博弈论与AI

关键词

术语	英文	核心概念
博弈论	Game Theory	研究策略交互的数学框架
参与人	Player	博弈中的决策主体
策略	Strategy	参与人可选择的行动集合
收益函数	Payoff Function	策略组合对应的收益数值
占优策略	Dominant Strategy	无论对手如何选择都是最优的策略
Nash均衡	Nash Equilibrium	所有参与人都无法单方面获利的状态
零和博弈	Zero-Sum Game	一方所得必为另一方所失的博弈
混合策略	Mixed Strategy	以概率分布选择纯策略
纳什求解器	Nash Solver	计算博弈均衡的算法
机制设计	Mechanism Design	设计激励相容的规则

---

博弈论与AI：从囚徒困境到多智能体协作

你知道为什么淘宝商家会在双十一打价格战吗？为什么自动驾驶汽车需要”学会”预测其他车辆的意图？为什么Facebook的广告定价能让它赚得盆满钵满？

这些看似毫不相关的问题，背后都有一个共同的数学框架在支撑——博弈论。

博弈论不是那种高深莫测、离日常生活很远的理论。实际上，它描述的正是我们每天都在经历的事情：在不确定别人会怎么做的情况下，我们如何做出最优决策。

这篇文章会带你从零开始理解博弈论的核心概念，更重要的是，你会发现它如何彻底改变了人工智能的设计思路。当AI系统不再只是被动地执行指令，而是需要和其他AI、或者和人类”斗智斗勇”时，博弈论就成了必备的分析工具。

---

1. 博弈论入门：用囚徒困境看透博弈的本质

1.1 囚徒困境：不只是警察审嫌疑犯的故事

博弈论最经典的例子就是囚徒困境。这个故事你可能听过：

两个小偷张三和李四作案后被抓，警察把他们分开审讯。每个人面前都摆着同样的选择：坦白或者沉默。

收益是这样的：如果两人都沉默，各自坐牢1年（因为证据不足）；如果一人坦白一人沉默，坦白的直接释放，沉默的要坐牢4年；如果两人都坦白，各坐牢3年。

用表格画出来就是这样：

	李四沉默	李四坦白
张三沉默	-1, -1	-4, 0
张三坦白	0, -4	-3, -3

（数字是坐牢年数，所以负数代表”损失”，两个数字分别是张三和李四的收益）

这个故事精彩的地方在于：对两个人来说，最好的选择明明是两人都沉默（总共只坐2年牢），但最后两人都会选择坦白。

为什么？因为站在张三的角度：

• 如果李四沉默，张三坦白（0年）比沉默（-1年）好
• 如果李四坦白，张三坦白（-3年）比沉默（-4年）好

无论李四怎么选，坦白对张三都是更好的选择。坦白就是张三的”占优策略”——不管对手怎么出牌，这招都是最优的。

同样的逻辑对李四也成立。于是两个”理性人”最终都选择了坦白，结果是各坐3年牢——虽然不是最糟的，但明明可以更好的。

这个故事道出了博弈论最核心的洞见：个人理性不等于集体理性。每个人都做了对自己最优的选择，结果却是整体次优的。

1.2 真实世界的囚徒困境

囚徒困境绝不只是书斋里的智力游戏，它无处不在：

军备竞赛就是经典的囚徒困境。两国都可以选择”裁军”或”扩军”。如果双方都裁军，世界和平，两国都能把资源用于发展经济。但如果一方扩军一方裁军，扩军的那方就能获得战略优势。于是双方都会选择扩军，陷入无休止的军备竞赛。

广告投放也是囚徒困境。同一个行业的两家公司，比如可口可乐和百事可乐，都有”打广告”和”不打广告”的选择。如果都不打广告，两家都能省下巨额广告费。但如果一家打广告另一家不打，打广告的那家就会抢走大量市场份额。于是两家公司都会拼命打广告，利润都被广告商赚走了。

碳排放问题更是全球级的囚徒困境。每个国家都可以选择”减排”或”继续排放”。如果其他国家减排，某个国家继续排放就能获得工业优势；如果其他国家继续排放，这个国家减排也挡不住全球变暖。结果是谁都没有动力减排。

理解了囚徒困境，你就理解了为什么很多事情”明明对大家都好，却就是做不到”——因为它触及了理性决策的深层矛盾。

1.3 博弈的构成要素

一个标准博弈包含以下几个要素：

• 参与人（Player）：做出决策的主体，可以是人、公司、国家，甚至是AI智能体
• 策略空间（Strategy Space）：每个参与人所有可能的选择
• 收益函数（Payoff Function）：给定所有参与人的选择后，每个参与人获得的收益
• 信息结构（Information Structure）：参与人在做决策时知道什么

把这些要素用数学符号写出来，就是：

$$\Gamma =(N,(A_i{)}_{i\in N},(u_i{)}_{i\in N})$$

其中 $N$ 是参与人集合，$A_i$ 是第 $i$ 个人的策略空间，$u_i$ 是他的收益函数。

import numpy as np
from itertools import product
 
class NormalFormGame:
    """
    标准式博弈（Normal Form Game）表示
    
    博弈要素：
    - 参与人集合
    - 每个参与人的策略空间
    - 每个参与人的收益矩阵
    """
    
    def __init__(self, players, strategy_spaces, payoff_matrices):
        """
        参数:
            players: 参与人列表
            strategy_spaces: 各参与人的策略空间
            payoff_matrices: 各参与人的收益矩阵（numpy数组）
        """
        self.players = players
        self.strategy_spaces = strategy_spaces
        self.payoff_matrices = payoff_matrices
    
    def get_payoff(self, action_profile):
        """给定行动剖面，获取各参与人的收益"""
        rewards = []
        for i, player in enumerate(self.players):
            rewards.append(self._get_nested_value(self.payoff_matrices[i], action_profile, i))
        return rewards
    
    def _get_nested_value(self, matrix, action_profile, player_idx):
        """从嵌套矩阵中获取值"""
        idx = [action_profile[j] for j in range(len(action_profile)) if j != player_idx]
        return matrix[tuple(idx)]
    
    def best_response(self, player_idx, opponent_actions):
        """
        计算参与人的最优响应
        
        给定其他参与人的行动，选择能够最大化自身收益的行动
        """
        my_strategy_space = self.strategy_spaces[player_idx]
        best_action = 0
        best_payoff = float('-inf')
        
        for my_action in range(len(my_strategy_space)):
            action_profile = list(opponent_actions) + [my_action]
            payoff = self.get_payoff(action_profile)[player_idx]
            if payoff > best_payoff:
                best_payoff = payoff
                best_action = my_action
        
        return best_action, best_payoff
 
# 囚徒困境博弈示例
def create_prisoners_dilemma():
    """创建囚徒困境博弈"""
    players = ["囚徒A", "囚徒B"]
    # 0 = 沉默, 1 = 背叛
    strategy_spaces = [["沉默", "背叛"], ["沉默", "背叛"]]
    # 收益矩阵：[坦白者收益, 沉默者收益]
    # 囚徒A的收益矩阵
    payoff_A = np.array([[-1, -4], [0, -3]])  # 行=囚徒A的选择, 列=囚徒B的选择
    # 囚徒B的收益矩阵（对称）
    payoff_B = np.array([[-1, 0], [-4, -3]])
    
    return NormalFormGame(players, strategy_spaces, [payoff_A, payoff_B])

---

2. 博弈的分类：合作/非合作、完全信息/不完全信息

2.1 合作还是非合作？

博弈论首先把博弈分成两大类：合作博弈和非合作博弈。

非合作博弈里，参与人各自为战，每个人只管自己能得到什么。“囚徒困境”就是典型的非合作博弈——两个囚徒不能互相串通，只能自己做决定。

合作博弈则假设参与人可以形成联盟、签订有约束力的协议。比如工会和公司谈判，工会代表所有工人整体谈条件，这时候分析的就是如何分配联盟获得的收益。

对AI来说，最常用的还是非合作博弈的框架。因为AI智能体之间通常没有”合同”约束，更多的是竞争或者松散的合作关系。

2.2 完全信息还是不完全信息？

这是另一个重要维度。

完全信息博弈里，每个参与人都知道博弈的结构——收益矩阵、规则、对手可能的策略，大家都是”明牌”打。比如下棋就是完全信息博弈，你能看到棋盘上所有棋子的位置，对手也能看到。

不完全信息博弈则相反，参与人对收益结构有不确定性。比如拍卖时，你不知道其他竞标者愿意出多少钱；谈判时，你不知道对方的底线在哪里。不完全信息博弈需要引入贝叶斯分析——每个参与人对其他人的类型有一个先验概率分布。

现实世界中的博弈几乎都是不完全信息的。我们不知道竞争对手的研发进展，不知道合作方到底有多大的诚意，也不知道对手在虚张声势还是真有实力。

2.3 静态还是动态？

静态博弈里，所有参与人同时做决定——或者更准确地说，谁也不知道其他人选了啥。囚徒困境就是静态博弈。

动态博弈则有先后顺序，参与人在做决定时能看到对手之前的选择。下棋、打牌、讨价还价都是动态博弈。动态博弈引入了”承诺”、“威胁”、“信誉”等有趣的概念。

2.4 零和还是变和？

零和博弈里，一方的收益正好是另一方的损失。打个比方，蛋糕就这么大，你多吃一口别人就少吃一口。赌博、象棋、石头剪刀布都是零和博弈。

变和博弈（也叫”非零和博弈”）则不同，蛋糕的大小可以变。合作可以把蛋糕做大，大家都能分到更多。囚徒困境虽然最后两人都受损失，但如果合作的话损失会更小——这是一个”变和”的博弈。

博弈分类体系
├── 参与人数量
│   ├── 两人博弈
│   └── n人博弈（n > 2）
├── 收益结构
│   ├── 零和博弈（一方所得为另一方所失）
│   ├── 常和博弈（总收益恒定）
│   └── 变和博弈（总收益可变）
├── 时间维度
│   ├── 静态博弈（同时行动）
│   └── 动态博弈（序贯行动）
├── 信息结构
│   ├── 完全信息博弈
│   └── 不完全信息博弈（贝叶斯博弈）
└── 策略类型
    ├── 纯策略（确定性选择）
    └── 混合策略（概率性选择）

---

3. 占优策略与Nash均衡：为什么”大家好才是真的好”不是纳什均衡？

3.1 占优策略：不管对手怎么选，这招都是最优的

回到囚徒困境，我们发现”坦白”是每个囚徒的占优策略——不管对方选什么，坦白都比沉默好。

用数学语言说，对于参与人 $i$，策略 $s_i^{\ast }\in S_i$ 是严格占优策略，当且仅当：

$$u_i(s_i^{\ast },s_{-i})>u_i(s_i^{\prime },s_{-i}),\forall s_i^{\prime }\in S_i,\forall s_{-i}\in S_{-i}$$

如果一个博弈里每个参与人都有占优策略，那预测结果就太简单了——大家都会选自己的占优策略，博弈结果自然就是占优策略均衡。

问题是，不是所有博弈都有占优策略。很多时候，最优选择取决于对手怎么做。

def find_dominant_strategy(game, player_idx):
    """
    查找参与人的占优策略
    
    如果一个策略在所有情况下都优于其他策略，则为占优策略
    """
    num_strategies = len(game.strategy_spaces[player_idx])
    
    for my_action in range(num_strategies):
        is_dominant = True
        
        # 检查该策略是否在所有对手策略下都是最优的
        opponent_strategies = [len(game.strategy_spaces[j]) for j in range(len(game.players)) if j != player_idx]
        
        for opponent_action in range(np.prod(opponent_strategies)):
            opponent_profile = []
            temp = opponent_action
            for num_s in opponent_strategies:
                opponent_profile.append(temp % num_s)
                temp //= num_s
            
            action_profile = opponent_profile.copy()
            action_profile.insert(player_idx, my_action)
            
            my_payoff = game.get_payoff(action_profile)[player_idx]
            
            # 比较与其他策略的收益
            for other_action in range(num_strategies):
                if other_action == my_action:
                    continue
                
                other_profile = opponent_profile.copy()
                other_profile.insert(player_idx, other_action)
                other_payoff = game.get_payoff(other_profile)[player_idx]
                
                if my_payoff <= other_payoff:
                    is_dominant = False
                    break
            
            if not is_dominant:
                break
        
        if is_dominant:
            return my_action, game.strategy_spaces[player_idx][my_action]
    
    return None, None
 
# 囚徒困境分析
def analyze_prisoners_dilemma():
    """
    囚徒困境分析：
    
    收益矩阵（双方收益）:
                 囚徒B
              沉默    背叛
    囚徒A 沉默  (-1,-1) (-4, 0)
         背叛  ( 0,-4) (-3,-3)
    
    分析：
    - 对囚徒A：背叛总是优于沉默（无论B如何选择）
      - 若B沉默：背叛得0 > 沉默得-1 ✓
      - 若B背叛：背叛得-3 > 沉默得-4 ✓
    - 因此"背叛"是囚徒A的占优策略
    - 同理，"背叛"也是囚徒B的占优策略
    - Nash均衡：(背叛, 背叛) = (-3, -3)
    - 但帕累托最优：(沉默, 沉默) = (-1, -1)
    """
    game = create_prisoners_dilemma()
    
    for i, player in enumerate(game.players):
        action, strategy = find_dominant_strategy(game, i)
        if strategy:
            print(f"{player} 的占优策略: {strategy}")
    
    print("\nNash均衡: (背叛, 背叛) = (-3, -3)")
    print("帕累托最优: (沉默, 沉默) = (-1, -1)")

3.2 纳什均衡：想象一个所有人都不愿意单方面改变策略的僵局

纳什均衡是博弈论最核心的概念。1950年，约翰·纳什（John Nash）在他那篇只有短短两页的论文里提出了这个天才般的概念。

纳什均衡的定义是：一个策略组合 $(s_1^{\ast },s_2^{\ast },\dots ,s_n^{\ast })$ 是纳什均衡，当且仅当每个参与人在给定其他人策略的情况下，都没有动力单方面改变自己的策略。

用数学语言：

$$u_i(s_i^{\ast },s_{-i}^{\ast })\ge u_i(s_i^{\prime },s_{-i}^{\ast }),\forall i,\forall s_i^{\prime }\in S_i$$

用人话说就是：谁都不愿意先动。

再回头看囚徒困境。(背叛, 背叛) 就是一个纳什均衡——给定对方背叛了，我背叛是最好选择（-3 > -4）。给定我背叛了，对方背叛也是最好选择。没有人在这个状态下有动机单方面改变。

但这里有一个深刻的问题：纳什均衡不一定是”好”的。(背叛, 背叛) 虽然是均衡，但它不如 (沉默, 沉默) ——两人都只坐1年牢。

这就是博弈论的核心矛盾之一：均衡不一定是帕累托最优。帕累托最优意味着没有其他状态能在不让任何人变差的情况下让至少一个人变好。(沉默, 沉默) 明显比 (背叛, 背叛) 好，但 (沉默, 沉默) 不是均衡——因为在那个状态下，总有人会想背叛来获得更大利益。

“大家好才是真的好”这个想法，从博弈论角度看是有问题的——因为在Nash均衡的定义里，每个人只关心自己好不好，不关心整体。

def find_nash_equilibrium(game):
    """
    暴力搜索法找Nash均衡（适用于小规模博弈）
    
    枚举所有策略组合，检查每个参与人是否无法单方面改进
    """
    strategy_counts = [len(space) for space in game.strategy_spaces]
    equilibria = []
    
    # 枚举所有策略组合
    for action_profile in product(*[range(c) for c in strategy_counts]):
        is_equilibrium = True
        
        # 检查每个参与人是否无法单方面改进
        for player_idx in range(len(game.players)):
            current_payoff = game.get_payoff(action_profile)[player_idx]
            
            # 检查该参与人所有其他策略
            for alternative_action in range(strategy_counts[player_idx]):
                if alternative_action == action_profile[player_idx]:
                    continue
                
                alternative_profile = list(action_profile)
                alternative_profile[player_idx] = alternative_action
                
                alternative_payoff = game.get_payoff(alternative_profile)[player_idx]
                
                # 如果存在更好的单方面偏离，则不是均衡
                if alternative_payoff > current_payoff:
                    is_equilibrium = False
                    break
            
            if not is_equilibrium:
                break
        
        if is_equilibrium:
            equilibria.append(action_profile)
    
    return equilibria
 
# 石头剪刀布博弈
def create_rock_paper_scissors():
    """创建石头剪刀布博弈"""
    players = ["玩家1", "玩家2"]
    # 0=石头, 1=布, 2=剪刀
    strategy_spaces = [["石头", "布", "剪刀"], ["石头", "布", "剪刀"]]
    
    # 玩家1的收益：赢=1, 平=0, 输=-1
    payoff_1 = np.array([
        [0, -1, 1],   # 玩家1出石头
        [1, 0, -1],   # 玩家1出布
        [-1, 1, 0]    # 玩家1出剪刀
    ])
    
    # 玩家2的收益（相反）
    payoff_2 = np.array([
        [0, 1, -1],
        [-1, 0, 1],
        [1, -1, 0]
    ])
    
    return NormalFormGame(players, strategy_spaces, [payoff_1, payoff_2])
 
def analyze_rock_paper_scissors():
    """
    石头剪刀布分析：
    
    纯策略Nash均衡：不存在
    - 任何纯策略组合都存在至少一方可以改进
    
    混合策略Nash均衡：存在
    - 三个策略等概率 (1/3, 1/3, 1/3)
    - 这是对称Nash均衡
    """
    game = create_rock_paper_scissors()
    equilibria = find_nash_equilibrium(game)
    print(f"纯策略Nash均衡数量: {len(equilibria)}")
    print("（石头剪刀布没有纯策略均衡）")

3.3 纳什均衡的直觉：谁都不愿意先动

想象一个僵局：几个人被困在一个即将沉没的船上，谁都不敢先跳下去游泳逃生，因为不确定其他人会不会跟着一起来救自己。这就是纳什均衡的直觉——每个人都在等待，谁都不愿意单方面行动打破现状。

纳什均衡不一定是”最优”的，但它是”稳定”的——没有人有动机打破它。

纳什定理（Nash, 1950）：每个有限博弈至少存在一个Nash均衡（可能是混合策略均衡）。

这个定理的证明依赖于布劳威尔不动点定理，是个相当深刻的数学结果。它的意义在于告诉我们：不管博弈多复杂，总存在至少一个稳定的策略组合。这是博弈论能广泛应用的理论基石。

---

4. 零和博弈：纯粹对抗的世界

4.1 零和博弈的定义与性质

零和博弈是博弈论中研究得最深入的一类。它们的特征是：一方的收益正好是另一方的损失。

$$u_1(s_1,s_2)+u_2(s_1,s_2)=0,\forall s_1\in S_1,s_2\in S_2$$

在零和博弈里，没有合作的可能——蛋糕就那么大，甚至可以说蛋糕就是”相对大小”，你赢就是我输。

棋类游戏是零和博弈。体育比赛通常也是。商业竞争有时候也可以近似为零和博弈——尤其是在市场份额争夺的场景里。

零和博弈有个漂亮的性质：它总是有一个均衡。更准确地说，它总是有一个混合策略均衡，而且这个均衡可以用minimax定理来刻画。

class ZeroSumGame:
    """
    零和博弈特殊处理
    
    零和博弈性质：
    1. 一方的最优策略直接由对方的最优策略决定
    2. 存在鞍点（如果纯策略均衡存在）
    3. minimax定理保证混合策略均衡存在
    """
    
    def __init__(self, payoff_matrix):
        """
        参数:
            payoff_matrix: 行玩家（玩家1）的收益矩阵
                          列玩家（玩家2）的收益为 -payoff_matrix
        """
        self.payoff_matrix = np.array(payoff_matrix)
        self.player1_payoffs = self.payoff_matrix
        self.player2_payoffs = -self.payoff_matrix
    
    def row_maximin(self):
        """
        行玩家（最大化最小收益）的最优响应
        最大化最小值策略
        """
        # 每行的最小值
        row_mins = self.payoff_matrix.min(axis=1)
        # 选择最小值最大的行
        best_row = np.argmax(row_mins)
        return best_row, row_mins[best_row]
    
    def column_minimax(self):
        """
        列玩家（最小化最大损失）的最优响应
        """
        # 每列的最大值
        col_maxs = self.payoff_matrix.max(axis=0)
        # 选择最大值最小的列
        best_col = np.argmin(col_maxs)
        return best_col, col_maxs[best_col]
    
    def find_saddle_point(self):
        """
        查找鞍点（纯策略均衡）
        
        鞍点条件：
        - 行最小值中的最大值 = 列最大值中的最小值
        """
        row_mins = self.payoff_matrix.min(axis=1)
        col_maxs = self.payoff_matrix.max(axis=0)
        
        maximin = row_mins.max()
        minimax = col_maxs.min()
        
        if maximin == minimax:
            # 找到鞍点
            row_idx = np.argmax(row_mins)
            col_idx = np.argmin(col_maxs)
            return True, (row_idx, col_idx), maximin
        else:
            return False, None, None
 
# 剪刀石头布零和博弈分析
def analyze_rps_zero_sum():
    game = ZeroSumGame(np.array([
        [0, -1, 1],
        [1, 0, -1],
        [-1, 1, 0]
    ]))
    
    has_saddle, point, value = game.find_saddle_point()
    print(f"鞍点存在: {has_saddle}")
    if has_saddle:
        print(f"鞍点位置: {point}")
        print(f"博弈值: {value}")
    else:
        print("无纯策略均衡，需要混合策略")
    
    # 行玩家最大化最小收益
    best_row, maxmin = game.row_maximin()
    # 列玩家最小化最大收益
    best_col, minmax = game.column_minimax()
    
    print(f"\n行玩家maximin: {maxmin}")
    print(f"列玩家minimax: {minmax}")
    print(f"maximin != minimax，证实无纯策略均衡")

4.2 Minimax定理：对抗中的最优策略

1928年，冯·诺依曼（John von Neumann）证明了一个里程碑式的定理：最小最大定理（Minimax Theorem）。

这个定理说：在零和博弈里，最大化最小收益等于最小化最大损失。

$$\underset{s_1\in \Delta (S_1)}{\max }\underset{s_2\in \Delta (S_2)}{\min }{u}_1(s_1,s_2)=\underset{s_2\in \Delta (S_2)}{\min }\underset{s_1\in \Delta (S_1)}{\max }{u}_1(s_1,s_2)$$

用人话说就是：最坏情况下能得到的最好结果，等于最有利情况下最坏的结果。

在博弈论里，这个共同的值叫做”博弈值”（value of the game）。如果博弈值是0，就是”公平游戏”；如果博弈值大于0，行玩家有优势；如果小于0，列玩家有优势。

Minimax定理是现代对抗性AI的基石。AlphaGo的蒙特卡洛树搜索、强化学习中的对抗训练、网络安全中的攻防博弈，都离不开这个思想。

def fictitious_play(game, num_iterations=10000):
    """
    虚拟对局算法（Fictitious Play）
    
    迭代学习过程：
    1. 每个参与人根据对方的历史平均策略选择最优响应
    2. 更新历史平均
    3. 重复直到收敛
    
    收敛性：在两人零和博弈中，虚拟对局收敛到Nash均衡
    """
    n_rows, n_cols = game.payoff_matrix.shape
    
    # 初始化历史计数
    row_counts = np.ones(n_rows)  # 每个策略被选中的次数
    col_counts = np.ones(n_cols)
    
    row_distribution = row_counts / row_counts.sum()
    col_distribution = col_counts / col_counts.sum()
    
    for iteration in range(num_iterations):
        # 行玩家对列玩家历史策略的最优响应
        expected_payoffs = game.payoff_matrix @ col_distribution
        best_row = np.argmax(expected_payoffs)
        
        # 列玩家对行玩家历史策略的最优响应
        expected_payoffs_col = game.payoff_matrix.T @ row_distribution
        best_col = np.argmin(expected_payoffs_col)
        
        # 更新计数
        row_counts[best_row] += 1
        col_counts[best_col] += 1
        
        # 更新分布
        row_distribution = row_counts / row_counts.sum()
        col_distribution = col_counts / col_counts.sum()
        
        if iteration % 1000 == 0:
            value = row_distribution @ game.payoff_matrix @ col_distribution
            print(f"Iter {iteration}: 博弈值估计 = {value:.4f}")
            print(f"  行玩家策略: {row_distribution}")
            print(f"  列玩家策略: {col_distribution}")
    
    return row_distribution, col_distribution

---

5. 混合策略纳什均衡：石头剪刀布的聪明策略

5.1 为什么石头剪刀布没有纯策略均衡？

仔细想想石头剪刀布，你会发现一件有意思的事：它没有任何纯策略均衡。

假设玩家1固定出石头。如果玩家2知道了这件事，他就会一直出布来赢。那玩家1发现后就会改出剪刀……这个循环永远不会停。没有哪个纯策略组合是稳定的——只要你固定做某件事，对手就会找到克制的办法。

那怎么办？答案是混合策略：不固定在某个动作上，而是以一定概率在多个动作之间随机选择。

对于石头剪刀布，如果两个玩家都以 $1/3$ 的概率选择石头、布、剪刀，就达到了一种均衡状态——混合策略Nash均衡。

混合策略的意思是：

$${\sigma }_i\in \Delta (S_i)=\left\{(p_1,p_2,\dots ,p_{|S_i|}):\sum _{j=1}^{|S_i|}{p}_j=1,p_j\ge 0\right\}$$

简单说就是给每个纯策略分配一个概率，这些概率加起来等于1。

在混合策略均衡里，每个被选中的纯策略（构成”支持集”）必须给参与人带来相同的期望收益——否则，参与人就会把更多概率放在收益更高的策略上。

def find_mixed_nash_equilibrium(game):
    """
    寻找两人博弈的混合策略Nash均衡
    
    对于2x2博弈，可以通过解析方法求解
    """
    payoff_matrix = game.payoff_matrix
    n_rows, n_cols = payoff_matrix.shape
    
    equilibria = []
    
    if n_rows == 2 and n_cols == 2:
        # 2x2博弈混合均衡求解
        # 设行玩家以(p, 1-p)选择策略1和2
        # 设列玩家以(q, 1-q)选择策略1和2
        
        # 行玩家无差异条件
        # payoff[0,q] = payoff[1,q]
        # a*q + b*(1-q) = c*q + d*(1-q)
        # q = (d-b)/(a-b-c+d)
        
        a = payoff_matrix[0, 0]  # (R1, C1)
        b = payoff_matrix[0, 1]  # (R1, C2)
        c = payoff_matrix[1, 0]  # (R2, C1)
        d = payoff_matrix[1, 1]  # (R2, C2)
        
        denom = a - b - c + d
        if abs(denom) > 1e-10:
            q = (d - b) / denom  # 列玩家选择策略1的概率
            if 0 <= q <= 1:
                # 计算行玩家策略
                p = (d - c) / (a - b - c + d) if abs(denom) > 1e-10 else 0.5
                if 0 <= p <= 1:
                    equilibria.append({
                        'player1': [p, 1-p],
                        'player2': [q, 1-q],
                        'value': p * (a * q + b * (1-q)) + (1-p) * (c * q + d * (1-q))
                    })
    
    return equilibria
 
def analyze_matching_pennies():
    """
    硬币配对博弈（Matching Pennies）
    
    收益矩阵:
                 列玩家
              Head    Tail
    行玩家 Head  1,-1   -1,1
         Tail  -1,1    1,-1
    
    分析：
    - 无纯策略均衡
    - 混合策略均衡：各以0.5概率选择
    """
    game = ZeroSumGame(np.array([
        [1, -1],
        [-1, 1]
    ]))
    
    equilibria = find_mixed_nash_equilibrium(game)
    print("硬币配对博弈混合均衡:")
    for eq in equilibria:
        print(f"  行玩家: Head={eq['player1'][0]:.2f}, Tail={eq['player1'][1]:.2f}")
        print(f"  列玩家: Head={eq['player2'][0]:.2f}, Tail={eq['player2'][1]:.2f}")
        print(f"  博弈值: {eq['value']:.2f}")

5.2 支持选择与无差异条件

在混合策略Nash均衡里，有一个关键概念叫”支持集”（support）——就是在均衡中被分配了正概率的那些纯策略。

对于支持集中的每个策略，参与人必须是无差异的——选哪个收益都一样。如果某个策略在支持集中但期望收益低于其他不在支持集中的策略，那参与人就会把概率转移到更好的策略上，均衡就会变化。

这个条件用公式表示就是：

$$u_i(s_i^k,{\sigma }_{-i}^{\ast })=u_i(s_i^l,{\sigma }_{-i}^{\ast }),\forall s_i^k,s_i^l\in \text{supp}({\sigma }_i^{\ast })$$

def solve_mixed_strategy_lp(game, player_idx):
    """
    使用线性规划求解混合策略Nash均衡
    
    以玩家1为例：
    - 最大化 v（博弈值）
    - 约束：每个策略的期望收益 >= v
    """
    from scipy.optimize import linprog
    import numpy as np
    
    if len(game.players) != 2:
        raise NotImplementedError("仅支持两人博弈")
    
    payoff_matrix = game.payoff_matrix
    n_strategies = payoff_matrix.shape[0] if player_idx == 0 else payoff_matrix.shape[1]
    
    # 线性规划：最大化 v
    # 约束：Ax <= b, x >= 0
    
    if player_idx == 0:
        # 行玩家：minimize -v
        # 约束：p^T * payoff >= v for all columns
        A_ub = -payoff_matrix.T  # 不等式左侧系数
        b_ub = -np.ones(payoff_matrix.shape[1])  # v 的系数（设为1）
        
        # 约束：p.sum() = 1
        A_eq = np.ones((1, n_strategies + 1))
        b_eq = np.array([1.0])
        
        # 变量：[p1, p2, ..., pn, v]
        c = np.zeros(n_strategies + 1)
        c[-1] = -1  # 最大化 v = 最小化 -v
    else:
        # 列玩家：maximize v
        A_ub = payoff_matrix  # 不等式左侧
        b_ub = np.ones(payoff_matrix.shape[0])
        
        A_eq = np.ones((1, n_strategies + 1))
        b_eq = np.array([1.0])
        
        c = np.zeros(n_strategies + 1)
        c[-1] = 1  # 最大化 v
    
    result = linprog(c, A_ub=A_ub, b_ub=b_ub, A_eq=A_eq, b_eq=b_eq,
                     bounds=[(0, 1)] * n_strategies + [(-None, None)])
    
    if result.success:
        strategy = result.x[:-1]
        value = result.x[-1]
        return strategy, value
    else:
        return None, None

---

6. 博弈论与AI的碰撞：为什么大语言模型需要博弈论？

6.1 从单人决策到多智能体交互

早期的AI研究主要关注单人决策问题——一个智能体在确定性的环境里最大化自己的收益。典型的例子就是强化学习里的CartPole任务：智能体控制一根平衡杆，目标是让杆不倒。

这类问题的数学框架相对简单：状态、动作、奖励。智能体找到一个最优策略，让累积奖励最大化。

但是，当环境里有多个智能体时，事情就复杂了。

想象你训练了两个机器人一起搬桌子。如果你只优化机器人A的策略，机器人A可能会做出让机器人B很头疼的动作。反过来也一样。你需要考虑双方的策略如何交互。

更重要的是，现实世界中的AI对手不是静止的——它们会适应你的策略。你调整，我也调整；我进化，你也进化。这是一个动态的、交互的过程。

博弈论正是描述这种多智能体交互的数学语言。

6.2 多智能体系统中的博弈：竞争与合作

多智能体系统（Multi-Agent System）是AI的前沿领域。想象一群无人机编队飞行，或者多个自动驾驶车辆在十字路口会车——这些场景里，每个智能体都需要考虑其他智能体的行为。

从博弈论角度看，多智能体交互可以分为几种模式：

纯粹竞争：智能体之间是零和博弈。你赢就是我输。典型场景是对抗性AI训练——让两个AI互相对战，强的吃掉弱的。

纯粹合作：智能体有共同目标，收益函数相同。比如多机器人协同搬运，收益是整体任务完成情况。这种情况下，找到Nash均衡通常就是找到联合最优策略。

混合动机：最有趣的场景。智能体之间既有竞争也有合作。比如商业谈判——各方都有自己的利益，但达成协议对大家都有好处。

6.3 大语言模型时代的新博弈

大语言模型（LLM）的出现让博弈论变得更加重要。

AI对齐问题本质上是一个博弈论问题。你想要AI做某件事，但AI有自己的”想法”——更准确地说，AI的优化目标可能和你的意图不完全一致。如果把人类和AI看作博弈的两个参与人，那对齐问题就是：如何设计激励机制，让AI不会”背叛”人类的最优利益。

多智能体LLM系统也带来新的博弈问题。当多个LLM Agent一起工作时，它们之间如何协调？如果一个Agent试图”作弊”获取更多资源怎么办？如何设计通信协议让它们高效合作？

这些都是正在被研究的开放问题，博弈论提供了分析框架。

class MultiAgentGame:
    """
    多智能体博弈框架
    
    应用场景：
    - 多智能体强化学习
    - 分布式优化
    - 联邦学习
    """
    
    def __init__(self, agents, payoff_functions):
        self.agents = agents
        self.payoff_functions = payoff_functions
    
    def best_response_iteration(self, agent_idx, others_strategies):
        """
        最佳响应迭代
        
        给定其他智能体的策略，计算当前智能体的最优策略
        """
        agent = self.agents[agent_idx]
        payoff_fn = self.payoff_functions[agent_idx]
        
        # 离散化策略空间搜索
        best_strategy = None
        best_payoff = float('-inf')
        
        for strategy in agent.strategy_space:
            payoff = payoff_fn(strategy, others_strategies)
            if payoff > best_payoff:
                best_payoff = payoff
                best_strategy = strategy
        
        return best_strategy, best_payoff
    
    def fictitious_play_iteration(self, history):
        """
        虚拟对局迭代
        """
        new_strategies = []
        
        for i, agent in enumerate(self.agents):
            # 计算其他智能体的历史平均策略
            others_histories = [history[j] for j in range(len(self.agents)) if j != i]
            others_avg_strategies = [np.mean(h, axis=0) for h in others_histories]
            
            # 计算最优响应
            best_response, _ = self.best_response_iteration(i, others_avg_strategies)
            new_strategies.append(best_response)
        
        return new_strategies

---

7. 拍卖理论实战：广告投放背后的博弈

7.1 什么是拍卖？

拍卖不只是苏富比卖画、政府卖地。你每天看到的互联网广告，背后都是大规模的拍卖。

Google每秒处理几百万次广告展示，每次展示都是一次拍卖：广告主出价，系统决定展示谁家的广告，以及按什么价格收费。

Facebook的广告系统更复杂——它不只是拍卖，还涉及匹配问题：什么样的广告应该展示给什么样的用户，才能让平台和广告主都满意？

7.2 Vickrey拍卖：为什么说实话是最优策略

最著名的拍卖理论成果之一是Vickrey拍卖（也叫第二价格密封拍卖）。它的规则很简单：

1. 每个竞标者提交密封报价
2. 出价最高的人赢得拍品
3. 获胜者支付第二高的出价（而不是自己的出价）

这看起来有点反直觉——为什么第二高的出价？因为这个机制有一个关键性质：说实话是每个竞标者的占优策略。

想想看。如果你的真实估值是100块：

• 如果你出价100，而对手出价90，你赢了，付90。你得到了100-90=10的剩余。
• 如果你出价100，对手也出价100，你和对手都可能赢（取决于打破平局的规则），但你的处境不会变差。
• 如果你出价超过100（比如120），你能赢的情况下还是付90，不会更好；但如果你的120是虚高，对手出价95，你还是会付95——没有额外收益，但如果你输了，损失的是展示机会。

所以，出价高于你的真实估值不会带来任何好处，反而可能让你在赢了之后付出高于必要的代价。

如果你出价低于100（比如说80），可能输掉本该赢的拍卖（对手出价90），损失的是本来可以获得的10块剩余。

因此，说实话——按真实估值出价——永远是你能做的最好选择。

Vickrey拍卖是激励相容（Incentive Compatible）的典范。这个概念对机制设计极其重要。

class VickreyAuction:
    """
     Vickrey拍卖（第二价格密封拍卖）
    
    机制设计特点：
    - 激励相容：说实话是占优策略
    - 社会福利最大化
    - 个体理性
    """
    
    def __init__(self, reserve_price=0):
        self.reserve_price = reserve_price
        self.bids = []
    
    def submit_bid(self, bidder_id, bid):
        """提交投标"""
        if bid >= self.reserve_price:
            self.bids.append((bidder_id, bid))
    
    def determine_winner(self):
        """确定胜者和最终价格"""
        if not self.bids:
            return None, None, None
        
        # 按投标排序
        sorted_bids = sorted(self.bids, key=lambda x: x[1], reverse=True)
        
        winner_id = sorted_bids[0][0]
        winner_bid = sorted_bids[0][1]
        
        # 第二高价格（如果有多个投标人）
        if len(sorted_bids) > 1:
            price = sorted_bids[1][1]
        else:
            price = self.reserve_price
        
        return winner_id, price, winner_bid
 
class DoubleAuction:
    """
    双向拍卖
    
    买卖双方同时报价，机制设计决定交易价格
    """
    
    def __init__(self):
        self.buyer_bids = []  # (buyer_id, bid)
        self.seller_asks = []  # (seller_id, ask)
    
    def submit_buyer_bid(self, buyer_id, bid):
        self.buyer_bids.append((buyer_id, bid))
    
    def submit_seller_ask(self, seller_id, ask):
        self.seller_asks.append((seller_id, ask))
    
    def clear_market(self):
        """清空市场，找到交易对"""
        buyers = sorted(self.buyer_bids, key=lambda x: x[1], reverse=True)
        sellers = sorted(self.seller_asks, key=lambda x: x[1])
        
        trades = []
        i, j = 0, 0
        
        while i < len(buyers) and j < len(sellers):
            buyer_id, buyer_bid = buyers[i]
            seller_id, seller_ask = sellers[j]
            
            if buyer_bid >= seller_ask:
                # 交易可以发生
                price = (buyer_bid + seller_ask) / 2  # 中点价格
                trades.append({
                    'buyer': buyer_id,
                    'seller': seller_id,
                    'price': price
                })
                i += 1
                j += 1
            else:
                break
        
        return trades

7.3 真实的广告拍卖：广义第二价格拍卖

Google、Facebook使用的广告拍卖是广义第二价格拍卖（Generalized Second Price, GSP）。

机制和Vickrey拍卖类似，但有一个关键区别：在GSP中，广告主按自己下一位的出价付费，而不是第二高出价。这导致了一个有趣的博弈——广告主有动机降低出价（只要不低于下一位），来节省成本。

但GSP也有问题——它不是激励相容的。广告主可以通过策略性出价来获得优势。这意味着广告平台需要不断设计更好的拍卖机制。

Google广告系统后来引入了更复杂的机制，比如组合拍卖（多个广告位一起拍卖）、质量分数（考虑广告点击率、着陆页质量等因素）——这些都是机制设计的创新。

激励相容的重要性

在机制设计中，激励相容确保参与人有动机按照设计的规则行事。Vickrey拍卖之所以有效，是因为它将”说实话”变成每个投标人的占优策略。

---

8. 机制设计：如何设计一个不被钻空子的规则？

8.1 从”正向工程”到”逆向工程”

普通的博弈论是正向工程：给定规则，分析结果。

机制设计是逆向工程：你想要什么样的结果，反过来设计规则。

这个转变意义重大。想象你要设计一个分遗产的规则。你希望：

• 每个人都说实话（报告真实的价值）
• 最终分配是高效的
• 没有人吃亏

传统的博弈论分析不了这个问题——你需要从目标出发，反推规则。

8.2 机制设计的三个核心概念

激励相容（Incentive Compatibility）：说实话是对每个参与人的占优策略。如果一个机制是激励相容的，参与人不需要”猜测”其他人的行为，老老实实按真实意愿行动就是最优选择。

社会福利最大化：${\max }_{a\in A}{\sum }_i{v}_i(a)$。机制的最终目标通常是让整个社会的福利最大——所有参与人的收益之和最大。

个体理性（Individual Rationality）：参与人有参与的动机。如果一个机制让参与人觉得”参加不如不参加”，那它根本运行不起来。

8.3 显示原理：为什么只考虑”说实话”的机制就够了

机制设计领域有一个深刻的结果——显示原理（Revelation Principle）。

它的意思是：如果你想要一个激励相容的机制，你只需要考虑”直接说实话”的机制就够了。任何复杂的、允许策略性行为的机制，都可以等价地转换为一个直接说实话的机制。

这个原理大大简化了机制设计的复杂度——你不需要考虑五花八门的策略行为，只需要确保”说实话”是均衡就够了。

---

9. 进化博弈论：从生物进化理解策略演化

9.1 生物学中的博弈

进化生物学家发现，博弈论在自然界中无处不在。

孔雀为什么要开屏？尾巴越大越容易被捕食者发现，按理说应该退化才对。但雌孔雀喜欢尾巴华丽的雄孔雀——这说明”大尾巴”在性选择中是一种信号。如果把孔雀的博弈画出来，就是一个”信号博弈”：雄性发出信号（展示尾巴），雌性决定是否交配。

蚂蚁之间的合作与背叛也遵循博弈论逻辑。工蚁辛勤劳动不求回报——这看起来违反了”理性人”假设。但如果从进化博弈的角度看，工蚁通过帮助蜂后繁殖自己的基因，整体上还是”划算”的。

9.2 进化稳定策略（ESS）

进化博弈论提出了一个比Nash均衡更严格的概念：进化稳定策略（Evolutionarily Stable Strategy）。

如果一个种群中所有个体都采用策略 ESS ${\sigma }^{\ast }$，那么：

1. 要么 ${\sigma }^{\ast }$ 本身就是Nash均衡
2. 要么如果出现了突变策略 ${\sigma }^{\prime }$，${\sigma }^{\ast }$ 能在小规模突变的情况下获得更高收益

ESS强调的是稳定性——不是”大家都不会动”，而是”即使有人突变，系统也能恢复均衡”。

9.3 鹰鸽博弈：大自然中的策略多样性

自然界中，鹰派和鸽派策略往往共存。

考虑一个资源竞争场景：两只动物争夺食物。两种策略：

• 鹰派：正面冲突，战斗到底。赢了得到食物，输了受重伤。
• 鸽派：象征性地展示威慑，如果对方也强硬就撤退。

如果种群中全是鸽派，一只突变出现的鹰派就能横扫整个种群。但如果全是鹰派，激烈的内耗会让鸽派入侵——因为鸽派避免了战斗损失。

最终，鹰派和鸽派会在某个比例上达到ESS——这就是自然界策略多样性的博弈论解释。

---

10. 博弈论视角下的GAN：生成器与判别器的博弈均衡

10.1 GAN的本质是一个两人零和博弈

生成对抗网络（GAN）是博弈论在深度学习中最经典的应用之一。

GAN包含两个神经网络：

• 生成器（Generator）：生成假样本，试图骗过判别器
• 判别器（Discriminator）：判断样本是真是假

从博弈论的角度看，GAN就是一个两人零和博弈：

$$\underset{G}{\min }\underset{D}{\max }V(D,G)={\mathbb{E}}_{\mathbf{x}\sim p_{\text{data}}}[\log D(\mathbf{x})]+{\mathbb{E}}_{\mathbf{z}\sim p_{\mathbf{z}}}[\log (1-D(G(\mathbf{z})))]$$

生成器试图最小化这个值，判别器试图最大化。在Nash均衡下，判别器无法区分真假样本（$D(G(z))=0.5$），而生成器产生的分布正好匹配真实数据分布。

class GANGame:
    """
    GAN的博弈论建模
    
    博弈要素：
    - 参与人1：生成器G（最小化）
    - 参与人2：判别器D（最大化）
    - 零和博弈：G的损失 = -D的损失
    """
    
    def __init__(self):
        self.generator_loss_history = []
        self.discriminator_loss_history = []
    
    def compute_gan_objective(self, real_samples, fake_samples, discriminator, generator):
        """
        计算GAN的博弈目标值
        """
        # 判别器试图最大化
        d_real = discriminator(real_samples)
        d_fake = discriminator(fake_samples.detach())
        
        # 二分类交叉熵损失
        d_loss_real = -torch.log(d_real + 1e-8).mean()
        d_loss_fake = -torch.log(1 - d_fake + 1e-8).mean()
        d_loss = (d_loss_real + d_loss_fake) / 2
        
        # 生成器试图最小化（但通过判别器的反向信号）
        g_loss = -torch.log(d_fake + 1e-8).mean()
        
        return g_loss, d_loss
    
    def check_nash_equilibrium(self, generator, discriminator, real_data, latent_dim):
        """
        检查GAN是否接近Nash均衡
        """
        generator.eval()
        discriminator.eval()
        
        with torch.no_grad():
            # 生成样本
            z = torch.randn(100, latent_dim).to(next(generator.parameters()).device)
            fake_samples = generator(z)
            
            # 判别器输出
            d_real = discriminator(real_data[:100]).mean().item()
            d_fake = discriminator(fake_samples).mean().item()
        
        # Nash均衡条件：
        # - D(G(z)) ≈ 0.5（无法区分真假）
        # - G无法进一步改进
        
        equilibrium_gap = abs(d_fake - 0.5)
        
        return {
            'D(real)': d_real,
            'D(fake)': d_fake,
            'equilibrium_gap': equilibrium_gap,
            'is_near_equilibrium': equilibrium_gap < 0.1
        }

10.2 GAN训练的博弈困境

GAN的训练长期以来都是一个难题。为什么？

因为GAN的损失函数不是凸的，生成器和判别器的目标是对抗的——判别器太强，生成器就得不到有用的梯度；判别器太弱，生成器就失去方向。这就像两个人在下棋，只有棋力相当的时候对局才有意义。

这正是博弈论的用武之地。研究者们用博弈论来分析GAN的训练动态：

• 模式崩溃（Mode Collapse）是因为博弈没有达到均衡
• 训练不稳定是因为两个玩家的策略在”振荡”，而不是收敛到均衡
• 各种GAN变体（Wasserstein GAN、Least Squares GAN等）本质上是在设计更好的损失函数，让博弈更容易收敛

10.3 更广泛的对抗训练

GAN的成功启发了对抗训练（Adversarial Training）在其他领域的应用。

• 对抗样本攻击：攻击者试图制造能让分类器犯错的对抗样本，防御者试图训练鲁棒的分类器——这是一个对抗博弈
• 对抗自编码器：用判别器来约束隐变量的分布
• 对抗去噪：去噪器和生成器博弈，目标是恢复清晰图像

---

11. 博弈论视角下的多智能体强化学习：如何设计奖励机制？

11.1 多智能体强化学习的挑战

多智能体强化学习（MARL）是当前AI最活跃的研究方向之一。

在单智能体强化学习里，问题相对简单：智能体学习一个最优策略，最大化累积奖励。环境是固定的，奖励信号是清晰的。

但在多智能体场景下，每个智能体都在一个非稳态环境里学习。因为当我的策略变化时，其他智能体的最优策略也可能变化——环境变了。这意味着我学到的”最优策略”可能不再是最优了。

博弈论提供了分析这类问题的框架。 多智能体学习可以被理解为在多个智能体之间求解一个博弈的Nash均衡。

11.2 合作还是竞争？奖励机制设计

多智能体学习的一个核心问题是：如何设计奖励机制，让智能体产生期望的行为？

这个问题的本质是机制设计——你想要什么结果，就设计什么样的激励。

中心化训练 vs 分散式执行：一种常见做法是在训练时引入中心化的 critic（知道所有智能体的状态和动作），在执行时每个智能体只基于本地信息决策。这实际上是在降低博弈的复杂度。

全局奖励 vs 局部奖励：如果所有智能体共享同一个奖励函数，那就是完全合作的博弈。如果每个智能体有自己的奖励，可能出现竞争甚至对抗。全局奖励可能导致”懒蚂蚁”问题——有些智能体搭便车不出力。

信用分配（Credit Assignment）：当团队成功或失败时，如何把功劳/责任分配给各个智能体？这是多智能体学习中的核心难题。

11.3 常见的MARL算法分类

从博弈论角度看，MARL算法可以分为几类：

Fully Cooperative：所有智能体共享同一个目标函数。这种情况下，问题是找到**团队博弈（Team Game）**的联合最优策略。

Fully Competitive：智能体之间的利益完全对立（零和博弈）。 minimax是核心工具。

MixedMotivation：最复杂的场景，每个智能体有自己的目标。这需要分析一般和博弈（General-Sum Game）中的Nash均衡。

常见的MARL算法包括：

• VDN/QMIX：值分解方法，将联合Q值分解为各智能体的局部Q值（适用于合作博弈）
• MADDPG：多智能体Actor-Critic，用中心化的Critic指导训练
• Nash Q-Learning：直接求解Nash均衡，适用于一般和博弈
• 反事实多智能体策略梯度（COMA）：解决信用分配问题

---

12. 实战：用Python模拟一个简单的博弈游戏

12.1 模拟囚徒困境的演化

让我们用代码来模拟囚徒困境的多次对局，看看不同策略的表现。

import numpy as np
import random
 
class IteratedPrisonersDilemma:
    """
    迭代囚徒困境
    
    两个玩家进行多轮囚徒困境博弈，
    每轮都能看到对手上一轮的选择
    """
    
    def __init__(self, payoff_matrix):
        self.payoff_matrix = payoff_matrix  # 收益矩阵
        self.history = []  # 记录历史对局
    
    def play_round(self, player1_action, player2_action):
        """执行一轮博弈，返回双方收益"""
        payoff1 = self.payoff_matrix[player1_action][player2_action][0]
        payoff2 = self.payoff_matrix[player1_action][player2_action][1]
        self.history.append((player1_action, player2_action, payoff1, payoff2))
        return payoff1, payoff2
    
    def get_last_opponent_action(self, player_idx):
        """获取对手上一轮的选择"""
        if not self.history:
            return None  # 第一轮，没有历史
        last_round = self.history[-1]
        return last_round[1] if player_idx == 0 else last_round[0]
 
# 经典的囚徒困境收益矩阵
# 格式：[玩家1收益, 玩家2收益]
PD_PAYOFFS = {
    #              对手沉默    对手背叛
    '我的沉默':   ((-1, -1),   (-4,  0)),  # 收益: [我, 对手]
    '我的背叛':   (( 0, -4),   (-3, -3)),
}
 
class Strategy:
    """策略基类"""
    def choose_action(self, opponent_last_action, my_history, opponent_history):
        raise NotImplementedError
 
class AlwaysDefect(Strategy):
    """总是背叛"""
    def choose_action(self, opponent_last_action, my_history, opponent_history):
        return 1
 
class AlwaysCooperate(Strategy):
    """总是合作（沉默）"""
    def choose_action(self, opponent_last_action, my_history, opponent_history):
        return 0
 
class TitForTat(Strategy):
    """一报还一报：第一步合作，然后复制对手上一步"""
    def choose_action(self, opponent_last_action, my_history, opponent_history):
        if opponent_last_action is None:
            return 0  # 第一步合作
        return opponent_last_action
 
class GrimTrigger(Strategy):
    """触发策略：一直合作直到对手背叛，然后永远背叛"""
    def choose_action(self, opponent_last_action, my_history, opponent_history):
        if opponent_history and 1 in opponent_history:
            return 1  # 对手背叛过，永远背叛
        return 0
 
class RandomStrategy(Strategy):
    """随机策略：50%合作，50%背叛"""
    def choose_action(self, opponent_last_action, my_history, opponent_history):
        return random.choice([0, 1])
 
class Pavlov(Strategy):
    """帕夫洛夫/_win-stay_lose-shift：赢了保持，输了换策略"""
    def choose_action(self, opponent_last_action, my_history, opponent_history):
        if not my_history:  # 第一步
            return 0
        
        my_last = my_history[-1]
        opp_last = opponent_history[-1]
        
        # 计算上一轮的收益
        payoff = PD_PAYOFFS['我的沉默' if my_last == 0 else '我的背叛'][opp_last][0]
        
        if payoff >= opp_last:  # 如果我的收益 >= 对手的收益（说明我赢了或平局），保持
            return my_last
        else:  # 输了，换策略
            return 1 - my_last
 
def simulate_tournament(strategies, num_rounds=200, num_repetitions=100):
    """
    策略锦标赛模拟
    
    所有策略两两对战，计算平均总收益
    """
    results = {s.__class__.__name__: 0 for s in strategies}
    
    for rep in range(num_repetitions):
        for i, strat1 in enumerate(strategies):
            for j, strat2 in enumerate(strategies):
                if i == j:  # 不和自己打
                    continue
                
                game = IteratedPrisonersDilemma(None)
                strat1_history = []
                strat2_history = []
                
                for round_num in range(num_rounds):
                    opp_last_1 = game.get_last_opponent_action(0)
                    opp_last_2 = game.get_last_opponent_action(1)
                    
                    action1 = strat1.choose_action(opp_last_1, strat1_history, strat2_history)
                    action2 = strat2.choose_action(opp_last_2, strat2_history, strat1_history)
                    
                    payoff1, payoff2 = game.play_round(action1, action2)
                    strat1_history.append(action1)
                    strat2_history.append(action2)
                
                # 累计这轮对局的收益
                game_result = sum(r[2] for r in game.history)
                results[strat1.__class__.__name__] += game_result
    
    # 计算平均值
    num_matches = num_repetitions * (len(strategies) - 1)
    avg_results = {k: v / num_matches for k, v in results.items()}
    
    return avg_results
 
# 运行锦标赛
if __name__ == "__main__":
    strategies = [
        AlwaysDefect(),
        AlwaysCooperate(),
        TitForTat(),
        GrimTrigger(),
        RandomStrategy(),
        Pavlov(),
    ]
    
    print("=" * 50)
    print("迭代囚徒困境策略锦标赛")
    print("=" * 50)
    print(f"每场对局 {200} 轮，重复 {100} 次\n")
    
    results = simulate_tournament(strategies)
    
    # 排序输出
    sorted_results = sorted(results.items(), key=lambda x: x[1], reverse=True)
    for name, score in sorted_results:
        print(f"{name:20s}: 平均收益 {score:.2f}")

12.2 运行结果与分析

运行上面的代码，你会看到各种策略的表现。通常：

• 一报还一报（Tit for Tat） 表现稳健——它既不会被人欺负太久，也不会主动挑起冲突
• 总是背叛（Always Defect） 在短期对局中可能表现不错，但遇到同样策略时会陷入双输
• 帕夫洛夫（Pavlov） 在重复博弈中也很有竞争力

这个实验说明了一个博弈论的洞见：在重复博弈中，策略的选择比一次性决策更重要。针锋相对、得饶人处且饶人——这些策略在进化中是有优势的。

---

13. 博弈论思维在商业决策中的应用

13.1 定价策略：跟随还是差异化？

想象你是可乐市场的后来者，面对可口可乐和百事可乐已经建立的品牌优势。你有几个选择：

• 价格战：比大品牌卖得更便宜
• 差异化：针对特定细分市场，比如无糖可乐、气泡水
• 跟随策略：模仿大品牌的定价和产品线

从博弈论角度看，这是一个古诺竞争（Cournot Competition）或者更一般的寡头博弈。每个玩家的最优策略取决于它对竞争对手反应的预期。

13.2 平台经济：先圈用户还是先赚钱？

互联网平台面临的经典博弈是双边市场问题。

以网约车平台为例：乘客越多，司机越愿意加入；司机越多，乘客体验越好。这是一个正反馈循环。

但问题是：先有鸡还是先有蛋？没有足够的司机，乘客不会来；没有足够的乘客，司机也不愿意入驻。

博弈论告诉我们，平台需要设计激励机制来打破这个僵局——比如早期给司机高额补贴吸引供给，给乘客优惠吸引需求。这是一场博弈：平台补贴 vs 用户增长，最终目标是达到一个正的均衡。

13.3 谈判与讨价还价

商务谈判是动态博弈的典型场景。

想象买房：你出价、卖家还价，一来一回直到达成一致。每个参与者都有保留价格（最低/最高能接受的价格），但这个信息是隐藏的。

好的谈判策略需要考虑：

• 耐心：谁更能等，谁就能在谈判中占优
• 可信度：威胁/承诺是否可信
• 信息：我知道什么？我知道对手知道什么？

博弈论提供了Rubinstein讨价还价模型——如果双方都有无限耐心，谈判的均衡结果是双方平分剩余价值。

---

14. 结语：博弈论——理解对抗与合作的通用语言

博弈论之所以在AI时代变得尤为重要，是因为它提供了一套描述策略交互的通用语言和框架。

从AlphaGo的蒙特卡洛树搜索，到GAN的对抗训练，到多智能体系统的协作设计，再到AI安全和价值观对齐——博弈论无处不在。

理解博弈论，不仅是理解经济学和社会科学的一把钥匙，更是理解人工智能前沿问题的必备知识。

当你下次看到两个AI系统互相竞争、或者多个AI Agent协作完成任务时，试着从博弈论的角度分析：

• 参与人是谁？
• 策略空间是什么？
• 收益函数是什么？
• 均衡在哪里？
• 这个均衡是稳定的吗？是帕累托最优的吗？

这些问题会帮你穿透表面，理解AI系统行为的本质。

---

参考文献

1. von Neumann, J., & Morgenstern, O. (1944). Theory of Games and Economic Behavior. Princeton University Press.
2. Nash, J. (1950). Equilibrium Points in N-Person Games. PNAS, 36(1), 48-49.
3. von Neumann, J. (1928). Zur Theorie der Gesellschaftsspiele. Mathematische Annalen, 100(1), 295-320.
4. Goodfellow, I., et al. (2014). Generative Adversarial Networks. NeurIPS.
5. Shoham, Y., & Leyton-Brown, K. (2008). Multiagent Systems: Algorithmic, Game-Theoretic, and Logical Foundations. Cambridge University Press.
6. Nisan, N., et al. (2007). Algorithmic Game Theory. Cambridge University Press.
7. Myerson, R. B. (1991). Game Theory: Analysis of Conflict. Harvard University Press.
8. Hart, S., & Mas-Colell, A. (2000). A Simple Adaptive Procedure Leading to Correlated Equilibrium. Econometrica, 68(5), 1127-1150.
9. Axelrod, R. (1984). The Evolution of Cooperation. Basic Books.
10. Vickrey, W. (1961). Counterspeculation, Auctions, and Competitive Sealed Tenders. Journal of Finance, 16(1), 8-37.