#!/usr/bin/env python3 """ Autonomous Pipeline: unknown problem → solve → FAMM scar → RRC re-route → iterate Markdown in → parse → classify → AngrySphinx solver → on fail: record scar → RRC reads scar, re-routes search → repeat until solved or exhausted → emit receipt The FAMM scar is negative guidance: "the solution is NOT in this spectral region." RRC reads all scars and routes the solver away from dead zones. """ import json, re, sys, math, hashlib, time, argparse, os from pathlib import Path from dataclasses import dataclass, field from typing import List, Dict, Optional, Set, Tuple # ── Database configuration ─────────────────────────────────────────────── NEON_PG = os.environ.get("NEON_PG", "postgres://postgres:postgres@100.92.88.64:5432/research_stack") try: import psycopg2 import psycopg2.extras HAS_DB = True except ImportError: HAS_DB = False def db_conn(): if not HAS_DB: return None return psycopg2.connect(NEON_PG, connect_timeout=5) def db_init(): """Create ENE schema tables if they don't exist (idempotent).""" if not HAS_DB: return try: conn = db_conn() with conn.cursor() as cur: cur.execute("CREATE SCHEMA IF NOT EXISTS ene") cur.execute(""" CREATE TABLE IF NOT EXISTS ene.routes ( id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text, start_package_id TEXT NOT NULL REFERENCES ene.packages(pkg) ON DELETE CASCADE, end_package_id TEXT NOT NULL REFERENCES ene.packages(pkg) ON DELETE CASCADE, route_type TEXT NOT NULL, cost REAL DEFAULT 0, residual REAL DEFAULT 0, scar_pressure REAL DEFAULT 0, receipt_hash TEXT, path JSONB DEFAULT '[]'::jsonb, created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() ) """) cur.execute(""" CREATE TABLE IF NOT EXISTS ene.scars ( id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text, package_id TEXT NOT NULL REFERENCES ene.packages(pkg) ON DELETE CASCADE, scar_type TEXT NOT NULL, scar_pressure REAL DEFAULT 0, failure_mode TEXT, residual JSONB DEFAULT '{}'::jsonb, coarsening_agent JSONB DEFAULT '{}'::jsonb, opened_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), closed_at TIMESTAMPTZ, status TEXT NOT NULL DEFAULT 'open' ) """) cur.execute(""" CREATE TABLE IF NOT EXISTS ene.rrc_classifications ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), equation_id TEXT, shape TEXT, pist_label TEXT, spectral_radius DOUBLE PRECISION, weak_axes INT, score DOUBLE PRECISION, classified_at TIMESTAMPTZ NOT NULL DEFAULT NOW() ) """) cur.execute("CREATE INDEX IF NOT EXISTS idx_scar_pkg ON ene.scars(package_id)") cur.execute("CREATE INDEX IF NOT EXISTS idx_scar_pressure ON ene.scars(scar_pressure DESC)") cur.execute("CREATE INDEX IF NOT EXISTS idx_rrc_eq ON ene.rrc_classifications(equation_id)") conn.commit() conn.close() except Exception as e: print(f" [db] Schema init error: {e}", file=sys.stderr) def db_load_guide_paths(equation_id: str) -> Dict: """Load guide paths from DB: existing scars + RRC classifications for this equation. Returns dict of {scarred_regions: [...], classifications: [...], routes: [...]}.""" guide = {"scarred_regions": [], "classifications": [], "routes": []} if not HAS_DB: return guide try: conn = db_conn() with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur: cur.execute( "SELECT DISTINCT scar_type, failure_mode, scar_pressure FROM ene.scars WHERE status='open' ORDER BY scar_pressure DESC", () ) for row in cur.fetchall(): guide["scarred_regions"].append(row) cur.execute( "SELECT shape, pist_label, spectral_radius, weak_axes, score FROM ene.rrc_classifications WHERE equation_id=%s ORDER BY score DESC", (equation_id,) ) for row in cur.fetchall(): guide["classifications"].append(row) cur.execute( "SELECT route_type, cost, residual, scar_pressure FROM ene.routes ORDER BY cost ASC", () ) for row in cur.fetchall(): guide["routes"].append(row) conn.close() except Exception as e: print(f" [db] Load error: {e}", file=sys.stderr) return guide def db_write_scar(package_id: str, scar_type: str, pressure: float, failure_mode: str, coarsening_agent: str = ""): if not HAS_DB: return try: conn = db_conn() with conn.cursor() as cur: cur.execute( "INSERT INTO ene.scars (package_id, scar_type, scar_pressure, failure_mode, coarsening_agent) " "VALUES (%s, %s, %s, %s, %s::jsonb) ON CONFLICT DO NOTHING", (package_id, scar_type, pressure, failure_mode, json.dumps({"agent": coarsening_agent})) ) conn.commit() conn.close() except Exception as e: print(f" [db] Scar write error: {e}", file=sys.stderr) def db_write_route(start_pkg: str, end_pkg: str, route_type: str, cost: float, residual: float, scar_pressure: float, path: list): if not HAS_DB: return try: conn = db_conn() with conn.cursor() as cur: cur.execute( "INSERT INTO ene.routes (start_package_id, end_package_id, route_type, cost, residual, scar_pressure, path) " "VALUES (%s, %s, %s, %s, %s, %s, %s::jsonb)", (start_pkg, end_pkg, route_type, cost, residual, scar_pressure, json.dumps(path)) ) conn.commit() conn.close() except Exception as e: print(f" [db] Route write error: {e}", file=sys.stderr) def db_ensure_package(pkg_id: str, title: str = "", pkg_type: str = "lean_theorem"): """Upsert a package so foreign keys work.""" if not HAS_DB: return try: conn = db_conn() with conn.cursor() as cur: cur.execute( "INSERT INTO ene.packages (pkg, package_type, title) VALUES (%s, %s, %s) ON CONFLICT (pkg) DO NOTHING", (pkg_id, pkg_type, title) ) conn.commit() conn.close() except Exception as e: print(f" [db] Package error: {e}", file=sys.stderr) sys.setrecursionlimit(10000) # ═══════════════════════════════════════════════════════════════════ # Core primitives # ═══════════════════════════════════════════════════════════════════ LETTERS = ["Φ","Λ","Ρ","Κ","Ω","Σ","Π","Ζ"] def sigma3(n): t = 0 for d in range(1, int(n**0.5)+1): if n % d == 0: t += d**3 if n//d != d: t += (n//d)**3 return t def cartan_block(a, b): if a == b: return 273 if a // 2 == b // 2: return 256 return 0 @dataclass class FAMMScar: """A FAMM scar records a failure zone: where the solver hit a wall.""" region: str # which Cartan block pair collided collision_sum: int # the sum value that collided pressure: int # energy cost = 256*collisions failure_mode: str # ROSSBY (retry) or SCARRED (quarantine) coarsening_agent: str # fix route timestamp: float = field(default_factory=time.time) @dataclass class RRCState: """RRC state: tracks which spectral regions are dead (scarred) and which remain viable for search. The gate is a cumulative resource budget: each collision charge consumes budget; when budget is exhausted the region permanently scars (irreversible closure). Budget threshold decays over time, so early search is forgiving and late search is strict.""" regions: List[str] = field(default_factory=lambda: [ "CANONICAL_pair0", "CANONICAL_pair1", "CANONICAL_pair2", "CANONICAL_pair3", "ROSSBY_all" ]) dead_regions: Set[str] = field(default_factory=set) scars: List[FAMMScar] = field(default_factory=list) _idx: int = 0 equation_id: str = "" # Cumulative resource budget per region region_budget: Dict[str, int] = field(default_factory=dict) max_budget_initial: int = 20 # B₀ budget_decay: float = 0.85 # λ — threshold shrinks each iteration _iteration: int = 0 def __post_init__(self): """On init, load guide paths from DB to skip known dead regions.""" if self.equation_id: guide = db_load_guide_paths(self.equation_id) for scar_row in guide.get("scarred_regions", []): mode = scar_row.get("failure_mode", "ROSSBY") sregion = scar_row.get("scar_type", "ROSSBY_all") if mode == "SCARRED" or mode == "rosby_collapse": self.dead_regions.add(sregion) self.scars.append(FAMMScar( region=sregion, collision_sum=0, pressure=int(scar_row.get("scar_pressure", 256)), failure_mode="SCARRED", coarsening_agent="persisted scar (loaded from DB)" )) for cls_row in guide.get("classifications", []): shape = cls_row.get("shape", "") if shape and shape != "unknown": pass @property def current_max_budget(self) -> int: """B(t): dynamic budget threshold. Decays with iterations, never below 3.""" return max(3, int(self.max_budget_initial * (self.budget_decay ** self._iteration))) def charge_budget(self, region: str, cost: int) -> bool: """Charge cumulative collision cost to a region. Returns True if budget is exhausted → region permanently scars.""" self.region_budget[region] = self.region_budget.get(region, 0) + cost if self.region_budget[region] >= self.current_max_budget: scar = FAMMScar( region=region, collision_sum=cost, pressure=self.region_budget[region], failure_mode="SCARRED", coarsening_agent=( f"budget exhausted: cumulative {self.region_budget[region]} " f"collisions ≥ B_max={self.current_max_budget}" ) ) self.record_scar(scar) return True return False def next_region(self) -> Optional[str]: """Return next viable region, cycling through all non-dead regions.""" tried = 0 while tried < len(self.regions): r = self.regions[self._idx % len(self.regions)] self._idx += 1 if r not in self.dead_regions: return r tried += 1 return None def scar_blocked(self, region: str) -> bool: """Check if a given region (e.g. 'pair_0') is in the dead set.""" canonical_map = {"pair_0": "CANONICAL_pair0", "pair_1": "CANONICAL_pair1", "pair_2": "CANONICAL_pair2", "pair_3": "CANONICAL_pair3"} canonical = canonical_map.get(region, "ROSSBY_all") return canonical in self.dead_regions def record_scar(self, scar: FAMMScar): self.scars.append(scar) if scar.failure_mode == "SCARRED": self.dead_regions.add(scar.region) pkg_id = f"scar:{scar.region}" db_ensure_package(pkg_id, title=f"FAMM scar @ {scar.region}", pkg_type="scar") db_write_scar( package_id=pkg_id, scar_type=scar.region, pressure=float(scar.pressure), failure_mode=scar.failure_mode, coarsening_agent=scar.coarsening_agent ) def summary(self): alive = [r for r in self.regions if r not in self.dead_regions] dead = sorted(self.dead_regions) return f"alive={alive} dead={dead} scars={len(self.scars)}" # ═══════════════════════════════════════════════════════════════════ # Solver: find Sidon set in [1,N] with scar recording # ═══════════════════════════════════════════════════════════════════ def solve_with_scars(N: int, rrc: RRCState, region: str = "", time_limit_s: float = 10.0): """ Find maximal Sidon subset in [1,N] using σ₃ pre-filtering. On every collision, charge the region's cumulative budget. RRC reads scars before search to avoid dead regions. """ # E8 σ₃ pre-filter: only search σ₃-bounded candidates # This reduces search space from N to N^0.25 (~5-25 elements) candidates = [] n = 1 while n**3 + 1 <= N: if sigma3(n) <= N: candidates.append(n) n += 1 # If E8 pre-filter gives too few candidates, fall back to full range (capped) if len(candidates) <= 1: candidates = list(range(1, min(N + 1, 65))) # cap at 64 for brute-force best = [] nodes = 0 t0 = time.time() best_energy = 0 best_dna = "" def collision_count(s): sums = set() coll = 0 coll_details = [] for i, a in enumerate(s): for b in s[i:]: p = a + b if p in sums: coll += 1 coll_details.append((a, b, p)) else: sums.add(p) return coll, coll_details def new_collisions(current, x): psums = {a + x for a in current} | {x + x} existing = set() for i, a in enumerate(current): for b in current[i:]: existing.add(a + b) return len(psums & existing) def search(current, idx, current_coll): nonlocal best, nodes, t0, best_energy, best_dna if time.time() - t0 > time_limit_s: return nodes += 1 # Upper bound prune if len(current) + (len(candidates) - idx) <= len(best): return # AngrySphinx gate: at 2 collisions, record FAMM scar and return if current_coll >= 2: # Record scar for this failure _, details = collision_count(current) for a, b, p in details[-1:]: # last collision # Determine which Cartan pair li_a, li_b = sigma3(a) % 8, sigma3(b) % 8 pair = f"pair_{li_a//2}_{li_b//2}" pressure = 256 * current_coll - 17 * current_coll # Classify scar type if any(li // 2 == (li_a // 2) and li // 2 == (li_b // 2) for li in [sigma3(x) % 8 for x in current]): mode = "SCARRED" # same-pair collapse coarsening = f"quarantine pair {li_a//2}, retry with single-element filter" else: mode = "ROSSBY" # cross-pair threading coarsening = f"adjust Cartan block {li_a//2} energy ±256" scar = FAMMScar( region=pair, collision_sum=p, pressure=pressure, failure_mode=mode, coarsening=coarsening ) rrc.record_scar(scar) return # Update best: compute Hachimoji encoding + Cartan energy if len(current) > len(best): best = sorted(current[:]) # Hachimoji DNA dna = "".join(LETTERS[sigma3(n) % 8] for n in best) # Cartan energy indices = [sigma3(n) % 8 for n in best] ce = sum(cartan_block(indices[i], indices[j]) for i in range(len(indices)) for j in range(i, len(indices))) best_energy = ce best_dna = dna if idx >= len(candidates): return x = candidates[idx] # RRC check: skip if this element falls in a dead region li_x = sigma3(x) % 8 region = f"pair_{li_x//2}" if rrc.scar_blocked(region): # This Cartan block is dead — skip entire block search(current, idx + 1, current_coll) return c = new_collisions(current, x) if current_coll + c <= 1: current.append(x) search(current, idx + 1, current_coll + c) current.pop() search(current, idx + 1, current_coll) search([], 0, 0) elapsed = time.time() - t0 return { "solution": best, "size": len(best), "dna": best_dna, "cartan_energy": best_energy, "nodes": nodes, "time": round(elapsed, 4), "timed_out": elapsed > time_limit_s } # ═══════════════════════════════════════════════════════════════════ # Markdown Ingester (from existing ingest.py) # ═══════════════════════════════════════════════════════════════════ @dataclass class ParsedEquation: text: str line: int is_block: bool classification: str = "unknown" def parse_markdown(text: str) -> List[ParsedEquation]: equations = [] lines = text.split('\n') # Block equations: $$...$$ in_block = False block_text = "" for i, line in enumerate(lines): if line.strip().startswith('$$') and not in_block: in_block = True block_text = line.strip()[2:] if '$$' in block_text: # single-line block eq = block_text.split('$$')[0].strip() equations.append(ParsedEquation(text=eq, line=i+1, is_block=True)) in_block = False continue elif in_block: if '$$' in line: block_text += " " + line.split('$$')[0] eq = block_text.strip() if eq: equations.append(ParsedEquation(text=eq, line=i+1, is_block=True)) in_block = False block_text = "" else: block_text += " " + line # Inline equations: $...$ (skip if already captured in blocks) for i, line in enumerate(lines): if '$$' in line: continue inlines = re.findall(r'\$([^$]+)\$', line) for eq in inlines: eq = eq.strip() if eq and len(eq) >= 3: # meaningful equation, not empty/short equations.append(ParsedEquation(text=eq, line=i+1, is_block=False)) return equations SPECTRAL_KW = [r'spectral', r'eigenvalue', r'gap', r'Cartan', r'Sidon', r'chiral', r'braid', r'sigma', r'tau', r'Delta', r'lambda'] BRAID_KW = [r'braid', r'strand', r'cross', r'Sidon', r'eigensolid'] CARTAN_KW = [r'Cartan', r'weight', r'diagonal', r'block', r'Gram'] def classify_equation(eq: ParsedEquation) -> ParsedEquation: text = eq.text.lower() scores = {"spectral": 0, "braid": 0, "cartan": 0} for kw in SPECTRAL_KW: if re.search(kw, text, re.IGNORECASE): scores["spectral"] += 1 for kw in BRAID_KW: if re.search(kw, text, re.IGNORECASE): scores["braid"] += 1 for kw in CARTAN_KW: if re.search(kw, text, re.IGNORECASE): scores["cartan"] += 1 best = max(scores, key=scores.get) eq.classification = best if scores[best] > 0 else "unknown" return eq # ═══════════════════════════════════════════════════════════════════ # The Autonomous Loop # ═══════════════════════════════════════════════════════════════════ def autonomous_solve(equation: ParsedEquation, max_iterations: int = 10) -> Dict: """ Unknown equation → try multiple spectral regions → scar dead zones → re-route. Each iteration tries a different RRC spectral region. If a region produces a solution worse than the best so far, record a FAMM scar and move to next region. This is the autonomous "solve → scar → re-route" cycle. Guide paths are loaded from the ENE PostgreSQL database on startup and new scars are persisted to guide future runs. """ # Determine N from equation numbers = [int(x) for x in re.findall(r'\b(\d+)\b', equation.text) if 2 <= int(x) <= 10000] N = min(max(max(numbers), 64) if numbers else 128, 10000) # Create a deterministic equation_id for DB lookup eq_hash = hashlib.sha256(equation.text.encode()).hexdigest()[:16] equation_id = f"eq_{eq_hash}" # RRC state loads guide paths from DB (scarred regions, classifications) on init rrc = RRCState(equation_id=equation_id) iteration_log = [] best_solution = [] best_dna = "" # Ensure package exists in DB for this equation db_ensure_package(equation_id, title=equation.text[:120], pkg_type="equation") for iteration in range(max_iterations): region = rrc.next_region() if region is None: iteration_log.append({"iteration": iteration, "status": "EXHAUSTED", "region": "—", "size": 0}) break # Update dynamic budget threshold (decays with each iteration) rrc._iteration = iteration # Generate σ₃-bounded candidates for this region candidates = [] n = 1 while n**3 + 1 <= N: if sigma3(n) <= N: candidates.append(n) n += 1 # RRC filter: only process elements in viable region region_blocks = { "CANONICAL_pair0": (0,), "CANONICAL_pair1": (1,), "CANONICAL_pair2": (2,), "CANONICAL_pair3": (3,), "ROSSBY_all": (0, 1, 2, 3), } allowed_blocks = region_blocks.get(region, (0, 1, 2, 3)) # Filter candidates by region, but fall back to all if too few filtered = [x for x in candidates if (sigma3(x) % 8) // 2 in allowed_blocks] if len(filtered) <= 1: filtered = candidates result = solve_with_scars_prefiltered(filtered, N, rrc, region=region, time_limit_s=5.0) budget_info = f"B={rrc.region_budget.get(region, 0)}/{rrc.current_max_budget}" log_entry = { "iteration": iteration, "region": region, "solution": result["solution"], "size": result["size"], "dna": result["dna"], "cartan_energy": result["cartan_energy"], "nodes": result["nodes"], "time": result["time"], "collisions": result.get("collisions", 0), "budget": budget_info, "budget_exhausted": result.get("budget_exhausted", False), } if result.get("budget_exhausted", False): log_entry["status"] = "BUDGET_EXHAUSTED" elif result["size"] == 0: if not best_solution: scar = FAMMScar( region=region, collision_sum=0, pressure=256, failure_mode="SCARRED" if "ROSSBY" not in region else "ROSSBY", coarsening_agent=f"gate closed @ {region}" ) rrc.record_scar(scar) log_entry["status"] = "GATE_CLOSED" elif result["size"] > len(best_solution): best_solution = result["solution"] best_dna = result["dna"] log_entry["status"] = "IMPROVED" # Write guide path to DB: this region was productive db_ensure_package(equation_id, title=equation.text[:120], pkg_type="equation") db_ensure_package(f"solution:size={result['size']}", title=f"Sidon set size {result['size']}", pkg_type="solution") db_write_route( start_pkg=equation_id, end_pkg=f"solution:size={result['size']}", route_type=f"rrc_region:{region}", cost=float(result.get("time", 0)), residual=0.0, scar_pressure=0.0, path=result["solution"] ) elif result["size"] < len(best_solution) and best_solution: # This region is worse → record a scar for future avoidance scar = FAMMScar( region=region, collision_sum=0, pressure=256, failure_mode="SCARRED" if "ROSSBY" not in region else "ROSSBY", coarsening_agent=f"region {region} is suboptimal (size {result['size']} < best {len(best_solution)})" ) rrc.record_scar(scar) log_entry["status"] = "SCARRED" log_entry["collisions"] = 1 # mark as scarred else: log_entry["status"] = "SAME" iteration_log.append(log_entry) alpha = math.log(len(best_solution)) / math.log(N) if len(best_solution) > 0 and N > 1 else 0 epsilon = 1 - alpha return { "equation": equation.text, "classification": equation.classification, "N": N, "iterations": len(iteration_log), "log": iteration_log, "final_size": len(best_solution), "final_solution": best_solution, "final_dna": best_dna, "erdos_epsilon": round(epsilon, 4), "rrc_summary": rrc.summary(), "total_scars": len(rrc.scars), "scars": [{"region": s.region, "mode": s.failure_mode, "pressure": s.pressure, "agent": s.coarsening_agent} for s in rrc.scars] } def solve_with_scars_prefiltered(candidates, N, rrc, region="", time_limit_s=5.0): """Solver with pre-filtered candidates. Charges cumulative resource budget. Each collision event (≥2 collisions on a search path) charges the region's cumulative budget. When budget > B_max(t), the region permanently scars. This models the gate as a computational resource constraint, not a Sidon feasibility check. """ best = [] nodes = 0 t0 = time.time() best_energy = 0 best_dna = "" collisions = 0 budget_exhausted = False def collision_count(s): sums = set() coll = 0 for i, a in enumerate(s): for b in s[i:]: p = a + b if p in sums: coll += 1 else: sums.add(p) return coll, [] def new_collisions(current, x): psums = {a + x for a in current} | {x + x} existing = set() for i, a in enumerate(current): for b in current[i:]: existing.add(a + b) return len(psums & existing) def search(current, idx, current_coll): nonlocal best, nodes, t0, best_energy, best_dna, collisions, budget_exhausted if budget_exhausted or time.time() - t0 > time_limit_s: return # Charge 1 effort unit per node explored to the region's cumulative budget if region: if rrc.charge_budget(region, 1): budget_exhausted = True return nodes += 1 if len(current) + (len(candidates) - idx) <= len(best): return if current_coll >= 2: collisions = max(collisions, current_coll) # Charge additional collision cost when the path is pruned if region: if rrc.charge_budget(region, current_coll): budget_exhausted = True if current: _, details = collision_count(current) for a, b, p in details[-1:]: li_a, li_b = sigma3(a) % 8, sigma3(b) % 8 rrc.scars.append(FAMMScar( region=f"CANONICAL_pair{li_a // 2}", collision_sum=p, pressure=256 * current_coll, failure_mode="ROSSBY", coarsening_agent=f"collision @ depth {len(current)}" )) return if len(current) > len(best): best = sorted(current[:]) dna = "".join(LETTERS[sigma3(n) % 8] for n in best) indices = [sigma3(n) % 8 for n in best] ce = sum(cartan_block(indices[i], indices[j]) for i in range(len(indices)) for j in range(i, len(indices))) best_energy = ce best_dna = dna if idx >= len(candidates): return x = candidates[idx] c = new_collisions(current, x) if current_coll + c <= 1: current.append(x) search(current, idx + 1, current_coll + c) current.pop() search(current, idx + 1, current_coll) search([], 0, 0) elapsed = time.time() - t0 return { "solution": best, "size": len(best), "dna": best_dna, "cartan_energy": best_energy, "nodes": nodes, "time": round(elapsed, 4), "timed_out": elapsed > time_limit_s, "collisions": collisions, "budget_exhausted": budget_exhausted } # ═══════════════════════════════════════════════════════════════════ # Main # ═══════════════════════════════════════════════════════════════════ def main(): parser = argparse.ArgumentParser(description="Autonomous pipeline: problem → solve → scar → re-route") parser.add_argument("input", type=str, help="Markdown file with equations") parser.add_argument("--max-iter", type=int, default=10, help="Max RRC re-route iterations") parser.add_argument("--verbose", action="store_true") args = parser.parse_args() input_path = Path(args.input) if not input_path.exists(): print(f"Error: {input_path} not found"); sys.exit(1) text = input_path.read_text() equations = parse_markdown(text) equations = [classify_equation(e) for e in equations] print(f"╔══════════════════════════════════════════════════════════╗") print(f"║ AUTONOMOUS PIPELINE: {input_path.name}") print(f"║ Equations parsed: {len(equations)}") spectral = sum(1 for e in equations if e.classification == "spectral") braid = sum(1 for e in equations if e.classification == "braid") cartan = sum(1 for e in equations if e.classification == "cartan") unknown = sum(1 for e in equations if e.classification == "unknown") print(f"║ Spectral: {spectral} Braid: {braid} Cartan: {cartan} Unknown: {unknown}") print(f"╚══════════════════════════════════════════════════════════╝") all_results = [] for eq in equations: if eq.classification == "unknown": if args.verbose: print(f"\n[{eq.line}] UNKNOWN → skipped: `{eq.text[:80]}`") all_results.append({"equation": eq.text, "line": eq.line, "result": "skipped"}) continue print(f"\n── [{eq.line}] {eq.classification.upper()}: `{eq.text[:60]}...` ──") result = autonomous_solve(eq) all_results.append(result) print(f" N={result['N']} Iterations: {result['iterations']}") for i, entry in enumerate(result["log"]): status_icon = {"IMPROVED": "✓", "SCARRED": "⚡", "SAME": "=", "EXHAUSTED": "✗", "GATE_CLOSED": "💥", "BUDGET_EXHAUSTED": "💥"}.get(entry["status"], "?") entry_region = entry.get("region", "—") entry_size = entry.get("size", 0) entry_dna = entry.get("dna", "") or "" entry_budget = entry.get("budget", "") budget_tag = f" [{entry_budget}]" if entry_budget else "" print(f" [{i}] {status_icon} {entry_region}: size={entry_size} ({entry['status']}){budget_tag}") print(f" Scars: {result['total_scars']}") for s in result["scars"]: print(f" ⚡ {s['mode']} @ {s['region']} → {s['agent']}") print(f" Best: {result['final_solution']} ({result['final_size']} elts)") print(f" DNA: {result['final_dna']}") print(f" ε: {result['erdos_epsilon']:.4f}") # Emit receipt receipt = { "schema": "autonomous_pipeline_v1", "source": str(input_path), "total_equations": len(equations), "results": all_results } out_path = input_path.with_suffix(".autonomous.json") out_path.write_text(json.dumps(receipt, indent=2)) print(f"\nReceipt: {out_path}") if __name__ == "__main__": main()