运筹学练习Python精解——对策论(博弈)

练习-1

用图解法给出矩阵对策的混合策略均衡，其中赢得矩阵如下所示：

$$P = \begin{pmatrix} 2 & 4\\ 2 &3 \\ 3 & 2\\ -2 & 6 \end{pmatrix}$$

玩家1的策略有四钟，但玩家2的策略只有两种，因此我们可以通过图解法来解出玩家1在面对玩家2两种策略时的最优混合策略。
解题过程
Step 1: 设玩家2选择策略1的概率为$x$，选择策略2的概率为$1-x$。
对于玩家1选择第$i$中策略时，玩家1的期望收益为：

$$E_i = x \cdot a_{i1} + (1-x) \cdot a_{i2}$$

其中$a_{i1}$ 和$a_{i2}$ 分别为玩家1选择第$i$种策略行时，对应第1列和第2列的收益。
因此，4个方程为：

• 对于第1行：$E_1 = 2x + 4(1-x) = 2x + 4 - 4x = -2x + 4$
• 对于第2行：$E_2 = 2x + 3(1-x) = 2x + 3 - 3x = -x + 3$
• 对于第3行：$E_3 = 3x + 2(1-x) = 3x + 2 - 2x = x + 2$
• 对于第4行：$E_4 = -2x + 6(1-x) = -2x + 6 - 6x = -8x + 6$

Step 2: 绘制每个$E_i$ 的曲线

我们可以通过绘制这四个方程的曲线图来寻找它们的交点。每条曲线代表玩家1选择该行的期望收益，交点则代表可能的最优混合策略。

• $E_1 = -2x + 4$ （斜率为负，截距为4）
• $E_2 = -x + 3$ （斜率为负，截距为3）
• $E_3 = x + 2$ （斜率为正，截距为2）
• $E_4 = -8x + 6$ （斜率为负，截距为6）

Step 3: 找到上面四个收益最大值上方区域，然后找到该区域最小的收益取值点，就是混合策略点
通过计算或观察图形，从而确定玩家2在两种策略上的最优混合策略。随后，我们可以算出玩家1的最佳回应策略，以及博弈的最优解（即纳什均衡）。

import numpy as np
import matplotlib.pyplot as plt

# 定义玩家1选择策略1的概率范围
x = np.linspace(0, 1, 100)

# 计算每行的收益函数
y1 = -2 * x + 4  # 第一条线
y2 = -1 * x + 3  # 第二条线
y3 = x + 2       # 第三条线
y4 = -8 * x + 6  # 第四条线

# 找出每个x点的最大值（公共上方部分）
y_max = np.maximum(np.maximum(y1, y2), np.maximum(y3, y4))

# 绘制每条损益曲线
plt.plot(x, y1, label="Row 1: $E_1 = -2x + 4$")
plt.plot(x, y2, label="Row 2: $E_2 = -x + 3$")
plt.plot(x, y3, label="Row 3: $E_3 = x + 2$")
plt.plot(x, y4, label="Row 4: $E_4 = -8x + 6$")

# 绘制y=6和x=1的直线
plt.axhline(y=6, color='red', linestyle='--', label='$y=6$')
plt.axvline(x=1, color='blue', linestyle='--', label='$x=1$')

# 填充y=6, x=1 和最大值区域之间的绿色阴影
plt.fill_between(x, y_max, 6, where=(x <= 1), color='green', alpha=0.3, label="Shaded Region between $y=6$, $x=1$, and Max")

# 找到阴影部分的最小y点
y_min = np.min(y_max[y_max <= 6])  # 找到最大值曲线中小于等于6的最小y值
x_min_index = np.where(y_max == y_min)[0][0]  # 找到对应的x索引
x_min = x[x_min_index]

# 用红点标记最小的y点
plt.scatter(x_min, y_min, color='red', zorder=5, label=f'Min point at x={x_min:.2f}, y={y_min:.2f}')

# 绘制最小y值与x轴的虚线连线
plt.plot([x_min, x_min], [0, y_min], color='red', linestyle='--')

# 输出对应的x和y值，保留两位小数
print(f'The minimum y value is: {y_min:.2f}')
print(f'The corresponding x value is: {x_min:.2f}')

# 设置坐标轴标签和图例
plt.title('Graphical Solution with Green Shaded Region')
plt.xlabel('Probability of Player 1 choosing strategy 1 (x)')
plt.ylabel('Player 1 Payoff')

# 将图例放置左下角，并再缩小图例字体
plt.legend(loc='lower left', fontsize='x-small')
plt.grid(True)

# 显示图像
plt.show()

练习0

用图解法给出矩阵对策的混合策略均衡，其中赢得矩阵如下所示：

$$P = \begin{pmatrix} 2 & 3 &11 \\ 7 & 5 & 2 \end{pmatrix}$$

解题过程

• 列出每个玩家的支付函数：
  • 对于玩家A：假设他选择策略1的概率为$p$，则他选择策略2的概率为$1 - p$。
  • 对于玩家B：假设他选择策略1、策略2和策略3的概率分别为$q_1$,$q_2$ 和$q_3$。
• 写出玩家A和玩家B的期望收益函数
  玩家A的期望收益：
  • 当他选择策略1时，期望收益为$E_A = 2q_1 + 3q_2 + 11q_3$
  • 当他选择策略2时，期望收益为$E_A = 7q_1 + 5q_2 + 2q_3$
    玩家B的期望损失：
  • 当他选择策略1时，期望损失为$E_B = 2p + 7(1 - p)$
  • 当他选择策略2时，期望损失为$E_B = 3p + 5(1 - p)$
  • 当他选择策略3时，期望损失为$E_B = 11p + 2(1 - p)$
• 绘制图形：
  • 在$E_A$ 和$p$ 的坐标系中绘制玩家A的收益函数。
  • 找到这些函数的交点，确定最优概率$p$ 和$q$。

import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import linprog

# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False

# 定义支付矩阵
P = np.array([
    [2, 3, 11],
    [7, 5, 2]
])

# 构建图解法中的线性方程组
# 对于A的支付函数，绘制在E_A 和 p 的坐标系中
p = np.linspace(0, 1, 500)
A_payoff1 = 2 * p + 7 * (1 - p)
A_payoff2 = 3 * p + 5 * (1 - p)
A_payoff3 = 11 * p + 2 * (1 - p)

# 计算每个p值的最小支付
min_payoff = np.minimum(np.minimum(A_payoff1, A_payoff2), A_payoff3)

# 绘制图形
plt.plot(p, A_payoff1, label='2p + 7(1 - p)')
plt.plot(p, A_payoff2, label='3p + 5(1 - p)')
plt.plot(p, A_payoff3, label='11p + 2(1 - p)')
plt.fill_between(p, min_payoff, color='gray', alpha=0.3, label='最小值部分')

# 找到最小值区域中纵坐标最大的点
max_in_min_region_index = np.argmax(min_payoff)
p_star = p[max_in_min_region_index]
E_star = min_payoff[max_in_min_region_index]

plt.axvline(p_star, color='r', linestyle='--', label=f'p* = {p_star:.2f}')
plt.axhline(E_star, color='g', linestyle='--', label=f'E* = {E_star:.2f}')

# 添加标签和图例
plt.xlabel('p (玩家A选择策略1的概率)')
plt.ylabel('收益 (玩家A)')
plt.title('图解法求解混合策略均衡')
plt.legend()
plt.grid(True)
plt.show()

# 通过线性规划求解玩家A和玩家B的混合策略
c = [-1, -1, -1]  # 目标函数系数 (最小化负的混合策略)
A_ub = np.array([
    [2, 3, 11],
    [7, 5, 2]
])
b_ub = np.array([E_star, E_star])

result = linprog(c, A_ub=A_ub, b_ub=b_ub, bounds=(0, 1))

if result.success:
    q_star = result.x / np.sum(result.x)  # 归一化为概率
    q_star = np.round(q_star, 2)  # 保留两位小数
    print(f'玩家B的最优混合策略: q* = {q_star}')
else:
    print('线性规划未能找到最优解')

# 玩家A的混合策略
x_star = np.array([1 - p_star, p_star])
x_star = np.round(x_star, 2)  # 保留两位小数
print(f'玩家A的最优混合策略: x* = {x_star}')

E_star = round(E_star, 2)  # 保留两位小数
print(f'博弈的值 (E*) = {E_star}')

玩家B的最优混合策略: q* = [0.   0.82 0.18]
玩家A的最优混合策略: x* = [0.73 0.27]
博弈的值 (E*) = 4.45

练习1

已知矩阵对策的赢得矩阵为

$$\left[ {\begin{array}{*{20}{c}} 5&9\\ 8&6 \end{array}} \right]$$

试求其混合策略纳什均衡。

$$\begin{array}{*{20}{c}} {\begin{array}{*{20}{c}} {}&{{\beta _1}}&{{\beta _2}}&{} \end{array}}\\ {\begin{array}{*{20}{c}} {\begin{array}{*{20}{c}} {{\alpha _1}}\\ {{\alpha _2}} \end{array}}&{\left[ {\begin{array}{*{20}{c}} 5&9\\ 8&6 \end{array}} \right]}&{\begin{array}{*{20}{c}} x\\ {1 - x} \end{array}} \end{array}}\\ {\begin{array}{*{20}{c}} {}&y&{1 - y}&{} \end{array}} \end{array}$$

• 局中人1混合策略

$$V_{\beta1} = 5x + 8(1 - x) = 8 - 3x \quad V_{\beta2} = 9x + 6(1 - x) = 6 + 3x$$

联立上面方程，可解得$x=1/3$

• 局中人2赢得期望值

$$V_{\alpha1} = 5y + 9(1 - y) = 9 - 4y \quad V_{\alpha2} = 8y + 6(1 - y) = 6 + 2y$$

联立上面方程，可解得$y=1/2$

• 最优混合策略
  最优策略为$(x^*=1/3, y^*=1/2)$

import matplotlib.pyplot as plt
from matplotlib import rcParams

# 定义收益矩阵
A = np.array([[5, 9], [8, 6]])

# 定义变量
p = cp.Variable(2)  # 玩家1的混合策略
q = cp.Variable(2)  # 玩家2的混合策略

# 约束条件
constraints = [
    p >= 0,
    cp.sum(p) == 1,
    q >= 0,
    cp.sum(q) == 1,
    p @ A[:, 0] == p @ A[:, 1],  # 玩家1对两个策略的期望收益相等
    q @ A[0, :] == q @ A[1, :]   # 玩家2对两个策略的期望收益相等
]

# 定义问题
problem = cp.Problem(cp.Maximize(0), constraints)

# 求解问题
problem.solve()

# 获取结果
p1, p2 = p.value
q1, q2 = q.value

print("玩家1的混合策略：")
print(f"p1 = {p1:.2f}, p2 = {p2:.2f}")

print("玩家2的混合策略：")
print(f"q1 = {q1:.2f}, q2 = {q2:.2f}")
# 绘制直线图
x = np.linspace(0, 1, 100)
y1 = 5 * x + 8 * (1 - x)
y2 = 9 * x + 6 * (1 - x)

plt.plot(x, y1, label='y1 = 5 * x + 8 * (1 - x)')
plt.plot(x, y2, label='y2 = 9 * x + 6 * (1 - x)')
plt.axvline(p1, color='r', linestyle='--', label='均衡点')

plt.xlabel('p1的概率')
plt.ylabel('期望收益')
plt.title('玩家1的混合策略均衡点')
plt.legend()
plt.grid(True)
plt.show()

练习2

甲乙两国进行乒乓球团体赛，每国由三个人组成一个队参加比赛。甲国的人员根据不同的组合可组成4个队，乙国的人员可组成3个队。根据以往的比赛记录，已知各种组成队法相遇后甲国的得分如下表所示：

甲\乙	1队	2队	3队
1队	-5	1	-7
2队	3	2	4
3队	8	-1	-8
4队	-2	-1	6

问双方应各派哪个队上场是最优决策？

import numpy as np

# 定义收益矩阵
A = np.array([
    [-5, 1, -7],
    [3, 2, 4],
    [8, -1, -8],
    [-2, -1, 6]
])

# 初始化存储纳什均衡的列表
nash_equilibria = []

# 遍历所有可能的策略组合
for i in range(A.shape[0]):  # 甲的策略
    for j in range(A.shape[1]):  # 乙的策略
        # 甲的当前策略得分
        payoff_1 = A[i, j]
        
        # 甲对乙的固定策略 j 下的最佳回应策略
        best_response_1 = np.max(A[:, j])
        
        # 乙对甲的固定策略 i 下的最佳回应策略（取相反数）
        best_response_2 = np.min(A[i, :])
        
        # 如果当前策略组合是最佳回应策略，则它是一个纳什均衡
        if payoff_1 == best_response_1 and payoff_1 == best_response_2:
            nash_equilibria.append((i+1, j+1))

# 输出纳什均衡
print("纯策略纳什均衡：")
for eq in nash_equilibria:
    print(f"甲的策略: {eq[0]} 队, 乙的策略: {eq[1]} 队")
#纯策略纳什均衡：甲的策略: 2 队, 乙的策略: 2 队

练习3

已知矩阵的赢得矩阵如下，试用线性方程组法求最优混合策略及博弈值。

$$\begin{bmatrix} 2 & 2 & 6 \\ 2 & 10 & 2 \\ 8 & 2 & 2 \\ \end{bmatrix}$$

将矩阵中各元素减去2得到新的矩阵$A - 2$：

$$A - 2 = \begin{bmatrix} 0 & 0 & 4 \\ 0 & 8 & 0 \\ 6 & 0 & 0 \\ \end{bmatrix}$$

接着，我们构建线性方程组：

$$\begin{cases} x_1 + x_2 + x_3 = 1 \\ 4x_1= V \\ 8x_2 = V \\ 6x_3 = V \end{cases} \quad \quad \begin{cases} y_1 + y_2 + y_3 = 1 \\ 6y_1 = V \\ 8y_2 = V \\ 4y_3 = V \end{cases}$$

解得最优混合策略为$X^* = (6/13, 3/13, 4/13)$和$Y^* = (4/13, 3/13, 6/13)$，博弈值为$V = 50/13$。

import cvxpy as cp
import numpy as np

# 定义赢得矩阵
A = np.array([
    [2, 2, 6],
    [2, 10, 2],
    [8, 2, 2]
])

# 玩家1的最优混合策略
p = cp.Variable(3)
v1 = cp.Variable()

# 玩家1的约束条件
constraints1 = [
    p >= 0,
    cp.sum(p) == 1,
    A.T @ p >= v1
]

# 玩家1的目标函数
objective1 = cp.Maximize(v1)

# 定义问题
problem1 = cp.Problem(objective1, constraints1)

# 求解问题
problem1.solve()

# 获取玩家1的结果
p_value = p.value
game_value_1 = v1.value

print("玩家1的最优混合策略：")
for i, prob in enumerate(p_value):
    print(f"策略 {i+1}: {prob:.4f}")

print(f"博弈值 (玩家1): {game_value_1:.4f}")

# 玩家2的最优混合策略
q = cp.Variable(3)
v2 = cp.Variable()

# 玩家2的约束条件
constraints2 = [
    q >= 0,
    cp.sum(q) == 1,
    A @ q <= v2
]

# 玩家2的目标函数
objective2 = cp.Minimize(v2)

# 定义问题
problem2 = cp.Problem(objective2, constraints2)

# 求解问题
problem2.solve()

# 获取玩家2的结果
q_value = q.value
game_value_2 = v2.value

print("玩家2的最优混合策略：")
for i, prob in enumerate(q_value):
    print(f"策略 {i+1}: {prob:.4f}")

print(f"博弈值 (玩家2): {game_value_2:.4f}")

# 验证博弈值是否一致
if np.isclose(game_value_1, game_value_2):
    print(f"博弈值 (一致): {game_value_1:.4f}")
else:
    print("博弈值不一致，可能存在误差。")

玩家1的最优混合策略：
策略 1: 0.4615
策略 2: 0.2308
策略 3: 0.3077
博弈值 (玩家1): 3.8462
玩家2的最优混合策略：
策略 1: 0.3077
策略 2: 0.2308
策略 3: 0.4615
博弈值 (玩家2): 3.8462
博弈值 (一致): 3.8462

练习4

甲、乙两方交战。乙方用三个师守城，有两条公路通入该城，甲方用两个师攻城。甲方可能两个师各走一条公路，也可能从一条公路进攻。乙方可用三个师防守某一条公路，也可用两个师防守一条公路，用第三个师防守另一条公路。哪方军队在一条公路上数量多，哪方军队就控制住这条公路：如果双方在同一条公路上的数量相同，则乙方控制住公路和甲方攻入城的机会各半。

• 博弈模型构建

  • 设两条路为A, B。
  • 甲方攻城的策略集为：2A, AB, 2B。
  • 乙方守城的策略集为：3A, 2AB, A2B, 3B。

• 甲方的赢得矩阵为：

$$A = \begin{pmatrix} 0 & 0.5 & 1 & 1 \\ 1 & 0.5 & 0.5 & 1 \\ 1 & 1 & 0.5 & 0 \end{pmatrix}$$

• 线性方程组

$$\begin{cases} x_2 + x_3 = v \\ 0.5x_1 + 0.5x_2 + x_3 = v \\ x_1 + 0.5x_2+0.5x_3 = v \\ x_1 + x_2 =v\\ x_1 + x_2 + x_3 = 1 \end{cases} \quad \quad \begin{cases} 0.5y_2 + y_3 + y_4 = v \\ y_1 + 0.5y_2 + 0.5y_3 + y_4 = v \\ y_1 + y_2 + 0.5y_3 = v \\ y_1 + y_2 + y_3 + y_4 = 1 \end{cases}$$

• 解得结果
  • 甲方最优策略 $x^* = (1/3, 1/3, 1/3)$，即甲方均以1/3的概率选择三个策略。
  • 乙方最优策略$y^* = (1/6, 1/3, 1/3, 1/6)$
  • 甲方攻入城的可能性$V = 2/3$
• 结论
  甲方以1/3的概率取两个师同守第一条路，各走一条路及同守第二条路。攻入城的机会为2/3。乙方则以1/6, 1/3, 1/3, 1/6的概率取三个师同守第一条路，两师守第一条路和一师守第二条路，一师守第一条路和两师守第二条路，以及三个师同守第二条路。

import cvxpy as cp
import numpy as np

# 定义赢得矩阵
A = np.array([
    [0, 0.5, 1, 1],
    [1, 0.5, 0.5, 1],
    [1, 1, 0.5, 0]
])

# 玩家1 (甲) 的混合策略变量
p = cp.Variable(3)
v1 = cp.Variable()

# 玩家1 (甲) 的约束条件
constraints1 = [
    p >= 0,
    cp.sum(p) == 1,
    A.T @ p >= v1
]

# 玩家1 (甲) 的目标函数
objective1 = cp.Maximize(v1)

# 定义问题
problem1 = cp.Problem(objective1, constraints1)

# 求解问题
problem1.solve()

# 获取玩家1 (甲) 的结果
p_value = p.value
game_value_1 = v1.value

print("甲的最优混合策略：")
for i, prob in enumerate(p_value):
    print(f"策略 {i+1}: {prob:.4f}")

print(f"博弈值 (甲): {game_value_1:.4f}")

# 玩家2 (乙) 的混合策略变量
q = cp.Variable(4)
v2 = cp.Variable()

# 玩家2 (乙) 的约束条件
constraints2 = [
    q >= 0,
    cp.sum(q) == 1,
    A @ q <= v2
]

# 玩家2 (乙) 的目标函数
objective2 = cp.Minimize(v2)

# 定义问题
problem2 = cp.Problem(objective2, constraints2)

# 求解问题
problem2.solve()

# 获取玩家2 (乙) 的结果
q_value = q.value
game_value_2 = v2.value

print("乙的最优混合策略：")
for i, prob in enumerate(q_value):
    print(f"策略 {i+1}: {prob:.4f}")

print(f"博弈值 (乙): {game_value_2:.4f}")

# 验证博弈值是否一致
if np.isclose(game_value_1, game_value_2):
    print(f"博弈值 (一致): {game_value_1:.4f}")
else:
    print("博弈值不一致，可能存在误差。")

甲的最优混合策略：
策略 1: 0.3333
策略 2: 0.3333
策略 3: 0.3333
博弈值 (甲): 0.6667
乙的最优混合策略：
策略 1: 0.1667
策略 2: 0.3333
策略 3: 0.3333
策略 4: 0.1667
博弈值 (乙): 0.6667
博弈值 (一致): 0.6667

练习5

某企业有甲、乙两个公司，每年的税额分别是 400 万元和 1200 万元。对于每个公司，企业可以如实申报税款，或者篡改账目，称税额为零。而国家税务局由于人力所限，对该企业每年只能检查一个公司的账目。如果税务局发现有偷税现象，则该公司不仅要如数缴纳税款，而且将被处以相当于一半税款的罚金。问题要求：(1)将此问题写成一个矩阵博弈模型，并求出税务局和企业的最优策略及税务局从该企业收到的平均税款（含罚金）。(2)税务局应将罚金提高到税款的多少倍，才能迫使该企业不敢漏税？

• 分析建立矩阵博弈模型
  • 企业的策略：如实申报甲、乙公司的税款；篡改甲公司的账目，如实申报乙公司的账目；如实申报甲公司的账目，篡改乙公司的账目；篡改甲、乙公司的账目
  • 税务局的策略：检查甲公司的账目；检查乙公司的账目
• 收益矩阵
  • 如果企业如实申报，不管税务局检查哪家公司，企业需要缴纳的税款为 1600 万元。
  • 如果企业篡改甲公司的账目（税额为零），如实申报乙公司的账目，则税务局检查甲公司会导致企业被罚款 400 万元的一半（200 万元），加上追缴的税款 400 万元，加上乙公司的税款 1200 万元，总计 1800 万元。
  • 企业如果如实申报甲公司的账目，篡改乙公司的账目（税额为零），税务局检查乙公司会导致企业被罚款 1200 万元的一半（600 万元），加上追缴的税款 1200 万元，加上甲公司的税款 400 万元，总计 2200 万元。等等。

解：(1) 税务局有两个策略：查甲公司和查乙公司。企业有 4 个策略：(T,T),(F,F),(T,F),F,T），其中 $\mathrm{T}$ 表示如实申报, $\mathrm{F}$ 表示偷税, 括号内的一对字母依次表示公司甲和乙的做法。例如(T,F)表示公司甲如实申报, 公司乙偷税。下表给出税务局从该企业征收的税款和罚金之和, 这是一个有限二人零和博弈。

税务局\企业	$$(\mathrm{T}, \mathrm{T})$$	$$(\mathrm{F}, \mathrm{F})$$	$$(\mathrm{T}, \mathrm{F})$$	$$(\mathrm{F}, \mathrm{T})$$
查甲	16	6	4	18
查乙	16	18	22	12

这个博弈没有鞍点。考虑下述线性规划:

$$\begin{align*} \text{maximize} \quad & u \\ \text{subject to} \quad & \begin{aligned} 16x_1 + 16x_2 &\geq u \\ 6x_1 + 18x_2 &\geq u \\ 4x_1 + 22x_2 &\geq u \\ 18x_1 + 12x_2 &\geq u \\ x_1 + x_2 &= 1 \\ x_1, x_2 &\geq 0 \end{aligned} \end{align*}$$

解得: $u=14, x_1{ }^*=1 / 3, x_2{ }^*=2 / 3$
再考虑:

$$\begin{aligned} & 16 y_1+6 y_2+4 y_3+18 y_4=14 \\ & y_1+y_2+y_3+y_4=1 \end{aligned}$$

由于 $\mathrm{x}=\left(\mathrm{x}_1{ }^*, \mathrm{x}_2{ }^*\right)$ 处, 线性规划中第 1 和第 3 个约束为:

$$\begin{aligned} & 16 \mathrm{x}_1{ }^*+16 \mathrm{x}_2{ }^*=16>\mathrm{u} \\ & 4 \mathrm{x}_1{ }^*+22 \mathrm{x}_2{ }^*=16>\mathrm{u} \end{aligned}$$

故 $\mathrm{y}_1{ }^*=0, \mathrm{y}_3{ }^*=0$, 解得: $\mathrm{y}_2{ }^*=1 / 3, \mathrm{y}_4{ }^*=2 / 3$
所以, 当罚金是税款的一半时, 税务局的最优策略是以 $1 / 3$ 的概率检查公司甲, 以 $2 / 3$ 的概率检查公司乙。而企业的最优策略是以 $1 / 3$ 的概率让两个公司都偷税, 以 $2 / 3$ 的概率让公司甲偷税, 公司乙如实申报税款。这样企业上缴的税款和罚金之和的平均值是 1400 万元。

（2）设罚金是应交税款的 $\mathrm{a}$ 倍, 令 $\mathrm{k}=\mathrm{a}+1$, 税务局从该企业收得的税收与罚金之和如下表:

企业 / 税务局	$$(\mathrm{T}, \mathrm{T})$$	$$(\mathrm{F}, \mathrm{F})$$	$$(\mathrm{T}, \mathrm{F})$$	$$(\mathrm{F}, \mathrm{T})$$
查甲	16	4k	4	4k+12
查乙	16	12k	4+12k	12

考虑线性规划:

$$\begin{array}{ll} \min & x_1{ }^{\prime}+x_2{ }^{\prime} \\ \text { s.t. } & 16 x_1{ }^{\prime}+16 x_2{ }^{\prime} \geq 1 \\ & 4 k x_1{ }^{\prime}+12 k x_2{ }^{\prime} \geq 1 \\ & 4 x_1{ }^{\prime}+(4+12 k) x_2{ }^{\prime} \geq 1 \\ & (4 k+12) x_1{ }^{\prime}+12 x_2{ }^{\prime} \geq 1 \\ & x_1{ }^{\prime}, x_2{ }^{\prime} \geq 0 \end{array}\quad \quad \begin{array}{ll} \max & y_1{ }^{\prime}+y_2{ }^{\prime}+y_3{ }^{\prime}+y_4{ }^{\prime} \\ \text { s.t. } & 16 y_1{ }^{\prime}+4 k y_2{ }^{\prime}+4 y_3{ }^{\prime}+(4 k+12) y_4{ }^{\prime} \leq 1 \\ & 16 y_1{ }^{\prime}+12 y_2{ }^{\prime}+(4+12 k) y_3{ }^{\prime}+12 y_4{ }^{\prime} \leq 1 \\ & y_j{ }^{\prime} \geq 0 \quad j=1,2,3,4 \end{array}$$

用单纯形法解上式, 经过计算得到下表:

$\mathrm{C}_{\mathrm{B}}$	$\mathrm{Y}_{\mathrm{B}}$	$\mathrm{b}$	$\mathrm{y}_1{ }^{\prime}$	$\mathrm{y}_2{ }^{\prime}$	$\mathrm{y}_3{ }^{\prime}$	$\mathrm{y}_4{ }^{\prime}$	$\mathrm{z}_1{ }^{\prime}$	$\mathrm{z}_2{ }^{\prime}$
1	$\mathrm{y}_1{ }^{\prime}$	$1 / 16$	1	$\mathrm{k} / 4+1 / 6$	0	$\mathrm{k} / 4+5 / 6$	$1 / 6+1 / 48 \mathrm{k}$	$1 / 48 \mathrm{k}$
1	$\mathrm{y}_3{ }^{\prime}$	0	0	$2 / 3$	1	$-1 / 3$	$-1 / 12 \mathrm{k}$	$1 / 12$
$\sigma_j$			0	$1 / 2-\mathrm{k} / 4$	0	$1 / 2-\mathrm{k} / 4$	$1 / 16 \mathrm{k}-1 / 6$	$-1 / 16 \mathrm{k}$

企业不敢漏税相当于只能采用策略(T, T), 即 $\mathrm{y}_1{ }^*=1, \mathrm{y}_2{ }^*=0, \mathrm{y}_3{ }^*=0, \mathrm{y}_4{ }^*=0$, 由上表, 只须 $1 / 2-k / 4 \leqslant 0$, 即 $k \geqslant 2$, 得 $a \geqslant 1$, 故为了使企业不敢偷税, 应规定罚金不少于应缴税款。

我们引入变量$v_A$ 表示玩家A的期望收益，引入变量$v_B$表示玩家B的期望收益，然后构建以下线性规划问题：

$$\begin{array}{cc} \begin{array}{ll} \text{Maximize} \quad v_B \\ \text{subject to} & \\ p_1 \cdot 16 + p_2 \cdot 16 \geq v_B \\ p_1 \cdot 6 + p_2 \cdot 18 \geq v_B \\ p_1 \cdot 4 + p_2 \cdot 22 \geq v_B \\ p_1 \cdot 18 + p_2 \cdot 12 \geq v_B \\ p_1 + p_2 = 1 \\ p_1, p_2 \geq 0 \end{array} & \quad \quad \begin{array}{ll} \text{Minimize} \quad v_A \\ \text{subject to} & \\ q_1 \cdot 16 + q_2 \cdot 6 + q_3 \cdot 4 + q_4 \cdot 18 \leq v_A \\ q_1 \cdot 16 + q_2 \cdot 18 + q_3 \cdot 22 + q_4 \cdot 12 \leq v_A \\ q_1 + q_2 + q_3 + q_4 = 1 \\ q_1, q_2, q_3, q_4 \geq 0 \end{array} \end{array}$$

#https://www.renrendoc.com/paper/204906273.html
import pulp

# 创建玩家B的线性规划问题（最大化问题）
lp_problem_B = pulp.LpProblem("Maximize_vB", pulp.LpMaximize)

# 定义玩家B的变量
v_B = pulp.LpVariable("v_B")
p1 = pulp.LpVariable("p1", lowBound=0, upBound=1)
p2 = pulp.LpVariable("p2", lowBound=0, upBound=1)

# 添加玩家B的目标函数
lp_problem_B += v_B, "Objective_B"

# 添加玩家B的不等式约束
lp_problem_B += 16 * p1 + 16 * p2 >= v_B
lp_problem_B += 6 * p1 + 18 * p2 >= v_B
lp_problem_B += 4 * p1 + 22 * p2 >= v_B
lp_problem_B += 18 * p1 + 12 * p2 >= v_B

# 添加玩家B的等式约束
lp_problem_B += p1 + p2 == 1

# 求解玩家B的问题
lp_problem_B.solve()

# 输出玩家B的结果
if pulp.LpStatus[lp_problem_B.status] == 'Optimal':
    print(f"玩家B的最小期望收益: v_B = {pulp.value(v_B):.2f}")
    print(f"玩家B的混合策略: p1 = {pulp.value(p1):.2f}, p2 = {pulp.value(p2):.2f}")
else:
    print("玩家B的混合策略未找到")

# 创建玩家A的线性规划问题（最大化问题）
lp_problem_A = pulp.LpProblem("Minimize_vA", pulp.LpMinimize)

# 定义玩家A的变量
v_A = pulp.LpVariable("v_A")
q1 = pulp.LpVariable("q1", lowBound=0)
q2 = pulp.LpVariable("q2", lowBound=0)
q3 = pulp.LpVariable("q3", lowBound=0)
q4 = pulp.LpVariable("q4", lowBound=0)

# 添加玩家A的目标函数
lp_problem_A += v_A, "Objective_A"

# 添加玩家A的不等式约束
lp_problem_A += 16 * q1 + 6 * q2 + 4 * q3 + 18 * q4 <= v_A
lp_problem_A += 16 * q1 + 18 * q2 + 22 * q3 + 12 * q4 <= v_A

# 添加玩家A的等式约束
lp_problem_A += q1 + q2 + q3 + q4 == 1

# 求解玩家A的问题
lp_problem_A.solve()

# 输出玩家A的结果
if pulp.LpStatus[lp_problem_A.status] == 'Optimal':
    print(f"玩家A的最小期望收益: v_A = {pulp.value(v_A):.2f}")
    print(f"玩家A的混合策略: q1 = {pulp.value(q1):.2f}, q2 = {pulp.value(q2):.2f}, q3 = {pulp.value(q3):.2f}, q4 = {pulp.value(q4):.2f}")
else:
    print("玩家A的混合策略未找到")

玩家B的最小期望收益: v_B = 14.00
玩家B的混合策略: p1 = 0.33, p2 = 0.67
玩家A的最小期望收益: v_A = 14.00
玩家A的混合策略: q1 = 0.00, q2 = 0.33, q3 = 0.00, q4 = 0.67

练习6

假设甲乙双方交战。甲方派两架轰炸机 $\mathrm{H}_1$ 和 $\mathrm{H}_2$ 去轰炸乙方阵地。 $\mathrm{H}_1$ 飞在前面, $\mathrm{H}_2$ 飞在后面, 其中一架带炸弹, 另一架保护; 乙方派一架驱逐机 $\mathrm{q}$ 进行阻截。如果 $\mathrm{q}$ 攻击 $\mathrm{H}_1$, 则将遇到 $\mathrm{H}_1$ 和 $\mathrm{H}_2$ 的还击; 如果 $\mathrm{q}$ 攻击 $\mathrm{H}_2$, 则只遭到 $\mathrm{H}_2$ 的还击, $\mathrm{H}_1$ 无能为力。 $\mathrm{H}_1$ 和 $\mathrm{H}_2$ 的炮火装置一样, 它们击毁 $\mathrm{q}$ 的概率都是 $\mathrm{p}_1=0.4$; 而 $\mathrm{q}$ 在未被击中的条件下, 击毁 $\mathrm{H}_1$ 和 $\mathrm{H}_2$ 的概率均为 $\mathrm{p}_2=0.9$ 。试求双方的最优策略。
解 建立博弈模型。显然局中人为交战双方。双方的策略集分别为

$$\begin{aligned} & \mathrm{S}_{\mathbb{1}}=\left\{a_1\left(\mathrm{H}_1 \text { 带炸弹 }\right),\quad a_2\left(\mathrm{H}_2 \text { 带炸弹 }\right)\right\} \\ & \mathrm{S}_2=\left\{\beta_1\left(\mathrm{q} \text { 攻击 } \mathrm{H}_1\right),\quad \beta_2\left(\mathrm{q} \text { 攻击 } \mathrm{H}_2\right)\right\} \end{aligned}$$

下面求甲方的支付矩阵。据题意, 只要甲方的带弹机不被乙方击中就可实现甲方的目的。所以, 我们以甲方的带弹机不被击中的概率为甲方的赢得矩阵收益 $\mathrm{A}=\left(\mathrm{a}_{\mathrm{ij}}\right)_{2 \times 2}$ 。下面分别计算。
$\mathrm{a}_{11}$ 这时甲方 $\mathrm{H}_1$ 带弹, 乙方攻击 $\mathrm{H}_1$ 。由于 $\mathrm{H}_1$ 未被击中的概率等于 $\mathrm{q}$ 被击毁的概率与 $\mathrm{q}$ 虽未炸机均未击中 $\mathrm{q}$ 的概率, 所以

$$\begin{aligned} a_{11} & =\left[1-\left(1-p_1\right)^2\right]+\left(1-p_1\right)^2\left(1-p_2\right) \\ & =\left[1-(1-0.4)^2\right]+(1-0.4)^2(1-0.9) \\ & =0.676 \end{aligned}$$

$a_{12}$ 这时甲方 $H_1$ 带弹, 乙方攻击 $H_2$, 所以 $H_1$ 肯定不会被击中, 从而 $a_{12}=1$ 。
$a_{21}$ 这时甲方 $H_2$ 带弹, 乙方攻击 $H_1$, 所以 $H_2$ 肯定不会被击中, 从而 $a_{21}=1$ 。
$\mathrm{a}_2$ 这时甲方 $\mathrm{H}_2$ 带弹, 乙方攻击 $\mathrm{H}_2, \mathrm{H}_2$ 未被击中的概率等于 $\mathrm{q}$ 被击毁的概率与 $\mathrm{q}$ 虽未被击毁但也未击中 $\mathrm{H}_2$ 的概率之和, 所以

$$\begin{aligned} a_{22} & =p_1+\left(1-p_1\right)\left(1-p_2\right) \\ & =0.4+(1-0.4)(1-0.9) \\ & =0.46 \end{aligned}$$

建立矩阵对策模型，这是 $2\times 2$ 矩阵对策。解之, 得

$$\begin{aligned} & x^*=(0.625,0.375) \\ & y^*=(0.625,0.375) \\ & v=0.798 \end{aligned}$$

结果表明, 当这一对策多次重复进行时, 甲方应以 $62.5 \%$ 的次数让 $H_1$ 带弹, $37.5 \%$ 的次数让 $H_2$ 带弹,这时甲方将有 $79.8 \%$ 的次数能击毁乙方的阵地。而乙方为了不受到更大损失，应分别以 $62.5 \%$ 和 $37.5 \%$的次数攻击 $\mathrm{H}_1$ 和 $\mathrm{H}_2$ 。

import pulp

# 支付矩阵
A = [
    [0.676, 1],
    [1, 0.46]
]

# 甲方的线性规划问题
prob_A = pulp.LpProblem("MaxMin", pulp.LpMaximize)
v = pulp.LpVariable("v")
x1 = pulp.LpVariable("x1", lowBound=0)
x2 = pulp.LpVariable("x2", lowBound=0)

# 目标函数
prob_A += v

# 约束条件
prob_A += 0.676 * x1 + 1 * x2 >= v
prob_A += 1 * x1 + 0.46 * x2 >= v
prob_A += x1 + x2 == 1

# 求解
prob_A.solve()

print("甲方的最优混合策略：")
for v in prob_A.variables():
    if v.name != 'v':
        print(f"{v.name} = {v.varValue}")

print("博弈的值：", pulp.value(prob_A.objective))

# 乙方的线性规划问题
prob_B = pulp.LpProblem("MinMax", pulp.LpMinimize)
w = pulp.LpVariable("w")
y1 = pulp.LpVariable("y1", lowBound=0)
y2 = pulp.LpVariable("y2", lowBound=0)

# 目标函数
prob_B += w

# 约束条件
prob_B += 0.676 * y1 + 1 * y2 <= w
prob_B += 1 * y1 + 0.46 * y2 <= w
prob_B += y1 + y2 == 1

# 求解
prob_B.solve()

print("乙方的最优混合策略：")
for v in prob_B.variables():
    if v.name != 'w':
        print(f"{v.name} = {v.varValue}")

print("博弈的值：", pulp.value(prob_B.objective))

甲方的最优混合策略：
x1 = 0.625
x2 = 0.375
博弈的值： 0.7975
乙方的最优混合策略：
y1 = 0.625
y2 = 0.375
博弈的值： 0.7975