CPPI 组合保险：固定比例机制与 1987 年的教训

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

def cppi_rebalance(value, floor, m, risky_return):
    """
    单步 CPPI 再平衡。
    
    参数
    ----
    value : float        当前组合总价值
    floor  : float        当前底线价值（随时间增长）
    m      : float        风险乘数
    risky_return : float  风险资产在本期收益率
    
    返回
    ----
    new_value, exposure   再平衡后的组合价值与风险敞口
    """
    cushion = value - floor
    # 防护：敞口不能为负，也不能超过总资产
    exposure = max(0.0, min(m * cushion, value))
    # 安全资产部分
    safe = value - exposure
    # 下一期：风险资产按 risky_return 增长，安全资产假设本步不增值（简化）
    new_value = exposure * (1 + risky_return) + safe
    return new_value, exposure


def simulate_cppi(n_steps, mu, sigma, m=3, floor_init=0.9, seed=42):
    """
    蒙特卡洛模拟 CPPI 路径。
    mu, sigma : 风险资产年化漂移与波动
    floor_init : 初始底线占初始价值比例
    """
    rng = np.random.default_rng(seed)
    dt = 1.0 / 252.0
    value = 1.0
    floor = floor_init
    floor_growth = np.exp(0.02 * dt)   # 底线按 2% 无风险利率增长
    values, floors, exposures = [value], [floor], [0.0]
    
    for _ in range(n_steps):
        # 生成日收益（几何布朗运动）
        z = rng.standard_normal()
        risky_ret = (mu - 0.5 * sigma ** 2) * dt + sigma * np.sqrt(dt) * z
        value, exp = cppi_rebalance(value, floor, m, risky_ret)
        floor *= floor_growth
        values.append(value)
        floors.append(floor)
        exposures.append(exp)
    
    return pd.DataFrame({
        "value": values,
        "floor": floors,
        "exposure": exposures,
    })


# 运行一次模拟
df = simulate_cppi(n_steps=252, mu=0.08, sigma=0.20, m=3)
print(f"期末价值: {df['value'].iloc[-1]:.4f}")
print(f"最低价值: {df['value'].min():.4f}  (底线: {df['floor'].min():.4f})")

def crash_spiral_demo():
    """
    演示顺周期卖出如何自我强化。
    假设市场有 N 个 CPPI 账户，每个在下跌时按比例减仓。
    """
    n_accounts = 1000
    m = 3
    # 初始组合价值均为 1，底线 0.9
    values = np.ones(n_accounts)
    floors = np.full(n_accounts, 0.9)
    
    price_index = [1.0]
    for step in range(10):
        # 本步市场冲击：由所有账户的卖出行为共同决定
        # 简化：卖出量越大，价格跌得越多
        total_sell = 0.0
        for i in range(n_accounts):
            cushion = values[i] - floors[i]
            target_exp = max(0, m * cushion)
            current_exp = values[i]  # 假设全仓风险资产
            sell = max(0, current_exp - target_exp)
            total_sell += sell
            values[i] = target_exp * 0.97 + (values[i] - target_exp)  # 留安全部分
        # 卖压转化为价格下跌
        price_drop = total_sell / n_accounts * 0.5
        new_price = price_index[-1] * (1 - price_drop)
        price_index.append(new_price)
        # 价格下跌进一步压低所有组合价值
        values *= new_price / price_index[-2]
    
    return price_index

spiral = crash_spiral_demo()
print("价格指数序列:", [f"{p:.3f}" for p in spiral])