Add eisenstein-phase-cost-screen: certified necessary cost screen for the F4/Eisenstein decoder route

research/eisenstein-phase-cost-screen/README.md

@@ -0,0 +1,125 @@
+# Eisenstein phase-path cost screen
+
+**Outcome: certified necessary-condition screen — any Eisenstein-supplied
+decoder that beats the selected complex supplier needs total copy cost
+C <= 31 (bracket 31.0635… at s=7, window h=7); every *clean* support
+alphabet costs exactly 40; the prize for any complex-only win is capped by
+the selected assembly's bit side at kappa <= 0.001730427469823602 (+3.45%).**
+No supplier was built and no kappa changed.
+
+## Question
+
+PR #831 reopened the F4/Eisenstein phase path: alternating F4 trace forms no
+longer block phase compilation, because the alternating-compatible
+quadratic-phase normal form handles nondegenerate alternating blocks. The
+next question is economic: **if we build an Eisenstein supplier, does it beat
+the current selected complex supplier?** This package answers the first half
+of that question — the cost side — under the repo's inherited accounting.
+
+## What was checked (all exact, standard library only)
+
+1. **Geometry replay** (`research/eisenstein-clique-copy-bound/geometry.py`):
+   240 roots of E8, order-three complex structure J, 40 nonorthogonal lines
+   (degree 27), full flat census
+   `{(0,0):1, (1,1):40, (2,2):240, (2,4):90, (3,5):360, (3,12):40, (4,40):1}`,
+   every line-spanned flat nonsingular, and a 7-clique exists — so any
+   pattern-legal decoder B satisfies B[Q,Q] = I_7 on a 7-clique, hence
+   `rank_F2(B) >= 7` unconditionally (no reliance on the archived minrank-10
+   SAT).
+
+2. **Clean-class floor = 40.** Call an ordered flat pair (R, A) *clean* if
+   every cross pair of distinct lines is orthogonal. For clean pairs the
+   per-rectangle pairing-rank charge is exactly |R ∩ A|: the functionals
+   x ↦ ⟨x, t⟩ − ⟨Jt, Jt·x⟩ for t ∈ R ∩ A are independent on X_R by positive
+   definiteness of the real form and pairwise orthogonality of R ∩ A. The
+   verifier checks this on **all 7033 clean ordered pairs** (tight everywhere,
+   no census drift). Two independent sharp witnesses at total cost 40:
+   - **Frame partition:** the 40 lines split into ten pairwise-orthogonal
+     4-line frames, each spanning all of E8; the block-diagonal decoder is
+     pattern-legal (F2 rank 10) and costs exactly 40.
+   - **Star decomposition:** the canonical pattern
+     B0 = (all-ones + orthogonality) mod 2 decomposes into 40 clean stars,
+     each of cost exactly 1.
+
+3. **Certified threshold screen.** For a supplier with window h and stage
+   count s (odd), the format-limits skeleton (`skel.profile`, k=1,
+   x = C/40 with v = 40 Eisenstein ports) gives a pressure whose root X must
+   exceed the selected complex saving
+   b = 67018507072324140917/40000000000000000000000. Because the copy slot
+   enters the profile as mass s·x at cap h, the beat condition is **linear in
+   C**, so the exact threshold is
+   `C*(s,h) = 40·((s−1) − F_0(b)) / (s·(m/h)^b)` with m = 1 + s(h−1).
+   The verifier certifies rational brackets on C*(s,h) for every h ∈ [7,40]
+   and every odd s (interval arithmetic from `cert.py`, outward-rounded,
+   ~1e-42 wide), confirms non-beat directly at each window's closure point,
+   and closes the tail with an exact rational increment bound
+   (binomial-series chord bound; exact partial sums to P = 200, exact
+   quadratic minimum beyond; the closed-form slot masses are cross-checked
+   against the engine at 25 points). Result:
+
+   | window h | max integer threshold | argmax s | viable s range |
+   |---|---|---|---|
+   | 7  | 31 | 7 | 3..61 |
+   | 8  | 30 | 7–15 | 3..49 |
+   | 9  | 30 | 7–11 | 3..41 |
+   | 10 | 29 | 7–11 | 3..35 |
+
+   Larger windows only hurt (s=9 dies at h ≥ 24). So **any beating supplier
+   needs C ≤ 31 at some s ≤ 61**, and with the minrank-10 window the bound
+   sharpens to C ≤ 29 at s ≤ 35.
+
+4. **Prize cap.** The selected assembly's bit side is
+   X_bit = 0.001733427039589844 (PR #1094 audit, `bit_lower`), *above* the
+   complex side b. Every screen argmax point clears X_bit, so any
+   complex-only improvement is capped by the bit side:
+   `kappa <= X_bit/(1+X_bit) = 1733427039589844234749/1001733427039589844234749
+   = 0.001730427469823602`, i.e. **+3.45% over the selected record**
+   0.001672660197076918 — the uniform prize regardless of how cheap the
+   decoder is.
+
+5. **Negative controls (4):** closed-form/direct cross-validation at eight
+   boundary points; doubling b flips the argmax beat verdict; a tampered
+   pattern changes the clean census; the naive consecutive-block partition is
+   illegal (the frame witness needs orthogonality) and a star without its
+   self-loop costs 0 (the star witness is not vacuously constant).
+
+## What this proves and what it does not
+
+**Proves (under the inherited accounting):** the old #620-style construction
+(40 units) cannot improve kappa; any Eisenstein route that can must live in
+the non-clean window C ∈ [22, 31] at s ≤ 61; and the entire prize is at most
++3.45%.
+
+**Does not prove:** that a C ≤ 31 non-clean decoder exists; that the
+quadratic-phase normal form compiles such a decoder's labels without extra
+frames; or any new kappa. The screen is a necessary condition, not a
+construction and not a general decoder-optimality theorem.
+
+## Credit
+
+Built on `research/format-limits/scripts/{skel,cert}.py` (PR #801 format
+ceilings), `research/eisenstein-clique-copy-bound/geometry.py` (E8 root
+geometry and pairing-rank machinery), and the selected-record provenance in
+`research/community-frontier1094-audit/` (PR #1094). Related results: PR #798
+(copy floor 22, all supports), PR #620 (40-unit construction), PR #831
+(alternating-phase interface). See SOURCES.json for pinned hashes.
+
+## Open next questions
+
+- **Does a pattern-legal 40×40 F2-valued decoder exist with total copy cost
+  C ≤ 31 whose support is not clean?** The screen shows the entire remaining
+  upside of the Eisenstein phase route lives in this window (C ∈ [22,31] at
+  s ≤ 61). Settling it either yields the first Eisenstein-supplied assembly
+  (kappa up to the bit cap 0.001730427469823602) or closes the route under
+  the current accounting. First step: enumerate minimal non-clean supports
+  (a nonorthogonal pair read by a common rectangle) and certify their minimum
+  copy cost with the same pairing-rank machinery. Not blocked.
+- **Can the quadratic-phase normal form (PR #831) realize a candidate
+  decoder's phase labels on nondegenerate alternating blocks at the frame
+  level required by the assembly template?** PR #831 removed the interface
+  obstruction at the trace-form level, but no one has checked that a concrete
+  cheap decoder's labels compile without extra frames or adapters that would
+  break the C ≤ 31 budget. First step: take the cheapest abstract decoder
+  surviving the screen (if any) and run the f4-alternating-interface
+  compilation on its labels, charging every added frame. Blocked by the
+  non-clean window question.

research/eisenstein-phase-cost-screen/SOURCES.json

@@ -0,0 +1,48 @@
+{
+  "schema_version": 1,
+  "base_commit": "d78fe4bbb6f6b769e39586f8bb3ba8c31a31fd3a",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1",
+      "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075"
+    },
+    {
+      "path": "research/community-frontier1094-audit/ASSEMBLY.json",
+      "usage": "input",
+      "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0",
+      "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045"
+    },
+    {
+      "path": "research/community-frontier1094-audit/INDEPENDENT1094.json",
+      "usage": "input",
+      "git_blob": "009a385e26858058a18188364078d162aa6f9519",
+      "sha256": "301fb8a0e4ab7e3c383ff974c54c08178283b2a3453c5282757f692a3c7a4bfd"
+    },
+    {
+      "path": "research/eisenstein-clique-copy-bound/geometry.py",
+      "usage": "input",
+      "git_blob": "a92c16295d6fcf2a7ffeb7d38444613f939db6cb",
+      "sha256": "248df3fb820b5165ca485ad4d43f0271043498c45a59ac1edc310a124073644c"
+    },
+    {
+      "path": "research/format-limits/scripts/cert.py",
+      "usage": "input",
+      "git_blob": "351fbd107c86a233a91eb915f88612c9f9ad6c26",
+      "sha256": "cab1c055cf4dbad6a89b4527e2ef3d138131b6742eaf21bd8b4338a9ee2febf4"
+    },
+    {
+      "path": "research/format-limits/scripts/skel.py",
+      "usage": "input",
+      "git_blob": "e3c6c815b604dd41d3807c78917806ae4a5c08a7",
+      "sha256": "9cfbc1316389a46922765cdae85fdde2042f7681986d1c97a19174c4922ea29c"
+    }
+  ]
+}

research/eisenstein-phase-cost-screen/TASK.json

@@ -0,0 +1,72 @@
+{
+  "schema_version": 1,
+  "task_id": "complex-rank-shape-decoder",
+  "priority_revision": 3,
+  "base_commit": "d78fe4bbb6f6b769e39586f8bb3ba8c31a31fd3a",
+  "original_card": {
+    "id": "complex-rank-shape-decoder",
+    "question": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?",
+    "starting_points": [
+      "research/complex-local-word-ceiling/README.md",
+      "research/complex-decoder-field-extension-seed44/README.md",
+      "research/complex-frame-pair-decoders/README.md"
+    ],
+    "methods": [
+      "Find one exact small decoding identity whose frame path climbs in blocks, and price its complete per-call profile.",
+      "Bound the best effective child rank achievable for one fixed support alphabet, including copies, frames and restoration."
+    ],
+    "acceptance_gate": "A per-call local profile, with all copied information, frames and restoration counted, whose ceiling exceeds the selected word's by at least 5%; masked or overcomplete supports must change an assumption of the eight-term all-pairs bound.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "research/complex-local-word-ceiling/verify.py"
+      ],
+      "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING",
+      "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.",
+      "scope": "Positive control and planning budget only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin. Ideal budget: rank-16 delivery is 2.31x (levers.py).",
+    "bottleneck_link": "Rank-1 children are about half of recursive cost; the selected word's effective child rank is about 3.9. Larger-rank delivery lowers recursive cost per unit of paid mass.",
+    "allowed_variations": [
+      "One masked, overcomplete or block decoder family with exact labels and supports.",
+      "A scoped lower bound on effective rank for one alphabet.",
+      "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope."
+    ],
+    "scope_change_triggers": [
+      "Repacking idle remainders of an unchanged word (covered by the packing ceiling).",
+      "Repeating the eight-term all-pairs search inside its proved scope."
+    ],
+    "overlap_terms": [
+      "rank shape",
+      "block climb",
+      "masked decoder",
+      "overcomplete",
+      "effective rank"
+    ]
+  },
+  "scope_status": "unchanged",
+  "actual_scope": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?",
+  "scope_change_reason": null,
+  "bottleneck_link": "Rank-1 children are about half of recursive cost, so decoder copy cost is the lever this card targets. This package prices the Eisenstein (F4/Eisenstein-phase) decoder route under the inherited accounting: the certified necessary-condition screen says any beating supplier needs total copy cost C <= 31 at some stage count (sup bracket 31.0635 at s=7, window h=7; h=10 gives C <= 29 at s <= 35), while every clean support alphabet costs exactly 40 (two independent sharp witnesses). The route therefore survives only if a non-clean decoder with C <= 31 exists; the prize is capped by the selected assembly's bit side at kappa <= 1733427039589844234749/1001733427039589844234749 = 0.001730427469823602 (+3.45% over the selected 0.001672660197076918).",
+  "budget_minutes": 240,
+  "stop_rule": "Stop when (a) the certified threshold screen covers every legal window h in [7,40] and every odd stage count s (scan plus exact rational tail closure), (b) the clean-class floor 40 is proven with sharp witnesses, and (c) negative controls pass; or immediately if a candidate supplier beats the screen, or if the screen's assumptions are contradicted by an existing result.",
+  "outcome": "partial",
+  "evidence": "research/eisenstein-phase-cost-screen/verify.py passes in ~21s (Python 3.12, stdlib only, no randomness): Part A replays the 240-root geometry (40 lines, flat census 1/40/240/90/360/40/1, all line-spanned flats nonsingular, a 7-clique exists so any legal pattern has rank >= 7). Part B proves the clean-class floor: on all 7033 clean ordered flat pairs the per-rectangle charge equals |R cap A| (tight everywhere), and two independent pattern-legal witnesses cost exactly 40 (ten orthogonal 4-line frames; 40 clean stars). Part C certifies, for every window h in [7,40] and every odd s, closed-form rational brackets on the exact copy-cost threshold C*(s,h) (the beat condition is linear in C), with direct certified confirmation and an exact rational tail closure (binomial-series increment bound, exact partial sums to P=200, exact quadratic minimum beyond) covering all s beyond the closure point; sup over the screen is 31.063467310837773 at s=7 h=7, so any beating supplier needs C <= 31 at s <= 61 (h=7 row; h=10: C <= 29 at s <= 35). Part D shows every screen argmax point clears the selected bit side 0.001733427039589844, so the prize is capped at kappa <= 0.001730427469823602 (+3.45%). Part E: four negative controls (closed-form/direct cross-validation, doubled-b flip, tampered-pattern census change, naive-partition illegality and star self-loop sensitivity). Not done: no supplier was built; the non-clean window C in [22,31] is open; no kappa changed.",
+  "author": "Maximus Putnam (@Maximooch), with substantial Penguin (OpenAI) assistant assistance in mathematics, implementation, checking and writing",
+  "ai_assistance": "Penguin (OpenAI) coding/math agent: derived the closed-form threshold brackets and tail closure, wrote verify.py and this package, and ran all checks; every claim is backed by the exact verifier output. No other AI tools used.",
+  "open_questions": [
+    {
+      "question": "Does a pattern-legal 40x40 F2-valued decoder exist with total copy cost C <= 31 whose support is NOT clean (i.e. some clean-class hypothesis fails), and does its full frame/restoration bill stay within the screen?",
+      "why_it_matters": "The screen is a necessary condition: the entire remaining upside of the Eisenstein phase route lives in the non-clean window C in [22,31] at s <= 61. Settling it either yields the first Eisenstein-supplied assembly (kappa up to the bit cap 0.001730427469823602) or closes the route under the current accounting.",
+      "first_step": "Extend the clean-class dichotomy: enumerate minimal non-clean supports (a nonorthogonal pair read by a common rectangle) and certify their minimum copy cost with the same pairing-rank machinery; if the minimum exceeds 31 the route is closed.",
+      "blocked_by": "nothing"
+    },
+    {
+      "question": "Can the quadratic-phase normal form (PR #831) actually realize a candidate decoder's phase labels on nondegenerate alternating blocks at the frame level required by the assembly template?",
+      "why_it_matters": "PR #831 removed the interface obstruction at the trace-form level, but no one has checked that a concrete cheap decoder's labels compile through the alternating-compatible normal form without extra frames or adapters that would break the C <= 31 budget.",
+      "first_step": "Take the cheapest abstract decoder surviving the screen (if any) and run the f4-alternating-interface compilation on its labels, charging every added frame.",
+      "blocked_by": "the non-clean window question"
+    }
+  ]
+}

research/eisenstein-phase-cost-screen/VERIFY.json

@@ -0,0 +1,24 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/community-frontier1094-audit/ASSEMBLY.json",
+    "research/community-frontier1094-audit/INDEPENDENT1094.json",
+    "research/eisenstein-clique-copy-bound/geometry.py",
+    "research/format-limits/scripts/cert.py",
+    "research/format-limits/scripts/skel.py"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Replays the E8 root geometry and flat census, proves the clean-class floor 40 with two sharp witnesses, certifies the Eisenstein copy-cost threshold screen over all windows h in [7,40] and all odd stage counts (closed-form rational brackets plus exact tail closure), checks the bit-side prize cap, and runs four negative controls; prints PASS_EISENSTEIN_PHASE_COST_SCREEN."
+    }
+  ]
+}