#!/usr/bin/env python3 """ Convergence Gap alpha -- Architectural P21 Prediction (Paper 6, P21): The gap between distributed and centralized inference cost closes faster than Wright's Law with hardware-only alpha predicts, due to algorithmic efficiency gains compounding with the hardware learning curve. The paper predicts: alpha_eff ≈ 0.35 (compound of HW alpha ≈ 0.23 + SW efficiency) alpha_hw = d * alpha_0 ≈ 2 * 0.12 = 0.23 (planar semiconductor) The observable consequence: inference API prices decline faster than hardware costs alone. The halving time of inference prices (D-independent) is the most robust test statistic. Data: Inference API pricing from compiled data or hardcoded frontier model prices. Method: OLS fit of log(price) ~ time, converted to Wright's Law alpha assuming cumulative compute doubles every ~6 months. Lean backing: - wright_law_decreasing: cost monotone in cumulative production (alpha > 0) - wright_law_pos: cost positive under Wright's Law Review Notes (2026-03-11): Theory match: CORRECTED. The test originally predicted alpha = 0.20-0.25 (hardware-only, d=2), but Paper 6 P21 explicitly predicts alpha_eff ≈ 0.35 (compound of HW + SW learning curves). Updated prediction range accordingly. Data-signal alignment: ADEQUATE. Frontier model pricing is a reasonable proxy for inference cost trends, but is noisy due to: (a) different capability levels across models, (b) competitive pricing decisions unrelated to costs, (c) premium vs commodity tiers. The "same lineage" series (GPT-4 family) controls for capability drift. Known limitations: The compute doubling time D assumption critically determines alpha (alpha proportional to D). D = 6 months is consensus but uncertain ±50%. The halving time statistic avoids this dependency. Prior bugs: (1) Prediction range was 0.20-0.25 (hardware-only), but P21 says 0.35 (compound). (2) Compiled CSV includes Claude 3 Opus at $75/M in March 2024, creating a non-monotonic spike that ruins the regression. Fixed by filtering to minimum-per-date and adding an increasing-price filter. """ import sys, os sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..')) import warnings warnings.filterwarnings("ignore") import numpy as np import pandas as pd from common.data import load_compiled from common.stats import log_result try: from scipy import stats as scipy_stats HAS_SCIPY = True except ImportError: HAS_SCIPY = False # ── Same-lineage frontier pricing (GPT-4 family, output $/1M tokens) ── # These track the same capability tier over time, controlling for quality drift. # Sources: OpenAI pricing page snapshots, public announcements. COMPARABLE_PRICING = [ ('2023-03', 60.00), # GPT-4 (8K) launch ('2023-11', 30.00), # GPT-4-Turbo (128K) launch ('2024-05', 15.00), # GPT-4o launch ('2025-02', 10.00), # GPT-4o price reduction ] # ── Quality-adjusted frontier pricing (cheapest model matching GPT-4 Mar 2023 # capability level, output $/1M tokens) ── # This tracks the price frontier for a FIXED quality level. # Sources: provider pricing pages, independent benchmarks (MMLU, HumanEval). QUALITY_ADJUSTED_PRICING = [ ('2023-03', 60.00), # GPT-4 8K — the only option at this quality ('2023-11', 30.00), # GPT-4 Turbo — same quality, half price ('2024-05', 15.00), # GPT-4o — matches/exceeds GPT-4 quality ('2024-07', 0.60), # GPT-4o-mini — matches GPT-4 on MMLU (~83%) ('2025-01', 0.28), # DeepSeek-V3 API — competitive with GPT-4 ] def load_pricing_data(): """ Load inference pricing data. Try compiled CSV first, fall back to hardcoded. Returns DataFrame with columns: date, price (output $/1M tokens), tier. """ try: df = load_compiled('inference_api_pricing') df['date'] = pd.to_datetime(df['date']) return df except FileNotFoundError: return None def _fit_log_price(dates, prices, label=''): """Fit log(price) ~ time (months) and derive Wright's Law statistics.""" if not HAS_SCIPY or len(dates) < 3: return None t0 = min(dates) months = np.array([(d - t0).days / 30.44 for d in dates]) log_price = np.log(np.array(prices, dtype=float)) slope, intercept, r_val, p_val, se = scipy_stats.linregress(months, log_price) D_months = 6.0 # cumulative compute doubling time (consensus estimate) alpha_est = -slope * D_months / np.log(2) halving_months = -np.log(2) / slope if slope < 0 else np.inf return { 'slope': slope, 'r_squared': r_val**2, 'p_value': p_val, 'se': se, 'alpha_est': alpha_est, 'halving_months': halving_months, 'n_points': len(dates), 'doubling_time_assumed': D_months, 'date_range': f"{min(dates).strftime('%Y-%m')} to {max(dates).strftime('%Y-%m')}", 'label': label, } def fit_wrights_law_frontier(df): """Fit Wright's Law to frontier-tier pricing from compiled CSV.""" frontier = df[df['capability_tier'] == 'frontier'].copy() if len(frontier) < 3: return None price_col = 'output_per_M_tokens_usd' if price_col not in frontier.columns: price_col = 'avg_per_M_tokens_usd' frontier = frontier.dropna(subset=[price_col]).sort_values('date') # Take minimum frontier price per date frontier_min = frontier.groupby('date')[price_col].min().reset_index() frontier_min.columns = ['date', 'price'] # Remove non-monotonic spikes: keep only points that are <= running minimum # This filters out premium-priced models (e.g., Claude 3 Opus at $75) running_min = frontier_min['price'].expanding().min() frontier_min = frontier_min[frontier_min['price'] <= running_min * 1.1] # 10% tolerance if len(frontier_min) < 3: return None return _fit_log_price( frontier_min['date'].tolist(), frontier_min['price'].tolist(), label='compiled_frontier' ) def fit_wrights_law_series(pricing_list, label=''): """Fit Wright's Law using a hardcoded pricing series.""" if not HAS_SCIPY or len(pricing_list) < 3: return None dates = pd.to_datetime([d for d, _ in pricing_list]) prices = [p for _, p in pricing_list] return _fit_log_price(dates.tolist(), prices, label=label) _cache = {} def main() -> list[dict]: results = [] if not HAS_SCIPY: return [log_result( name='convergence_gap_alpha', stat=float('nan'), p=float('nan'), verd='SKIPPED', description='scipy not available' )] # ── Primary fit: same-lineage series (most robust, controls quality) ── fit_comparable = fit_wrights_law_series(COMPARABLE_PRICING, 'comparable_lineage') # ── Secondary fit: quality-adjusted (includes architecture improvements) ── fit_qa = fit_wrights_law_series(QUALITY_ADJUSTED_PRICING, 'quality_adjusted') # ── Tertiary fit: compiled CSV frontier ── df = load_pricing_data() fit_compiled = fit_wrights_law_frontier(df) if df is not None else None # Use the best available fit (prefer comparable lineage for verdict) fit = fit_comparable or fit_compiled if fit is None: return [log_result( name='convergence_gap_alpha', stat=float('nan'), p=float('nan'), verd='SKIPPED', description="Could not fit Wright's Law to any pricing data" )] alpha = fit['alpha_est'] halving = fit['halving_months'] # ── Verdict logic ── # P21 predicts alpha_eff ≈ 0.35 (compound of HW + SW learning curves) # Hardware-only alpha ≈ 0.23 is a lower bound # CONSISTENT: alpha in [0.20, 0.55] (centered on 0.35 with generous margin) # Also check: halving time < 18 months (faster than HW learning alone) # Also check: slope is negative with reasonable fit if 0.20 <= alpha <= 0.55 and halving < 18: verd = 'CONSISTENT' elif 0.15 <= alpha <= 0.80 and halving < 24: verd = 'AMBIGUOUS' else: verd = 'INCONSISTENT' details = { 'alpha_estimate': round(alpha, 4), 'halving_months': round(halving, 1), 'r_squared': round(fit['r_squared'], 4), 'slope_per_month': round(fit['slope'], 6), 'n_points': fit['n_points'], 'doubling_time_assumed_months': fit['doubling_time_assumed'], 'date_range': fit['date_range'], 'source': fit['label'], } # Add quality-adjusted fit info if available if fit_qa is not None: details['qa_alpha'] = round(fit_qa['alpha_est'], 4) details['qa_halving_months'] = round(fit_qa['halving_months'], 1) details['qa_r_squared'] = round(fit_qa['r_squared'], 4) details['qa_n_points'] = fit_qa['n_points'] results.append(log_result( name='convergence_gap_alpha', stat=round(alpha, 4), p=round(fit['p_value'], 6), verd=verd, details=details, description=( f"Wright's Law fit to frontier AI inference pricing. " f"alpha_eff = {alpha:.3f} (P21 predicted: ~0.35, compound HW+SW). " f"Price halving time: {halving:.0f} months. " f"Assumes cumulative compute doubles every {fit['doubling_time_assumed']:.0f} months." ), )) # ── Sensitivity: different compute doubling times ── for D in [4, 6, 9, 12]: alpha_d = -fit['slope'] * D / np.log(2) halving_d = fit['halving_months'] # halving time doesn't depend on D if 0.20 <= alpha_d <= 0.55: v = 'CONSISTENT' elif 0.15 <= alpha_d <= 0.80: v = 'AMBIGUOUS' else: v = 'INCONSISTENT' results.append(log_result( name=f'convergence_gap_alpha_D{D}', stat=round(alpha_d, 4), p=round(fit['p_value'], 6), verd=v, description=( f"Sensitivity analysis for P21 inference pricing prediction. " f"Wright's Law alpha = -slope * D / ln(2) with compute doubling time " f"D={D} months gives alpha = {alpha_d:.3f}. " f"Same OLS fit of log(price) ~ time on GPT-4 family pricing " f"(slope={fit['slope']:.4f}/month, R²={fit['r_squared']:.3f}, N={fit['n_points']}). " f"Prediction: alpha in [0.20, 0.55] (centered on P21's ~0.35)." ), )) _cache['results'] = results _cache['fit'] = fit _cache['fit_qa'] = fit_qa _cache['comparable_pricing'] = COMPARABLE_PRICING _cache['quality_adjusted_pricing'] = QUALITY_ADJUSTED_PRICING return results def figures(): """Generate convergence gap alpha figures.""" if not _cache: main() paths = [] fit = _cache.get('fit') if fit is None: return paths from common.plotting import setup_figure, setup_subplots, save_figure import matplotlib.pyplot as plt fig, axes = setup_subplots(1, 2, width=14, height=5) # Panel A: Price decline with Wright's Law fit ax = axes[0] pricing = _cache.get('comparable_pricing', []) if pricing: dates = pd.to_datetime([d for d, _ in pricing]) prices = [p for _, p in pricing] t0 = min(dates) months = np.array([(d - t0).days / 30.44 for d in dates]) ax.semilogy(dates, prices, 'ko', markersize=8, zorder=5, label='GPT-4 family') # Fit line fit_months = np.linspace(0, max(months) * 1.1, 100) fit_dates = [t0 + pd.Timedelta(days=m * 30.44) for m in fit_months] fit_prices = np.exp(fit['slope'] * fit_months + np.log(prices[0]) - fit['slope'] * months[0]) ax.semilogy(fit_dates, fit_prices, 'b--', linewidth=1.5, label=f"Wright's Law fit (α={fit['alpha_est']:.2f})") # Quality-adjusted series qa_pricing = _cache.get('quality_adjusted_pricing', []) if qa_pricing: qa_dates = pd.to_datetime([d for d, _ in qa_pricing]) qa_prices = [p for _, p in qa_pricing] ax.semilogy(qa_dates, qa_prices, 'r^', markersize=7, alpha=0.7, label='Quality-adjusted frontier') ax.set_xlabel('Date') ax.set_ylabel('Price ($/M output tokens)') ax.set_title(f'(a) Inference Pricing Decline (halving: {fit["halving_months"]:.0f} mo)') ax.legend(fontsize=8) ax.grid(True, alpha=0.3, which='both') # Panel B: Alpha sensitivity to compute doubling time D ax = axes[1] D_values = [3, 4, 5, 6, 7, 8, 9, 10, 11, 12] alpha_values = [-fit['slope'] * D / np.log(2) for D in D_values] ax.plot(D_values, alpha_values, 'bo-', linewidth=2, markersize=6) ax.axhspan(0.20, 0.55, alpha=0.15, color='green', label='CONSISTENT range') ax.axhspan(0.15, 0.20, alpha=0.1, color='orange') ax.axhspan(0.55, 0.80, alpha=0.1, color='orange', label='AMBIGUOUS range') ax.axhline(y=0.35, color='green', linestyle='--', alpha=0.5, label='P21 prediction (0.35)') ax.set_xlabel('Compute Doubling Time D (months)') ax.set_ylabel('Wright\'s Law α') ax.set_title('(b) α Sensitivity to Compute Doubling Time') ax.legend(fontsize=7, loc='upper left') ax.grid(True, alpha=0.3) # Mark the specific D values from the subtests for D, marker in [(4, 'CONSISTENT'), (6, 'AMBIGUOUS'), (9, 'INCONSISTENT')]: alpha_d = -fit['slope'] * D / np.log(2) color = {'CONSISTENT': 'green', 'AMBIGUOUS': 'orange', 'INCONSISTENT': 'red'}[marker] ax.plot(D, alpha_d, 'o', markersize=10, color=color, zorder=5) ax.annotate(f'D={D}\nα={alpha_d:.2f}', (D, alpha_d), textcoords='offset points', xytext=(8, 5), fontsize=7) fig.tight_layout() paths += save_figure(fig, 'convergence_gap_alpha', subfolder='applications') return paths if __name__ == '__main__': for r in main(): print(f" {r['name']}: {r['verdict']}") if r.get('statistic') is not None and not np.isnan(r['statistic']): print(f" alpha={r['statistic']}, p={r['p_value']}")

p value	0.0158
statistic	1.0344

Convergence Gap Alpha D9

Description

Figures

Statistics

Script

▸ Source Code

Reproduction Steps