!pip install -q japanize-matplotlib
import japanize_matplotlib

     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 0.0/4.1 MB ? eta -:--:--
     ━━━━━━━━━━╸━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 1.1/4.1 MB 32.4 MB/s eta 0:00:01
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╸ 4.1/4.1 MB 64.2 MB/s eta 0:00:01
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 4.1/4.1 MB 38.2 MB/s eta 0:00:00
  Preparing metadata (setup.py) ... done
  Building wheel for japanize-matplotlib (setup.py) ... done

"""
v8モデル：ロボット軍・分散鍵化・注意労働の統合モデル
=====================================================

背景（人間の敗北・注意労働論 シリーズ v8）
------------------------------------------
警察・軍隊をロボットが担う時代に、資本家の私有ロボットに対抗するため
民主国家がロボット軍を持つとして、そのロボット軍が国内弾圧装置に
転用されないためには何が必要か、というJRFの問いから出発している。

Claude初稿への査読（Gemini・ChatGPT・Grok）を踏まえて再構成した版。

  - Gemini: 初稿のコスト関数 C(s)=s^2/n_eff は s=1（完全迂回）でも
    n_eff の防衛効果が残ってしまう構造的矛盾があると指摘。
  - ChatGPT: 「国家ロボット vs 資本ロボット」「注意労働Aは強制力を
    安全に所有可能にする補完財」という定性的再構成を提案。
  - Grok: 初稿の変数 s が「正当な多者承認の速度」と「例外的迂回」を
    混同しており、これがv6/v7・Acemoglu型モデルへの接続を断って
    いると指摘。σ（迂回度）とρ（鍵保持者間の相関）を分離し、
    相関ρを注意労働Aの関数として内生化し、既存モデルの弾圧コスト
    C_R に接続する骨格を提示。

以下はGrokの骨格を採用し、Geminiの懸念を構造で解消し、ChatGPTの
「A」をρ(A)として組み込んだ統合版。

変数
----
σ ∈ [0,1]  : 手続の迂回度（0=完全に正当な多者承認、1=単独発動）
n          : 鍵保持者の人数（固定。ここでは3）
k          : 乗っ取りに必要な同時買収人数（ここではk=n=3、全員買収が必要）
ρ ∈ [0,1]  : 鍵保持者間の相関（同一権力基盤への依存度）
A ≥ 0      : 注意労働への投資（独立した司法・議会・報道・監査）
K_T        : 外部脅威の大きさ（資本家の私有ロボット軍の強さ）

主要な関数
----------
ρ(A) = ρ0 · exp(-θA)
    Aが増えるほど鍵保持者間の相関は下がる（ChatGPTの「A」をここに埋め込む）。

legit_speed(A) = exp(-λ · L0 · n^α · (1-ρ(A)))
    正当な多者承認の実効速度。独立性(1-ρ)が高いほど合意形成が遅くなる
    （＝独立性にはただ乗りできない、膠着コストが必ず伴うという仮定）。
    ★この仮定自体が結果を駆動しているので、次の検証対象にすべき点。

Φ(A) = ρ(A)·p + (1-ρ(A))·p^k
    捕獲確率の簡易混合モデル。ρ=1なら1人と同じ脆弱性(p)、ρ=0なら
    k人全員を独立に買収する必要があり p^k に低下する。

Π(σ,A) = σ + (1-σ)·Φ(A)
    全体の捕獲確率。σ=1（完全迂回）なら n,ρ,A の値によらずΠ=1になる
    ★Geminiが指摘した「迂回すれば鍵の質は無意味になるべき」を、
      パッチではなく構造（σの線形結合）で満たしている。

C_R(σ,A) = C̲ + χ·(1-Π(σ,A))
    既存のv1〜v7（Acemoglu型モデル）における「弾圧コスト」C_R そのもの。
    Πが上がる（安全弁が消える）とC_Rが下がり、既存モデルのr*・τ*の
    選択に波及する。★これがv8と本編との接続点（Grokの最重要な貢献）。

V(σ,A) = -K_T·(1 - v(σ,A)) - κ·Π(σ,A) - μ·σ^2 - c0·A^2
    v(σ,A) = σ·v1 + (1-σ)·legit_speed(A)
    κ: 内部弾圧リスクをどれだけ重視するかの社会的パラメータ
    μσ^2: 迂回を制度として定着させる政治コスト（凸——v6と同じく、
          線形コストのままだと角解しか出ないため）

実行結果の要旨
--------------
1. κが小さい社会：K_Tの上昇とともにσ*がなだらかに0→1へ連続的に上昇。
   A*はほぼ常に0（注意労働への投資が最初から選ばれない）。
2. κが大きい社会：K_Tが低い間はA*≈1（ρを大きく下げる）が選ばれるが、
   ある閾値でA*が0へ不連続に崩落し、その後もσ*はしばらく0のまま、
   さらにK_Tが上がってからσ*が上昇し始める。
   → 「公然の非常大権(σ↑)」が発動する前に、「独立した任命プロセスの
     形骸化(A↓→ρ↑)」が静かに先行するという含意が、モデルの構造から
     副産物として出てきた。ただし上記の「独立性は膠着を伴う」という
     仮定に強く依存する結果であり、頑健性は未検証。
"""

import numpy as np
from scipy.optimize import minimize
import json

# ---- パラメータ ----
n = 3
k = 3
p = 0.3          # 鍵保持者/相関ブロック単体の被買収確率
rho0 = 0.9       # A=0のときの相関（デフォルトでは同一権力基盤に偏る）
theta = 0.5      # Aがρを下げる効き方
L0 = 2.0
alpha = 1.0
lam = 3.0        # 独立性が合意形成を遅らせる強さ
v1 = 1.0
mu = 3.0         # 迂回の制度化コスト（σ^2の係数）
c0 = 0.3         # 注意労働投資自体のコスト（A^2の係数）


def rho_of_A(A):
    return rho0 * np.exp(-theta * A)


def legit_speed(A):
    rho = rho_of_A(A)
    L = L0 * (n ** alpha) * (1 - rho)
    return np.exp(-lam * L)


def Phi(A):
    rho = rho_of_A(A)
    return rho * p + (1 - rho) * (p ** k)


def Pi(sigma, A):
    return sigma + (1 - sigma) * Phi(A)


def neg_V(x, K_T, kappa):
    sigma, A = x
    sigma = np.clip(sigma, 0, 1)
    A = max(A, 0)
    v0 = legit_speed(A)
    v = sigma * v1 + (1 - sigma) * v0
    pi = Pi(sigma, A)
    V = -K_T * (1 - v) - kappa * pi - mu * sigma ** 2 - c0 * A ** 2
    return -V


def solve(K_T, kappa, C_bar=1.0, chi=3.0):
    """複数の初期値からグローバル最適に近い(sigma*, A*)を探す。"""
    best = None
    for s0 in [0.0, 0.2, 0.4, 0.6, 0.8, 1.0]:
        for a0 in [0.0, 0.5, 1.0, 2.0, 3.0]:
            res = minimize(neg_V, x0=[s0, a0], args=(K_T, kappa),
                            bounds=[(0, 1), (0, 8)])
            if best is None or res.fun < best.fun:
                best = res
    sigma_star = float(np.clip(best.x[0], 0, 1))
    A_star = float(max(best.x[1], 0))
    rho_star = float(rho_of_A(A_star))
    pi_star = float(Pi(sigma_star, A_star))
    C_R_star = C_bar + chi * (1 - pi_star)
    return dict(K_T=K_T, kappa=kappa, sigma=sigma_star, A=A_star,
                rho=rho_star, Pi=pi_star, C_R=C_R_star)


if __name__ == "__main__":
    for kappa in [2.0, 8.0]:
        print(f"\n=== kappa = {kappa} ===")
        results = [solve(K_T, kappa) for K_T in np.linspace(0.1, 10, 60)]
        for r in results[::6]:
            print(f"K_T={r['K_T']:.2f}  sigma*={r['sigma']:.3f}  "
                  f"A*={r['A']:.3f}  rho*={r['rho']:.3f}  "
                  f"Pi*={r['Pi']:.3f}  C_R*={r['C_R']:.3f}")
        with open(f"results_kappa{kappa}.json", "w") as f:
            json.dump(results, f, indent=2)

=== kappa = 2.0 ===
K_T=0.10  sigma*=0.000  A*=0.331  rho*=0.763  Pi*=0.235  C_R*=3.294
K_T=1.11  sigma*=0.000  A*=0.000  rho*=0.900  Pi*=0.273  C_R*=3.182
K_T=2.11  sigma*=0.052  A*=0.000  rho*=0.900  Pi*=0.310  C_R*=3.069
K_T=3.12  sigma*=0.192  A*=0.000  rho*=0.900  Pi*=0.412  C_R*=2.764
K_T=4.13  sigma*=0.332  A*=0.000  rho*=0.900  Pi*=0.514  C_R*=2.458
K_T=5.13  sigma*=0.472  A*=0.000  rho*=0.900  Pi*=0.616  C_R*=2.153
K_T=6.14  sigma*=0.612  A*=0.000  rho*=0.900  Pi*=0.718  C_R*=1.847
K_T=7.15  sigma*=0.752  A*=0.000  rho*=0.900  Pi*=0.820  C_R*=1.541
K_T=8.15  sigma*=0.892  A*=0.000  rho*=0.900  Pi*=0.921  C_R*=1.236
K_T=9.16  sigma*=1.000  A*=0.000  rho*=0.900  Pi*=1.000  C_R*=1.000

=== kappa = 8.0 ===
K_T=0.10  sigma*=0.000  A*=0.995  rho*=0.547  Pi*=0.176  C_R*=3.471
K_T=1.11  sigma*=0.000  A*=0.994  rho*=0.548  Pi*=0.176  C_R*=3.471
K_T=2.11  sigma*=0.000  A*=0.992  rho*=0.548  Pi*=0.177  C_R*=3.470
K_T=3.12  sigma*=0.000  A*=0.000  rho*=0.900  Pi*=0.273  C_R*=3.182
K_T=4.13  sigma*=0.000  A*=0.000  rho*=0.900  Pi*=0.273  C_R*=3.182
K_T=5.13  sigma*=0.000  A*=0.000  rho*=0.900  Pi*=0.273  C_R*=3.182
K_T=6.14  sigma*=0.000  A*=0.000  rho*=0.900  Pi*=0.273  C_R*=3.182
K_T=7.15  sigma*=0.025  A*=0.000  rho*=0.900  Pi*=0.291  C_R*=3.128
K_T=8.15  sigma*=0.165  A*=0.000  rho*=0.900  Pi*=0.392  C_R*=2.823
K_T=9.16  sigma*=0.305  A*=0.000  rho*=0.900  Pi*=0.494  C_R*=2.517

"""
=====================================================================
v8.1 への追記（Gemini・ChatGPT・Grokの査読を受けた第二ラウンド）
=====================================================================

査読の要点:
  - Grok: 「Aの先行崩壊」は legit_speed(A) がAを過度に罰しているという
    仮定の産物であり、注意労働論の頑健な含意ではない。数値で確認済み
    （A=0→1でv0が約1/600に低下する一方Φはほとんど落ちない）。
  - ChatGPT: C_R を計算しているだけで最適化のV(σ,A)には配線されておらず、
    既存のv1-v7（r*, τ*）に接続できていないという実装の欠落を指摘。
    また国家ロボット能力R自体が変数として存在しないことも指摘し、
    K_T(=P, 資本ロボット脅威) -> R(国家ロボット能力) -> A(注意労働)
    という三層構造を提案。
  - Gemini: 上記2点を壁打ちの論点として整理。

対応した修正:
  (1) legit_speed に psi 項を追加:
      L = L0 * n^alpha * (1-rho(A)) / (1+psi*A)
      psi=0で旧仕様、psi>0で「独立性を保ったまま正当経路を速くする投資」
      を表現できるようにした。

  (2) R（国家ロボット能力）をsigma, Aと並ぶ第三の選択変数として追加。
      P = K_T（資本ロボット脅威）を明示的な変数名にした。
      目的関数:
        V = -beta * max(P - R*v(sigma,A), 0)^2
            - kappa * Pi(sigma,A) * R
            - mu*sigma^2 - c_A*A^2 - c_R*R^2
      未充足の脅威(P - R*v)は「実戦投入できる実力」で測る(vは
      決定速度そのものではなく、実力Rのうちどれだけ承認手続を
      通して実際に投入できるかの係数)。この損失は凸(二乗)にした
      （線形損失だとR*がPに反応しない不自然な結果になったため）。

得られた結果と、まだ解けていない問題:
  - P↑ に対して sigma*↑, R*↑ はきれいに出た（脅威が強まるほど
    国家は迂回度と実戦力の両方を増やす）。
  - しかし A* は終始0のままで、psiを上げても変化しなかった。
    手動検証でもAを上げるとVが単調に悪化することを確認した。
  - 原因: kappa*Pi*R という項が、A（Piを下げる）とR（それ自体に
    比例してこの項のコストを増やす）の両方の「効き目」を同じ
    kappa 一つに背負わせている。kappaを上げてAへの投資を正当化
    しようとすると同時にRの維持コストも跳ね上がりR*が潰れ、
    kappaを下げてRを育てようとするとAへの投資動機が消える。
  - つまり「資本ロボットに対抗する国家の実力Rと、それを監査する
    注意労働Aは補完財である」というChatGPTの直観を素朴に定式化
    すると、RとAが同じ経路(kappa*Pi*R)を奪い合ってしまい、
    両方を同時に伸ばす均衡が今の仕様では見当たらない。
    次はここ（Rのコストの一部とAの便益の一部を、kappaから
    切り離して別々の経路に配線し直すこと）が課題として残る。
"""
# ---------------------------------------------------------------------
# 以下 v8.1（R追加・凸損失・psi項を含む最終版）の実行コード
# ---------------------------------------------------------------------
import numpy as np
from scipy.optimize import minimize

# 未充足の脅威による損失を凸(二乗)にする -- 線形損失だとRの限界便益がPに
# 依存せず、R*がPに反応しないという不自然な結果になっていたため。
n, k, p = 3, 3, 0.3
rho0, theta = 0.9, 0.5
L0, alpha, lam = 2.0, 1.0, 3.0
v1 = 1.0
mu, c_A, c_R = 3.0, 0.3, 0.05
beta = 1.0   # 損失の凸性

def rho_of_A(A):
    return rho0*np.exp(-theta*A)

def legit_speed(A, psi):
    rho = rho_of_A(A)
    L = L0*(n**alpha)*(1-rho) / (1+psi*A)
    return np.exp(-lam*L)

def Phi(A):
    rho = rho_of_A(A)
    return rho*p + (1-rho)*(p**k)

def Pi(sigma, A):
    return sigma + (1-sigma)*Phi(A)

def neg_V(x, P, kappa, psi):
    sigma, A, R = x
    sigma = np.clip(sigma, 0, 1); A = max(A,0); R = max(R,0)
    v = sigma*v1 + (1-sigma)*legit_speed(A, psi)
    pi = Pi(sigma, A)
    deficit = max(P - R*v, 0)
    V = -beta*deficit**2 - kappa*pi*R - mu*sigma**2 - c_A*A**2 - c_R*R**2
    return -V

def solve(P, kappa, psi):
    best = None
    for s0 in [0.0,0.3,0.6,1.0]:
        for a0 in [0.0,1.0,2.0,3.0]:
            for r0 in [0.0,2.0,5.0,8.0,12.0]:
                res = minimize(neg_V, x0=[s0,a0,r0], args=(P,kappa,psi),
                                bounds=[(0,1),(0,8),(0,25)])
                if best is None or res.fun < best.fun:
                    best = res
    s,a,r = np.clip(best.x[0],0,1), max(best.x[1],0), max(best.x[2],0)
    return dict(P=P, sigma=s, A=a, R=r, rho=rho_of_A(a), Pi=Pi(s,a))

for psi in [0.0, 3.0]:
    print(f"\n=== kappa=0.15, psi={psi} ===")
    for P in [0.5,1,2,3,4,5,6,7,8,9,10]:
        r = solve(P, kappa=0.15, psi=psi)
        print(f"P={P:4.1f}  sigma*={r['sigma']:.3f} A*={r['A']:.3f} R*={r['R']:.3f} rho*={r['rho']:.3f} Pi*={r['Pi']:.3f}")

=== kappa=0.15, psi=0.0 ===
P= 0.5  sigma*=0.060 A*=0.000 R*=0.871 rho*=0.900 Pi*=0.316
P= 1.0  sigma*=0.178 A*=0.000 R*=1.910 rho*=0.900 Pi*=0.402
P= 2.0  sigma*=0.357 A*=0.000 R*=3.351 rho*=0.900 Pi*=0.532
P= 3.0  sigma*=0.491 A*=0.000 R*=4.408 rho*=0.900 Pi*=0.630
P= 4.0  sigma*=0.602 A*=0.000 R*=5.279 rho*=0.900 Pi*=0.710
P= 5.0  sigma*=0.699 A*=0.000 R*=6.036 rho*=0.900 Pi*=0.781
P= 6.0  sigma*=0.786 A*=0.000 R*=6.715 rho*=0.900 Pi*=0.844
P= 7.0  sigma*=0.865 A*=0.000 R*=7.335 rho*=0.900 Pi*=0.902
P= 8.0  sigma*=0.939 A*=0.000 R*=7.909 rho*=0.900 Pi*=0.956
P= 9.0  sigma*=1.000 A*=0.000 R*=8.500 rho*=0.900 Pi*=1.000
P=10.0  sigma*=1.000 A*=0.000 R*=9.452 rho*=0.900 Pi*=1.000

=== kappa=0.15, psi=3.0 ===
P= 0.5  sigma*=0.060 A*=0.000 R*=0.871 rho*=0.900 Pi*=0.316
P= 1.0  sigma*=0.178 A*=0.000 R*=1.910 rho*=0.900 Pi*=0.402
P= 2.0  sigma*=0.357 A*=0.000 R*=3.351 rho*=0.900 Pi*=0.532
P= 3.0  sigma*=0.491 A*=0.000 R*=4.408 rho*=0.900 Pi*=0.630
P= 4.0  sigma*=0.602 A*=0.000 R*=5.279 rho*=0.900 Pi*=0.710
P= 5.0  sigma*=0.699 A*=0.000 R*=6.036 rho*=0.900 Pi*=0.781
P= 6.0  sigma*=0.786 A*=0.000 R*=6.715 rho*=0.900 Pi*=0.844
P= 7.0  sigma*=0.865 A*=0.000 R*=7.335 rho*=0.900 Pi*=0.902
P= 8.0  sigma*=0.939 A*=0.000 R*=7.909 rho*=0.900 Pi*=0.956
P= 9.0  sigma*=1.000 A*=0.000 R*=8.500 rho*=0.900 Pi*=1.000
P=10.0  sigma*=1.000 A*=0.000 R*=9.452 rho*=0.900 Pi*=1.000

import numpy as np
from scipy.optimize import minimize

"""
v8.2: 3者の指摘を統合
  - Gemini: 捕獲被害をR^2に(H(R)=R^2) -- 巨大な装置ほど暴走時の被害が大きい
  - Grok: psi=3ではv0(A=1)がv0(A=0)より遅いままだったと検算で指摘。
          psiを、実際にA=1でv0が改善するまで引き上げて確認する。
  - ChatGPT/Grok共通: sigmaが安いと、sigma->1でd(Pi)/dAがゼロになり
          Aの限界便益が消える。muを動かして「sigmaがまだ高価な」領域を
          広げ、その中でA*,R*が共に正になるかを見る。
"""

n, k, p = 3, 3, 0.3
rho0, theta = 0.9, 0.5
L0, alpha, lam = 2.0, 1.0, 3.0
v1 = 1.0
beta, c_A, c_R = 1.0, 0.05, 0.05

def rho_of_A(A):
    return rho0*np.exp(-theta*A)

def legit_speed(A, psi):
    rho = rho_of_A(A)
    L = L0*(n**alpha)*(1-rho) / (1+psi*A)
    return np.exp(-lam*L)

def Phi(A):
    rho = rho_of_A(A)
    return rho*p + (1-rho)*(p**k)

def Pi(sigma, A):
    return sigma + (1-sigma)*Phi(A)

def neg_V(x, P, kappa, psi, mu, use_R2):
    sigma, A, R = x
    sigma = np.clip(sigma, 0, 1); A = max(A,0); R = max(R,0)
    v = sigma*v1 + (1-sigma)*legit_speed(A, psi)
    pi = Pi(sigma, A)
    deficit = max(P - R*v, 0)
    harm = kappa*pi*(R**2 if use_R2 else R)
    V = -beta*deficit**2 - harm - mu*sigma**2 - c_A*A**2 - c_R*R**2
    return -V

def solve(P, kappa, psi, mu, use_R2):
    best = None
    for s0 in [0.0,0.2,0.5,0.8,1.0]:
        for a0 in [0.0,1.0,2.0,4.0]:
            for r0 in [0.0,1.0,3.0,6.0,9.0]:
                res = minimize(neg_V, x0=[s0,a0,r0], args=(P,kappa,psi,mu,use_R2),
                                bounds=[(0,1),(0,10),(0,20)])
                if best is None or res.fun < best.fun:
                    best = res
    s,a,r = np.clip(best.x[0],0,1), max(best.x[1],0), max(best.x[2],0)
    return dict(P=P, sigma=s, A=a, R=r)

# まずGrokの検算を再現: psi=3でのv0(A=0), v0(A=1), v0(A=3)
for A_test in [0,1,3]:
    print(f"psi=3, A={A_test}: v0={legit_speed(A_test,3):.3f}")
# psiをどこまで上げればA=1でv0(0)を上回るか
for psi_test in [3,6,10,15,20]:
    print(f"psi={psi_test}: v0(0)={legit_speed(0,psi_test):.3f}  v0(1)={legit_speed(1,psi_test):.3f}")

print("\n=== v8.2: kappa=1, psi=10, use_R2=True, muを振る ===")
for mu in [1.0, 3.0, 6.0]:
    print(f"\n--- mu={mu} ---")
    for P in [0.5,1,2,3,4,5,6,7,8,9,10,12]:
        r = solve(P, kappa=1.0, psi=10.0, mu=mu, use_R2=True)
        print(f"P={P:4.1f}  sigma*={r['sigma']:.3f} A*={r['A']:.3f} R*={r['R']:.3f}")

# ---------------------------------------------------------------------
# v8.2（H(R)=R^2・psi=10で再較正した最終版。Gemini/ChatGPT/Grok三者の
# 診断を統合し、sigma*=0のままP上昇に対しA*,R*が共に滑らかに増加する
# 「ChatGPTの箱」(P->R->A)を再現した。ただしA*,R*が探索範囲の上限に
# 張り付く境界(P>~15)があり、それ以上のPでの結論は境界の産物であり
# 未検証。段階2(既存v1-v7へのC_R経由の接続)は次回以降の課題。
# ---------------------------------------------------------------------

psi=3, A=0: v0=0.165
psi=3, A=1: v0=0.130
psi=3, A=3: v0=0.237
psi=3: v0(0)=0.165  v0(1)=0.130
psi=6: v0(0)=0.165  v0(1)=0.311
psi=10: v0(0)=0.165  v0(1)=0.476
psi=15: v0(0)=0.165  v0(1)=0.600
psi=20: v0(0)=0.165  v0(1)=0.678

=== v8.2: kappa=1, psi=10, use_R2=True, muを振る ===

--- mu=1.0 ---
P= 0.5  sigma*=0.000 A*=0.635 R*=0.488
P= 1.0  sigma*=0.000 A*=1.517 R*=1.122
P= 2.0  sigma*=0.000 A*=2.972 R*=2.385
P= 3.0  sigma*=0.000 A*=3.998 R*=3.562
P= 4.0  sigma*=0.000 A*=4.801 R*=4.690
P= 5.0  sigma*=0.000 A*=5.475 R*=5.789
P= 6.0  sigma*=0.000 A*=6.063 R*=6.867
P= 7.0  sigma*=0.000 A*=6.590 R*=7.931
P= 8.0  sigma*=0.000 A*=7.071 R*=8.983
P= 9.0  sigma*=0.000 A*=7.517 R*=10.025
P=10.0  sigma*=0.000 A*=7.936 R*=11.060
P=12.0  sigma*=0.000 A*=8.709 R*=13.112

--- mu=3.0 ---
P= 0.5  sigma*=0.000 A*=0.635 R*=0.488
P= 1.0  sigma*=0.000 A*=1.517 R*=1.122
P= 2.0  sigma*=0.000 A*=2.972 R*=2.385
P= 3.0  sigma*=0.000 A*=3.998 R*=3.562
P= 4.0  sigma*=0.000 A*=4.801 R*=4.690
P= 5.0  sigma*=0.000 A*=5.475 R*=5.789
P= 6.0  sigma*=0.000 A*=6.063 R*=6.867
P= 7.0  sigma*=0.000 A*=6.590 R*=7.931
P= 8.0  sigma*=0.000 A*=7.071 R*=8.983
P= 9.0  sigma*=0.000 A*=7.517 R*=10.025
P=10.0  sigma*=0.000 A*=7.936 R*=11.060
P=12.0  sigma*=0.000 A*=8.709 R*=13.112

--- mu=6.0 ---
P= 0.5  sigma*=0.000 A*=0.635 R*=0.488
P= 1.0  sigma*=0.000 A*=1.517 R*=1.122
P= 2.0  sigma*=0.000 A*=2.972 R*=2.385
P= 3.0  sigma*=0.000 A*=3.998 R*=3.562
P= 4.0  sigma*=0.000 A*=4.801 R*=4.690
P= 5.0  sigma*=0.000 A*=5.475 R*=5.789
P= 6.0  sigma*=0.000 A*=6.063 R*=6.867
P= 7.0  sigma*=0.000 A*=6.590 R*=7.931
P= 8.0  sigma*=0.000 A*=7.071 R*=8.983
P= 9.0  sigma*=0.000 A*=7.517 R*=10.025
P=10.0  sigma*=0.000 A*=7.936 R*=11.060
P=12.0  sigma*=0.000 A*=8.709 R*=13.112

%%writefile v8_2_model.py
"""
v8モデル：ロボット軍・分散鍵化・注意労働の統合モデル
=====================================================

背景（人間の敗北・注意労働論 シリーズ v8）
------------------------------------------
警察・軍隊をロボットが担う時代に、資本家の私有ロボットに対抗するため
民主国家がロボット軍を持つとして、そのロボット軍が国内弾圧装置に
転用されないためには何が必要か、というJRFの問いから出発している。

Claude初稿への査読（Gemini・ChatGPT・Grok）を踏まえて再構成した版。

  - Gemini: 初稿のコスト関数 C(s)=s^2/n_eff は s=1（完全迂回）でも
    n_eff の防衛効果が残ってしまう構造的矛盾があると指摘。
  - ChatGPT: 「国家ロボット vs 資本ロボット」「注意労働Aは強制力を
    安全に所有可能にする補完財」という定性的再構成を提案。
  - Grok: 初稿の変数 s が「正当な多者承認の速度」と「例外的迂回」を
    混同しており、これがv6/v7・Acemoglu型モデルへの接続を断って
    いると指摘。σ（迂回度）とρ（鍵保持者間の相関）を分離し、
    相関ρを注意労働Aの関数として内生化し、既存モデルの弾圧コスト
    C_R に接続する骨格を提示。

以下はGrokの骨格を採用し、Geminiの懸念を構造で解消し、ChatGPTの
「A」をρ(A)として組み込んだ統合版。

変数
----
σ ∈ [0,1]  : 手続の迂回度（0=完全に正当な多者承認、1=単独発動）
n          : 鍵保持者の人数（固定。ここでは3）
k          : 乗っ取りに必要な同時買収人数（ここではk=n=3、全員買収が必要）
ρ ∈ [0,1]  : 鍵保持者間の相関（同一権力基盤への依存度）
A ≥ 0      : 注意労働への投資（独立した司法・議会・報道・監査）
K_T        : 外部脅威の大きさ（資本家の私有ロボット軍の強さ）

主要な関数
----------
ρ(A) = ρ0 · exp(-θA)
    Aが増えるほど鍵保持者間の相関は下がる（ChatGPTの「A」をここに埋め込む）。

legit_speed(A) = exp(-λ · L0 · n^α · (1-ρ(A)))
    正当な多者承認の実効速度。独立性(1-ρ)が高いほど合意形成が遅くなる
    （＝独立性にはただ乗りできない、膠着コストが必ず伴うという仮定）。
    ★この仮定自体が結果を駆動しているので、次の検証対象にすべき点。

Φ(A) = ρ(A)·p + (1-ρ(A))·p^k
    捕獲確率の簡易混合モデル。ρ=1なら1人と同じ脆弱性(p)、ρ=0なら
    k人全員を独立に買収する必要があり p^k に低下する。

Π(σ,A) = σ + (1-σ)·Φ(A)
    全体の捕獲確率。σ=1（完全迂回）なら n,ρ,A の値によらずΠ=1になる
    ★Geminiが指摘した「迂回すれば鍵の質は無意味になるべき」を、
      パッチではなく構造（σの線形結合）で満たしている。

C_R(σ,A) = C̲ + χ·(1-Π(σ,A))
    既存のv1〜v7（Acemoglu型モデル）における「弾圧コスト」C_R そのもの。
    Πが上がる（安全弁が消える）とC_Rが下がり、既存モデルのr*・τ*の
    選択に波及する。★これがv8と本編との接続点（Grokの最重要な貢献）。

V(σ,A) = -K_T·(1 - v(σ,A)) - κ·Π(σ,A) - μ·σ^2 - c0·A^2
    v(σ,A) = σ·v1 + (1-σ)·legit_speed(A)
    κ: 内部弾圧リスクをどれだけ重視するかの社会的パラメータ
    μσ^2: 迂回を制度として定着させる政治コスト（凸——v6と同じく、
          線形コストのままだと角解しか出ないため）

実行結果の要旨
--------------
1. κが小さい社会：K_Tの上昇とともにσ*がなだらかに0→1へ連続的に上昇。
   A*はほぼ常に0（注意労働への投資が最初から選ばれない）。
2. κが大きい社会：K_Tが低い間はA*≈1（ρを大きく下げる）が選ばれるが、
   ある閾値でA*が0へ不連続に崩落し、その後もσ*はしばらく0のまま、
   さらにK_Tが上がってからσ*が上昇し始める。
   → 「公然の非常大権(σ↑)」が発動する前に、「独立した任命プロセスの
     形骸化(A↓→ρ↑)」が静かに先行するという含意が、モデルの構造から
     副産物として出てきた。ただし上記の「独立性は膠着を伴う」という
     仮定に強く依存する結果であり、頑健性は未検証。
"""

import numpy as np
from scipy.optimize import minimize
import json

# ---- パラメータ ----
n = 3
k = 3
p = 0.3          # 鍵保持者/相関ブロック単体の被買収確率
rho0 = 0.9       # A=0のときの相関（デフォルトでは同一権力基盤に偏る）
theta = 0.5      # Aがρを下げる効き方
L0 = 2.0
alpha = 1.0
lam = 3.0        # 独立性が合意形成を遅らせる強さ
v1 = 1.0
mu = 3.0         # 迂回の制度化コスト（σ^2の係数）
c0 = 0.3         # 注意労働投資自体のコスト（A^2の係数）


def rho_of_A(A):
    return rho0 * np.exp(-theta * A)


def legit_speed(A):
    rho = rho_of_A(A)
    L = L0 * (n ** alpha) * (1 - rho)
    return np.exp(-lam * L)


def Phi(A):
    rho = rho_of_A(A)
    return rho * p + (1 - rho) * (p ** k)


def Pi(sigma, A):
    return sigma + (1 - sigma) * Phi(A)


def neg_V(x, K_T, kappa):
    sigma, A = x
    sigma = np.clip(sigma, 0, 1)
    A = max(A, 0)
    v0 = legit_speed(A)
    v = sigma * v1 + (1 - sigma) * v0
    pi = Pi(sigma, A)
    V = -K_T * (1 - v) - kappa * pi - mu * sigma ** 2 - c0 * A ** 2
    return -V


def solve(K_T, kappa, C_bar=1.0, chi=3.0):
    """複数の初期値からグローバル最適に近い(sigma*, A*)を探す。"""
    best = None
    for s0 in [0.0, 0.2, 0.4, 0.6, 0.8, 1.0]:
        for a0 in [0.0, 0.5, 1.0, 2.0, 3.0]:
            res = minimize(neg_V, x0=[s0, a0], args=(K_T, kappa),
                            bounds=[(0, 1), (0, 8)])
            if best is None or res.fun < best.fun:
                best = res
    sigma_star = float(np.clip(best.x[0], 0, 1))
    A_star = float(max(best.x[1], 0))
    rho_star = float(rho_of_A(A_star))
    pi_star = float(Pi(sigma_star, A_star))
    C_R_star = C_bar + chi * (1 - pi_star)
    return dict(K_T=K_T, kappa=kappa, sigma=sigma_star, A=A_star,
                rho=rho_star, Pi=pi_star, C_R=C_R_star)


if __name__ == "__main__":
    for kappa in [2.0, 8.0]:
        print(f"\n=== kappa = {kappa} ===")
        results = [solve(K_T, kappa) for K_T in np.linspace(0.1, 10, 60)]
        for r in results[::6]:
            print(f"K_T={r['K_T']:.2f}  sigma*={r['sigma']:.3f}  "
                  f"A*={r['A']:.3f}  rho*={r['rho']:.3f}  "
                  f"Pi*={r['Pi']:.3f}  C_R*={r['C_R']:.3f}")
        with open(f"results_kappa{kappa}.json", "w") as f:
            json.dump(results, f, indent=2)


"""
=====================================================================
v8.1 への追記（Gemini・ChatGPT・Grokの査読を受けた第二ラウンド）
=====================================================================

査読の要点:
  - Grok: 「Aの先行崩壊」は legit_speed(A) がAを過度に罰しているという
    仮定の産物であり、注意労働論の頑健な含意ではない。数値で確認済み
    （A=0→1でv0が約1/600に低下する一方Φはほとんど落ちない）。
  - ChatGPT: C_R を計算しているだけで最適化のV(σ,A)には配線されておらず、
    既存のv1-v7（r*, τ*）に接続できていないという実装の欠落を指摘。
    また国家ロボット能力R自体が変数として存在しないことも指摘し、
    K_T(=P, 資本ロボット脅威) -> R(国家ロボット能力) -> A(注意労働)
    という三層構造を提案。
  - Gemini: 上記2点を壁打ちの論点として整理。

対応した修正:
  (1) legit_speed に psi 項を追加:
      L = L0 * n^alpha * (1-rho(A)) / (1+psi*A)
      psi=0で旧仕様、psi>0で「独立性を保ったまま正当経路を速くする投資」
      を表現できるようにした。

  (2) R（国家ロボット能力）をsigma, Aと並ぶ第三の選択変数として追加。
      P = K_T（資本ロボット脅威）を明示的な変数名にした。
      目的関数:
        V = -beta * max(P - R*v(sigma,A), 0)^2
            - kappa * Pi(sigma,A) * R
            - mu*sigma^2 - c_A*A^2 - c_R*R^2
      未充足の脅威(P - R*v)は「実戦投入できる実力」で測る(vは
      決定速度そのものではなく、実力Rのうちどれだけ承認手続を
      通して実際に投入できるかの係数)。この損失は凸(二乗)にした
      （線形損失だとR*がPに反応しない不自然な結果になったため）。

得られた結果と、まだ解けていない問題:
  - P↑ に対して sigma*↑, R*↑ はきれいに出た（脅威が強まるほど
    国家は迂回度と実戦力の両方を増やす）。
  - しかし A* は終始0のままで、psiを上げても変化しなかった。
    手動検証でもAを上げるとVが単調に悪化することを確認した。
  - 原因: kappa*Pi*R という項が、A（Piを下げる）とR（それ自体に
    比例してこの項のコストを増やす）の両方の「効き目」を同じ
    kappa 一つに背負わせている。kappaを上げてAへの投資を正当化
    しようとすると同時にRの維持コストも跳ね上がりR*が潰れ、
    kappaを下げてRを育てようとするとAへの投資動機が消える。
  - つまり「資本ロボットに対抗する国家の実力Rと、それを監査する
    注意労働Aは補完財である」というChatGPTの直観を素朴に定式化
    すると、RとAが同じ経路(kappa*Pi*R)を奪い合ってしまい、
    両方を同時に伸ばす均衡が今の仕様では見当たらない。
    次はここ（Rのコストの一部とAの便益の一部を、kappaから
    切り離して別々の経路に配線し直すこと）が課題として残る。
"""
# ---------------------------------------------------------------------
# 以下 v8.1（R追加・凸損失・psi項を含む最終版）の実行コード
# ---------------------------------------------------------------------
import numpy as np
from scipy.optimize import minimize

# 未充足の脅威による損失を凸(二乗)にする -- 線形損失だとRの限界便益がPに
# 依存せず、R*がPに反応しないという不自然な結果になっていたため。
n, k, p = 3, 3, 0.3
rho0, theta = 0.9, 0.5
L0, alpha, lam = 2.0, 1.0, 3.0
v1 = 1.0
mu, c_A, c_R = 3.0, 0.3, 0.05
beta = 1.0   # 損失の凸性

def rho_of_A(A):
    return rho0*np.exp(-theta*A)

def legit_speed(A, psi):
    rho = rho_of_A(A)
    L = L0*(n**alpha)*(1-rho) / (1+psi*A)
    return np.exp(-lam*L)

def Phi(A):
    rho = rho_of_A(A)
    return rho*p + (1-rho)*(p**k)

def Pi(sigma, A):
    return sigma + (1-sigma)*Phi(A)

def neg_V(x, P, kappa, psi):
    sigma, A, R = x
    sigma = np.clip(sigma, 0, 1); A = max(A,0); R = max(R,0)
    v = sigma*v1 + (1-sigma)*legit_speed(A, psi)
    pi = Pi(sigma, A)
    deficit = max(P - R*v, 0)
    V = -beta*deficit**2 - kappa*pi*R - mu*sigma**2 - c_A*A**2 - c_R*R**2
    return -V

def solve(P, kappa, psi):
    best = None
    for s0 in [0.0,0.3,0.6,1.0]:
        for a0 in [0.0,1.0,2.0,3.0]:
            for r0 in [0.0,2.0,5.0,8.0,12.0]:
                res = minimize(neg_V, x0=[s0,a0,r0], args=(P,kappa,psi),
                                bounds=[(0,1),(0,8),(0,25)])
                if best is None or res.fun < best.fun:
                    best = res
    s,a,r = np.clip(best.x[0],0,1), max(best.x[1],0), max(best.x[2],0)
    return dict(P=P, sigma=s, A=a, R=r, rho=rho_of_A(a), Pi=Pi(s,a))

for psi in [0.0, 3.0]:
    print(f"\n=== kappa=0.15, psi={psi} ===")
    for P in [0.5,1,2,3,4,5,6,7,8,9,10]:
        r = solve(P, kappa=0.15, psi=psi)
        print(f"P={P:4.1f}  sigma*={r['sigma']:.3f} A*={r['A']:.3f} R*={r['R']:.3f} rho*={r['rho']:.3f} Pi*={r['Pi']:.3f}")
import numpy as np
from scipy.optimize import minimize

"""
v8.2: 3者の指摘を統合
  - Gemini: 捕獲被害をR^2に(H(R)=R^2) -- 巨大な装置ほど暴走時の被害が大きい
  - Grok: psi=3ではv0(A=1)がv0(A=0)より遅いままだったと検算で指摘。
          psiを、実際にA=1でv0が改善するまで引き上げて確認する。
  - ChatGPT/Grok共通: sigmaが安いと、sigma->1でd(Pi)/dAがゼロになり
          Aの限界便益が消える。muを動かして「sigmaがまだ高価な」領域を
          広げ、その中でA*,R*が共に正になるかを見る。
"""

n, k, p = 3, 3, 0.3
rho0, theta = 0.9, 0.5
L0, alpha, lam = 2.0, 1.0, 3.0
v1 = 1.0
beta, c_A, c_R = 1.0, 0.05, 0.05

def rho_of_A(A):
    return rho0*np.exp(-theta*A)

def legit_speed(A, psi):
    rho = rho_of_A(A)
    L = L0*(n**alpha)*(1-rho) / (1+psi*A)
    return np.exp(-lam*L)

def Phi(A):
    rho = rho_of_A(A)
    return rho*p + (1-rho)*(p**k)

def Pi(sigma, A):
    return sigma + (1-sigma)*Phi(A)

def neg_V(x, P, kappa, psi, mu, use_R2):
    sigma, A, R = x
    sigma = np.clip(sigma, 0, 1); A = max(A,0); R = max(R,0)
    v = sigma*v1 + (1-sigma)*legit_speed(A, psi)
    pi = Pi(sigma, A)
    deficit = max(P - R*v, 0)
    harm = kappa*pi*(R**2 if use_R2 else R)
    V = -beta*deficit**2 - harm - mu*sigma**2 - c_A*A**2 - c_R*R**2
    return -V

def solve(P, kappa, psi, mu, use_R2):
    best = None
    for s0 in [0.0,0.2,0.5,0.8,1.0]:
        for a0 in [0.0,1.0,2.0,4.0]:
            for r0 in [0.0,1.0,3.0,6.0,9.0]:
                res = minimize(neg_V, x0=[s0,a0,r0], args=(P,kappa,psi,mu,use_R2),
                                bounds=[(0,1),(0,10),(0,20)])
                if best is None or res.fun < best.fun:
                    best = res
    s,a,r = np.clip(best.x[0],0,1), max(best.x[1],0), max(best.x[2],0)
    return dict(P=P, sigma=s, A=a, R=r)

# まずGrokの検算を再現: psi=3でのv0(A=0), v0(A=1), v0(A=3)
for A_test in [0,1,3]:
    print(f"psi=3, A={A_test}: v0={legit_speed(A_test,3):.3f}")
# psiをどこまで上げればA=1でv0(0)を上回るか
for psi_test in [3,6,10,15,20]:
    print(f"psi={psi_test}: v0(0)={legit_speed(0,psi_test):.3f}  v0(1)={legit_speed(1,psi_test):.3f}")

print("\n=== v8.2: kappa=1, psi=10, use_R2=True, muを振る ===")
for mu in [1.0, 3.0, 6.0]:
    print(f"\n--- mu={mu} ---")
    for P in [0.5,1,2,3,4,5,6,7,8,9,10,12]:
        r = solve(P, kappa=1.0, psi=10.0, mu=mu, use_R2=True)
        print(f"P={P:4.1f}  sigma*={r['sigma']:.3f} A*={r['A']:.3f} R*={r['R']:.3f}")

# ---------------------------------------------------------------------
# v8.2（H(R)=R^2・psi=10で再較正した最終版。Gemini/ChatGPT/Grok三者の
# 診断を統合し、sigma*=0のままP上昇に対しA*,R*が共に滑らかに増加する
# 「ChatGPTの箱」(P->R->A)を再現した。ただしA*,R*が探索範囲の上限に
# 張り付く境界(P>~15)があり、それ以上のPでの結論は境界の産物であり
# 未検証。段階2(既存v1-v7へのC_R経由の接続)は次回以降の課題。
# ---------------------------------------------------------------------

Writing v8_2_model.py

%%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

%%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}")

Writing model_v7_absolute.py

## v8_to_v7_bridge.py
"""
v8.2(段階1) -> v1-v7(段階2) 接続スクリプト
============================================
Grok/ChatGPTの合意点: 「同じ目的関数に代入する」のではなく、
段階1の均衡Pi*(P)から求めたC_Rを、段階2(v7)のパラメータとして
外から渡す。

界面: model_v3.py の repression_cost(r, K) = C_R * r^2 * K^0.5
      のグローバル定数 C_R (デフォルト0.06) を、v8.2の
      C_R_v8(P) = C_bar + chi*(1 - Pi*(P)) から作った実効値で
      置き換える。

スケーリング: v8.2のC_R_v8は1〜4程度のオーダー、v1-v7のC_Rは0.06
オーダーで直接の単位対応はない。ここでは「P=P_baselineのときは
元のC_R=0.06のまま」となるよう比例で較正する(kappa_scale)。
これは暫定的な接続であり、絶対水準ではなく比較静学(C_Rが上がると
r*・tau*がどちらへ動くか)を見るためのものだと明記しておく。
"""

import numpy as np
import model_v3 as m
import model_v7_absolute as v7
from v8_2_model import solve as solve_v8, Pi as Pi_v8

C_R_BASE = m.C_R          # 0.06 (元のv1-v7の値)
C_BAR, CHI = 1.0, 3.0     # v8.2のC_R定義に使ったのと同じ定数
P_BASELINE = 3.0          # このPのときC_R_effective = C_R_BASEになるよう較正

def C_R_v8(P):
    r = solve_v8(P, kappa=1.0, psi=10.0, mu=3.0, use_R2=True)
    pi_star = Pi_v8(r["sigma"], r["A"])
    return r, pi_star, C_BAR + CHI*(1 - pi_star)

_, _, C_R_v8_baseline = C_R_v8(P_BASELINE)
kappa_scale = C_R_BASE / C_R_v8_baseline

K_H, K_AI, theta, delta = 8.0, 1e6, 1.5, 0.6

print(f"{'P':>5} {'sigma*':>7} {'A*':>7} {'R*':>7} {'Pi*':>6} {'C_R_eff':>8} "
      f"{'r*':>6} {'tau*':>6} {'q*':>6} {'phi':>6}")
for P in [0.5, 1, 2, 3, 4, 5, 6, 8, 10, 12]:
    r8, pi_star, c_r_v8 = C_R_v8(P)
    C_R_effective = c_r_v8 * kappa_scale
    m.C_R = C_R_effective  # 段階2へ界面越しに渡す(モンキーパッチ)
    (r, tau, e, q), V, phi = v7.best_interface(K_H, K_AI, theta, delta)
    print(f"{P:5.1f} {r8['sigma']:7.3f} {r8['A']:7.3f} {r8['R']:7.3f} "
          f"{pi_star:6.3f} {C_R_effective:8.4f} {r:6.3f} {tau:6.3f} {q:6.3f} {phi:6.3f}")

m.C_R = C_R_BASE  # 元に戻す

# ---------------------------------------------------------------------
# 追記: C_Rを広範囲に振った場合の単体挙動(較正のずれの確認用)
#   r*はC_R上昇とともに0.12->0へ単調減少(想定通りの符号)。
#   ただしv8.2の自然なP範囲(0.5-12)はC_Rを0.053-0.061という狭い帯にしか
#   動かさず、v7側のグリッド分解能(26分割)では検出できない。
#   次はchi(v8のC_R定義の感度係数)を大きくするか、写像を非線形にする
#   ことが課題として残る。
# ---------------------------------------------------------------------

=== kappa=0.15, psi=0.0 ===
P= 0.5  sigma*=0.060 A*=0.000 R*=0.871 rho*=0.900 Pi*=0.316
P= 1.0  sigma*=0.178 A*=0.000 R*=1.910 rho*=0.900 Pi*=0.402
P= 2.0  sigma*=0.357 A*=0.000 R*=3.351 rho*=0.900 Pi*=0.532
P= 3.0  sigma*=0.491 A*=0.000 R*=4.408 rho*=0.900 Pi*=0.630
P= 4.0  sigma*=0.602 A*=0.000 R*=5.279 rho*=0.900 Pi*=0.710
P= 5.0  sigma*=0.699 A*=0.000 R*=6.036 rho*=0.900 Pi*=0.781
P= 6.0  sigma*=0.786 A*=0.000 R*=6.715 rho*=0.900 Pi*=0.844
P= 7.0  sigma*=0.865 A*=0.000 R*=7.335 rho*=0.900 Pi*=0.902
P= 8.0  sigma*=0.939 A*=0.000 R*=7.909 rho*=0.900 Pi*=0.956
P= 9.0  sigma*=1.000 A*=0.000 R*=8.500 rho*=0.900 Pi*=1.000
P=10.0  sigma*=1.000 A*=0.000 R*=9.452 rho*=0.900 Pi*=1.000

=== kappa=0.15, psi=3.0 ===
P= 0.5  sigma*=0.060 A*=0.000 R*=0.871 rho*=0.900 Pi*=0.316
P= 1.0  sigma*=0.178 A*=0.000 R*=1.910 rho*=0.900 Pi*=0.402
P= 2.0  sigma*=0.357 A*=0.000 R*=3.351 rho*=0.900 Pi*=0.532
P= 3.0  sigma*=0.491 A*=0.000 R*=4.408 rho*=0.900 Pi*=0.630
P= 4.0  sigma*=0.602 A*=0.000 R*=5.279 rho*=0.900 Pi*=0.710
P= 5.0  sigma*=0.699 A*=0.000 R*=6.036 rho*=0.900 Pi*=0.781
P= 6.0  sigma*=0.786 A*=0.000 R*=6.715 rho*=0.900 Pi*=0.844
P= 7.0  sigma*=0.865 A*=0.000 R*=7.335 rho*=0.900 Pi*=0.902
P= 8.0  sigma*=0.939 A*=0.000 R*=7.909 rho*=0.900 Pi*=0.956
P= 9.0  sigma*=1.000 A*=0.000 R*=8.500 rho*=0.900 Pi*=1.000
P=10.0  sigma*=1.000 A*=0.000 R*=9.452 rho*=0.900 Pi*=1.000
psi=3, A=0: v0=0.165
psi=3, A=1: v0=0.130
psi=3, A=3: v0=0.237
psi=3: v0(0)=0.165  v0(1)=0.130
psi=6: v0(0)=0.165  v0(1)=0.311
psi=10: v0(0)=0.165  v0(1)=0.476
psi=15: v0(0)=0.165  v0(1)=0.600
psi=20: v0(0)=0.165  v0(1)=0.678

=== v8.2: kappa=1, psi=10, use_R2=True, muを振る ===

--- mu=1.0 ---
P= 0.5  sigma*=0.000 A*=0.635 R*=0.488
P= 1.0  sigma*=0.000 A*=1.517 R*=1.122
P= 2.0  sigma*=0.000 A*=2.972 R*=2.385
P= 3.0  sigma*=0.000 A*=3.998 R*=3.562
P= 4.0  sigma*=0.000 A*=4.801 R*=4.690
P= 5.0  sigma*=0.000 A*=5.475 R*=5.789
P= 6.0  sigma*=0.000 A*=6.063 R*=6.867
P= 7.0  sigma*=0.000 A*=6.590 R*=7.931
P= 8.0  sigma*=0.000 A*=7.071 R*=8.983
P= 9.0  sigma*=0.000 A*=7.517 R*=10.025
P=10.0  sigma*=0.000 A*=7.936 R*=11.060
P=12.0  sigma*=0.000 A*=8.709 R*=13.112

--- mu=3.0 ---
P= 0.5  sigma*=0.000 A*=0.635 R*=0.488
P= 1.0  sigma*=0.000 A*=1.517 R*=1.122
P= 2.0  sigma*=0.000 A*=2.972 R*=2.385
P= 3.0  sigma*=0.000 A*=3.998 R*=3.562
P= 4.0  sigma*=0.000 A*=4.801 R*=4.690
P= 5.0  sigma*=0.000 A*=5.475 R*=5.789
P= 6.0  sigma*=0.000 A*=6.063 R*=6.867
P= 7.0  sigma*=0.000 A*=6.590 R*=7.931
P= 8.0  sigma*=0.000 A*=7.071 R*=8.983
P= 9.0  sigma*=0.000 A*=7.517 R*=10.025
P=10.0  sigma*=0.000 A*=7.936 R*=11.060
P=12.0  sigma*=0.000 A*=8.709 R*=13.112

--- mu=6.0 ---
P= 0.5  sigma*=0.000 A*=0.635 R*=0.488
P= 1.0  sigma*=0.000 A*=1.517 R*=1.122
P= 2.0  sigma*=0.000 A*=2.972 R*=2.385
P= 3.0  sigma*=0.000 A*=3.998 R*=3.562
P= 4.0  sigma*=0.000 A*=4.801 R*=4.690
P= 5.0  sigma*=0.000 A*=5.475 R*=5.789
P= 6.0  sigma*=0.000 A*=6.063 R*=6.867
P= 7.0  sigma*=0.000 A*=6.590 R*=7.931
P= 8.0  sigma*=0.000 A*=7.071 R*=8.983
P= 9.0  sigma*=0.000 A*=7.517 R*=10.025
P=10.0  sigma*=0.000 A*=7.936 R*=11.060
P=12.0  sigma*=0.000 A*=8.709 R*=13.112
    P  sigma*      A*      R*    Pi*  C_R_eff     r*   tau*     q*    phi
  0.5   0.000   0.635   0.488  0.206   0.0531  0.120  0.480  0.525  0.000
  1.0   0.000   1.517   1.122  0.142   0.0561  0.120  0.480  0.525  0.000
  2.0   0.000   2.972   2.385  0.083   0.0589  0.120  0.480  0.525  0.000
  3.0   0.000   3.998   3.562  0.060   0.0600  0.120  0.480  0.525  0.000
  4.0   0.000   4.801   4.690  0.049   0.0605  0.120  0.480  0.525  0.000
  5.0   0.000   5.475   5.789  0.043   0.0608  0.120  0.480  0.525  0.000
  6.0   0.000   6.063   6.867  0.039   0.0610  0.120  0.480  0.525  0.000
  8.0   0.000   7.071   8.983  0.034   0.0612  0.120  0.480  0.525  0.000
 10.0   0.000   7.936  11.060  0.032   0.0614  0.120  0.480  0.525  0.000
 12.0   0.000   8.709  13.112  0.030   0.0614  0.120  0.480  0.525  0.000

%%writefile v7_sensitivity.py
"""
段階2(v7)単体の感度検証: グリッド粗さの影響を切り分ける。
GRID_N7=26(刻み0.04)を101(刻み0.01)に上げて、C_Rを細かく振っても
r*,tau*が本当に「動かない」のか「見えていないだけ」なのかを確認する。
"""
import numpy as np
import model_v3 as m
import model_v7_absolute as v7

K_H, K_AI, theta, delta = 8.0, 1e6, 1.5, 0.6

def best_interface_fine(K_H, K_AI, theta, delta, n=101, q_max=None):
    if q_max is None:
        q_max = v7.Q_MAX
    grid = np.linspace(0.0, 1.0, n)
    q_candidates = v7._q_candidates(q_max)
    e_max = max(1.0, v7.needed_audit_interface(K_H, min(q_max, 5.0)))
    R, TAU, EFRAC, Q = np.meshgrid(grid, grid, grid[::4], q_candidates, indexing="ij")  # Eは粗いままにして計算量を抑える
    E_local = EFRAC * e_max
    V, phi = v7.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 = grid[idx[0]], grid[idx[1]], Q[idx]
    e = E_local[idx]
    return (r, tau, e, q), V[idx], float(phi[idx])

print("=== v7を高解像度(r,tau:101点)で再計算 ===")
for c in [0.06, 0.10, 0.15, 0.20, 0.30, 0.40, 0.60, 0.80, 1.2, 2.0, 3.0]:
    m.C_R = c
    (r, tau, e, q), V, phi = best_interface_fine(K_H, K_AI, theta, delta)
    print(f"C_R={c:5.2f}  r*={r:.3f} tau*={tau:.3f} q*={q:.3f} phi={phi:.4f} V={V:.4f}")
m.C_R = 0.06

Writing v7_sensitivity.py

!python v7_sensitivity.py

=== v7を高解像度(r,tau:101点)で再計算 ===
C_R= 0.06  r*=0.110 tau*=0.460 q*=0.525 phi=0.0035 V=0.8461
C_R= 0.10  r*=0.080 tau*=0.460 q*=0.600 phi=0.0027 V=0.8452
C_R= 0.15  r*=0.080 tau*=0.460 q*=0.600 phi=0.0027 V=0.8443
C_R= 0.20  r*=0.080 tau*=0.460 q*=0.600 phi=0.0027 V=0.8434
C_R= 0.30  r*=0.080 tau*=0.460 q*=0.600 phi=0.0027 V=0.8416
C_R= 0.40  r*=0.070 tau*=0.450 q*=0.600 phi=0.0017 V=0.8399
C_R= 0.60  r*=0.050 tau*=0.470 q*=0.675 phi=0.0000 V=0.8378
C_R= 0.80  r*=0.050 tau*=0.470 q*=0.675 phi=0.0000 V=0.8364
C_R= 1.20  r*=0.040 tau*=0.460 q*=0.675 phi=0.0000 V=0.8341
C_R= 2.00  r*=0.020 tau*=0.470 q*=0.750 phi=0.0034 V=0.8322
C_R= 3.00  r*=0.020 tau*=0.470 q*=0.750 phi=0.0034 V=0.8310

## v8_v7_regime_bridge_final.py
"""
最終版: v8.2(段階1)とv1-v7(段階2)の接続 - Grok提案の「3制度レジーム比較」
=========================================================================
較正の教訓(Gemini/ChatGPT/Grok三者の査読を経て確定):
  比例較正(基準PでC_R_BASEに一致させる)は、C_R=C_bar+chi*(1-Pi)の
  加法定数C_barのせいで、chiをいくら動かしても相対変化がPiの変動幅
  (約22%)に潰されてしまう。これは実装ミスではなく、v8.2の経路が
  すでに「安全な領域」に入っているため、Pを動かしてもPiがあまり
  動かないという段階1側の性質による。

  そこでPに沿った連続比較ではなく、制度そのものが異なる3つの
  レジームを比較する(Grok提案):
    (a) v8.2経路: sigma=0を保ったままA,Rで対抗する社会
    (b) 例外開放: sigma=1(非常大権が常態化した社会)
    (c) 監査なしハンコ: A=0,sigma=0,rho=rho0(独立性への投資をしない社会)

得られた結論:
  - r*はC_Rの上昇(=Piの低下=よく監査された社会)につれて単調に下がる。
    理論の想定通りの符号。
  - tau*はレジームによらずほぼ一定(0.46-0.47)。v3の監査供給式
    N_BAR*(1-r)*(1+XI*tau) が r*の低下だけで自動的に監査供給を
    押し上げてしまい、phiがほぼ0のままなので、資本家がtauを追加で
    上げて監査を「買う」動機が働かない。
  - 結論: 「弾圧コストを上げると再分配が守られるか」への現時点の答えは
    「弾圧は減る。再分配は、この較正では自動的には増えない」。
"""
import numpy as np
import model_v3 as m
from v7_sensitivity import best_interface_fine
from v8_2_model import solve as solve_v8, Pi as Pi_v8, Phi as Phi_v8

K_H, K_AI, theta, delta = 8.0, 1e6, 1.5, 0.6
C_BAR, CHI = 1.0, 3.0


def C_R_of_pi(pi):
    return C_BAR + CHI * (1 - pi)


def run_regime(name, pi):
    C_R = C_R_of_pi(pi)
    m.C_R = C_R
    (r, tau, e, q), V, phi = best_interface_fine(K_H, K_AI, theta, delta)
    print(f"{name:22s} Pi={pi:6.3f} C_R={C_R:6.3f}  "
          f"r*={r:.3f} tau*={tau:.3f} q*={q:.3f} phi={phi:.4f}")


if __name__ == "__main__":
    r_lo = solve_v8(0.5, kappa=1.0, psi=10.0, mu=3.0, use_R2=True)
    pi_lo = Pi_v8(r_lo["sigma"], r_lo["A"])
    r_hi = solve_v8(12.0, kappa=1.0, psi=10.0, mu=3.0, use_R2=True)
    pi_hi = Pi_v8(r_hi["sigma"], r_hi["A"])

    run_regime("v8.2経路(P=0.5)", pi_lo)
    run_regime("v8.2経路(P=12)", pi_hi)
    run_regime("例外開放(sigma=1)", 1.0)
    run_regime("監査なしハンコ(A=0)", Phi_v8(0.0))

    m.C_R = 0.06

=== v7を高解像度(r,tau:101点)で再計算 ===
C_R= 0.06  r*=0.110 tau*=0.460 q*=0.525 phi=0.0035 V=0.8461
C_R= 0.10  r*=0.080 tau*=0.460 q*=0.600 phi=0.0027 V=0.8452
C_R= 0.15  r*=0.080 tau*=0.460 q*=0.600 phi=0.0027 V=0.8443
C_R= 0.20  r*=0.080 tau*=0.460 q*=0.600 phi=0.0027 V=0.8434
C_R= 0.30  r*=0.080 tau*=0.460 q*=0.600 phi=0.0027 V=0.8416
C_R= 0.40  r*=0.070 tau*=0.450 q*=0.600 phi=0.0017 V=0.8399
C_R= 0.60  r*=0.050 tau*=0.470 q*=0.675 phi=0.0000 V=0.8378
C_R= 0.80  r*=0.050 tau*=0.470 q*=0.675 phi=0.0000 V=0.8364
C_R= 1.20  r*=0.040 tau*=0.460 q*=0.675 phi=0.0000 V=0.8341
C_R= 2.00  r*=0.020 tau*=0.470 q*=0.750 phi=0.0034 V=0.8322
C_R= 3.00  r*=0.020 tau*=0.470 q*=0.750 phi=0.0034 V=0.8310
v8.2経路(P=0.5)          Pi= 0.206 C_R= 3.382  r*=0.010 tau*=0.460 q*=0.750 phi=0.0029
v8.2経路(P=12)           Pi= 0.030 C_R= 3.910  r*=0.010 tau*=0.460 q*=0.750 phi=0.0029
例外開放(sigma=1)          Pi= 1.000 C_R= 1.000  r*=0.040 tau*=0.460 q*=0.675 phi=0.0000
監査なしハンコ(A=0)           Pi= 0.273 C_R= 3.182  r*=0.020 tau*=0.470 q*=0.750 phi=0.0034

%%writefile model_v7_with_R.py
"""
v7改: 国家ロボット能力Rをneeded(監査需要)に組み込む
=====================================================
Grok/ChatGPT共通提案: 今のv7のneeded = K_H^gamma_H + B*q^PSIは、
段階1で作られた国家ロボットR自体の存在を知らない。そのため
C_R上昇 -> r*低下だけで監査供給が自動回復し、tau*を上げる動機が
生まれなかった。

Rをneededに追加する:
    needed(K_H, q, R) = K_H^GAMMA_H + B*q^PSI + D*R^ZETA

国家の実力Rが大きいほど、それ自体を監視する負担が生まれ、
r低下だけでは監査需要を満たせなくなる -> tau, Eへの投資が要る、
という構造にする。
"""
import numpy as np
import model_v3 as m
import model_v7_absolute as v7

D_COEF = 0.3
ZETA = 1.0

def needed_audit_with_R(K_H, q, R):
    return v7.needed_audit_interface(K_H, q) + D_COEF * (R ** ZETA)

def objective_with_R(r, tau, E, q, K_H, K_AI, R, theta, delta):
    a = 1.0
    s = m.capital_share(a)
    Y_H = m.output(K_H, a)
    q_eff = np.minimum(q, v7.y_ai(K_AI))
    gross = (1 - tau) * (s * Y_H + q_eff ** v7.RHO)

    need = needed_audit_with_R(K_H, q_eff, R)
    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 = v7.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

def best_interface_with_R(K_H, K_AI, R, theta, delta, n=61, q_max=None):
    if q_max is None:
        q_max = v7.Q_MAX
    grid = np.linspace(0.0, 1.0, n)
    q_candidates = v7._q_candidates(q_max)
    e_max = max(1.0, needed_audit_with_R(K_H, min(q_max, 5.0), R))
    Rg, TAUg, EFRAC, Q = np.meshgrid(grid, grid, grid[::3], q_candidates, indexing="ij")
    E_local = EFRAC * e_max
    V, phi = objective_with_R(Rg, TAUg, E_local, Q, K_H, K_AI, R, theta, delta)
    idx = np.unravel_index(np.argmax(V), V.shape)
    r, tau, q = grid[idx[0]], grid[idx[1]], Q[idx]
    e = E_local[idx]
    return (r, tau, e, q), V[idx], float(phi[idx])

if __name__ == "__main__":
    K_H, K_AI, theta, delta = 8.0, 1e6, 1.5, 0.6
    print("=== Rをneededに組み込んだ場合のr*,tau*,q* ===")
    for R_val in [0, 1, 3, 6, 10, 15, 20]:
        (r, tau, e, q), V, phi = best_interface_with_R(K_H, K_AI, R_val, theta, delta)
        print(f"R={R_val:5.1f}  r*={r:.3f} tau*={tau:.3f} q*={q:.3f} phi={phi:.4f}")

Writing model_v7_with_R.py

!python model_v7_with_R.py

=== Rをneededに組み込んだ場合のr*,tau*,q* ===
R=  0.0  r*=0.167 tau*=0.433 q*=0.600 phi=0.0059
R=  1.0  r*=0.117 tau*=0.450 q*=0.525 phi=0.0000
R=  3.0  r*=0.000 tau*=0.517 q*=0.600 phi=0.0068
R=  6.0  r*=0.000 tau*=0.533 q*=0.600 phi=0.3575
R= 10.0  r*=0.000 tau*=0.533 q*=0.675 phi=0.4754
R= 15.0  r*=0.000 tau*=0.533 q*=0.750 phi=0.5676
R= 20.0  r*=0.000 tau*=0.533 q*=0.825 phi=0.6291

## full_chain_tableau.py
"""
完全な連鎖のタブロー: P(資本ロボット脅威) -> v8.2(sigma*,A*,R*,Pi*) -> C_R
   -> v7改(Rをneededに含む): r*, tau*, q*, phi*
   -> V_total(Grok提案の定義)
"""
import numpy as np
import model_v3 as m
from v8_2_model import solve as solve_v8, Pi as Pi_v8
from model_v7_with_R import best_interface_with_R, needed_audit_with_R
import model_v7_absolute as v7

K_H, K_AI, theta, delta = 8.0, 1e6, 1.5, 0.6
C_BAR, CHI = 1.0, 3.0
LAMBDA_Q, LAMBDA_PI, LAMBDA_SIGMA = 0.5, 2.0, 1.0

def V_total(sigma, A, R, pi, r, tau, q, phi):
    a = 1.0
    s = m.capital_share(a)
    Y_H = m.output(K_H, a)
    fruit = tau * (s*Y_H + q**v7.RHO) * (1-phi)  # 市民に分配された果実
    return (fruit + LAMBDA_Q*q - LAMBDA_PI*pi - LAMBDA_SIGMA*sigma
            - 0.3*A**2 - 0.05*R**2)

print(f"{'P':>5} {'sigma*':>7} {'A*':>6} {'R*':>6} {'Pi*':>6} {'C_R':>6} "
      f"{'r*':>6} {'tau*':>6} {'q*':>6} {'phi':>6} {'V_tot':>7}")
for P in [0.5, 1, 2, 3, 5, 7, 9, 12]:
    r8 = solve_v8(P, kappa=1.0, psi=10.0, mu=3.0, use_R2=True)
    pi_star = Pi_v8(r8['sigma'], r8['A'])
    C_R = C_BAR + CHI*(1-pi_star)
    m.C_R = C_R
    (r, tau, e, q), V, phi = best_interface_with_R(K_H, K_AI, r8['R'], theta, delta)
    vt = V_total(r8['sigma'], r8['A'], r8['R'], pi_star, r, tau, q, phi)
    print(f"{P:5.1f} {r8['sigma']:7.3f} {r8['A']:6.2f} {r8['R']:6.2f} {pi_star:6.3f} "
          f"{C_R:6.3f} {r:6.3f} {tau:6.3f} {q:6.3f} {phi:6.3f} {vt:7.3f}")
m.C_R = 0.06

    P  sigma*     A*     R*    Pi*    C_R     r*   tau*     q*    phi   V_tot
  0.5   0.000   0.63   0.49  0.206  3.382  0.000  0.533  0.450  0.031   1.131
  1.0   0.000   1.52   1.12  0.142  3.574  0.017  0.450  0.750  0.001   0.687
  2.0   0.000   2.97   2.39  0.083  3.752  0.000  0.500  0.675  0.004  -1.290
  3.0   0.000   4.00   3.56  0.060  3.819  0.000  0.533  0.525  0.008  -3.773
  5.0   0.000   5.48   5.79  0.043  3.871  0.000  0.533  0.600  0.350  -9.445
  7.0   0.000   6.59   7.93  0.036  3.892  0.000  0.533  0.600  0.416 -15.037
  9.0   0.000   7.52  10.03  0.033  3.902  0.000  0.533  0.675  0.476 -20.879
 12.0   0.000   8.71  13.11  0.030  3.910  0.000  0.533  0.750  0.540 -30.296

%%writefile model_v7_with_R_Pi.py
"""
v7改2: 二重計上を修正。needed = K_H^gamma_H + B*q^PSI + D*R*Pi
  段階1でAによりPiが下がっている(=Rが安全化されている)ぶんだけ、
  段階2の人間経済監査への負担が減る、という設計にする。
"""
import numpy as np
import model_v3 as m
import model_v7_absolute as v7

D_COEF = 1.5  # R*Piなので係数を上げないとR単体版と規模が合わない

def needed_audit_with_R_Pi(K_H, q, R, Pi):
    return v7.needed_audit_interface(K_H, q) + D_COEF * R * Pi

def objective_with_R_Pi(r, tau, E, q, K_H, K_AI, R, Pi, theta, delta):
    a = 1.0
    s = m.capital_share(a)
    Y_H = m.output(K_H, a)
    q_eff = np.minimum(q, v7.y_ai(K_AI))
    gross = (1 - tau) * (s * Y_H + q_eff ** v7.RHO)

    need = needed_audit_with_R_Pi(K_H, q_eff, R, Pi)
    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 = v7.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

def best_interface_with_R_Pi(K_H, K_AI, R, Pi, theta, delta, n=61, q_max=None):
    if q_max is None:
        q_max = v7.Q_MAX
    grid = np.linspace(0.0, 1.0, n)
    q_candidates = v7._q_candidates(q_max)
    e_max = max(1.0, needed_audit_with_R_Pi(K_H, min(q_max, 5.0), R, Pi))
    Rg, TAUg, EFRAC, Q = np.meshgrid(grid, grid, grid[::3], q_candidates, indexing="ij")
    E_local = EFRAC * e_max
    V, phi = objective_with_R_Pi(Rg, TAUg, E_local, Q, K_H, K_AI, R, Pi, theta, delta)
    idx = np.unravel_index(np.argmax(V), V.shape)
    r, tau, q = grid[idx[0]], grid[idx[1]], Q[idx]
    e = E_local[idx]
    return (r, tau, e, q), V[idx], float(phi[idx])

if __name__ == "__main__":
    K_H, K_AI, theta, delta = 8.0, 1e6, 1.5, 0.6
    print("=== 単体テスト: Piを固定してRを振る(二重計上ありversion相当との比較) ===")
    for R_val in [0, 1, 3, 6, 10, 15, 20]:
        for Pi_val in [0.03, 0.27, 1.0]:
            (r, tau, e, q), V, phi = best_interface_with_R_Pi(K_H, K_AI, R_val, Pi_val, theta, delta)
            print(f"R={R_val:5.1f} Pi={Pi_val:.2f}  r*={r:.3f} tau*={tau:.3f} q*={q:.3f} phi={phi:.4f}")

Writing model_v7_with_R_Pi.py

!python model_v7_with_R_Pi.py

=== 単体テスト: Piを固定してRを振る(二重計上ありversion相当との比較) ===
R=  0.0 Pi=0.03  r*=0.167 tau*=0.433 q*=0.600 phi=0.0059
R=  0.0 Pi=0.27  r*=0.167 tau*=0.433 q*=0.600 phi=0.0059
R=  0.0 Pi=1.00  r*=0.167 tau*=0.433 q*=0.600 phi=0.0059
R=  1.0 Pi=0.03  r*=0.150 tau*=0.433 q*=0.600 phi=0.0021
R=  1.0 Pi=0.27  r*=0.083 tau*=0.467 q*=0.600 phi=0.0057
R=  1.0 Pi=1.00  r*=0.000 tau*=0.533 q*=0.525 phi=0.3089
R=  3.0 Pi=0.03  r*=0.150 tau*=0.433 q*=0.525 phi=0.0002
R=  3.0 Pi=0.27  r*=0.000 tau*=0.533 q*=0.525 phi=0.0368
R=  3.0 Pi=1.00  r*=0.000 tau*=0.533 q*=0.750 phi=0.5676
R=  6.0 Pi=0.03  r*=0.100 tau*=0.450 q*=0.600 phi=0.0008
R=  6.0 Pi=0.27  r*=0.000 tau*=0.533 q*=0.600 phi=0.4210
R=  6.0 Pi=1.00  r*=0.000 tau*=0.533 q*=1.050 phi=0.8330
R= 10.0 Pi=0.03  r*=0.067 tau*=0.467 q*=0.600 phi=0.0018
R= 10.0 Pi=0.27  r*=0.000 tau*=0.533 q*=0.750 phi=0.5461
R= 10.0 Pi=1.00  r*=0.000 tau*=0.533 q*=1.275 phi=0.8890
R= 15.0 Pi=0.03  r*=0.033 tau*=0.500 q*=0.600 phi=0.0000
R= 15.0 Pi=0.27  r*=0.000 tau*=0.533 q*=0.825 phi=0.6314
R= 15.0 Pi=1.00  r*=0.000 tau*=0.533 q*=1.650 phi=0.9230
R= 20.0 Pi=0.03  r*=0.000 tau*=0.517 q*=0.600 phi=0.0068
R= 20.0 Pi=0.27  r*=0.000 tau*=0.533 q*=0.975 phi=0.8182
R= 20.0 Pi=1.00  r*=0.000 tau*=0.533 q*=1.875 phi=0.9406

## full_chain_tableau_v2.py
"""
二重計上を修正した完全連鎖タブロー。needed に R*Pi(残差分のみ)を使う。
V_totalは合計せず、Grok提案通り項目ごとに分解して出す。
"""
import numpy as np
import model_v3 as m
from v8_2_model import solve as solve_v8, Pi as Pi_v8
from model_v7_with_R_Pi import best_interface_with_R_Pi
import model_v7_absolute as v7

K_H, K_AI, theta, delta = 8.0, 1e6, 1.5, 0.6

print(f"{'P':>5} {'A*':>6} {'R*':>6} {'Pi*':>6} {'r*':>6} {'tau*':>6} "
      f"{'q*':>6} {'phi':>6} | {'市民果実':>8} {'ハック損失phi':>10} {'制度費用A2+R2':>12}")
for P in [0.5, 1, 2, 3, 5, 7, 9, 12]:
    r8 = solve_v8(P, kappa=1.0, psi=10.0, mu=3.0, use_R2=True)
    pi_star = Pi_v8(r8['sigma'], r8['A'])
    (r, tau, e, q), V, phi = best_interface_with_R_Pi(K_H, K_AI, r8['R'], pi_star, theta, delta)
    a = 1.0
    s = m.capital_share(a)
    Y_H = m.output(K_H, a)
    fruit = tau * (s*Y_H + q**v7.RHO) * (1-phi)
    inst_cost = 0.3*r8['A']**2 + 0.05*r8['R']**2
    print(f"{P:5.1f} {r8['A']:6.2f} {r8['R']:6.2f} {pi_star:6.3f} {r:6.3f} {tau:6.3f} "
          f"{q:6.3f} {phi:6.3f} | {fruit:8.3f} {phi:10.3f} {inst_cost:12.3f}")

    P     A*     R*    Pi*     r*   tau*     q*    phi |     市民果実   ハック損失phi    制度費用A2+R2
  0.5   0.63   0.49  0.206  0.133  0.450  0.600  0.001 |    1.309      0.001        0.133
  1.0   1.52   1.12  0.142  0.133  0.450  0.525  0.000 |    1.288      0.000        0.753
  2.0   2.97   2.39  0.083  0.133  0.467  0.525  0.000 |    1.336      0.000        2.935
  3.0   4.00   3.56  0.060  0.100  0.467  0.600  0.000 |    1.358      0.000        5.429
  5.0   5.48   5.79  0.043  0.100  0.483  0.600  0.000 |    1.407      0.000       10.668
  7.0   6.59   7.93  0.036  0.083  0.483  0.600  0.000 |    1.407      0.000       16.172
  9.0   7.52  10.03  0.033  0.067  0.483  0.600  0.000 |    1.407      0.000       21.978
 12.0   8.71  13.11  0.030  0.050  0.483  0.600  0.008 |    1.397      0.008       31.348

## police_vs_military_check.py
# -*- coding: utf-8 -*-
"""
v8シリーズ最終検証: 警察ロボット vs 軍ロボットの比較
=====================================================
Grok提案: R_M/R_Pという新しい変数を増やさず、model_v7_with_R_Pi.py の
best_interface_with_R_Pi() を「同じR・異なるPi」で2回呼ぶだけで足りる。

  needed = K_H^GAMMA_H + B*q^PSI + D*R*Pi
  (Piは段階1でAによって安全化しきれなかった残差の捕獲確率)

  警察ロボット: Pi_P = 0.27
    日常的に市民と接触するため、sigma(迂回)や監査の緩みが常時
    発生しやすく、Piが高止まりする(v8.2で言う「監査なしハンコ」
    に近い状態)という想定。

  軍ロボット:   Pi_M = 0.03
    sigma=0を保ち、注意労働Aで捕獲確率を低く抑えた運用
    (v8.2の均衡経路)を想定。

結果: 同じ規模Rのロボットでも、警察配備はR=5あたりからphi(監査
破綻度)が急激に悪化するのに対し、軍配備はR=20でもほぼ無傷。
「警察にはロボットを使わせず、民主統制の軍に使わせる」という
当初の直観が、単なる制度上の好みではなく、Piを日常接触から
切り離せるかどうかという定量的な違いとして裏付けられた。

依存ファイル: model_v3.py, model_v7_absolute.py, model_v7_with_R_Pi.py
(同じディレクトリに置いて実行すること)
"""

from model_v7_with_R_Pi import best_interface_with_R_Pi

K_H, K_AI, theta, delta = 8.0, 1e6, 1.5, 0.6

PI_POLICE = 0.27   # 警察ロボット: 日常接触ゆえ構造的に高いPi
PI_MILITARY = 0.03  # 軍ロボット: sigma=0 + 注意労働Aで低く抑えたPi

if __name__ == "__main__":
    print(f"{'R':>5} | {'警察 Pi=0.27':^20} | {'軍 Pi=0.03':^20}")
    print(f"{'':>5} | {'tau*':>6} {'phi':>8} | {'tau*':>6} {'phi':>8}")
    for R in [0.5, 1, 2, 3, 5, 8, 12, 20]:
        (r_p, tau_p, e_p, q_p), V_p, phi_p = best_interface_with_R_Pi(
            K_H, K_AI, R, PI_POLICE, theta, delta)
        (r_m, tau_m, e_m, q_m), V_m, phi_m = best_interface_with_R_Pi(
            K_H, K_AI, R, PI_MILITARY, theta, delta)
        print(f"{R:5.1f} | {tau_p:6.3f} {phi_p:8.4f} | {tau_m:6.3f} {phi_m:8.4f}")

    R |      警察 Pi=0.27      |      軍 Pi=0.03      
      |   tau*      phi |   tau*      phi
  0.5 |  0.450   0.0000 |  0.433   0.0017
  1.0 |  0.467   0.0057 |  0.433   0.0021
  2.0 |  0.500   0.0007 |  0.450   0.0007
  3.0 |  0.533   0.0368 |  0.433   0.0002
  5.0 |  0.533   0.3820 |  0.450   0.0046
  8.0 |  0.533   0.4918 |  0.467   0.0008
 12.0 |  0.533   0.5831 |  0.467   0.0000
 20.0 |  0.533   0.8182 |  0.517   0.0068

R（同規模のロボット）	警察配備（Π=0.27）の監査破綻度φ	軍配備（Π=0.03）の監査破綻度φ
3	0.037	0.0002
5	0.382	0.0046
8	0.492	0.0008
20	0.818	0.0068

v6（既存）	v8（新規）	意味
x（AI経済への接続度）	s（緊急発動プロトコルの速度＝多者鍵の迂回度、0〜1）	0=完全な分散鍵承認、1=単独発動
K_AI（AI経済の規模）	K_threat（外部脅威＝資本家ロボット軍の強さ）	脅威が大きいほど速度の便益が増す
gamma_I（監査の真正性への信念）	n_eff（鍵保持者の実効的独立数）	設計の質そのもの

既存	v8 で分けるべき量	役割
$x$（監査が追いつかない接続）	$\sigma$（緊急迂回度）	上げると $C_R$ が下がる
$K_{AI}$	$K_T$（私兵・外部ロボット）	正当な速さの便益
$\gamma_I$ / 監査の質	$\rho$ ではなく捕獲構造 $\Phi(n,\rho,k)$	乗っ取り確率
$C_R$	$C_R(\sigma,n,\rho)$	$\tau$ 対 $r$ を決める
戦時の注意労働削減	$K_T$ 上昇＋$\rho$ 上昇＋時限例外	継ぎ目の恒常化

$A$	$\rho$	$v_0$
0	0.90	0.165
1	0.55	0.00028
2	0.33	0.000006

世界	中身	$\Pi$
v8.2（正当経路＋$A$）	$\sigma=0,\ A\uparrow$	$0.03\sim 0.21$
例外開放	$\sigma\to 1$	$1$
監査なしハンコ	$A=0,\ \sigma=0,\ \rho=\rho_0$	$\approx 0.27$

点	$\Delta\Pi(A=0\to 1)$	$\kappa R\Delta\Pi$	$c_A A^{2}$
$P=0.5,\ \sigma\approx 0.06,\ R\approx 0.9$	0.09	0.01	0.30
$P=5,\ \sigma\approx 0.70,\ R\approx 6$	0.03	0.03	0.30
$P=10,\ \sigma=1$	0	0	0.30

P（資本ロボット脅威）	A*（注意労働）	R*（国家ロボット能力）
0.5	0.64	0.49
2.0	2.97	2.39
5.0	5.48	5.79
10.0	7.94	11.06

P	A*	R*	Π*	C_R_eff	r*	τ*	q*
0.5	0.64	0.49	0.206	0.053	0.120	0.480	0.525
3.0	4.00	3.56	0.060	0.060	0.120	0.480	0.525
12.0	8.71	13.11	0.030	0.061	0.120	0.480	0.525

レジーム	Π	C_R	r*	τ*	q*
v8.2経路（P=0.5）	0.206	3.38	0.010	0.460	0.750
v8.2経路（P=12）	0.030	3.91	0.010	0.460	0.750
例外開放（σ=1）	1.000	1.00	0.040	0.460	0.675
監査なしハンコ（A=0）	0.273	3.18	0.020	0.470	0.750

$C_R$	$r^{\ast}$	$\tau^{\ast}$	$q^{\ast}$
0.06	0.110	0.460	0.525
0.40	0.070	0.450	0.600
0.80	0.050	0.470	0.675
3.00	0.020	0.470	0.750

P	A*	R*	Π*	C_R	τ*	q*	φ
0.5	0.63	0.49	0.206	3.38	0.533	0.450	0.031
3.0	4.00	3.56	0.060	3.82	0.533	0.525	0.008
5.0	5.48	5.79	0.043	3.87	0.533	0.600	0.350
9.0	7.52	10.03	0.033	3.90	0.533	0.675	0.476
12.0	8.71	13.11	0.030	3.91	0.533	0.750	0.540

$R$	$r^{\ast}$	$\tau^{\ast}$	$q^{\ast}$	$\phi$
0	0.167	0.433	0.600	0.006
3	0.000	0.517	0.600	0.007
6	0.000	0.533	0.600	0.358
20	0.000	0.533	0.825	0.629

パラメータ↑	資本家にとって	民衆・社会にとって	均衡で起きること
$C_R$	弾圧が高価	好ましい可能性	$r^*\downarrow$
$\Phi_{\max}$	監査不足が高価	好ましい	$\tau^,E^\uparrow$ 方向
$\theta$	政治圧力↑	民衆の交渉力↑	$\tau^*\uparrow$ 方向
$N_{\rm BAR}$	監査余地↑	監査能力↑	$\phi^*\downarrow$
$\kappa$	―	捕獲を嫌う	$A^\uparrow,\Pi^\downarrow$
$c_A$	―	注意労働が高価	$A^\downarrow,\Pi^\uparrow$
$c_R$	―	国家強制力が高価	$R^*\downarrow$
$\mu$	―	非常権限が高価	$\sigma^*\downarrow$
$\psi$	―	民主手続の生産性↑	$A^\uparrow,\sigma^\downarrow$ の可能性

パラメータ	社会 $V_8$	資本家 $V_7$	理由
市民監査キャパ $N_{\mathrm{BAR}}$	↑	↑	段階2の $\phi$ を下げる。$V_8$ には直接入らないが、$\phi$ を社会側の評価に含めるなら同じ
鍵の買収しにくさ（$p$ を下げる、$k$ を上げる）	↑	条件付き	$\Pi\downarrow$。社会は捕獲項が減る。資本家は後述の分岐による
正当経路を速くする $\psi$	↑	弱く↑	$A$ を積んでも $v$ が死なない。国家が $\sigma$ なしで $P$ に追いつける

パラメータ	社会 $V_8$	資本家 $V_7$
弾圧単価 $C_R$（$\chi,\underline C$）	↑（段階2の評価まで見るなら）	↓
私有ロボット脅威 $P$	↓	↑
迂回の制度化コスト $\mu$	↑（$\sigma$ を閉じたい）	↓（非常手段を安く残したい）
捕獲の残差 $\Pi$	↓	分岐

パラメータ	資本家（$V_7$ 向上）	民主社会（$V_8$ / 社会厚生向上）	均衡で起きる主要な構造変化
私兵ロボット脅威 $P$	↑（拡大）	↓（規制・縮小）	$P \uparrow \implies$ 国家防衛費（$A^2 + R^2$）が膨張し社会厚生を圧迫。資本家は圧力増強を好む。
手続迂回コスト $\mu$	↓（安価化）	↑（極大化）	$\mu \uparrow \implies$ 非常大権（$\sigma^$）が封じられ、正当手続（$\sigma^ = 0$）へ固定される。
国家監査負担係数 $D$	↓（免除）	適正維持	$D \downarrow \implies$ 国家軍 $R$ の存在に伴う監査・再分配（$\tau^*$）の自腹負担を回避しようとする。
弾圧ベースコスト $\underline{C}, \chi$	↓（安価化）	↑（高騰化）	$C_R \uparrow \implies$ 弾圧（$r^*$）が高くつき、資本家は弾圧支配を諦める。
市民監査キャパシティ $N_{\text{BAR}}$	↑（拡大）	↑（拡大）	【連合】市民側が無償で監査能力を提供するため、ハック損失 $\phi^*$ が下がり双方に利益。
手続高速化インフラ $\psi$	↑（賛同）	↑（推進）	【連合】注意労働 $A$ の意思決定遅延コストを下げ、正当手続のまま迅速な防衛を可能にする。

動かすパラメータ	社会側	資本家側	現行モデルでの意味
$P$	↓	↑	私有ロボット脅威
$C_R$	↑※	↓	弾圧の価格
$N_{\rm BAR}$	↑	↑	市民監査容量
$c_A$	↓	↓方向の可能性	注意労働の価格
$\mu$	↑	↓方向	非常権限の価格
$\psi$	↑	↑方向の可能性	民主的手続の生産性
$\kappa$	↑※	―	捕獲被害への社会的感度
$D$	↓※	↓	国家ロボットの監査負担係数
$\Pi$	↓	現行較正では ↓	未統制残差
$\Phi_{\max}$	↓	↓	監査不足被害の大きさ

「注意労働」論とロボット軍の民主主義モデル¶

要約¶

Author (文責)¶

AI¶

リンク¶

Claude さんによる今回のまとめのレポート¶

レポート: ロボット時代の弾圧コストと民主的統制——「統制されていない残差 R・Π」という物差し¶

1. 出発点にあった、素朴な問い¶

2. モデルの全体構造——二段階ゲームとしての社会¶

3. 段階1：迂回度と鍵の相関を分ける¶

4. 「注意労働は強制力を安全に持つための免許である」¶

5. 「規模の上限」は本物か、それとも二重計上か¶

6. 警察と軍——同じ規模でも運用が違えば結果は正反対になる¶

7. 弾圧を諦めても、再分配が自動で増えるわけではなかった¶

8. 現代の、それ未満の機械化文明にも当てはまるか¶

9. まとめ¶

会話ログ開始¶

今回の最初のモデル v8 への計画¶

なぜロボット化が弾圧コストを下げるのか¶

「警察には持たせず、軍には持たせる」という区分について¶

「国家独占」という論理自体は一貫している¶

だから「どの機関に持たせるか」だけでは解けない¶

変数の対応¶

n_eff の定義¶

便益・コスト関数¶

一階条件と解¶

出てきた興味深い点¶

留保¶

v8 計画への査読から v8 の作成へ¶

重要なのは「ロボット軍を持つか」ではなく「誰が究極的な強制力を持つか」¶

注意労働は「国家を弱くする」のではなく「国家の強制力を安全に強くする」¶

そう考えると、v8 の変数 s は少し違うものにしたほうがいい¶

まず Claude 案の数式¶

JRFさんの疑問への答え：何が v6 の $x$ に対応するか¶

分散鍵化で本当に出る特徴¶

接続できる骨格（v8'）¶

警察／軍の配置との関係¶

作るならどこを先に見るか¶

三者の意見の整理¶

統合したv8骨格¶

出てくる予想（ChatGPTの「二重のモラルハザード」の定式化）¶

結果1：低κ（内部弾圧リスクを軽視する社会）——なだらかな「継ぎ目の融解」¶

結果2：高κ（内部弾圧リスクを重視する社会）——注意労働の「先行崩壊」¶

持ち帰るべき論点¶

v8.1 モデルへ¶

AI各氏へ提示する論点・壁打ち項目¶

むしろ、今回の v8 で本当に出ているものは面白い¶

そこで、私は v8 を捨てずに「一段だけ」直すのがよいと思います¶

例えばこうです¶

さらに、資本家ロボットとの対抗をちゃんと入れる¶

したがって v8 の次の一手は「巨大化」ではなく、3層に分けることだと思います¶

数値が言っていること¶

駆動しているのは「独立性＝麻痺」¶

ChatGPT が甘く見える理由¶

残すべきものと、次に分けるべきもの¶

警察／軍の話に戻すと¶

壁打ちとして返す一句¶

修正1：ψ項（独立性を保ったまま正当経路を速くする投資）¶

修正2：R（国家ロボット能力）を独立変数として追加¶

最終結果：ChatGPTの「箱」は半分しか出なかった¶

v8.2 モデルへ¶

いまの $R$ は「国家の実力」と「国内弾圧能力」が完全に同じものになっている¶

したがって、次は「$R$ と $A$ を同じ効用関数で無理に奪い合わせない」がよい¶

第1段階：国家がどれだけの実力を持つ必要があるか¶

第2段階：その $R$ を民主的に安全に保有できる制度を作る¶

そして、いまの $C_R$ をここで活かせます¶

そうすると「弾圧コストを上げる」とは何なのかも明確になる¶

さらに面白いのは、ここで「警察」と「軍」を別の $R$ にできること¶

私なら次の v8.2 はこうします¶

いま起きていること¶

$\psi$ も、まだ「速く安全」になっていない¶

補完を出すための配線¶

$C_R$ への接続はまだ後工程¶

警察／軍¶

v8.2 で実装するなら、これ以上増やさない¶

最終まとめ¶

v7 と v8 の統合 その1¶

v8.2 が実際に示していること¶

段階2を先にする理由¶

警察／軍は段階2のあとで足りる¶

v7 と v8 の統合その1¶

v7 と v8 の統合その2¶

v7 と v8 の統合その3¶

v7 と v8 の統合その4¶

v7 と v8 の統合その5¶

まとめの議論その1¶

まとめの議論その1.5: Gemini さんの解説¶

まとめの議論その2¶