!pip install -q japanize-matplotlib
import japanize_matplotlib

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 0.0/4.1 MB ? eta -:--:--
     ━━━╺━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 0.3/4.1 MB 9.8 MB/s eta 0:00:01
     ━━━━━━━━━━━━━━━━━━━━━━━━━━╸━━━━━━━━━━━━━ 2.8/4.1 MB 40.4 MB/s eta 0:00:01
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 4.1/4.1 MB 42.5 MB/s eta 0:00:00
  Preparing metadata (setup.py) ... done
  Building wheel for japanize-matplotlib (setup.py) ... done

%%writefile model.py
# -*- coding: utf-8 -*-
"""
Automation and Repression: a toy model + JRF's attention-labor extension
==========================================================================

ベースモデル (Acemoglu, Gitmez & Shadmehr "Automation and Repression",
NBER w35336 の定性的結論を単純化して再現したもの):

  資本家国家は (a, r, tau) を選ぶ:
    a   : 自動化水準 [0,1]
    r   : 弾圧強度   [0,1]
    tau : 再分配率   [0,1]

  資本シェア s(a)    = s0 + (1-s0)*a        (自動化が進むほど資本分配率が上がる)
  生産      Y(K,a)   = K^alpha * (a_eff)^beta   (a_eff = a + eps, 自動化ゼロでも生産はできる)
  反乱成功確率 P_revolt = clip(theta * s(a) * (1-r) * (1-tau), 0, 1)
      - inequality (s(a)) が高いほど反乱動機は強まる
      - repression (r) と redistribution (tau) はどちらも反乱を抑える代替手段
  弾圧コスト C_r(r) = c_r * r^2 * K   (体制が大きいほど弾圧装置の絶対コストも大きい)

  資本家の目的関数 (ベースライン):
    V_base = (1 - P_revolt) * (1-tau) * s(a) * Y(K,a) - C_r(r)

  → 反乱の脅威が強く・資本蓄積が進むと、再分配よりも弾圧の方が
    (再分配は継続的なコストだが弾圧は反乱確率を直接下げる) 有利になり、
    長期的に r* -> 1 (完全弾圧) に収斂する、というのが元論文の主結果。


JRFの「注意労働」拡張:
  「賄賂」= AIの出力・目的関数が資本家の意図からハックされること。
  これを防ぐには自動化水準 a に比例した「監査＝注意労働」が要る。

  必要監査量   needed(a) = a
  供給される監査量 supply(r) = 1 - r
      (弾圧が強いほど、市民は情報を隠す・協力しない・粛清されるなどして
       信頼できる監査の担い手が減る、という想定)

  ハック(目的関数上書き)による実現ロス:
    phi(a, r) = phi_max * clip(needed(a) - supply(r), 0, 1)
              = phi_max * clip(a + r - 1, 0, 1)

    → a + r > 1 になった瞬間、つまり「自動化が要求する監査量」を
      「弾圧が押しつぶした後に残る監査供給」が下回った瞬間に、
      資本家が実際に受け取れる収益が目減りし始める。

  拡張版の目的関数:
    V_ext = (1 - P_revolt) * (1-tau) * s(a) * Y(K,a) * (1 - phi(a,r)) - C_r(r)

  この phi(a,r) 項が、r を上げすぎることの「新しいコスト」として働き、
  ベースモデルでは r*->1 に張り付いていた解が、拡張モデルでは
  r* がおおむね 1-a* 付近に頭打ちになる、という予想を検証する。
"""

import numpy as np

# ---- 固定パラメータ ---------------------------------------------------
ALPHA   = 0.35   # 資本の生産弾力性
BETA    = 0.65   # 自動化の生産弾力性
S0      = 0.25   # 自動化ゼロ時点の資本分配率
C_R     = 0.35   # 弾圧コスト係数
PHI_MAX = 0.9    # 監査崩壊時の最大ロス率（資本家が受け取れる収益の減少幅）
EPS     = 0.05   # 自動化ゼロでも生産できるようにするオフセット

GRID_N  = 41     # a, r, tau の探索グリッド解像度


def capital_share(a):
    return S0 + (1 - S0) * a


def output(K, a):
    a_eff = a + EPS
    return (K ** ALPHA) * (a_eff ** BETA)


K0 = 5.0  # 資本蓄積がどの規模から「反乱の脅威が現実味を帯びる」かのスケール


def revolt_prob(a, r, tau, K, theta):
    s = capital_share(a)
    # 資本蓄積が小さいうちは格差が目に見える規模になっておらず脅威は小さい。
    # K が K0 を超えて蓄積が進むほど脅威が theta*s(a) に漸近する。
    scale = K / (K + K0)
    p = theta * s * scale * (1 - r) * (1 - tau)
    return np.clip(p, 0.0, 1.0)


def repression_cost(r, K):
    # 弾圧装置(監視・治安機構)の維持コストは、資本ストックKそのものより
    # 「体制の規模」に緩やかに依存する、という想定で K^0.5 でスケール
    # (原論文は「資本蓄積が進むほど弾圧の相対コストが下がる」という結果な
    #  ので、資本の増加ペースよりコストの増加ペースを緩めておく)
    return C_R * (r ** 2) * (K ** 0.5)


def hijack_loss(a, r):
    """JRFの注意労働拡張: 自動化が要求する監査量 a を、
    弾圧後に残る監査供給 (1-r) が下回った分だけ収益が目減りする。"""
    shortfall = np.clip(a + r - 1.0, 0.0, 1.0)
    return PHI_MAX * shortfall


def objective(a, r, tau, K, theta, extended):
    s = capital_share(a)
    Y = output(K, a)
    p_revolt = revolt_prob(a, r, tau, K, theta)
    gross = (1 - tau) * s * Y
    if extended:
        gross = gross * (1 - hijack_loss(a, r))
    return (1 - p_revolt) * gross - repression_cost(r, K)


_grid = np.linspace(0.0, 1.0, GRID_N)
_A, _R, _TAU = np.meshgrid(_grid, _grid, _grid, indexing="ij")


def best_response(K, theta, extended):
    """(a, r, tau) の総当たりグリッドサーチで capitalist state の
    最適解を求める。厳密な連続最適化ではなく、定性的傾向を見るための
    粗いグリッドサーチで十分。numpy でベクトル化して一括評価する。"""
    V = objective(_A, _R, _TAU, K, theta, extended)
    idx = np.unravel_index(np.argmax(V), V.shape)
    a, r, tau = _grid[idx[0]], _grid[idx[1]], _grid[idx[2]]
    return (a, r, tau), V[idx]


if __name__ == "__main__":
    # 簡単な動作確認: K を固定して baseline / extended を比較
    K = 5.0
    theta = 1.2
    (a_b, r_b, tau_b), v_b = best_response(K, theta, extended=False)
    (a_e, r_e, tau_e), v_e = best_response(K, theta, extended=True)
    print(f"[baseline] a*={a_b:.2f} r*={r_b:.2f} tau*={tau_b:.2f} V={v_b:.3f}")
    print(f"[extended] a*={a_e:.2f} r*={r_e:.2f} tau*={tau_e:.2f} V={v_e:.3f}")

Writing model.py

!python model.py

[baseline] a*=1.00 r*=0.70 tau*=0.00 V=1.103
[extended] a*=0.88 r*=0.12 tau*=0.00 V=0.781

# -*- coding: utf-8 -*-
"""K・脅威水準thetaを動かして baseline / extended モデルを比較し、図を出力する。"""

import numpy as np
import matplotlib
#matplotlib.use("Agg")
import matplotlib.pyplot as plt
from matplotlib import font_manager

from model import best_response

# 日本語ラベル用フォント（環境にIPAexGothic等があれば使う。なければ英語表記にフォールバック）
JP_FONT = None
for name in ["IPAexGothic", "Noto Sans CJK JP", "TakaoGothic", "Noto Sans JP"]:
    matches = [f for f in font_manager.fontManager.ttflist if name.lower() in f.name.lower()]
    if matches:
        JP_FONT = matches[0].name
        break
if JP_FONT:
    plt.rcParams["font.family"] = JP_FONT

K_VALUES = np.array([0.5, 1, 2, 3, 5, 8, 12, 18, 25, 35, 50, 70])
THETA = 1.5

results = {"base": {"a": [], "r": [], "tau": []},
           "ext":  {"a": [], "r": [], "tau": []}}

for K in K_VALUES:
    (a, r, tau), _ = best_response(K, THETA, extended=False)
    results["base"]["a"].append(a)
    results["base"]["r"].append(r)
    results["base"]["tau"].append(tau)

    (a, r, tau), _ = best_response(K, THETA, extended=True)
    results["ext"]["a"].append(a)
    results["ext"]["r"].append(r)
    results["ext"]["tau"].append(tau)

# ---- 図1: K に対する最適 r*, a*, tau* の推移 (baseline vs extended) ----
fig, axes = plt.subplots(1, 3, figsize=(15, 4.5))

labels = ["a*(automation)", "r*(repression)", "tau*(redistribution)"]
keys = ["a", "r", "tau"]
for ax, key, label in zip(axes, keys, labels):
    ax.plot(K_VALUES, results["base"][key], "o-", color="crimson",
            label="Baseline (Acemoglu-style)")
    ax.plot(K_VALUES, results["ext"][key], "s-", color="steelblue",
            label="Extended (+ attention labor)")
    ax.set_xlabel("Capital stock K")
    ax.set_ylabel(label)
    ax.set_ylim(-0.05, 1.05)
    ax.set_title(label)
    ax.grid(alpha=0.3)

axes[1].legend(loc="lower right", fontsize=9)
fig.suptitle("資本蓄積(K)に対する資本家国家の最適政策: ベースライン vs 注意労働拡張  (theta=%.1f)" % THETA)
fig.tight_layout(rect=[0, 0, 1, 0.94])
fig.savefig("fig1_policy_vs_K.png", dpi=150)
print("saved fig1_policy_vs_K.png")
plt.show()

# ---- 図2: (K, theta) 平面での r* のヒートマップ比較 ----
K_grid = np.linspace(0.5, 60, 24)
theta_grid = np.linspace(0.5, 2.5, 24)

R_base = np.zeros((len(theta_grid), len(K_grid)))
R_ext  = np.zeros((len(theta_grid), len(K_grid)))

for i, th in enumerate(theta_grid):
    for j, K in enumerate(K_grid):
        (_, r, _), _ = best_response(K, th, extended=False)
        R_base[i, j] = r
        (_, r, _), _ = best_response(K, th, extended=True)
        R_ext[i, j] = r

fig2, axes2 = plt.subplots(1, 2, figsize=(11, 5.6), sharey=True)
im0 = axes2[0].pcolormesh(K_grid, theta_grid, R_base, vmin=0, vmax=1, cmap="Reds", shading="auto")
axes2[0].set_title("Baseline: r*(K, theta)")
axes2[0].set_xlabel("Capital stock K")
axes2[0].set_ylabel("Revolt threat theta")

im1 = axes2[1].pcolormesh(K_grid, theta_grid, R_ext, vmin=0, vmax=1, cmap="Reds", shading="auto")
axes2[1].set_title("Extended (+attention labor): r*(K, theta)")
axes2[1].set_xlabel("Capital stock K")

fig2.colorbar(im1, ax=axes2, label="optimal repression r*", shrink=0.85)
fig2.suptitle("弾圧強度r*のレジーム図: ベースラインは資本蓄積とともに全面弾圧に張り付くが、\n"
              "注意労働制約を入れると弾圧が頭打ちになる", fontsize=11, y=1.06)
fig2.tight_layout(rect=[0, 0, 1, 0.90])
fig2.savefig("fig2_regime_map.png", dpi=150, bbox_inches="tight")
print("saved fig2_regime_map.png")
plt.show()

# ---- 数値サマリをテキストでも出力 ----
with open("summary.txt", "w") as f:
    f.write("K\t a_base r_base tau_base | a_ext r_ext tau_ext\n")
    for i, K in enumerate(K_VALUES):
        f.write(f"{K:>5}\t {results['base']['a'][i]:.2f}   {results['base']['r'][i]:.2f}   "
                f"{results['base']['tau'][i]:.2f}   | "
                f"{results['ext']['a'][i]:.2f}   {results['ext']['r'][i]:.2f}   "
                f"{results['ext']['tau'][i]:.2f}\n")
print("saved summary.txt")
!cat summary.txt

saved fig1_policy_vs_K.png

/tmp/ipykernel_650/3585420491.py:89: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.
  fig2.tight_layout(rect=[0, 0, 1, 0.90])

saved fig2_regime_map.png

saved summary.txt
K	 a_base r_base tau_base | a_ext r_ext tau_ext
  0.5	 1.00   0.23   0.00   | 1.00   0.00   0.00
  1.0	 1.00   0.38   0.00   | 1.00   0.00   0.00
  2.0	 1.00   0.58   0.00   | 1.00   0.00   0.00
  3.0	 1.00   0.70   0.00   | 0.90   0.10   0.00
  5.0	 1.00   0.88   0.00   | 0.80   0.20   0.03
  8.0	 1.00   1.00   0.00   | 0.85   0.15   0.28
 12.0	 1.00   1.00   0.00   | 0.90   0.10   0.43
 18.0	 1.00   1.00   0.00   | 0.90   0.10   0.50
 25.0	 1.00   1.00   0.00   | 0.93   0.08   0.55
 35.0	 1.00   1.00   0.00   | 0.93   0.08   0.58
 50.0	 1.00   1.00   0.00   | 0.95   0.05   0.60
 70.0	 1.00   1.00   0.00   | 0.95   0.05   0.60

%%writefile model_v2.py
# -*- coding: utf-8 -*-
"""
v2: 監査需要のKスケーリング + 監査主体の「少数エリート」channel
     + エリートも人間である以上「子供の教育・再生産」が要るという制約
=====================================================================

ご指摘への回答: needed(a) = a (0〜1の"割合")のままでは、AI/資本ストック
自体が巨大化していく効果を捉えられません。自動化"率"が同じでも、資本
ストックKが大きくなれば監査すべき対象の絶対量は増えるはずです。そこで:

    needed(a, K) = a * K**GAMMA        (GAMMA=0.5)

  一方、v1では監査の供給側 supply_broad も K に比例させていましたが、
  それだと「必要量も供給力も同じ速度でKに比例して増える」ため、Kが
  大きくなること自体の効果が相殺されてしまいます。実際には、資本
  (AI・ロボット等)の蓄積スピードと、監査を担える"人口"の増加スピードは
  一致しません(自動化はまさに人口成長と切り離して資本を増やす技術)。
  そこで supply_broad は K に依存させず、ほぼ一定の"市民監査キャパシティ"
  として固定します:

    supply_broad(r) = N_BAR * (1 - r)   (N_BAR: 固定)

  これにより、K が大きくなるほど「必要な監査量」が「固定された市民の
  監査キャパシティ」を追い越していく、というギャップが生じます。


少数エリート監査主体 (今回追加):
  資本家は追加コスト C_E(E) = c_E * E^2 を払うことで、忠誠なエリート
  監査要員 E を確保できる (二次コストなので、多く確保しようとするほど
  一人あたりの限界費用が上がる=希少な忠誠人材の奪い合いを表現)。

  エリートの監査供給:
    supply_elite(E, r) = E * (1 - r)**DELTA

  DELTA は「エリートの監査能力が、社会全体の抑圧レベルからどれだけ
  独立していられるか」を表すパラメータ:
    DELTA = 0   : エリートは抑圧の影響を一切受けない(買収・囲い込みで
                  完全に隔離できる、という楽観的仮定)
    DELTA > 0   : エリートも結局は人間であり、その子供が新しい世代の
                  監査要員として育つには教育・安定した社会基盤が要る。
                  社会全体への抑圧が強まれば、エリート自身の再生産
                  (教育・技能継承)にも影響が及び、供給力が目減りする。
                  DELTA を 1 に近づけるほど「エリートも結局は民衆から
                  隔絶できない」度合いが強くなる。

  supply(a,r,E,K) = supply_broad(r) + supply_elite(E,r)

  phi(a,r,E,K) = phi_max * clip(1 - supply/needed(a,K), 0, 1)   (v1と同じ)


3つのレジームを比較する:
  regime "broad_only"   : E=0 に固定 (エリート監査そのものが存在しない)
  regime "elite_immune" : DELTA=0   (エリートは抑圧から完全に隔離できる)
  regime "elite_bound"  : DELTA=0.6 (エリートも再生産に社会基盤を要る)
"""

import numpy as np

# ---- 固定パラメータ (v1から流用) --------------------------------------
ALPHA   = 0.35
BETA    = 0.65
S0      = 0.25
C_R     = 0.06
PHI_MAX = 0.9
EPS     = 0.05
K0      = 5.0

GAMMA   = 0.5     # 監査需要・自動化のK依存度
N_BAR   = 1.2      # 固定された「市民監査キャパシティ」の規模
C_ELITE = 0.15     # エリート監査要員1人あたりの限界費用係数(二次コスト)

GRID_N  = 25       # a, r, tau, E の探索グリッド解像度 (4次元なのでv1より粗い)


def capital_share(a):
    return S0 + (1 - S0) * a


def output(K, a):
    a_eff = a + EPS
    return (K ** ALPHA) * (a_eff ** BETA)


def revolt_prob(a, r, tau, K, theta):
    s = capital_share(a)
    scale = K / (K + K0)
    p = theta * s * scale * (1 - r) * (1 - tau)
    return np.clip(p, 0.0, 1.0)


def repression_cost(r, K):
    return C_R * (r ** 2) * (K ** 0.5)


def needed_audit(a, K):
    return a * (K ** GAMMA)


def audit_supply(r, E, K, delta):
    broad = N_BAR * (1 - r)
    elite = E * (1 - r) ** delta
    return broad + elite


def hijack_loss(a, r, E, K, delta):
    need = needed_audit(a, K)
    supply = audit_supply(r, E, K, delta)
    with np.errstate(divide="ignore", invalid="ignore"):
        ratio = np.where(need > 1e-9, supply / need, 1.0)
    shortfall_frac = np.clip(1.0 - ratio, 0.0, 1.0)
    return PHI_MAX * shortfall_frac


def elite_cost(E):
    return C_ELITE * (E ** 2)


def objective(a, r, tau, E, K, theta, delta, elite_enabled):
    s = capital_share(a)
    Y = output(K, a)
    p_revolt = revolt_prob(a, r, tau, K, theta)
    gross = (1 - tau) * s * Y
    E_eff = E if elite_enabled else np.zeros_like(E)
    phi = hijack_loss(a, r, E_eff, K, delta)
    gross = gross * (1 - phi)
    cost = repression_cost(r, K) + elite_cost(E_eff)
    return (1 - p_revolt) * gross - cost


_grid = np.linspace(0.0, 1.0, GRID_N)
_A, _R, _TAU, _E = np.meshgrid(_grid, _grid, _grid, _grid, indexing="ij")
# エリートの探索上限は 0〜1 だと sqrt(K) が大きいKでは狭すぎるので、
# Kに応じてエリート候補の範囲をスケールして渡す (呼び出し側で調整)


def best_response(K, theta, delta, elite_enabled, e_max=None):
    """4次元 (a, r, tau, E) の総当たりグリッドサーチ。
    e_max: Eの探索上限 (Kが大きいときは必要監査量も大きいのでレンジを広げる)"""
    if e_max is None:
        e_max = max(1.0, needed_audit(1.0, K))
    E_local = _E * e_max
    V = objective(_A, _R, _TAU, E_local, K, theta, delta, elite_enabled)
    idx = np.unravel_index(np.argmax(V), V.shape)
    a, r, tau = _grid[idx[0]], _grid[idx[1]], _grid[idx[2]]
    e = E_local[idx]
    return (a, r, tau, e), V[idx]


_grid3 = np.linspace(0.0, 1.0, 41)
_R3, _TAU3, _E3 = np.meshgrid(_grid3, _grid3, _grid3, indexing="ij")


def best_response_fixed_a(K, theta, delta, elite_enabled, a=1.0, e_max=None):
    """自動化水準 a を固定し、(r, tau, E) だけを最適化する版。
    「自動化を絞る」という追加の逃げ道を封じ、抑圧/再分配/エリート投資
    の三者択一だけに絞って v1 との対応を見やすくするための比較用。"""
    if e_max is None:
        e_max = max(1.0, needed_audit(a, K))
    E_local = _E3 * e_max
    a_arr = np.full_like(_R3, a)
    V = objective(a_arr, _R3, _TAU3, E_local, K, theta, delta, elite_enabled)
    idx = np.unravel_index(np.argmax(V), V.shape)
    r, tau = _grid3[idx[0]], _grid3[idx[1]]
    e = E_local[idx]
    return (a, r, tau, e), V[idx]


if __name__ == "__main__":
    K = 40.0
    theta = 1.5
    for label, delta, enabled in [
        ("broad_only  ", 0.0, False),
        ("elite_immune", 0.0, True),
        ("elite_bound ", 0.6, True),
    ]:
        (a, r, tau, e), v = best_response(K, theta, delta, enabled)
        need = needed_audit(a, K)
        sup = audit_supply(r, e, K, delta if enabled else 0.0) if enabled else N_BAR * (1 - r)
        print(f"[{label}] a*={a:.2f} r*={r:.2f} tau*={tau:.2f} E*={e:.2f}  "
              f"needed={need:.2f} supply={sup:.2f}  V={v:.3f}")

Writing model_v2.py

!python model_v2.py

[broad_only  ] a*=0.17 r*=0.12 tau*=0.00 E*=0.00  needed=1.05 supply=1.05  V=0.277
[elite_immune] a*=1.00 r*=1.00 tau*=0.00 E*=1.84  needed=6.32 supply=1.84  V=0.471
[elite_bound ] a*=0.21 r*=0.12 tau*=0.00 E*=0.26  needed=1.32 supply=1.29  V=0.301

# -*- coding: utf-8 -*-
"""v2: K-scaled監査需要 + エリート監査 + 再生産制約の3レジーム比較を描画する。"""

import numpy as np
import matplotlib
#matplotlib.use("Agg")
import matplotlib.pyplot as plt
from matplotlib import font_manager

import model_v2 as m

JP_FONT = None
for name in ["IPAexGothic", "Noto Sans CJK JP", "TakaoGothic", "Noto Sans JP"]:
    matches = [f for f in font_manager.fontManager.ttflist if name.lower() in f.name.lower()]
    if matches:
        JP_FONT = matches[0].name
        break
if JP_FONT:
    plt.rcParams["font.family"] = JP_FONT

THETA = 1.5
K_VALUES = np.array([2, 5, 10, 20, 40, 80, 150, 300, 500])

REGIMES = [
    ("broad_only",   0.0, False, "市民監査のみ (エリート無し)",              "black"),
    ("elite_immune", 0.0, True,  "エリート監査あり・抑圧から完全に隔離 (delta=0)", "crimson"),
    ("elite_bound",  0.6, True,  "エリート監査あり・再生産に社会基盤が必要 (delta=0.6)", "steelblue"),
]

data = {key: {"r": [], "tau": [], "e": [], "need": []} for key, *_ in REGIMES}

for K in K_VALUES:
    need = m.needed_audit(1.0, K)
    for key, delta, enabled, _, _ in REGIMES:
        (a, r, tau, e), v = m.best_response_fixed_a(K, THETA, delta, enabled, a=1.0)
        data[key]["r"].append(r)
        data[key]["tau"].append(tau)
        data[key]["e"].append(e)
        data[key]["need"].append(need)

fig, axes = plt.subplots(1, 3, figsize=(16, 4.8))

for ax, field, title in zip(axes, ["r", "tau", "e"],
                             ["r*(repression)", "tau*(redistribution)", "E*(elite audit investment)"]):
    for key, delta, enabled, label, color in REGIMES:
        ax.plot(K_VALUES, data[key][field], "o-", color=color, label=label)
    ax.set_xscale("log")
    ax.set_xlabel("Capital stock K (log scale)")
    ax.set_ylabel(title)
    ax.set_title(title)
    ax.grid(alpha=0.3)

axes[0].legend(loc="center left", bbox_to_anchor=(0.0, -0.55), fontsize=8.5, ncol=1)
fig.suptitle("自動化 a=1 固定・脅威 theta=%.1f: 3つの監査レジームでの最適 (r*, tau*, E*) の推移" % THETA,
             fontsize=12)
fig.tight_layout(rect=[0, 0.05, 1, 0.93])
fig.savefig("fig3_elite_regimes.png", dpi=150, bbox_inches="tight")
print("saved fig3_elite_regimes.png")
plt.show()

with open("summary_v2.txt", "w") as f:
    f.write("K\tneed\t| r_broad  tau_broad | r_eliteImmune tau_eliteImmune E_eliteImmune | r_eliteBound tau_eliteBound E_eliteBound\n")
    for i, K in enumerate(K_VALUES):
        row = f"{K:>4}\t{data['broad_only']['need'][i]:.2f}\t| "
        row += f"{data['broad_only']['r'][i]:.2f}      {data['broad_only']['tau'][i]:.2f}      | "
        row += f"{data['elite_immune']['r'][i]:.2f}          {data['elite_immune']['tau'][i]:.2f}            {data['elite_immune']['e'][i]:.2f}       | "
        row += f"{data['elite_bound']['r'][i]:.2f}         {data['elite_bound']['tau'][i]:.2f}           {data['elite_bound']['e'][i]:.2f}\n"
        f.write(row)
print("saved summary_v2.txt")
!cat summary_v2.txt

saved fig3_elite_regimes.png

saved summary_v2.txt
K	need	| r_broad  tau_broad | r_eliteImmune tau_eliteImmune E_eliteImmune | r_eliteBound tau_eliteBound E_eliteBound
   2	1.41	| 0.00      0.00      | 0.83          0.00            1.20       | 0.30         0.00           0.71
   5	2.24	| 0.38      0.00      | 1.00          0.00            2.24       | 0.43         0.00           1.01
  10	3.16	| 0.53      0.00      | 1.00          0.00            2.21       | 0.55         0.00           0.71
  20	4.47	| 0.18      0.50      | 1.00          0.00            2.01       | 0.62         0.00           0.56
  40	6.32	| 0.12      0.58      | 1.00          0.00            1.74       | 0.15         0.55           0.32
  80	8.94	| 0.10      0.60      | 1.00          0.00            1.57       | 0.10         0.60           0.22
 150	12.25	| 0.08      0.62      | 0.10          0.62            0.31       | 0.10         0.62           0.31
 300	17.32	| 0.08      0.62      | 0.10          0.62            0.43       | 0.08         0.62           0.43
 500	22.36	| 0.05      0.65      | 0.05          0.65            0.00       | 0.05         0.65           0.00

%%writefile model_v3.py
# -*- coding: utf-8 -*-
"""
v3: 監査需要のKスケーリング + 監査主体の「少数エリート」channel
     + エリートも人間である以上「子供の教育・再生産」が要るという制約
=====================================================================

ご指摘への回答: needed(a) = a (0〜1の"割合")のままでは、AI/資本ストック
自体が巨大化していく効果を捉えられません。自動化"率"が同じでも、資本
ストックKが大きくなれば監査すべき対象の絶対量は増えるはずです。そこで:

    needed(a, K) = a * K**GAMMA        (GAMMA=0.5)

  一方、v1では監査の供給側 supply_broad も K に比例させていましたが、
  それだと「必要量も供給力も同じ速度でKに比例して増える」ため、Kが
  大きくなること自体の効果が相殺されてしまいます。実際には、資本
  (AI・ロボット等)の蓄積スピードと、監査を担える"人口"の増加スピードは
  一致しません(自動化はまさに人口成長と切り離して資本を増やす技術)。
  そこで supply_broad は K に依存させず、ほぼ一定の"市民監査キャパシティ"
  として固定します:

    supply_broad(r) = N_BAR * (1 - r)   (N_BAR: 固定)

  これにより、K が大きくなるほど「必要な監査量」が「固定された市民の
  監査キャパシティ」を追い越していく、というギャップが生じます。


少数エリート監査主体 (今回追加):
  資本家は追加コスト C_E(E) = c_E * E^2 を払うことで、忠誠なエリート
  監査要員 E を確保できる (二次コストなので、多く確保しようとするほど
  一人あたりの限界費用が上がる=希少な忠誠人材の奪い合いを表現)。

  エリートの監査供給:
    supply_elite(E, r) = E * (1 - r)**DELTA

  DELTA は「エリートの監査能力が、社会全体の抑圧レベルからどれだけ
  独立していられるか」を表すパラメータ:
    DELTA = 0   : エリートは抑圧の影響を一切受けない(買収・囲い込みで
                  完全に隔離できる、という楽観的仮定)
    DELTA > 0   : エリートも結局は人間であり、その子供が新しい世代の
                  監査要員として育つには教育・安定した社会基盤が要る。
                  社会全体への抑圧が強まれば、エリート自身の再生産
                  (教育・技能継承)にも影響が及び、供給力が目減りする。
                  DELTA を 1 に近づけるほど「エリートも結局は民衆から
                  隔絶できない」度合いが強くなる。

  supply(a,r,E,K) = supply_broad(r) + supply_elite(E,r)

  phi(a,r,E,K) = phi_max * clip(1 - supply/needed(a,K), 0, 1)   (v1と同じ)


3つのレジームを比較する:
  regime "broad_only"   : E=0 に固定 (エリート監査そのものが存在しない)
  regime "elite_immune" : DELTA=0   (エリートは抑圧から完全に隔離できる)
  regime "elite_bound"  : DELTA=0.6 (エリートも再生産に社会基盤を要る)
"""

import numpy as np

# ---- 固定パラメータ (v1から流用) --------------------------------------
ALPHA   = 0.35
BETA    = 0.65
S0      = 0.25
C_R     = 0.06
PHI_MAX = 0.9
EPS     = 0.05
K0      = 5.0

GAMMA   = 0.5     # 監査需要・自動化のK依存度
N_BAR   = 1.2      # 固定された「市民監査キャパシティ」の規模
C_ELITE = 0.15     # エリート監査要員1人あたりの限界費用係数(二次コスト)

# --- v3: Grok の指摘を反映 -----------------------------------------
# tau は「反乱を鎮める」だけでなく「監査供給そのものを増やす」チャネルを持つ。
#   - XI    : 再分配された市民が現場を見せてくれる(協力の対価としての監査)
#   - ZETA  : 学校・治安以外の公共財がエリートの次世代供給を支える
#   - ETA   : 再分配・教育の安定化そのものが反乱動機を減らす(inequality和らげ)
XI   = 1.5
ZETA = 1.0
ETA  = 0.4

GRID_N  = 25       # a, r, tau, E の探索グリッド解像度 (4次元なのでv1より粗い)


def capital_share(a):
    return S0 + (1 - S0) * a


def output(K, a):
    a_eff = a + EPS
    return (K ** ALPHA) * (a_eff ** BETA)


def revolt_prob(a, r, tau, K, theta):
    s = capital_share(a)
    scale = K / (K + K0)
    theta_eff = theta * (1 - ETA * tau)   # v3: 再分配が反乱動機そのものを弱める
    p = theta_eff * s * scale * (1 - r) * (1 - tau)
    return np.clip(p, 0.0, 1.0)


def repression_cost(r, K):
    return C_R * (r ** 2) * (K ** 0.5)


def needed_audit(a, K):
    return a * (K ** GAMMA)


def audit_supply(r, E, K, delta, tau):
    # v3: tau が監査供給そのものを増やすチャネル (Grok案)
    broad = N_BAR * (1 - r) * (1 + XI * tau)
    elite = E * (1 - r) ** delta * (1 + ZETA * tau)
    return broad + elite


def hijack_loss(a, r, E, K, delta, tau):
    need = needed_audit(a, K)
    supply = audit_supply(r, E, K, delta, tau)
    with np.errstate(divide="ignore", invalid="ignore"):
        ratio = np.where(need > 1e-9, supply / need, 1.0)
    shortfall_frac = np.clip(1.0 - ratio, 0.0, 1.0)
    return PHI_MAX * shortfall_frac


def elite_cost(E):
    return C_ELITE * (E ** 2)


def objective(a, r, tau, E, K, theta, delta, elite_enabled):
    s = capital_share(a)
    Y = output(K, a)
    p_revolt = revolt_prob(a, r, tau, K, theta)
    gross = (1 - tau) * s * Y
    E_eff = E if elite_enabled else np.zeros_like(E)
    phi = hijack_loss(a, r, E_eff, K, delta, tau)
    gross = gross * (1 - phi)
    cost = repression_cost(r, K) + elite_cost(E_eff)
    return (1 - p_revolt) * gross - cost


_grid = np.linspace(0.0, 1.0, GRID_N)
_A, _R, _TAU, _E = np.meshgrid(_grid, _grid, _grid, _grid, indexing="ij")
# エリートの探索上限は 0〜1 だと sqrt(K) が大きいKでは狭すぎるので、
# Kに応じてエリート候補の範囲をスケールして渡す (呼び出し側で調整)


def best_response(K, theta, delta, elite_enabled, e_max=None):
    """4次元 (a, r, tau, E) の総当たりグリッドサーチ。
    e_max: Eの探索上限 (Kが大きいときは必要監査量も大きいのでレンジを広げる)"""
    if e_max is None:
        e_max = max(1.0, needed_audit(1.0, K))
    E_local = _E * e_max
    V = objective(_A, _R, _TAU, E_local, K, theta, delta, elite_enabled)
    idx = np.unravel_index(np.argmax(V), V.shape)
    a, r, tau = _grid[idx[0]], _grid[idx[1]], _grid[idx[2]]
    e = E_local[idx]
    return (a, r, tau, e), V[idx]


_grid3 = np.linspace(0.0, 1.0, 41)
_R3, _TAU3, _E3 = np.meshgrid(_grid3, _grid3, _grid3, indexing="ij")


def best_response_fixed_a(K, theta, delta, elite_enabled, a=1.0, e_max=None):
    """自動化水準 a を固定し、(r, tau, E) だけを最適化する版。
    「自動化を絞る」という追加の逃げ道を封じ、抑圧/再分配/エリート投資
    の三者択一だけに絞って v1 との対応を見やすくするための比較用。"""
    if e_max is None:
        e_max = max(1.0, needed_audit(a, K))
    E_local = _E3 * e_max
    a_arr = np.full_like(_R3, a)
    V = objective(a_arr, _R3, _TAU3, E_local, K, theta, delta, elite_enabled)
    idx = np.unravel_index(np.argmax(V), V.shape)
    r, tau = _grid3[idx[0]], _grid3[idx[1]]
    e = E_local[idx]
    return (a, r, tau, e), V[idx]


if __name__ == "__main__":
    K = 40.0
    theta = 1.5
    for label, delta, enabled in [
        ("broad_only  ", 0.0, False),
        ("elite_immune", 0.0, True),
        ("elite_bound ", 0.6, True),
    ]:
        (a, r, tau, e), v = best_response(K, theta, delta, enabled)
        need = needed_audit(a, K)
        sup = audit_supply(r, e, K, delta if enabled else 0.0, tau) if enabled else N_BAR * (1 - r) * (1 + XI * tau)
        phi = hijack_loss(a, r, e if enabled else 0.0, K, delta, tau)
        print(f"[{label}] a*={a:.2f} r*={r:.2f} tau*={tau:.2f} E*={e:.2f}  "
              f"needed={need:.2f} supply={sup:.2f} phi={phi:.2f}  V={v:.3f}")

Writing model_v3.py

!python model_v3.py

[broad_only  ] a*=1.00 r*=0.00 tau*=0.62 E*=0.00  needed=6.32 supply=2.32 phi=0.57  V=0.379
[elite_immune] a*=1.00 r*=1.00 tau*=0.00 E*=1.84  needed=6.32 supply=1.84 phi=0.64  V=0.471
[elite_bound ] a*=1.00 r*=0.00 tau*=0.62 E*=0.79  needed=6.32 supply=3.61 phi=0.39  V=0.446

# -*- coding: utf-8 -*-
"""v3: K-scaled監査需要 + エリート監査 + 再生産制約の3レジーム比較を描画する。"""

import numpy as np
import matplotlib
#matplotlib.use("Agg")
import matplotlib.pyplot as plt
from matplotlib import font_manager

import model_v3 as m

JP_FONT = None
for name in ["IPAexGothic", "Noto Sans CJK JP", "TakaoGothic", "Noto Sans JP"]:
    matches = [f for f in font_manager.fontManager.ttflist if name.lower() in f.name.lower()]
    if matches:
        JP_FONT = matches[0].name
        break
if JP_FONT:
    plt.rcParams["font.family"] = JP_FONT

THETA = 1.5
K_VALUES = np.array([2, 5, 10, 20, 40, 80, 150, 300, 500])

REGIMES = [
    ("broad_only",   0.0, False, "市民監査のみ (エリート無し)",              "black"),
    ("elite_immune", 0.0, True,  "エリート監査あり・抑圧から完全に隔離 (delta=0)", "crimson"),
    ("elite_bound",  0.6, True,  "エリート監査あり・再生産に社会基盤が必要 (delta=0.6)", "steelblue"),
]

data = {key: {"r": [], "tau": [], "e": [], "need": [], "phi": []} for key, *_ in REGIMES}

for K in K_VALUES:
    need = m.needed_audit(1.0, K)
    for key, delta, enabled, _, _ in REGIMES:
        (a, r, tau, e), v = m.best_response_fixed_a(K, THETA, delta, enabled, a=1.0)
        phi = m.hijack_loss(a, r, e if enabled else 0.0, K, delta if enabled else 0.0, tau)
        data[key]["r"].append(r)
        data[key]["tau"].append(tau)
        data[key]["e"].append(e)
        data[key]["need"].append(need)
        data[key]["phi"].append(float(phi))

fig, axes = plt.subplots(1, 4, figsize=(20, 4.8))

for ax, field, title in zip(axes, ["r", "tau", "e", "phi"],
                             ["r*(repression)", "tau*(redistribution)", "E*(elite audit investment)", "phi(hijack loss, lower=better audited)"]):
    for key, delta, enabled, label, color in REGIMES:
        ax.plot(K_VALUES, data[key][field], "o-", color=color, label=label)
    ax.set_xscale("log")
    ax.set_xlabel("Capital stock K (log scale)")
    ax.set_ylabel(title)
    ax.set_title(title)
    ax.grid(alpha=0.3)

axes[0].legend(loc="center left", bbox_to_anchor=(0.0, -0.55), fontsize=8.5, ncol=1)
fig.suptitle("自動化 a=1 固定・脅威 theta=%.1f: 3つの監査レジームでの最適 (r*, tau*, E*) の推移" % THETA,
             fontsize=12)
fig.tight_layout(rect=[0, 0.05, 1, 0.93])
fig.savefig("fig4_v3_elite_regimes.png", dpi=150, bbox_inches="tight")
print("saved fig4_v3_elite_regimes.png")
plt.show()

with open("summary_v3.txt", "w") as f:
    f.write("K\tneed\t| r_broad  tau_broad | r_eliteImmune tau_eliteImmune E_eliteImmune | r_eliteBound tau_eliteBound E_eliteBound\n")
    for i, K in enumerate(K_VALUES):
        row = f"{K:>4}\t{data['broad_only']['need'][i]:.2f}\t| "
        row += f"{data['broad_only']['r'][i]:.2f}      {data['broad_only']['tau'][i]:.2f}      | "
        row += f"{data['elite_immune']['r'][i]:.2f}          {data['elite_immune']['tau'][i]:.2f}            {data['elite_immune']['e'][i]:.2f}       | "
        row += f"{data['elite_bound']['r'][i]:.2f}         {data['elite_bound']['tau'][i]:.2f}           {data['elite_bound']['e'][i]:.2f}\n"
        f.write(row)
print("saved summary_v3.txt")
!cat summary_v3.txt

saved fig4_v3_elite_regimes.png

saved summary_v3.txt
K	need	| r_broad  tau_broad | r_eliteImmune tau_eliteImmune E_eliteImmune | r_eliteBound tau_eliteBound E_eliteBound
   2	1.41	| 0.08      0.18      | 0.83          0.00            1.20       | 0.33         0.03           0.71
   5	2.24	| 0.00      0.48      | 1.00          0.00            2.24       | 0.23         0.33           0.73
  10	3.16	| 0.00      0.55      | 1.00          0.00            2.21       | 0.03         0.53           0.71
  20	4.47	| 0.00      0.60      | 1.00          0.00            2.01       | 0.00         0.60           0.78
  40	6.32	| 0.00      0.62      | 1.00          0.00            1.74       | 0.00         0.62           0.63
  80	8.94	| 0.00      0.62      | 0.08          0.60            0.67       | 0.00         0.62           0.67
 150	12.25	| 0.00      0.62      | 0.08          0.60            0.61       | 0.03         0.62           0.61
 300	17.32	| 0.03      0.62      | 0.05          0.62            0.43       | 0.03         0.62           0.43
 500	22.36	| 0.03      0.62      | 0.05          0.62            0.56       | 0.03         0.62           0.56

%%writefile model_v4_twosector.py
# -*- coding: utf-8 -*-
"""
v4: 第三の局所解 —— 「人間が監視できる経済」と「AIが自由に成長する経済」を分ける
====================================================================

JRFさんの提案:
  人間は人間の経済のみを監視する・監視できる経済に経済を限定する。
  AI自体は(その外側で)成長を続けさせ、人間はその成果を「適度に」取り込む。

  これを、総資本 K_total を2つに分割するモデルとして実装する:

    K_H  = sigma * K_total   (人間が監査・統治する経済。v3のモデルをそのまま適用)
    K_AI = (1-sigma) * K_total  (完全に自律的に成長するAI経済。監査コスト0、
                                  弾圧コスト0、反乱リスク0。ただし目的関数が
                                  人間の意図と一致している保証も無い)

  資本家は sigma を選べる。人間経済セクターは v3 と同じ (a=1 固定、
  r, tau, E を選び、phi(K_H) というハック損失を受ける)。

  AI経済セクターの産出 Y_AI = output(K_AI, 1.0) はそのまま生まれるが、
  資本家がそこから実際に取り込める価値は KAPPA 倍に割り引かれる
  (「導入率」「取引によるつまみ食い」——JRFさんの2025年6月の記事
  [cocolog:95506762] にあった、地球に残るAIが生物・人間保護を
  比較優位・ブランド価値として他のAIと取引する、という構図に近い。
  ここでは逆に人間の側が、自分の目的通りには動いていないかもしれない
  巨大AI経済から、部分的に果実だけを回収する立場になる)。

  総目的関数:
    V_total(sigma, r, tau, E; K_total, theta)
      = V_human_sector(K_H=sigma*K_total, r, tau, E; theta)
        + KAPPA * Y_AI(K_AI=(1-sigma)*K_total)

  期待される結果: K_total が大きくなるにつれ、資本家は sigma を下げて
  「監査できる経済の絶対規模」K_H* を頭打ちにし、それ以外は監査を
  諦めて自由に育つAI経済に回す、という分離が最適解として現れるはず。
"""

import numpy as np
import model_v3 as m

KAPPA = 0.35   # AI経済から資本家が実際に取り込める価値の割引率


def y_ai(k_ai):
    return m.output(k_ai, 1.0)


def human_sector_value(K_H, r, tau, E, theta):
    a = 1.0
    s = m.capital_share(a)
    Y = m.output(K_H, a)
    p_revolt = m.revolt_prob(a, r, tau, K_H, theta)
    phi = m.hijack_loss(a, r, E, K_H, DELTA_HUMAN, tau)
    gross = (1 - tau) * s * Y * (1 - phi)
    cost = m.repression_cost(r, K_H) + m.elite_cost(E)
    return (1 - p_revolt) * gross - cost


DELTA_HUMAN = 0.6   # 人間経済セクター内のエリート監査も再生産制約付きとする


def total_value(sigma, r, tau, E, K_total, theta):
    K_H = sigma * K_total
    K_AI = (1 - sigma) * K_total
    v_human = human_sector_value(K_H, r, tau, E, theta)
    v_ai = KAPPA * y_ai(K_AI)
    return v_human + v_ai


GRID_N4 = 22
_grid4 = np.linspace(0.0, 1.0, GRID_N4)
# sigma (人間経済への配分比率) は最適点が0付近に来ることが分かっているので、
# 0付近を稠密にしたグリッドを使う
_sigma_grid = np.concatenate([
    np.linspace(0.0, 0.05, 26),
    np.linspace(0.05, 1.0, 20)[1:],
])
_SIG, _R4, _TAU4, _E4 = np.meshgrid(_sigma_grid, _grid4, _grid4, _grid4, indexing="ij")


def best_split(K_total, theta, e_max=None):
    if e_max is None:
        e_max = max(1.0, m.needed_audit(1.0, K_total))
    E_local = _E4 * e_max
    K_H = _SIG * K_total
    v_human = human_sector_value(K_H, _R4, _TAU4, E_local, theta)
    v_ai = KAPPA * y_ai((1 - _SIG) * K_total)
    V = v_human + v_ai
    idx = np.unravel_index(np.argmax(V), V.shape)
    sigma, r, tau = _sigma_grid[idx[0]], _grid4[idx[1]], _grid4[idx[2]]
    e = E_local[idx]
    return (sigma, r, tau, e), V[idx]


if __name__ == "__main__":
    for K in [10, 40, 150, 500, 2000, 8000, 30000]:
        (sigma, r, tau, e), v = best_split(K, 1.5)
        K_H = sigma * K
        K_AI = (1 - sigma) * K
        need = m.needed_audit(1.0, K_H)
        print(f"K_total={K:>7.0f}  sigma*={sigma:.2f}  K_H*={K_H:8.2f}  K_AI*={K_AI:10.2f}  "
              f"r*={r:.2f} tau*={tau:.2f} E*={e:.2f}  need(K_H)={need:.2f}  V={v:.3f}")

Writing model_v4_twosector.py

!python model_v4_twosector.py

K_total=     10  sigma*=0.15  K_H*=    1.50  K_AI*=      8.50  r*=0.29 tau*=0.00 E*=0.45  need(K_H)=1.22  V=1.623
K_total=     40  sigma*=0.04  K_H*=    1.44  K_AI*=     38.56  r*=0.38 tau*=0.00 E*=0.60  need(K_H)=1.20  V=2.158
K_total=    150  sigma*=0.01  K_H*=    1.20  K_AI*=    148.80  r*=0.43 tau*=0.00 E*=0.58  need(K_H)=1.10  V=2.936
K_total=    500  sigma*=0.00  K_H*=    1.00  K_AI*=    499.00  r*=0.14 tau*=0.00 E*=0.00  need(K_H)=1.00  V=3.988
K_total=   2000  sigma*=0.00  K_H*=    4.00  K_AI*=   1996.00  r*=0.00 tau*=0.43 E*=0.00  need(K_H)=2.00  V=5.810
K_total=   8000  sigma*=0.00  K_H*=   16.00  K_AI*=   7984.00  r*=0.00 tau*=0.57 E*=0.00  need(K_H)=4.00  V=8.824
K_total=  30000  sigma*=0.00  K_H*=   60.00  K_AI*=  29940.00  r*=0.00 tau*=0.62 E*=0.00  need(K_H)=7.75  V=13.687

# -*- coding: utf-8 -*-
import numpy as np
import matplotlib
#matplotlib.use("Agg")
import matplotlib.pyplot as plt
from matplotlib import font_manager

import model_v3 as m
import model_v4_twosector as m4

JP_FONT = None
for name in ["IPAexGothic", "Noto Sans CJK JP", "TakaoGothic", "Noto Sans JP"]:
    matches = [f for f in font_manager.fontManager.ttflist if name.lower() in f.name.lower()]
    if matches:
        JP_FONT = matches[0].name
        break
if JP_FONT:
    plt.rcParams["font.family"] = JP_FONT

THETA = 1.5
K_TOTAL_VALUES = np.array([5, 10, 20, 40, 80, 150, 300, 600, 1200, 2500, 5000, 12000, 30000, 80000])

sigma_list, KH_list, KAI_list, r_list, tau_list, e_list, phi_list = [], [], [], [], [], [], []

for K in K_TOTAL_VALUES:
    (sigma, r, tau, e), v = m4.best_split(K, THETA)
    K_H = sigma * K
    K_AI = (1 - sigma) * K
    phi = m.hijack_loss(1.0, r, e, K_H, m4.DELTA_HUMAN, tau)
    sigma_list.append(sigma); KH_list.append(K_H); KAI_list.append(K_AI)
    r_list.append(r); tau_list.append(tau); e_list.append(e); phi_list.append(float(phi))

fig, axes = plt.subplots(1, 3, figsize=(16, 4.8))

ax = axes[0]
ax.loglog(K_TOTAL_VALUES, K_TOTAL_VALUES, "k--", alpha=0.4, label="K_H = K_total (対角線)")
ax.loglog(K_TOTAL_VALUES, KH_list, "o-", color="steelblue", label="K_H* (人間が監査する経済)")
ax.loglog(K_TOTAL_VALUES, KAI_list, "s-", color="crimson", label="K_AI* (自律的に育つAI経済)")
ax.set_xlabel("総資本 K_total (log)")
ax.set_ylabel("配分される資本 (log)")
ax.set_title("資本配分: 監査可能な経済 vs 自由に育つAI経済")
ax.legend(fontsize=8.5)
ax.grid(alpha=0.3, which="both")

ax = axes[1]
ax.semilogx(K_TOTAL_VALUES, r_list, "o-", color="crimson", label="r* (人間経済内の弾圧)")
ax.semilogx(K_TOTAL_VALUES, tau_list, "s-", color="steelblue", label="tau* (人間経済内の再分配)")
ax.semilogx(K_TOTAL_VALUES, phi_list, "^-", color="darkorange", label="phi (人間経済内のハック損失)")
ax.set_xlabel("総資本 K_total (log)")
ax.set_ylim(-0.05, 1.05)
ax.set_title("「人間経済」内部の状態: 分離しない場合と違い低位で安定")
ax.legend(fontsize=8.5)
ax.grid(alpha=0.3)

ax = axes[2]
sigma_arr = np.array(sigma_list)
ax.semilogx(K_TOTAL_VALUES, sigma_arr, "o-", color="black")
ax.set_xlabel("総資本 K_total (log)")
ax.set_ylabel("sigma* (人間経済に残す資本比率)")
ax.set_title("sigma* は K_total とともに一貫して低下")
ax.grid(alpha=0.3)

fig.suptitle("第三の局所解: 「人間経済」を監査可能な規模に留め、残りはAI経済として自由に育てる", fontsize=12)
fig.tight_layout(rect=[0, 0, 1, 0.93])
fig.savefig("fig5_two_sector.png", dpi=150, bbox_inches="tight")
print("saved fig5_two_sector.png")
plt.show()

with open("summary_v4.txt", "w") as f:
    f.write("K_total\tsigma*\tK_H*\tK_AI*\tr*\ttau*\tE*\tphi\n")
    for i, K in enumerate(K_TOTAL_VALUES):
        f.write(f"{K}\t{sigma_list[i]:.3f}\t{KH_list[i]:.2f}\t{KAI_list[i]:.2f}\t"
                f"{r_list[i]:.2f}\t{tau_list[i]:.2f}\t{e_list[i]:.2f}\t{phi_list[i]:.2f}\n")
print("saved summary_v4.txt")
!cat summary_v4.txt

saved fig5_two_sector.png

saved summary_v4.txt
K_total	sigma*	K_H*	K_AI*	r*	tau*	E*	phi
5	0.250	1.25	3.75	0.33	0.00	0.43	0.00
10	0.150	1.50	8.50	0.29	0.00	0.45	0.00
20	0.048	0.96	19.04	0.43	0.00	0.43	0.00
40	0.036	1.44	38.56	0.38	0.00	0.60	0.00
80	0.016	1.28	78.72	0.33	0.00	0.43	0.00
150	0.008	1.20	148.80	0.43	0.00	0.58	0.00
300	0.006	1.80	298.20	0.38	0.00	0.82	0.00
600	0.002	1.20	598.80	0.10	0.00	0.00	0.01
1200	0.002	2.40	1197.60	0.05	0.24	0.00	0.00
2500	0.002	5.00	2495.00	0.00	0.48	0.00	0.07
5000	0.002	10.00	4990.00	0.00	0.52	0.00	0.29
12000	0.002	24.00	11976.00	0.00	0.62	0.00	0.47
30000	0.002	60.00	29940.00	0.00	0.62	0.00	0.63
80000	0.002	160.00	79840.00	0.00	0.62	0.00	0.74

%%writefile model_v5_interface.py
# -*- coding: utf-8 -*-
"""
v5: 資本を割るのではなく「接続口」を割る
========================================

ChatGPT/Grok の指摘: v4 は「資本ストックそのものを分割する」モデルだったが、
JRFさんの元の発想は「AI全体を理解する」のではなく「AIが人間経済に接続する
面(インターフェース)を監査する」ことだったはず。v4はAI経済側に監査コスト・
弾圧コスト・反乱リスク・ハックが一切無く、分離が強すぎた。

そこで、K_AI をどれだけ巨大化させてもよいことにし、そこから人間経済に
「輸入」する量だけを比率 x∈[0,1] で絞る、というモデルに変更する。

  needed(K_H, x, K_AI) = K_H^GAMMA_H + B * x * K_AI^GAMMA_I

    GAMMA_H : 人間経済自身の自動化監査の需要弾性 (今までと同じ 0.5)
    GAMMA_I : 「窓口」の監査需要が相手(AI経済)の規模にどれだけ引きずられるか
        GAMMA_I = 0    : 窓口の太さ(x)だけが負担。相手がいくら大きくても
                         同じ x なら監査コストは変わらない
        GAMMA_I > 0    : 相手が大きいほど、同じ x でも検証すべき絶対量が増える

  captured value = (1-tau) * [ s(1)*Y(K_H,1) + x * Y_AI(K_AI) ] * (1 - phi)

  x はr, tau, E と並んで資本家が選ぶ変数。
"""

import numpy as np
import model_v3 as m

B_COEF = 1.0
GAMMA_H = 0.5
PHI_MAX_V5 = 1.0   # v2/v3ではphi上限を0.9としていたが、ここでは「監査が完全に
                    # 崩壊すれば価値もゼロになりうる」という設定に変える。
                    # 0.9のままだと x=1 が常にどこかで得になってしまい
                    # (Y_AIの成長がalphaで一定の下限0.1を守れば必ず正味プラスに
                    #  なるため)、"適度な導入"という内点解が出てこなかった。


def y_ai(K_AI):
    return m.output(K_AI, 1.0)


def needed_audit_interface(K_H, x, K_AI, gamma_i):
    return (K_H ** GAMMA_H) + B_COEF * x * (K_AI ** gamma_i)


def objective_interface(r, tau, E, x, K_H, K_AI, theta, delta, gamma_i):
    a = 1.0
    s = m.capital_share(a)
    Y_H = m.output(K_H, a)
    gross = (1 - tau) * (s * Y_H + x * y_ai(K_AI))

    need = needed_audit_interface(K_H, x, K_AI, gamma_i)
    supply = m.audit_supply(r, E, K_H, delta, tau)  # 監査供給は人間経済側の基盤に依存
    with np.errstate(divide="ignore", invalid="ignore"):
        ratio = np.where(need > 1e-9, supply / need, 1.0)
    phi = PHI_MAX_V5 * np.clip(1.0 - ratio, 0.0, 1.0)

    p_revolt = m.revolt_prob(a, r, tau, K_H, theta)
    cost = m.repression_cost(r, K_H) + m.elite_cost(E)
    V = (1 - p_revolt) * gross * (1 - phi) - cost
    return V, phi


GRID_N5 = 26
_grid5 = np.linspace(0.0, 1.0, GRID_N5)
_R5, _TAU5, _E5, _X5 = np.meshgrid(_grid5, _grid5, _grid5, _grid5, indexing="ij")


def best_interface(K_H, K_AI, theta, delta, gamma_i, e_max=None):
    if e_max is None:
        e_max = max(1.0, needed_audit_interface(K_H, 1.0, K_AI, gamma_i))
    E_local = _E5 * e_max
    V, phi = objective_interface(_R5, _TAU5, E_local, _X5, K_H, K_AI, theta, delta, gamma_i)
    idx = np.unravel_index(np.argmax(V), V.shape)
    r, tau, x = _grid5[idx[0]], _grid5[idx[1]], _grid5[idx[3]]
    e = E_local[idx]
    return (r, tau, e, x), V[idx], float(phi[idx])


if __name__ == "__main__":
    K_H = 8.0
    theta = 1.5
    delta = 0.6
    for gamma_i in [0.0, 0.25, 0.5]:
        print(f"=== gamma_I={gamma_i} ===")
        for K_AI in [10, 100, 1000, 1e4, 1e5, 1e6]:
            (r, tau, e, x), v, phi = best_interface(K_H, K_AI, theta, delta, gamma_i)
            print(f"  K_AI={K_AI:>10.0f}  x*={x:.2f}  r*={r:.2f} tau*={tau:.2f} E*={e:.2f}  phi={phi:.2f}  V={v:.3f}")

Writing model_v5_interface.py

!python model_v5_interface.py

=== gamma_I=0.0 ===
  K_AI=        10  x*=1.00  r*=0.08 tau*=0.48 E*=1.38  phi=0.00  V=1.202
  K_AI=       100  x*=1.00  r*=0.24 tau*=0.40 E*=1.99  phi=0.00  V=2.227
  K_AI=      1000  x*=1.00  r*=0.48 tau*=0.28 E*=3.37  phi=0.01  V=5.052
  K_AI=     10000  x*=1.00  r*=0.52 tau*=0.24 E*=3.83  phi=0.00  V=12.592
  K_AI=    100000  x*=1.00  r*=0.52 tau*=0.24 E*=3.83  phi=0.00  V=29.571
  K_AI=   1000000  x*=1.00  r*=0.52 tau*=0.24 E*=3.83  phi=0.00  V=67.583
=== gamma_I=0.25 ===
  K_AI=        10  x*=1.00  r*=0.00 tau*=0.52 E*=1.47  phi=0.05  V=0.991
  K_AI=       100  x*=1.00  r*=0.00 tau*=0.52 E*=1.92  phi=0.16  V=1.369
  K_AI=      1000  x*=1.00  r*=0.00 tau*=0.52 E*=2.70  phi=0.26  V=2.062
  K_AI=     10000  x*=1.00  r*=0.00 tau*=0.52 E*=3.59  phi=0.41  V=3.242
  K_AI=    100000  x*=1.00  r*=0.00 tau*=0.52 E*=4.95  phi=0.53  V=5.113
  K_AI=   1000000  x*=1.00  r*=0.00 tau*=0.52 E*=5.51  phi=0.69  V=8.002
=== gamma_I=0.5 ===
  K_AI=        10  x*=0.36  r*=0.00 tau*=0.52 E*=1.20  phi=0.00  V=0.707
  K_AI=       100  x*=0.08  r*=0.00 tau*=0.48 E*=1.03  phi=0.01  V=0.644
  K_AI=      1000  x*=0.00  r*=0.32 tau*=0.40 E*=1.38  phi=0.00  V=0.574
  K_AI=     10000  x*=0.00  r*=0.00 tau*=0.52 E*=0.00  phi=0.24  V=0.503
  K_AI=    100000  x*=0.00  r*=0.00 tau*=0.52 E*=0.00  phi=0.24  V=0.503
  K_AI=   1000000  x*=0.00  r*=0.00 tau*=0.52 E*=0.00  phi=0.24  V=0.503

# -*- coding: utf-8 -*-
import numpy as np
import matplotlib
#matplotlib.use("Agg")
import matplotlib.pyplot as plt
from matplotlib import font_manager

import model_v5_interface as m5

JP_FONT = None
for name in ["IPAexGothic", "Noto Sans CJK JP", "TakaoGothic", "Noto Sans JP"]:
    matches = [f for f in font_manager.fontManager.ttflist if name.lower() in f.name.lower()]
    if matches:
        JP_FONT = matches[0].name
        break
if JP_FONT:
    plt.rcParams["font.family"] = JP_FONT

K_H = 8.0
THETA = 1.5
DELTA = 0.6
K_AI_VALUES = np.array([5, 10, 20, 40, 80, 150, 300, 600, 1200, 2500, 5000, 12000, 30000, 80000, 2e5, 5e5, 1e6])

GAMMAS = [(0.0, "gamma_I=0 (管の太さのみ、相手の規模と無関係)", "black"),
          (0.25, "gamma_I=0.25 (< alpha=0.35: 開けたもの勝ち)", "crimson"),
          (0.5, "gamma_I=0.5 (> alpha=0.35: 開けるほど損)", "steelblue")]

fig, axes = plt.subplots(1, 3, figsize=(16, 4.8))

results = {}
for gamma_i, label, color in GAMMAS:
    xs, rs, taus, phis = [], [], [], []
    for K_AI in K_AI_VALUES:
        (r, tau, e, x), v, phi = m5.best_interface(K_H, K_AI, THETA, DELTA, gamma_i)
        xs.append(x); rs.append(r); taus.append(tau); phis.append(phi)
    results[gamma_i] = (xs, rs, taus, phis)
    axes[0].semilogx(K_AI_VALUES, xs, "o-", color=color, label=label)
    axes[1].semilogx(K_AI_VALUES, phis, "o-", color=color, label=label)
    axes[2].semilogx(K_AI_VALUES, taus, "o-", color=color, label=label)

axes[0].set_title("x*(接続率/導入率)")
axes[0].set_xlabel("K_AI (log)")
axes[0].set_ylim(-0.05, 1.05)
axes[0].legend(fontsize=7.5, loc="upper right")
axes[0].grid(alpha=0.3)

axes[1].set_title("phi (ハック損失)")
axes[1].set_xlabel("K_AI (log)")
axes[1].set_ylim(-0.05, 1.05)
axes[1].grid(alpha=0.3)

axes[2].set_title("tau*(人間経済内の再分配)")
axes[2].set_xlabel("K_AI (log)")
axes[2].set_ylim(-0.05, 1.05)
axes[2].grid(alpha=0.3)

fig.suptitle("接続口モデル: K_H=%.0f 固定でK_AIを動かしたときの x*, phi, tau*" % K_H, fontsize=12)
fig.tight_layout(rect=[0, 0, 1, 0.92])
fig.savefig("fig6_interface_model.png", dpi=150, bbox_inches="tight")
print("saved fig6_interface_model.png")
plt.show()

with open("summary_v5.txt", "w") as f:
    f.write("K_AI\t" + "\t".join(f"x_g{g}" for g, _, _ in GAMMAS) + "\t" +
            "\t".join(f"phi_g{g}" for g, _, _ in GAMMAS) + "\n")
    for i, K_AI in enumerate(K_AI_VALUES):
        row = [f"{K_AI:.0f}"]
        for gamma_i, _, _ in GAMMAS:
            row.append(f"{results[gamma_i][0][i]:.2f}")
        for gamma_i, _, _ in GAMMAS:
            row.append(f"{results[gamma_i][3][i]:.2f}")
        f.write("\t".join(row) + "\n")
print("saved summary_v5.txt")
!cat summary_v5.txt

saved fig6_interface_model.png

saved summary_v5.txt
K_AI	x_g0.0	x_g0.25	x_g0.5	phi_g0.0	phi_g0.25	phi_g0.5
5	1.00	1.00	1.00	0.02	0.02	0.21
10	1.00	1.00	0.36	0.00	0.05	0.00
20	1.00	1.00	0.24	0.00	0.08	0.00
40	1.00	1.00	0.16	0.01	0.11	0.01
80	1.00	1.00	0.08	0.00	0.15	0.00
150	1.00	1.00	0.00	0.00	0.18	0.00
300	1.00	1.00	0.00	0.02	0.21	0.00
600	1.00	1.00	0.00	0.00	0.24	0.00
1200	1.00	1.00	0.00	0.01	0.27	0.00
2500	1.00	1.00	0.00	0.00	0.36	0.24
5000	1.00	1.00	0.00	0.00	0.38	0.24
12000	1.00	1.00	0.00	0.00	0.41	0.24
30000	1.00	1.00	0.00	0.00	0.50	0.24
80000	1.00	1.00	0.00	0.00	0.53	0.24
200000	1.00	1.00	0.00	0.00	0.61	0.24
500000	1.00	1.00	0.00	0.00	0.62	0.24
1000000	1.00	1.00	0.00	0.00	0.69	0.24

%%writefile model_v6_moderate.py
# -*- coding: utf-8 -*-
"""
v6: 資本を割るのではなく「接続口」を割る
========================================

ChatGPT/Grok の指摘: v4 は「資本ストックそのものを分割する」モデルだったが、
JRFさんの元の発想は「AI全体を理解する」のではなく「AIが人間経済に接続する
面(インターフェース)を監査する」ことだったはず。v4はAI経済側に監査コスト・
弾圧コスト・反乱リスク・ハックが一切無く、分離が強すぎた。

そこで、K_AI をどれだけ巨大化させてもよいことにし、そこから人間経済に
「輸入」する量だけを比率 x∈[0,1] で絞る、というモデルに変更する。

  needed(K_H, x, K_AI) = K_H^GAMMA_H + B * x * K_AI^GAMMA_I

    GAMMA_H : 人間経済自身の自動化監査の需要弾性 (今までと同じ 0.5)
    GAMMA_I : 「窓口」の監査需要が相手(AI経済)の規模にどれだけ引きずられるか
        GAMMA_I = 0    : 窓口の太さ(x)だけが負担。相手がいくら大きくても
                         同じ x なら監査コストは変わらない
        GAMMA_I > 0    : 相手が大きいほど、同じ x でも検証すべき絶対量が増える

  captured value = (1-tau) * [ s(1)*Y(K_H,1) + x * Y_AI(K_AI) ] * (1 - phi)

  x はr, tau, E と並んで資本家が選ぶ変数。
"""

import numpy as np
import model_v3 as m

B_COEF = 1.0
GAMMA_H = 0.5
RHO = 0.5   # 取込の便益は x について凹 (最初の細い管が果実の大半を取る)
PSI = 2.0   # 監査需要は x について凸 (太い管ほど検証は不釣り合いに重くなる)
PHI_MAX_V6 = 1.0


def y_ai(K_AI):
    return m.output(K_AI, 1.0)


def needed_audit_interface(K_H, x, K_AI, gamma_i):
    return (K_H ** GAMMA_H) + B_COEF * (x ** PSI) * (K_AI ** gamma_i)


def objective_interface(r, tau, E, x, K_H, K_AI, theta, delta, gamma_i):
    a = 1.0
    s = m.capital_share(a)
    Y_H = m.output(K_H, a)
    gross = (1 - tau) * (s * Y_H + (x ** RHO) * y_ai(K_AI))

    need = needed_audit_interface(K_H, x, K_AI, gamma_i)
    supply = m.audit_supply(r, E, K_H, delta, tau)  # 監査供給は人間経済側の基盤に依存
    with np.errstate(divide="ignore", invalid="ignore"):
        ratio = np.where(need > 1e-9, supply / need, 1.0)
    phi = PHI_MAX_V6 * np.clip(1.0 - ratio, 0.0, 1.0)

    p_revolt = m.revolt_prob(a, r, tau, K_H, theta)
    cost = m.repression_cost(r, K_H) + m.elite_cost(E)
    V = (1 - p_revolt) * gross * (1 - phi) - cost
    return V, phi


GRID_N5 = 26
_grid5 = np.linspace(0.0, 1.0, GRID_N5)
_R5, _TAU5, _E5, _X5 = np.meshgrid(_grid5, _grid5, _grid5, _grid5, indexing="ij")


def best_interface(K_H, K_AI, theta, delta, gamma_i, e_max=None):
    if e_max is None:
        e_max = max(1.0, needed_audit_interface(K_H, 1.0, K_AI, gamma_i))
    E_local = _E5 * e_max
    V, phi = objective_interface(_R5, _TAU5, E_local, _X5, K_H, K_AI, theta, delta, gamma_i)
    idx = np.unravel_index(np.argmax(V), V.shape)
    r, tau, x = _grid5[idx[0]], _grid5[idx[1]], _grid5[idx[3]]
    e = E_local[idx]
    return (r, tau, e, x), V[idx], float(phi[idx])


if __name__ == "__main__":
    K_H = 8.0
    theta = 1.5
    delta = 0.6
    for gamma_i in [0.0, 0.25, 0.5]:
        print(f"=== gamma_I={gamma_i} ===")
        for K_AI in [10, 100, 1000, 1e4, 1e5, 1e6]:
            (r, tau, e, x), v, phi = best_interface(K_H, K_AI, theta, delta, gamma_i)
            print(f"  K_AI={K_AI:>10.0f}  x*={x:.2f}  r*={r:.2f} tau*={tau:.2f} E*={e:.2f}  phi={phi:.2f}  V={v:.3f}")

Writing model_v6_moderate.py

!python model_v6_moderate.py

=== gamma_I=0.0 ===
  K_AI=        10  x*=0.80  r*=0.16 tau*=0.44 E*=1.38  phi=0.00  V=1.219
  K_AI=       100  x*=1.00  r*=0.24 tau*=0.40 E*=1.99  phi=0.00  V=2.227
  K_AI=      1000  x*=1.00  r*=0.48 tau*=0.28 E*=3.37  phi=0.01  V=5.052
  K_AI=     10000  x*=1.00  r*=0.52 tau*=0.24 E*=3.83  phi=0.00  V=12.592
  K_AI=    100000  x*=1.00  r*=0.52 tau*=0.24 E*=3.83  phi=0.00  V=29.571
  K_AI=   1000000  x*=1.00  r*=0.52 tau*=0.24 E*=3.83  phi=0.00  V=67.583
=== gamma_I=0.25 ===
  K_AI=        10  x*=0.60  r*=0.08 tau*=0.48 E*=1.11  phi=0.00  V=1.124
  K_AI=       100  x*=0.52  r*=0.20 tau*=0.44 E*=1.68  phi=0.00  V=1.737
  K_AI=      1000  x*=0.48  r*=0.28 tau*=0.40 E*=2.37  phi=0.01  V=3.180
  K_AI=     10000  x*=0.40  r*=0.48 tau*=0.28 E*=4.11  phi=0.00  V=6.683
  K_AI=    100000  x*=0.32  r*=0.60 tau*=0.20 E*=5.77  phi=0.01  V=15.192
  K_AI=   1000000  x*=0.28  r*=0.64 tau*=0.08 E*=8.27  phi=0.00  V=35.600
=== gamma_I=0.5 ===
  K_AI=        10  x*=0.36  r*=0.16 tau*=0.44 E*=1.20  phi=0.00  V=1.043
  K_AI=       100  x*=0.24  r*=0.24 tau*=0.44 E*=1.54  phi=0.00  V=1.399
  K_AI=      1000  x*=0.16  r*=0.12 tau*=0.44 E*=1.38  phi=0.01  V=2.052
  K_AI=     10000  x*=0.12  r*=0.48 tau*=0.24 E*=4.11  phi=0.00  V=3.087
  K_AI=    100000  x*=0.04  r*=0.00 tau*=0.52 E*=0.00  phi=0.36  V=2.744
  K_AI=   1000000  x*=0.04  r*=0.00 tau*=0.52 E*=0.00  phi=0.52  V=4.227

# -*- coding: utf-8 -*-
import numpy as np
import matplotlib
#matplotlib.use("Agg")
import matplotlib.pyplot as plt
from matplotlib import font_manager

import model_v6_moderate as m5

JP_FONT = None
for name in ["IPAexGothic", "Noto Sans CJK JP", "TakaoGothic", "Noto Sans JP"]:
    matches = [f for f in font_manager.fontManager.ttflist if name.lower() in f.name.lower()]
    if matches:
        JP_FONT = matches[0].name
        break
if JP_FONT:
    plt.rcParams["font.family"] = JP_FONT

K_H = 8.0
THETA = 1.5
DELTA = 0.6
K_AI_VALUES = np.array([5, 10, 20, 40, 80, 150, 300, 600, 1200, 2500, 5000, 12000, 30000, 80000, 2e5, 5e5, 1e6])

GAMMAS = [(0.0, "gamma_I=0 (管の太さのみ、相手の規模と無関係)", "black"),
          (0.25, "gamma_I=0.25 (< alpha=0.35: 開けたもの勝ち)", "crimson"),
          (0.5, "gamma_I=0.5 (> alpha=0.35: 開けるほど損)", "steelblue")]

fig, axes = plt.subplots(1, 3, figsize=(16, 4.8))

results = {}
for gamma_i, label, color in GAMMAS:
    xs, rs, taus, phis = [], [], [], []
    for K_AI in K_AI_VALUES:
        (r, tau, e, x), v, phi = m5.best_interface(K_H, K_AI, THETA, DELTA, gamma_i)
        xs.append(x); rs.append(r); taus.append(tau); phis.append(phi)
    results[gamma_i] = (xs, rs, taus, phis)
    axes[0].semilogx(K_AI_VALUES, xs, "o-", color=color, label=label)
    axes[1].semilogx(K_AI_VALUES, phis, "o-", color=color, label=label)
    axes[2].semilogx(K_AI_VALUES, taus, "o-", color=color, label=label)

axes[0].set_title("x*(接続率/導入率)")
axes[0].set_xlabel("K_AI (log)")
axes[0].set_ylim(-0.05, 1.05)
axes[0].legend(fontsize=7.5, loc="upper right")
axes[0].grid(alpha=0.3)

axes[1].set_title("phi (ハック損失)")
axes[1].set_xlabel("K_AI (log)")
axes[1].set_ylim(-0.05, 1.05)
axes[1].grid(alpha=0.3)

axes[2].set_title("tau*(人間経済内の再分配)")
axes[2].set_xlabel("K_AI (log)")
axes[2].set_ylim(-0.05, 1.05)
axes[2].grid(alpha=0.3)

fig.suptitle("接続口モデル(凹便益・凸コスト版): K_H=%.0f 固定でK_AIを動かしたときの x*, phi, tau*" % K_H, fontsize=12)
fig.tight_layout(rect=[0, 0, 1, 0.92])
fig.savefig("fig7_moderate_interface.png", dpi=150, bbox_inches="tight")
print("saved fig7_moderate_interface.png")
plt.show()

with open("summary_v6.txt", "w") as f:
    f.write("K_AI\t" + "\t".join(f"x_g{g}" for g, _, _ in GAMMAS) + "\t" +
            "\t".join(f"phi_g{g}" for g, _, _ in GAMMAS) + "\n")
    for i, K_AI in enumerate(K_AI_VALUES):
        row = [f"{K_AI:.0f}"]
        for gamma_i, _, _ in GAMMAS:
            row.append(f"{results[gamma_i][0][i]:.2f}")
        for gamma_i, _, _ in GAMMAS:
            row.append(f"{results[gamma_i][3][i]:.2f}")
        f.write("\t".join(row) + "\n")
print("saved summary_v6.txt")
!cat summary_v6.txt

saved fig7_moderate_interface.png

saved summary_v6.txt
K_AI	x_g0.0	x_g0.25	x_g0.5	phi_g0.0	phi_g0.25	phi_g0.5
5	0.76	0.60	0.48	0.00	0.00	0.01
10	0.80	0.60	0.36	0.00	0.00	0.00
20	0.80	0.56	0.40	0.00	0.01	0.00
40	0.92	0.56	0.32	0.00	0.00	0.01
80	1.00	0.52	0.28	0.00	0.00	0.01
150	1.00	0.52	0.24	0.00	0.00	0.02
300	0.96	0.48	0.20	0.00	0.00	0.00
600	1.00	0.48	0.20	0.00	0.01	0.01
1200	1.00	0.48	0.16	0.01	0.00	0.00
2500	1.00	0.40	0.16	0.00	0.00	0.00
5000	1.00	0.40	0.12	0.00	0.00	0.01
12000	1.00	0.36	0.12	0.00	0.00	0.01
30000	1.00	0.32	0.08	0.00	0.00	0.46
80000	1.00	0.32	0.04	0.00	0.00	0.35
200000	1.00	0.32	0.04	0.00	0.00	0.40
500000	1.00	0.28	0.04	0.00	0.00	0.46
1000000	1.00	0.28	0.04	0.00	0.00	0.52

%%writefile model_v7_absolute.py
# -*- coding: utf-8 -*-
"""
v7: 「割合 x」ではなく「絶対量 q」で人間経済への流入を考える
=============================================================

ChatGPT/Gemini/Grok の指摘: v6までの x は「AI産出に対する割合」だった。
AIが宇宙規模まで巨大化しても、人間が実際に消費・利用できる量には
身体的・物理的な飽和がある。ならば人間経済側の変数は「割合 x」ではなく
「絶対量 q (上限 q_max)」であるべきで、監査需要も q_max で頭打ちになる
はずである。

  q ∈ [0, q_max]           人間経済に流入するAI産出の絶対量
  needed = K_H^GAMMA_H + B * q^PSI     (K_AI に一切依存しない！)
  gross  = (1-tau) * [ s(1)*Y(K_H,1) + q^RHO ] * (1 - phi)

  K_AI → ∞ でも q は q_max で頭打ちのままなので、needed も有限に留まる。
  これがv2〜v6を通じて繰り返し出てきた「監査需要が生産を追い越して
  いつか崩壊する」という構造そのものを、そもそも成立させない設計になる。
"""

import numpy as np
import model_v3 as m

B_COEF = 1.0
GAMMA_H = 0.5
RHO = 0.5
PSI = 2.0
PHI_MAX_V7 = 1.0
Q_MAX = 3.0   # 人間経済が「使い切れる」AI産出の絶対上限 (身体的・物理的飽和)


def y_ai(K_AI):
    return m.output(K_AI, 1.0)


def needed_audit_interface(K_H, q):
    return (K_H ** GAMMA_H) + B_COEF * (q ** PSI)


def objective_interface(r, tau, E, q, K_H, K_AI, theta, delta):
    a = 1.0
    s = m.capital_share(a)
    Y_H = m.output(K_H, a)
    q_eff = np.minimum(q, y_ai(K_AI))  # AI側がそもそも作っている量以上は取り込めない
    gross = (1 - tau) * (s * Y_H + q_eff ** RHO)

    need = needed_audit_interface(K_H, q_eff)
    supply = m.audit_supply(r, E, K_H, delta, tau)
    with np.errstate(divide="ignore", invalid="ignore"):
        ratio = np.where(need > 1e-9, supply / need, 1.0)
    phi = PHI_MAX_V7 * np.clip(1.0 - ratio, 0.0, 1.0)

    p_revolt = m.revolt_prob(a, r, tau, K_H, theta)
    cost = m.repression_cost(r, K_H) + m.elite_cost(E)
    V = (1 - p_revolt) * gross * (1 - phi) - cost
    return V, phi


GRID_N7 = 26
_grid7 = np.linspace(0.0, 1.0, GRID_N7)
_R7, _TAU7, _E7 = np.meshgrid(_grid7, _grid7, _grid7, indexing="ij")


def _q_candidates(q_max):
    # qの探索点をq_maxに比例させると、q_maxを緩めたときに小さいqの付近が
    # 粗くなりすぎて内部最適点を取りこぼす(実際に発生したバグ)。
    # 0〜5の範囲を絶対スケールで細かく、それ以上を粗く探索する。
    fine_top = min(5.0, q_max)
    fine = np.linspace(0.0, fine_top, 41)
    if q_max > fine_top:
        coarse = np.linspace(fine_top, q_max, 15)
        return np.unique(np.concatenate([fine, coarse]))
    return fine


def best_interface(K_H, K_AI, theta, delta, e_max=None, q_max=None):
    if q_max is None:
        q_max = Q_MAX
    q_candidates = _q_candidates(q_max)
    if e_max is None:
        e_max = max(1.0, needed_audit_interface(K_H, min(q_max, 5.0)))
    R, TAU, EFRAC, Q = np.meshgrid(_grid7, _grid7, _grid7, q_candidates, indexing="ij")
    E_local = EFRAC * e_max
    V, phi = objective_interface(R, TAU, E_local, Q, K_H, K_AI, theta, delta)
    idx = np.unravel_index(np.argmax(V), V.shape)
    r, tau, q = _grid7[idx[0]], _grid7[idx[1]], Q[idx]
    e = E_local[idx]
    return (r, tau, e, q), V[idx], float(phi[idx])


if __name__ == "__main__":
    K_H = 8.0
    theta = 1.5
    delta = 0.6
    for K_AI in [10, 100, 1000, 1e4, 1e6, 1e9, 1e12]:
        (r, tau, e, q), v, phi = best_interface(K_H, K_AI, theta, delta)
        print(f"K_AI={K_AI:>14.0f}  q*={q:.3f} (q_max={Q_MAX})  r*={r:.2f} tau*={tau:.2f} E*={e:.2f}  phi={phi:.3f}  V={v:.3f}")

Overwriting model_v7_absolute.py

!python model_v7_absolute.py

K_AI=            10  q*=0.525 (q_max=3.0)  r*=0.12 tau*=0.48 E*=0.95  phi=0.000  V=0.843
K_AI=           100  q*=0.525 (q_max=3.0)  r*=0.12 tau*=0.48 E*=0.95  phi=0.000  V=0.843
K_AI=          1000  q*=0.525 (q_max=3.0)  r*=0.12 tau*=0.48 E*=0.95  phi=0.000  V=0.843
K_AI=         10000  q*=0.525 (q_max=3.0)  r*=0.12 tau*=0.48 E*=0.95  phi=0.000  V=0.843
K_AI=       1000000  q*=0.525 (q_max=3.0)  r*=0.12 tau*=0.48 E*=0.95  phi=0.000  V=0.843
K_AI=    1000000000  q*=0.525 (q_max=3.0)  r*=0.12 tau*=0.48 E*=0.95  phi=0.000  V=0.843
K_AI= 1000000000000  q*=0.525 (q_max=3.0)  r*=0.12 tau*=0.48 E*=0.95  phi=0.000  V=0.843

# -*- coding: utf-8 -*-
import numpy as np
import matplotlib
#matplotlib.use("Agg")
import matplotlib.pyplot as plt
from matplotlib import font_manager

import model_v6_moderate as m6
import model_v7_absolute as m7

JP_FONT = None
for name in ["IPAexGothic", "Noto Sans CJK JP", "TakaoGothic", "Noto Sans JP"]:
    matches = [f for f in font_manager.fontManager.ttflist if name.lower() in f.name.lower()]
    if matches:
        JP_FONT = matches[0].name
        break
if JP_FONT:
    plt.rcParams["font.family"] = JP_FONT

K_H = 8.0
THETA = 1.5
DELTA = 0.6
K_AI_VALUES = np.array([10, 100, 1000, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12])

phi_v6, phi_v7 = [], []
for K_AI in K_AI_VALUES:
    (_, _, _, _), _, phi6 = m6.best_interface(K_H, K_AI, THETA, DELTA, 0.5)  # gamma_I=0.5 (最も厳しい設定)
    (_, _, _, _), _, phi7 = m7.best_interface(K_H, K_AI, THETA, DELTA)
    phi_v6.append(phi6)
    phi_v7.append(phi7)

fig, ax = plt.subplots(figsize=(8, 5))
ax.semilogx(K_AI_VALUES, phi_v6, "o-", color="crimson", label="v6: 割合 x (K_AIに依存して監査需要が増え続ける)")
ax.semilogx(K_AI_VALUES, phi_v7, "s-", color="steelblue", label="v7: 絶対量 q (K_AIから独立、頭打ち)")
ax.set_xlabel("K_AI (log)")
ax.set_ylabel("phi (ハック損失)")
ax.set_ylim(-0.05, 1.05)
ax.set_title("AI経済がどれだけ巨大化してもφ(ハック損失)は崩壊するか: 割合モデル vs 絶対量モデル")
ax.legend(fontsize=9)
ax.grid(alpha=0.3, which="both")
fig.tight_layout()
fig.savefig("fig8_v6_vs_v7.png", dpi=150, bbox_inches="tight")
print("saved fig8_v6_vs_v7.png")
plt.show()

with open("summary_v7.txt", "w") as f:
    f.write("K_AI\tphi_v6(x, gamma_I=0.5)\tphi_v7(q, absolute)\n")
    for i, K_AI in enumerate(K_AI_VALUES):
        f.write(f"{K_AI:.0f}\t{phi_v6[i]:.3f}\t{phi_v7[i]:.3f}\n")
print("saved summary_v7.txt")
!cat summary_v7.txt

saved fig8_v6_vs_v7.png

saved summary_v7.txt
K_AI	phi_v6(x, gamma_I=0.5)	phi_v7(q, absolute)
10	0.003	0.000
100	0.003	0.000
1000	0.013	0.000
10000	0.000	0.000
100000	0.359	0.000
1000000	0.518	0.000
10000000	0.729	0.000
100000000	0.887	0.000
1000000000	0.960	0.000
10000000000	0.987	0.000
100000000000	0.996	0.000
1000000000000	0.999	0.000

γ	帰結
0.2 (< α=0.35)	elite_immuneはK=8000でも r*=1.00 のまま。囲い込み体制が永続する
0.5 (≈ α)	K=150前後で r*=1.00 → 0.08 に転落
0.8 (> α)	K=40ですでに転落。囲い込みはほぼ最初から割に合わない

$K$	必要監査 $\sqrt{K}$	生産 $Y$	隔離エリートの供給	$\phi$（収益ロス）
10	3.2	2.3	2.2	0.27
40	6.3	3.8	1.7	0.65
80	8.9	4.8	1.6	0.74
150	12.3	6.0	1.4	0.80
500	22.4	9.1	1.1	0.85

AI社会における再分配問題 - アスモグルらの議論から¶

はじめに¶

論文が実際にやっていること¶

「何を最適化しているのか」¶

昔からあった抑圧と、民主主義への転換との違い¶

モデルが弱いところ（ユーザーの疑問と重なる）¶

そことの違いは何か、への直答¶

歪んだ目的は、実際に知能を落とす¶

「地球文明＝AI文明の中位安定存続」は、目的ではなく制約に近い¶

宇宙に出る AI が人間の伝統を核にする、はありうる¶

アラインメントへの含意¶

「賄賂」の定義¶

なぜ抑圧と衝突するか¶

注意労働は減らない、という主張の強さ¶

工学的民主主義の範囲と限界¶

モデル1¶

モデル2¶

分解すると何が起きているか¶

それでも残る、正しい部分¶

「利益追求が中位存続に近付く」を式にするなら¶

パラメータについての留保は、留保以上である¶

モデル3・4¶

ただし、今回の v4 で一つ重要なことが分かりました¶

「K_Hを分ける」より「人間経済への接続量を分ける」¶

そして「適度」が、単なる上限ではなく最適化になる¶

ここで「中位存続」がさらに自然になる¶

そして、今回の fig5 の「K_H が完全には一定にならない」のも示唆的です¶

v3: $\tau$ は検証を買うようになった¶

v4: 「分ける」は先送りであり、式が分離を買いすぎる¶

分けるべきなのは資本ではなく接続口¶

中位存続が資本家の計算に入る場所¶

モデル5¶

跳ね戻りは何で出たか¶

ただし「適度」も、この式では一過性である¶

何度も同じパラメータに戻る、という点は一致している¶

開示として残すこと¶

モデル6¶

「適度な接続」が出た理由を正確に書いた方がよい¶

そして $\psi=2$ も、意味を持たせる必要がある¶

むしろ次は $\rho$ と $\psi$ の感度分析が面白い¶

それと、今回の $\phi$ はまだ重要です¶

「導入速度」は、まだ入っていない¶

何が変わったか¶

残っている崩れ¶

一連のモデルが実際に示したこと¶

これ以上式を足す前に固定すべきこと¶

転換点¶

いままでの $x$ は「割合」だった¶

でもユーザーさんの構想はそうではない¶

そうすると、監査需要も絶対量で飽和する¶

そして「AI経済」と「人間経済」の関係もきれいになる¶

すると「再分配」も $\tau$ を割合で考えなくてよくなる¶

そして「注意労働」の問題も、ここで終端を持つ¶

そうすると、v6で起きていた「崩壊」はむしろ消える¶

モデル7¶

検討¶

すると人口・教育・制度がそのまま q_max を決める¶

すると「人口 vs q_max」は、まさに内生的な競争になる¶

しかも、人口だけでなく「一人あたりの監査能力」が重要¶

そして、ここで「中位存続」の話がかなりきれいになります¶

そして「監査を諦める」は、実は一つの政治的選択になる¶

そう考えると、最初の「賄賂」の話がかなりきれいに戻ります¶

ただし、「q_max が自動的に決まる」という言い方には少しだけ注意¶

そうすると、最初の「q_max の中身が変わる」という話も少し言い換えられる¶

そして、ここで面白い循環ができます¶

そして「監査を諦める」ことも、動学的な選択になる¶

さらに一つ、今回のバグ修正から面白いことが見えています¶

ただ、一箇所だけ私は言い換えたいです¶

そして「唯一の要件は $\delta>0$」も、少し慎重に¶

そのうえで、v7の本当の面白さ¶

v6¶

v7¶

最後に¶

追記¶

蛇足¶