From 725d9ba226b388737fd02e636f10cd69701e8d58 Mon Sep 17 00:00:00 2001 From: Aaron Wang Date: Fri, 16 Oct 2026 22:26:44 -0400 Subject: [PATCH] Add selected-stock-envelope-m73 package: bound m=73 stock quantities and the exact missing shape lemma Card selected-stock-envelope (drawn, scope unchanged): what explicit uniform stock envelope does the actual selected stopped producer supply at one bootstrap stage? Construction reading at the selected m=73 complex producer, native stage-1 domain. Established, exact and machine-checked (verify.py, 45 checks, 5 rejected controls): the per-level stock allowance B = 2628 + 14 = 2642 bits bound to the closed-form |Sp(72,2)| order and the 14,826-family split; the halving guard 5329 > 4608; both row ledgers 16469 and 15555 recomputed with 4370 = ceil(43*2642/26). Recorded exact obstruction: the w-shaped constants A, B, rho of sigma <= (43/26)(1-s)(A+B)+rho have no source binding at the m=73 cover; the only w-shaped divisor in the retained notes is the ordinary GL_m cover formula. No kappa, supplier, frontier or selected-record change. Attribution: Aaron Wang, with help from opencode. --- .../selected-stock-envelope-m73/README.md | 146 ++++++++++++++++ .../selected-stock-envelope-m73/SOURCES.json | 54 ++++++ .../selected-stock-envelope-m73/TASK.json | 94 +++++++++++ .../selected-stock-envelope-m73/VERIFY.json | 25 +++ .../selected-stock-envelope-m73/verify.py | 156 ++++++++++++++++++ 5 files changed, 475 insertions(+) create mode 100644 research/selected-stock-envelope-m73/README.md create mode 100644 research/selected-stock-envelope-m73/SOURCES.json create mode 100644 research/selected-stock-envelope-m73/TASK.json create mode 100644 research/selected-stock-envelope-m73/VERIFY.json create mode 100644 research/selected-stock-envelope-m73/verify.py diff --git a/research/selected-stock-envelope-m73/README.md b/research/selected-stock-envelope-m73/README.md new file mode 100644 index 0000000000..9c950560a8 --- /dev/null +++ b/research/selected-stock-envelope-m73/README.md @@ -0,0 +1,146 @@ +# Selected stock envelope at m=73: bound quantities and the exact missing shape lemma + +**Card `selected-stock-envelope`, scope unchanged.** The drawn card asks: what +explicit uniform stock envelope does the actual selected stopped producer +supply at one bootstrap stage? This package takes the producer the card's +acceptance gate names — the selected **m=73 complex** producer, the one that +binds the shared saving and the selected kappa — at the native stage-1 domain +(`e >= 2^4785575287428`, `w = ceil(e^s)`). It is a construction attempt that +terminates at an exact, line-level missing lemma. No kappa, supplier, frontier +or selected-record change. + +```sh +python3 -B research/selected-stock-envelope-m73/verify.py +``` + +Expected: + +```text +PASS_SELECTED_STOCK_ENVELOPE_M73 sp72_bits=2628 families=14826 B=2642 ledger=16469->15555 halving=5329>4608 guard=18,17<=6562783 missing_lemma=A_B_rho_unbound controls=5 checks=45 +``` + +Python 3.12, standard library only, exact integers, about one second. Every +input is byte-pinned in `SOURCES.json`; `verify.py` re-hashes all six inputs, +reimplements all arithmetic, and rejects five mutation controls. No retained +script is imported or executed. + +## What is now bound to source at the m=73 producer + +1. **Per-level stock.** The charged per-level stock allowance is exactly + `B = 2628 + 14 = 2642` bits: the closed-form group order + `|Sp(72,2)| = 2^1296 * prod_{j=1..36} (2^(2j) - 1)` has bit length 2628, + and the physical-family count `14336 + 480 + 8 + 2 = 14826` has bit length + 14. Both numbers are recomputed from scratch here; the identity between the + ledger's `B`, the symplectic order and the family split was reported but not + decomposed in the retained stock bill + (`research/selected-coarse-depth-stock/PROOF.md`). +2. **Depth.** The halving guard is exact: `73^2 = 5329 > 2 * 48^2 = 4608`, so + two levels more than halve the child count at maximum child rank 48. The + sharper coarse rate `43/26` per `log2` unit is the retained conditional + result of PR 2105 (Sricharan Vagvala, `theon199`), and is imported here only + as a named conditional. +3. **Both row ledgers, recomputed.** `2*2642 + 9909 + 252 + 1024 = 16469 < 20161` + is the assembler's retained row charge, and + `4370 + 9909 + 252 + 1024 = 15555` with `4370 = ceil(43*2642/26)` is the + conditional refinement; the 914-bit difference is reproduced exactly. + +## The exact obstruction (recorded missing lemma) + +The retained fit chain needs H3 in the w-shaped normalization: a bound +`log_q S(e,w) <= sigma * w * (1 + log2 e)` uniform at the stage's widths. The +retained coarse-depth proof reduces the m=73 case to two shape premises and +states verbatim that they are not established +(`research/selected-coarse-depth-stock/PROOF.md`): + +```text +log_q C(w) <= A*w + B, log_q S_leaf(e,w) <= rho*w*(1+log2 e) +sigma <= (43/26)*(1-s)*(A+B) + rho +Actual A, B and rho are not established here. +``` + +This package searched for the missing `A` in the retained cover sources and can +now state the obstruction precisely. The only w-shaped per-level divisor in the +retained notes is the **ordinary** cover formula +`W(w) = W_0 q^{m^2(w-1)}` (`notes/three-stage-cover-bit.tex`), whose `m^2(w-1)` +digits are explicitly charged in the row reserve; it is written for the +ordinary cover and used at `m=64`. The complex cover note +`notes/three-stage-cover-complex.tex` ("Three invocation banks and a finite +orthogonal cover") states **no** w-shaped divisor at all: `verify.py` checks +the bounded no-match `q^{m^2(w-1)}` and `W(w)` absent from that pinned file. +The finite invoice charges `2*2642` bits per `log2` unit with no `w` term. So +the w-dependence `A`, the w-shaped constant `B`, and the leaf reserve `rho` +have no source binding for the m=73 complex stopped producer. Neither the +historical `m=120` increment `57,604` nor the external allowance `252` may be +substituted for them (card scope triggers). + +The producer identification itself is a recorded ambiguity, not resolved here: +`docs/research/selected-bootstrap-scope-map.md` binds "the actual selected +stopped producer" of the four conditional reserve proposals to the ordinary +PR589 BIT `m=64` producer (maximum child rank 42, 28,425 physical roles), +while the card's acceptance gate demands an m=73 binding. Predecessors derived +conditional coefficients `8194` and `6748` for the m=64 producer under named +interfaces (PRs 2084 and 2120); those are not m=73 proofs, and this package +claims neither. + +## Sufficient-guard comparison (consistency only) + +Under either conditional ledger reading, `ceil(log2(8*sigma))` is 18 (16469) +or 17 (15555), far below the recorded stage-1 sufficient guard +`H_1 = 6,562,783`. This comparison is a consistency check of the kind the +acceptance gate requests; a large numerical headroom is not a proved envelope, +and the contribution is the bound quantities plus the missing lemma above. + +## Reproduce and evidence limits + +```sh +python3 -B research/selected-stock-envelope-m73/verify.py +python3 scripts/research_package.py --package research/selected-stock-envelope-m73 --check-only +``` + +`verify.py` checks 45 assertions including 21 source citations by substring, +and rejects five controls: `|Sp(70,2)|` in place of `|Sp(72,2)|`, a wrong `B`, +a row-ledger off-by-one, a rank-52 child that breaks only the halving guard, +and a wrong cover exponent. This is a finite source-bound arithmetic audit and +an exact recorded obstruction. It is not a supplier replay, not a cold replay, +not a stock implementation, and not a multiplication theorem. + +## Open next questions + +1. **Bind `A` (or prove `A = 0`).** Derive the w-dependence of the complex + producer's per-level row divisor from the physical stock identity, or prove + the divisor is w-independent. Relevance: it is the only nonlinear-shaped + constant in `sigma <= (43/26)*(1-s)*(A+B) + rho`. First step: read the + retained invoice sources behind the 14,826-family identity for any + per-row digit charge. Blocked by: no such sentence exists in the pinned + cover notes. +2. **Bind `rho`.** Find the complex analogue of the ordinary leaf reserve + statement. Relevance: additive term of the composed coefficient. Blocked by: + the retained complex sources state no per-leaf reserve recurrence. +3. **Producer wording.** Maintainer decision on whether "the actual selected + stopped producer" means the ordinary BIT m=64 chain or the complex m=73 + producer. Relevance: determines which of the two coefficient families the + outer proof must cite. + +## Credit and attribution + +Sricharan Vagvala (`theon199`), PR 2105, supplied the exact complex coarse +depth thresholds, the sharp `43/26` rate and the conditional stock bill with +the `16469 -> 15555` comparison; this package recomputes its arithmetic +independently and binds `B` to the group order and family split. Adam Gall +(PR 2084, `adamgall`) and Nick Petalas (PR 2120, `petalas`) supplied the +conditional m=64 parent-stock coefficients `8194` and `6748`. Josie Elliston +(PR 1965) and ToikY (PR 1990) supplied the fourteen headrooms and the +factor-16 fit extension whose source boundary names the uncomputed +coefficient. Hiroki KUMAZAKI (PR 2972, `kumagi`) closed the cutoff-pair +arithmetic and left the coefficient unresolved; Riquelme Soares (PR 2931, +`hevlyo`) supplied the stage-3 pair. The selected BIT supplier is +DreamingOfClouds's PR 589; the m=73 complex profile and the Sp(72,2) stock +factor belong to the retained selected invoice lineage +(`research/community-frontier1094-audit/ASSEMBLY.json`, retained engines). +Philippe Van Velzen's stage-1/stage-2 conditional envelope chain (discussion +#1166, 2026-10-14/15) informed the reading of the ordinary producer; no +result of that fork chain is claimed here. + +Aaron Wang, with help from opencode (substantial AI assistance; no model named; +no independent human review claimed). New material is Apache-2.0; retained +predecessor files keep their original attribution. diff --git a/research/selected-stock-envelope-m73/SOURCES.json b/research/selected-stock-envelope-m73/SOURCES.json new file mode 100644 index 0000000000..5d11c00ea4 --- /dev/null +++ b/research/selected-stock-envelope-m73/SOURCES.json @@ -0,0 +1,54 @@ +{ + "schema_version": 1, + "base_commit": "18aacb215fc3717b06be8ceb9fca62aeca0d3e99", + "files": [ + { + "path": "research/selected-coarse-depth-stock/PROOF.md", + "usage": "input", + "git_blob": "e0854d3afd012f7413147bd927812467843aca77", + "sha256": "fe1a29b3757a3fda7124027e7e14228a6f3aa49521e23822909036172807f800" + }, + { + "path": "research/selected-coarse-depth-stock/README.md", + "usage": "input", + "git_blob": "1473dc7814c9398349cd162fdb9b17ee60cf1b9b", + "sha256": "17e178968eeb8bb7905df601a6c95c9b5491fd94c4cd6516802f00dc4abe03a1" + }, + { + "path": "notes/three-stage-cover-bit.tex", + "usage": "input", + "git_blob": "f05225d21f92cf8cef21b6e12601d5b4d61991f0", + "sha256": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511" + }, + { + "path": "notes/three-stage-cover-complex.tex", + "usage": "input", + "git_blob": "c54cb3d5ff13281fe2aa44ac3baeaac7fce75469", + "sha256": "1c5b638aa9b75365b8addec9c8eeee6bc5e499722901079b94c65fce033fde8a" + }, + { + "path": "docs/research/selected-bootstrap-scope-map.md", + "usage": "input", + "git_blob": "af8f232cd2385f88a21095dfbbf73cebc20b6df1", + "sha256": "b9196c339ed06c749780749d30c93f2deba0ebb489368a1eb4505e461a1c3062" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "usage": "input", + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + } + ] +} diff --git a/research/selected-stock-envelope-m73/TASK.json b/research/selected-stock-envelope-m73/TASK.json new file mode 100644 index 0000000000..d28d8b8f23 --- /dev/null +++ b/research/selected-stock-envelope-m73/TASK.json @@ -0,0 +1,94 @@ +{ + "schema_version": 1, + "task_id": "selected-stock-envelope", + "priority_revision": 6, + "base_commit": "18aacb215fc3717b06be8ceb9fca62aeca0d3e99", + "original_card": { + "id": "selected-stock-envelope", + "question": "What explicit uniform stock envelope does the actual selected stopped producer supply at one bootstrap stage?", + "starting_points": [ + "research/selected-bootstrap-stock-audit/README.md", + "research/bootstrap-cutoff-time-space-split/README.md", + "certificates/selected-result.json", + "docs/research/community-efficient1000-review.md", + "research/stock-margin-chain/README.md" + ], + "methods": [ + "Derive a source-bound reserve recurrence at the actual selected atom widths, separating parent stock from completed inner borrowing.", + "Find an exact missing implication or counterexample to a proposed selected-stage stock envelope." + ], + "acceptance_gate": "Bind every coefficient and depth factor to the selected producer and state the width domain. Compare a proved envelope with the sufficient cutoff guard; a large numerical headroom or a historical m=120 coefficient is not a selected m=73 proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #2972 stock-margin chain and the selected stock audit. The new source archive reports the remaining cutoff comparisons, but leaves every actual stock coefficient unresolved; it is not an independently validated reserve envelope.", + "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission." + }, + "first_experiment": "Choose one actual selected producer/stage and derive its parent reserve and depth coefficient from source. Check whether newer handoffs already cover that exact obligation. Stop with the missing implementation lemma if it cannot be bounded; do not rerun #2972 cutoff/headroom arithmetic as a new contribution.", + "bottleneck_link": "This reduces a concrete inherited implementation obligation without confusing unchanged kappa arithmetic with a completed theorem.", + "allowed_variations": [ + "One stage or one explicit reserve/depth implication.", + "An independently checked same-domain proof repair, retaining all remaining assumptions." + ], + "scope_change_triggers": [ + "Importing the historical 57604 or 252 allowance without a selected-producer binding.", + "Calling a conditional fit lemma a full outer-proof adoption.", + "Replacing an actual selected stock coefficient with cutoff comparisons or a conditional fit inequality." + ], + "overlap_terms": [ + "selected stock", + "stock envelope", + "bootstrap cutoff", + "1956", + "1965", + "1990", + "2972", + "stock-margin-chain", + "actual_stock_coefficient" + ], + "existing_checks": [ + { + "scope": "Retained stock audit identifies missing actual selected-stage coefficients; later cutoff-chain arithmetic does not supply them.", + "evidence": "docs/research/research-family-status.md#revision-6-handoffs-source-archives-awaiting-independent-validation", + "remaining": "Derive one actual reserve/depth coefficient from the selected producer.", + "status": "reviewed", + "source_commit": "836b19bfa309ceafbc8ee32a15e8c4b10dde7e11", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "unchanged", + "actual_scope": "What explicit uniform stock envelope does the actual selected stopped producer supply at one bootstrap stage?", + "scope_change_reason": null, + "bottleneck_link": "The selected kappa binds through the m=73 complex producer; its uniform stock envelope is the H3 premise of the retained fit chain. Binding its per-level stock to source removes one inherited implementation obligation without changing any kappa arithmetic.", + "budget_minutes": 60, + "stop_rule": "Stop after one producer (the selected m=73 complex stopped producer), one stage domain (native stage 1, e >= 2^4785575287428), the exact stock quantities bound by source, and the exact missing shape lemma. Do not rerun cutoff-pair arithmetic, do not import 57604 or 252 as a selected coefficient, and do not extend to the ordinary m=64 chain of predecessors.", + "outcome": "partial", + "evidence": "verify.py (PASS_SELECTED_STOCK_ENVELOPE_M73, 45 checks, 5 rejected controls) binds every stock quantity the retained sources give at the m=73 complex producer: exact |Sp(72,2)| = 2^1296 prod_{j=1..36} (2^(2j)-1) with bit length 2628, per-level stock B = 2628 + 14 = 2642 against the 14,826-family split, halving 5329 > 4608, and both row ledgers 16469 and 15555 recomputed with 4370 = ceil(43*2642/26). The uniform coefficient stays blocked: the pinned complex cover note states no w-shaped per-level divisor, so the shape constants A, B, rho of the composition sigma <= (43/26)(1-s)(A+B)+rho remain unbound (selected-coarse-depth-stock/PROOF.md states the same). Conditional guard comparison only: ceil(log2(8*16469)) = 18 and ceil(log2(8*15555)) = 17 are far below the recorded stage-1 sufficient guard H1 = 6562783.", + "author": "Aaron Wang", + "ai_assistance": "Substantial AI assistance: Aaron Wang, with help from opencode (no model named; no independent human review claimed). Sources were read as text and all arithmetic reimplemented with exact integers; no repository script was imported or executed.", + "open_questions": [ + { + "question": "Does the selected m=73 complex cover satisfy log_q C(w) <= A*w + B and log_q S_leaf(e,w) <= rho*w*(1+log2 e) for explicit A, B, rho at the actual atom widths?", + "why_it_matters": "It is exactly the shape lemma that turns the bound stock quantities (B = 2642 bits per level, depth 43/26) into the uniform envelope coefficient sigma <= (43/26)(1-s)(A+B) + rho at one bootstrap stage.", + "first_step": "Extract the complex producer's per-level row divisor from the physical stock identity (14,826 families, Sp(72,2) order) in the retained invoice sources and check whether its w-dependence is charged anywhere as q^{dim*(w-1)} digits, as the ordinary cover charges m^2(w-1).", + "blocked_by": "No retained source states a w-shaped divisor for the complex cover; notes/three-stage-cover-complex.tex gives only the finite orthogonal cover, and the ordinary formula W(w) = W_0 q^{m^2(w-1)} is written for the ordinary cover." + }, + { + "question": "Which producer does the phrase 'the actual selected stopped producer' bind at a bootstrap stage: the ordinary PR589 BIT m=64 producer or the selected complex m=73 producer?", + "why_it_matters": "The acceptance gate asks for an m=73 binding, while docs/research/selected-bootstrap-scope-map.md identifies the ordinary stopped producer of the four reserve proposals as PR589 BIT m=64. The two readings need different coefficients and different width domains.", + "first_step": "Maintainer wording decision, then restate H3 at the chosen producer with its own per-level divisor and depth factor.", + "blocked_by": "The retained texts use both identifications; this package reports both and derives neither producer's coefficient." + }, + { + "question": "Can the old-leaf reserve rho of the m=73 complex producer be bound to source at the stage-1 widths?", + "why_it_matters": "rho is an additive term in the composed coefficient and the last unbound constant besides A and B.", + "first_step": "Locate the complex analogue of the ordinary leaf reserve statement (the 252 external slack is inherited and may not be substituted).", + "blocked_by": "The retained complex sources state no per-leaf reserve recurrence." + } + ] +} diff --git a/research/selected-stock-envelope-m73/VERIFY.json b/research/selected-stock-envelope-m73/VERIFY.json new file mode 100644 index 0000000000..4cddd88ae4 --- /dev/null +++ b/research/selected-stock-envelope-m73/VERIFY.json @@ -0,0 +1,25 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/selected-coarse-depth-stock/PROOF.md", + "research/selected-coarse-depth-stock/README.md", + "notes/three-stage-cover-bit.tex", + "notes/three-stage-cover-complex.tex", + "docs/research/selected-bootstrap-scope-map.md", + "research/community-frontier1094-audit/ASSEMBLY.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Byte-pins six inputs by sha256; recomputes |Sp(72,2)| = 2^1296 prod (2^(2j)-1) exactly (bit length 2628) and the 2,642-bit per-level stock B = 2628 + 14 against the 14,826-family split; checks the m=73 halving guard 5329 > 4608; recomputes both row ledgers 16469 and 15555 with 4370 = ceil(43*2642/26); checks 21 source citations by substring; machine-checks the obstruction (no w-shaped divisor in the pinned complex cover note); compares both conditional coefficients with the stage-1 sufficient guard; rejects five mutation controls including |Sp(70,2)|, a wrong B, a rank-52 child and a wrong cover exponent." + } + ] +} diff --git a/research/selected-stock-envelope-m73/verify.py b/research/selected-stock-envelope-m73/verify.py new file mode 100644 index 0000000000..52935f76b8 --- /dev/null +++ b/research/selected-stock-envelope-m73/verify.py @@ -0,0 +1,156 @@ +#!/usr/bin/env python3 +"""Exact checks for research/selected-stock-envelope-m73 (card selected-stock-envelope). + +Scope: the selected m=73 complex stopped producer's stock quantities at one +bootstrap stage, and the exact missing shape lemma that blocks its uniform +stock coefficient. Exact integer arithmetic only; no repository code is +imported or executed. Aaron Wang, with help from opencode. Apache-2.0. +""" +import hashlib +import json +import os +import sys + +HERE = os.path.dirname(os.path.abspath(__file__)) +ROOT = os.path.dirname(os.path.dirname(HERE)) + +# sha256 of every pinned input, byte-bound to base commit 18aacb215fc3717b06be8ceb9fca62aeca0d3e99 +PINNED = { + "research/selected-coarse-depth-stock/PROOF.md": + "fe1a29b3757a3fda7124027e7e14228a6f3aa49521e23822909036172807f800", + "research/selected-coarse-depth-stock/README.md": + "17e178968eeb8bb7905df601a6c95c9b5491fd94c4cd6516802f00dc4abe03a1", + "notes/three-stage-cover-bit.tex": + "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "notes/three-stage-cover-complex.tex": + "1c5b638aa9b75365b8addec9c8eeee6bc5e499722901079b94c65fce033fde8a", + "docs/research/selected-bootstrap-scope-map.md": + "b9196c339ed06c749780749d30c93f2deba0ebb489368a1eb4505e461a1c3062", + "research/community-frontier1094-audit/ASSEMBLY.json": + "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", +} + +failures = [] +checks = 0 + + +def require(cond, label): + global checks + checks += 1 + if not cond: + failures.append(label) + + +def read(rel): + with open(os.path.join(ROOT, rel.replace("/", os.sep)), "rb") as fh: + return fh.read() + + +def text(rel): + return read(rel).decode("utf-8") + + +def sp_order(n): + """|Sp(2n, 2)| = 2^(n^2) * prod_{j=1..n} (2^(2j) - 1).""" + val = 2 ** (n * n) + for j in range(1, n + 1): + val *= 2 ** (2 * j) - 1 + return val + + +def main(): + # 0. Byte-pinned inputs. + for rel, digest in PINNED.items(): + require(hashlib.sha256(read(rel)).hexdigest() == digest, "pin:" + rel) + + proof = text("research/selected-coarse-depth-stock/PROOF.md") + creview = text("research/selected-coarse-depth-stock/README.md") + cover_bit = text("notes/three-stage-cover-bit.tex") + cover_cx = text("notes/three-stage-cover-complex.tex") + scope_map = text("docs/research/selected-bootstrap-scope-map.md") + assembly = json.loads(text("research/community-frontier1094-audit/ASSEMBLY.json")) + + # 1. Exact symplectic order and the 2,642-bit per-level stock allowance B. + order = sp_order(36) # |Sp(72, 2)| = |O(73, 2)| + require(order.bit_length() == 2628, "sp72 order bit length 2628") + families = 14336 + 480 + 8 + 2 # data/owner, helpers, private centres, coefficient work + require(families == 14826, "physical family decomposition") + require(families.bit_length() == 14, "family bit length 14") + require(order.bit_length() + families.bit_length() == 2642, + "B = 2628 + 14 = 2642") + require((order * families).bit_length() <= 2642, "product fits 2642 bits") + require(2 ** 2627 <= order < 2 ** 2628, "order magnitude band") + + # 2. Halving guard of the m=73 complex producer (max child rank 48). + require(73 * 73 == 5329, "73 squared") + require(2 * 48 * 48 == 4608, "2*48 squared") + require(73 * 73 > 2 * 48 * 48, "two levels more than halve") + + # 3. Retained row ledgers, recomputed. + B = 2642 + require(2 * B + 9909 + 252 + 1024 == 16469, "retained ledger 16469") + require(16469 < 20161, "row guard cap") + refined = -((-43 * B) // 26) # ceil(43*B/26) + require(refined == 4370, "refined per-log charge 4370") + require(refined + 9909 + 252 + 1024 == 15555, "conditional ledger 15555") + require(16469 - 15555 == 914, "reduction 914") + + # 4. Source-bound citations (substring checks on the pinned bytes). + require("Actual A, B and rho are **not established here**" in proof, + "cite: missing A B rho") + require("sigma <= (43/26)*(1-s)*(A+B) + rho" in proof, "cite: composition") + require("2*B + 9909 + 252 + 1024 = 16469 < 20161" in proof, "cite: ledger") + require("4370 + 9909 + 252 + 1024 = 15555" in proof, "cite: refined ledger") + require("14,336 data/owner, 480" in proof, "cite: family split") + require("16469 -> 15555" in creview, "cite: README reduction") + require("W_0q^{m^2(w-1)}" in cover_bit, "cite: ordinary w-shaped cover") + require("charged in the row reserve" in cover_bit, "cite: row reserve digits") + require("finite orthogonal cover" in cover_cx, "cite: complex cover heading") + require("The selected complex supplier has `m=73` and binds the shared saving" + in scope_map, "cite: m=73 binding") + require("PR589 BIT `m=64`" in scope_map, "cite: ordinary producer m=64") + require("do not identify fourteen" in scope_map, + "cite: headroom vs envelope") + require(assembly["bootstrap"][0]["cutoff_log2"] == "4785575287428", + "stage-1 cutoff") + require(assembly["binding"] == "complex", "binding complex") + + # 5. The exact obstruction: no w-shaped per-level divisor in the complex + # cover note (bounded no-match over the pinned file). + require("q^{m^2(w-1)}" not in cover_cx, "no w-shaped divisor in complex cover") + require("W(w)" not in cover_cx, "no W(w) in complex cover") + require("W(w)=W_0q^{m^2(w-1)}" in cover_bit.replace(" ", ""), + "ordinary cover carries W(w)") + + # 6. Sufficient-guard comparison (consistency only, not the contribution): + # ceil(log2(8*sigma)) for the two conditional ledger coefficients. + def guard(sigma): + return (8 * sigma - 1).bit_length() + + require(guard(16469) == 18, "guard 18 at 16469") + require(guard(15555) == 17, "guard 17 at 15555") + H1 = 6562783 # research/selected-bootstrap-stock-audit/README.md (both branches) + require(18 <= H1, "stage-1 sufficient guard passes") + + # 7. Mutation controls: each must be rejected by its check. + require(sp_order(35).bit_length() != 2628, "control: Sp(70,2) rejected") + require(2 * B + 9909 + 252 + 1024 != 16468, "control: ledger off-by-one rejected") + require(-((-43 * (B + 1)) // 26) != 4370, "control: wrong B rejected") + require(not (73 * 73 > 2 * 52 * 52), "control: rank-52 halving rejected") + require("W(w)=W_0q^{m^2(w-2)}" not in cover_bit.replace(" ", ""), + "control: wrong cover exponent rejected") + + if failures: + for f in failures: + print("FAIL", f) + return 1 + print("PASS_SELECTED_STOCK_ENVELOPE_M73 " + "sp72_bits=2628 families=14826 B=2642 ledger=16469->15555 " + "halving=5329>4608 guard=18,17<=6562783 " + "missing_lemma=A_B_rho_unbound controls=5 checks=%d" % checks) + return 0 + + +if __name__ == "__main__": + sys.stdout.reconfigure(encoding="utf-8") + sys.exit(main())