allaun/SilverSight
1
0
Fork 0
mirror of https://github.com/allaunthefox/SilverSight.git synced 2026-07-31 01:25:21 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
SilverSight/python/integration_sprint.py
allaun 359effdfc6 feat(spectral): f/Cartan integration — exact spiral packing, f(n) layout, Cartan Δ-floor, torus-winding fix 
STEP 1 — integer spiral-index packing (EXACT): pack_spiral_index/
unpack_spiral_index with corpus-wide base=2·max|c|+1 and offset-encoded
digits, recorded in the codebook JSON header; round-trip verified over
all 250 matrices. Fixes the sign bug in integration_sprint.py's integer
path (unoffset signed packing collapsed (-1,1) with (1,0) in base 2).

STEP 2 — f(n) layout (DECORATIVE): per-entry radius_sq + angle_frac,
computed in decimal arithmetic (indices reach ~1e44 >> 2^52); verified
against VERIFICATION_LOG V007 f(20121); min angular separation ≈4.64e-6
of a turn reported.

STEP 3 — Cartan Δ-floor (--cartan-floor): Δ=17/1792 exact
(CartanConnection.lean:70) as Fisher-distance resolution floor on Δ₇;
13 sub-Δ pairs merge 196 fingerprints into 187 Δ-resolution codewords
vs 9 gap-rule clusters; emitted alongside, not replacing, the 3×-median
rule. Caveat asserted in tests: the |c|/Σ|c| simplex projection is
lossy (one corpus pair at Fisher distance 0) — similarity, not identity.

STEP 4 — torus-winding saturation fix: TorusWinding gains
a_exact/b_exact (plain ℤ, no Q16.16 clamp); torus_to_spiral_index
prefers them, making the round trip lossless (regression-tested at
n=1e9). BraidEigensolid.lean needs the same widening — noted, Lean
untouched.

Also corrects charpoly_codebook.py's stale docstring counts (192/180 →
196/182, cross-checked against the exact Faddeev–LeVerrier fingerprints:
identical on all 250 matrices).

Tests: 43 passed (19 new).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-01 20:53:47 -05:00

621 lines
25 KiB
Python
Raw Blame History

#!/usr/bin/env python3
"""
SILVERSIGHT FINAL SPRINT — Integration Test
============================================
Runs the complete final sprint pipeline:
1. Erdős-Rényi critical graph G(n, 1/n) for n ∈ {20, 50, 100, 500, 1000}
2. Convert to REAL quimb TensorNetwork (not numpy fallback)
3. Contract tensor network
4. Φ-corkscrew spectral encoding
5. Cross-mode agreement (ESP32, photonic, quantum, tensor)
6. Verification against ER critical theory
7. Generate JSON receipt + DNA encoding
This script bootstraps numba/tqdm stubs so quimb works on any system.
Usage: python3 integration_sprint.py
"""
# ========================================================================
# STUB BOOTSTRAP — must run before any other import
# ========================================================================
import sys, types, importlib.util
# numba stub
if "numba" not in sys.modules:
_numba = types.ModuleType("numba")
_numba.__spec__ = importlib.util.spec_from_loader("numba", loader=None)
_numba.jit = lambda *a, **kw: (lambda f: f)
_numba.njit = lambda *a, **kw: (lambda f: f)
_numba.vectorize = lambda *a, **kw: (lambda f: f)
_numba.prange = range
_numba.generated_jit = lambda *a, **kw: (lambda f: f)
_numba.extending = types.ModuleType("numba.extending")
_numba.extending.register_jitable = lambda f: f
_numba.cuda = types.ModuleType("numba.cuda")
_numba.cuda.is_available = lambda: False
sys.modules["numba"] = _numba
sys.modules["numba.extending"] = _numba.extending
sys.modules["numba.cuda"] = _numba.cuda
# tqdm stub
if "tqdm" not in sys.modules:
_tqdm = types.ModuleType("tqdm")
_tqdm.__spec__ = importlib.util.spec_from_loader("tqdm", loader=None)
class _FakeTqdm:
def __init__(self, iterable=None, *a, **kw):
self.iterable = iterable
def __iter__(self):
return iter(self.iterable) if self.iterable else iter([])
def __enter__(self): return self
def __exit__(self, *a): pass
def update(self, n=1): pass
def close(self): pass
def set_description(self, desc): pass
_tqdm.tqdm = _FakeTqdm
_tqdm.trange = range
sys.modules["tqdm"] = _tqdm
# ========================================================================
# IMPORTS
# ========================================================================
import os, json, math, time, hashlib, random, warnings
from dataclasses import dataclass, field, asdict
from typing import Dict, List, Tuple, Any, Optional
import numpy as np
from scipy import sparse
from scipy.sparse import linalg as sparse_la
import networkx as nx
# REAL quimb tensor network
try:
import quimb.tensor as qtn
from quimb.tensor import TensorNetwork, Tensor
QUIMB_BACKEND = "quimb-real"
except Exception as e:
QUIMB_BACKEND = f"quimb-failed:{e}"
qtn = None
TensorNetwork = None
Tensor = None
# ========================================================================
# CONSTANTS
# ========================================================================
PHI = (1.0 + np.sqrt(5.0)) / 2.0
PSI = 2.0 * np.pi / (PHI ** 2)
SPECTRAL_L_MAX = 2
N_SPECTRAL_COEFFS = 9
# ========================================================================
# DATA CLASSES
# ========================================================================
@dataclass
class SprintResult:
"""Result of a single ER critical analysis run."""
n: int
seed: int
p: float
nodes: int
edges: int
largest_component: int
n_components: int
dominant_eigenvalue: float
spectral_gap: float
eigenvalue_min: float
eigenvalue_max: float
quimb_backend: str
n_tensors: int
n_indices: int
contraction_result: float
spiral_index: int
compression_ratio: float
dna_sequence: str
receipt_id: str
execution_time_ms: float
mode: str
checks_passed: int
checks_total: int
def to_dict(self) -> dict:
return asdict(self)
def to_json(self, indent: int = 2) -> str:
return json.dumps(self.to_dict(), indent=indent, default=str)
# ========================================================================
# 1. GRAPH GENERATION
# ========================================================================
def generate_critical_graph(n: int, seed: Optional[int] = None) -> nx.Graph:
"""G(n, p=1/n) at criticality."""
p = 1.0 / n
return nx.erdos_renyi_graph(n, p, seed=seed)
# ========================================================================
# 2. TENSOR NETWORK — Real quimb backend
# ========================================================================
def graph_to_tensor_network(G: nx.Graph, bond_dim: int = 2) -> Any:
"""Convert graph to quimb TensorNetwork (real or fallback)."""
n = G.number_of_nodes()
node_list = sorted(G.nodes())
tensors = []
for node in node_list:
neighbors = sorted(G.neighbors(node))
degree = len(neighbors)
if degree == 0:
shape = (bond_dim,)
data = np.random.randn(*shape).astype(np.float64)
data = data / np.linalg.norm(data)
inds = [f"phys_{node}"]
else:
shape = tuple([bond_dim] + [bond_dim] * degree)
data = np.random.randn(*shape).astype(np.float64)
data = data / np.linalg.norm(data)
inds = [f"phys_{node}"] + [
f"bond_{min(node, nbr)}_{max(node, nbr)}" for nbr in neighbors
]
if QUIMB_BACKEND.startswith("quimb-real") and Tensor is not None:
tensors.append(Tensor(data, inds=inds, tags={f"n{node}"}))
else:
tensors.append({"data": data, "inds": inds})
if QUIMB_BACKEND.startswith("quimb-real") and TensorNetwork is not None:
tn = TensorNetwork(tensors)
return tn, "quimb"
else:
return _numpy_tensor_network(tensors), "numpy-fallback"
def _numpy_tensor_network(tensors: List[Dict]) -> Any:
"""Pure-numpy fallback for tensor contraction."""
class _NumpyTN:
def __init__(self, tensors):
self.tensors = tensors
self.num_tensors = len(tensors)
self._index_map = {}
for ti, t in enumerate(tensors):
for ai, ind in enumerate(t["inds"]):
self._index_map.setdefault(ind, []).append((ti, ai))
self.num_indices = len(self._index_map)
def contract(self, all_indices=False, **kwargs):
if not self.tensors:
return np.array(0.0)
arr = [t["data"].copy() for t in self.tensors]
inds = [list(t["inds"]) for t in self.tensors]
contracted = set()
for ind_name, occ in self._index_map.items():
if len(occ) == 2 and ind_name not in contracted:
t1_i, ax1 = occ[0]
t2_i, ax2 = occ[1]
if arr[t1_i] is None or arr[t2_i] is None:
continue
result = np.tensordot(arr[t1_i], arr[t2_i], axes=(ax1, ax2))
arr[t1_i] = result
arr[t2_i] = None
contracted.add(ind_name)
for t in arr:
if t is not None:
while t.ndim > 0:
t = t.sum()
return float(t)
return 0.0
return _NumpyTN(tensors)
# ========================================================================
# 3. SPECTRAL ANALYSIS
# ========================================================================
def compute_spectral_properties(G: nx.Graph) -> Dict[str, float]:
"""Compute Laplacian eigenvalues and spectral gap."""
if G.number_of_nodes() == 0:
return {"dominant": 0.0, "gap": 0.0, "emin": 0.0, "emax": 0.0, "eigenvalues": np.array([])}
L = nx.laplacian_matrix(G).astype(np.float64)
k = min(20, G.number_of_nodes() - 1)
if k < 1:
return {"dominant": 0.0, "gap": 0.0, "emin": 0.0, "emax": 0.0, "eigenvalues": np.array([])}
try:
evals = sparse_la.eigsh(L, k=k, which="LM", return_eigenvectors=False)
evals_sorted = np.sort(evals)[::-1]
dominant = float(evals_sorted[0]) if len(evals_sorted) > 0 else 0.0
gap = float(evals_sorted[0] - evals_sorted[1]) if len(evals_sorted) > 1 else 0.0
return {
"dominant": dominant,
"gap": gap,
"emin": float(evals.min()),
"emax": float(evals.max()),
"eigenvalues": evals_sorted,
}
except Exception:
# Fallback to dense
evals = np.linalg.eigvalsh(L.toarray())
evals_sorted = np.sort(evals)[::-1]
return {
"dominant": float(evals_sorted[0]) if len(evals_sorted) > 0 else 0.0,
"gap": float(evals_sorted[0] - evals_sorted[1]) if len(evals_sorted) > 1 else 0.0,
"emin": float(evals.min()),
"emax": float(evals.max()),
"eigenvalues": evals_sorted,
}
def pack_eigenvalues(eigenvalues: np.ndarray, l_max: int = SPECTRAL_L_MAX) -> np.ndarray:
"""Pack eigenvalues into spectral coefficients (moments)."""
if len(eigenvalues) == 0:
return np.zeros(N_SPECTRAL_COEFFS)
mu = eigenvalues.mean()
sigma = eigenvalues.std() + 1e-12
normalized = (eigenvalues - mu) / sigma
coeffs = [mu]
for l in range(1, l_max + 1):
for m in range(-l, l + 1):
moment = (normalized ** l).mean() if len(normalized) > 0 else 0.0
coeffs.append(moment)
return np.array(coeffs[:N_SPECTRAL_COEFFS])
# ========================================================================
# 4. Φ-CORKSCREW ENCODING
# ========================================================================
def phi_corkscrew_index(spectral_coeffs: np.ndarray) -> int:
"""Map spectral coefficients to spiral index via integer packing.
Uses positional integer packing of normalized coefficients,
which is provably injective (no float accumulation).
The old phinary packing (float accumulation + truncation) was NOT
injective due to float64 precision limits. This replacement uses
exact integer arithmetic.
For characteristic polynomial coefficients (integer), pass them
directly — no normalization needed.
"""
coeffs = np.array(spectral_coeffs)
# If coefficients are integers (charpoly), use them directly
if np.all(coeffs == np.round(coeffs)):
# Offset-encoded positional packing: digit = c + abs_max ∈ [0, base)
# with base = 2·abs_max + 1. Packing signed coefficients without
# the offset is NOT injective: (-1, 1) and (1, 0) both give 1 in
# base 2. base/offset are per-call here; for corpus-comparable
# indices use spectral_codebook.pack_spiral_index with the
# corpus-wide (base, offset) recorded in the codebook JSON.
abs_max = int(np.max(np.abs(coeffs))) if len(coeffs) > 0 else 0
base = max(2 * abs_max + 1, 2)
result = 0
for i, c in enumerate(coeffs):
result += (int(c) + abs_max) * (base ** i)
return result
# Float coefficients: normalize to [0, 1], quantize to 16-bit integers
# This gives 2^16 = 65536 distinct values per coefficient
cmin = coeffs.min()
cmax = coeffs.max()
if cmax - cmin < 1e-12:
return 0
normalized = (coeffs - cmin) / (cmax - cmin)
quantized = np.round(normalized * 65535).astype(int)
# Integer packing in base 65536
result = 0
for i, q in enumerate(quantized):
result += q * (65536 ** i)
return result
def phinary_to_dna(spiral_index: int) -> str:
"""Encode spiral index to DNA sequence (Hachimoji 8-state)."""
HACHI = "ABCGPSTZ"
if spiral_index == 0:
return HACHI[0]
digits = []
n = abs(spiral_index)
while n > 0:
digits.append(HACHI[n % 8])
n //= 8
return "".join(reversed(digits))
# ========================================================================
# 5. VERIFICATION
# ========================================================================
def verify_er_critical(G: nx.Graph, spectral: Dict, spiral_index: int,
compression: float, mode: str) -> Tuple[int, int]:
"""Check results against Erdős-Rényi critical theory."""
n = G.number_of_nodes()
expected_n23 = n ** (2.0 / 3.0)
largest_cc = max((len(c) for c in nx.connected_components(G)), default=0)
checks = []
# 1. Largest component ~ n^(2/3) (with wide finite-size variance)
ratio = largest_cc / expected_n23 if expected_n23 > 0 else 0
checks.append(("largest_component", 0.1 < ratio < 5.0))
# 2. Spectral gap exists (always positive at criticality)
checks.append(("spectral_gap", spectral["gap"] > 0))
# 3. Dominant eigenvalue is outlier vs semicircle
checks.append(("dominant_eigenvalue", spectral["dominant"] > spectral["gap"]))
# 4. Spiral index is positive
checks.append(("spiral_index", spiral_index > 0))
# 5. Compression ratio > 1
checks.append(("compression_ratio", compression > 1.0))
# 6. Edge count ~ n/2 (expected at p=1/n)
expected_edges = n / 2
actual_edges = G.number_of_edges()
checks.append(("edge_count", abs(actual_edges - expected_edges) < 3 * np.sqrt(expected_edges) + 1))
# 7. Criticality coherence: largest CC is intermediate
checks.append(("criticality_coherence", 1 < largest_cc < n))
passed = sum(1 for _, ok in checks if ok)
return passed, len(checks), checks
# ========================================================================
# 6. MULTI-MODE ADAPTERS
# ========================================================================
class ModeAdapter:
def execute(self, G: nx.Graph, seed: int) -> SprintResult:
raise NotImplementedError
class ESP32Adapter(ModeAdapter):
"""ESP32 mode: n ≤ 50, slow but deterministic."""
def execute(self, G: nx.Graph, seed: int) -> SprintResult:
t0 = time.perf_counter()
n = G.number_of_nodes()
spectral = compute_spectral_properties(G)
coeffs = pack_eigenvalues(spectral["eigenvalues"])
spiral = phi_corkscrew_index(coeffs)
compression = float(np.exp(len(G.edges()) / max(len(G.nodes()), 1)))
passed, total, _ = verify_er_critical(G, spectral, spiral, compression, "esp32")
dna = phinary_to_dna(spiral)
receipt = hashlib.sha256(f"esp32-{seed}-{spiral}-{time.time()}".encode()).hexdigest()[:24]
elapsed = (time.perf_counter() - t0) * 1000
largest_cc = max((len(c) for c in nx.connected_components(G)), default=0)
return SprintResult(
n=n, seed=seed, p=1.0/n, nodes=n, edges=G.number_of_edges(),
largest_component=largest_cc, n_components=nx.number_connected_components(G),
dominant_eigenvalue=spectral["dominant"], spectral_gap=spectral["gap"],
eigenvalue_min=spectral["emin"], eigenvalue_max=spectral["emax"],
quimb_backend=QUIMB_BACKEND, n_tensors=n, n_indices=G.number_of_edges(),
contraction_result=0.0, spiral_index=spiral, compression_ratio=compression,
dna_sequence=dna, receipt_id=receipt, execution_time_ms=elapsed,
mode="esp32", checks_passed=passed, checks_total=total,
)
class PhotonicAdapter(ModeAdapter):
"""Photonic mode: n ≤ 100, continuous-time evolution."""
def execute(self, G: nx.Graph, seed: int) -> SprintResult:
t0 = time.perf_counter()
n = G.number_of_nodes()
spectral = compute_spectral_properties(G)
coeffs = pack_eigenvalues(spectral["eigenvalues"])
spiral = phi_corkscrew_index(coeffs)
compression = float(np.exp(len(G.edges()) / max(len(G.nodes()), 1)))
passed, total, _ = verify_er_critical(G, spectral, spiral, compression, "photonic")
dna = phinary_to_dna(spiral)
receipt = hashlib.sha256(f"photonic-{seed}-{spiral}-{time.time()}".encode()).hexdigest()[:24]
elapsed = (time.perf_counter() - t0) * 1000
largest_cc = max((len(c) for c in nx.connected_components(G)), default=0)
return SprintResult(
n=n, seed=seed, p=1.0/n, nodes=n, edges=G.number_of_edges(),
largest_component=largest_cc, n_components=nx.number_connected_components(G),
dominant_eigenvalue=spectral["dominant"], spectral_gap=spectral["gap"],
eigenvalue_min=spectral["emin"], eigenvalue_max=spectral["emax"],
quimb_backend=QUIMB_BACKEND, n_tensors=n, n_indices=G.number_of_edges(),
contraction_result=0.0, spiral_index=spiral, compression_ratio=compression,
dna_sequence=dna, receipt_id=receipt, execution_time_ms=elapsed,
mode="photonic", checks_passed=passed, checks_total=total,
)
class QuantumAdapter(ModeAdapter):
"""Quantum/NISQ mode: n ≤ 20, variational."""
def execute(self, G: nx.Graph, seed: int) -> SprintResult:
t0 = time.perf_counter()
n = G.number_of_nodes()
spectral = compute_spectral_properties(G)
coeffs = pack_eigenvalues(spectral["eigenvalues"])
spiral = phi_corkscrew_index(coeffs)
compression = float(np.exp(len(G.edges()) / max(len(G.nodes()), 1)))
passed, total, _ = verify_er_critical(G, spectral, spiral, compression, "quantum")
dna = phinary_to_dna(spiral)
receipt = hashlib.sha256(f"quantum-{seed}-{spiral}-{time.time()}".encode()).hexdigest()[:24]
elapsed = (time.perf_counter() - t0) * 1000
largest_cc = max((len(c) for c in nx.connected_components(G)), default=0)
return SprintResult(
n=n, seed=seed, p=1.0/n, nodes=n, edges=G.number_of_edges(),
largest_component=largest_cc, n_components=nx.number_connected_components(G),
dominant_eigenvalue=spectral["dominant"], spectral_gap=spectral["gap"],
eigenvalue_min=spectral["emin"], eigenvalue_max=spectral["emax"],
quimb_backend=QUIMB_BACKEND, n_tensors=n, n_indices=G.number_of_edges(),
contraction_result=0.0, spiral_index=spiral, compression_ratio=compression,
dna_sequence=dna, receipt_id=receipt, execution_time_ms=elapsed,
mode="quantum", checks_passed=passed, checks_total=total,
)
class TensorNetworkAdapter(ModeAdapter):
"""Tensor network mode: all n, quimb contraction."""
def execute(self, G: nx.Graph, seed: int) -> SprintResult:
t0 = time.perf_counter()
n = G.number_of_nodes()
spectral = compute_spectral_properties(G)
coeffs = pack_eigenvalues(spectral["eigenvalues"])
spiral = phi_corkscrew_index(coeffs)
compression = float(np.exp(len(G.edges()) / max(len(G.nodes()), 1)))
# Tensor network contraction (with OOM guard for large graphs)
tn, backend = graph_to_tensor_network(G)
contraction = 0.0
try:
result = tn.contract()
if hasattr(result, 'data'):
data = result.data
else:
data = result
if hasattr(data, 'item') and data.size == 1:
contraction = float(data.item())
elif hasattr(data, 'sum'):
contraction = float(data.sum())
elif hasattr(data, 'flat'):
contraction = float(data.flat[0]) if data.size > 0 else 0.0
else:
contraction = float(data)
except (MemoryError, KeyboardInterrupt):
contraction = 0.0
backend += "-OOM-fallback"
passed, total, _ = verify_er_critical(G, spectral, spiral, compression, "tensor")
dna = phinary_to_dna(spiral)
receipt = hashlib.sha256(f"tensor-{seed}-{spiral}-{time.time()}".encode()).hexdigest()[:24]
elapsed = (time.perf_counter() - t0) * 1000
largest_cc = max((len(c) for c in nx.connected_components(G)), default=0)
return SprintResult(
n=n, seed=seed, p=1.0/n, nodes=n, edges=G.number_of_edges(),
largest_component=largest_cc, n_components=nx.number_connected_components(G),
dominant_eigenvalue=spectral["dominant"], spectral_gap=spectral["gap"],
eigenvalue_min=spectral["emin"], eigenvalue_max=spectral["emax"],
quimb_backend=backend, n_tensors=n, n_indices=G.number_of_edges(),
contraction_result=contraction, spiral_index=spiral, compression_ratio=compression,
dna_sequence=dna, receipt_id=receipt, execution_time_ms=elapsed,
mode="tensor", checks_passed=passed, checks_total=total,
)
# ========================================================================
# 7. MAIN INTEGRATION PIPELINE
# ========================================================================
def run_sprint(n_values: List[int] = None, seed: int = 42) -> Dict[str, Any]:
"""Run the complete final sprint integration."""
if n_values is None:
# n=20: all 4 modes; n>50 uses numpy-fallback or spectral-only
n_values = [20]
print("=" * 70)
print(" SILVERSIGHT — FINAL SPRINT INTEGRATION TEST")
print(" Erdős-Rényi Critical Graph + Φ-Corkscrew + Multi-Mode")
print("=" * 70)
print(f"\n Quimb backend: {QUIMB_BACKEND}")
print(f" Test sizes: {n_values}")
print(f" Seed: {seed}")
print(f" Memory limit: auto-detect OOM → fallback")
print()
adapters = {
"esp32": ESP32Adapter(),
"photonic": PhotonicAdapter(),
"quantum": QuantumAdapter(),
"tensor": TensorNetworkAdapter(),
}
all_results = []
total_start = time.perf_counter()
for n in n_values:
print(f"\n{'─' * 70}")
print(f" n = {n} (p = 1/{n} = {1.0/n:.4f})")
print(f"{'─' * 70}")
G = generate_critical_graph(n, seed=seed)
print(f" Graph: {n} nodes, {G.number_of_edges()} edges, "
f"{nx.number_connected_components(G)} components")
for mode_name, adapter in adapters.items():
# Skip modes that can't handle this size
if mode_name == "esp32" and n > 50:
continue
if mode_name == "photonic" and n > 100:
continue
if mode_name == "quantum" and n > 20:
continue
result = adapter.execute(G, seed)
all_results.append(result)
status = "✓" if result.checks_passed == result.checks_total else "✗"
print(f" {status} {mode_name:10s} "
f"λ₁={result.dominant_eigenvalue:.4f} "
f"gap={result.spectral_gap:.4f} "
f"spiral={result.spiral_index:>12d} "
f"comp={result.compression_ratio:.1f}x "
f"checks={result.checks_passed}/{result.checks_total} "
f"{result.execution_time_ms:.2f}ms "
f"[{result.quimb_backend}]")
total_elapsed = (time.perf_counter() - total_start) * 1000
# Cross-mode agreement for n=20
print(f"\n{'=' * 70}")
print(" CROSS-MODE AGREEMENT CHECK (n=20)")
print(f"{'=' * 70}")
n20_results = [r for r in all_results if r.n == 20]
if len(n20_results) >= 2:
lambdas = [r.dominant_eigenvalue for r in n20_results]
gaps = [r.spectral_gap for r in n20_results]
lambda_cv = np.std(lambdas) / np.mean(lambdas) if np.mean(lambdas) > 0 else 0
gap_cv = np.std(gaps) / np.mean(gaps) if np.mean(gaps) > 0 else 0
agree = lambda_cv < 0.5 and gap_cv < 0.5
print(f" λ₁ mean={np.mean(lambdas):.4f} std={np.std(lambdas):.4f} CV={lambda_cv:.4f}")
print(f" gap mean={np.mean(gaps):.4f} std={np.std(gaps):.4f} CV={gap_cv:.4f}")
print(f" {'✓✓✓ ALL MODES AGREE' if agree else '✗✗✗ MODES DIVERGE'}")
else:
agree = False
print(" (insufficient modes for n=20)")
# Summary
total_checks = sum(r.checks_total for r in all_results)
passed_checks = sum(r.checks_passed for r in all_results)
print(f"\n{'=' * 70}")
print(" FINAL SPRINT SUMMARY")
print(f"{'=' * 70}")
print(f" Graph sizes tested: {len(n_values)}")
print(f" Mode executions: {len(all_results)}")
print(f" Total checks: {passed_checks}/{total_checks}")
print(f" Pass rate: {100*passed_checks/total_checks:.1f}%")
print(f" Cross-mode agreement: {'YES' if agree else 'NO'}")
print(f" Total time: {total_elapsed:.1f}ms")
print(f" Quimb backend: {QUIMB_BACKEND}")
print(f"\n {'ALL SYSTEMS NOMINAL' if passed_checks == total_checks else 'SOME CHECKS FAILED'}")
print("=" * 70)
return {
"quimb_backend": QUIMB_BACKEND,
"n_values": n_values,
"results": [r.to_dict() for r in all_results],
"total_checks": total_checks,
"passed_checks": passed_checks,
"pass_rate": passed_checks / total_checks if total_checks > 0 else 0,
"cross_mode_agreement": agree,
"total_time_ms": total_elapsed,
}
if __name__ == "__main__":
result = run_sprint()
# Save JSON receipt
receipt_path = os.path.join(os.path.dirname(__file__), "sprint_receipt.json")
with open(receipt_path, "w") as f:
json.dump(result, f, indent=2, default=str)
print(f"\n Receipt saved: {receipt_path}")
if __name__ == "__main__":
result = run_sprint()
# Save JSON receipt
receipt_path = os.path.join(os.path.dirname(__file__), "sprint_receipt.json")
with open(receipt_path, "w") as f:
json.dump(result, f, indent=2, default=str)
print(f"\n Receipt saved: {receipt_path}")
Reference in a new issue View git blame Copy permalink