NOT RUN - AND LEFT BEHIND *'FRCMPID_R8_INDEPENDENT_COMPLEX_TRANSPORT_V2_1_FINAL'

Published on 11/9/26 9:03 PM Πβ ≡ Πγ ≡ Πᴰ ≡ Π ≡ (今) ≡ ∀ ---> [ Derived Readings ] ---> [ G(Π) ≡ Θ_FR(Π) ] ---> [ det(G) → 0⁺ ] ---> [ L(Π) ≡ Π ] FRCMΠD — R8 Origin-of-5 · Numbered Cell Copy Guide Read-only saved-data analysis. Upload R8_ORIGIN_OF_FIVE_INPUTS.zip to /content. CELL 01 — MARKDOWN — TITLE, PURPOSE & PERMISSIONS ```markdown ### CELL 01 — MARKDOWN — TITLE, PURPOSE & PERMISSIONS # FRCMΠD — R8 Origin-of-5 Scaling Inquiry · v1.0 **Status:** Read-only examination of the **saved** R8 v2.1 results; no new R8 recurrence and no physical interpretation. **Research principle:** **The math proves the math, not reality.** Mathematical proof applies only to valid derivations from stated assumptions. Numerical checks are classified separately. **Question:** Does the frozen 2×2 recurrence explain the approximately fivefold growth of the *logarithmic magnitudes* seen along its saved trajectory? This notebook independently evaluates saved algebraic relationships, exact-vs-approximate read-only transition diagnostics, the proposed scaling matrix, and finite-trajectory ratios. It **does not** evolve `G`, `b`, or `P`, change initial conditions, or establish infinite-index limits. **Ordering:** Run the numbered CODE cells sequentially. MARKDOWN cells are explanatory. Each CODE cell has its own copy box in the accompanying HTML guide. ``` CELL 02 — MARKDOWN — REQUIRED INPUTS & ONE-ZIP OPTION ```markdown ### CELL 02 — MARKDOWN — REQUIRED INPUTS & ONE-ZIP OPTION **The notebook deliberately does not contain fabricated/hardcoded R8 observations.** It needs the original saved files: - `results.json` — saved scalar observations and frozen run metadata. - `per_index_full_states.jsonl` — saved reduced states, including `Q = Z + iW`. **Simplest Colab setup:** Upload the supplied `R8_ORIGIN_OF_FIVE_INPUTS.zip` using Colab's Files-panel upload button. **Do not extract it**; the notebook reads both members directly. Alternatively upload both JSON files individually into `/content`. The code also works locally when run beside those files. A ZIP without both named members is rejected. Both input files are checked against pinned SHA-256 byte hashes. Upload errors are reported explicitly, not bypassed. **Input scope:** 12 precision tracks; 14 reduced-state records per track (initial `n=-1` plus post-update `n=0..12`), totaling 168 saved states. The read-only analysis focuses on the selected `16000`-dps track. ``` CELL 03 — CODE — IMPORTS, PRECISION & PINNED IDENTITIES ```python # CELL 03 — CODE — IMPORTS, PRECISION & PINNED IDENTITIES from pathlib import Path from collections import Counter import hashlib import io import json import sys import zipfile import csv import math import mpmath as mp # mpmath must be allowed to parse the 16,000-digit saved decimal strings. # This does not increase arithmetic precision or execute the recurrence. if hasattr(sys, 'set_int_max_str_digits'): sys.set_int_max_str_digits(0) ANALYSIS_DPS = 120 # Analysis precision; not the 16,000-dps saved-run precision. mp.mp.dps = ANALYSIS_DPS SELECTED_DPS = 16000 EXPECTED_RUN_ID = '20261109T031335059891Z' EXPECTED_VERSION = 'FRCMPID_R8_INDEPENDENT_COMPLEX_TRANSPORT_V2_1_FINAL' EXPECTED_TRACKS = [480,640,960,1280,1600,2400,3200,4800,6400,9600,12000,16000] EXPECTED_HASHES = { 'results.json': 'be9c4a2e8ab874cfeb9113127115e6157f9efb4a28120ef1d813d62e9e7af2e0', 'per_index_full_states.jsonl': 'b8e665ab085efea6ce5552285f91e3b55e0eed912681c325310cf49175625a34', } ZIP_NAME = 'R8_ORIGIN_OF_FIVE_INPUTS.zip' BASE = Path('/content') if Path('/content').is_dir() else Path.cwd() print('Read-only analysis. No R8 recurrence functions are defined or called.') print('Analysis decimal precision:', ANALYSIS_DPS, '| selected saved track:', SELECTED_DPS) print('Looking for inputs in:', BASE) ``` CELL 04 — CODE — READ BOTH FILES, VERIFY HASHES & PIN RUN ```python # CELL 04 — CODE — READ BOTH FILES, VERIFY HASHES & PIN RUN individual_paths = {name: BASE/name for name in EXPECTED_HASHES} zip_path = BASE/ZIP_NAME if all(path.is_file() for path in individual_paths.values()): source_mode = 'TWO_ORIGINAL_FILES' source_bytes = {name: path.read_bytes() for name,path in individual_paths.items()} elif zip_path.is_file(): source_mode = 'ORIGINAL_FILES_INSIDE_ZIP' with zipfile.ZipFile(zip_path, 'r') as zf: bad = zf.testzip() if bad is not None: raise ValueError('ZIP integrity failure in member: ' + bad) missing = set(EXPECTED_HASHES) - set(zf.namelist()) if missing: raise FileNotFoundError('ZIP missing members: ' + ', '.join(sorted(missing))) source_bytes = {name: zf.read(name) for name in EXPECTED_HASHES} else: raise FileNotFoundError( 'Saved R8 inputs not found. In Colab, upload '+ZIP_NAME+ ' (unextracted) to /content using the Files icon, OR upload both '+ 'results.json and per_index_full_states.jsonl to /content. No analysis executed.') observed_hashes = {name: hashlib.sha256(data).hexdigest() for name,data in source_bytes.items()} for name, expected in EXPECTED_HASHES.items(): if observed_hashes[name] != expected: raise ValueError('PINNED INPUT HASH MISMATCH: '+name+' | observed='+observed_hashes[name]) saved = json.loads(source_bytes['results.json'].decode('utf-8')) if not isinstance(saved, dict): raise ValueError('results.json must contain an object.') if saved.get('run_id') != EXPECTED_RUN_ID or saved.get('version') != EXPECTED_VERSION: raise ValueError('Pinned run identity/version mismatch; no substitution is permitted.') if saved.get('attempted_indices') != [0,12]: raise ValueError('Saved attempted range differs from [0,12].') if sorted(saved.get('precision_tracks', [])) != EXPECTED_TRACKS: raise ValueError('Unexpected precision track inventory.') if saved.get('status') != 'COMPUTED_EXPLORATORY_UNCERTIFIED': raise ValueError('Unexpected run status: '+repr(saved.get('status'))) print('INPUTS VERIFIED:', source_mode) for name, value in observed_hashes.items(): print(' SHA-256', name, value) print('RUN ID:', saved['run_id']) print('RUN STATUS:', saved['status']) ``` CELL 05 — MARKDOWN — SAVED STATE INDEXING & DEFINITIONS ```markdown ### CELL 05 — MARKDOWN — SAVED STATE INDEXING & DEFINITIONS **No index ambiguity:** A saved `state_kind='INITIAL', n=-1` is the state **before update 0**. A `POST_UPDATE, n=k` is the state **after update k**. Thus transition `n` maps saved state `n-1` to saved state `n`. The saved reduced representation contains \[ T=\operatorname{tr}G,\qquad d=\det G,\qquad Q=Z+iW, \] with **exact definition** \[ Z=(GP-P^{\mathsf T}G)_{01}. \] `Q.real` is the saved **Z**, not a square-root approximation reconstructed from the rounded `a` and determinant summaries. This avoids the circular test in the DeepSeek v0.3 draft and preserves sign. The selected data are still **saved outputs of one computation**. Reading them is not an independent replay or physical verification. ``` CELL 06 — CODE — PARSE 168 STATES AND AUDIT ALL LEDGER SLOTS ```python # CELL 06 — CODE — PARSE 168 STATES AND AUDIT ALL LEDGER SLOTS ledger = [] errors = [] for line_no, line in enumerate(source_bytes['per_index_full_states.jsonl'].decode('utf-8').splitlines(), 1): if not line.strip(): continue try: row = json.loads(line) track, index, kind = int(row['dps']), int(row['n']), row['state_kind'] state = row['state'] if not isinstance(state, dict) or any(key not in state for key in ('T','d','Q','direction','A','C','p','dps')): raise ValueError('state missing a required reduced-state field') if not (isinstance(state['Q'],list) and len(state['Q'])==2 and isinstance(state['direction'],list) and len(state['direction'])==2 and isinstance(state['C'],list) and len(state['C'])==4): raise ValueError('invalid Q/direction/C shape') if (index == -1 and kind != 'INITIAL') or (index >= 0 and kind != 'POST_UPDATE'): raise ValueError('state_kind and n disagree') if int(state['dps']) != track: raise ValueError('inner/outer precision mismatch') ledger.append(row) except Exception as exc: errors.append('line %d: %s'%(line_no, exc)) if errors: raise ValueError('Ledger parse/schema error(s): '+repr(errors[:5])) counts = Counter((int(row['dps']), int(row['n'])) for row in ledger) required_slots = {(track, n) for track in EXPECTED_TRACKS for n in range(-1,13)} missing, excess = required_slots-set(counts), set(counts)-required_slots duplicates = [(slot,count) for slot,count in counts.items() if count != 1] if missing or excess or duplicates or len(ledger)!=168: raise ValueError('Ledger incomplete or duplicated. Missing=%s; excess=%s; duplicates=%s; rows=%d'% (len(missing),len(excess),len(duplicates),len(ledger))) raw = saved.get('raw_observations') if not isinstance(raw,list) or len(raw)!=156: raise ValueError('Expected 156 saved transition summaries; found '+str(type(raw))) raw_counts=Counter((int(r['dps']),int(r['n'])) for r in raw) if set(raw_counts)!={(p,n) for p in EXPECTED_TRACKS for n in range(13)} or any(v!=1 for v in raw_counts.values()): raise ValueError('Raw observation index mismatch.') raw_by_n = {int(r['n']): r for r in raw if int(r['dps']) == SELECTED_DPS} state_by_n = {int(r['n']):r['state'] for r in ledger if int(r['dps']) == SELECTED_DPS} assert sorted(state_by_n)==list(range(-1,13)) print('PASS: 168 unique saved states, 156 unique saved transition summaries.') print('Selected transition sequence: INITIAL(-1) -> POST(0) -> ... -> POST(12)') ``` CELL 07 — MARKDOWN — FROZEN 2×2 R8 ALGEBRA ```markdown ### CELL 07 — MARKDOWN — FROZEN 2×2 R8 ALGEBRA For the **saved reduced-state representation** (the 2×2 frozen R8 equations), let \[ G=\begin{pmatrix}g&h\\h&k\end{pmatrix},\quad T=g+k=3.5,\quad r^2=T^2/4-d,\quad C=b+P. \] The saved direction stores \((x+ih)/r\), where \(g=T/2+x\), \(k=T/2-x\). \[ F=h(C_{00}-C_{11})-gC_{01}+kC_{10},\quad w=Z/d,\quad a=w(F+2Z). \] \[ \rho=\frac{2|w|r}{\sqrt d},\quad v=|\tau a|\rho,\quad q=\frac{\tau a}{1+v},\quad\omega=2qw. \] With frozen \(\mu=0.5\), two **exact reduced recurrence identities** are \[ Z_{n+1}=(1+2\mu a_n)Z_n-\omega_n W_n \] and \[ \frac{d_{n+1}}{d_n}=\frac{1+2v_n}{(1+v_n)^2}. \] The notebook **checks these identities against the saved states**; it never computes a successor state to continue the recurrence. A positive determinant with positive fixed trace is the 2×2 SPD criterion when the matrix is symmetric. ``` CELL 08 — CODE — EVALUATE EXACT REDUCED-STATE DIAGNOSTICS ```python # CELL 08 — CODE — EVALUATE EXACT REDUCED-STATE DIAGNOSTICS fi = saved['frozen_decimal_inputs'] if fi != { 'G': [['2','0.5'],['0.5','1.5']], 'P': [['2','0.5'],['-0.5','1']], 'b': [['1.5','0.4'],['-0.3','0.8']], 'lambda':'0.5','mu':'0.5','tau':'0.1'}: raise ValueError('Frozen initial entries or coefficients do not match the selected run.') TAU = mp.mpf(fi['tau']); MU = mp.mpf(fi['mu']) T_EXPECTED=mp.mpf('3.5') def read_reduced(s): T=mp.mpf(s['T']); d=mp.mpf(s['d']) z,w=(mp.mpf(v) for v in s['Q']) e_re,e_im=(mp.mpf(v) for v in s['direction']) C=tuple(mp.mpf(v) for v in s['C']) p=mp.mpf(s['p']) if not (mp.isfinite(T) and mp.isfinite(d) and T>0 and 0mp.mpf('1e-80'): raise ValueError('A saved-state invariant/direction error exceeds audit tolerance.') print('PASS: all 14 selected states satisfy pinned T, p, C and unit-direction checks.') print('Max selected-state invariant/direction residual:',mp.nstr(max_invariant_error,6)) checks=[] for t in transitions: n=t['n']; row=raw_by_n[n] p=t['pre']; post=t['post'] trace_error=abs(p['T']-T_EXPECTED) c_error=max(abs(p['C'][i]-mp.mpf(['3.5','0.9','-0.8','1.8'][i])) for i in range(4)) direction_error=abs(p['er']**2+p['ei']**2-1) checks.append(dict(n=n, a_summary_rel=relative_difference(t['a'],mp.mpf(row['a'])), rho_summary_rel=relative_difference(t['rho'],mp.mpf(row['rho'])), exact_z_rel=relative_difference(t['Zexact'],post['Z']), exact_d_rel=relative_difference(t['dexact'],post['d']), det_summary_rel=relative_difference(post['d'],mp.mpf(row['d_next'])), trace_error=trace_error, c_error=c_error, direction_error=direction_error, determinant_positive=(p['d']>0 and post['d']>0))) print('Read-only consistency checks, selected 16,000-dps saved track') print('Analysis precision:',ANALYSIS_DPS,'dps. Values below this precision may print as zero.') print('n rel(a vs saved) rel(rho vs saved) rel(Z-update) rel(d-update)') for c in checks: print('%02d %-17s %-18s %-17s %-17s'% ( c['n'],mp.nstr(c['a_summary_rel'],5),mp.nstr(c['rho_summary_rel'],5), mp.nstr(c['exact_z_rel'],5),mp.nstr(c['exact_d_rel'],5))) if not all(c['determinant_positive'] for c in checks): raise ValueError('Saved determinant violated SPD-domain positivity.') if any(c['exact_z_rel']>mp.mpf('1e-80') or c['exact_d_rel']>mp.mpf('1e-80') or c['a_summary_rel']>mp.mpf('1e-60') for c in checks): raise ValueError('Saved transition algebra disagrees with pinned data beyond diagnostic tolerance.') print('PASS: saved summaries and exact reduced identities consistent at declared analysis precision.') ``` CELL 10 — MARKDOWN — LEADING-ORDER HYPOTHESES AND APPROXIMATION DOMAIN ```markdown ### CELL 10 — MARKDOWN — LEADING-ORDER HYPOTHESES AND APPROXIMATION DOMAIN The leading-order candidate is **not** an exact R8 law: \[ Z_{n+1}\ \approx\ \frac{2Z_n^3}{d_n},\qquad d_{n+1}\ \approx\ \frac{d_n^{7/2}}{\tau T|Z_n|^3}. \] To assess it, inspect four conditions on the **saved** states: 1. \(|F_n/(2Z_n)|\ll1\) — the nonleading term in \(a_n\) is small. 2. \(1/|a_n|\ll1\) — the additive \(Z_n\) term is small relative to \(a_nZ_n\). 3. \(|\omega_nW_n/(a_nZ_n)|\ll1\) — the exact correction term is small. 4. \(1/v_n\ll1\) and \(4d_n/T^2\ll1\) — the determinant leading-order reduction is relevant. If any denominator is mathematically zero, the corresponding diagnostic reports `UNDEFINED`, not an artificial numerical zero. To avoid precision-induced fake zero residuals at high indices, later cells calculate **logarithmic correction magnitudes directly** from these terms rather than relying only on subtracting two nearly equal very large numbers. ``` CELL 11 — CODE — COMPONENT-WISE CORRECTION MAGNITUDES ```python # CELL 11 — CODE — COMPONENT-WISE CORRECTION MAGNITUDES def log10abs_or_status(x): return '-infinity (EXACT_ZERO)' if x==0 else mp.nstr(mp.log10(abs(x)),11) dominance=[] print('n log10|F/(2Z)| log10|1/a| log10|omega W/(aZ)| log10(1/v) log10(4d/T²)') for t in transitions: n=t['n'];p=t['pre'];Z=p['Z'];W=p['W'];d=p['d'];T=p['T'];a=t['a'];v=t['v'] f_term=None if Z==0 else t['F']/(2*Z) small_a=None if a==0 else 1/a omega_term=None if a*Z==0 else t['omega']*W/(a*Z) inv_v=None if v==0 else 1/v d_scale=4*d/(T*T) dominance.append(dict(n=n,FhalfZ=f_term,inv_a=small_a, omega_rel=omega_term,inv_v=inv_v,d_scale=d_scale)) items=(f_term,small_a,omega_term,inv_v,d_scale) rendered=[('UNDEFINED' if x is None else log10abs_or_status(x)) for x in items] print('%02d %-18s %-18s %-24s %-16s %s'% (n,*rendered)) print('These are saved-state diagnostics. They do not establish infinite-index trends.') ``` CELL 12 — MARKDOWN — A RESOLVABLE TEST FOR THE Z APPROXIMATION ```markdown ### CELL 12 — MARKDOWN — A RESOLVABLE TEST FOR THE Z APPROXIMATION For the **frozen** \(\mu=\tfrac12\), compare the exact saved update to its leading approximation: \[ \frac{Z_{n+1}}{2Z_n^3/d_n} =1+\underbrace{\frac{F_n}{2Z_n}+\frac{d_n}{2Z_n^2} -\frac{\omega_nW_nd_n}{2Z_n^3}}_{\delta_{Z,n}}. \] This exact **correction-factor identity** holds whenever the denominators exist. The notebook evaluates \(\log_{10}|\delta_{Z,n}|\) directly, even if \(1+\delta_{Z,n}\) rounds to `1` at 120-digit analysis precision. It separately compares that expression with the saved next-state \(Z\). The difference between **algebraic correction size** and **computational resolution** is always kept visible. ``` CELL 13 — CODE — TEST EXACT Z CORRECTION FACTOR ```python # CELL 13 — CODE — TEST EXACT Z CORRECTION FACTOR z_rows=[] print('n log10|delta_Z| sign(Z_next) rel(saved Z vs exact update) sign predicted') for t in transitions: n=t['n']; pre=t['pre']; Z=pre['Z']; d=pre['d'] if Z==0: z_rows.append(dict(n=n,status='UNDEFINED_Z_ZERO')) print('%02d UNDEFINED_Z_ZERO'%n) continue delta=(t['F']/(2*Z) + d/(2*Z*Z) - t['omega']*pre['W']*d/(2*Z**3)) pred_leading=2*Z**3/d post=t['post']['Z'] rel=relative_difference(t['Zexact'],post) z_rows.append(dict(n=n,status='DEFINED',delta_z=delta, log10_abs_delta=mp.ninf if delta==0 else mp.log10(abs(delta)), exact_rel=rel, sign_actual=int(mp.sign(post)), sign_leading=int(mp.sign(pred_leading)))) print('%02d %-17s %-13s %-28s %s'% ( n,log10abs_or_status(delta),int(mp.sign(post)),mp.nstr(rel,5),int(mp.sign(pred_leading)))) print('Interpret log10|delta_Z| as a finite recorded correction size, not an asymptotic theorem.') ``` CELL 14 — MARKDOWN — DETERMINANT APPROXIMATION WITHOUT CANCELLATION ```markdown ### CELL 14 — MARKDOWN — DETERMINANT APPROXIMATION WITHOUT CANCELLATION The **exact** saved determinant identity is \[ d_{n+1}=d_n\frac{1+2v_n}{(1+v_n)^2}. \] The candidate leading approximation is \[ d_{n+1}^{\mathrm{lead}}=\frac{d_n^{7/2}}{\tau T|Z_n|^3}. \] With \(\epsilon_n=F_n/(2Z_n)\), their **exact ratio** (under the frozen conditions, for defined nonzero terms) is \[ \frac{d_{n+1}}{d_{n+1}^{\mathrm{lead}}} =\frac{T}{2r_n}\,\frac{1}{|1+\epsilon_n|} \frac{1+1/(2v_n)}{(1+1/v_n)^2}. \] The next cell uses `mp.log1p` to calculate **log10 of this ratio** without destroying very small differences through premature subtraction. An exact ratio equal to 1 at finite display precision must **not** be reported as a mathematical identity. ``` CELL 15 — CODE — TEST DETERMINANT CORRECTION IN LOG SPACE ```python # CELL 15 — CODE — TEST DETERMINANT CORRECTION IN LOG SPACE d_rows=[] print('n log10(d_exact / d_lead) log10|ln(d_exact / d_lead)| status') for t in transitions: n=t['n'];p=t['pre'];Z=p['Z'];v=t['v'];d=p['d'];T=p['T'] if Z==0 or v==0: d_rows.append(dict(n=n,status='UNDEFINED_ZERO_DENOMINATOR')) print('%02d UNDEFINED_ZERO_DENOMINATOR'%n) continue epsilon=t['F']/(2*Z) # This is the small-correction form of the exact/leading determinant ratio. # mp.log1p avoids rounding 1 + epsilon to 1 when epsilon is extremely tiny. logratio_natural=(-mp.mpf('0.5')*mp.log1p(-4*d/(T*T)) - mp.log(abs(1+epsilon)) + mp.log1p(1/(2*v)) - 2*mp.log1p(1/v)) # For tiny epsilon, mp.log(abs(1+epsilon)) may round to zero at 120 dps; # use mp.log1p(epsilon) instead whenever 1+epsilon is positive. if 1+epsilon>0: logratio_natural=(-mp.mpf('0.5')*mp.log1p(-4*d/(T*T)) - mp.log1p(epsilon) + mp.log1p(1/(2*v)) - 2*mp.log1p(1/v)) log10ratio=logratio_natural/mp.log(10) d_rows.append(dict(n=n,status='DEFINED',log10_ratio=log10ratio, log10_abs_natural=mp.ninf if logratio_natural==0 else mp.log10(abs(logratio_natural)))) print('%02d %-29s %-32s %s'% (n,mp.nstr(log10ratio,10), log10abs_or_status(logratio_natural),'DEFINED')) print('Zeros reported at this stage would reflect 120-dps diagnostic precision, not exact equality.') ``` CELL 16 — MARKDOWN — THE PROPOSED SCALE MATRIX AND ITS DOMAIN ```markdown ### CELL 16 — MARKDOWN — THE PROPOSED SCALE MATRIX AND ITS DOMAIN Let \(X_n=-\log_{10}d_n\), \(Y_n=\log_{10}|Z_n|\). Under the two **leading-order approximations**, \[ \binom{X_{n+1}}{Y_{n+1}} \approx \underbrace{\begin{pmatrix}7/2&3\\1&3\end{pmatrix}}_{M} \binom{X_n}{Y_n} +\binom{\log_{10}(\tau T)}{\log_{10}2}. \] The exact characteristic polynomial of this **hypothesized leading-order** matrix is \[ \det(M-\Lambda I)=\Lambda^2-\tfrac{13}{2}\Lambda+\tfrac{15}{2} =(\Lambda-5)(\Lambda-\tfrac32). \] Therefore its **matrix eigenvalues** are exactly **5** and **1.5**, and the eigenvector for **5** has \(Y/X=1/2\). This proves those identities **for M**, not that every frozen R8 trajectory follows M, or that infinite-index ratios converge. The finite data can check the approximation and its observed implications only. ``` CELL 17 — CODE — VERIFY MATRIX EIGENVALUES & FINITE SAVED RATIOS ```python # CELL 17 — CODE — VERIFY MATRIX EIGENVALUES & FINITE SAVED RATIOS M=((mp.mpf('3.5'),mp.mpf(3)),(mp.mpf(1),mp.mpf(3))) trM=M[0][0]+M[1][1] detM=M[0][0]*M[1][1]-M[0][1]*M[1][0] disc=trM*trM-4*detM roots=sorted(((trM-mp.sqrt(disc))/2,(trM+mp.sqrt(disc))/2)) if roots != [mp.mpf('1.5'),mp.mpf('5')]: raise ValueError('Scaling matrix eigenvalues unexpectedly disagree with exact calculation.') print('EXACT 2×2 MATRIX FACT: eigenvalues =', [mp.nstr(r,8) for r in roots]) print('EXACT DOMINANT EIGENVECTOR RELATION: Y/X = 0.5') scale_rows=[] print('n X_n Y_n X_next/X_n Y_next/Y_n Y_n/X_n') for t in transitions: n=t['n'];p=t['pre'];post=t['post'] if p['Z']==0 or post['Z']==0: scale_rows.append(dict(n=n,status='UNDEFINED_Z_ZERO')) print('%02d UNDEFINED_Z_ZERO'%n) continue X=-mp.log10(p['d']);Y=mp.log10(abs(p['Z'])) Xnext=-mp.log10(post['d']);Ynext=mp.log10(abs(post['Z'])) Xratio=None if X==0 else Xnext/X Yratio=None if Y==0 else Ynext/Y YX=None if X==0 else Y/X scale_rows.append(dict(n=n,status='DEFINED',X=X,Y=Y,X_next=Xnext,Y_next=Ynext, X_growth=Xratio,Y_growth=Yratio,Y_over_X=YX)) def fval(v): return 'UNDEFINED' if v is None else mp.nstr(v,10) print('%02d %-16s %-16s %-15s %-15s %s'%( n,fval(X),fval(Y),fval(Xratio),fval(Yratio),fval(YX))) print('Early ratios can be misleading when X or Y is near zero; focus on finite late-index diagnostics.') ``` CELL 18 — CODE — AFFINE MATRIX RESIDUALS IN LOG SPACE ```python # CELL 18 — CODE — AFFINE MATRIX RESIDUALS IN LOG SPACE affine_rows=[] log_tauT=mp.log10(TAU*T_EXPECTED) log2=mp.log10(2) print('n X_next-M_X-c_X Y_next-M_Y-c_Y normalized residuals') for row in scale_rows: if row['status']!='DEFINED': affine_rows.append(dict(n=row['n'],status='UNDEFINED')) continue X,Y,Xn,Yn=(row[k] for k in ('X','Y','X_next','Y_next')) pred_X=mp.mpf('3.5')*X+3*Y+log_tauT pred_Y=X+3*Y+log2 error_X=Xn-pred_X error_Y=Yn-pred_Y norm_X=abs(error_X)/max(1,abs(Xn)) norm_Y=abs(error_Y)/max(1,abs(Yn)) affine_rows.append(dict(n=row['n'],status='DEFINED', residual_X=error_X,residual_Y=error_Y, normalized_X=norm_X,normalized_Y=norm_Y)) print('%02d %-20s %-20s %-12s %-12s'%( row['n'],mp.nstr(error_X,8),mp.nstr(error_Y,8), mp.nstr(norm_X,5),mp.nstr(norm_Y,5))) print('Residual 0 at analysis resolution does NOT imply exact equality of the full recurrence.') ``` CELL 19 — MARKDOWN — CLAIM BOUNDARIES & CROSS-AUDIT QUESTIONS ```markdown ### CELL 19 — MARKDOWN — CLAIM BOUNDARIES & CROSS-AUDIT QUESTIONS **What is exact (from the specified algebra):** the definitions, the 2×2 reduced identities under their domain conditions, the determinant ratio expression, and the eigenvalues/eigenvectors of the explicitly defined **leading-order** matrix M. **What is observational:** finite saved states n=-1..12, their consistency with the equations at analysis precision, shrinking correction terms in the recorded regime, and late-index ratios near 5 and 1/2. **What is not established:** source-to-execution binding; independent recurrence replay; an infinite-index asymptotic theorem; universal independence from initial conditions; any mapping R8 matrices to G(Π); physical saturation; physical mechanism; ontology. **Independent cross-audit questions:** 1. Are the reduced definitions and the algebraic correction-factor identities correct? 2. Does the saved-state indexing shift every pre-state one slot earlier than the corresponding post-state? 3. Are late residuals being distinguished from 120-digit analysis-resolution zeros? 4. Can dominance of the leading terms be established **for every sufficiently large n**, rather than only the observed finite range? 5. Can any counterexample initial conditions prevent the hypothesized scaling regime? **Do not say** that the 5 is already proven as an asymptotic invariant of the complete recurrence. ``` CELL 20 — CODE — EXPORT OBSERVATIONAL DIAGNOSTICS AND A NEW MANIFEST ```python # CELL 20 — CODE — EXPORT OBSERVATIONAL DIAGNOSTICS AND A NEW MANIFEST # Creates NEW analysis outputs only; does not edit the source files or evolve R8. EXPORT_DIR=BASE/'R8_ORIGIN_OF_FIVE_READ_ONLY_OUTPUTS' EXPORT_DIR.mkdir(parents=True,exist_ok=True) def as_text(value): if value is None: return 'UNDEFINED' if isinstance(value, str): return value if isinstance(value,bool): return str(value) return mp.nstr(value,35) files_written=[] for filename, data in [ ('exact_identity_checks.csv', checks), ('correction_magnitudes.csv', dominance), ('z_correction_factor.csv', z_rows), ('determinant_correction_logspace.csv', d_rows), ('finite_scaling_ratios.csv', scale_rows), ('affine_matrix_residuals.csv', affine_rows)]: out=EXPORT_DIR/filename fields=list(dict.fromkeys(key for item in data for key in item)) with out.open('w',encoding='utf-8',newline='') as stream: writer=csv.DictWriter(stream,fieldnames=fields) writer.writeheader() for item in data: writer.writerow({key: as_text(item.get(key)) for key in fields}) files_written.append(out) manifest={ 'analysis_id':'FRCMPID_R8_ORIGIN_OF_FIVE_READ_ONLY_v1_0', 'analysis_status':'READ_ONLY_SAVED_STATE_ANALYSIS', 'new_recurrence_updates_executed':0, 'selected_saved_precision_track':SELECTED_DPS, 'analysis_arithmetic_dps':ANALYSIS_DPS, 'pinned_run_id':EXPECTED_RUN_ID, 'input_sha256':observed_hashes, 'not_established':['source_to_execution_binding','independent_recurrence_replay', 'infinite_index_limit','universal_initial_condition_scaling', 'physical_interpretation','mapping_to_G_of_Pi'], 'outputs_sha256':{p.name:hashlib.sha256(p.read_bytes()).hexdigest() for p in files_written}, } manifest_path=EXPORT_DIR/'read_only_analysis_manifest.json' manifest_path.write_text(json.dumps(manifest,indent=2)+'\n',encoding='utf-8') print('READ-ONLY ANALYSIS EXPORT CREATED:',EXPORT_DIR) for p in files_written+[manifest_path]: print(' ',p.name) print('Source files unchanged. No new R8 recurrence calculation performed.') ``` CELL 21 — MARKDOWN — EXECUTION RECORD — RESEARCHER FILL-IN ```markdown ### CELL 21 — MARKDOWN — EXECUTION RECORD — RESEARCHER FILL-IN **Execution record (complete after Colab execution):** - Input mode (original files or ZIP): **PENDING** - Pinned SHA-256 checks: **PENDING** - Saved ledger inventory: **PENDING** - Exact R8 reduced identity checks: **PENDING** - Z correction-factor log magnitudes: **PENDING** - Determinant correction-factor log magnitudes: **PENDING** - Late-index ratios and affine residuals: **PENDING** - Output diagnostics and manifest: **PENDING** **Interpretation rule:** Exact algebraic identities, finite numerical confirmations, and conjectured asymptotic statements are separate categories. **Researcher conclusion:** _(Leave blank until inspecting the actual execution outputs.)_ **Governing sentence:** **THE MATH PROVES THE MATH, NOT REALITY.** ```