#!/usr/bin/env python3 """ Monetary Schism Simulation Tests -- Paper 7 (Settlement Feedback) ================================================================= Tests key predictions of the 4-ODE monetary schism model from monetary_schism_model.py. The model simulates AI-crypto adoption dynamics, monetary displacement, and dual-currency Solow paths. Testable predictions: 1. Bistable equilibrium: tipping point exists at interior crypto share 2. Crypto adoption follows S-curve with inflection ~2032 3. Dual-currency Solow path dominates fiat-only counterfactual 4. Policy effectiveness degrades nonlinearly (Lucas critique gap > 0) 5. Developing-economy accommodate path dominates resist path 6. Sensitivity: results robust to parameter perturbations Migrated from scripts/monetary_schism_model.py Review Notes (2026-03-12): Theory match: PARTIAL — Model implements qualitative predictions from Paper 7 (4-ODE system, bistable equilibrium, S-curve adoption, Lucas critique gap, developing divergence). Growth rate formulas in _compute_developing_advanced are calibrated, not derived from the formal 4-ODE system. No Lean formalization of developing divergence prediction. I/O audit: N/A (T1-T6 simulation), WEAK proxy for T7 (mcap/GDP != theta). Data-signal alignment: T1-T6 N/A (simulation). T7 WEAK proxy but valid for rank correlation (both are monotonically increasing adoption measures). Code quality: CLEAN — No bugs. T5 parameterization is non-trivial (shared base growth, quadratic disruption cost). T2 is a mathematical identity (logistic inflection = center), relabeled as sanity check. Confidence in verdict: LOW-MEDIUM — Most subtests are simulation checks (p=NaN). T7 provides empirical anchor (Spearman r=0.893, p=0.007). T5 is no longer tautological but produces AMBIGUOUS verdict (ratio 1.23). """ import warnings warnings.filterwarnings('ignore') import numpy as np import pandas as pd from pathlib import Path from dataclasses import dataclass, field import sys import os sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..')) from common.stats import log_result from common.plotting import setup_figure, setup_subplots, save_figure DATA_DIR = Path(__file__).resolve().parents[2] / 'data' / 'compiled' # ══════════════════════════════════════════════════════════════════════════════ # MODEL (extracted from scripts/monetary_schism_model.py) # ══════════════════════════════════════════════════════════════════════════════ YEARS = np.arange(2020, 2051) @dataclass class WorldEconomy: """Master simulation state for monetary schism model.""" years: np.ndarray = field(default_factory=lambda: YEARS.copy()) # AI Sector ai_base_2025: float = 391e9 ai_cagr: float = 0.306 ai_saturation: float = 0.35 # Crypto S-Curve theta_0: float = 0.02 theta_max: float = 0.65 k_scurve: float = 0.8 t_star: int = 2032 # World GDP gdp_2025: float = 105e12 gdp_growth_base: float = 0.03 # Solow Parameters alpha: float = 0.33 s_base: float = 0.22 delta: float = 0.05 g0: float = 0.02 # Coasean Parameters txn_cost_market_2025: float = 1.0 txn_cost_internal_2025: float = 0.4 smart_contract_deflation: float = 0.30 # Perez Cycle installation_start: int = 2020 turning_point_base: int = 2031 deployment_end: int = 2045 compression_factor: float = 0.6 def __post_init__(self): self.n = len(self.years) self._compute_all() def _compute_all(self): self._compute_gdp() self._compute_ai_sector() self._compute_crypto_scurve() self._compute_monetary_displacement() self._compute_solow_dual_currency() self._compute_tipping_point() self._compute_lucas_critique() self._compute_developing_advanced() def _compute_gdp(self): self.gdp = np.zeros(self.n) self.gdp[0] = self.gdp_2025 * (1 + self.gdp_growth_base) ** (self.years[0] - 2025) for i in range(1, self.n): self.gdp[i] = self.gdp[i-1] * (1 + self.gdp_growth_base) def _compute_ai_sector(self): self.ai_sector = np.zeros(self.n) for i, y in enumerate(self.years): raw = self.ai_base_2025 * (1 + self.ai_cagr) ** (y - 2025) share = raw / self.gdp[i] dampened_share = self.ai_saturation * share / ( self.ai_saturation + share * (1 - self.ai_saturation / 0.5)) self.ai_sector[i] = dampened_share * self.gdp[i] self.ai_gdp_share = self.ai_sector / self.gdp def _compute_crypto_scurve(self): self.theta = np.array([ self.theta_0 + (self.theta_max - self.theta_0) / ( 1 + np.exp(-self.k_scurve * (y - self.t_star))) for y in self.years ]) def _compute_monetary_displacement(self): self.ai_crypto_volume = self.ai_sector * self.theta self.fiat_exit_ratio = self.ai_crypto_volume / self.gdp self.policy_effectiveness = 1 - self.fiat_exit_ratio def _compute_solow_dual_currency(self): self.y_capita = np.zeros(self.n) self.y_capita_fiat_only = np.zeros(self.n) self.s_eff = np.zeros(self.n) self.tech_A = np.zeros(self.n) self.y_capita[0] = 2.0 self.y_capita_fiat_only[0] = 2.0 self.tech_A[0] = 1.0 for i in range(self.n): theta_i = self.theta[i] eps_x = 0.02 eps_m = 0.003 self.s_eff[i] = self.s_base + (eps_x - eps_m) * theta_i self.tech_A[i] = self.tech_A[0] * ( 1 + self.g0 * (1 + 0.5 * theta_i)) ** max(self.years[i] - 2020, 0) tech_A_fiat = self.tech_A[0] * (1 + self.g0) ** max(self.years[i] - 2020, 0) k_star = (self.s_eff[i] / (self.g0 + self.delta)) ** (1 / (1 - self.alpha)) self.y_capita[i] = self.tech_A[i] * k_star ** self.alpha k_star_fiat = (self.s_base / (self.g0 + self.delta)) ** (1 / (1 - self.alpha)) self.y_capita_fiat_only[i] = tech_A_fiat * k_star_fiat ** self.alpha # Normalize to 2025 = 100 idx = np.where(self.years == 2025)[0][0] norm = self.y_capita[idx] norm_fiat = self.y_capita_fiat_only[idx] self.y_capita = self.y_capita / norm * 100 self.y_capita_fiat_only = self.y_capita_fiat_only / norm_fiat * 100 def _compute_tipping_point(self): self.tp_shares = np.linspace(0, 1, 101) eta = 40 b0 = 5 c_base = 22 rho = 8 self.tp_benefit = b0 + eta * self.tp_shares self.tp_cost = c_base * (1 - self.tp_shares) + rho * (1 - self.tp_shares)**2 self.tp_net = self.tp_benefit - self.tp_cost crossings = np.where(np.diff(np.sign(self.tp_net)))[0] self.tipping_share = self.tp_shares[crossings[0]] if len(crossings) > 0 else 0.30 def _compute_lucas_critique(self): self.policy_eff_naive = np.zeros(self.n) self.policy_eff_actual = np.zeros(self.n) self.lucas_gap = np.zeros(self.n) for i, y in enumerate(self.years): theta_i = self.theta[i] self.policy_eff_naive[i] = 1.0 - 0.5 * self.fiat_exit_ratio[i] feedback = theta_i * 0.3 self.policy_eff_actual[i] = (1.0 - self.fiat_exit_ratio[i]) * (1.0 - feedback) self.lucas_gap[i] = self.policy_eff_naive[i] - self.policy_eff_actual[i] def _compute_developing_advanced(self): self.advanced_welfare = np.zeros(self.n) self.developing_accommodate = np.zeros(self.n) self.developing_resist = np.zeros(self.n) self.advanced_welfare[0] = 100 self.developing_accommodate[0] = 30 self.developing_resist[0] = 30 # Both developing paths share the same base growth rate (3%). # Accommodate: gains from crypto settlement efficiency (+2%*theta) # but pays a policy-disruption cost (-3%*theta^2) that grows # quadratically as monetary sovereignty erodes. # Resist: avoids disruption but pays exclusion cost (-1.5%*theta) # as the global economy shifts to crypto settlement. # At low theta: accommodate wins (linear benefit > quadratic cost). # At high theta: quadratic disruption cost could dominate, # making resist competitive. Outcome is NOT predetermined. base_growth = 0.03 acc_benefit = 0.02 # linear crypto efficiency gain acc_disruption = 0.03 # quadratic policy disruption cost res_exclusion = 0.015 # linear exclusion penalty for i in range(1, self.n): theta_i = self.theta[i] self.advanced_welfare[i] = self.advanced_welfare[i-1] * ( 1 + 0.02 + 0.005 * theta_i) acc_growth = base_growth + acc_benefit * theta_i - acc_disruption * theta_i**2 self.developing_accommodate[i] = self.developing_accommodate[i-1] * ( 1 + acc_growth) res_growth = max(base_growth - res_exclusion * theta_i, -0.01) self.developing_resist[i] = self.developing_resist[i-1] * (1 + res_growth) # ══════════════════════════════════════════════════════════════════════════════ # TESTS # ══════════════════════════════════════════════════════════════════════════════ _cache = {} def main(): """Run monetary schism simulation tests. Returns list of result dicts.""" results = [] econ = WorldEconomy() # ── T1: Tipping point exists at interior crypto share ────────────── tp = econ.tipping_share tp_interior = 0.05 < tp < 0.95 if tp_interior: verd_tp = 'CONSISTENT' else: verd_tp = 'INCONSISTENT' results.append(log_result( 'monetary_schism_tipping_point', stat=tp, p=np.nan, verd=verd_tp, details={ 'tipping_share': float(tp), 'interior': tp_interior, }, description="Tests that the 4-ODE monetary schism model produces a bistable equilibrium with an interior tipping point in crypto share (0.05 < phi < 0.95). Computed from benefit-cost crossing of the calibrated model." )) # ── T2: S-curve inflection near t_star ───────────────────────────── # Second derivative of theta should change sign near t_star dtheta = np.diff(econ.theta) d2theta = np.diff(dtheta) inflection_idx = np.argmax(dtheta) # max first derivative = inflection inflection_year = econ.years[inflection_idx] year_error = abs(inflection_year - econ.t_star) if year_error <= 2: verd_sc = 'CONSISTENT' elif year_error <= 5: verd_sc = 'AMBIGUOUS' else: verd_sc = 'INCONSISTENT' results.append(log_result( 'monetary_schism_scurve_inflection', stat=float(inflection_year), p=np.nan, verd=verd_sc, details={ 'inflection_year': int(inflection_year), 't_star': econ.t_star, 'year_error': int(year_error), }, description="Sanity check: verifies the logistic S-curve inflection is near the calibrated t_star (~2032). This is a mathematical identity of the logistic function (inflection = center), not an empirical test. Year error <= 2 is consistent." )) # ── T3: Dual-currency dominates fiat-only ────────────────────────── idx_2050 = np.where(econ.years == 2050)[0][0] dual_2050 = econ.y_capita[idx_2050] fiat_2050 = econ.y_capita_fiat_only[idx_2050] dominance = dual_2050 > fiat_2050 gap_pct = (dual_2050 - fiat_2050) / fiat_2050 * 100 # Check dominance holds across entire post-2025 period idx_2025 = np.where(econ.years == 2025)[0][0] always_dominates = np.all(econ.y_capita[idx_2025:] >= econ.y_capita_fiat_only[idx_2025:] - 0.01) if dominance and always_dominates and gap_pct > 1.0: verd_solow = 'CONSISTENT' elif dominance: verd_solow = 'AMBIGUOUS' else: verd_solow = 'INCONSISTENT' results.append(log_result( 'monetary_schism_dual_currency_dominance', stat=gap_pct, p=np.nan, verd=verd_solow, details={ 'dual_2050': float(dual_2050), 'fiat_2050': float(fiat_2050), 'gap_pct': float(gap_pct), 'always_dominates': bool(always_dominates), }, description="Tests that the dual-currency Solow path dominates the fiat-only counterfactual through 2050. Compares per-capita output from the extended Solow model with crypto-augmented savings and technology vs the baseline; gap > 1% and persistent dominance is consistent." )) # ── T4: Lucas critique gap is positive and growing ───────────────── lucas_gap_2050 = econ.lucas_gap[idx_2050] lucas_gap_positive = lucas_gap_2050 > 0 # Gap should be monotonically increasing post-2025 gap_post = econ.lucas_gap[idx_2025:] gap_increasing = np.all(np.diff(gap_post) >= -1e-10) if lucas_gap_positive and gap_increasing: verd_lucas = 'CONSISTENT' elif lucas_gap_positive: verd_lucas = 'AMBIGUOUS' else: verd_lucas = 'INCONSISTENT' results.append(log_result( 'monetary_schism_lucas_gap', stat=float(lucas_gap_2050), p=np.nan, verd=verd_lucas, details={ 'lucas_gap_2050': float(lucas_gap_2050), 'gap_positive': bool(lucas_gap_positive), 'gap_increasing': bool(gap_increasing), }, description="Tests that the Lucas critique gap (naive minus actual policy effectiveness) is positive and monotonically increasing post-2025. A growing gap indicates that traditional policy models increasingly overstate monetary policy transmission as crypto adoption rises." )) # ── T5: Developing accommodate > resist ──────────────────────────── dev_acc_2050 = econ.developing_accommodate[idx_2050] dev_res_2050 = econ.developing_resist[idx_2050] acc_dominates = dev_acc_2050 > dev_res_2050 ratio = dev_acc_2050 / dev_res_2050 if dev_res_2050 > 0 else np.inf # Should dominate across entire horizon always_acc = np.all(econ.developing_accommodate >= econ.developing_resist - 0.01) if acc_dominates and always_acc and ratio > 1.5: verd_dev = 'CONSISTENT' elif acc_dominates: verd_dev = 'AMBIGUOUS' else: verd_dev = 'INCONSISTENT' results.append(log_result( 'monetary_schism_developing_divergence', stat=float(ratio), p=np.nan, verd=verd_dev, details={ 'accommodate_2050': float(dev_acc_2050), 'resist_2050': float(dev_res_2050), 'ratio': float(ratio), 'always_dominates': bool(always_acc), }, description="Tests that developing economies following the 'accommodate' path (embrace crypto adoption) achieve higher welfare than the 'resist' path by 2050. Ratio > 1.5 and persistent dominance is consistent with the model's prediction of divergent development trajectories." )) # ── T6: Robustness -- parameter sensitivity ──────────────────────── # Vary key parameters and check if ALL qualitative results hold: # (a) dual-currency dominates fiat (T3) # (b) interior tipping point (T1) # (c) Lucas gap positive (T4) perturbations = [ {'k_scurve': 0.5}, {'k_scurve': 1.2}, {'t_star': 2029}, {'t_star': 2035}, {'ai_cagr': 0.20}, {'ai_cagr': 0.40}, {'theta_max': 0.45}, {'theta_max': 0.85}, ] n_dual = 0 n_tipping = 0 n_lucas = 0 n_tests = 0 rob_details = [] for params in perturbations: try: e = WorldEconomy(**params) idx50 = np.where(e.years == 2050)[0][0] dual_ok = bool(e.y_capita[idx50] > e.y_capita_fiat_only[idx50]) tip_ok = bool(0.05 < e.tipping_share < 0.95) lucas_ok = bool(e.lucas_gap[idx50] > 0) if dual_ok: n_dual += 1 if tip_ok: n_tipping += 1 if lucas_ok: n_lucas += 1 n_tests += 1 rob_details.append({ 'params': params, 'dual_ok': dual_ok, 'tipping_ok': tip_ok, 'lucas_ok': lucas_ok, }) except Exception: pass frac_dual = n_dual / n_tests if n_tests > 0 else 0.0 frac_tipping = n_tipping / n_tests if n_tests > 0 else 0.0 frac_lucas = n_lucas / n_tests if n_tests > 0 else 0.0 min_frac = min(frac_dual, frac_tipping, frac_lucas) if min_frac >= 0.875: verd_rob = 'CONSISTENT' elif min_frac >= 0.5: verd_rob = 'AMBIGUOUS' else: verd_rob = 'INCONSISTENT' results.append(log_result( 'monetary_schism_robustness', stat=min_frac, p=np.nan, verd=verd_rob, details={ 'n_tests': n_tests, 'frac_dual_dominance': float(frac_dual), 'frac_tipping_interior': float(frac_tipping), 'frac_lucas_positive': float(frac_lucas), 'min_fraction': float(min_frac), 'perturbation_results': rob_details, }, description="Tests sensitivity of three predictions to parameter perturbations (k_scurve, t_star, ai_cagr, theta_max): (a) dual-currency dominance, (b) interior tipping point, (c) positive Lucas gap. Runs 8 calibrations; all three must hold in >= 87.5% of cases." )) # ── T7: Empirical S-curve calibration ─────────────────────────── # Compare model theta(t) to observed stablecoin mcap as a fraction # of world GDP over the overlap period (2020-2025). theta is a share, # so we must normalize mcap to a share of GDP for a fair comparison. # The model predicts theta_0 = 2% in 2020, rising to ~65% by 2050. # We check whether observed share growth tracks the model's early # S-curve phase (both should be accelerating from a small base). from scipy.stats import spearmanr as _spearmanr t7_verd = 'SKIPPED' t7_stat = np.nan t7_details = {} try: mcap_df = pd.read_csv(DATA_DIR / 'stablecoin_treasury_weekly.csv', parse_dates=['date']) mcap_df = mcap_df.dropna(subset=['stablecoin_mcap']) mcap_df['year'] = mcap_df['date'].dt.year annual_mcap = mcap_df.groupby('year')['stablecoin_mcap'].mean() annual_mcap = annual_mcap[annual_mcap.index >= 2020] if len(annual_mcap) >= 3: # World GDP estimates (trillions) for normalization # Source: IMF WEO, approximate world_gdp = {2020: 84.9e12, 2021: 96.5e12, 2022: 100.2e12, 2023: 105.4e12, 2024: 109.5e12, 2025: 113.1e12, 2026: 117.0e12} # Observed share: stablecoin mcap / world GDP obs_share = {} for yr in annual_mcap.index: if yr in world_gdp: obs_share[yr] = annual_mcap[yr] / world_gdp[yr] if len(obs_share) >= 3: obs_yrs = sorted(obs_share.keys()) obs_vals = np.array([obs_share[y] for y in obs_yrs]) # Model theta over same years model_vals = np.array([ econ.theta[np.where(econ.years == y)[0][0]] for y in obs_yrs if y in econ.years ]) model_yrs = [y for y in obs_yrs if y in econ.years] # Spearman on levels (both should be monotonically increasing) if len(model_yrs) >= 3: r_sp, p_sp = _spearmanr(obs_vals[:len(model_yrs)], model_vals) else: r_sp, p_sp = np.nan, np.nan # Order-of-magnitude comparison at last common year last_yr = model_yrs[-1] obs_last = obs_share[last_yr] model_last = econ.theta[np.where(econ.years == last_yr)[0][0]] # Ratio of observed share to model theta share_ratio = obs_last / model_last if model_last > 0 else np.inf t7_stat = float(share_ratio) t7_details = { 'observed_share_pct': {str(y): float(v * 100) for y, v in obs_share.items()}, 'model_theta_pct': {str(y): float(econ.theta[ np.where(econ.years == y)[0][0]] * 100) for y in model_yrs}, 'share_ratio_last_year': float(share_ratio), 'last_year': int(last_yr), 'spearman_r': float(r_sp) if not np.isnan(r_sp) else None, 'spearman_p': float(p_sp) if not np.isnan(p_sp) else None, 'n_years': len(model_yrs), } # Both are small shares growing over time; Spearman should # be strongly positive. Levels may differ by an order of # magnitude since stablecoin mcap/GDP is NOT theta (crypto # share of AI economy), but both should be increasing. if r_sp >= 0.7: t7_verd = 'CONSISTENT' elif r_sp >= 0.3: t7_verd = 'AMBIGUOUS' elif not np.isnan(r_sp): t7_verd = 'INCONSISTENT' except FileNotFoundError: t7_details = {'error': 'stablecoin_treasury_weekly.csv not found'} results.append(log_result( 'monetary_schism_empirical_scurve', stat=t7_stat, p=t7_details.get('spearman_p', np.nan) or np.nan, verd=t7_verd, details=t7_details, description=( "Tests whether observed stablecoin mcap (as a share of world GDP) " "tracks the model's S-curve adoption trajectory over 2020-2026. " "Computes Spearman rank correlation between observed share and " "model theta; r >= 0.7 is consistent (both monotonically " "increasing). Levels may differ since mcap/GDP is not exactly " "theta. Data: stablecoin_treasury_weekly.csv + IMF WEO GDP." ) )) # Cache for figures _cache['econ'] = econ _cache['results'] = results _cache['empirical_scurve'] = t7_details return results def figures() -> list: """Generate monetary schism figures from cached simulation.""" if not _cache: main() econ = _cache.get('econ') if econ is None: return [] paths = [] yrs = econ.years # ── Figure 1: Phase portrait (tipping point) ────────────────────── fig, ax = setup_figure(width=8, height=5) ax.plot(econ.tp_shares * 100, econ.tp_benefit, 'g-', linewidth=2, label='Benefit B(phi)') ax.plot(econ.tp_shares * 100, econ.tp_cost, 'r-', linewidth=2, label='Cost C(phi)') ax.fill_between(econ.tp_shares * 100, econ.tp_benefit, econ.tp_cost, where=econ.tp_benefit > econ.tp_cost, alpha=0.15, color='green') ax.fill_between(econ.tp_shares * 100, econ.tp_benefit, econ.tp_cost, where=econ.tp_benefit < econ.tp_cost, alpha=0.15, color='red') ax.axvline(econ.tipping_share * 100, color='purple', linestyle='--', linewidth=1.5, label=f'Tipping point ({econ.tipping_share*100:.0f}%)') ax.set_xlabel('Crypto share of AI economy (%)') ax.set_ylabel('Welfare units') ax.set_title('Monetary Schism: Tipping Point Dynamics') ax.legend(fontsize=9) paths.extend(save_figure(fig, 'monetary_schism_tipping_point', subfolder='applications')) # ── Figure 2: Dual-currency Solow paths ─────────────────────────── fig, ax = setup_figure(width=8, height=5) ax.plot(yrs, econ.y_capita, 'b-', linewidth=2, label='Dual-currency path') ax.plot(yrs, econ.y_capita_fiat_only, 'k--', linewidth=1.5, label='Fiat-only counterfactual') ax.fill_between(yrs, econ.y_capita_fiat_only, econ.y_capita, where=econ.y_capita > econ.y_capita_fiat_only, alpha=0.2, color='steelblue') ax.set_xlabel('Year') ax.set_ylabel('Output per capita (2025 = 100)') ax.set_title('Dual-Currency Extended Solow Model') ax.legend(fontsize=9) paths.extend(save_figure(fig, 'monetary_schism_solow', subfolder='applications')) # ── Figure 3: S-curve and inflection ───────────────────────────── fig, ax = setup_figure(width=8, height=5) ax.plot(yrs, econ.theta * 100, 'b-', linewidth=2, label='Crypto share theta(t)') dtheta = np.diff(econ.theta) inflection_idx = np.argmax(dtheta) ax.axvline(econ.years[inflection_idx], color='red', linestyle='--', label=f'Inflection: {econ.years[inflection_idx]}') ax.axvline(econ.t_star, color='gray', linestyle=':', label=f't* = {econ.t_star}') ax.set_xlabel('Year') ax.set_ylabel('Crypto share (%)') ax.set_title('S-Curve Adoption with Inflection Point') ax.legend(fontsize=9) paths.extend(save_figure(fig, 'monetary_schism_scurve', subfolder='applications')) # ── Figure 4: Lucas critique gap ────────────────────────────────── fig, ax = setup_figure(width=8, height=5) ax.plot(yrs, econ.policy_eff_naive, 'b-', linewidth=2, label='Naive policy effectiveness') ax.plot(yrs, econ.policy_eff_actual, 'r-', linewidth=2, label='Actual policy effectiveness') ax.fill_between(yrs, econ.policy_eff_actual, econ.policy_eff_naive, alpha=0.2, color='orange', label='Lucas gap') ax.set_xlabel('Year') ax.set_ylabel('Policy effectiveness') ax.set_title('Lucas Critique Gap: Naive vs Actual Monetary Policy') ax.legend(fontsize=9) paths.extend(save_figure(fig, 'monetary_schism_lucas_gap', subfolder='applications')) # ── Figure 5: Developing economy divergence ─────────────────────── fig, ax = setup_figure(width=8, height=5) ax.plot(yrs, econ.developing_accommodate, 'g-', linewidth=2, label='Accommodate') ax.plot(yrs, econ.developing_resist, 'r--', linewidth=2, label='Resist') ax.plot(yrs, econ.advanced_welfare, 'b:', linewidth=1.5, label='Advanced (reference)') ax.set_xlabel('Year') ax.set_ylabel('Welfare index (2020 = base)') ax.set_title('Developing Economy: Accommodate vs Resist Crypto Adoption') ax.legend(fontsize=9) paths.extend(save_figure(fig, 'monetary_schism_developing', subfolder='applications')) # ── Figure 6: Empirical S-curve comparison ──────────────────────── emp = _cache.get('empirical_scurve', {}) if emp and 'observed_share_pct' in emp: try: obs_pct = emp['observed_share_pct'] model_pct = emp['model_theta_pct'] obs_yrs = sorted(int(y) for y in obs_pct.keys()) mod_yrs = sorted(int(y) for y in model_pct.keys()) fig, (ax1, ax2) = setup_subplots(nrows=1, ncols=2, width=12, height=5) # Left: observed stablecoin mcap/GDP share ax1.plot(obs_yrs, [obs_pct[str(y)] for y in obs_yrs], 'ko-', linewidth=2, label='Stablecoin mcap / world GDP') ax1.set_xlabel('Year') ax1.set_ylabel('Share (%)') ax1.set_title('Observed: Stablecoin Share of GDP') ax1.legend(fontsize=9) ax1.grid(True, alpha=0.3) # Right: model theta ax2.plot(mod_yrs, [model_pct[str(y)] for y in mod_yrs], 'b--o', linewidth=2, label='Model theta') ax2.set_xlabel('Year') ax2.set_ylabel('Crypto share (%)') ax2.set_title('Model: Calibrated Theta') ax2.legend(fontsize=9) ax2.grid(True, alpha=0.3) r_sp = emp.get('spearman_r') fig.suptitle( f'Empirical vs Model Adoption (Spearman r={r_sp:.2f})' if r_sp else 'Empirical vs Model Adoption', fontsize=12, y=1.02) fig.tight_layout() paths.extend(save_figure(fig, 'monetary_schism_empirical_scurve', subfolder='applications')) except Exception: pass # ── Figure 7: Sensitivity -- theta under parameter variation ────── fig, axes = setup_subplots(nrows=1, ncols=3, width=14, height=4) # S-curve steepness for k_val, ls, lbl in [(0.5, ':', 'k=0.5'), (0.8, '-', 'k=0.8'), (1.2, '--', 'k=1.2')]: e = WorldEconomy(k_scurve=k_val) axes[0].plot(e.years, e.theta * 100, linewidth=1.5, linestyle=ls, label=lbl) axes[0].set_title('S-curve steepness') axes[0].set_ylabel('Crypto share (%)') axes[0].legend(fontsize=8) axes[0].grid(True, alpha=0.3) # Inflection year for ts, ls, lbl in [(2029, ':', 't*=2029'), (2032, '-', 't*=2032'), (2035, '--', 't*=2035')]: e = WorldEconomy(t_star=ts) axes[1].plot(e.years, e.fiat_exit_ratio * 100, linewidth=1.5, linestyle=ls, label=lbl) axes[1].set_title('Inflection year') axes[1].set_ylabel('Fiat exit ratio (%GDP)') axes[1].legend(fontsize=8) axes[1].grid(True, alpha=0.3) # AI CAGR for cagr, ls, lbl in [(0.20, ':', '20%'), (0.306, '-', '31%'), (0.40, '--', '40%')]: e = WorldEconomy(ai_cagr=cagr) axes[2].plot(e.years, e.ai_sector / 1e12, linewidth=1.5, linestyle=ls, label=lbl) axes[2].set_title('AI sector CAGR') axes[2].set_ylabel('AI sector ($T)') axes[2].legend(fontsize=8) axes[2].grid(True, alpha=0.3) for ax in axes: ax.set_xlabel('Year') fig.suptitle('Monetary Schism: Sensitivity Analysis', fontsize=12, y=1.02) fig.tight_layout() paths.extend(save_figure(fig, 'monetary_schism_sensitivity', subfolder='applications')) return paths if __name__ == '__main__': res = main() for r in res: p_str = f"{r['p_value']:.4f}" if not np.isnan(r['p_value']) else "N/A" stat_str = f"{r['statistic']:.4f}" if not np.isnan(r['statistic']) else "N/A" print(f" {r['name']:50s} {r['verdict']:15s} stat={stat_str} p={p_str}") # Generate figures fig_paths = figures() if fig_paths: print(f"\nFigures saved:") for p in fig_paths: print(f" {p}")

n tests	8
n robust	8
statistic	1
robustness fraction	1

Monetary Schism Robustness

Description

Figures

Statistics

Script

▸ Source Code

Reproduction Steps