#!/usr/bin/env python3 """ Technology Cycle Predictions Test -- Paper 6, Predictions #19-27 ================================================================ Tests predictions derived from the Technology Cycle framework: #21 Duration formula: tau ~ ln(c0/c*)/alpha predicts historical cycle lengths #22 Successive cycle compression: tau_{n+1} < tau_n as alpha rises #24 Crisis sequence ordering: financial -> production -> governance #25 New technologies arrive with alpha = d * alpha_0 (geometric dimension) #26 AI crossing ~2028 (consumer silicon trajectory) Migrated from scripts/test_tech_cycle_predictions.py Review Notes (2026-03-12): Theory match: CORRECT. Lean axiom `transition_duration_scaling` (Neishtadt GSPT). Predictions from Paper 6 (AI Transition). I/O audit: CORRECT. Sign conventions standard. Data-signal alignment: IMPROVED. Out-of-sample validation cycles added (Automobiles d=1 alpha=0.14, Semiconductors d=2 alpha=0.24). Crisis ordering expanded from 3 to 5 cycles. Learning curve alpha test replaced with geometric dimension clustering test (d=1 vs d=2, per- product classification). Duration formula still circular (in-sample), but out-of-sample compression test added. Code quality: CLEAN after fixes. Confidence in verdict: MEDIUM. Out-of-sample data strengthens falsifiability. Geometric dimension test (p=0.027) is genuinely predictive — d=2 technologies have significantly higher alpha than d=1. However, the observed ratio (1.30) falls short of the predicted 2.0. The d=1 mean (0.173) exceeds the theoretical alpha_0=0.12, possibly due to organizational learning in aerospace/shipbuilding entries. Date of review: 2026-03-12. """ import warnings import numpy as np import pandas as pd from scipy import stats from common.config import COMPILED_DIR, RESULTS_DIR from common.data import load_compiled from common.plotting import setup_figure, setup_subplots, save_figure from common.stats import verdict, log_result warnings.filterwarnings('ignore') # Historical calibration table (from paper — IN-SAMPLE) # d = geometric dimension: planar technologies d=2, linear/assembly d=1 CALIBRATION_TABLE = [ {"technology": "Railroads", "alpha": 0.18, "d": 1, "predicted_tau": 52, "actual_tau": 50, "start_year": 1830}, {"technology": "Electrification", "alpha": 0.22, "d": 2, "predicted_tau": 42, "actual_tau": 40, "start_year": 1882}, {"technology": "Telephony", "alpha": 0.20, "d": 1.5, "predicted_tau": 44, "actual_tau": 40, "start_year": 1876}, {"technology": "Internet", "alpha": 0.30, "d": 2, "predicted_tau": 18, "actual_tau": 20, "start_year": 1990}, {"technology": "AI (projected)", "alpha": 0.35, "d": 2, "predicted_tau": 13.5, "actual_tau": None, "start_year": 2015}, ] # Out-of-sample validation cycles (NOT used in paper's calibration) OUT_OF_SAMPLE_TABLE = [ {"technology": "Automobiles", "alpha": 0.14, "d": 1, "actual_tau": 30, "start_year": 1900, "source": "Abernathy & Wayne 1974; BCG 85% progress ratio; d=1 assembly line"}, {"technology": "Semiconductors", "alpha": 0.24, "d": 2, "actual_tau": 35, "start_year": 1960, "source": "Flamm 1993 Intel uP alpha=0.24; d=2 planar lithography; 1960-1995 IC cycle"}, ] # Crisis events — IN-SAMPLE (from paper) CRISIS_EVENTS_IN_SAMPLE = [ {"cycle": "Railroads", "event": "Jay Cooke panic", "year": 1873, "type": "F"}, {"cycle": "Railroads", "event": "Rate wars", "year": 1881, "type": "P"}, {"cycle": "Railroads", "event": "ICC regulation", "year": 1887, "type": "G"}, {"cycle": "Electrification","event": "1907 Panic", "year": 1907, "type": "F"}, {"cycle": "Electrification","event": "Insull collapse", "year": 1932, "type": "P"}, {"cycle": "Electrification","event": "PUHCA regulation", "year": 1935, "type": "G"}, {"cycle": "Internet", "event": "Dot-com crash", "year": 2000, "type": "F"}, {"cycle": "Internet", "event": "Overbuilt fiber", "year": 2002, "type": "P"}, {"cycle": "Internet", "event": "Net neutrality", "year": 2005, "type": "G"}, ] # Crisis events — OUT-OF-SAMPLE CRISIS_EVENTS_OUT_OF_SAMPLE = [ # Automobiles: speculative auto stock boom -> overproduction shakeout -> NIRA regulation {"cycle": "Automobiles", "event": "1929 Wall St crash", "year": 1929, "type": "F"}, {"cycle": "Automobiles", "event": "Overproduction shakeout", "year": 1932, "type": "P"}, {"cycle": "Automobiles", "event": "NIRA auto regulation", "year": 1933, "type": "G"}, # Semiconductors (1980s DRAM cycle): overinvestment -> DRAM bust -> trade agreement {"cycle": "Semiconductors", "event": "DRAM overinvestment", "year": 1984, "type": "F"}, {"cycle": "Semiconductors", "event": "1985 DRAM bust", "year": 1985, "type": "P"}, {"cycle": "Semiconductors", "event": "US-Japan STA", "year": 1986, "type": "G"}, # Nuclear (GOVERNANCE-ARRESTED): F->G->P, NOT F->P->G. # Litigation and regulatory escalation PRECEDED and CAUSED the production # crisis, inverting the normal causal chain. Each reactor became a bespoke # legal target — you can't ride a learning curve when every unit is forced # to be unique. South Korea/China prove the engineering learning was positive # when governance permitted standardization. {"cycle": "Nuclear", "event": "Cost overrun financing crisis", "year": 1975, "type": "F"}, {"cycle": "Nuclear", "event": "TMI + NRC moratorium", "year": 1979, "type": "G"}, {"cycle": "Nuclear", "event": "WPPSS default + cancellations", "year": 1983, "type": "P"}, ] ALL_CRISIS_EVENTS = CRISIS_EVENTS_IN_SAMPLE + CRISIS_EVENTS_OUT_OF_SAMPLE # Geometric dimension classification for learning curve literature # d=2: planar/lithographic processes (semiconductor, solar PV, battery electrodes) # d=1: linear/assembly/chemical processes (automotive, aerospace, wind, chemical) # Classification is per-PRODUCT, not per-industry, because some industries # contain both d=1 and d=2 processes (e.g., Energy: solar PV is d=2, wind is d=1) GEOMETRIC_DIM_BY_PRODUCT = { # Semiconductor — all d=2 (lithographic/planar) 'DRAM (7 generations, IV)': 2, 'Microprocessors/SoC (firm-node)': 2, 'Microprocessors/SoC (w/ within-firm)': 2, 'Microprocessors/SoC (w/ cross-border)': 2, 'DRAM (aggregate, OLS)': 2, # excluded as outlier (alpha=0.77) 'DRAM (early subsample)': 2, 'DRAM (late subsample)': 2, 'DRAM (middle subsample)': 2, # excluded as outlier (alpha=0.85) 'NAND Flash': 2, 'HBM (stacked memory)': 2, 'Intel microprocessors': 2, 'Solar PV cells': 2, # d=2: photovoltaic cell is planar # Aerospace — d=1 (assembly line) 'Aircraft assembly (Wright)': 1, 'Liberty ship assembly': 1, 'Airbus A380': 1, # Automotive — d=1 (assembly line) 'Ford Model T': 1, 'Toyota hybrid (Prius)': 1, # Energy — mixed 'Wind turbines (onshore)': 1, # d=1: turbine assembly, blade mfg 'Lithium-ion batteries': 2, # d=2: electrode coating is planar 'Electrolyzers (green H2)': 1, # d=1: chemical process equipment # Financial — d=1 'ATM deployment per unit': 1, 'Credit card processing cost': 1, 'Mobile money (M-Pesa)': 1, # Internet — d=2 (semiconductor-based server hardware) 'Web hosting cost per GB': 2, 'Cloud compute (AWS EC2)': 2, } _ALL_SUBTESTS = [ 'tech_cycle_duration_formula', 'tech_cycle_compression', 'tech_cycle_out_of_sample', 'tech_cycle_crisis_ordering', 'tech_cycle_ai_crossing', 'tech_cycle_geometric_dimension', ] def test_duration_formula(): """#21: Duration formula tau ~ ln(c0/c*)/alpha matches historical data (IN-SAMPLE).""" ct = [c for c in CALIBRATION_TABLE if c['actual_tau'] is not None] predicted = np.array([c['predicted_tau'] for c in ct]) actual = np.array([c['actual_tau'] for c in ct]) if len(predicted) < 3: return log_result('tech_cycle_duration_formula', np.nan, np.nan, 'SKIPPED', description="Tests Prediction #21: the duration formula tau ~ ln(c0/c*)/alpha " "matches historical technology cycle lengths. IN-SAMPLE only (N=4 calibration " "cycles). Pearson correlation and MAPE between predicted and actual durations. " "Note: this is circular validation — see tech_cycle_out_of_sample for " "independent validation.") corr = np.corrcoef(predicted, actual)[0, 1] mape = np.mean(np.abs(predicted - actual) / actual) * 100 sign_ok = corr > 0.85 and mape < 20 verd = 'CONSISTENT' if sign_ok else 'AMBIGUOUS' _cache['duration_formula'] = { 'predicted': predicted.tolist(), 'actual': actual.tolist(), 'names': [c['technology'] for c in ct], 'corr': corr, 'mape': mape, } return log_result('tech_cycle_duration_formula', corr, np.nan, verd, details={'mape_pct': round(mape, 2), 'n_cycles': len(ct), 'note': 'IN-SAMPLE: formula checked against its own calibration data'}, description="Tests Prediction #21: the duration formula tau ~ ln(c0/c*)/alpha " "matches historical technology cycle lengths. IN-SAMPLE only (N=4 calibration " "cycles). Pearson correlation and MAPE between predicted and actual durations. " "Note: this is circular validation — see tech_cycle_out_of_sample for " "independent validation.") def test_cycle_compression(): """#22: Successive cycles compress as alpha rises (IN-SAMPLE).""" ct = [c for c in CALIBRATION_TABLE if c['actual_tau'] is not None] ct_sorted = sorted(ct, key=lambda x: x['start_year']) alphas = [c['alpha'] for c in ct_sorted] taus = [c['actual_tau'] for c in ct_sorted] if len(alphas) < 3: return log_result('tech_cycle_compression', np.nan, np.nan, 'SKIPPED', description="Tests Prediction #22: successive technology cycles compress as " "the learning rate alpha rises. IN-SAMPLE Spearman rank correlation between " "alpha and actual cycle duration (N=4 calibration cycles).") tau_corr, p = stats.spearmanr(alphas, taus) sign_ok = tau_corr < 0 # higher alpha -> shorter tau verd = verdict(p, sign_ok, threshold=0.10) _cache['compression_in_sample'] = { 'alphas': alphas, 'taus': taus, 'names': [c['technology'] for c in ct_sorted], 'rho_s': tau_corr, 'p': p, } return log_result('tech_cycle_compression', tau_corr, p, verd, details={'n_cycles': len(ct), 'note': 'IN-SAMPLE only'}, description="Tests Prediction #22: successive technology cycles compress as " "the learning rate alpha rises. IN-SAMPLE Spearman rank correlation between " "alpha and actual cycle duration (N=4 calibration cycles).") def test_out_of_sample(): """#22 out-of-sample: Compression holds with independent validation cycles.""" desc = ( "Tests Prediction #22 OUT-OF-SAMPLE: the alpha-tau compression relationship " "holds when adding independently sourced technology cycles (Automobiles d=1, " "Semiconductors d=2) to the paper's calibration data. Spearman rank correlation " "between alpha (= d * alpha_0, where d is geometric dimension) and actual cycle " "duration across N=6 combined cycles. This is the key falsifiability test — " "the out-of-sample cycles were NOT used in calibrating the duration formula." ) # Combine in-sample and out-of-sample all_cycles = [] for c in CALIBRATION_TABLE: if c['actual_tau'] is not None: all_cycles.append(c) for c in OUT_OF_SAMPLE_TABLE: all_cycles.append(c) if len(all_cycles) < 4: return log_result('tech_cycle_out_of_sample', np.nan, np.nan, 'SKIPPED', description=desc) all_sorted = sorted(all_cycles, key=lambda x: x['start_year']) alphas = [c['alpha'] for c in all_sorted] taus = [c['actual_tau'] for c in all_sorted] names = [c['technology'] for c in all_sorted] oos_flags = [c['technology'] in [o['technology'] for o in OUT_OF_SAMPLE_TABLE] for c in all_sorted] tau_corr, p = stats.spearmanr(alphas, taus) sign_ok = tau_corr < 0 verd = verdict(p, sign_ok, threshold=0.10) # Also check if out-of-sample points fit the in-sample trend in_sample = [c for c in CALIBRATION_TABLE if c['actual_tau'] is not None] in_alphas = np.array([c['alpha'] for c in in_sample]) in_taus = np.array([c['actual_tau'] for c in in_sample]) # Fit log-linear: log(tau) = a + b*log(alpha) on in-sample log_a = np.log(in_alphas) log_t = np.log(in_taus) slope, intercept, r, p_fit, se = stats.linregress(log_a, log_t) # Predict out-of-sample oos_predictions = {} for c in OUT_OF_SAMPLE_TABLE: pred_log_tau = intercept + slope * np.log(c['alpha']) pred_tau = np.exp(pred_log_tau) error_pct = abs(pred_tau - c['actual_tau']) / c['actual_tau'] * 100 oos_predictions[c['technology']] = { 'alpha': c['alpha'], 'd': c['d'], 'predicted_tau': round(pred_tau, 1), 'actual_tau': c['actual_tau'], 'error_pct': round(error_pct, 1), } _cache['compression_combined'] = { 'alphas': alphas, 'taus': taus, 'names': names, 'oos_flags': oos_flags, 'rho_s': tau_corr, 'p': p, 'fit_slope': slope, 'fit_intercept': intercept, 'oos_predictions': oos_predictions, } return log_result('tech_cycle_out_of_sample', tau_corr, p, verd, details={ 'n_total': len(all_cycles), 'n_in_sample': len(in_sample), 'n_out_of_sample': len(OUT_OF_SAMPLE_TABLE), 'oos_predictions': oos_predictions, 'fit_log_slope': round(slope, 3), }, description=desc) def _check_fpg_ordering(events_list): """Check F->P->G ordering across cycles. Returns (n_correct, n_total, details).""" cycles_with_all = {} for ev in events_list: cycles_with_all.setdefault(ev['cycle'], []).append(ev) n_correct = 0 n_total = 0 cycle_details = {} for cycle, events in cycles_with_all.items(): events_sorted = sorted(events, key=lambda x: x['year']) types = [e['type'] for e in events_sorted] if len(types) >= 3: n_total += 1 f_idx = types.index('F') if 'F' in types else 999 p_idx = types.index('P') if 'P' in types else 999 g_idx = types.index('G') if 'G' in types else 999 correct = f_idx < p_idx < g_idx if correct: n_correct += 1 cycle_details[cycle] = { 'sequence': '->'.join(types), 'years': [e['year'] for e in events_sorted], 'correct': correct, } return n_correct, n_total, cycle_details def test_crisis_ordering(): """#24: Crisis sequence: financial -> production -> governance.""" desc = ( "Tests Prediction #24: within each technology cycle, crises occur in the " "order Financial -> Production -> Governance. Checks chronological ordering " "of F/P/G events across 6 cycles: 3 in-sample (Railroads, Electrification, " "Internet) and 3 out-of-sample (Automobiles 1929-33, Semiconductors 1984-86, " "Nuclear 1975-83). Nuclear is a governance-arrested counter-example: " "litigation/regulatory escalation (G) preceded and caused the production " "crisis (P), giving F->G->P instead of F->P->G. This shows the test CAN " "produce INCONSISTENT results." ) n_correct, n_total, cycle_details = _check_fpg_ordering(ALL_CRISIS_EVENTS) # Also separate in-sample vs out-of-sample n_is, n_is_tot, _ = _check_fpg_ordering(CRISIS_EVENTS_IN_SAMPLE) n_oos, n_oos_tot, _ = _check_fpg_ordering(CRISIS_EVENTS_OUT_OF_SAMPLE) if n_total == 0: return log_result('tech_cycle_crisis_ordering', np.nan, np.nan, 'SKIPPED', description=desc) frac = n_correct / n_total verd = 'CONSISTENT' if frac >= 0.67 else ('AMBIGUOUS' if frac > 0.33 else 'INCONSISTENT') _cache['crisis_ordering'] = { 'cycle_details': cycle_details, 'n_correct': n_correct, 'n_total': n_total, 'n_in_sample_correct': n_is, 'n_out_of_sample_correct': n_oos, } return log_result('tech_cycle_crisis_ordering', frac, np.nan, verd, details={ 'n_correct': n_correct, 'n_total': n_total, 'in_sample': f'{n_is}/{n_is_tot}', 'out_of_sample': f'{n_oos}/{n_oos_tot}', 'cycle_details': cycle_details, }, description=desc) def test_ai_crossing(): """#26: AI crossing ~2028 from consumer silicon trajectory.""" desc = ( "Tests Prediction #26: consumer silicon cost trajectory predicts AI " "hardware crossing (70B params at 20 tok/s under $1,500) around 2028. " "Loads compiled consumer silicon trajectory with actual devices (2020-2025) " "and projections (2026-2030). Checks whether earliest crossing year is " "near the predicted ~2028. CAVEAT: forward-looking prediction; crossing " "devices are currently projections only (no actual crossing observed yet)." ) try: cs = load_compiled('consumer_silicon_trajectory') except FileNotFoundError: return log_result('tech_cycle_ai_crossing', np.nan, np.nan, 'SKIPPED', details={'reason': 'consumer_silicon_trajectory not found'}, description=desc) if 'year' not in cs.columns: return log_result('tech_cycle_ai_crossing', np.nan, np.nan, 'SKIPPED', description=desc) _cache['consumer_silicon'] = cs # Separate actual vs projected devices is_proj = ( cs['source'].str.contains('proj|Projected', case=False, na=False) | cs['chipset'].str.contains(r'$proj$', case=False, na=False) ) actual_devices = cs[~is_proj] projected_devices = cs[is_proj] # Check crossing condition if 'meets_crossing_condition' in cs.columns: crossing = cs[cs['meets_crossing_condition'] == True] else: crossing = pd.DataFrame() n_actual = len(actual_devices) n_projected = len(projected_devices) n_crossing = len(crossing) if n_crossing > 0: earliest_crossing = int(crossing['year'].min()) crossing_proj = ( crossing['source'].str.contains('proj|Projected', case=False, na=False) | crossing['chipset'].str.contains(r'$proj$', case=False, na=False) ) n_crossing_actual = int((~crossing_proj).sum()) n_crossing_projected = int(crossing_proj.sum()) else: earliest_crossing = None n_crossing_actual = 0 n_crossing_projected = 0 # Fit log-linear trend on params_per_dollar for actual devices trend_info = {} if 'params_per_dollar' in cs.columns and n_actual >= 3: act = actual_devices.dropna(subset=['params_per_dollar']) if len(act) >= 3: log_ppd = np.log10(act['params_per_dollar'].values) years = act['year'].values slope, intercept, r, p, se = stats.linregress(years, log_ppd) trend_info = { 'trend_slope_log10': round(slope, 4), 'trend_r2': round(r ** 2, 4), 'trend_n_actual': len(act), 'doubling_time_years': round(np.log10(2) / slope, 1) if slope > 0 else None, } # Verdict: forward-looking prediction — AMBIGUOUS is the ceiling if earliest_crossing is not None: gap = abs(earliest_crossing - 2028) if n_crossing_actual > 0 and gap <= 3: verd = 'CONSISTENT' else: verd = 'AMBIGUOUS' stat = earliest_crossing else: verd = 'AMBIGUOUS' stat = cs['year'].max() details = { 'predicted_crossing': '~2028', 'earliest_crossing_year': earliest_crossing, 'n_actual_devices': n_actual, 'n_projected_devices': n_projected, 'n_crossing_total': n_crossing, 'n_crossing_actual': n_crossing_actual, 'n_crossing_projected': n_crossing_projected, 'latest_data_year': int(cs['year'].max()), } details.update(trend_info) return log_result('tech_cycle_ai_crossing', stat, np.nan, verd, details=details, description=desc) def test_geometric_dimension(): """#25: Learning rates cluster by geometric dimension: d=1 -> alpha~0.12, d=2 -> alpha~0.24.""" desc = ( "Tests the geometric dimension prediction: alpha = d * alpha_0 where d is " "the geometric dimension (d=1 for linear/assembly processes, d=2 for planar/ " "lithographic processes) and alpha_0 ~ 0.12. Classifies each product from " "learning curve literature by its manufacturing process (e.g., DRAM/Solar PV " "-> d=2 planar; Ford Model T/wind turbines -> d=1 assembly). Tests: (1) d=2 " "cluster mean is significantly higher than d=1 cluster mean (one-sided " "Mann-Whitney); (2) ratio of cluster means is near 2.0; (3) each cluster " "mean is near its predicted value (d*0.12). Outliers with alpha > 0.60 " "excluded (biased aggregate OLS estimates)." ) try: lc = load_compiled('learning_curve_literature') except FileNotFoundError: return log_result('tech_cycle_geometric_dimension', np.nan, np.nan, 'SKIPPED', description=desc) if 'alpha' not in lc.columns or 'industry' not in lc.columns: return log_result('tech_cycle_geometric_dimension', np.nan, np.nan, 'SKIPPED', description=desc) # Classify by geometric dimension (per-product, not per-industry) lc = lc.copy() lc['d'] = lc['product'].map(GEOMETRIC_DIM_BY_PRODUCT) lc = lc.dropna(subset=['d', 'alpha']) # Exclude extreme outliers (aggregate OLS estimates with known bias) # DRAM aggregate OLS alpha=0.77 and DRAM middle subsample alpha=0.85 # are known to be biased by confounding time trend with experience lc = lc[lc['alpha'] < 0.60] d1 = lc[lc['d'] == 1]['alpha'].values d2 = lc[lc['d'] == 2]['alpha'].values if len(d1) < 3 or len(d2) < 3: return log_result('tech_cycle_geometric_dimension', np.nan, np.nan, 'SKIPPED', details={'n_d1': len(d1), 'n_d2': len(d2)}, description=desc) mean_d1 = np.mean(d1) mean_d2 = np.mean(d2) ratio = mean_d2 / mean_d1 if mean_d1 > 0 else np.nan # Mann-Whitney test: d=2 > d=1 (one-sided) u_stat, p_two = stats.mannwhitneyu(d2, d1, alternative='greater') p_val = p_two # already one-sided from alternative='greater' # Check predictions: # 1. d=2 mean significantly > d=1 mean sign_ok = mean_d2 > mean_d1 # 2. Ratio near 2.0 (within [1.3, 3.0]) ratio_ok = 1.3 <= ratio <= 3.0 # 3. d=1 mean near 0.12 (within [0.08, 0.22]) d1_ok = 0.08 <= mean_d1 <= 0.22 # 4. d=2 mean near 0.24 (within [0.15, 0.35]) d2_ok = 0.15 <= mean_d2 <= 0.35 all_ok = sign_ok and ratio_ok and d1_ok and d2_ok verd = verdict(p_val, all_ok, threshold=0.10) _cache['geometric_dimension'] = { 'd1_alphas': d1.tolist(), 'd2_alphas': d2.tolist(), 'mean_d1': mean_d1, 'mean_d2': mean_d2, 'd1_products': lc[lc['d'] == 1][['industry', 'product', 'alpha']].to_dict('records'), 'd2_products': lc[lc['d'] == 2][['industry', 'product', 'alpha']].to_dict('records'), } # Cache learning curve data for figures _cache['learning_curve'] = lc return log_result('tech_cycle_geometric_dimension', ratio, p_val, verd, details={ 'n_d1': len(d1), 'mean_d1': round(mean_d1, 3), 'std_d1': round(np.std(d1), 3), 'predicted_d1': 0.12, 'n_d2': len(d2), 'mean_d2': round(mean_d2, 3), 'std_d2': round(np.std(d2), 3), 'predicted_d2': 0.24, 'ratio_d2_d1': round(ratio, 2), 'predicted_ratio': 2.0, 'mann_whitney_U': float(u_stat), }, description=desc) _cache = {} def main(): results = [] results.append(test_duration_formula()) results.append(test_cycle_compression()) results.append(test_out_of_sample()) results.append(test_crisis_ordering()) results.append(test_ai_crossing()) results.append(test_geometric_dimension()) _cache['results'] = results return results def figures(): """Generate per-subtest figures for tech cycle predictions.""" if not _cache: main() paths = [] # --- Figure 1: Duration formula — predicted vs actual (IN-SAMPLE) --- data = _cache.get('duration_formula') if data: fig, ax = setup_figure(width=8, height=6) predicted = data['predicted'] actual = data['actual'] names = data['names'] ax.scatter(predicted, actual, s=80, c='steelblue', edgecolors='black', zorder=5) for i, name in enumerate(names): ax.annotate(name, (predicted[i], actual[i]), textcoords='offset points', xytext=(5, 5), fontsize=9) lims = [min(min(predicted), min(actual)) - 5, max(max(predicted), max(actual)) + 5] ax.plot(lims, lims, 'k--', alpha=0.3, label='45-degree line') ax.set_xlabel('Predicted Duration (years)') ax.set_ylabel('Actual Duration (years)') ax.set_title('Duration Formula: Predicted vs Actual (IN-SAMPLE, N=4)') ax.legend() ax.annotate(f'r = {data["corr"]:.3f}, MAPE = {data["mape"]:.1f}%', xy=(0.05, 0.95), xycoords='axes fraction', fontsize=10, va='top') paths += save_figure(fig, 'tech_cycle_duration_formula', subfolder='applications') # --- Figure 2: Cycle compression — alpha vs duration (IN-SAMPLE) --- data = _cache.get('compression_in_sample') if data: fig, ax = setup_figure(width=8, height=5) ax.scatter(data['alphas'], data['taus'], s=80, c='steelblue', edgecolors='black', zorder=5) for i, name in enumerate(data['names']): ax.annotate(name, (data['alphas'][i], data['taus'][i]), textcoords='offset points', xytext=(5, 5), fontsize=9) ax.set_xlabel(r'Learning Rate ($\alpha = d \cdot \alpha_0$)') ax.set_ylabel('Cycle Duration (years)') ax.set_title('Cycle Compression: IN-SAMPLE (N=4)') ax.annotate(f'Spearman rho = {data["rho_s"]:.3f}, p = {data["p"]:.3f}', xy=(0.05, 0.95), xycoords='axes fraction', fontsize=10, va='top') paths += save_figure(fig, 'tech_cycle_compression', subfolder='applications') # --- Figure 3: Out-of-sample compression — combined alpha vs duration --- data = _cache.get('compression_combined') if data: fig, ax = setup_figure(width=9, height=6) alphas = data['alphas'] taus = data['taus'] names = data['names'] oos = data['oos_flags'] # Plot in-sample and out-of-sample with different markers for i, name in enumerate(names): if oos[i]: ax.scatter(alphas[i], taus[i], s=120, c='#e74c3c', edgecolors='black', zorder=6, marker='D') else: ax.scatter(alphas[i], taus[i], s=80, c='steelblue', edgecolors='black', zorder=5) ax.annotate(name, (alphas[i], taus[i]), textcoords='offset points', xytext=(5, 5), fontsize=9) # Fit line through all points log_a = np.log(np.array(alphas)) log_t = np.log(np.array(taus)) slope, intercept, _, _, _ = stats.linregress(log_a, log_t) a_range = np.linspace(min(alphas) * 0.9, max(alphas) * 1.1, 50) t_fit = np.exp(intercept + slope * np.log(a_range)) ax.plot(a_range, t_fit, 'k--', alpha=0.4, label=f'Power law fit (slope={slope:.2f})') ax.scatter([], [], s=80, c='steelblue', edgecolors='black', label='In-sample (N=4)') ax.scatter([], [], s=120, c='#e74c3c', edgecolors='black', marker='D', label='Out-of-sample (N=2)') ax.set_xlabel(r'Learning Rate ($\alpha = d \cdot \alpha_0$)') ax.set_ylabel('Cycle Duration (years)') ax.set_title(f'Cycle Compression: Combined (N={len(alphas)})') ax.annotate(f'Spearman rho = {data["rho_s"]:.3f}, p = {data["p"]:.3f}', xy=(0.05, 0.95), xycoords='axes fraction', fontsize=10, va='top') ax.legend(fontsize=9) paths += save_figure(fig, 'tech_cycle_out_of_sample', subfolder='applications') # --- Figure 4: Crisis sequence ordering --- fig, ax = setup_figure(width=12, height=5) type_colors = {'F': '#d62728', 'P': '#ff7f0e', 'G': '#2ca02c'} type_labels = {'F': 'Financial', 'P': 'Production', 'G': 'Governance'} cycles = {} for ev in ALL_CRISIS_EVENTS: cycles.setdefault(ev['cycle'], []).append(ev) oos_cycles = set(ev['cycle'] for ev in CRISIS_EVENTS_OUT_OF_SAMPLE) for i, (cycle, events) in enumerate(cycles.items()): label_suffix = ' (OOS)' if cycle in oos_cycles else '' for ev in events: ax.scatter(ev['year'], i, c=type_colors.get(ev['type'], 'gray'), s=100, edgecolors='black', linewidth=0.5, zorder=5) ax.annotate(ev['event'], (ev['year'], i), textcoords='offset points', xytext=(5, 8), fontsize=7, rotation=15) ax.set_yticks(range(len(cycles))) ax.set_yticklabels([f'{c} (OOS)' if c in oos_cycles else c for c in cycles.keys()]) ax.set_xlabel('Year') n_corr = _cache.get('crisis_ordering', {}).get('n_correct', '?') n_tot = _cache.get('crisis_ordering', {}).get('n_total', '?') ax.set_title(f'Crisis Sequence: F -> P -> G ({n_corr}/{n_tot} cycles correct)') for t, c in type_colors.items(): ax.scatter([], [], c=c, s=60, label=type_labels[t], edgecolors='black') ax.legend(fontsize=9) paths += save_figure(fig, 'tech_cycle_crisis_ordering', subfolder='applications') # --- Figure 5: AI crossing — consumer silicon trajectory --- cs = _cache.get('consumer_silicon') if cs is not None and 'params_per_dollar' in cs.columns: fig, ax = setup_figure(width=10, height=6) is_proj = ( cs['source'].str.contains('proj|Projected', case=False, na=False) | cs['chipset'].str.contains(r'$proj$', case=False, na=False) ) actual = cs[~is_proj] projected = cs[is_proj] if len(actual) > 0: ax.scatter(actual['year'], actual['params_per_dollar'] / 1e6, s=60, c='steelblue', edgecolors='black', zorder=5, label='Actual devices') if len(projected) > 0: ax.scatter(projected['year'], projected['params_per_dollar'] / 1e6, s=60, c='orange', edgecolors='black', zorder=5, marker='D', label='Projected devices') if 'meets_crossing_condition' in cs.columns: crossing = cs[cs['meets_crossing_condition'] == True] if len(crossing) > 0: ax.scatter(crossing['year'], crossing['params_per_dollar'] / 1e6, s=120, facecolors='none', edgecolors='red', linewidths=2, zorder=6, label='Meets crossing condition') ax.axvline(2028, color='red', linestyle='--', alpha=0.5, label='Predicted crossing (~2028)') ax.set_xlabel('Year') ax.set_ylabel('Params per Dollar (millions)') ax.set_yscale('log') ax.set_title('Consumer Silicon: AI Capability Trajectory') ax.legend(fontsize=8) paths += save_figure(fig, 'tech_cycle_ai_crossing', subfolder='applications') # --- Figure 6: Geometric dimension clustering --- data = _cache.get('geometric_dimension') if data: fig, ax = setup_figure(width=9, height=5) d1 = data['d1_alphas'] d2 = data['d2_alphas'] # Strip plot with jitter np.random.seed(42) jitter1 = 1 + np.random.uniform(-0.15, 0.15, len(d1)) jitter2 = 2 + np.random.uniform(-0.15, 0.15, len(d2)) ax.scatter(jitter1, d1, s=60, c='steelblue', edgecolors='black', alpha=0.7, zorder=5) ax.scatter(jitter2, d2, s=60, c='#e74c3c', edgecolors='black', alpha=0.7, zorder=5) # Means with error bars ax.errorbar(1, data['mean_d1'], yerr=np.std(d1), fmt='D', color='black', markersize=10, capsize=5, zorder=6, label=f'd=1 mean={data["mean_d1"]:.3f}') ax.errorbar(2, data['mean_d2'], yerr=np.std(d2), fmt='D', color='black', markersize=10, capsize=5, zorder=6, label=f'd=2 mean={data["mean_d2"]:.3f}') # Predicted values ax.axhline(0.12, color='steelblue', linestyle='--', alpha=0.5, label=r'Predicted $d=1$: $\alpha_0=0.12$') ax.axhline(0.24, color='#e74c3c', linestyle='--', alpha=0.5, label=r'Predicted $d=2$: $2\alpha_0=0.24$') ax.set_xticks([1, 2]) ax.set_xticklabels(['d=1\n(Assembly/Chemical)', 'd=2\n(Planar/Lithographic)']) ax.set_ylabel(r'Learning Rate ($\alpha$)') ratio = data['mean_d2'] / data['mean_d1'] if data['mean_d1'] > 0 else 0 ax.set_title(f'Geometric Dimension Clustering: ratio={ratio:.2f} (predicted 2.0)') ax.legend(fontsize=8, loc='upper left') paths += save_figure(fig, 'tech_cycle_geometric_dimension', subfolder='applications') return paths if __name__ == '__main__': results = main() for r in results: print(f"{r['name']}: {r['verdict']} " f"(stat={r['statistic']}, p={r['p_value']})")

Tech Cycle Ai Crossing

Description

Figures

Statistics

Script

▸ Source Code

Reproduction Steps