mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
342 lines
15 KiB
Python
342 lines
15 KiB
Python
#!/usr/bin/env python3
|
||
# /// script
|
||
# requires-python = ">=3.10"
|
||
# dependencies = ["requests", "rich"]
|
||
# ///
|
||
"""
|
||
EigenGate Paradigm Analysis
|
||
Re-runs the three-pass adaptive analysis (summarize / cross-link / critique)
|
||
with the EigenGate as the central lens.
|
||
|
||
Context loaded:
|
||
- Kernel/EigenGate.lean + GateChain.lean (the new paradigm)
|
||
- HCMMR/Core.lean + Bridge.lean + Manifest.lean (the old Gate typeclass)
|
||
- HCMMR/Laws/ (14, 15, 15E, 16, 17, 18)
|
||
- HCMMR/Kernels/ (RecamanFieldStep, FAMMScarMemory, PrimeGearCache, SNRAnomalyDetector)
|
||
- HCMMR/v0_2_Roadmap.md
|
||
- Core/ layer (FoldedPointManifold, UnderverseZeroLayer, QuantumFoamBoundary,
|
||
S3CProjectedGeodesicResolution, PathEpigeneticManifold)
|
||
- FAMM.lean, ReceiptCore.lean, FixedPoint.lean (substrate)
|
||
|
||
The three passes ask:
|
||
1. SUMMARIZE — what does the EigenGate paradigm actually unify?
|
||
2. CROSS-LINK — where does ∥G·s − s∥ ≤ τ naturally appear across all kernels/laws?
|
||
3. CRITIQUE — what is still hand-wavy, what must be proven, what is the migration plan?
|
||
"""
|
||
|
||
import datetime
|
||
import os
|
||
import re
|
||
import sys
|
||
import time
|
||
from pathlib import Path
|
||
|
||
import requests
|
||
from rich.console import Console
|
||
from rich.markdown import Markdown
|
||
from rich.progress import Progress, SpinnerColumn, TextColumn
|
||
|
||
RESEARCH_ROOT = Path("/home/allaun/Documents/Research Stack")
|
||
LEAN_ROOT = RESEARCH_ROOT / "0-Core-Formalism/lean/Semantics/Semantics"
|
||
API_BASE = "https://ollama.com/v1"
|
||
API_KEY = os.environ.get("OLLAMA_API_KEY", "")
|
||
DEFAULT_MODEL = "cogito-2.1:671b"
|
||
FALLBACK_CHAIN = ["qwen3-next:80b", "gemma4:31b", "deepseek-v4-flash"]
|
||
|
||
MAX_PER_FILE = 10_000 # chars per lean file (they're dense)
|
||
MAX_CONTEXT = 110_000 # total context chars
|
||
|
||
console = Console()
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Files to load — ordered by conceptual priority
|
||
# ---------------------------------------------------------------------------
|
||
LEAN_FILES = [
|
||
# ── New paradigm kernel ──────────────────────────────────────────────
|
||
"Kernel/EigenGate.lean",
|
||
"Kernel/GateChain.lean",
|
||
|
||
# ── Old Gate typeclass (what needs migrating) ─────────────────────
|
||
"HCMMR/Core.lean",
|
||
"HCMMR/Bridge.lean",
|
||
"HCMMR/Manifest.lean",
|
||
|
||
# ── Laws (old Gate pattern) ──────────────────────────────────────────
|
||
"HCMMR/Laws/Law14_Motion.lean",
|
||
"HCMMR/Laws/Law15_Field.lean",
|
||
"HCMMR/Laws/Law15E_SignalDetection.lean",
|
||
"HCMMR/Laws/Law16_Entropy.lean",
|
||
"HCMMR/Laws/Law17_Observer.lean",
|
||
"HCMMR/Laws/Law18_Constants.lean",
|
||
|
||
# ── Kernels ──────────────────────────────────────────────────────────
|
||
"HCMMR/Kernels/RecamanFieldStep.lean",
|
||
"HCMMR/Kernels/FAMMScarMemory.lean",
|
||
"HCMMR/Kernels/PrimeGearCache.lean",
|
||
"HCMMR/Kernels/SNRAnomalyDetector.lean",
|
||
|
||
# ── Core substrate ───────────────────────────────────────────────────
|
||
"Core/FoldedPointManifold.lean",
|
||
"Core/UnderverseZeroLayer.lean",
|
||
"Core/QuantumFoamBoundary.lean",
|
||
"Core/S3CProjectedGeodesicResolution.lean",
|
||
"Core/PathEpigeneticManifold.lean",
|
||
]
|
||
|
||
EXTRA_DOCS = [
|
||
# Roadmap and substrate prose
|
||
"HCMMR/v0_2_Roadmap.md",
|
||
"0-Core-Formalism/lean/Semantics/Semantics/FAMM.lean",
|
||
]
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Helpers
|
||
# ---------------------------------------------------------------------------
|
||
|
||
def load(path: Path, max_chars: int = MAX_PER_FILE) -> str:
|
||
try:
|
||
text = path.read_text(errors="replace")
|
||
if len(text) > max_chars:
|
||
text = text[:max_chars] + f"\n-- [truncated at {max_chars} chars]"
|
||
return text
|
||
except Exception as e:
|
||
return f"-- [could not read {path}: {e}]"
|
||
|
||
|
||
def gather_context() -> str:
|
||
parts = []
|
||
for rel in LEAN_FILES:
|
||
p = LEAN_ROOT / rel
|
||
label = f"LEAN: {rel}"
|
||
parts.append(f"\n\n---\n## {label}\n\n```lean\n{load(p)}\n```")
|
||
|
||
for rel in EXTRA_DOCS:
|
||
p = RESEARCH_ROOT / rel
|
||
label = f"DOC: {rel}"
|
||
parts.append(f"\n\n---\n## {label}\n\n{load(p, 6000)}")
|
||
|
||
combined = "\n".join(parts)
|
||
if len(combined) > MAX_CONTEXT:
|
||
combined = combined[:MAX_CONTEXT] + "\n\n-- [context truncated]"
|
||
return combined
|
||
|
||
|
||
def chat(model: str, system: str, user: str, label: str, retries: int = 3) -> str:
|
||
headers = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}
|
||
models_to_try = [model] + [m for m in FALLBACK_CHAIN if m != model]
|
||
|
||
for attempt_model in models_to_try:
|
||
payload = {
|
||
"model": attempt_model,
|
||
"messages": [
|
||
{"role": "system", "content": system},
|
||
{"role": "user", "content": user},
|
||
],
|
||
"stream": False,
|
||
"options": {"temperature": 0.2, "num_predict": 8192},
|
||
}
|
||
for attempt in range(1, retries + 1):
|
||
with Progress(SpinnerColumn(),
|
||
TextColumn(f"[bold cyan]{label}[/bold cyan] ({attempt_model}, try {attempt}) ..."),
|
||
transient=True, console=console) as p:
|
||
p.add_task("", total=None)
|
||
try:
|
||
resp = requests.post(f"{API_BASE}/chat/completions",
|
||
headers=headers, json=payload, timeout=600)
|
||
except requests.exceptions.Timeout:
|
||
console.print(f"[yellow]Timeout, retrying...[/yellow]")
|
||
time.sleep(5 * attempt)
|
||
continue
|
||
|
||
if resp.status_code == 200:
|
||
content = resp.json()["choices"][0]["message"]["content"]
|
||
content = re.sub(r"<think>.*?</think>", "", content, flags=re.DOTALL).strip()
|
||
return content
|
||
|
||
body = resp.text[:300]
|
||
if "overloaded" in body.lower() or resp.status_code in (429, 503):
|
||
wait = 12 * attempt
|
||
console.print(f"[yellow]Overloaded, waiting {wait}s...[/yellow]")
|
||
time.sleep(wait)
|
||
elif resp.status_code == 500:
|
||
console.print(f"[yellow]500 on {attempt_model}, trying fallback...[/yellow]")
|
||
break
|
||
else:
|
||
console.print(f"[red]API error {resp.status_code}:[/red] {body}")
|
||
sys.exit(1)
|
||
console.print(f"[yellow]Exhausted retries for {attempt_model}[/yellow]")
|
||
|
||
console.print("[red]All models failed.[/red]")
|
||
sys.exit(1)
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# System prompt — shared across all three passes
|
||
# ---------------------------------------------------------------------------
|
||
SYSTEM = """\
|
||
You are an expert in formal verification (Lean 4), type theory, and physics-informed \
|
||
computation. You are reviewing the HCMMR (Hyper-Coherent Morphic Meta-Recursion) \
|
||
research stack on its `distilled` branch.
|
||
|
||
The stack is undergoing a PARADIGM SHIFT. The old system used a flat `Gate` struct \
|
||
(name, required, score, verdict). The new paradigm is the `Eigengate`:
|
||
|
||
structure Eigengate (α : Type) where
|
||
operator : α → α -- G: the operator whose fixed points encode the law
|
||
residual : α → Q0_16 -- ∥G·s − s∥, normalised to [0,1)
|
||
threshold : Q0_16 -- τ: max admissible residual
|
||
|
||
The central doctrine: EVERY physical law, routing decision, and compression check \
|
||
is an eigenstate condition ∥G·s − s∥ ≤ τ. The full physical universe is the \
|
||
intersection of λ=1 eigenspaces for all required gate operators simultaneously.
|
||
|
||
The migration is INCOMPLETE. EigenGate.lean and GateChain.lean exist but are not \
|
||
imported by anything. All Laws (14–18) still use the old Gate struct. The kernels \
|
||
(RecamanFieldStep, FAMMScarMemory, PrimeGearCache, SNRAnomalyDetector) also use old Gate. \
|
||
LawRecovery.lean (concrete eigengate constructors for each physical law) was never written.
|
||
|
||
Be precise, rigorous, and honest. Do not hallucinate. Flag uncertainty explicitly.\
|
||
"""
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Pass 1 — Summarize what the EigenGate paradigm actually unifies
|
||
# ---------------------------------------------------------------------------
|
||
PASS1_SYS = SYSTEM + """
|
||
|
||
YOUR TASK: PARADIGM SUMMARY.
|
||
Given all the Lean source files, answer:
|
||
1. What does the Eigengate pattern (`∥G·s − s∥ ≤ τ`) actually unify across the stack?
|
||
List every law/kernel and state what G, s, and the residual would be in each case.
|
||
2. What is the relationship between the old `Gate` struct and `Eigengate`?
|
||
Are they isomorphic? Can one be mechanically derived from the other?
|
||
3. What does `Semantics.Kernel.EigenGate` currently prove that the old HCMMR/Core does not?
|
||
4. What is the correct `α` type for each of the six laws (14, 15K, 15A-D, 15E, 16, 17, 18)?
|
||
Be specific — what Lean type carries the state?
|
||
5. Where does the Recamán kernel fit in the eigengate picture?
|
||
What is G for a Recamán field step?
|
||
|
||
Use markdown headers per section. Be concrete — reference actual line numbers and
|
||
struct fields from the source files where relevant.
|
||
"""
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Pass 2 — Cross-link: where does ∥G·s − s∥ naturally appear already?
|
||
# ---------------------------------------------------------------------------
|
||
PASS2_SYS = SYSTEM + """
|
||
|
||
YOUR TASK: CROSS-DOMAIN EIGENGATE DETECTION.
|
||
Scan all the Lean files in the context. For each file/module, identify:
|
||
1. Any existing computation that already computes something of the form ∥G·s − s∥
|
||
(even if not named that way). What is G? What is s? What is the residual value?
|
||
2. Any existing `residual`, `score`, `epsilon`, or `delta` computation that could
|
||
directly become the `residual : α → Q0_16` field of an Eigengate.
|
||
3. Any existing operator/transform that maps a state to a new state — these are
|
||
candidate `operator : α → α` fields.
|
||
4. Places where the old Gate struct's `score` field is set to a formula (not just
|
||
a constant `Q16_16.one`) — these are the richest migration candidates.
|
||
|
||
Format as a table: | Module | Existing computation | Candidate G | Candidate residual | Migration difficulty |
|
||
Then give a prioritized migration order (easiest → hardest) with reasoning.
|
||
"""
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Pass 3 — Critique and concrete migration plan
|
||
# ---------------------------------------------------------------------------
|
||
PASS3_SYS = SYSTEM + """
|
||
|
||
YOUR TASK: CRITIQUE AND CONCRETE MIGRATION PLAN.
|
||
Be rigorous. Identify:
|
||
|
||
A) ARCHITECTURAL CRITIQUE
|
||
[CRITICAL/MODERATE/MINOR] — what is wrong or incomplete in the current design?
|
||
Pay special attention to:
|
||
- The type parameter `α` in `Eigengate (α : Type)` — is it flexible enough?
|
||
The Laws need different α types (TrajectoryPoint, KahlerState, MaxwellField, etc.)
|
||
Can a single GateChain hold gates over different α? If not, how must GateChain change?
|
||
- The `score` function `1/(1+r)` — is this the right proximity measure for all laws?
|
||
- FAMM's `expNeg` — if it's a stub, what breaks?
|
||
- PrimeGearCache's silent cache-miss (returns Q16_16.one with no receipt) — severity?
|
||
- RecamanFieldStep's untested gate-reject path — what scenario does this cover?
|
||
- SNRAnomalyDetector's dead `dopplerDrift` branch — is it needed?
|
||
|
||
B) CONCRETE MIGRATION PLAN
|
||
Write the exact 5-step plan to complete the paradigm migration:
|
||
Step 1: What to add to Semantics.lean (exact import lines)
|
||
Step 2: What LawRecovery.lean must contain (list each law's G, α, residual formula)
|
||
Step 3: Which kernels need a new `toEigengate` adapter function and what it looks like
|
||
Step 4: What new theorems are needed to prove the old Gate and new Eigengate are equivalent
|
||
Step 5: What the v0.2 build should look like when complete (job count, zero errors)
|
||
|
||
C) WHAT NOT TO DO
|
||
Flag any tempting-but-wrong approaches that the previous agent sessions considered
|
||
and should be avoided.
|
||
"""
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Main
|
||
# ---------------------------------------------------------------------------
|
||
def main():
|
||
if not API_KEY:
|
||
console.print("[red]Set OLLAMA_API_KEY before calling the Ollama Cloud API.[/red]")
|
||
sys.exit(1)
|
||
|
||
console.rule("[bold green]EigenGate Paradigm Analysis[/bold green]")
|
||
console.print(f"Model: [bold]{DEFAULT_MODEL}[/bold] Fallbacks: {FALLBACK_CHAIN}\n")
|
||
|
||
console.print("[dim]Loading Lean source files and docs...[/dim]")
|
||
context = gather_context()
|
||
console.print(f"[dim]Context: {len(context):,} chars[/dim]\n")
|
||
|
||
summary = chat(DEFAULT_MODEL, PASS1_SYS,
|
||
f"Lean source files:\n\n{context}\n\nProduce the paradigm summary.",
|
||
"Pass 1: Paradigm Summary")
|
||
|
||
crosslink = chat(DEFAULT_MODEL, PASS2_SYS,
|
||
f"Summary from Pass 1:\n{summary}\n\n---\nLean source files:\n\n{context}\n\nDetect eigengate patterns.",
|
||
"Pass 2: Cross-link Detection")
|
||
|
||
critique = chat(DEFAULT_MODEL, PASS3_SYS,
|
||
f"Summary:\n{summary}\n\nCross-links:\n{crosslink}\n\n---\nLean source files:\n\n{context}\n\nDeliver critique and migration plan.",
|
||
"Pass 3: Critique + Migration Plan")
|
||
|
||
timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
|
||
report = f"""# EigenGate Paradigm Analysis
|
||
*Generated: {timestamp} | Model: {DEFAULT_MODEL}*
|
||
|
||
> **Context:** This analysis re-examines the HCMMR `distilled` branch through the lens
|
||
> of the incomplete `Eigengate (α : Type)` paradigm migration. The old `Gate` struct
|
||
> (HCMMR/Core.lean) and the new `Eigengate` (Kernel/EigenGate.lean) coexist but are
|
||
> disconnected. This report determines what the migration requires and how to complete it.
|
||
|
||
---
|
||
|
||
## Pass 1 — What the EigenGate Paradigm Unifies
|
||
|
||
{summary}
|
||
|
||
---
|
||
|
||
## Pass 2 — Where ∥G·s − s∥ Already Appears in the Codebase
|
||
|
||
{crosslink}
|
||
|
||
---
|
||
|
||
## Pass 3 — Critique & Concrete Migration Plan
|
||
|
||
{critique}
|
||
|
||
---
|
||
*Generated by `scripts/eigengate_paradigm_analysis.py`*
|
||
"""
|
||
|
||
date_str = datetime.datetime.now().strftime("%Y-%m-%d")
|
||
out = RESEARCH_ROOT / "6-Documentation" / "docs" / "reports" / f"eigengate_paradigm_analysis_{date_str}.md"
|
||
out.parent.mkdir(parents=True, exist_ok=True)
|
||
out.write_text(report)
|
||
|
||
console.rule("[bold green]Complete[/bold green]")
|
||
console.print(f"\nReport: [bold]{out}[/bold]\n")
|
||
console.print(Markdown(report[:8000] + ("\n\n*[truncated — see file]*" if len(report) > 8000 else "")))
|
||
|
||
if __name__ == "__main__":
|
||
main()
|