From 0e61ddb8d117c6586f5cc1234bb9358c35462142 Mon Sep 17 00:00:00 2001 From: maxime-fleury Date: Fri, 9 Oct 2026 23:01:30 +0200 Subject: [PATCH 01/11] Price rungs 3 and 4 of the bank ladder: kappa = 7.11175695867958e-4, and the complex ledger's top MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Rung 2 binds on the complex supplier and lands on its ceiling, so the ladder can only continue there. Exactly three families of that ledger fill whole width-66 banks: rank 11 (rung 2), rank 16 and rank 20. Pricing the other two with the pinned engine through the unchanged 47-constraint assembly gives rung 3 at 7.10572698755137e-4 and rung 4 at 7.11175695867958e-4 -- +0.4072% over rung 2 and +4.0963% over the #207 frontier -- after which no remaining family has a whole-bank volume, so the accounting ladder terminates. The next wall is the bit word: the rung-1 leaf caps kappa at 7.277251e-4. A priced target, not a witness: C1-C7 and T1 are open, plus #219's inherited R1-R4. 🤖 Generated with Codebuff Co-Authored-By: Codebuff --- research/complex-bank-run3/NOTICE.md | 49 + research/complex-bank-run3/PROOF.md | 110 + research/complex-bank-run3/README.md | 122 + research/complex-bank-run3/SOURCE.json | 25 + research/complex-bank-run3/certificate.json | 353 + research/complex-bank-run3/ledger3.py | 209 + research/complex-bank-run3/obligations.json | 138 + research/complex-bank-run3/pins.py | 34 + ...207-coordinated-crossover.certificate.json | 199 + .../references/pr219-run1/NOTICE.md | 36 + .../references/pr219-run1/PROOF.md | 94 + .../references/pr219-run1/README.md | 90 + .../references/pr219-run1/SOURCE.json | 12 + .../references/pr219-run1/arithmetic.py | 148 + .../references/pr219-run1/banks.py | 104 + .../references/pr219-run1/certificate.json | 270 + .../inputs/absorbed-occurrences.json | 12010 ++++++++++++++++ .../references/pr219-run1/interval_moment.py | 76 + .../references/pr219-run1/obligations.json | 35 + .../pr219-run1/paired_cube_assembly.py | 58 + .../pr193-source-assisted-v4.certificate.json | 599 + .../references/pr200-bit.certificate.json | 4442 ++++++ .../references/pr205-packed.certificate.json | 318 + .../references/pr219-run1/schedule.py | 130 + .../references/pr219-run1/verify.py | 121 + research/complex-bank-run3/run3.py | 396 + research/complex-bank-run3/verify.py | 97 + 27 files changed, 20275 insertions(+) create mode 100644 research/complex-bank-run3/NOTICE.md create mode 100644 research/complex-bank-run3/PROOF.md create mode 100644 research/complex-bank-run3/README.md create mode 100644 research/complex-bank-run3/SOURCE.json create mode 100644 research/complex-bank-run3/certificate.json create mode 100644 research/complex-bank-run3/ledger3.py create mode 100644 research/complex-bank-run3/obligations.json create mode 100644 research/complex-bank-run3/pins.py create mode 100644 research/complex-bank-run3/references/pr207-coordinated-crossover.certificate.json create mode 100644 research/complex-bank-run3/references/pr219-run1/NOTICE.md create mode 100644 research/complex-bank-run3/references/pr219-run1/PROOF.md create mode 100644 research/complex-bank-run3/references/pr219-run1/README.md create mode 100644 research/complex-bank-run3/references/pr219-run1/SOURCE.json create mode 100644 research/complex-bank-run3/references/pr219-run1/arithmetic.py create mode 100644 research/complex-bank-run3/references/pr219-run1/banks.py create mode 100644 research/complex-bank-run3/references/pr219-run1/certificate.json create mode 100644 research/complex-bank-run3/references/pr219-run1/inputs/absorbed-occurrences.json create mode 100644 research/complex-bank-run3/references/pr219-run1/interval_moment.py create mode 100644 research/complex-bank-run3/references/pr219-run1/obligations.json create mode 100644 research/complex-bank-run3/references/pr219-run1/paired_cube_assembly.py create mode 100644 research/complex-bank-run3/references/pr219-run1/references/pr193-source-assisted-v4.certificate.json create mode 100644 research/complex-bank-run3/references/pr219-run1/references/pr200-bit.certificate.json create mode 100644 research/complex-bank-run3/references/pr219-run1/references/pr205-packed.certificate.json create mode 100644 research/complex-bank-run3/references/pr219-run1/schedule.py create mode 100644 research/complex-bank-run3/references/pr219-run1/verify.py create mode 100644 research/complex-bank-run3/run3.py create mode 100644 research/complex-bank-run3/verify.py diff --git a/research/complex-bank-run3/NOTICE.md b/research/complex-bank-run3/NOTICE.md new file mode 100644 index 0000000000..6bf44e65f8 --- /dev/null +++ b/research/complex-bank-run3/NOTICE.md @@ -0,0 +1,49 @@ +# Notice and credits — `research/complex-bank-run3` + +This package is Apache-2.0, in line with the repository, and changes no existing file. It +vendors two inputs byte-identically and pins them by sha256 (`SOURCE.json`); their licences +and notices are retained with them. + +## Vendored inputs + +* `references/pr219-run1/` — **PR219**, `research/residual-bank-run1` (head `237067f`). This is + rung 1 itself: the bit word's rank-22 absorption, the retained-ledger schedule, the exact + interval-moment engine and the 47-constraint balanced assembly. It is imported, never + re-implemented, and this package inherits its obligations R1-R4 verbatim. +* `references/pr207-coordinated-crossover.certificate.json` — **PR207**, + `research/coordinated-crossover-pr200` (head `cd14825`). The frontier certificate: the two + side child ledgers the ladder is priced against and its published `kappa`. Vendored + verbatim. + +## Mechanisms this package uses but does not own + +* **Rung 2 and the ceiling argument** — PR224, `research/complex-bank-run2`: the rank-11 + complex absorption, the fact that rung 1 sits on the complex branch ceiling, and the + identification of the complex supplier as the only way up. This package rebuilds rung 2 + from the pinned profile and reproduces its published grid point exactly; it does not restate + it as new. +* **The bank-absorption ladder and the `10^-10` replica convention** — PR208, + `research/composed-diagonal-bit-bootstrap`: the ladder whose rungs 3 and 4 this package + prices, and the pricing model under which rung 2 reproduces PR208's own published value + `3541457/5*10^9`. +* **The bank proof and the engine chain** — PR200 (Chafik Boukhalfa; bit word and physical + checkers), PR205/PR206 (the completed entrance banks and the packed bit certificate, the + only bank construction in the pins), PR197 (Evan McKinney; the completed-bank machinery), + PR184/PR168-v4 (icekylinx, eumemic; the source-assisted complex word and the physical + paired-cube framework), PR183 (romainhedouin; the closed-form assembly ceiling) and PR193 + (ikeboy; the complex supplier whose profile this ladder is built on). All upstream + attributions, notices and licences stand as published. +* **PR219's own upstream credits** are retained inside the vendored directory, unchanged. + +## What is new here + +The rank-16 and rank-20 absorptions and their exact prices; the exhaustion of the complex +ledger's whole-bank criterion (`66 | r * n_r` holds for exactly three families); the mixed +tiling obligation T1 that the two new families owe and rank 11 did not; the rank-16 and +rank-20 inventory obligations C6 and C7; and the next-step arithmetic showing that +`kappa = 7.2e-4` needs +1.242% more complex saving while anything above `7.277251e-4` needs a +new bit word. + +Prepared by Maxime Fleury with Codebuff assistance. No new kappa is claimed as a record: the +number is a priced target, conditional on C1-C7, T1 and the inherited R1-R4, and the package +says so in its own `status` field. diff --git a/research/complex-bank-run3/PROOF.md b/research/complex-bank-run3/PROOF.md new file mode 100644 index 0000000000..ceb58712e1 --- /dev/null +++ b/research/complex-bank-run3/PROOF.md @@ -0,0 +1,110 @@ +# The argument for rungs 3 and 4, and for the top of the complex ladder + +Everything below is exact rational arithmetic on the pinned complex profile +(`references/pr193-source-assisted-v4.certificate.json`, the word #207's frontier certificate +prices) through the pinned interval-moment engine and the unchanged 47-constraint assembly. +The machine-checked form is `certificate.json`; `verify.py` rebuilds it from pinned bytes. + +## 1. The criterion + +A family of rank `r` with `n` children per vertex occupies `r * n` registers per copy. It can +leave the ledger into whole banks of width `m` only when + + m | r * n (whole-bank volume) + +and the absorption is free rather than a relabelling when the retained ledger still satisfies +the row identity `m * W - rank_mass = deficit` and the stock falls by exactly the bank count. +Those are the conditions PR219's rank-22 bit absorption and PR224's rank-11 complex +absorption satisfy, and the conditions the certified entrance-bank proof satisfies on the bit +word (2,200 rank-60 exteriors: `60 * 6,600 = 396,000 = 72 * 5,500`). + +The criterion is necessary, and it is what the built rungs use. It is not sufficient: a bank +must be tiled by blocks, which for a rank that does not divide the width means a mixture +(obligation T1). Both facts are stated, not blurred: rungs 3 and 4 are priced on the volume +condition and they owe the tiling. + +## 2. Which families qualify, and that is all of them + +On the complex ledger (`m = 66`, one copy `W = 12,052`, deficit `1,320`, 20 families, +213,147 children, rank mass 794,112, largest child 20) the whole-bank volume condition +`66 | r * n_r` selects exactly three families: + +| rank | n_r | r * n_r | = 66 x | +| ---: | ---: | ---: | ---: | +| 11 | 1,062 | 11,682 | 177 | +| **16** | 264 | 4,224 | 64 | +| **20** | 66 | 1,320 | 20 | + +`verify.py` asserts this list, so the claim "exactly three" is machine-checked rather than +eyeballed. After rungs 2-4 all three are out of the ledger, and the eligibility scan on the +retained row is empty -- the criterion cannot be applied again at this width, on this ledger. + +## 3. The ledgers, step by step (three-copy rows) + +| after | W | rank mass | children | largest child | rule applied | +| --- | ---: | ---: | ---: | ---: | --- | +| base | 36,156 | 2,382,336 | 639,441 | 20 | row identity `66 * 12,052 - 794,112 = 1,320` | +| rung 2 (+11) | 35,625 | 2,347,290 | 636,255 | 20 | removed 35,046 = 66 x 531; stock drop 531 | +| **rung 3 (+16)** | **35,433** | **2,334,618** | **635,463** | 19 | removed 12,672 = 66 x 192; stock drop 192 | +| **rung 4 (+20)** | **35,373** | **2,330,658** | **635,265** | 19 | removed 3,960 = 66 x 60; stock drop 60 | + +Every row re-satisfies `66 * W - rank_mass = 3,960` (= three copies of the deficit `1,320`, +unchanged by banking). The deficit is untouched, which is the point: banking moves dirt from +paid children into bank structure, it does not create or destroy rank mass. + +## 4. The prices + +For each rung the complex paid moment is recomputed by the pinned engine on the retained row +(`bit=False`, i.e. without the bit branch's rare-class fallback, exactly as PR219 prices the +complex side), on the `10^-18` grid with the adjacent grid point rejected in both directions: + +| rung | complex coarse saving | grid gap above | +| --- | ---: | ---: | +| base | 7.00918443859411e-4 | — | +| rung 2 | 7.08793603125109e-4 | (PR224, reproduced to the digit) | +| **rung 3** | **7.11077971348264e-4** | adjacent point rejected | +| **rung 4** | **7.11681826686289e-4** | adjacent point rejected | + +The assembly rule is the queue's own: `a = min(bit_leaf, (1-beta) * C - weak)`, +`q = a(1-2 eta)`, `kappa = floor((1-eta) q/(1+q) * 10^18)/10^18`, with +`eta = beta = 10^-24`, `weak = 10^-30`. It prints the same numbers #207, #219 and #224 print +on their own inputs (asserted equal, not within a tolerance), so the convention is calibrated +rather than chosen here. + +| rung | kappa | binding | assembly bound | ceiling gap | +| --- | ---: | --- | ---: | ---: | +| rung 2 | 7.08291570590726e-4 | complex | 7.082915705907269e-4 | 8.6e-19 | +| **rung 3** | **7.10572698755137e-4** | complex | 7.105726987551371e-4 | < 1e-18 | +| **rung 4** | **7.11175695867958e-4** | complex | 7.111756958679581e-4 | < 1e-18 | + +Each rung lands on its own branch ceiling: the complex budget `(1-beta) C - weak` is what the +minimum selects (asserted), the adjacent `10^-18` point is rejected by the unchanged +47-constraint assembly (asserted), and the bit leaf is not the binding branch (recorded). + +## 5. Where the ladder stops, and what the next step costs + +Rung 4 is the top of the accounting ladder: no family of the remaining 17 has a whole-bank +volume (asserted). Two consequences follow, and they are the useful part of the result: + +* **Above the top, the bank mechanism has nothing left to take.** Reaching `kappa = 7.2e-4` + needs a complex coarse saving of `7.2051877e-4`, i.e. +1.242% over the top rung's coarse + saving -- more banking than this ledger's remaining mass can supply at this width. +* **Above `kappa = 7.277251e-4` the bit word is the wall.** While the complex branch caps the + budget, the ceiling is `budget/(1+budget)`, and the budget is in turn capped by #219's + rung-1 bit leaf (7.2825e-4). Targets `7.5e-4`, `8e-4` and `1e-3` are therefore unreachable + on this bit word, whatever the complex ledger does; they need a new bit supplier first. + +## 6. Verification boundary + +* Machine-checked here: the pinned bytes (21 files, sha256), the frontier reproduction, rung 1 + rebuilt by the vendored #219 package, rung 2 rebuilt by this package's own ledger module, + rungs 3 and 4 (volumes, row identities, stock drops, both paid moments, adjacency + rejections), the branch ceilings, the eligibility exhaustion and the PR208 replica. +* **Not** checked here: any physical realization. C1-C7 and T1 are open, and #219's R1-R4 are + inherited open; the complex supplier has no bank construction in the pins + (machine-checked), and neither new family has an occurrence inventory. The kappa is + conditional on all of them, exactly as #219's rung 1 and #224's rung 2 are. +* Not run: upstream CI, and any contributor verifier other than the vendored #219 package + invoked in place. +* The `10^-10` supplier field is priced as a conservative variant; on it the ladder's top sits + lower, because PR193's published `complex_saving` is its coarser-grid value. diff --git a/research/complex-bank-run3/README.md b/research/complex-bank-run3/README.md new file mode 100644 index 0000000000..2534992212 --- /dev/null +++ b/research/complex-bank-run3/README.md @@ -0,0 +1,122 @@ +# Rungs 3 and 4 of the bank ladder: the complex ledger's remainder priced to kappa = 7.11175695867958e-4, and the ladder's top + +**A priced target, not a witness, and the same blocker as rung 2.** This package prices the +rest of the bank ladder above PR224's rung 2 -- two more whole-bank families of the complex +ledger -- and records where the accounting criterion the built rungs use stops. + +## Result + +| Rung | what leaves the ledger | kappa | Binding | Status | +|---|---|---|---|---| +| frontier, #207 | — | `1366380910073/2*10^15` = 0.0006831904550365 | bit | reproduced here **exactly** | +| rung 1, #219 | bit rank-22 bin, 6,116 width-72 banks | `700427501305159/10^18` = 0.000700427501305159 | complex | reproduced here **exactly**, by importing the vendored #219 package | +| rung 2, #224 | complex rank-11 family, 531 banks | `354145785295363/5*10^17` = 0.000708291570590726 | complex | rebuilt here **exactly** by this package's own ledger module | +| **rung 3, this package** | + complex rank-16 family, 192 banks | `710572698755137/10^18` = **0.000710572698755137** | complex | **+0.3221%** over rung 2; blocked (below) | +| **rung 4, this package** | + complex rank-20 family, 60 banks | `355587847933979/5*10^17` = **0.000711175695867958** | complex | **+0.4072%** over rung 2, **+4.0963%** over the frontier; blocked (below) | + +The price is the same ledger in two independent conventions: the `10^-18` grid of the queue's +latest rungs (`eta = beta = 10^-24`, `weak = 10^-30`), and PR208's pricing model +(`stop = 10^-9`, `eta = 10^-8`, `10^-10` grid) as an independent replica -- where rung 2 +reproduces PR208's own published ladder value `3541457/5*10^9`, and rungs 3 and 4 price at +`284229/4*10^8` and `1422351/2*10^9`. + +## Why the ladder is on the complex word, and how far it goes + +Rung 1 already sits on the complex branch's ceiling, so every later rung must raise the +**complex** coarse saving; rung 2 does it once, and lands on the new ceiling in turn. The +criterion that makes such an absorption free is that the family's own volume is a whole +number of banks (`66 | rank * children`), and on this ledger exactly three families satisfy +it: rank 11 (already rung 2), **rank 16** and **rank 20**. Rungs 3 and 4 take the other two. +After them **no family of the remaining 17 has a whole-bank volume**, so the criterion is +exhausted and the complex-side accounting ladder terminates. + +| rank | children per vertex | volume (three copies) | banks (three copies) | share of the ledger's rank mass | +| --- | ---: | ---: | ---: | ---: | +| 11 (rung 2) | 1,062 | 35,046 = 66 x 531 | 531 | 1.471% | +| **16 (rung 3)** | 264 | 12,672 = 66 x 192 | 192 | 0.540% | +| **20 (rung 4)** | 66 | 3,960 = 66 x 60 | 60 | 0.169% | + +Each step is checked rather than relabelled: the volume fills whole banks, the retained +ledger satisfies the row identity `66 * W - rank_mass = 3,960`, and the stock falls by +exactly the bank count. The top row is `W = 35,373`, rank mass `2,330,658`, 635,265 children +in 17 families, largest child 19. + +## What the pins do not provide (the blocker, unchanged from rung 2) + +`obligations.json` states C1-C7 and T1 and inherits #219's R1-R4. The two facts that decide +the status are read from the pins, not asserted: + +* **The complex supplier still has no bank construction.** Its certificate carries no key + containing `bank` at all (`certificate.json` -> `blocked_on`, machine-checked), and neither + does #207's frontier certificate. The only banked word in the pins is the **bit** word's + entrance-gauge pack (#205: 45,842 banks, width 72, rank-60 exteriors), a mechanism specific + to that word's entrance structure. +* **The new families have no inventory.** Nothing enumerates the complex word's rank-16 or + rank-20 children, exactly as nothing enumerates its rank-11 family or #219's rank-22 bin + before its own inventory was written. A rung that cannot name its items cannot be built. + +One further obligation is specific to rungs 3 and 4 and worth stating precisely because it is +**not** a construction: rank 11 divides the bank width (`66 = 6 * 11`) and needed no mixture, +but `66 = 4 * 16 + 2` and `66 = 3 * 20 + 6`, so the rank-16 and rank-20 blocks cannot tile a +66-wide bank alone. Their banks must mix block sizes (T1), which is the same obligation #219 +carries for the bit word as R1 -- admissible tilings of width 72 over families {4, 24, 22} -- +with no analogous enumeration to inherit. + +## What the top rung implies for the next step + +While the complex branch caps the budget, the assembly's ceiling is `budget/(1+budget)` with +the budget capped in turn by the bit leaf of #219's rung-1 bit word (7.2825e-4). So: + +* reaching `kappa = 7.2e-4` needs a complex coarse saving of `7.2051877e-4`, i.e. **+1.242%** + over the top rung's own coarse saving -- more banking than this ledger contains; +* reaching `7.5e-4`, `8e-4` or `1e-3` is **impossible on this bit word**: the leaf caps kappa + at `1819302815717/25*10^16 = 7.277251...e-4` there, so those targets need a new bit word + before any complex-side work can matter. + +## Verify + +```sh +cd research/complex-bank-run3 +python3 -B verify.py # check: pins, rebuild, compare with certificate.json +python3 -B verify.py --write # authoring: regenerate certificate.json and SOURCE.json +``` + +`verify.py` passes with exit 0, pins 21 files by sha256, rebuilds the whole complex-side +ladder (base, rung 2, rungs 3 and 4), both paid moments per rung, the two 47-constraint +assemblies with adjacent-grid rejection, the eligibility scan and the PR208 replica, and +reproduces #207's, #219's and #224's published grid points exactly. The vendored rung-1 +package also self-verifies in place: + +```sh +cd research/complex-bank-run3/references/pr219-run1 && python3 -B verify.py +``` + +## Scope and limits + +* **This is a priced target, not a witness.** The accounting is certified; C1-C7, T1 and the + inherited R1-R4 are open, so the kappa is conditional on them in exactly the sense #219 + states for rung 1 and #224 for rung 2. It is not an unconditional multiplication theorem, + not a practical multiplier, and not a Lean/kernel certificate. +* The whole-bank volume condition is necessary and is the criterion the built rungs use; it + is not sufficient on its own for the two new families, which owe T1's tiling. +* Nothing here bounds any *other* complex-side lever: the ladder is over this supplier's + child ledger at this bank width. A different word, width or frame layout is not priced. +* The ladder inherits every interface #207/#219/#224 inherit (all-size compiler, weighted and + restored selector, routing/layout, fixed-tape leaf, prime supply, precision/recovery, + analytic transfer). +* The `10^-10` supplier field (PR193's published `complex_saving = 219037/312500000`) is + priced too, in `certificate.json` -> `conservative_variant`, rather than ignored. + +## Credits + +Rung 1, its retained-ledger schedule, the interval-moment engine and the 47-constraint +assembly are **PR219** (`research/residual-bank-run1`, head `237067f`) -- vendored +byte-identically under `references/pr219-run1/` and imported, not re-implemented; the frontier +floor and the complex ledger's own shape are **PR207** (`research/coordinated-crossover-pr200`, +head `cd14825`), whose certificate is vendored verbatim; rung 2 and the ceiling argument it +rests on are **PR224** (`research/complex-bank-run2`); the bank-absorption ladder and the +`10^-10` replica price are **PR208** (`research/composed-diagonal-bit-bootstrap`); the +underlying bank proof and engine chain is PR200/PR205 (Chafik Boukhalfa and the PR197/PR205 +line) and PR184/PR168-v4 (icekylinx/eumemic) as inherited through them. This package adds +rungs 3 and 4, their prices, the exhaustion of the ledger's whole-bank criterion and the +next-step arithmetic. Apache-2.0; no existing file is changed. diff --git a/research/complex-bank-run3/SOURCE.json b/research/complex-bank-run3/SOURCE.json new file mode 100644 index 0000000000..8eed6d2517 --- /dev/null +++ b/research/complex-bank-run3/SOURCE.json @@ -0,0 +1,25 @@ +{ + "files": { + "ledger3.py": "202591f64e76002dd0bc05e7d0c36214db85faf9261bb1757bfb0ca568cc53cd", + "obligations.json": "6be2fa3489d2006f981454c0a0a56f174b1a9def43a891ad28ce01e9e7ef9802", + "pins.py": "970caafa94b69a8dd352c7f123b44a5fcc009d19d25b8b75b0e30ba2b5b97754", + "references/pr207-coordinated-crossover.certificate.json": "f4e30cca369fb014b729df870ca3716cc0f1e2297b9f265341492cba85a14aeb", + "references/pr219-run1/NOTICE.md": "1f04b17404663a0983b7cc45e308e577d4d49fb6a4c1ff077dc3f13bae83c56f", + "references/pr219-run1/PROOF.md": "b7b9d83d4f87b32a9cba82a56039a18c9843eac0bd18f6a7bdcf9667b27b8a04", + "references/pr219-run1/README.md": "cc9fe21d282fac5085c09d35b9d0bc199c5ddef45ccdbdb2e6fbad45c08a881d", + "references/pr219-run1/SOURCE.json": "2fa4045bdf08c88103d678c1c7c29b66ebefa95d60f29a8d85697bf988c2c22b", + "references/pr219-run1/arithmetic.py": "6ad4d1ffc3a749a66cc0ec78afb4fedd94c84f9ca429de9011fa2e9c11ce819c", + "references/pr219-run1/banks.py": "0548a1c15bd6f6dea4505f5fd2ca1bb4ecbe914c8c90769b8cd8beeef428d0cf", + "references/pr219-run1/certificate.json": "fd092f55d1a2a3e8e01566b12b24c67a9efb35ef9b2fc0cd4e6217ba026245f6", + "references/pr219-run1/inputs/absorbed-occurrences.json": "1aedd8640818afe63eb7797f0332b915ed64ebeea3e9f210aaf40a06a02478a7", + "references/pr219-run1/interval_moment.py": "9d3d1d28bfb3375958995205179b171fb65c70a3792cf9f7a21ef5ee54f5460b", + "references/pr219-run1/obligations.json": "0268fc3628421bb930e9f56a23469a45f3b2bfae8888f6030622c2a51ce6a511", + "references/pr219-run1/paired_cube_assembly.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json": "d84406d2fcc6990deba2b135509e6d86600e57123d88f9b21f7b7240e1aeb513", + "references/pr219-run1/references/pr200-bit.certificate.json": "853afa75980e11ce16b333c28311c4f635e84065867c049fda9916c2419091ed", + "references/pr219-run1/references/pr205-packed.certificate.json": "c11fbb9aaa99594afc8d21e33761dc6d1d6c76ce3dbc36d5b64cae872c242f5a", + "references/pr219-run1/schedule.py": "b9fff272f30048b982da3c0fc0149c2fde20bb7e32b8f9f860069956c12ebdc9", + "references/pr219-run1/verify.py": "c839a06389945f9b0c6fbfd59bf2dd8030190c3de504d72c9bf032879f931197", + "run3.py": "279b153f5b3f4ed4fdf956243dfc186b7885132fc3bf087032cb46fdbb1d28e8" + } +} diff --git a/research/complex-bank-run3/certificate.json b/research/complex-bank-run3/certificate.json new file mode 100644 index 0000000000..23ead049ec --- /dev/null +++ b/research/complex-bank-run3/certificate.json @@ -0,0 +1,353 @@ +{ + "binding": "complex", + "blocked_on": { + "complex_family_inventory": null, + "complex_family_inventory_note": "the only occurrence inventory in the pins is #219's bit-side inputs/absorbed-occurrences.json (rank 22); the complex rank-11 family of PR224, and the rank-16 and rank-20 families this package absorbs, have no such enumeration, so the item-to-block map of C1 has no starting inventory", + "complex_supplier_has_bank_keys": [], + "frontier_certificate_has_bank_keys": [], + "pinned_bit_bank_construction": { + "bank_controls_keys": [ + "formal_columns_per_case", + "rejected", + "weighted_partition_cases" + ], + "distinct_gauges": 220, + "gauge_roles": 2200, + "note": "the pinned construction banks the bit word's selected entrance-gauge exteriors into width-72 banks; it is the only bank construction in the pins", + "physical_banks": 45842, + "physical_copies": 3, + "source": "references/pr219-run1/references/pr205-packed.certificate.json (#205)" + } + }, + "calibrations": { + "frontier": { + "a_bit": "4375408149318106538866216854671930632866706725794304565219529058788314814256861959639757/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "a_complex": "700918443859411/1000000000000000000", + "binding": "bit", + "equal": true, + "published": "1366380910073/2000000000000000", + "reproduced": "1366380910073/2000000000000000" + }, + "run1": { + "binding": "complex", + "bit_coarse_after": "728251090009891/1000000000000000000", + "bit_leaf": "728251089990228079570667060334898259823066154658013234139282580595702841889832933964476516783/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "ceiling_gap": "852386528394998651/1000700918443859411000000000000000000", + "complex_ceiling": "700918443859411/1000700918443859411", + "complex_coarse": "700918443859411/1000000000000000000", + "conclusion": "rung 1 already sits on the complex branch ceiling, so every further rung has to raise the complex supplier's own coarse saving", + "equal": true, + "published": "700427501305159/1000000000000000000", + "reproduced": "700427501305159/1000000000000000000" + }, + "run2": { + "coarse": "708793603125109/1000000000000000000", + "equal": true, + "note": "rebuilt here by this package's own ledger module from the pinned complex profile, not imported", + "published": "354145785295363/500000000000000000", + "reproduced": "708793603125109/1000000000000000000" + } + }, + "comparison": { + "frontier": "1366380910073/2000000000000000", + "pr208_priced_rung2": "3541457/5000000000", + "rung1": "700427501305159/1000000000000000000", + "rung2": "354145785295363/500000000000000000" + }, + "conservative_variant": { + "certified_moment": "700918443859411/1000000000000000000", + "delta": "-43859411/1000000000000000000", + "note": "PR193 publishes 219037/312500000 = 7.009184e-4, its value on the 10^-10 grid, 4.3859411e-11 below the 10^-18 certified paid moment of the same profile; the ladder above is priced on the certified moment, which #207 and #219's rung 1 also price. A reviewer who prefers the coarser field sees a smaller top rung: recorded here rather than hidden.", + "supplier_field": "219037/312500000", + "top_kappa_on_the_field": "17582790704471/25000000000000000" + }, + "decimal": 0.000711175695867958, + "gain_vs_frontier": "13992620415729/341595227518250", + "gain_vs_rung1": "10748194562799/700427501305159", + "gain_vs_rung2": "1442062638616/354145785295363", + "kappa": "355587847933979/500000000000000000", + "ledgers": { + "base_excluded": true, + "base_saving": "700918443859411/1000000000000000000", + "ceilings": { + "base": "700918443859411/1000700918443859411", + "rung2": "708793603125109/1000708793603125109", + "rung3": "88884746418533/125088884746418533", + "rung4": "711681826686289/1000711681826686289" + }, + "eligibility": [ + { + "banks": 531, + "blocks_per_bank": "6", + "children": 3186, + "family": 11, + "uniform_tiling": true, + "volume": 35046, + "whole": true + }, + { + "banks": 192, + "blocks_per_bank": null, + "children": 792, + "family": 16, + "uniform_tiling": false, + "volume": 12672, + "whole": true + }, + { + "banks": 60, + "blocks_per_bank": null, + "children": 198, + "family": 20, + "uniform_tiling": false, + "volume": 3960, + "whole": true + } + ], + "final_eligibility": [], + "final_row": { + "W": 35373, + "children": 635265, + "deficit": 3960, + "families": 17, + "mass": 2330658, + "maxchild": 19 + }, + "final_saving": "711681826686289/1000000000000000000", + "ladder": [ + { + "banks": 531, + "banks_one_copy": "177", + "blocks_per_bank": "6", + "children_after": 636255, + "children_before": 639441, + "family": 11, + "mass_after": 2347290, + "mass_before": 2382336, + "maxchild_after": 20, + "maxchild_before": 20, + "next_excluded": true, + "rank_divides_width": true, + "saving": "708793603125109/1000000000000000000", + "share_of_ledger": "177/12032", + "stock_after": 35625, + "stock_before": 36156, + "stock_drop": 531, + "volume": 35046 + }, + { + "banks": 192, + "banks_one_copy": "64", + "blocks_per_bank": null, + "children_after": 635463, + "children_before": 636255, + "family": 16, + "mass_after": 2334618, + "mass_before": 2347290, + "maxchild_after": 20, + "maxchild_before": 20, + "next_excluded": true, + "rank_divides_width": false, + "saving": "88884746418533/125000000000000000", + "share_of_ledger": "64/11855", + "stock_after": 35433, + "stock_before": 35625, + "stock_drop": 192, + "volume": 12672 + }, + { + "banks": 60, + "banks_one_copy": "20", + "blocks_per_bank": null, + "children_after": 635265, + "children_before": 635463, + "family": 20, + "mass_after": 2330658, + "mass_before": 2334618, + "maxchild_after": 19, + "maxchild_before": 20, + "next_excluded": true, + "rank_divides_width": false, + "saving": "711681826686289/1000000000000000000", + "share_of_ledger": "20/11791", + "stock_after": 35373, + "stock_before": 35433, + "stock_drop": 60, + "volume": 3960 + } + ], + "one_copy": { + "W": 12052, + "children": 213147, + "deficit": 1320, + "families": 20, + "m": 66, + "mass": 794112, + "maxchild": 20 + }, + "source": "pr207-coordinated-crossover.certificate.json", + "three_copy": { + "W": 36156, + "children": 639441, + "deficit": 3960, + "mass": 2382336 + } + }, + "needed_for": [ + { + "binding": "complex", + "budget": "720518773516933/1000000000000000000", + "coarse": "360259386758467/500000000000000000", + "coarse_decimal": 0.000720518773516934, + "gain_vs_top": "8836946830645/711681826686289", + "kappa": "720000000000001/1000000000000000000", + "needs_new_bit": false, + "target": "9/12500" + }, + { + "binding": "bit", + "budget": "187640730547911/250000000000000000", + "coarse": null, + "gain_vs_top": null, + "kappa": null, + "kappa_at_the_bit_ceiling": "1819302815717/2500000000000000", + "needs_new_bit": true, + "required_bit_leaf": "187640730547911/250000000000000000", + "target": "3/4000" + }, + { + "binding": "bit", + "budget": "8064516129032259/1000000000000000000", + "coarse": null, + "gain_vs_top": null, + "kappa": null, + "kappa_at_the_bit_ceiling": "1819302815717/2500000000000000", + "needs_new_bit": true, + "required_bit_leaf": "8064516129032259/1000000000000000000", + "target": "1/125" + }, + { + "binding": "bit", + "budget": "500500500500501/500000000000000000", + "coarse": null, + "gain_vs_top": null, + "kappa": null, + "kappa_at_the_bit_ceiling": "1819302815717/2500000000000000", + "needs_new_bit": true, + "required_bit_leaf": "500500500500501/500000000000000000", + "target": "1/1000" + } + ], + "obligations": [ + "C1", + "C2", + "C3", + "C4", + "C5", + "C6", + "C7", + "T1", + "R1", + "R2", + "R3", + "R4" + ], + "replica": [ + { + "family": 11, + "kappa": "3541457/5000000000", + "kind": "rung 2", + "matches_published": true, + "published": "3541457/5000000000" + }, + { + "family": 16, + "kappa": "284229/400000000", + "kind": "rung 3", + "matches_published": null, + "published": null + }, + { + "family": 20, + "kappa": "1422351/2000000000", + "kind": "rung 4", + "matches_published": null, + "published": null + } + ], + "rung": 4, + "rungs": [ + { + "adjacent_grid_rejected": true, + "assembly": { + "minimum_constraint": "1/1000000000000000000000000000000" + }, + "binding": "complex", + "bit_leaf_headroom": "17173118641964079570667772412869608087066154658013234139282580595702841889832933964476516783/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "ceiling_gap": "92008231714245979/125088884746418533000000000000000000", + "coarse": "88884746418533/125000000000000000", + "complex_ceiling": "88884746418533/125088884746418533", + "family": 16, + "kappa": "710572698755137/1000000000000000000", + "rung": 3 + }, + { + "adjacent_grid_rejected": true, + "assembly": { + "minimum_constraint": "1/1000000000000000000000000000000" + }, + "binding": "complex", + "bit_leaf_headroom": "16569263303939079570667773016724946112066154658013234139282580595702841889832933964476516783/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "ceiling_gap": "399469263583486069/500355840913343144500000000000000000", + "coarse": "711681826686289/1000000000000000000", + "complex_ceiling": "711681826686289/1000711681826686289", + "family": 20, + "kappa": "355587847933979/500000000000000000", + "rung": 4 + } + ], + "source_pins": { + "ledger3.py": "202591f64e76002dd0bc05e7d0c36214db85faf9261bb1757bfb0ca568cc53cd", + "obligations.json": "6be2fa3489d2006f981454c0a0a56f174b1a9def43a891ad28ce01e9e7ef9802", + "pins.py": "970caafa94b69a8dd352c7f123b44a5fcc009d19d25b8b75b0e30ba2b5b97754", + "references/pr207-coordinated-crossover.certificate.json": "f4e30cca369fb014b729df870ca3716cc0f1e2297b9f265341492cba85a14aeb", + "references/pr219-run1/NOTICE.md": "1f04b17404663a0983b7cc45e308e577d4d49fb6a4c1ff077dc3f13bae83c56f", + "references/pr219-run1/PROOF.md": "b7b9d83d4f87b32a9cba82a56039a18c9843eac0bd18f6a7bdcf9667b27b8a04", + "references/pr219-run1/README.md": "cc9fe21d282fac5085c09d35b9d0bc199c5ddef45ccdbdb2e6fbad45c08a881d", + "references/pr219-run1/SOURCE.json": "2fa4045bdf08c88103d678c1c7c29b66ebefa95d60f29a8d85697bf988c2c22b", + "references/pr219-run1/arithmetic.py": "6ad4d1ffc3a749a66cc0ec78afb4fedd94c84f9ca429de9011fa2e9c11ce819c", + "references/pr219-run1/banks.py": "0548a1c15bd6f6dea4505f5fd2ca1bb4ecbe914c8c90769b8cd8beeef428d0cf", + "references/pr219-run1/certificate.json": "fd092f55d1a2a3e8e01566b12b24c67a9efb35ef9b2fc0cd4e6217ba026245f6", + "references/pr219-run1/inputs/absorbed-occurrences.json": "1aedd8640818afe63eb7797f0332b915ed64ebeea3e9f210aaf40a06a02478a7", + "references/pr219-run1/interval_moment.py": "9d3d1d28bfb3375958995205179b171fb65c70a3792cf9f7a21ef5ee54f5460b", + "references/pr219-run1/obligations.json": "0268fc3628421bb930e9f56a23469a45f3b2bfae8888f6030622c2a51ce6a511", + "references/pr219-run1/paired_cube_assembly.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json": "d84406d2fcc6990deba2b135509e6d86600e57123d88f9b21f7b7240e1aeb513", + "references/pr219-run1/references/pr200-bit.certificate.json": "853afa75980e11ce16b333c28311c4f635e84065867c049fda9916c2419091ed", + "references/pr219-run1/references/pr205-packed.certificate.json": "c11fbb9aaa99594afc8d21e33761dc6d1d6c76ce3dbc36d5b64cae872c242f5a", + "references/pr219-run1/schedule.py": "b9fff272f30048b982da3c0fc0149c2fde20bb7e32b8f9f860069956c12ebdc9", + "references/pr219-run1/verify.py": "c839a06389945f9b0c6fbfd59bf2dd8030190c3de504d72c9bf032879f931197", + "run3.py": "279b153f5b3f4ed4fdf956243dfc186b7885132fc3bf087032cb46fdbb1d28e8" + }, + "status": "MODEL AND TARGET, NOT CONSTRUCTED: the rung-3 and rung-4 ledgers (whole-bank volume, retained row identities, stock drops, both paid moments on the 10^-18 grid, the two 47-constraint assemblies) are certified here, but every rung above rung 2 needs a bank construction on the complex supplier that no package in the pins provides (obligations.json C1-C7 and T1, plus #219's inherited R1-R4). The kappa below is conditional on those and is not a completed finite witness.", + "top": { + "banks": 783, + "binding": "complex", + "ceiling": "711681826686289/1000711681826686289", + "ceiling_gap": "399469263583486069/500355840913343144500000000000000000", + "children": 635265, + "coarse": "711681826686289/1000000000000000000", + "eligibility_exhausted": true, + "families_absorbed": [ + 11, + 16, + 20 + ], + "families_left": 17, + "kappa": "355587847933979/500000000000000000", + "largest_child": 19, + "note": "no family of the remaining complex ledger has a whole-bank volume, so the accounting criterion the built rungs use cannot be applied again without a different bank width or a mixed tiling that reopens the volume condition", + "rank_mass": 2330658, + "stock": 35373 + } +} diff --git a/research/complex-bank-run3/ledger3.py b/research/complex-bank-run3/ledger3.py new file mode 100644 index 0000000000..44bf104d1a --- /dev/null +++ b/research/complex-bank-run3/ledger3.py @@ -0,0 +1,209 @@ +#!/usr/bin/env python3 +"""Rungs 3 and 4 of the bank ladder: the rest of the complex ledger that can be banked. + +PR219 (``research/residual-bank-run1``, head ``237067f``) built **rung 1**: the bit word's +rank-22 bin leaves the ledger, its 440,352 three-copy registers of dirt become 6,116 +width-72 banks, and the composition then binds on the **complex** supplier. PR224 +(``research/complex-bank-run2``) built **rung 2**: the complex word's rank-11 family leaves +into 531 of that word's own width-66 banks, and the assembly lands on the new complex +ceiling. + +Rung 2 is not the end of the complex ledger. Two further families fill whole width-66 +banks on their own volume -- rank 16 (264 children per vertex) and rank 20 (66 per vertex) +-- and after them **nothing else does**: the criterion that makes an absorption free is +that the family's own volume is a whole number of banks, and among the remaining 17 +families no volume satisfies it. That makes the complex-side ladder finite, and this +module builds the ledger up to its top. + +The criterion, stated once because everything here turns on it: a family of rank ``r`` with +``n`` children per vertex occupies ``r * n`` registers per copy, and it can leave the +ledger into whole banks only when that volume is a whole number of width-``m`` banks +(``m | r * n``). That is what PR219's rank-22 absorption and PR224's rank-11 absorption +both satisfy, and what the certified entrance-bank proof satisfies on the bit word (2,200 +rank-60 exteriors whose 396,000 three-copy registers fill 5,500 banks). It is *necessary* +and it is the accounting criterion the built rungs use; it is not a construction -- see +``obligations.json`` T1 for the tiling that rank 16 and rank 20 additionally owe, since +neither rank divides the bank width (``66 % 16 = 2``, ``66 % 20 = 6``) whereas rank 11 does +(``66 = 6 * 11``). + +Prices come from the pinned engine (PR200's exact interval moment), used on the complex +side exactly as PR219 uses it there: ``bit=False``, i.e. without the bit branch's rare-class +fallback, on the ``10^-18`` grid. +""" +import importlib.util +import json +import sys +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +RUN1 = HERE / 'references' / 'pr219-run1' +COPIES = 3 +GRID = 10 ** 18 +# The complex ledger's bank width and the family every bank was measured against. +WIDTH = 66 + + +def load(name, path): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +def engine(): + """The pinned interval-moment engine, as PR219 vendors it.""" + return load('run3_interval_moment', RUN1 / 'interval_moment.py') + + +def run1(): + """PR219's own schedule and arithmetic, imported from the vendored package.""" + return load('run3_run1_schedule', RUN1 / 'schedule.py'), \ + load('run3_run1_arithmetic', RUN1 / 'arithmetic.py') + + +def profile(row): + """PR219's profile form, from either certificate spelling of the same fields.""" + hist = {int(r): int(n) for r, n in + (row.get('child_multiplicities') or row['child_histogram']).items() if n} + W = int(row.get('W', row.get('W_per_vertex'))) + D = int(row.get('N', row.get('deficit_per_vertex'))) + return dict(m=int(row['m']), W=W, N=D, L=int(row.get('L', 0)), + child_multiplicities=hist, + total_rank=int(row.get('total_rank', sum(r * n for r, n in hist.items()))), + maxchild=int(row.get('maxchild', max(hist)))) + + +def check_row(row): + m, W, D, hist = row['m'], row['W'], row['N'], row['child_multiplicities'] + mass = sum(r * n for r, n in hist.items()) + assert m * W - mass == D, 'row identity' + assert mass == row['total_rank'], 'declared rank mass' + assert max(hist) == row['maxchild'], 'declared largest child' + return mass + + +def three_copies(row): + """The supplier's row over its three copies: integral stock, same saving.""" + m, W, D, hist = row['m'], row['W'], row['N'], row['child_multiplicities'] + hist = {r: COPIES * n for r, n in hist.items()} + return dict(m=m, W=COPIES * W, N=COPIES * D, L=row['L'], + child_multiplicities=hist, total_rank=sum(r * n for r, n in hist.items()), + maxchild=max(hist)) + + +def bankable(row, family): + """Does this family's own volume fill whole banks, and how many?""" + m, hist = row['m'], row['child_multiplicities'] + if family not in hist: + return None + volume = family * hist[family] + return dict(family=family, children=hist[family], volume=volume, + banks=volume // m, whole=(volume % m == 0), + uniform_tiling=(m % family == 0), + blocks_per_bank=Q(m, family) if m % family == 0 else None) + + +def eligibility(row): + """Every family of the row whose own volume is a whole number of banks.""" + m = row['m'] + return sorted(r for r in row['child_multiplicities'] + if (r * row['child_multiplicities'][r]) % m == 0) + + +def absorb(row, family): + """Take one child family out of the ledger and into whole banks.""" + m, W, D, hist = row['m'], row['W'], row['N'], row['child_multiplicities'] + assert family in hist, 'the family must sit in the ledger' + kept = {r: n for r, n in hist.items() if r != family} + taken = family * hist[family] + assert taken % m == 0, 'the absorbed volume must fill whole banks' + mass = m * W - D - taken + assert sum(r * n for r, n in kept.items()) == mass, 'row identity after absorption' + stock, remainder = divmod(mass + D, m) + assert remainder == 0, 'half-filled stock' + assert kept, 'a ledger must remain after the absorption' + assert taken // m > 0, 'the absorption must occupy at least one bank' + retained = dict(m=m, W=stock, N=D, L=row['L'], child_multiplicities=kept, + total_rank=mass, maxchild=max(kept)) + assert check_row(retained) == mass + return dict(family=family, volume=taken, banks=taken // m, retained=retained, + stock_before=W, stock_after=stock, stock_drop=W - stock, + mass_before=m * W - D, mass_after=mass, + children_before=sum(hist.values()), children_after=sum(kept.values()), + maxchild_before=max(hist), maxchild_after=max(kept), + share_of_ledger=Q(taken, m * W - D), + rank_divides_width=(m % family == 0)) + + +def certify(interval, row): + """The complex side's paid moment, exactly as PR219 prices it: no bit fallback.""" + run1_arithmetic = load('run3_run1_arithmetic_certify', RUN1 / 'arithmetic.py') + return run1_arithmetic.certify(interval, profile(row), False) + + +def ceiling(coarse): + """The branch ceiling a coarse saving `C` can reach in the assembly: `C/(1+C)`.""" + return coarse / (1 + coarse) + + +def side(certificate_path, interval, rungs=()): + """The complex half of the ladder: base row plus one entry per absorbed family. + + ``rungs`` is applied in order, each entry a family rank; every step is checked + (whole-bank volume, retained row identity, stock drop equal to the bank count) and + priced with the pinned engine. + """ + certificate = json.loads(Path(certificate_path).read_text()) + row = profile(certificate['complex_profile']) + mass = check_row(row) + base = certify(interval, row) + copied = three_copies(row) + ladder, work = [], copied + for family in rungs: + step = absorb(work, family) + work = step['retained'] + after = certify(interval, work) + ladder.append(dict( + family=family, volume=step['volume'], banks=step['banks'], + banks_one_copy=Q(step['banks'], COPIES), + stock_before=step['stock_before'], stock_after=step['stock_after'], + stock_drop=step['stock_drop'], mass_before=step['mass_before'], + mass_after=step['mass_after'], children_before=step['children_before'], + children_after=step['children_after'], maxchild_before=step['maxchild_before'], + maxchild_after=step['maxchild_after'], + share_of_ledger=step['share_of_ledger'], + rank_divides_width=step['rank_divides_width'], + blocks_per_bank=(Q(step['retained']['m'], family) + if step['rank_divides_width'] else None), + saving=after['saving'], + next_excluded=after['next_excluded']['lower'] > 1)) + return dict(source=Path(certificate_path).name, + one_copy=dict(m=row['m'], W=row['W'], deficit=row['N'], mass=mass, + children=sum(row['child_multiplicities'].values()), + maxchild=row['maxchild'], + families=len(row['child_multiplicities'])), + three_copy=dict(W=copied['W'], deficit=copied['N'], mass=copied['total_rank'], + children=sum(copied['child_multiplicities'].values())), + eligibility=[bankable(copied, r) for r in eligibility(copied)], + base_saving=base['saving'], + base_excluded=base['next_excluded']['lower'] > 1, + ladder=ladder, + ceilings=dict(base=ceiling(base['saving']), + **{'rung%d' % (i + 2): ceiling(step['saving']) + for i, step in enumerate(ladder)}), + final_eligibility=eligibility(work), + final_row=dict(W=work['W'], deficit=work['N'], mass=work['total_rank'], + children=sum(work['child_multiplicities'].values()), + families=len(work['child_multiplicities']), + maxchild=max(work['child_multiplicities'])), + final_saving=certify(interval, work)['saving']) + + +if __name__ == '__main__': + sys.set_int_max_str_digits(0) + sys.dont_write_bytecode = True + part = side(HERE / 'references' / 'pr207-coordinated-crossover.certificate.json', + engine(), (11, 16, 20)) + print(json.dumps(part, indent=1, sort_keys=True, default=str)) diff --git a/research/complex-bank-run3/obligations.json b/research/complex-bank-run3/obligations.json new file mode 100644 index 0000000000..3a9293eb7a --- /dev/null +++ b/research/complex-bank-run3/obligations.json @@ -0,0 +1,138 @@ +{ + "claim_scope": "This package certifies an accounting ledger and its exact price: the whole-bank volume condition, the retained row identity with the stock falling by the bank count, both complex paid moments with the adjacent 10^-18 grid point excluded, the unchanged 47-constraint assembly at the rung-2 budget with its adjacent point rejected, and an independent replica of the same ledger in PR208's pricing convention. The rung is NOT constructed: C1 has no precedent in the pins and C5 has no inventory. The kappa is therefore a priced, exactly certified target conditional on C1-C5 and on #219's inherited R1-R4, and it is not a completed finite witness or an unconditional multiplication theorem in any case.", + "inherited": [ + { + "id": "R1", + "name": "bit-side residual-type definition and bank blocks", + "source": "research/complex-bank-run2/references/pr219-run1/obligations.json (PR219 head 237067f)", + "status": "OPEN" + }, + { + "id": "R2", + "name": "bit-side formal columns of the modified word", + "source": "research/complex-bank-run2/references/pr219-run1/obligations.json (PR219 head 237067f)", + "status": "OPEN" + }, + { + "id": "R3", + "name": "bit-side charts, routing and prime witnesses", + "source": "research/complex-bank-run2/references/pr219-run1/obligations.json (PR219 head 237067f)", + "status": "OPEN" + }, + { + "id": "R4", + "name": "bit-side moment-envelope parity", + "source": "research/complex-bank-run2/references/pr219-run1/obligations.json (PR219 head 237067f)", + "status": "OPEN" + } + ], + "obligations": [ + { + "generalized_to_rungs_3_4": { + "banks_one_copy": 783, + "banks_three_copies": 783, + "blocks": "six rank-11 blocks per bank where the rank divides the width; the rank-16 and rank-20 blocks need the mixed tiling of T1", + "note": "This item was written for rung 2 (rank 11, 531 three-copy banks). The ladder of this package applies it to ranks 11, 16 and 20 together: 783 three-copy banks, 261 per copy, with rungs 3 and 4 replacing 192 and 60 of them respectively.", + "ranks": "11, 16, 20 (the whole-bank families of this ledger)" + }, + "id": "C1", + "name": "complex-side bank construction and residual-type blocks", + "reference_precedent": "PR205 references/pr219-run1/references/pr205-packed.certificate.json: physical.banks with gauge_roles, distinct_gauges, copies and bank_controls; research/coordinated-frames-and-entrance-banks BANK-PROOF-PR200.md for the block/normalizer pattern.", + "statement": "Build the bank construction on the complex supplier: banks of width 66 hosting the rank-11 items, with the normalizer that sends each item's true residual projector to its assigned block, the per-bank block assignment (six rank-11 blocks per bank, since 66 = 6 x 11) and the hashed item-to-bank/offset map for all 531 three-copy banks (177 one copy). The pins contain no bank construction for the complex supplier: its certificate has no bank keys at all, and the only banked word in the pins is the bit word's entrance-gauge pack of PR205/PR206 (width 72, rank-60 exteriors, 6,116 banks).", + "status": "OPEN", + "why_it_is_the_blocker": "The bit-side mechanism is specific to the width-72 bit word's entrance gauges; nothing in the queue banks complex-word dirt, so this is a new mechanism rather than an extension of an existing one." + }, + { + "generalized_to_rungs_3_4": { + "banks_one_copy": 783, + "banks_three_copies": 783, + "blocks": "six rank-11 blocks per bank where the rank divides the width; the rank-16 and rank-20 blocks need the mixed tiling of T1", + "note": "This item was written for rung 2 (rank 11, 531 three-copy banks). The ladder of this package applies it to ranks 11, 16 and 20 together: 783 three-copy banks, 261 per copy, with rungs 3 and 4 replacing 192 and 60 of them respectively.", + "ranks": "11, 16, 20 (the whole-bank families of this ledger)" + }, + "id": "C2", + "name": "formal columns of the modified complex word", + "reference_precedent": "#219 R2; PR193's complex certificate fields exact_scalar_program_sha256 and the complex profile's contract checks.", + "statement": "Re-run the complete formal-column checks on the complex word after the re-assignment: every source, target and dirty-register column over F2 and over the defining integers, with the rank-11 transitions realized by bank re-assignment instead of paid children, and the exact scalar program / lift certificate re-derived rather than compared as a container digest.", + "status": "OPEN" + }, + { + "generalized_to_rungs_3_4": { + "banks_one_copy": 783, + "banks_three_copies": 783, + "blocks": "six rank-11 blocks per bank where the rank divides the width; the rank-16 and rank-20 blocks need the mixed tiling of T1", + "note": "This item was written for rung 2 (rank 11, 531 three-copy banks). The ladder of this package applies it to ranks 11, 16 and 20 together: 783 three-copy banks, 261 per copy, with rungs 3 and 4 replacing 192 and 60 of them respectively.", + "ranks": "11, 16, 20 (the whole-bank families of this ledger)" + }, + "id": "C3", + "name": "charts, routing and prime witnesses for the new complex blocks", + "reference_precedent": "#219 R3; PR205's chart digest and colouring checks; banks.py (vendored) for the fraction-free inversion and two-colouring helpers.", + "statement": "Exact charts (integer kernel bases with fraction-free inverses and replayed elementary factors) for every new complex block frame, the incidence colouring of the new bank incidences, and distinct integer Gram/prime witnesses for every frame the new blocks use, with residual factors below the retained q bound.", + "status": "OPEN" + }, + { + "generalized_to_rungs_3_4": { + "banks_one_copy": 783, + "banks_three_copies": 783, + "blocks": "six rank-11 blocks per bank where the rank divides the width; the rank-16 and rank-20 blocks need the mixed tiling of T1", + "note": "This item was written for rung 2 (rank 11, 531 three-copy banks). The ladder of this package applies it to ranks 11, 16 and 20 together: 783 three-copy banks, 261 per copy, with rungs 3 and 4 replacing 192 and 60 of them respectively.", + "ranks": "11, 16, 20 (the whole-bank families of this ledger)" + }, + "id": "C4", + "name": "complex moment-envelope parity", + "reference_precedent": "#219 R4; PR200's interval-moment engine as vendored by #219 (interval_moment.py).", + "statement": "Confirm that the paid moment envelope for the modified complex word is exactly the one priced here: retained three-copy stock 35,625 (one copy 11,875), deficit 3,960 (one copy 1,320), the retained child histogram of ledger.py's absorbed row, and no rare-class fallback on the complex side (the convention #219 uses there). Any completion child C1 introduces must re-enter the ledger and the kappa be recomputed.", + "status": "OPEN" + }, + { + "generalized_to_rungs_3_4": { + "banks_one_copy": 783, + "banks_three_copies": 783, + "blocks": "six rank-11 blocks per bank where the rank divides the width; the rank-16 and rank-20 blocks need the mixed tiling of T1", + "note": "This item was written for rung 2 (rank 11, 531 three-copy banks). The ladder of this package applies it to ranks 11, 16 and 20 together: 783 three-copy banks, 261 per copy, with rungs 3 and 4 replacing 192 and 60 of them respectively.", + "ranks": "11, 16, 20 (the whole-bank families of this ledger)" + }, + "id": "C5", + "name": "inventory and provenance of the rank-11 family", + "reference_precedent": "#219 schedule.py section 1 and inputs/absorbed-occurrences.json.", + "statement": "Enumerate the rank-11 items: for each of the 1,062 per-vertex children of the complex ledger's bin 11, the frame/chain occurrence it comes from, with a checked bijection onto the 3,186 three-copy occurrences and a proof that no other bin is touched. The pins contain no such inventory; the only occurrence inventory they hold is #219's bit-side inputs/absorbed-occurrences.json for the rank-22 bin, which is what makes #219's R1 a closed checklist.", + "status": "OPEN" + }, + { + "id": "C6", + "name": "rank-16 family inventory on the complex word", + "reference_precedent": "PR219 references/pr219-run1/inputs/absorbed-occurrences.json (rank-22 provenance), which this family has no counterpart of.", + "statement": "Enumerate the complex word's rank-16 child family: its 264 occurrences per vertex (792 over the three copies), their frame or chain identity, a bijection onto the 192 three-copy blocks the absorption of rung 3 needs, and a proof that no other bin of the ledger moves. Nothing in the pins enumerates this family, exactly as nothing enumerates the rank-11 family of PR224 or the rank-22 bin of PR219's bit-side absorption, whose inventory (inputs/absorbed-occurrences.json) is what made that rung a closed checklist.", + "status": "OPEN", + "why_it_is_the_blocker": "A rung that cannot name its items cannot be built: the item-to-block map of C1 has no starting inventory for this family, so its absorption is priced but not instantiated." + }, + { + "id": "C7", + "name": "rank-20 family inventory on the complex word", + "reference_precedent": "PR219 references/pr219-run1/inputs/absorbed-occurrences.json.", + "statement": "The same enumeration for the rank-20 family: 66 occurrences per vertex (198 over the three copies) onto the 60 three-copy blocks of rung 4, with the same no-other-bin-moves proof.", + "status": "OPEN", + "why_it_is_the_blocker": "Same gap as C6, one rung further; it is the last family of the ledger that satisfies the whole-bank volume condition." + }, + { + "id": "T1", + "name": "mixed tiling of the width-66 bank for ranks 16 and 20", + "reference_precedent": "PR219 references/pr219-run1/schedule.py (width-72 tilings over {4, 24, 22}); research/coordinated-frames-and-entrance-banks BANK-PROOF-PR200.md (18 four-coordinate cores or 3 24-coordinate cores fill a width-72 bank).", + "statement": "Rank 11 divides the bank width (66 = 6 x 11) and needed no mixture, but 66 = 4 x 16 + 2 and 66 = 3 x 20 + 6: the rank-16 and rank-20 blocks cannot tile a 66-wide bank on their own, so their banks must mix block sizes. The obligation is to enumerate the admissible tilings of width 66 over the families the complex word actually offers, choose one per bank, and show that the chosen pattern realises exactly 264 rank-16 and 66 rank-20 children per vertex -- i.e. that every absorbed item lands in some block and no block is left half-used.", + "status": "OPEN", + "why_it_is_the_blocker": "It is the same obligation PR219 carries as R1 for the bit word (admissible tilings of width 72 over families {4, 24, 22}), but with no analogous enumeration to inherit: the bit word's bank pattern is pinned in the bank proof, the complex word has none." + } + ], + "status": "OPEN obligations for rungs 3 and 4. verify.py certifies the accounting (whole-bank volumes, retained row identities, stock drops equal to the bank counts, both paid moments on the 10^-18 grid, the two 47-constraint assemblies and the exclusion of the adjacent grid points) and the exact prices; it discharges none of these items.", + "why_rung_3_and_4": { + "consequence": "the accounting ladder on the complex word terminates at rung 4; going higher needs a different bank width, a different ledger (a new supplier), or a mixed tiling that reopens the volume condition.", + "numbers": { + "rank_16_volume": "16 * 792 = 12,672 = 66 * 192 three-copy banks", + "rank_20_volume": "20 * 198 = 3,960 = 66 * 60 three-copy banks", + "remaining_families": "every one of the 17 families left after rungs 2-4 has a volume that is not a whole number of width-66 banks", + "rung_2_ceiling": "7.082915705907269e-4 (kappa 354145785295363/5*10^17 inside one 10^-18 grid step)", + "rung_2_coarse": "708793603125109/10^18 = 7.08793603125109e-4" + }, + "statement": "Rung 2 (PR224) absorbs the complex word's rank-11 family and lands on the complex branch's new ceiling, so the only way up is to raise the complex coarse saving again. Exactly two further families of that ledger satisfy the whole-bank volume condition -- rank 16 and rank 20 -- and after them no family does." + } +} diff --git a/research/complex-bank-run3/pins.py b/research/complex-bank-run3/pins.py new file mode 100644 index 0000000000..321dac2c7e --- /dev/null +++ b/research/complex-bank-run3/pins.py @@ -0,0 +1,34 @@ +#!/usr/bin/env python3 +"""The bytes this package is allowed to depend on. + +Two sources are pinned: #207's frontier certificate (the row pair the ladder is priced +against, taken verbatim from that submission's head) and the whole of #219's rung-1 +package under `references/pr219-run1/`, which supplies rung 1 itself, the interval-moment +engine and the 47-constraint assembly. Everything else in this directory is the work of +this package. +""" +from hashlib import sha256 +from pathlib import Path + +HERE = Path(__file__).resolve().parent +VENDORED_RUN1 = 'references/pr219-run1' + +OWN = ('ledger3.py', 'run3.py', 'pins.py', 'obligations.json', + 'references/pr207-coordinated-crossover.certificate.json') + + +def pinned_paths(): + """Every file whose bytes this package is pinned to, as relative paths.""" + own = list(OWN) + vendored = sorted(str(p.relative_to(HERE)).replace('\\', '/') + for p in (HERE / VENDORED_RUN1).rglob('*') if p.is_file()) + assert vendored, 'the vendored rung-1 package must be present' + return own + vendored + + +def digest(path): + return sha256(Path(path).read_bytes()).hexdigest() + + +def manifest(): + return {name: digest(HERE / name) for name in pinned_paths()} diff --git a/research/complex-bank-run3/references/pr207-coordinated-crossover.certificate.json b/research/complex-bank-run3/references/pr207-coordinated-crossover.certificate.json new file mode 100644 index 0000000000..ebf70ec2ae --- /dev/null +++ b/research/complex-bank-run3/references/pr207-coordinated-crossover.certificate.json @@ -0,0 +1,199 @@ +{ + "a_bit": "4375408149318106538866216854671930632866706725794304565219529058788314814256861959639757/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "a_complex": "700918443859411/1000000000000000000", + "adjacent_kappa_rejected": true, + "assembly": { + "absorption_gap": "134281643351448469855595122809435201472739986862783885293176478497632435149777090241037553043786318538250810999419972289/246322131082666081020725623388609831999871293422821561354667625512514417816371066596945447670129629672549080027711000000000000000000000000", + "margins": { + "Gaussian_arithmetic": "269255886111883479314991099644648533713048750891109557636200948729645684632351887487203757789591105011931098889929870370327450919972289/394115409732265729633160997421775731199794069476514498167468200820023068506193706555112716272207407476078528044337600000000000000000000000", + "balanced_prefix": "168284928819927174572023388609831999871293422821561354667625512514417816371066596945447670129629672549080027711/246322131082666081020725623388609831999871293422821561354667625512514417816371066596945447670129629672549080027711", + "bulk_exposure": "4375408149318106538866216854671930632866706725794304565219529058788314814256861959639757/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_phase_layer": "168284928819927174571777066478749333790272697198172744835625641220994994809711929319935155711813301482483082263329870370327450919972289/246322131082666081020725623388609831999871293422821561354667625512514417816371066596945447670129629672549080027711000000000000000000000000", + "coordinate_movement": "4375408149318106538866216854671930632866706725794304565219529058788314814256861959639757/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "dimension": "246153846153846153846153600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000/246322131082666081020725623388609831999871293422821561354667625512514417816371066596945447670129629672549080027711", + "scalar_work": "1346279430559417396575940786747573332889326656949102227509004228821919709407178107938068846619221009326043276240329870370327450919972289/1970577048661328648165804987108878655998970347382572490837341004100115342530968532775563581361037037380392640221688000000000000000000000000" + }, + "minimum_margin": "168284928819927174571777066478749333790272697198172744835625641220994994809711929319935155711813301482483082263329870370327450919972289/246322131082666081020725623388609831999871293422821561354667625512514417816371066596945447670129629672549080027711000000000000000000000000", + "parameters": { + "C0": { + "base": 2, + "exponent": 210000 + }, + "C1": 1, + "a_bit": "4375408149318106538866216854671930632866706725794304565219529058788314814256861959639757/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "a_complex": "700918443859411/1000000000000000000", + "alpha_squared_power": "336569857639854349143800455088581333661566120019734099503251153735412811180778526265382825841442974031563109974329870370327450919972289/492644262165332162041451246777219663999742586845643122709335251025028835632742133193890895340259259345098160055422000000000000000000000000", + "beta": "1/1000000000000000000000000", + "c": "2187704074659053269433904051927815998326814496680297610679131662687431612823865760290819711685185743138040360243/3200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "delta": "1/8000000000000000000000000", + "epsilon": "246153846153846153846153600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000/246322131082666081020725623388609831999871293422821561354667625512514417816371066596945447670129629672549080027711", + "eta": "1/1000000000000000000000000", + "kappa": "1366380910073/2000000000000000", + "lambda_": "6395624591850681893461133787520736218685239832140422550106711103807918410980047703259889301788314814256861959639757/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime": "3197812295925340946730566895948072184001673185503319702389320868337312568387176134239709180288314814256861959639757/3200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q": "2187704074659053269433104051927815998326814496680297610679131662687431612823865760290819711685185743138040360243/3200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "sigma": "999299081556140589/1000000000000000000", + "tau": "6395624591850681893461133783145328069367133293274205695434780470941211685185743138040360243/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "recurrence": { + "internal": "6395624591850681893461133783145328069367133293274205695434780470941211685185743138040360243/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "leaf": "999299081556140589000000000700918443859411/1000000000000000000000000000000000000000000", + "reservations": "3197812295925340946730566095948072184001673185503319702389320868337312568387176134239709180288314814256861959639757/3200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "strict_constraints": { + "Gaussian_arithmetic_above_kappa": "214850777155596201368600808930470355522283178903230270162019178396787203748294034208300043037326711738979101128519972289/394115409732265729633160997421775731199794069476514498167468200820023068506193706555112716272207407476078528044337600000000000000000000000", + "K_dominates_log": "168284928819927174571838604940287795328734235598172744835625641220994994809711929319935155711813301482483082263329870370327450919972289/246322131082666081020725623388609831999871293422821561354667625512514417816371066596945447670129629672549080027711000000000000000000000000", + "K_geometry": "184783669544204542559187223388609831999871293422821561354667625512514417816371066596945447670129629672549080027711/246322131082666081020725623388609831999871293422821561354667625512514417816371066596945447670129629672549080027711000000000000000000000000", + "alpha_below_one": "492307692307692307692307446322131082666081020725623388609831999871293422821561354667625512514417816371066596945447670129629672549080027711/492644262165332162041451246777219663999742586845643122709335251025028835632742133193890895340259259345098160055422000000000000000000000000", + "alpha_below_one_fourth": "122824495683693186161219011239216334666274080591391046577830561602521796097004754772207341009223371862242976903881170129629672549080027711/492644262165332162041451246777219663999742586845643122709335251025028835632742133193890895340259259345098160055422000000000000000000000000", + "alpha_positive": "336569857639854349143800455088581333661566120019734099503251153735412811180778526265382825841442974031563109974329870370327450919972289/492644262165332162041451246777219663999742586845643122709335251025028835632742133193890895340259259345098160055422000000000000000000000000", + "artificial_boundary": "13795385620059859954557211835837422495990005841237450092528224032414803008712432326207385188431549748156340912609847010388889017647240083133/1970577048661328648165804987108878655998970347382572490837341004100115342530968532775563581361037037380392640221688000000000000000000000000", + "balanced_prefix_above_kappa": "268563779347159105043352287070117180165143973468154616229475666330515895328389813224208299978467977335760967097/492644262165332162041451246777219663999742586845643122709335251025028835632742133193890895340259259345098160055422000000000000000", + "beta_below_one": "999999999999999999999999/1000000000000000000000000", + "beta_positive": "1/1000000000000000000000000", + "bit_positive": "4375408149318106538866216854671930632866706725794304565219529058788314814256861959639757/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "bulk_exposure_above_kappa": "2989237084506538866216854671930632866706725794304565219529058788314814256861959639757/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_below_one": "3197812295925340946730566095948072184001673185503319702389320868337312568387176134239709180288314814256861959639757/3200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_positive": "2187704074659053269433904051927815998326814496680297610679131662687431612823865760290819711685185743138040360243/3200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cell_above_band": "492307692307692307692306953677868917333918979274376611390168000128706577178438645332374487485582183628933403054552329870370327450919972289/985288524330664324082902493554439327999485173691286245418670502050057671265484266387781790680518518690196320110844000000000000000000000000", + "compact_leaf": "55234945691061930566893705133163651557985503319702389320868337312568387176134239709180288314814256861959639757/3200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_phase_layer_above_kappa": "134281643351448469855595122809435201472739986862783885293176478497632435149777090241037553043786318538250810999419972289/246322131082666081020725623388609831999871293422821561354667625512514417816371066596945447670129629672549080027711000000000000000000000000", + "compact_reservations": "1/4000000000000000000000000", + "complex_above_bit": "110469891382123861133783145328069367133293274205695434780470941211685185743138040360243/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_below_one_over32": "30549081556140589/1000000000000000000", + "coordinate_movement_above_kappa": "2989237084506538866216854671930632866706725794304565219529058788314814256861959639757/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "delta_below_one_eighth": "999999999999999999999999/8000000000000000000000000", + "delta_positive": "1/8000000000000000000000000", + "dimension_above_kappa": "491971122450052453611726932569939441043609700224474057455808722443125780596733533136624999988130553879110139923045977335760967097/492644262165332162041451246777219663999742586845643122709335251025028835632742133193890895340259259345098160055422000000000000000", + "epsilon_below_one": "168284928819927174572023388609831999871293422821561354667625512514417816371066596945447670129629672549080027711/246322131082666081020725623388609831999871293422821561354667625512514417816371066596945447670129629672549080027711", + "epsilon_positive": "246153846153846153846153600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000/246322131082666081020725623388609831999871293422821561354667625512514417816371066596945447670129629672549080027711", + "gamma_sublinear": "1/2000000000000000000000000", + "guard_width": "168284928819927174572023388609831999871293422821561354667625512514417816371066596945447670129629672549080027711/246322131082666081020725623388609831999871293422821561354667625512514417816371066596945447670129629672549080027711", + "lambda_above_internal": "4375408149318106538866216854671930632866706725794304565219529058788314814256861959639757/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_sigma": "110469891382123861133787520736218685239832140422550106711103807918410980047703259889301788314814256861959639757/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_tau": "4375408149318106538866216854671930632866706725794304565219529058788314814256861959639757/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime_above_lambda": "4375408149318106538866216854671930632866706725794304565219529058788314814256861959639757/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime_below_one": "2187704074659053269433104051927815998326814496680297610679131662687431612823865760290819711685185743138040360243/3200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "leaf_saving_above_bit": "110469891382123861133778659450028666902893274205695434780470941211685185743138040360243/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "literal_scalar_guard": "1", + "phase_boundary": "269255886111883479314991099644648533713048750891109557636200948729645684632351887487203757789591105011931098889929870370327450919972289/394115409732265729633160997421775731199794069476514498167468200820023068506193706555112716272207407476078528044337600000000000000000000000", + "phase_local": "1346279430559417396575940786747573332889326656949102227509004228821919709407178107938068846619221009326043276240329870370327450919972289/1970577048661328648165804987108878655998970347382572490837341004100115342530968532775563581361037037380392640221688000000000000000000000000", + "prime_interval_packing": "168284928819927174572023388609831999871293422821561354667625512514417816371066596945447670129629672549080027711/246322131082666081020725623388609831999871293422821561354667625512514417816371066596945447670129629672549080027711", + "q_below_internal": "4375408149318106538866216854671930632866706725794304565219529058788314814256861959639757/3200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_leaf": "55234945691061930566893705133163651557985503319702389320868337312568387176134239709180288314814256861959639757/3200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_reservations": "1/4000000000000000000000000", + "q_positive": "2187704074659053269433104051927815998326814496680297610679131662687431612823865760290819711685185743138040360243/3200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "record_suffix": "168284928819927174572023388609831999871293422821561354667625512514417816371066596945447670129629672549080027711/246322131082666081020725623388609831999871293422821561354667625512514417816371066596945447670129629672549080027711", + "row_product_gap": "23971789/25", + "scalar_work_above_kappa": "1074254871066505337507328127554845332050743894001325042096341310654438068799141436525766602968424239213414195838919972289/1970577048661328648165804987108878655998970347382572490837341004100115342530968532775563581361037037380392640221688000000000000000000000000", + "short_record_fallback": "1574306855524918884571274205389066327000920465903440952946365445540569604237553260610885033093742760664679982409998088157882306036774103883673142683918570723766876330273287070119111281479259396462862693773/1576461638929062918532643989687102924799176277906057992669872803280092274024774826220450865088829629904314112177350400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "small_field_exposure": "1/1000000000000000000000000" + } + }, + "beta": "1/1000000000000000000000000", + "binding": "bit", + "bit": { + "accepted": { + "lower": "1652402343749999997851238800561347063905497669045666488650474907/1652402343750000000000000000000000000000000000000000000000000000", + "saving": "136731504666219/200000000000000000", + "strict_gap_lower": "2438016547619109504615743675878715911813/676824000000000000000000000000000000000000000000000", + "upper": "1652402343749999997851238800561347063905497701989363999508104809/1652402343750000000000000000000000000000000000000000000000000000" + }, + "next_excluded": { + "lower": "8262011718750000006555831576444862302593421956910263100630461/8262011718750000000000000000000000000000000000000000000000000", + "saving": "85457190416387/125000000000000000", + "strict_gap_lower": "65013736811541319536185606023662851449/18048640000000000000000000000000000000000000000000", + "upper": "275400390625000000218527719214828743419780737420068666036349517/275400390625000000000000000000000000000000000000000000000000000" + }, + "saving": "136731504666219/200000000000000000" + }, + "bit_ordinary": "4375408149318106538866216854671930632866706725794304565219529058788314814256861959639757/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "bit_profile": { + "L": 0, + "N": 5808, + "W": 56402, + "child_multiplicities": { + "1": 378477, + "10": 5796, + "11": 3627, + "12": 12159, + "13": 4806, + "14": 10638, + "15": 2808, + "16": 9396, + "17": 4284, + "18": 3996, + "19": 2790, + "2": 178653, + "20": 15840, + "21": 45054, + "22": 20016, + "3": 91629, + "4": 28737, + "5": 24219, + "6": 12096, + "7": 11691, + "8": 7344, + "9": 5175 + }, + "m": 72, + "maxchild": 22, + "total_rank": 4055136 + }, + "complex": { + "accepted": { + "lower": "265143999999999999505356323836919762528275607173151/265144000000000000000000000000000000000000000000000", + "saving": "700918443859411/1000000000000000000", + "strict_gap_lower": "44967606923916385224702216933483/24104000000000000000000000000000000000000000000000", + "upper": "24103999999999999955032393076083614775297783066517/24104000000000000000000000000000000000000000000000" + }, + "next_excluded": { + "lower": "66286000000000000033428585232057842908390904631703/66286000000000000000000000000000000000000000000000", + "saving": "175229610964853/250000000000000000", + "strict_gap_lower": "-1162733399375924970726640217937/2305600000000000000000000000000000000000000000000", + "upper": "2305600000000000001162733399375924970726640217937/2305600000000000000000000000000000000000000000000" + }, + "saving": "700918443859411/1000000000000000000" + }, + "complex_profile": { + "L": 0, + "N": 1320, + "W": 12052, + "child_multiplicities": { + "1": 87534, + "10": 2790, + "11": 1062, + "12": 3591, + "13": 381, + "14": 2226, + "15": 5637, + "16": 264, + "17": 243, + "18": 7959, + "19": 501, + "2": 39834, + "20": 66, + "3": 29769, + "4": 12627, + "5": 5850, + "6": 4815, + "7": 2118, + "8": 4593, + "9": 1287 + }, + "m": 66, + "maxchild": 20, + "total_rank": 794112 + }, + "eta": "1/1000000000000000000000000", + "kappa": "1366380910073/2000000000000000", + "kappa_float": 0.0006831904550365, + "ordinary_chain": [ + "546573370825043616599485038841961823/800000000000000000000000000000000000000", + "109385155514905442426418537664349652181461624755757237/160000000000000000000000000000000000000000000000000000000", + "21877040740002110769946254600167413306868853489797819501857050278676903/32000000000000000000000000000000000000000000000000000000000000000000000000", + "4375408149318106538866216854671930632866706725794304565219529058788314814256861959639757/6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "scope": "Conditional finite supplier certificate; retained all-size interfaces and analytic assumptions", + "status": "PASS_EXACT_47_CONSTRAINT_ASSEMBLY" +} diff --git a/research/complex-bank-run3/references/pr219-run1/NOTICE.md b/research/complex-bank-run3/references/pr219-run1/NOTICE.md new file mode 100644 index 0000000000..03c71d90f2 --- /dev/null +++ b/research/complex-bank-run3/references/pr219-run1/NOTICE.md @@ -0,0 +1,36 @@ +# NOTICE + +## Provenance + +Package construction and the enumeration/schedule/arithmetic/verification code: +prepared for the CrocSwap/integer-mult-bounds queue with **OpenAI Codex +assistance**, 2026-10-10. + +## Vendored sources (byte-identical, sha256-pinned in SOURCE.json) + +- `interval_moment.py` — PR200's exact rational interval moment engine + (Chafik Boukhalfa, `research/paired-cube-diagonal-bit-168/arithmetic/`, + package Apache-2.0). +- `paired_cube_assembly.py` — the unchanged balanced assembly + (PR168-v4/PR184 lineage via ikeboy's PR193 tree; original attributions retained). +- `banks.py` — incidence colouring helpers (Evan McKinney, PR197, Apache-2.0; + vendored via rohanarun's PR205 package). +- `references/pr193-source-assisted-v4.certificate.json` — ikeboy's PR193 complex + supplier certificate (unchanged; its own credits and AI disclosures stand). +- `references/pr200-bit.certificate.json` — Chafik Boukhalfa's PR200 bit word + certificate (unchanged). +- `references/pr205-packed.certificate.json` — rohanarun's PR205 packed-row + certificate (unchanged). + +All mathematical content of the vendored files is the work of their authors as +credited in the upstream packages. The new content of this package is the rank-22 +enumeration (derived from the pinned PR200 word), the absorption schedule, the +retained-ledger arithmetic and the obligation statement. + +## AI assistance disclosure + +The new code, enumeration and text in this package were prepared with OpenAI Codex +(GPT-class model) assistance. The exact arithmetic is machine-replayed by +`verify.py`; the mathematical claims remain conditional as stated in PROOF.md. + +Apache-2.0. diff --git a/research/complex-bank-run3/references/pr219-run1/PROOF.md b/research/complex-bank-run3/references/pr219-run1/PROOF.md new file mode 100644 index 0000000000..63d45a6d98 --- /dev/null +++ b/research/complex-bank-run3/references/pr219-run1/PROOF.md @@ -0,0 +1,94 @@ +# Construction argument and scope + +## Claim + +On the retained multiplication interfaces, absorbing the rank-22 residual family of +the PR200/PR205 terminal-modified bit word into the banks yields the conditional +exponent + + kappa = 700427501305159 / 10^18 = 0.000700427501305159 + +with the complex supplier binding. This is certified **at the accounting level** +(Steps 1–4 below, all machine-replayed by `verify.py`) and is **conditional on the +physical realization obligations R1–R4** (`obligations.json`). + +## Step 1 — the absorbed family is exactly enumerated + +`inputs/absorbed-occurrences.json` lists every rank-22 ledger child of the per-vertex +histogram with its provenance, derived from the pinned PR200 word +(`word_p12.json`, `frames_p12.json`, the bit certificate and the base checker, all +sha256-pinned in that file): 1,320 physical-chain frame jumps, 24 copied-centre +children, 880 source-chain frame jumps, 0 target jumps — 2,224 per vertex, i.e. the +full `hist[22] = 6,672` bin under the row's factor-3 normalization. No other bin is +touched. + +## Step 2 — whole-bank volume and retained ledger + +Under the three-copy integer normalization of the published packed row +(W = 56,402, rank mass 4,055,136, deficit 5,808, 877,638 children): + +* absorbed volume `22 × 20,016 = 440,352` registers = `72 × 6,116` whole banks; +* retained mass `3,614,784`, retained children `857,622`, largest child 21; +* row identity `72·50,286 − 3,614,784 = 5,808`, deficit unchanged, stock drop + `56,402 − 50,286 = 6,116` exactly the bank count. + +This is the accounting form of "absorbing a family into the banks drops its dirt +and, by the row identity W = (mass + D)/m, drops the stock with it" (PR #208). +`schedule.py` also enumerates every block tiling of width 72 over the word's +residual families {4, 24} plus the new 22-blocks and checks pattern divisibility. + +## Step 3 — exact paid moments + +`arithmetic.py` prices the absorbed profile with PR200's exact rational interval +moment engine, including the complete worst-case envelope (bad fraction 10^-16, +fallback `32·72²` per retained child). Before the absorption is applied the same +pipeline reproduces PR #205's certified packed coarse saving +`683528191056257/10^18` **to the digit**, which validates the engine against a +published certificate. + +* complex coarse saving (unchanged): `700918443859411/10^18`; +* bit coarse saving before absorption: `683528191056257/10^18`; +* bit coarse saving after absorption: `728251090009891/10^18` — the bit word now + clears the complex cap `7.009184e-4`; +* three-level finite ordinary composition from PR200's completed ordinary supplier + gives the bit leaf `≈ 7.282510899902281e-4`, strictly above the complex cap. + +## Step 4 — balanced assembly + +The unchanged 47-constraint balanced assembly (eta = beta = 10^-24, weak = 10^-30) +takes `a = min(bit leaf, (1−β)·b − weak)`. The bit leaf clears the cap, so +`a = (1−β)·b − weak` and the complex branch binds: + + kappa = 700427501305159 / 10^18 = 0.000700427501305159 + +All 47 strict constraints and 7 margins are positive; the adjacent grid point +`kappa + 10^-18` is rejected by the same assembly. This is the exact 10^-18-grid +sharpening of PR #208's priced rung-1 target `7004273/10^10`. + +## What remains conditional (R1–R4) + +The rank-22 bin is not the gauge-exterior species the current bank construction +absorbs: it is frame-transition increments. Non-gauge chains already bank their +residual projectors and keep every increment child, so the published mechanism +cannot absorb this family — this is exactly the "genuinely different residual type" +the suppliers' crossover notes reserve. A completed finite witness must add: + +* R1: the residual-type definition, block shapes and per-occurrence block + assignment (schedule.py supplies the admissible tilings); +* R2: formal-column replay of the modified word (F2 identity and defining-integer + decoder) under bank re-assignment at the enumerated transitions; +* R3: exact charts, incidence colouring and prime witnesses for the new blocks; +* R4: moment-envelope parity (any completion child R1 introduces must be added to + the ledger and the kappa recomputed). + +Until then the claim is an accounting construction and certified target, in the +same sense every repository witness is conditional on its stated interfaces — and +strictly more limited than the published witnesses, which have their physical +realizations built and replayed. + +## Inherited conditions + +The retained analytic, uniform-recursion, fixed-tape, all-size compiler, selector, +routing, precision and finite-bridge hypotheses of the PR184/PR186/PR193/PR200 +lineage are inherited, not proved. This is not an unconditional multiplication +theorem, a formal verification of the algorithm, or a runtime benchmark. diff --git a/research/complex-bank-run3/references/pr219-run1/README.md b/research/complex-bank-run3/references/pr219-run1/README.md new file mode 100644 index 0000000000..ab1664287a --- /dev/null +++ b/research/complex-bank-run3/references/pr219-run1/README.md @@ -0,0 +1,90 @@ +# Building PR208's priced target: rank-22 residual bank absorption + +This package **builds the accounting construction** that PR #208 priced and left +unbuilt — the first certified-shape rung of its bank-absorption ladder: absorb the +bit word's **rank-22 residual family** into the banks — and states precisely what a +physical realization must still supply. + +Under the retained multiplication interfaces, the certified accounting target is + +$$ +T(n)=O\left(n(\log n)^{1-\kappa}\right),\qquad +\kappa=\frac{700427501305159}{10^{18}}=0.000700427501305159, +$$ + +**conditional on the physical realization obligations R1–R4** in +[obligations.json](obligations.json). The binding branch is the unchanged complex +supplier: the absorbed bit word clears the complex cap, so κ sits at the complex +side's own value, exactly as PR #208's rung table predicts (`7004273/10^10` on its +10^-10 pricing grid; this package certifies the finer 10^-18 grid point). + +| | κ | status | +| --- | --- | --- | +| main reviewed (#186) | 6.61885549259598e-4 | published | +| #205 packed diagonal bit | 6.83061299399923e-4 | verified this queue | +| #210 shared entrance gauges | 6.83883297459132e-4 | verified this queue | +| **this package, rank-22 absorption** | **7.00427501305159e-4** | **accounting certified; R1–R4 open** | +| #208's priced rung-1 target | 7.004273e-4 | model price (superseded by the exact grid above) | + +That is **+2.42% over #210's frontier** (+2.52% over the #207 row #208 priced) and +**+5.82% over main** — the complex +supplier's own cap, with no complex-side work, exactly the move #208 priced. + +## What is new and machine-checked + +1. **The absorbed family, with provenance.** The rank-22 ledger bin is enumerated + occurrence by occurrence from the pinned PR200 word + ([inputs/absorbed-occurrences.json](inputs/absorbed-occurrences.json)): + 1,320 physical-chain frame jumps, 24 copied-centre children and 880 source-chain + frame jumps per vertex — 2,224 × 3 = 6,672 ledger children. This is not the + banked gauge-exterior species: non-gauge chains already bank their residual + projectors and keep every increment child, so this family is the *"future + genuinely different residual type"* PR #207's crossover notes reserve. +2. **The whole-bank schedule.** Dirt volume `22 × 20,016 = 440,352 = 72 × 6,116` + fills whole banks; the stock drop equals the bank count exactly; the retained + ledger (857,622 children, largest 21) satisfies the row identity + `72·50,286 − 3,614,784 = 5,808` with the deficit unchanged + ([schedule.py](schedule.py)). +3. **Exact arithmetic to the κ.** Both rational interval moment engines, the + three-level finite ordinary composition and the unchanged 47-constraint + balanced assembly, with the adjacent 10^-18 grid point **excluded** + ([arithmetic.py](arithmetic.py)). The engine reproduces PR #205's certified + packed coarse saving to the digit before the absorption is applied — the + pipeline is validated against a published certificate, not just self-consistent. + +## What is not built here + +The physical realization of the new residual type: the banked word's formal +columns (F2 identity and defining-integer decoder) under the modified transitions, +the block assignment, charts, incidence colouring and prime witnesses. These are +stated one-to-one against the gauge-family precedent in +[obligations.json](obligations.json) (R1–R4, all OPEN). Until they verify, this is +an **accounting construction and a certified target**, not a completed finite +witness — the same distinction PR #208 draws ("priced target, not built"), moved +one full step forward: the target is now certified to the grid point, the family is +enumerated, and the remaining work is a closed checklist. + +As every result in this repository: conditional on the retained analytic, +uniform-recursion, fixed-tape and finite-bridge interfaces; never an unconditional +multiplication theorem. + +## Reproduce + +```sh +python3 -B verify.py # read-only replay, ~1 minute +python3 -B verify.py --write # authoring only +``` + +Python 3.11+, assertions enabled. No network, no git, no scratch space. + +## Credits + +The absorbed word and its checkers: Chafik Boukhalfa (#200). Complex supplier: +ikeboy (#193/#202 lineage). Bank mechanism: Evan McKinney (#197), realized on this +word by rohanarun (#205); completed entrance banks: PR #186/#207 (Dugongue) and the +BANK-PROOF-PR200.md argument. The pricing model this builds: maxime-fleury (#204, +#208), whose rung-1 target is reproduced and sharpened here. Frame/ceiling context: +rohanarun (#211/#213), eumemic (#210), DaysSky (#192/#201/#212). All retained +upstream attributions of the PR168/PR184 lineage stand. + +Prepared with OpenAI Codex assistance. Apache-2.0. diff --git a/research/complex-bank-run3/references/pr219-run1/SOURCE.json b/research/complex-bank-run3/references/pr219-run1/SOURCE.json new file mode 100644 index 0000000000..db23ea92f3 --- /dev/null +++ b/research/complex-bank-run3/references/pr219-run1/SOURCE.json @@ -0,0 +1,12 @@ +{ + "files": { + "banks.py": "0548a1c15bd6f6dea4505f5fd2ca1bb4ecbe914c8c90769b8cd8beeef428d0cf", + "inputs/absorbed-occurrences.json": "1aedd8640818afe63eb7797f0332b915ed64ebeea3e9f210aaf40a06a02478a7", + "interval_moment.py": "9d3d1d28bfb3375958995205179b171fb65c70a3792cf9f7a21ef5ee54f5460b", + "obligations.json": "0268fc3628421bb930e9f56a23469a45f3b2bfae8888f6030622c2a51ce6a511", + "paired_cube_assembly.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "references/pr193-source-assisted-v4.certificate.json": "d84406d2fcc6990deba2b135509e6d86600e57123d88f9b21f7b7240e1aeb513", + "references/pr200-bit.certificate.json": "853afa75980e11ce16b333c28311c4f635e84065867c049fda9916c2419091ed", + "references/pr205-packed.certificate.json": "c11fbb9aaa99594afc8d21e33761dc6d1d6c76ce3dbc36d5b64cae872c242f5a" + } +} diff --git a/research/complex-bank-run3/references/pr219-run1/arithmetic.py b/research/complex-bank-run3/references/pr219-run1/arithmetic.py new file mode 100644 index 0000000000..7de1b126bd --- /dev/null +++ b/research/complex-bank-run3/references/pr219-run1/arithmetic.py @@ -0,0 +1,148 @@ +#!/usr/bin/env python3 +"""Exact paid moments, finite ordinary-leaf composition and the balanced assembly +for the rank-22-absorbed profile. + +Inherited machinery (vendored byte-identically): + interval_moment.py - PR200's exact rational interval moment engine + paired_cube_assembly.py - PR184/PR168-v4's unchanged 47-constraint balanced assembly +Profiles come from the pinned certificates and schedule.py's retained ledger. +""" +import importlib.util +import json +import sys +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.dont_write_bytecode = True +if hasattr(sys, 'set_int_max_str_digits'): + sys.set_int_max_str_digits(0) + + +def load(name, path): + s = importlib.util.spec_from_file_location(name, path) + m = importlib.util.module_from_spec(s) + s.loader.exec_module(m) + return m + + +def profile(m, W, H, delta): + H = {int(r): int(n) for r, n in H.items()} + return dict(m=m, W=W, child_multiplicities=H, N=delta, L=0, + total_rank=sum(r * n for r, n in H.items()), maxchild=max(H)) + + +def paid(im, row, a, bit): + result = im.moment(row, a) + if bit: + l, u = im.log_interval(Q(row['m'])) + e, f = im.exp_interval(a * l, a * u) + w = Q(1, 10 ** 16) * Q(32 * row['m'] * sum(row['child_multiplicities'].values()), row['W']) + result.update(lower=result['lower'] + w * e, upper=result['upper'] + w * f) + return result + + +def certify(im, row, bit): + den = 10 ** 18 + lo = 0 + hi = den // 100 + assert paid(im, row, Q(lo, den), bit)['upper'] < 1 < paid(im, row, Q(hi, den), bit)['lower'] + while hi - lo > 1: + mid = (lo + hi) // 2 + v = paid(im, row, Q(mid, den), bit) + if v['upper'] < 1: + lo = mid + elif v['lower'] > 1: + hi = mid + else: + raise AssertionError('Interval inconclusive') + a = Q(lo, den) + b = Q(hi, den) + return dict(saving=a, accepted=paid(im, row, a, bit), next_excluded=paid(im, row, b, bit)) + + +def build(schedule): + im = load('interval_moment', HERE / 'interval_moment.py') + assembly = load('frontier_assembly', HERE / 'paired_cube_assembly.py') + c191 = json.loads((HERE / 'references/pr193-source-assisted-v4.certificate.json').read_text()) + b200 = json.loads((HERE / 'references/pr200-bit.certificate.json').read_text())['bit'] + pack = json.loads((HERE / 'references/pr205-packed.certificate.json').read_text())['physical'] + + cp_raw = c191['complex_profile'] + cp = profile(cp_raw['m'], cp_raw['W_per_vertex'], cp_raw['child_histogram'], cp_raw['deficit_per_vertex']) + packed = profile(72, pack['W'], pack['child_histogram'], pack['deficit']) + + kept = schedule['retained_profile'] + absorbed = profile(72, kept['W_after'], kept['histogram'], kept['deficit']) + assert absorbed['total_rank'] == kept['rank_mass_after'] + assert absorbed['maxchild'] == kept['maxchild'] + + complex_cert = certify(im, cp, False) + before = certify(im, packed, True) + after = certify(im, absorbed, True) + # The engine must reproduce PR205's certified packed coarse saving exactly. + certified_packed_saving = Q(json.loads((HERE / 'references/pr205-packed.certificate.json').read_text()) + ['arithmetic']['bit_after']['saving']) + assert before['saving'] == certified_packed_saving, 'engine drift: packed row not reproduced' + + old = Q(b200['coarse']['ordinary_saving']) + coarse = after['saving'] + chain = [old] + for _ in range(3): + a = (1 - coarse) * coarse + coarse * chain[-1] + assert chain[-1] < a < coarse < 1 - a + chain.append(a) + leaf = chain[-1] + + bridge = c191['assembly']['finite_bridge'] + bridge['rows']['degree_gap'] = Q(bridge['rows']['degree_gap']) + beta = eta = Q(1, 10 ** 24) + weak = Q(1, 10 ** 30) + den = 10 ** 18 + + def assemble(bit_saving): + b = complex_cert['saving'] + a = min(bit_saving, (1 - beta) * b - weak) + q = a * (1 - 2 * eta) + bound = (1 - eta) * q / (1 + q) + z = bound * den + k = Q((z.numerator - 1) // z.denominator, den) + out = assembly.assembly(a, b, bridge, k, eta=eta, beta=beta) + assert len(out['strict_constraints']) == 47 and len(out['margins']) == 7 + try: + assembly.assembly(a, b, bridge, k + Q(1, den), eta=eta, beta=beta) + except AssertionError: + pass + else: + raise AssertionError('Next final grid accepted') + constraints = out.pop('strict_constraints') + return dict(kappa=k, assembly=dict(out, strict_constraint_count=len(constraints), + minimum_constraint=min(constraints.values())), + binding='complex' if a == (1 - beta) * b - weak else 'bit') + + before_assembly = assemble(chain[0]) + after_assembly = assemble(leaf) + assert before_assembly['kappa'] < after_assembly['kappa'] + assert after_assembly['binding'] == 'complex', 'rank-22 absorption must clear the complex cap' + + return dict( + complex_coarse=complex_cert['saving'], + bit_coarse_before=before['saving'], + bit_coarse_after=after['saving'], + bit_before_next_excluded=before['next_excluded'], + bit_after_next_excluded=after['next_excluded'], + ordinary_seed=old, ordinary_chain=chain, ordinary_leaf=leaf, + before_assembly=before_assembly, after_assembly=after_assembly, + kappa_gain=after_assembly['kappa'] - before_assembly['kappa'], + ) + + +if __name__ == '__main__': + sys.path.insert(0, str(HERE)) + import schedule as sched + out = build(sched.build()) + for k, v in out.items(): + if isinstance(v, Q): + print(k, '=', v, float(v)) + elif isinstance(v, dict) and 'kappa' in v: + print(k, 'kappa =', v['kappa'], float(v['kappa']), 'binding', v['binding']) diff --git a/research/complex-bank-run3/references/pr219-run1/banks.py b/research/complex-bank-run3/references/pr219-run1/banks.py new file mode 100644 index 0000000000..6505ebd37e --- /dev/null +++ b/research/complex-bank-run3/references/pr219-run1/banks.py @@ -0,0 +1,104 @@ +"""PR197 chart inversion and bank colouring helpers (byte-identical extract of packing.py up to build()). + +Apache-2.0. Prepared with substantial OpenAI Codex assistance. +""" +from array import array +from collections import Counter +from fractions import Fraction as Q +from math import gcd +from pathlib import Path +import hashlib,json,sys + +def inverse_integer(a): + """Fraction-free Gauss-Jordan; return integral C,d with a C = d I.""" + n=len(a) + m=[list(row)+[int(i==j) for j in range(n)] for i,row in enumerate(a)] + previous=1 + factors=[] + for k in range(n): + pivot=next((i for i in range(k,n) if m[i][k]),None) + if pivot is None: + raise ValueError('Singular basis') + m[k],m[pivot]=m[pivot],m[k] + if pivot != k:factors.append(('swap',k,pivot,1,1)) + p=m[k][k] + if p != previous: + ratio=Q(previous,p) + factors.append(('scale',k,k,ratio.numerator,ratio.denominator)) + for i in range(n): + if i==k:continue + u=m[i][k] + if u: + ratio=Q(-u,previous) + factors.append(('add',i,k,ratio.numerator,ratio.denominator)) + for j in range(2*n): + if j==k:continue + value=p*m[i][j]-u*m[k][j] + assert value % previous==0 + m[i][j]=value//previous + m[i][k]=0 + previous=p + d=m[0][0] + assert d and all(m[i][j]==d*int(i==j) for i in range(n) for j in range(n)) + c=[row[n:] for row in m] + common=abs(d) + for row in c: + for x in row:common=gcd(common,x) + d//=common + c=[[x//common for x in row] for row in c] + if d<0:d=-d;c=[[-x for x in row] for row in c] + return c,d,factors + +def color_incidence(left,right,nleft,nright,colors): + """Incremental two-color swaps; parallel edges are identified separately.""" + assert len(left)==len(right) + full=(1<=1,'log interval domain') + base=Q(4,3);k=0 + while x>base:x/=base;k+=1 + def short(y): + z=(y-1)/(y+1);power=z;s=Q(0) + for j in range(LOG_TERMS):s+=power/Q(2*j+1);power*=z*z + lo=2*s;tail=2*power/(Q(2*LOG_TERMS+1)*(1-z*z)) + return lo,lo+tail + lo,hi=short(x);blo,bhi=short(base) + return lower(k*blo+lo),upper(k*bhi+hi) + +def exp_interval(lo,hi): + require(0<=lo<=hi1 and W>0,'profile dimensions') + raw=profile['child_multiplicities'];hist={int(t):n for t,n in raw.items()} + require(len(hist)==len(raw),'aliased histogram keys') + require(all(00 for t,n in hist.items()),'invalid child or multiplicity') + mass=sum(t*n for t,n in hist.items());require(mass==profile['total_rank']==W*m-profile['N']+profile['L'],'rank mass') + require(max(hist)==profile['maxchild'],'maximum child') + require(0=0,'nonnegative saving');lo=hi=Q(0);rows=[] + for t,n,L,U in prepare(profile): + E,F=exp_interval(a*L,a*U);w=Q(t*n,profile['m']*profile['W']);lo+=w*E;hi+=w*F + if details:rows.append(dict(child=t,multiplicity=n,log_lower=L,log_upper=U,exp_lower=E,exp_upper=F,contribution_lower=w*E,contribution_upper=w*F)) + result=dict(saving=a,lower=lo,upper=hi,strict_gap_lower=1-hi) + if details:result['terms']=rows + return result + +def saving_grid(profile,denominator=10**24): + require(type(denominator) is int and denominator>0,'positive saving grid') + prepare(profile);lo=0;hi=denominator//32;iterations=0 + require(moment(profile,Q(lo,denominator))['upper']<1,'initial contraction') + require(moment(profile,Q(hi,denominator))['lower']>1,'initial exclusion') + while hi-lo>1: + mid=(hi+lo)//2;m=moment(profile,Q(mid,denominator));iterations+=1 + if m['upper']<1:lo=mid + elif m['lower']>1:hi=mid + else:raise ValueError('Moment interval overlaps one; increase enclosure precision') + accepted=moment(profile,Q(lo,denominator),True);rejected=moment(profile,Q(hi,denominator),True) + require(accepted['upper']<1 bank, offset) generated and hashed.", + "reference_precedent": "PR205 packing.py: 'For each role, the inherited fixed normalizer sends its true residual projector to its assigned block'; BANK-PROOF-PR200.md block allocation with 9-edge-colouring of 462,078 role-copy uses.", + "status": "OPEN" + }, + { + "id": "R2", + "name": "formal columns of the modified word", + "statement": "Re-run the complete formal-column checks on the modified word: every source, target and dirty-register column over F2 and over the defining integers (residual bound and packed digits as in PR200's terminal-modified replay), with the rank-22 transitions realized by bank re-assignment instead of paid children. The F2 identity and the defining-integer decoder must both hold.", + "reference_precedent": "PR200 paired-cube-diagonal-bit-168 verify.py: 'all formal source/target/dirty columns, complete target chronology... F2 identity and its defining integer decoder'.", + "status": "OPEN" + }, + { + "id": "R3", + "name": "charts, routing and prime witnesses", + "statement": "Exact charts (integer kernel bases with fraction-free inverses and replayed elementary factors) for every new block frame, the incidence colouring of the new bank incidences, and distinct integer Gram/prime witnesses for every frame the new blocks use, with residual factors below the retained q bound.", + "reference_precedent": "PR205 packing.py chart digest and colouring checks; 'All 24,401 used bit frame IDs... distinct integer Gram witnesses'.", + "status": "OPEN" + }, + { + "id": "R4", + "name": "moment envelope parity", + "statement": "Confirm that the paid moment envelope for the modified word is exactly the one arithmetic.py prices: retained child histogram as in schedule.py, stock 50,286 (three-copy normalization), deficit 5,808, worst-case bad fraction 1e-16 and fallback 32*72^2 per retained child, strict adapter and internally borrowed-row tolls paid. Any additional completion child introduced by R1 must be added to the ledger and the kappa recomputed.", + "reference_precedent": "BANK-PROOF-PR200.md 'Fully charged child inventory and exact price'; PR205 arithmetic.py paid() wrapper.", + "status": "OPEN" + } + ], + "claim_scope": "verify.py certifies: enumeration provenance, whole-bank volume condition, retained ledger and row identity, both interval moment engines, three-level ordinary composition, the 47-constraint balanced assembly and the exclusion of the adjacent kappa grid point. The resulting kappa is conditional on R1-R4 exactly as every published witness in this repository is conditional on its stated finite bridge and all-size interfaces; it is not a completed finite witness until R1-R4 verify, and it is not an unconditional multiplication theorem in any case." +} diff --git a/research/complex-bank-run3/references/pr219-run1/paired_cube_assembly.py b/research/complex-bank-run3/references/pr219-run1/paired_cube_assembly.py new file mode 100644 index 0000000000..43007488ad --- /dev/null +++ b/research/complex-bank-run3/references/pr219-run1/paired_cube_assembly.py @@ -0,0 +1,58 @@ +#!/usr/bin/env python3 +"""Exact semantic assembly with the balanced prefix, for the paired-cube network. + +Prepared by eumemic with Anthropic Claude assistance. Apache-2.0. The 47 strict constraints, the seven margins and +the finite bridge are unchanged from icekylinx's scripts/structured_bulk_assembly.py (PR144, adapted from Zhihao +Chen's PR23). The prefix is the RaD project's (hipotures) balanced positional transform, reviewed in +references/semantic-bulk/rad20/reports/review-balanced-transform.md: the prefix margin becomes 1-eps instead of +1-eps(1+c), and eps(1+c)<1 remains a strict geometric condition (K_geometry) whose gap need not exceed kappa. +The parameters c=q+eta/4 and eps=(1-eta)/(1+q) are those of the reviewed balanced assembly in +research/copied-fixed/balanced_assembly.py, with its backoff h equal to eta. Nothing else differs from +structured_bulk_assembly.assembly. +""" +from fractions import Fraction as Q + + +def assembly(bit_saving,complex_saving,bridge,kappa,eta=Q(1,10**8),beta=Q(1,4)): + a,b=bit_saving,complex_saving + tau,sigma=1-a,1-b + q=a*(1-2*eta); lp=1-q; lam=(tau+lp)/2 + c=q+eta/4; eps=(1-eta)/(1+q) + minimum=eps*q; r=(minimum+1-eps)/2; delta=eta/8 + internal=tau+(1-beta)*max(sigma-tau,Q(0));leaf=sigma+beta*(1-sigma) + margins=dict(balanced_prefix=1-eps,coordinate_movement=a, + compact_phase_layer=minimum,bulk_exposure=a, + Gaussian_arithmetic=min(1-eps-delta,r-delta), + scalar_work=1-eps-delta,dimension=eps) + slacks=dict(bit_positive=a,complex_above_bit=b-a, + complex_below_one_over32=Q(1,32)-b,beta_positive=beta, + beta_below_one=1-beta,leaf_saving_above_bit=(1-beta)*b-a, + q_positive=q,q_below_internal=1-internal-q,q_below_leaf=1-leaf-q, + c_positive=c,c_below_one=1-c,q_below_reservations=c-q, + lambda_above_tau=lam-tau,lambda_above_sigma=lam-sigma, + lambda_above_internal=lam-internal,lambda_prime_above_lambda=lp-lam, + compact_leaf=lp-leaf,compact_reservations=lp-(1-c), + lambda_prime_below_one=q,epsilon_positive=eps,epsilon_below_one=1-eps, + guard_width=1-eps,K_geometry=1-eps*(1+c),K_dominates_log=eps*c, + record_suffix=1-eps,phase_local=1-eps-delta,phase_boundary=r-delta, + gamma_sublinear=1-eps-r,cell_above_band=eps-(1-r)/2, + prime_interval_packing=1-eps,alpha_positive=r,alpha_below_one=1-r, + alpha_below_one_fourth=Q(1,4)-r,delta_positive=delta, + delta_below_one_eighth=Q(1,8)-delta,short_record_fallback=eps-a, + small_field_exposure=1-eps-minimum, + artificial_boundary=8-eps+r-delta-minimum, + literal_scalar_guard=Q(bridge['semantic']['strict_literal_gap']), + row_product_gap=bridge['rows']['degree_gap']) + slacks.update({name+'_above_kappa':val-kappa for name,val in margins.items()}) + assert len(slacks)==47 and len(margins)==7 + assert all(v>0 for v in slacks.values()),{k:str(v) for k,v in slacks.items() if v<=0} + assert min(margins.values())==minimum + assert margins['balanced_prefix']-minimum==eta and 1-eps-r==eta/2 + assert 1-eps*(1+c)==eta-eps*eta/4 + return dict(parameters=dict(a_bit=a,a_complex=b,tau=tau,sigma=sigma, + eta=eta,beta=beta,q=q,c=c,epsilon=eps,lambda_=lam, + lambda_prime=lp,alpha_squared_power=r,delta=delta, + C0=bridge['semantic']['C0'],C1=1,kappa=kappa), + strict_constraints=slacks,margins=margins,minimum_margin=minimum, + absorption_gap=minimum-kappa, + recurrence=dict(internal=internal,leaf=leaf,reservations=1-c)) diff --git a/research/complex-bank-run3/references/pr219-run1/references/pr193-source-assisted-v4.certificate.json b/research/complex-bank-run3/references/pr219-run1/references/pr193-source-assisted-v4.certificate.json new file mode 100644 index 0000000000..1bf00cdb84 --- /dev/null +++ b/research/complex-bank-run3/references/pr219-run1/references/pr193-source-assisted-v4.certificate.json @@ -0,0 +1,599 @@ +{ + "assembly": { + "arithmetic": "32-term rational logarithm enclosure; rational exponential majorant; upward 2^120 rounding", + "assembly": { + "absorption_gap": "2173306316420487501395028271/104235961402452965120764469382500000000", + "margins": { + "Gaussian_arithmetic": "4434888062605206747739992174212247/6671101529756989767728926040480000000", + "balanced_prefix": "27718310981186048305787753/41694384560981186048305787753", + "bulk_exposure": "1663073692132636741/2500000000000000000000", + "compact_phase_layer": "2771789403734043849392726994212247/4169438456098118604830578775300000000", + "coordinate_movement": "1663073692132636741/2500000000000000000000", + "dimension": "41666666250000000000000000000/41694384560981186048305787753", + "scalar_work": "22174607090564277663444154094212247/33355507648784948838644630202400000000" + }, + "minimum_margin": "2771789403734043849392726994212247/4169438456098118604830578775300000000", + "parameters": { + "C0": { + "base": 2, + "exponent": 210000 + }, + "C1": 1, + "a_bit": "1663073692132636741/2500000000000000000000", + "a_complex": "219037/312500000", + "alpha_squared_power": "5543620501852648679971502294212247/8338876912196237209661157550600000000", + "beta": "1/1000000000", + "c": "83153995443558144917363259/125000000000000000000000000000", + "delta": "1/800000000", + "epsilon": "41666666250000000000000000000/41694384560981186048305787753", + "eta": "1/100000000", + "kappa": "103873/156250000", + "lambda_": "249833692632449810018032636741/250000000000000000000000000000", + "lambda_prime": "124916846317056441855082636741/125000000000000000000000000000", + "q": "83153682943558144917363259/125000000000000000000000000000", + "sigma": "312280963/312500000", + "tau": "2498336926307867363259/2500000000000000000000" + }, + "recurrence": { + "internal": "2498336926307867363259/2500000000000000000000", + "leaf": "312280963000219037/312500000000000000", + "reservations": "124916846004556441855082636741/125000000000000000000000000000" + }, + "strict_constraints": { + "Gaussian_arithmetic_above_kappa": "3144465292604952853634094307643/833887691219623720966115755060000000000", + "K_dominates_log": "2771799820400606349392726994212247/4169438456098118604830578775300000000", + "K_geometry": "31277717998481186048305787753/4169438456098118604830578775300000000", + "alpha_below_one": "8333333291694384560981186048305787753/8338876912196237209661157550600000000", + "alpha_below_one_fourth": "2079175607547206653735317885355787753/8338876912196237209661157550600000000", + "alpha_positive": "5543620501852648679971502294212247/8338876912196237209661157550600000000", + "artificial_boundary": "233510728315362744392100599764117363259/33355507648784948838644630202400000000", + "balanced_prefix_above_kappa": "65283307521309383669314982631/6514747587653310320047779336406250000", + "beta_below_one": "999999999/1000000000", + "beta_positive": "1/1000000000", + "bit_positive": "1663073692132636741/2500000000000000000000", + "bulk_exposure_above_kappa": "1105692132636741/2500000000000000000000", + "c_below_one": "124916846004556441855082636741/125000000000000000000000000000", + "c_positive": "83153995443558144917363259/125000000000000000000000000000", + "cell_above_band": "8333333208305615439018813951694212247/16677753824392474419322315101200000000", + "compact_leaf": "4461116968827055082636741/125000000000000000000000000000", + "compact_phase_layer_above_kappa": "2173306316420487501395028271/104235961402452965120764469382500000000", + "compact_reservations": "1/400000000", + "complex_above_bit": "89222307867363259/2500000000000000000000", + "complex_below_one_over32": "2386647/78125000", + "coordinate_movement_above_kappa": "1105692132636741/2500000000000000000000", + "delta_below_one_eighth": "99999999/800000000", + "delta_positive": "1/800000000", + "dimension_above_kappa": "6506085680754997201261604332908732631/6514747587653310320047779336406250000", + "epsilon_below_one": "27718310981186048305787753/41694384560981186048305787753", + "epsilon_positive": "41666666250000000000000000000/41694384560981186048305787753", + "gamma_sublinear": "1/200000000", + "guard_width": "27718310981186048305787753/41694384560981186048305787753", + "lambda_above_internal": "1663073692132636741/250000000000000000000000000000", + "lambda_above_sigma": "8922232449810018032636741/250000000000000000000000000000", + "lambda_above_tau": "1663073692132636741/250000000000000000000000000000", + "lambda_prime_above_lambda": "1663073692132636741/250000000000000000000000000000", + "lambda_prime_below_one": "83153682943558144917363259/125000000000000000000000000000", + "leaf_saving_above_bit": "89222306115067259/2500000000000000000000", + "literal_scalar_guard": "1", + "phase_boundary": "4434888062605206747739992174212247/6671101529756989767728926040480000000", + "phase_local": "22174607090564277663444154094212247/33355507648784948838644630202400000000", + "prime_interval_packing": "27718310981186048305787753/41694384560981186048305787753", + "q_below_internal": "1663073692132636741/125000000000000000000000000000", + "q_below_leaf": "4461116968827055082636741/125000000000000000000000000000", + "q_below_reservations": "1/400000000", + "q_positive": "83153682943558144917363259/125000000000000000000000000000", + "record_suffix": "27718310981186048305787753/41694384560981186048305787753", + "row_product_gap": "23971789/25", + "scalar_work_above_kappa": "7313903748703071458464673082943/833887691219623720966115755060000000000", + "short_record_fallback": "104097324790926971012489935942936887957665004367027/104235961402452965120764469382500000000000000000000", + "small_field_exposure": "1/100000000" + } + }, + "assembly_source_sha256": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "author": "GPT-6 Astra", + "bit": { + "atom_exponent": "665229477/1000000000000", + "bad_moment_upper": "117582529126019651412906681804448786687653/36989922820202112025651255849363963904000000000000000", + "counts": { + "W": "21372", + "delta": "1936", + "edge_count": "294026", + "histogram": { + "1": "120168", + "10": "2574", + "11": "762", + "12": "3924", + "13": "1986", + "14": "3960", + "15": "1296", + "16": "2820", + "17": "1494", + "18": "1728", + "19": "1314", + "2": "63436", + "20": "5280", + "21": "11160", + "22": "11952", + "3": "29616", + "4": "8904", + "5": "8196", + "6": "3660", + "60": "2200", + "7": "3642", + "8": "2076", + "9": "1878" + }, + "m": 72, + "mass": "1536848", + "maxchild": 60 + }, + "effective_saving": "1663073692132636741/2500000000000000000000", + "effective_saving_decimal": "6.652294768531e-04", + "ideal_moment_upper": "39334514849934151305037973577749238577213/39334514851267230510969458527815956692992", + "ordinary_leaf_saving": "384599/10000000000", + "saving": "6656467/10000000000", + "strict_gap_lower": "30672985926701579472139284249731054634433369/998727916145457024692583907932827025408000000000000000", + "strict_gap_lower_decimal": "3.071205423503e-11" + }, + "complex": { + "bad_moment_upper": "0", + "counts": { + "W": "12052", + "delta": "1320", + "edge_count": "213147", + "histogram": { + "1": "87534", + "10": "2790", + "11": "1062", + "12": "3591", + "13": "381", + "14": "2226", + "15": "5637", + "16": "264", + "17": "243", + "18": "7959", + "19": "501", + "2": "39834", + "20": "66", + "3": "29769", + "4": "12627", + "5": "5850", + "6": "4815", + "7": "2118", + "8": "4593", + "9": "1287" + }, + "m": 66, + "mass": "794112", + "maxchild": 20 + }, + "ideal_moment_upper": "8009927901769221530141375505975603941953/8009927902599903050118341345249356414976", + "saving": "219037/312500000", + "strict_gap_lower": "830681519976965839273752473023/8009927902599903050118341345249356414976", + "strict_gap_lower_decimal": "1.037064915038e-10" + }, + "construction_receipts": { + "bit_high_boundary_sha256": "322f2dbbaa0177fa9c4fc8ea3d592bd20074a2d3ff8d0e98c3230d5f1fdd58ec", + "bit_low_checks": { + "all_rank3_fresh_complements_retained": true, + "every_required_fresh_output_verified": true, + "every_source_pair_inside_its_rank3_frame": true, + "exact_two_sided_inverse_on_every_instance": true, + "full_source_control_span_present_in_both_phases_of_every_M": true, + "no_old_rank2_operation_frame_equals_a_source_M": true, + "source_controls_unchanged": true + }, + "bit_low_instances_sha256": "162503d35f76776308baec3410757bebb7a1f106ae45fee907c75f6edb01b4de", + "complex_endpoint_checks": { + "all_centers_in_phase1": true, + "all_fresh_columns_equal_identity": true, + "all_target_cap_reads_in_phase2": true, + "arithmetic": "integers, endpoint scaled by 6", + "checked_source_columns": 1320, + "checked_target_rows": 1320, + "controls_before_original_K": true, + "original_source_V_before_all_controls": true, + "positive_target_data_histogram": { + "1": 3960, + "18": 1320 + }, + "read_counts": { + "center": 22, + "deferred": 2310, + "side": 3135 + }, + "source_controls_at_paid_parity_frames": true, + "target_chains_nested": true, + "target_data_histogram": { + "0": 6270, + "1": 3960, + "18": 1320 + } + }, + "complex_lift_certificate_sha256": "1d81a79bda88b8a0ef64b7ae815c0d20cf1eee7f4714053530805bbb39e89ef2", + "proof_sha256": { + "bit/SOURCE_ALIGNED_BIT_WORD.txt": "29a25a95492fa5054f16768f23612e1b3ec8d034130a28f77df863bb38ee5693", + "bit/source_aligned_lifts.json": "f6759116094f8fe0d048cef95eb4c7f52b08ac304bc55bcdd3c165e95f3aed6c", + "global/COMMON_FRAME_LIFT_AND_GLOBAL_CONTRACT.txt": "102a012e8938d60d0d7e5360b7088f317c51e42a148288882612b8635a463d16", + "global/FINITE_BRIDGE.txt": "66d8f4ea8752abd89952d6674a636575a0db16e18b1c16e293f48f64242f0c46" + }, + "status": "Constructive exact flow and fixed-boundary proofs; literal globally renumbered program/replay remains a downstream integration task" + }, + "doubling_achieved": false, + "finite_bridge": { + "proof": "FINITE_BRIDGE.txt", + "representation": "Exact powers of two with proved dominating bounds", + "rows": { + "coefficient": 20161, + "degree": 1000000, + "degree_gap": "23971789/25", + "suffix_slope": 4000000 + }, + "semantic": { + "B_upper": { + "base": 2, + "exponent": 100001 + }, + "C0": { + "base": 2, + "exponent": 210000 + }, + "C1": 1, + "E": { + "base": 2, + "exponent": 100000 + }, + "G": { + "base": 2, + "exponent": 30000 + }, + "induction_gap_lower": 1, + "strict_literal_gap": 1 + } + }, + "fixed_doubling_target": "4609169/5000000000", + "kappa": "103873/156250000", + "kappa_decimal": "6.647872000000e-04", + "ratio_to_reviewed_baseline": "6647872/4609169", + "ratio_to_reviewed_baseline_decimal": "1.442314655852e+00", + "reviewed_baseline": "4609169/10000000000", + "source_sha256": { + "bit": "e1d07bf5d5b2d4884137da84745b6f5eea642b0cea4cb6472dd307c7b2d1659b", + "complex": "7a18aa3afefe3c79778b938eb221cb047273f9d4a9f2acdc161439ade587861d" + }, + "status": "Exact arithmetic; construction and finite bridge are explicit proof dependencies" + }, + "binding_supplier": "bit", + "bit_effective_saving": "1663073692132636741/2500000000000000000000", + "complex_gain_over_pr184": "13701/205336", + "complex_profile": { + "W_per_vertex": 12052, + "child_histogram": { + "1": 87534, + "10": 2790, + "11": 1062, + "12": 3591, + "13": 381, + "14": 2226, + "15": 5637, + "16": 264, + "17": 243, + "18": 7959, + "19": 501, + "2": 39834, + "20": 66, + "3": 29769, + "4": 12627, + "5": 5850, + "6": 4815, + "7": 2118, + "8": 4593, + "9": 1287 + }, + "contract_checks": { + "all_centers_in_phase1": true, + "all_fresh_columns_equal_identity": true, + "all_target_cap_reads_in_phase2": true, + "arithmetic": "integers, endpoint scaled by 6", + "checked_source_columns": 1320, + "checked_target_rows": 1320, + "controls_before_original_K": true, + "original_source_V_before_all_controls": true, + "positive_target_data_histogram": { + "1": 3960, + "18": 1320 + }, + "read_counts": { + "center": 22, + "deferred": 2310, + "side": 3135 + }, + "source_controls_at_paid_parity_frames": true, + "target_chains_nested": true, + "target_data_histogram": { + "0": 6270, + "1": 3960, + "18": 1320 + } + }, + "deficit_per_vertex": 1320, + "entropy": "1.881413992826e+06", + "exact_lift_certificate_path": "research/source-assisted-v4/.work/lift.certificate.json.gz", + "exact_lift_certificate_sha256": "1d81a79bda88b8a0ef64b7ae815c0d20cf1eee7f4714053530805bbb39e89ef2", + "exact_scalar_program_sha256": "3b4e671d7c6630570b04788bb2c81629e2c52f8dc2fcc5805952f0b403921027", + "h": 22, + "local_histogram": { + "1": 23898, + "10": 930, + "11": 354, + "12": 1197, + "13": 127, + "14": 742, + "15": 1879, + "16": 88, + "17": 81, + "18": 13, + "19": 167, + "2": 11078, + "20": 22, + "3": 9923, + "4": 4209, + "5": 1950, + "6": 1605, + "7": 706, + "8": 1531, + "9": 429 + }, + "loss": 440, + "m": 66, + "numerical_local_root": "7.009184438594e-04", + "physical_R": 9412, + "physical_gauge_histogram": {}, + "proof_chain_sha256": { + "research/source-assisted-v4/.work/aligned/cache/frames.json": "434b81507ebb6e20aa73508d9ac01011fa1b785204363a5eee2eea59256e4b70", + "research/source-assisted-v4/.work/aligned/cache/graph.json": "a4d350feb76f2ddcffa409d079bf479c04afd65af2d6b6e96a2ea157019d78d5", + "research/source-assisted-v4/.work/aligned/cache/record.json": "2065cbaa22c87198a4d535119534e05fab4a258445ecda00cf3cbb9151cfcc30", + "research/source-assisted-v4/.work/aligned/cache/selection.json": "dfc2cd63e23473ee2a55aca490bde08566b5a8828a9826b9bea8e2ca84fbe22a", + "research/source-assisted-v4/.work/aligned/references/paired-cube/physical/frames.json": "1a6c215cdc58216f7ec96fb898a471e25d094fd86de085f6c06e86fd8997bfad", + "research/source-assisted-v4/.work/aligned/references/paired-cube/physical/pairs.json": "abf341935148071a2222fe61c430e4e2fe3d16a64db14ab4eed9cd9a5a0f54d3", + "research/source-assisted-v4/.work/flow.json": "ecc1b61843c40303516f05721d708e3f8183ba9c7fea2551da45028d557f7af3", + "research/source-assisted-v4/.work/flow.witness.json": "51da02c6cd844276ca26608f1b714ab07d476ec25634ad1a9b461ccda2fbe457", + "research/source-assisted-v4/.work/lift.certificate.json.gz": "1d81a79bda88b8a0ef64b7ae815c0d20cf1eee7f4714053530805bbb39e89ef2", + "research/source-assisted-v4/.work/lift.json": "c41fee34c5c6e036ed9242ea6c19f32988aa21753b83e79513c890804cc469ae", + "research/source-assisted-v4/contract_v4.py": "67da183217adbe28915391c8cd0c8c4ec9c9dedead54a641a2de23834df2342c", + "research/source-assisted-v4/data/kernel-pairs.json": "f1535677d1ec225a3a132b2da0f6da9613b7b814227647b288c4e298ec26d8d3", + "research/source-assisted-v4/data/physical-pairs.json": "7095501f054e9ec18aa212bfed1b01e497ca2ae997f4c9ece2779909b3fd72e2", + "research/source-assisted-v4/source_aligned_local_v4.py": "3e11a7418bf1f3b51674b45e4dded184cf1599338c4c3911e145f58c8c15a969", + "research/source-assisted-v4/verify.py": "734d17c2b12d50d4190d7f1c6e17038b3f0e6e1b444db6e0ba663f0d891364a6", + "research/source-assisted/decision/complex_frame_flow.py": "5ea4f32f4eb0b19816a0b98272592f9dc0e9cbc448ce5eb7907ba113233dcc86", + "research/source-assisted/decision/exact_complex_flow_lift.py": "9d841bcfdc7c9c19b31791e8d7cfebd223d80d5e9ecd376d26257244f5323f2e" + }, + "rank_per_vertex": 794112, + "regeneration": "Run source_aligned_local_v4.py, PR184 complex_frame_flow.py with source purification and frozen kernel reuse, PR184 exact_complex_flow_lift.py, and this checker on the PR168 v4 producer cache. No frozen large cache is required.", + "scalar_coefficients": [ + [ + -2, + 1 + ], + [ + -1, + 1 + ], + [ + -1, + 2 + ], + [ + 1, + 2 + ], + [ + 1, + 1 + ], + [ + 2, + 1 + ] + ], + "scalar_denominator_lcm": "2", + "signature": "GPT-6 Astra", + "source_data_histogram": { + "1": 1320, + "18": 1320, + "2": 1320 + }, + "status": "Exact local invertible flow, exact all-column fresh identity, paid source controls, target read chains, and integer histogram certified. A literal globally renumbered operation program is not exported; dense initial dirty-response subtraction is defined by the exact certified flow.", + "target_data_histogram": { + "0": 6270, + "1": 3960, + "18": 1320 + }, + "terminal_sink_substitutions": 0, + "v": 1320 + }, + "complex_saving": "219037/312500000", + "flow": { + "baseline_entropy": "2.264636168006e+06", + "birth_histogram": { + "1:1": 2640, + "1:10": 22, + "1:3": 2016, + "1:5": 154, + "1:6": 88, + "2:10": 74, + "2:11": 5, + "2:12": 57, + "2:13": 11, + "2:14": 92, + "2:15": 47, + "2:16": 37, + "2:17": 39, + "2:3": 1548, + "2:4": 503, + "2:5": 396, + "2:6": 94, + "2:7": 23, + "2:8": 241, + "2:9": 5 + }, + "cache_sha256": { + "frames.json": "434b81507ebb6e20aa73508d9ac01011fa1b785204363a5eee2eea59256e4b70", + "graph.json": "a4d350feb76f2ddcffa409d079bf479c04afd65af2d6b6e96a2ea157019d78d5", + "record.json": "2065cbaa22c87198a4d535119534e05fab4a258445ecda00cf3cbb9151cfcc30", + "selection.json": "dfc2cd63e23473ee2a55aca490bde08566b5a8828a9826b9bea8e2ca84fbe22a" + }, + "child_histogram": { + "1": 87534, + "10": 2790, + "11": 1062, + "12": 3591, + "13": 381, + "14": 2226, + "15": 5637, + "16": 264, + "17": 243, + "18": 7959, + "19": 501, + "2": 39834, + "20": 66, + "3": 29769, + "4": 12627, + "5": 5850, + "6": 4815, + "7": 2118, + "8": 4593, + "9": 1287 + }, + "deficit": 1320, + "edge_basis_values": 42787, + "edge_distinct_values": 42787, + "edge_nullity_histogram": { + "0": 41912 + }, + "edge_removed_values": 0, + "entropy": "1.881413992826e+06", + "entropy_ratio": "8.307798044588e-01", + "field_prime": 1000003, + "frames": 18532, + "h": 22, + "incoming_dependencies": 24, + "kernel_reuses": 0, + "local_histogram": { + "1": 23898, + "10": 930, + "11": 354, + "12": 1197, + "13": 127, + "14": 742, + "15": 1879, + "16": 88, + "17": 81, + "18": 13, + "19": 167, + "2": 11078, + "20": 22, + "3": 9923, + "4": 4209, + "5": 1950, + "6": 1605, + "7": 706, + "8": 1531, + "9": 429 + }, + "loss": 440, + "new_R": 9412, + "new_W": 12052, + "numerical_local_root": "7.009184438594e-04", + "original_physical_roles": 13372, + "original_role_crossings": 46747, + "outgoing_dependencies": 8116, + "retirement_histogram": { + "1:12": 66, + "1:20": 198, + "1:3": 84, + "1:6": 4, + "2:10": 63, + "2:11": 1, + "2:12": 103, + "2:13": 26, + "2:14": 117, + "2:15": 87, + "2:16": 293, + "2:17": 177, + "2:18": 651, + "2:19": 3410, + "2:20": 1320, + "2:21": 2640, + "2:3": 83, + "2:4": 13, + "2:5": 42, + "2:6": 3, + "2:8": 30, + "2:9": 1 + }, + "source_control_erasures": 0, + "source_sha256": { + "references/paired-cube/physical/frames.json": "1a6c215cdc58216f7ec96fb898a471e25d094fd86de085f6c06e86fd8997bfad", + "references/paired-cube/physical/pairs.json": "abf341935148071a2222fe61c430e4e2fe3d16a64db14ab4eed9cd9a5a0f54d3" + }, + "status": "Modular equal-frame flow price, retaining dirty kernel lifts and complete full-frame cleanup. Not an exact supplier certificate.", + "v": 1320, + "vectors": 26200 + }, + "gain_over_pr186": "1450825370201/330942774629799", + "gain_over_pr191": "1135/348753", + "kappa": "103873/156250000", + "lift": { + "all_actual_coefficients_dyadic": true, + "certificate_path": "research/source-assisted-v4/.work/lift.certificate.json.gz", + "certificate_sha256": "1d81a79bda88b8a0ef64b7ae815c0d20cf1eee7f4714053530805bbb39e89ef2", + "checker_path": "research/source-assisted/decision/exact_complex_flow_lift.py", + "checker_sha256": "9d841bcfdc7c9c19b31791e8d7cfebd223d80d5e9ecd376d26257244f5323f2e", + "coefficient_numerator_lcm": "2", + "coefficients": [ + [ + -2, + 1 + ], + [ + -1, + 1 + ], + [ + -1, + 2 + ], + [ + 1, + 2 + ], + [ + 1, + 1 + ], + [ + 2, + 1 + ] + ], + "denominator_lcm": "2", + "exact_scalar_program_sha256": "3b4e671d7c6630570b04788bb2c81629e2c52f8dc2fcc5805952f0b403921027", + "inverse_elementary_gates": 58165, + "kernel_reuses": 0, + "max_abs_numerator": "2", + "max_denominator": "2", + "nodes": 18532, + "physical_R": 9412, + "signature": "GPT-6 Astra", + "source_control_vertices": 0, + "source_erasures": 0, + "status": "Exact rational local lifts and inverse gate programs verified; monotone flow and zero-fresh kernel reuse DAG verified.", + "witness_path": "research/source-assisted-v4/.work/flow.witness.json", + "witness_sha256": "51da02c6cd844276ca26608f1b714ab07d476ec25634ad1a9b461ccda2fbe457" + }, + "lift_certificate_sha256": "1d81a79bda88b8a0ef64b7ae815c0d20cf1eee7f4714053530805bbb39e89ef2", + "scope": "PR184 contract, finite bridge and bit supplier unchanged; the complex supplier is PR184's source-parity local word and frame flow on PR168 v4's query modules and physical layer, with donor/recipient pairs that avoid parity purification. No new flattened bit transcript or full Clifford/router replay, as in PR184.", + "status": "PASS conditional finite witness", + "witness_sha256": "51da02c6cd844276ca26608f1b714ab07d476ec25634ad1a9b461ccda2fbe457" +} diff --git a/research/complex-bank-run3/references/pr219-run1/references/pr200-bit.certificate.json b/research/complex-bank-run3/references/pr219-run1/references/pr200-bit.certificate.json new file mode 100644 index 0000000000..7b80d2cd04 --- /dev/null +++ b/research/complex-bank-run3/references/pr219-run1/references/pr200-bit.certificate.json @@ -0,0 +1,4442 @@ +{ + "arithmetic": { + "actual_uniform_bit_saving": "677340914792209011106157466449676890973/1000000000000000000000000000000000000000000", + "adverse_control_count": 21, + "adverse_controls": [ + "full group stock replaced by local W", + "old ordinary reserve omitted", + "conservative old coarse reserve omitted", + "uniform supplier replaced by fictional finite profile", + "actual ordinary saving overstated", + "unpaid previous atom grid", + "scalar role reserve collapsed to physical stock", + "terminal removals omitted", + "terminal removals counted as aliases", + "odd divisor silently changed to 21", + "C0 detached from scalar charge", + "scalar group charge omitted", + "stale total row coefficient", + "inadequate polynomial row degree", + "float in otherwise unused metadata", + "noncontracting maximum child", + "transfer saving exceeds actual uniform supplier", + "old prefix charged at balanced parameters", + "old nonlinear scalar guard", + "old separate movement exposures", + "next final 1e-18 kappa grid point" + ], + "assembly": { + "absorption_gap": "14997626888680345751524011177060836353630220354194253091514663/500332244410424089575910423090842681151818848181152485337000000000000000000000000", + "constraints": { + "K_dominates_log": "332744409924090075910047758473270852729147270729394494318848181151818847514663/500332244410424089575910423090842681151818848181152485337000000000000000000000000", + "K_geometry": "375332369410299089700910423090842681151818848181152485337/500332244410424089575910423090842681151818848181152485337000000000000000000000000", + "a_below_b": "666489485337/1000000000000000000000000000000000000000", + "a_positive": "665489485336999999999999333510514663/1000000000000000000000000000000000000000", + "alpha_below_one": "999999000000999999000000500332244410424089575910423090842681151818848181152485337/1000664488820848179151820846181685362303637696362304970674000000000000000000000000", + "alpha_below_one_fourth": "249500633385363864636134865695980388696361303638694362837181151818848181152485337/1000664488820848179151820846181685362303637696362304970674000000000000000000000000", + "alpha_positive": "665488819848180151820345849440951879548120451881879831318848181151818847514663/1000664488820848179151820846181685362303637696362304970674000000000000000000000000", + "artificial_boundary": "28021267642263141736858268578810664824988675011325028334096043455456544543457456011/4002657955283392716607283384726741449214550785449219882696000000000000000000000000", + "b_below_one_over32": "30584510514663/1000000000000000", + "beta_below_one": "999999999999999999999999/1000000000000000000000000", + "beta_positive": "1/1000000000000000000000000", + "c_below_one": "499667255257331499999999875998734228005499999999999333510514663/500000000000000000000000000000000000000000000000000000000000000", + "c_positive": "332744742668500000000124001265771994500000000000666489485337/500000000000000000000000000000000000000000000000000000000000000", + "cell_above_band": "999999000000999998999999499667755589575910424089576909157318848181151818847514663/2001328977641696358303641692363370724607275392724609941348000000000000000000000000", + "compact_leaf": "665989485336999999999999333510514663/500000000000000000000000000000000000000000000000000000000000000", + "compact_reservations": "1/4000000000000000000000000", + "delta_below_one_eighth": "999999999999999999999999/8000000000000000000000000", + "delta_positive": "1/8000000000000000000000000", + "epsilon_below_one": "332744409924090075910423090842681151818848181152485337/500332244410424089575910423090842681151818848181152485337", + "epsilon_positive": "499999500000499999500000000000000000000000000000000000000/500332244410424089575910423090842681151818848181152485337", + "g1_above_kappa": "3749531805231189043903396771870981799077843043260608561/125083061102606022393977605772710670287954712045288121334250000000000000000", + "g2_above_kappa": "442581721611999999999333510514663/1000000000000000000000000000000000000000", + "g3_above_kappa": "14997626888680345751524011177060836353630220354194253091514663/500332244410424089575910423090842681151818848181152485337000000000000000000000000", + "g4_above_kappa": "442581721611999999999333510514663/1000000000000000000000000000000000000000", + "g5_above_kappa": "23996503221235199456892163429551192671417043658019713637914663/800531591056678543321456676945348289842910157089843976539200000000000000000000000", + "g6_above_kappa": "119984517435153638980819120789448326727809825565491292799514663/4002657955283392716607283384726741449214550785449219882696000000000000000000000000", + "g7_above_kappa": "124916688897643977359771926032520518755948684726582860464827843043260608561/125083061102606022393977605772710670287954712045288121334250000000000000000", + "gamma_sublinear": "1/2000000000000000000000000", + "guard_width": "332744409924090075910423090842681151818848181152485337/500332244410424089575910423090842681151818848181152485337", + "lambda_above_internal": "665489485336999999999999333510514663/1000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_sigma": "1331978970673999999999999333510514663/1000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_tau": "665489485336999999999999333510514663/1000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime_above_lambda": "665489485336999999999999333510514663/1000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime_below_one": "332744742668499999999999001265771994500000000000666489485337/500000000000000000000000000000000000000000000000000000000000000", + "literal_scalar_guard": "509532410931555680619111905701605719663775309011257184899853371767316317929959509126231486950421913624808115822871265825797304203462159273821591235330478517741402257811415848312180933180882017346493767909630120540412401717248529680239477806233338423813433642418140269735393353932383525076398988653273313580180901204266348309329078956207030476484250546538596473626447601552599528533232546440374842054188408552873669546090772684263830320082937322775897249335546651412079737702086628330204816852039179665908852391032936512904064714099133552082096956766796250645423541481444176637969951480577674329874853875936899064068864814607059269445648296885122099802981475254251150579892446783613334591065679578089966033233448468436814063172662291956468786941696439487875391872017092607956179762879810557759615757515667938229013963393363308533224642451183010009321425595599892859565124274006602949175445499201279903339215304303406754098458648347313475437055614694561143796447164268868760139299916803078267695569970235746633759497701127844741554164421029677303030094295911805654208049706003303749911216284967570666566397692767519504555648495473831709173105195200901996539621430430300635830329052382645589370703710787323881237350436469566667648126119901050082731608838362080495953217426022616769356134447200397805916283120006862503641256449692288145136611099948139171723222496845743524404645690103850840196673333764114308010720547121303713866666506131386201806213479351215520523407590483148115038052675394428095823311632011559213042160212498747737023207511022596817108337650671038492093331488041008596457572261975164210661246080327231396984947768722786800497413840838976099516813301831592280508235939477900165003940658838679752456878611458968849566445248873635447061566573717599424052819373759908728329634672107048634144277452027876858816368758936431866310678444104979295099807667890195815540069010878546283335326798720214506189006146013525815613748341597188553737684615305061909614930075276042239542632728599237677558154291784836234209839260961385775989978252141052692167087374814716316958809199738240097089984896211179410357612679205787133393598213399443234047343758210947473630159156804903661107307014673811229037905455528560902715898064189157164109867334955972123182394008947044337924111972641036987615631325705980088665021917764505752701397419334802321724957768910917139842399541271586368253479467749171765673001824640342732208730637433088044837656758347023314794582908793180355828527603076406038314236293691180265717157392528943729192895289381439545703430621762689685783066622386399651458288932909922872708975425457210923663715355446050789958818702829502585997812817559838763217783761780815134208631567717608018059301315067371926511435348937465810150744857799701522933317848371746274664033617476918199594067571243885651973555695593567897075036053913610249688897833282392816118005417458311224552598193160724565639148198763926396999695322462352982172673041255273367390517877675018181416138131654157433145797566561571462080965302898971443224325448151480478852006707573949077455172190063821451121090553857496062012376496102432932175398975958582052864383021374276627211771861123936251717736056801099584173304015650037766334278465741666772447153476298319676650156742380759982873343628991583889160812395484812889479623639637823045921293747387151213038133296304197187084414029355988745577433003360412082672554615377645724023287789044317516401542458078885444095561309764671780262478190934976125951505776827467212014643315053620078496638852562666282809987933208858648963094003228267991465468374067265061091652356791697164040972108962644440382988714131067012956918181123928885161908576947285402845544719409569801609648454943715419276985373795631635707090621395949357820437851729053270669403634782027388584542611815295760149838761009868291724840684414188155734679475207735783679273769763473701738939668178856087086524816531138104478472236352608710925874537462501665283906301456130281965042870002258943395688284553941621276179274035975696647087128868584662050536433638146347949287745234051870320643465641321123110496544453655544611858697128405140908714616669861095840467793479837787172361340311454735592349573073211191537014694638020982562532441624561645841002709514764852596724315250746048100013260104734590560285867119496339992799455894563812239458620579186335358804163156130414792801261054657666632747257535272567004783176044412619627596742610260714843215831767764036606670883123125337230204580538675192418384516567811635659681279617205173849000987983515395921851500467905707385303894258706134476144823451794499924560650568574735123852061185655043447829185676484621147830683389132204954040195027621664363048962803080054711406238761342281629204048640916135742735179726733294002487656491205203332917292149406134871821555187620588222021290082649111437261157691118607599552069686192748342830795035798514316005678570500029172404584032753876182332976274268255035392796688629221491625758906880678986446598999586214090227846821932509805525220257179652168800741511218990946334029126975787096252045648697692552669418220127721565538575180854820894922690246846847920004701910159575922752993839219316039516708009717078594550310972897979764145885892134560577089331088861141224814361879101764073201203019476334326618680082071605324546080305056691646068960988600124395621134785432285131790032415257453943194082004110407243319321545933846090011825389074175300514026423510516067996102155000988805501584416251567601995828581028194272281201484016859904354221118590554724294482421722378388630417876366803777883012593614028210823218674722313016294450404100510769975879434934692964069001919304089155168979467748883735785548948820125670866759122901792082248564105765298665207413578529677136622712062882670538812925542030722078443525568555457259310348308177887077895761740202907362065008303287086593963360800785218987612370694670532209479466620", + "phase_boundary": "532391055878544121456176613103879418820581179420885696518848181151818847514663/800531591056678543321456676945348289842910157089843976539200000000000000000000000", + "phase_leaf_above_bit": "1/1000000000000000000000000000000", + "phase_local": "2661955279392720607282884394497038790461209538796791853318848181151818847514663/4002657955283392716607283384726741449214550785449219882696000000000000000000000000", + "prime_interval_packing": "332744409924090075910423090842681151818848181152485337/500332244410424089575910423090842681151818848181152485337", + "q_below_internal": "665489485336999999999999333510514663/500000000000000000000000000000000000000000000000000000000000000", + "q_below_leaf": "665989485336999999999999333510514663/500000000000000000000000000000000000000000000000000000000000000", + "q_below_reservations": "1/4000000000000000000000000", + "q_positive": "332744742668499999999999001265771994500000000000666489485337/500000000000000000000000000000000000000000000000000000000000000", + "record_suffix": "332744409924090075910423090842681151818848181152485337/500332244410424089575910423090842681151818848181152485337", + "row_product_gap": "224336/5", + "short_record_fallback": "499666534152669800277630220919410241257932289343717793173019220789505365485712458495775569003569/500332244410424089575910423090842681151818848181152485337000000000000000000000000000000000000000", + "small_field_exposure": "1/1000000000000000000000000" + }, + "finite_bridge": { + "bit_uniform": { + "atom_beta": "677340914792209011107/1000000000000000000000000", + "coarse_saving": "677773948354561/1000000000000000000", + "old_atom_saving": "384599/10000000000", + "ordinary_saving": "677340914792209011106157466449676890973/1000000000000000000000000000000000000000000" + }, + "complex": { + "N": 4654170104423616554638164010272346091525338318081434624560713222756608378117397252400210666893081203396713814484336655024295069388921657147689634172725410447265943921080212832355099015801402340613368718684202796799353461392938077263755994129846605291547841283152950671461912870176687371031035766533157124388121683525968364849356178820541530477519547795337690304275736560189911727771655301087339514594924221793976288076428017850160362677522178019873965242784165001200605555445206166283124908285904680927159554862606796638919933387986940007180948084528616254659211856188901000183131972799431806345252217217039855354854231386567475200000000000000000000, + "W": 46411243245854594476289509747890069396021233546140851487191415266019118243302500025260585612358809000235563590952517719761209089671496797753817162587564074028304257449377910236583460867419590158707403366697091980507492130541851447744560720250887019282306238492532037642767544780405860503698124087027232748727913424433576959478844986223324367936052884568204558693319333592257430358074468733494431841373475402631901424204562120425500646912291234299697730674824215083942099186610036944533919066490426753821364561103403987998562941807630372207971833058068314969756973987132199898038307695423424899183753738809011830330262308894990663680000000000000000000, + "auxiliary_banks_after_sharing": 1, + "coefficient_bound": 26, + "coefficient_denominator_divides": 6, + "finite_group_router_upper": 1996781817829700505616648003442939670418121383146524832570562414229508517707365630210514410182868208422410426904222349614587120238169565023976593617888088249792889489232587391937114692862833413493878289150647220476973315936613893411371180627349937542747113703441878702871183764108427647246946738280116413202842001601611935577871928896078779222167053557763264184774765184286697868594594314095298375974619020411589760327871072912207011987279157835478300764863885862339514331188591889499931217751046333516074072899497781599216540489370635260835475068278948606593058144659269465953575864037220363386543007930389392650517576506725609273702290538744026324349048797544741931656448511039048822918393059436367372870428114118151808835454194697189172420675444159767607388539974249475729974744313867010877267947494917728324863231728827375097796764153590288328124290854313749034205788857188501097735018015334913812524031309584653511523390713673282151437254342444210331261975595018327204309097452847220268408585326212873150162975484878379620431963947109952968805006023852879520661180163026847720913903900327535082362352341970633278958844785634739058314191225917327628660919631334932181528624365834466594963958416015205875189155986400578676067745563136371392891175778031142494596567179094957992104382032540770219035244465619000829903097000075849583777272674623120007677063732581105732175038816041801105187366687892006322408874222540820191910326456749466829784102697616089009779807971524806980914181559704507613893357294407429708218298288807124701683600890622569213909248073265415355774627205317949186017722026285024353652225922915093100135743357732801132024782406130188987430338256239146124855199854334018599841017758087085872468293679789085826036881023401376565779696277800538708125495766714490405278954114302254259077986737997610651303475214846690409557531207945110471168522019985895615486336976041255809567024577951775285455773833308076711628905615556366827520000000000019248832, + "halving_degree": 1, + "invocations_per_stage": 3525886442745164056544063644145716736004044180364723200424782744512582104634391857878947474919000911664177132185103526533556870749183073596734571342973795793383290849303191539662953799849547227737400544457729391514661713176468240351330298583217125220869576729661326266259024901649005584114421035252391760900092184489369973370724377894349644301151172572225522957784648909234781611948223712944954177723427440753012339451839407462242698998122862136268155486957700758485307238973641035062973415368109606762999662774702118665848434384838590914531021276158042617166069588021894697108433312726842277534281982740181708602162296504975360000000000000000000, + "local_group_upper": 4552920126520, + "logical_group_upper": 48159262409601395467011635701100464832021030569677306175574358095765057248609523233731783063748587071783641348524556567732110852316854063265394354994194196235424254850312119215110537754435839555650149484077504564925881450138377028493433797993315174068073699814547634599867538980931684612010193186301768649845766678767978197392725197692362495088218829833738197421152595019362494884184045934416310722881634052266915958468750757416790961147082161549540715124877340344041143854505135550740971547919140073694734890777732207707027340740665870005216626365456712348847469693004375422271610757332987355192878777460512903919380631891708932219994112000000000000000000000, + "m": 66, + "maxchild": 20, + "original_X_involution_scalar_group_upper": 42240, + "physical_roles_per_vertex": 10523, + "reuse_pairs": 2310, + "s": 3058487884121979618880469479350472234045876075727214763530072694334505195679847604414798439748788312812150483188381832849215504848929866994604243096606503475420815047737861862782153318233891548134075253483323867916695127154369257473877251542428696667340663899223961533751196042636610105873045153977264204291654164329090110960754412911918866753301970833706163183454800280528800491905143281109545162016054452351911517709424671930232882333533699285760176259295614030538977940760817232172955533480082261071282901477962056411266234225915617625718960033747980171749301071294536292270345175925146611539782494544177740946442458155682816327680000000000000000000, + "scalar_group_upper": 1996781817829700505616648003442939670418121383146524832570562414229508517707365630210514410182868208422410426904222349614587120238169565023976593617888088249792889489232587391937114692862833413493878289150647220476973315936613893411371180627349937542747113703441878702871183764108427647246946738280116413202842001601611935577871928896078779222167053557763264184774765184286697868594594314095298375974619020411589760327871072912207011987279157835478300764863885862339514331188591889499931217751046333516074072899497781599216540489370635260835475068278948606593058144659269465953575864037220363386543007930389392650517576506725609273702290538744026324349048797544741931656448511039048822918393059436367372870428114118151808835454194697189172420675444159767607388539974249475729974744313867010877267947494917728324863231728827375097796764153590288328124290854313749034205788857188501097735018015334913812524031309584653511523390713673282151437254342444210331261975595018327204309097452847220268408585326212873150162975484878379620431963947109952968805006023852879520661180163026847720913903900327535082362352341970633278958844785634739058314191225917327628660919631334932181528624365834466594963958416015205875189155986400578676067745563136371392891175778031142494596567179094957992104382032540770219035244465619000829903097000075849583777272674623120007677063732581105732175038816041801105187366687892006322408874222540820191910326456749466829784102697616089009779807971524806980914181559704507613893357294407429708218298288807124701683600890622569213909248073265415355774627205317949186017722026285024353652225922915093100135743357732801132024782406130188987430338256239146124855199854334018599841017758087085872468293679789085826036881023401376565779696277800538708125495766714490405278954114302254259077986737997610651303475214846690409557531207945110471168522019985895615486336976041255809567024577951775285455773833308076711628905615556366827520000000000019248832, + "scalar_role_reserve": 12877, + "stages": 3, + "terminal_sinks": 44, + "wire_bits": 2159 + }, + "conservative_old_coarse_row_reserve": 9909, + "ordinary_leaf_row_degree": 252, + "rows": { + "coefficient": 12320, + "complex_coefficient": 2159, + "degree": 70000, + "degree_gap": "224336/5", + "suffix_slope": 280000 + }, + "semantic": { + "B": 509532410931555680619111905701605719663775309011257184899853371767316317929959509126231486950421913624808115822871265825797304203462159273821591235330478517741402257811415848312180933180882017346493767909630120540412401717248529680239477806233338423813433642418140269735393353932383525076398988653273313580180901204266348309329078956207030476484250546538596473626447601552599528533232546440374842054188408552873669546090772684263830320082937322775897249335546651412079737702086628330204816852039179665908852391032936512904064714099133552082096956766796250645423541481444176637969951480577674329874853875936899064068864814607059269445648296885122099802981475254251150579892446783613334591065679578089966033233448468436814063172662291956468786941696439487875391872017092607956179762879810557759615757515667938229013963393363308533224642451183010009321425595599892859565124274006602949175445499201279903339215304303406754098458648347313475437055614694561143796447164268868760139299916803078267695569970235746633759497701127844741554164421029677303030094295911805654208049706003303749911216284967570666566397692767519504555648495473831709173105195200901996539621430430300635830329052382645589370703710787323881237350436469566667648126119901050082731608838362080495953217426022616769356134447200397805916283120006862503641256449692288145136611099948139171723222496845743524404645690103850840196673333764114308010720547121303713866666506131386201806213479351215520523407590483148115038052675394428095823311632011559213042160212498747737023207511022596817108337650671038492093331488041008596457572261975164210661246080327231396984947768722786800497413840838976099516813301831592280508235939477900165003940658838679752456878611458968849566445248873635447061566573717599424052819373759908728329634672107048634144277452027876858816368758936431866310678444104979295099807667890195815540069010878546283335326798720214506189006146013525815613748341597188553737684615305061909614930075276042239542632728599237677558154291784836234209839260961385775989978252141052692167087374814716316958809199738240097089984896211179410357612679205787133393598213399443234047343758210947473630159156804903661107307014673811229037905455528560902715898064189157164109867334955972123182394008947044337924111972641036987615631325705980088665021917764505752701397419334802321724957768910917139842399541271586368253479467749171765673001824640342732208730637433088044837656758347023314794582908793180355828527603076406038314236293691180265717157392528943729192895289381439545703430621762689685783066622386399651458288932909922872708975425457210923663715355446050789958827304979549775015204660589628049382048159414088886350824139990951695623597455357585789947338756567246855082520379894803970478190080646374725907170600630937374638930370439244376137186931258502092725378890309112445759411478982597831480340925427115998851341292624150119598026644913815467329847434859878041023321026286574843080294022586123425055138651176542718649119075352633419372782791056476906418755435875482741999289270330175685831019358074044683575519364870537110698987378534156423412338368608215994716567771341264691784835620547116095154355823028405037678909536409294936241998064726276240916495855446538713390953917957332894522343859649425558894465528489251474045892119196192790538905119006865260569920159851539352630884411410684543010286411452690005269956873208792508595460908096781391701546463223346195916242564759714955799308966368742627228715461007712659326066236176298406802374308370970686396733236368702340191602509189940399556599714483690088244922651769301641228957332097529146753350021208820702940922157812928490776979272693871844477852319948601242412475069333766783326317417323451865061419628384583210851906090081837589052178712760888235589716528403027031568288437989490163340454913038153349106568531093828746761822382576908672736654271400044763829558214085414340795118674219525044565554958311699780729788995435250081345623470348243544594512672750920229723181348286851358440615607637394658415712783369231357282393690924650482720908188916779881724305476435285671169289604569420907232698282421856982026379712178193610758794079671443090170499840417046551812624329535152282424714022599419754331072196960476616795026403529285824410798217390317086027514688112288530970330509440091515683875928181551063423447893048491177211466119814349423907836888314559662032261555442354347785163113771451383175688798034527042538116399087831616488919004322119167912666265947346004223385757910827157266993723507556830481294342030677452635331455842755200417108167627732222635125802616945528741084596401279157096363540269571573594558215964221481961827180791443114180273766962657973492642630980698679516137989730279605879551135389988039469081618481067485985149309898196042198234371393482956069508355575669945213783147520197065586627742035457497165537741506100395483926269734486532538090154077823377395228805741722431419949702460659538988049212462045808719659171412420328131820872706910401880425640471451275221301310124900094785175997237965232152651361751380990572099367485745003558793777991713218825798314260532283007298442845388829409311469245870057031409455035036166747412979885180821102504947646922867359712076919940847173982654417985779271207380189196864547873292529929118911576152388352104179221105616072584796934015629810661075132694653746489015099846670040079689171577509515832477498369920566593783315631166617970156403597882536309491814201294583593876798892936417830767695273098204067095331361644413858859993328438701461466986432116371466429501796281745317597555372567687272741220946903622572552176033977105176780258670103736123493087637087879866619066857900162029142502169280392319175124019264819172639003008692281782670446846904816665909897332477161522504450906980821508386757337239111618507435101540897858413016340607824077401090553703957855712921974534670532209479468736, + "C0": 548324362691896502675861037544590133574553873674175935778047943368710886417867580577535042485762529084967524669195365237265969758102800729968088762369431370863790885166053148776812067561550206214713418566972978250104268753988305789298776309592163020741446666323935155425081378347694441919056307856963674194342807368658373137120145586012651860493768301469826592085401562390268551562233544159734213847758319356602083146399678164406361723714188573711922941458747613677810636511504152072750546320653874579457514038505298226944843031760829410835675047388208552381372397511175396933791613203032940887250960913251548074762127076589245784709000613346385246490727318433183998971607566312320017674061653909148387434134252020155047800128093282290792048163704766219770776714501976077198155358589913989290278950145062070036166230106725232797721232472468780997455525722691074501481083073764821970786831326264994592159242550304782441038157858805291517742012911528334128682342889921869003415940146031832388705154487556513766050669978054413885995033755917524455904454780648685825190684539602613598664950834382093828380169333005070593866958082779451756694583861534245025851852963620976137055855489295034674303829413951815001565603579205908287085028619170746483154134021758034702510423859637337705140756571118081655252501656918554285287040637052107379418001952146364468335507966107407156376624722456895122264489888316026921840952696078330646972949124367817120531126277419373190380927947176218452708233715576380559381429232455106618839838267893507135442066167569398598656112210385958482576237123883077845146706978120913850980422227686228421013263630171383336444944636080048189059629479225619232563146204735488377024187520057601524758680013592243165203032997200027869872581452544447210457815457387611488588245914650722359560757876221203290046188992425537543361941523880836613490387626400832644598705366426427234136036656130804355023949470562573079098977510572234914875059684213447776697050093488362776074852167103359074765917818291808398572539361945120873667096739923287687793021639888564466725468528157629007549987011293035616243520421077009265811123714300346555540013787246176155535568827090903954621436279700276148659728937689104433955220665653818488700676323007440489592332963648116587723544935319727730477104657877958137048549117225264096323437501345205498147782853749543905925285800516669883730554242766008667296407314547468824825492255562855873310335269022894806175914519055022881889012508084159913495602361075439922824870267472569315529985121551643435276092071926612229524192260604035476683960195190911751833269681049275147475563148006275307467913010394541177976089984457696520142647608392834886867377394388891743176608546559827500938578095216987172098620148238243484243622037700872628472320984986769353647967294460137204290690955253200825271314701870108306347762880799148058161647516168795464193382675583628398036446636838714577693656311011910718467607228814462879746590604215998361510581901038153960354576387664659008857368769203868266365861761371041040085791665388711051256572426804153285692906859709717832241685747102376546851897416908449398791090483373411070470660230628351845168083378254668879137563211183815930121289892625317251697174244899530855932201947894093955613716397394384529290530699287996082718665789827637424156606285141371882046405642687366825672519931915872938335723336771273239629576449718879429251000101520209401707568104048246780728982126025146267598737344929551361333697936995605541530897879775269265018844961620609099452513674020493012888095332848154341291886983648780976053539799253634683252006122905133283085441443635534735311151870345535587069249551347588643197226988657204806280807060526503829446169950127833291839294945619264884476159567533154891512910368661981539488068368954069996269108840986609444501231921358487799892712813396617688072110323812314934596833762706831725675761818857278482804820665705131816419362384004140051554247597382704155032706851207528184509959514646558686992456549196477226767876091527423267750665112002855063915391481060801447193538523508317466831345426548222667736507830894768357708377653362028695110415608053362950061721655765220161289565004940537381190895765118751120591731297033569700285773718386840511483918088827196624396342054657263975663166898380393290889964114044239750632572198763603868868887468929343388818605829072805451724809767245749263854035461296935472079060517075004070033375077497850232361257368839238207327373299967284267223131841486501683798149738397010581661934515817975123433127038178869689091191396413619462172869358691764163694331194170425641378999866471812408489677307032187179399149469280857321683417603560191395113127779900854241408278271797217003223494142046531191819211911996214950224596556007923335150494117497147787949875844827239889335840068908539272429643926120925108290749795869347932477947423800462191997380511583183863591337876415694464859477083443881961609968069317789483403041852407847639026192663213593119135904780850719485887348605211744806901849450737467992615904222379798283608626015925576874449996734627208251368192120498580478859063672467440538292510788087496861274141816406108854607905651119168042347563132254176568912132526791058901243125083908761671518518019758105271187851352858610022260702962596693208403737562776045067217998548739334611421773952010512871078776268375553961943232419804756029560649932377959373702019349229096743567417083554698025605253114271473849227851743954340400473000178034130209483973382669629325506108657548483784833475502086405884905019195321091456786131027522992497603928632830104877807790614391346410525405577611153343431374207626510748597963949634033740523092946676301473924362721842286122976519326261665022123651941159826510011906365871394451870130479892741276031714000065647014300601430000365834475726392543565816220973292979021836897724250035452614798117572691872113495053770271420833517560319781327445925683510123762196983138595610551843145150987242940033858174034701697983486100864848427470972292941453432765961298412994035879754805550237067184027821805880812659184159872912466544596588692635155302443444945264555941449515364125489109904582738388759639148886613754120176454463397667279831543562778130451790032094611069476042641943884816675808195369947772145518715901824476922272468098887062107543034652049781266350610035014787106962161683635687905862250751845019521203837045368720736966466149785315904854100697971727793182350348803720968963400876244446574679856132513182884833236817122030914179620244909551740556166651982526168493388708198294550091349159861080799876121318447870127497716781821922787349017787513719553478020099126487556819796332698511549753802048575752108415203957532651580808999266737491298522171330317017142227967580732643215206532748213806669057248668946959013244674484322247470227189617838354827806983533736278317479623040210575797302382317698730847796870839519084343322881087729816610366658747161379041769764525432569634365786128508554286565043976248652243493192890482938943020186480331971810397307691176371291058497485300622902859076167296966839036627929166606513734407562504280779390468323374558841804450679611361682373304473001857421727160936919973085798903402086876433819141862037844702550651495126901708721378301415009224190928908673469967351065907695480251456156254726061580852310075700170980987893942957014140896691908839227489629778377923172860379443546759711068781262913380349233054227886577370214141144221456139765594977329792176337765521621462858332333189560276900376957053293125316475475035434236353669751675154900352691975679887836647591137036275571167887026142318731239291198086694973461373787675785595595818235066725637677273564324969078602245050223850273318586241095050231293371114907715523050119839317168863871792244776706794992014448038428264587240849847624870887919438687915571363954165362509914715700365047647691873614981707069546493625308713894572351618337400653179008577693302124836755663756287364614639788426098838914234086768331113547652528276086427123142435028695329286942474036433017980979104129321647281535531406045289382069105277157126882308010825427785948726726201004796362658626288511034187963689739215707227535637137803889958501005850666981738319590592108923866777333651569856121642851497765357026044268973352113621149484261048774866817530634810800153553743179608954638775188570720777035064595227664578607229183431987735845007428072090104359536847475122805242280363670948479496786833972120992666283922106731090280764458314210479271148779790803724397948274235836014445049251090907814006204520943730358018897451589485380958728207663827346503402960971916351124732547340167598261113492961331722608316016402900594788010856474016644384365583864100537833648666114007855197202946570967097597758872094304196746089549373670843248471530586036495083288496514267929932294045592280969821786219730989063070537249267021630042494867403070533846620734547897682299588611777151402480072789390285932403018699042255132812021266648810960605699941541371967387198092060370983141756394968303037454309726925843303788079061784010204796055486186043328688951285923599447680453934410100332478221437999160534157784048296864633709012684562689180879088132554559819192303519857473968646471480591944953442967139881710903890274170231445936924068005752797050931441375112407236585803738705258870529361749397092618257736675536089309610511738606810897949375891130550970613313940750762078633996264863945968171853150408906192019253015727927042359080657749963052200626500711807355774861746874936838825180476934752679793938031924975877868137222794292489050782440242185086154262898215995820282187597949541339027808308729863940030701480132099968535501654927057663721648433069162026821339384993263217634941793096151794744331079307543527546816662136001425996892740462662227108790704493446354461608832638695877599613541634397936620503106617840288336672249307978174115163891360507039487340574861531692268949818865030425385539292626266149157643218783911424778023117872229653394338366089187442749151929451939707111148171443486051301910069047384928240597730371886067206722766064067144787487188009205582465651406862253005711809073941328924614483174323710150041471506672532789657950560415745671470391141583444053255784642338246860880613634350453550613883706529105212271094201398964465072446119687732179830049017182468879591316291599449637102424291237370212370493939222011764526719168305966769580473635513487720466859211465194017512063410615889765213809520611674783601119043631185263579918394682965473467704148689979164075645564890309795056836312409289465038512866354856135793668745648203240399351214137389345620502956335896071661581353445486867652333836841914630800589851263655462666013358131837784996009287069952857093387116427762369652408875872248201660964393285753804680152400324962097222501770564139260079923366875150383448303914221720295064665932858910710141496913959335028590022100931844913891652414288110334085004378785295977625914559975892449950560342616983089623962653519158799862731964683404670411149164645023411794497890329207031617088328625223283910717722454113768838461280153885236670363238537313432408102627160252751799824506547178140731035596896899984985269704908131562141295776036915231298043024368064607190751037719097068370052261651412434764150523222264168024102561991900565639471202818542949700231562007498752671781672949085170277178598477188440079391692208734889837748081816399190876024597990433977383241450775991986184831686607112639104062350777338572802982072080749270081210878522336661728271118859001034506381883927245628055940652434554731342028608453318102439473074500285632983173941609434648460777641917178776992397647054963190606994249786817235250992111755668434786710049374067334782982083416789840251722850348852779791802970332669074595619536284636413952, + "C1": 1, + "E": 509532410931555680619111905701605719663775309011257184899853371767316317929959509126231486950421913624808115822871265825797304203462159273821591235330478517741402257811415848312180933180882017346493767909630120540412401717248529680239477806233338423813433642418140269735393353932383525076398988653273313580180901204266348309329078956207030476484250546538596473626447601552599528533232546440374842054188408552873669546090772684263830320082937322775897249335546651412079737702086628330204816852039179665908852391032936512904064714099133552082096956766796250645423541481444176637969951480577674329874853875936899064068864814607059269445648296885122099802981475254251150579892446783613334591065679578089966033233448468436814063172662291956468786941696439487875391872017092607956179762879810557759615757515667938229013963393363308533224642451183010009321425595599892859565124274006602949175445499201279903339215304303406754098458648347313475437055614694561143796447164268868760139299916803078267695569970235746633759497701127844741554164421029677303030094295911805654208049706003303749911216284967570666566397692767519504555648495473831709173105195200901996539621430430300635830329052382645589370703710787323881237350436469566667648126119901050082731608838362080495953217426022616769356134447200397805916283120006862503641256449692288145136611099948139171723222496845743524404645690103850840196673333764114308010720547121303713866666506131386201806213479351215520523407590483148115038052675394428095823311632011559213042160212498747737023207511022596817108337650671038492093331488041008596457572261975164210661246080327231396984947768722786800497413840838976099516813301831592280508235939477900165003940658838679752456878611458968849566445248873635447061566573717599424052819373759908728329634672107048634144277452027876858816368758936431866310678444104979295099807667890195815540069010878546283335326798720214506189006146013525815613748341597188553737684615305061909614930075276042239542632728599237677558154291784836234209839260961385775989978252141052692167087374814716316958809199738240097089984896211179410357612679205787133393598213399443234047343758210947473630159156804903661107307014673811229037905455528560902715898064189157164109867334955972123182394008947044337924111972641036987615631325705980088665021917764505752701397419334802321724957768910917139842399541271586368253479467749171765673001824640342732208730637433088044837656758347023314794582908793180355828527603076406038314236293691180265717157392528943729192895289381439545703430621762689685783066622386399651458288932909922872708975425457210923663715355446050789958827304979549775015204660589628049382048159414088886350824139990951695623597455357585789947338756567246855082520379894803970478190080646374725907170600630937374638930370439244376137186931258502092725378890309112445759411478982597831480340925427115998851341292624150119598026644913815467329847434859878041023321026286574843080294022586123425055138651176542718649119075352633419372782791056476906418755435875482741999289270330175685831019358074044683575519364870537110698987378534156423412338368608215994716567771341264691784835620547116095154355823028405037678909536409294936241998064726276240916495855446538713390953917957332894522343859649425558894465528489251474045892119196192790538905119006865260569920159851539352630884411410684543010286411452690005269956873208792508595460908096781391701546463223346195916242564759714955799308966368742627228715461007712659326066236176298406802374308370970686396733236368702340191602509189940399556599714483690088244922651769301641228957332097529146753350021208820702940922157812928490776979272693871844477852319948601242412475069333766783326317417323451865061419628384583210851906090081837589052178712760888235589716528403027031568288437989490163340454913038153349106568531093828746761822382576908672736654271400044763829558214085414340795118674219525044565554958311699780729788995435250081345623470348243544594512672750920229723181348286851358440615607637394658415712783369231357282393690924650482720908188916779881724305476435285671169289604569420907232698282421856982026379712178193610758794079671443090170499840417046551812624329535152282424714022599419754331072196960476616795026403529285824410798217390317086027514688112288530970330509440091515683875928181551063423447893048491177211466119814349423907836888314559662032261555442354347785163113771451383175688798034527042538116399087831616488919004322119167912666265947346004223385757910827157266993723507556830481294342030677452635331455842755200417108167627732222635125802616945528741084596401279157096363540269571573594558215964221481961827180791443114180273766962657973492642630980698679516137989730279605879551135389988039469081618481067485985149309898196042198234371393482956069508355575669945213783147520197065586627742035457497165537741506100395483926269734486532538090154077823377395228805741722431419949702460659538988049212462045808719659171412420328131820872706910401880425640471451275221301310124900094785175997237965232152651361751380990572099367485745003558793777991713218825798314260532283007298442845388829409311469245870057031409455035036166747412979885180821102504947646922867359712076919940847173982651359497895149227761308727385197401058484053043184361388858279409844715909936224980382135575881022348262982211465364656165884341821110212694567334412909329002077554872828731920533477848384078608269522629052985623897506167429224619325015684875402071027932434304843133797610448371222249887455393547484202782140462207137339390835527332405678688619265716439035057763448822292023375542071961895670713508087681671141176119378455194688833975566628329856741993021096705144585041324058355406830053158801700409375564003338703853486066242935606886825188020787760406585587938040323971142831195721933266404800825329533223349607261499700030105646854670532209479468736, + "fixed_odd_divisor": 3, + "induction_gap": 46367449394771566936339183418846120489403553120024403825886656830825784931626315330487065312488394139857538539881285190147554682515056493917764802415073545114467605460838842196408464919460263578530932879776340969177528556269616200901792480367233796567022461460050764545920795207846900781952307967447871535796462009588237696148946185014839773360066799735012279100006731741286557096524161726074110626931145178311503928694260314268008559127547296372606649689534745278499256130889883178048638333535565349597705567583997222674269888983021153239470823065778458808733542274811420074055265584732568364018611702710257814830266698129242393519553995016546111082071314248136854702770212657308813447786976841606186909024243810627750079748712268568038659611694375993396660660353555427324012358422062760756125033933925782378840270668796061076523442463057653910848249729199590250220426308934600868374965540427316471203868592691610014622959736999605526264772060937205064085476691948467057172676292429080122360296867291452943672114290802633871481428962313700634575738580927974314532932523246300641241920681932048930657542190041844274914564013088118685534752572763282081685105550169157357860559943766820748632734037681646473192598889718730566755979476910995557528576404290949325131742785768058126011408234695236200338381763920624487831354336921998221207431610095280664626813247212962660720822757799450426457897273372534402028975569788038637961866652057956144364365426620960612367630090733966478468462793460892956719921358513051888386836579337386044069111883503056310356858726211064502780493165411731782277639075839739943170173393309778057125630246953773598845264659516346825056030010466674897526249470492488915015358599954319857473575953642766165310546517647500825682602558208301547588806563012151694277996755161741425707129248134536794152289557063215299834271738413553115854082497778007819214146279989947711783514738683539520063199559287230849220851099085344158390129299992760633774958636850119843798379578302530628657792040552420097313095372747486105615088020944835794987204951108139184843251637176179848835188625555217326342542753807726629138817437419349334298308281997196220100344483269246233160764938335316821842449396453099042147146723841213301933997927480993463209597854814181034751094189510334365873022450639244188068516994516570023495827165159467011276971156970893459725658358255714359511066631565174630676243166042271188630994488006411012080226765009579121646307044700179412380396011879952949486595502725897404180261322720133879356553471333710998659012186580404761406259062637162368282704292894802981416516763716606194053398097345590621886253284753139029526383624113656152493766382506682088657924996739176604301747368437540306885207826847619463812509354570427161313515297338820100057552524657415301092142663709971238228484010744523690438009479018129232564106444587416402664711024213867555895472057628797660883420424687157207527016116572248901733122213392078310720306756055337231680017617257065387397069835857089641162923233986139398484106744664668929521935323600045987410622761584738066205372262203218877073607851446608234530522791543347655519207667192055086952420041469787564659046379895584858428780767813245839198021823890091137923401122845635022918576806534117293401533291228097725859396363092521884138176182846853543939040365829624738711862734546490081089410481438372293413936063442194790479566075462000118282186942636807106644840728153324503828378073393134060977737115939555579077813106951701851998672027492043155019016062061758332462102724509551912957435828336284576359650574018015798030287961311006449351835117220875152354554851930002683967623916360976492660705113815142337847484561115322713059535231309372777282694884976434119720589186182997072187523454197447220603748262861240829438664204084675459872714247857043604863981397086471954768697736329538415955325836814498689219035538697404073508489797481772705012355799353976779055465501206364680046410798584607757402451735801690162558100653220333740904809502694103473618096020295002913915829863286600053512697825874143193927602645191426969236911798355610996076405354015817302558175543700388985364400553808215618579050261250101321205515485477951236214948813987698857700648976056547197644127569923403372128347402721165010021382637782518854828503836618218256318300076359048327927232709464521146771533758267412697126243416903105797575613156836624929244935801545254245648449843353202075868987680621141960870968592316992677100491629393312844280052630201208486384328103969885271311296428839187671573797785124791648189815162481690723237956843254123632259796448038142043115438698272516403295769082164531013197104797652744154858526273452021323390404912793601875587830479419243579835968557065455444135039153320488911591686427281777141224648587200735839840039327796806949002325260357385965014454266424337932968383124525226632242063934477055135989037290545838274460966204021081927342965821322496741259215422923920018047912478334046168593488984598530249859995699416328846571118733282902066045138419221365908625451015748654836125891273919375670142061042441202795323850233797245902913147646597708437753664158298930383476247343701374175189858260408188291174014581169551454720327950235869980929733798999714617092832421552036705913679871597216914673856469620223549820953429867340041480309120611062605216520995422312770157837075213490930500374086046973647251714613553365940755452351662771560034281722436162235284232727407310804163755092317807107042788699257214022599860269851936570105675153909641661156259392887921832993495765322589803445084663461638823901377538903659541819451106168229654102248019091916571087003538979439987237870974974997067862335084068914744651967697404515701044936285753098544710149273790997642223010663068338316597800657255421698547905032535254757263194917688759157284176594240221705115584486995311991043499240387060164869875899682655018431062631654976, + "literal_charge": 8602150047189017391843029789286164264397633273752142192572273343677564296140290213863435903407629781044931775522095102447544872232274628451243136983154019175044862799195358724163631235664934195650342836395502196070513645700205015362335507968804774298743099463425553958878446149889070330152112397525058850647985031301475689776144911105243639000519522385285503321508791061957291817488157505463194429987724002263147282562756226608375847168010223232454428811013041048686610882431723491236939392649633941852184749966988064573063759423179843436619766227305453505605520759257169907719598984609468469342379148219036740797175576572911649000230657841669733653133004438584566268479558369744617611371619714047531786863547342165546470382054695797432853408092277922597402257831146784572173119052463875300004005144460751820681254995043175536830775433766501277209684180245447311422921122678328305735455808304403586745303159843691228508505961672408091131340416425027153270294977604477187985223134884706370361307077753689984003976688999605615070695746586441632307600539031440802826614390051364049332043527820229354329006988633853031468238352784318382775077978860847005173916587731271418449676979621871615614228623965193371889055886092963082548612813434970997714603221188676743033397554276236316646437866916333639680420849198115445882693979119799380580600345984601198824388196978608447002074250875661793528478768809996365176349731085009333105945690598612400264723275458758613808931981630126557430907441015766323983665751995886185911918698355823586432739359988354578150267343835360275609634897131299862181580974858108490069487445711764198302088278539776310784957285582495467228820992792190977531053545527703444417307602364728064643729892360762418664858759691757275089630779287095027478379397941728157566371161190668332472966266763005931445515964706279258714423783443975494281749379534368563704478293621983417992735524041434559442841562771745250027561584049065940963344175937722710565152048370793617232535215624113648534354593086952446727532575089277007786985763821449817224804159577918781236392219356397886933941089363470136815955663254745466593961989862282652232017748789907326412816205862367847487065493020833776521989829078457987075672349264748822706946470301881167920591163986503365685570045069501212895829467454176384556905772030317496423453555165129733212572412834114041593025884977892074900420214271623052500568613681103838841968110989445056399316102683298019429949265617281993255202810858397930875624013685435087293740935229253486558475406650740991892747025319088152862668912282841338359061754788306782622745831079705949168289480396131076026558289251050870782378401981437859815308553222718198646948947624855986514441095590063131192179050107202222690259816999805451248012866975482912065729483754556620019451424873562540273420474051996818395921751177657017329187103847207798746730950287983229443389329780667525592972971825105814151722585840333561507822933718377467865400590994126018763313044721781253399662637027202706644506168377581986007139910706310953048426617808204185875233898194913062336477218293056741622639580272023272752851940456033314673140700904884808381662452232303147275239629862436893247069455519025904339792522042446629386246460714481042493276160000000000000002116, + "strict_literal_gap": 509532410931555680619111905701605719663775309011257184899853371767316317929959509126231486950421913624808115822871265825797304203462159273821591235330478517741402257811415848312180933180882017346493767909630120540412401717248529680239477806233338423813433642418140269735393353932383525076398988653273313580180901204266348309329078956207030476484250546538596473626447601552599528533232546440374842054188408552873669546090772684263830320082937322775897249335546651412079737702086628330204816852039179665908852391032936512904064714099133552082096956766796250645423541481444176637969951480577674329874853875936899064068864814607059269445648296885122099802981475254251150579892446783613334591065679578089966033233448468436814063172662291956468786941696439487875391872017092607956179762879810557759615757515667938229013963393363308533224642451183010009321425595599892859565124274006602949175445499201279903339215304303406754098458648347313475437055614694561143796447164268868760139299916803078267695569970235746633759497701127844741554164421029677303030094295911805654208049706003303749911216284967570666566397692767519504555648495473831709173105195200901996539621430430300635830329052382645589370703710787323881237350436469566667648126119901050082731608838362080495953217426022616769356134447200397805916283120006862503641256449692288145136611099948139171723222496845743524404645690103850840196673333764114308010720547121303713866666506131386201806213479351215520523407590483148115038052675394428095823311632011559213042160212498747737023207511022596817108337650671038492093331488041008596457572261975164210661246080327231396984947768722786800497413840838976099516813301831592280508235939477900165003940658838679752456878611458968849566445248873635447061566573717599424052819373759908728329634672107048634144277452027876858816368758936431866310678444104979295099807667890195815540069010878546283335326798720214506189006146013525815613748341597188553737684615305061909614930075276042239542632728599237677558154291784836234209839260961385775989978252141052692167087374814716316958809199738240097089984896211179410357612679205787133393598213399443234047343758210947473630159156804903661107307014673811229037905455528560902715898064189157164109867334955972123182394008947044337924111972641036987615631325705980088665021917764505752701397419334802321724957768910917139842399541271586368253479467749171765673001824640342732208730637433088044837656758347023314794582908793180355828527603076406038314236293691180265717157392528943729192895289381439545703430621762689685783066622386399651458288932909922872708975425457210923663715355446050789958818702829502585997812817559838763217783761780815134208631567717608018059301315067371926511435348937465810150744857799701522933317848371746274664033617476918199594067571243885651973555695593567897075036053913610249688897833282392816118005417458311224552598193160724565639148198763926396999695322462352982172673041255273367390517877675018181416138131654157433145797566561571462080965302898971443224325448151480478852006707573949077455172190063821451121090553857496062012376496102432932175398975958582052864383021374276627211771861123936251717736056801099584173304015650037766334278465741666772447153476298319676650156742380759982873343628991583889160812395484812889479623639637823045921293747387151213038133296304197187084414029355988745577433003360412082672554615377645724023287789044317516401542458078885444095561309764671780262478190934976125951505776827467212014643315053620078496638852562666282809987933208858648963094003228267991465468374067265061091652356791697164040972108962644440382988714131067012956918181123928885161908576947285402845544719409569801609648454943715419276985373795631635707090621395949357820437851729053270669403634782027388584542611815295760149838761009868291724840684414188155734679475207735783679273769763473701738939668178856087086524816531138104478472236352608710925874537462501665283906301456130281965042870002258943395688284553941621276179274035975696647087128868584662050536433638146347949287745234051870320643465641321123110496544453655544611858697128405140908714616669861095840467793479837787172361340311454735592349573073211191537014694638020982562532441624561645841002709514764852596724315250746048100013260104734590560285867119496339992799455894563812239458620579186335358804163156130414792801261054657666632747257535272567004783176044412619627596742610260714843215831767764036606670883123125337230204580538675192418384516567811635659681279617205173849000987983515395921851500467905707385303894258706134476144823451794499924560650568574735123852061185655043447829185676484621147830683389132204954040195027621664363048962803080054711406238761342281629204048640916135742735179726733294002487656491205203332917292149406134871821555187620588222021290082649111437261157691118607599552069686192748342830795035798514316005678570500029172404584032753876182332976274268255035392796688629221491625758906880678986446598999586214090227846821932509805525220257179652168800741511218990946334029126975787096252045648697692552669418220127721565538575180854820894922690246846847920004701910159575922752993839219316039516708009717078594550310972897979764145885892134560577089331088861141224814361879101764073201203019476334326618680082071605324546080305056691646068960988600124395621134785432285131790032415257453943194082004110407243319321545933846090011825389074175300514026423510516067996102155000988805501584416251567601995828581028194272281201484016859904354221118590554724294482421722378388630417876366803777883012593614028210823218674722313016294450404100510769975879434934692964069001919304089155168979467748883735785548948820125670866759122901792082248564105765298665207413578529677136622712062882670538812925542030722078443525568555457259310348308177887077895761740202907362065008303287086593963360800785218987612370694670532209479466620 + } + }, + "margins": { + "g1": "332744409924090075910423090842681151818848181152485337/500332244410424089575910423090842681151818848181152485337", + "g2": "665489485336999999999999333510514663/1000000000000000000000000000000000000000", + "g3": "332744409924090075909922758598270727729272270729394494318848181151818847514663/500332244410424089575910423090842681151818848181152485337000000000000000000000000", + "g4": "665489485336999999999999333510514663/1000000000000000000000000000000000000000", + "g5": "532391055878544121456176613103879418820581179420885696518848181151818847514663/800531591056678543321456676945348289842910157089843976539200000000000000000000000", + "g6": "2661955279392720607282884394497038790461209538796791853318848181151818847514663/4002657955283392716607283384726741449214550785449219882696000000000000000000000000", + "g7": "499999500000499999500000000000000000000000000000000000000/500332244410424089575910423090842681151818848181152485337" + }, + "minimum_margin": "332744409924090075909922758598270727729272270729394494318848181151818847514663/500332244410424089575910423090842681151818848181152485337000000000000000000000000", + "parameters": { + "C0": 548324362691896502675861037544590133574553873674175935778047943368710886417867580577535042485762529084967524669195365237265969758102800729968088762369431370863790885166053148776812067561550206214713418566972978250104268753988305789298776309592163020741446666323935155425081378347694441919056307856963674194342807368658373137120145586012651860493768301469826592085401562390268551562233544159734213847758319356602083146399678164406361723714188573711922941458747613677810636511504152072750546320653874579457514038505298226944843031760829410835675047388208552381372397511175396933791613203032940887250960913251548074762127076589245784709000613346385246490727318433183998971607566312320017674061653909148387434134252020155047800128093282290792048163704766219770776714501976077198155358589913989290278950145062070036166230106725232797721232472468780997455525722691074501481083073764821970786831326264994592159242550304782441038157858805291517742012911528334128682342889921869003415940146031832388705154487556513766050669978054413885995033755917524455904454780648685825190684539602613598664950834382093828380169333005070593866958082779451756694583861534245025851852963620976137055855489295034674303829413951815001565603579205908287085028619170746483154134021758034702510423859637337705140756571118081655252501656918554285287040637052107379418001952146364468335507966107407156376624722456895122264489888316026921840952696078330646972949124367817120531126277419373190380927947176218452708233715576380559381429232455106618839838267893507135442066167569398598656112210385958482576237123883077845146706978120913850980422227686228421013263630171383336444944636080048189059629479225619232563146204735488377024187520057601524758680013592243165203032997200027869872581452544447210457815457387611488588245914650722359560757876221203290046188992425537543361941523880836613490387626400832644598705366426427234136036656130804355023949470562573079098977510572234914875059684213447776697050093488362776074852167103359074765917818291808398572539361945120873667096739923287687793021639888564466725468528157629007549987011293035616243520421077009265811123714300346555540013787246176155535568827090903954621436279700276148659728937689104433955220665653818488700676323007440489592332963648116587723544935319727730477104657877958137048549117225264096323437501345205498147782853749543905925285800516669883730554242766008667296407314547468824825492255562855873310335269022894806175914519055022881889012508084159913495602361075439922824870267472569315529985121551643435276092071926612229524192260604035476683960195190911751833269681049275147475563148006275307467913010394541177976089984457696520142647608392834886867377394388891743176608546559827500938578095216987172098620148238243484243622037700872628472320984986769353647967294460137204290690955253200825271314701870108306347762880799148058161647516168795464193382675583628398036446636838714577693656311011910718467607228814462879746590604215998361510581901038153960354576387664659008857368769203868266365861761371041040085791665388711051256572426804153285692906859709717832241685747102376546851897416908449398791090483373411070470660230628351845168083378254668879137563211183815930121289892625317251697174244899530855932201947894093955613716397394384529290530699287996082718665789827637424156606285141371882046405642687366825672519931915872938335723336771273239629576449718879429251000101520209401707568104048246780728982126025146267598737344929551361333697936995605541530897879775269265018844961620609099452513674020493012888095332848154341291886983648780976053539799253634683252006122905133283085441443635534735311151870345535587069249551347588643197226988657204806280807060526503829446169950127833291839294945619264884476159567533154891512910368661981539488068368954069996269108840986609444501231921358487799892712813396617688072110323812314934596833762706831725675761818857278482804820665705131816419362384004140051554247597382704155032706851207528184509959514646558686992456549196477226767876091527423267750665112002855063915391481060801447193538523508317466831345426548222667736507830894768357708377653362028695110415608053362950061721655765220161289565004940537381190895765118751120591731297033569700285773718386840511483918088827196624396342054657263975663166898380393290889964114044239750632572198763603868868887468929343388818605829072805451724809767245749263854035461296935472079060517075004070033375077497850232361257368839238207327373299967284267223131841486501683798149738397010581661934515817975123433127038178869689091191396413619462172869358691764163694331194170425641378999866471812408489677307032187179399149469280857321683417603560191395113127779900854241408278271797217003223494142046531191819211911996214950224596556007923335150494117497147787949875844827239889335840068908539272429643926120925108290749795869347932477947423800462191997380511583183863591337876415694464859477083443881961609968069317789483403041852407847639026192663213593119135904780850719485887348605211744806901849450737467992615904222379798283608626015925576874449996734627208251368192120498580478859063672467440538292510788087496861274141816406108854607905651119168042347563132254176568912132526791058901243125083908761671518518019758105271187851352858610022260702962596693208403737562776045067217998548739334611421773952010512871078776268375553961943232419804756029560649932377959373702019349229096743567417083554698025605253114271473849227851743954340400473000178034130209483973382669629325506108657548483784833475502086405884905019195321091456786131027522992497603928632830104877807790614391346410525405577611153343431374207626510748597963949634033740523092946676301473924362721842286122976519326261665022123651941159826510011906365871394451870130479892741276031714000065647014300601430000365834475726392543565816220973292979021836897724250035452614798117572691872113495053770271420833517560319781327445925683510123762196983138595610551843145150987242940033858174034701697983486100864848427470972292941453432765961298412994035879754805550237067184027821805880812659184159872912466544596588692635155302443444945264555941449515364125489109904582738388759639148886613754120176454463397667279831543562778130451790032094611069476042641943884816675808195369947772145518715901824476922272468098887062107543034652049781266350610035014787106962161683635687905862250751845019521203837045368720736966466149785315904854100697971727793182350348803720968963400876244446574679856132513182884833236817122030914179620244909551740556166651982526168493388708198294550091349159861080799876121318447870127497716781821922787349017787513719553478020099126487556819796332698511549753802048575752108415203957532651580808999266737491298522171330317017142227967580732643215206532748213806669057248668946959013244674484322247470227189617838354827806983533736278317479623040210575797302382317698730847796870839519084343322881087729816610366658747161379041769764525432569634365786128508554286565043976248652243493192890482938943020186480331971810397307691176371291058497485300622902859076167296966839036627929166606513734407562504280779390468323374558841804450679611361682373304473001857421727160936919973085798903402086876433819141862037844702550651495126901708721378301415009224190928908673469967351065907695480251456156254726061580852310075700170980987893942957014140896691908839227489629778377923172860379443546759711068781262913380349233054227886577370214141144221456139765594977329792176337765521621462858332333189560276900376957053293125316475475035434236353669751675154900352691975679887836647591137036275571167887026142318731239291198086694973461373787675785595595818235066725637677273564324969078602245050223850273318586241095050231293371114907715523050119839317168863871792244776706794992014448038428264587240849847624870887919438687915571363954165362509914715700365047647691873614981707069546493625308713894572351618337400653179008577693302124836755663756287364614639788426098838914234086768331113547652528276086427123142435028695329286942474036433017980979104129321647281535531406045289382069105277157126882308010825427785948726726201004796362658626288511034187963689739215707227535637137803889958501005850666981738319590592108923866777333651569856121642851497765357026044268973352113621149484261048774866817530634810800153553743179608954638775188570720777035064595227664578607229183431987735845007428072090104359536847475122805242280363670948479496786833972120992666283922106731090280764458314210479271148779790803724397948274235836014445049251090907814006204520943730358018897451589485380958728207663827346503402960971916351124732547340167598261113492961331722608316016402900594788010856474016644384365583864100537833648666114007855197202946570967097597758872094304196746089549373670843248471530586036495083288496514267929932294045592280969821786219730989063070537249267021630042494867403070533846620734547897682299588611777151402480072789390285932403018699042255132812021266648810960605699941541371967387198092060370983141756394968303037454309726925843303788079061784010204796055486186043328688951285923599447680453934410100332478221437999160534157784048296864633709012684562689180879088132554559819192303519857473968646471480591944953442967139881710903890274170231445936924068005752797050931441375112407236585803738705258870529361749397092618257736675536089309610511738606810897949375891130550970613313940750762078633996264863945968171853150408906192019253015727927042359080657749963052200626500711807355774861746874936838825180476934752679793938031924975877868137222794292489050782440242185086154262898215995820282187597949541339027808308729863940030701480132099968535501654927057663721648433069162026821339384993263217634941793096151794744331079307543527546816662136001425996892740462662227108790704493446354461608832638695877599613541634397936620503106617840288336672249307978174115163891360507039487340574861531692268949818865030425385539292626266149157643218783911424778023117872229653394338366089187442749151929451939707111148171443486051301910069047384928240597730371886067206722766064067144787487188009205582465651406862253005711809073941328924614483174323710150041471506672532789657950560415745671470391141583444053255784642338246860880613634350453550613883706529105212271094201398964465072446119687732179830049017182468879591316291599449637102424291237370212370493939222011764526719168305966769580473635513487720466859211465194017512063410615889765213809520611674783601119043631185263579918394682965473467704148689979164075645564890309795056836312409289465038512866354856135793668745648203240399351214137389345620502956335896071661581353445486867652333836841914630800589851263655462666013358131837784996009287069952857093387116427762369652408875872248201660964393285753804680152400324962097222501770564139260079923366875150383448303914221720295064665932858910710141496913959335028590022100931844913891652414288110334085004378785295977625914559975892449950560342616983089623962653519158799862731964683404670411149164645023411794497890329207031617088328625223283910717722454113768838461280153885236670363238537313432408102627160252751799824506547178140731035596896899984985269704908131562141295776036915231298043024368064607190751037719097068370052261651412434764150523222264168024102561991900565639471202818542949700231562007498752671781672949085170277178598477188440079391692208734889837748081816399190876024597990433977383241450775991986184831686607112639104062350777338572802982072080749270081210878522336661728271118859001034506381883927245628055940652434554731342028608453318102439473074500285632983173941609434648460777641917178776992397647054963190606994249786817235250992111755668434786710049374067334782982083416789840251722850348852779791802970332669074595619536284636413952, + "C1": "1", + "a_bit": "665489485336999999999999333510514663/1000000000000000000000000000000000000000", + "a_complex": "665489485337/1000000000000000", + "alpha_squared_power": "665488819848180151820345849440951879548120451881879831318848181151818847514663/1000664488820848179151820846181685362303637696362304970674000000000000000000000000", + "beta": "1/1000000000000000000000000", + "c": "332744742668500000000124001265771994500000000000666489485337/500000000000000000000000000000000000000000000000000000000000000", + "delta": "1/8000000000000000000000000", + "epsilon": "499999500000499999500000000000000000000000000000000000000/500332244410424089575910423090842681151818848181152485337", + "h": "1/1000000000000000000000000", + "kappa": "166261725903847/250000000000000000", + "lambda_": "999334510514663000000000001331978970673999999999999333510514663/1000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime": "499667255257331500000000000998734228005499999999999333510514663/500000000000000000000000000000000000000000000000000000000000000", + "q": "332744742668499999999999001265771994500000000000666489485337/500000000000000000000000000000000000000000000000000000000000000", + "sigma": "999334510514663/1000000000000000", + "tau": "999334510514663000000000000666489485337/1000000000000000000000000000000000000000" + }, + "recurrence": { + "internal": "999334510514663000000000000666489485337/1000000000000000000000000000000000000000", + "leaf": "999334510514663000000000000665489485337/1000000000000000000000000000000000000000", + "reservations": "499667255257331499999999875998734228005499999999999333510514663/500000000000000000000000000000000000000000000000000000000000000" + }, + "scoped_limit": "665489485336999999999999333510514663/1000665489485336999999999999333510514663" + }, + "atom_exponent": "677340914792209011107/1000000000000000000000000", + "beta": "1/1000000000000000000000000", + "bridge": { + "bit_uniform": { + "atom_beta": "677340914792209011107/1000000000000000000000000", + "coarse_saving": "677773948354561/1000000000000000000", + "external_stock": "The bit group cardinality is not inserted into external polynomial row stock.", + "old_atom_saving": "384599/10000000000", + "ordinary_saving": "677340914792209011106157466449676890973/1000000000000000000000000000000000000000000", + "selector_stock": "Internally borrowed and restored q-adic rows; complete spectators preserved." + }, + "complex": { + "N": 4654170104423616554638164010272346091525338318081434624560713222756608378117397252400210666893081203396713814484336655024295069388921657147689634172725410447265943921080212832355099015801402340613368718684202796799353461392938077263755994129846605291547841283152950671461912870176687371031035766533157124388121683525968364849356178820541530477519547795337690304275736560189911727771655301087339514594924221793976288076428017850160362677522178019873965242784165001200605555445206166283124908285904680927159554862606796638919933387986940007180948084528616254659211856188901000183131972799431806345252217217039855354854231386567475200000000000000000000, + "W": 46411243245854594476289509747890069396021233546140851487191415266019118243302500025260585612358809000235563590952517719761209089671496797753817162587564074028304257449377910236583460867419590158707403366697091980507492130541851447744560720250887019282306238492532037642767544780405860503698124087027232748727913424433576959478844986223324367936052884568204558693319333592257430358074468733494431841373475402631901424204562120425500646912291234299697730674824215083942099186610036944533919066490426753821364561103403987998562941807630372207971833058068314969756973987132199898038307695423424899183753738809011830330262308894990663680000000000000000000, + "auxiliary_banks_after_sharing": 1, + "coefficient_bound": 26, + "coefficient_denominator_divides": 6, + "finite_group_router_upper": 1996781817829700505616648003442939670418121383146524832570562414229508517707365630210514410182868208422410426904222349614587120238169565023976593617888088249792889489232587391937114692862833413493878289150647220476973315936613893411371180627349937542747113703441878702871183764108427647246946738280116413202842001601611935577871928896078779222167053557763264184774765184286697868594594314095298375974619020411589760327871072912207011987279157835478300764863885862339514331188591889499931217751046333516074072899497781599216540489370635260835475068278948606593058144659269465953575864037220363386543007930389392650517576506725609273702290538744026324349048797544741931656448511039048822918393059436367372870428114118151808835454194697189172420675444159767607388539974249475729974744313867010877267947494917728324863231728827375097796764153590288328124290854313749034205788857188501097735018015334913812524031309584653511523390713673282151437254342444210331261975595018327204309097452847220268408585326212873150162975484878379620431963947109952968805006023852879520661180163026847720913903900327535082362352341970633278958844785634739058314191225917327628660919631334932181528624365834466594963958416015205875189155986400578676067745563136371392891175778031142494596567179094957992104382032540770219035244465619000829903097000075849583777272674623120007677063732581105732175038816041801105187366687892006322408874222540820191910326456749466829784102697616089009779807971524806980914181559704507613893357294407429708218298288807124701683600890622569213909248073265415355774627205317949186017722026285024353652225922915093100135743357732801132024782406130188987430338256239146124855199854334018599841017758087085872468293679789085826036881023401376565779696277800538708125495766714490405278954114302254259077986737997610651303475214846690409557531207945110471168522019985895615486336976041255809567024577951775285455773833308076711628905615556366827520000000000019248832, + "halving_degree": 1, + "invocations_per_stage": 3525886442745164056544063644145716736004044180364723200424782744512582104634391857878947474919000911664177132185103526533556870749183073596734571342973795793383290849303191539662953799849547227737400544457729391514661713176468240351330298583217125220869576729661326266259024901649005584114421035252391760900092184489369973370724377894349644301151172572225522957784648909234781611948223712944954177723427440753012339451839407462242698998122862136268155486957700758485307238973641035062973415368109606762999662774702118665848434384838590914531021276158042617166069588021894697108433312726842277534281982740181708602162296504975360000000000000000000, + "local_group_upper": 4552920126520, + "logical_group_upper": 48159262409601395467011635701100464832021030569677306175574358095765057248609523233731783063748587071783641348524556567732110852316854063265394354994194196235424254850312119215110537754435839555650149484077504564925881450138377028493433797993315174068073699814547634599867538980931684612010193186301768649845766678767978197392725197692362495088218829833738197421152595019362494884184045934416310722881634052266915958468750757416790961147082161549540715124877340344041143854505135550740971547919140073694734890777732207707027340740665870005216626365456712348847469693004375422271610757332987355192878777460512903919380631891708932219994112000000000000000000000, + "m": 66, + "maxchild": 20, + "original_X_involution_scalar_group_upper": 42240, + "physical_roles_per_vertex": 10523, + "reuse_pairs": 2310, + "s": 3058487884121979618880469479350472234045876075727214763530072694334505195679847604414798439748788312812150483188381832849215504848929866994604243096606503475420815047737861862782153318233891548134075253483323867916695127154369257473877251542428696667340663899223961533751196042636610105873045153977264204291654164329090110960754412911918866753301970833706163183454800280528800491905143281109545162016054452351911517709424671930232882333533699285760176259295614030538977940760817232172955533480082261071282901477962056411266234225915617625718960033747980171749301071294536292270345175925146611539782494544177740946442458155682816327680000000000000000000, + "scalar_group_upper": 1996781817829700505616648003442939670418121383146524832570562414229508517707365630210514410182868208422410426904222349614587120238169565023976593617888088249792889489232587391937114692862833413493878289150647220476973315936613893411371180627349937542747113703441878702871183764108427647246946738280116413202842001601611935577871928896078779222167053557763264184774765184286697868594594314095298375974619020411589760327871072912207011987279157835478300764863885862339514331188591889499931217751046333516074072899497781599216540489370635260835475068278948606593058144659269465953575864037220363386543007930389392650517576506725609273702290538744026324349048797544741931656448511039048822918393059436367372870428114118151808835454194697189172420675444159767607388539974249475729974744313867010877267947494917728324863231728827375097796764153590288328124290854313749034205788857188501097735018015334913812524031309584653511523390713673282151437254342444210331261975595018327204309097452847220268408585326212873150162975484878379620431963947109952968805006023852879520661180163026847720913903900327535082362352341970633278958844785634739058314191225917327628660919631334932181528624365834466594963958416015205875189155986400578676067745563136371392891175778031142494596567179094957992104382032540770219035244465619000829903097000075849583777272674623120007677063732581105732175038816041801105187366687892006322408874222540820191910326456749466829784102697616089009779807971524806980914181559704507613893357294407429708218298288807124701683600890622569213909248073265415355774627205317949186017722026285024353652225922915093100135743357732801132024782406130188987430338256239146124855199854334018599841017758087085872468293679789085826036881023401376565779696277800538708125495766714490405278954114302254259077986737997610651303475214846690409557531207945110471168522019985895615486336976041255809567024577951775285455773833308076711628905615556366827520000000000019248832, + "scalar_role_reserve": 12877, + "stages": 3, + "terminal_sinks": 44, + "wire_bits": 2159 + }, + "conservative_old_coarse_row_reserve": 9909, + "ordinary_leaf_row_degree": 252, + "rows": { + "coefficient": 12320, + "complex_coefficient": 2159, + "degree": 70000, + "degree_gap": "224336/5", + "suffix_slope": 280000 + }, + "semantic": { + "B": 509532410931555680619111905701605719663775309011257184899853371767316317929959509126231486950421913624808115822871265825797304203462159273821591235330478517741402257811415848312180933180882017346493767909630120540412401717248529680239477806233338423813433642418140269735393353932383525076398988653273313580180901204266348309329078956207030476484250546538596473626447601552599528533232546440374842054188408552873669546090772684263830320082937322775897249335546651412079737702086628330204816852039179665908852391032936512904064714099133552082096956766796250645423541481444176637969951480577674329874853875936899064068864814607059269445648296885122099802981475254251150579892446783613334591065679578089966033233448468436814063172662291956468786941696439487875391872017092607956179762879810557759615757515667938229013963393363308533224642451183010009321425595599892859565124274006602949175445499201279903339215304303406754098458648347313475437055614694561143796447164268868760139299916803078267695569970235746633759497701127844741554164421029677303030094295911805654208049706003303749911216284967570666566397692767519504555648495473831709173105195200901996539621430430300635830329052382645589370703710787323881237350436469566667648126119901050082731608838362080495953217426022616769356134447200397805916283120006862503641256449692288145136611099948139171723222496845743524404645690103850840196673333764114308010720547121303713866666506131386201806213479351215520523407590483148115038052675394428095823311632011559213042160212498747737023207511022596817108337650671038492093331488041008596457572261975164210661246080327231396984947768722786800497413840838976099516813301831592280508235939477900165003940658838679752456878611458968849566445248873635447061566573717599424052819373759908728329634672107048634144277452027876858816368758936431866310678444104979295099807667890195815540069010878546283335326798720214506189006146013525815613748341597188553737684615305061909614930075276042239542632728599237677558154291784836234209839260961385775989978252141052692167087374814716316958809199738240097089984896211179410357612679205787133393598213399443234047343758210947473630159156804903661107307014673811229037905455528560902715898064189157164109867334955972123182394008947044337924111972641036987615631325705980088665021917764505752701397419334802321724957768910917139842399541271586368253479467749171765673001824640342732208730637433088044837656758347023314794582908793180355828527603076406038314236293691180265717157392528943729192895289381439545703430621762689685783066622386399651458288932909922872708975425457210923663715355446050789958827304979549775015204660589628049382048159414088886350824139990951695623597455357585789947338756567246855082520379894803970478190080646374725907170600630937374638930370439244376137186931258502092725378890309112445759411478982597831480340925427115998851341292624150119598026644913815467329847434859878041023321026286574843080294022586123425055138651176542718649119075352633419372782791056476906418755435875482741999289270330175685831019358074044683575519364870537110698987378534156423412338368608215994716567771341264691784835620547116095154355823028405037678909536409294936241998064726276240916495855446538713390953917957332894522343859649425558894465528489251474045892119196192790538905119006865260569920159851539352630884411410684543010286411452690005269956873208792508595460908096781391701546463223346195916242564759714955799308966368742627228715461007712659326066236176298406802374308370970686396733236368702340191602509189940399556599714483690088244922651769301641228957332097529146753350021208820702940922157812928490776979272693871844477852319948601242412475069333766783326317417323451865061419628384583210851906090081837589052178712760888235589716528403027031568288437989490163340454913038153349106568531093828746761822382576908672736654271400044763829558214085414340795118674219525044565554958311699780729788995435250081345623470348243544594512672750920229723181348286851358440615607637394658415712783369231357282393690924650482720908188916779881724305476435285671169289604569420907232698282421856982026379712178193610758794079671443090170499840417046551812624329535152282424714022599419754331072196960476616795026403529285824410798217390317086027514688112288530970330509440091515683875928181551063423447893048491177211466119814349423907836888314559662032261555442354347785163113771451383175688798034527042538116399087831616488919004322119167912666265947346004223385757910827157266993723507556830481294342030677452635331455842755200417108167627732222635125802616945528741084596401279157096363540269571573594558215964221481961827180791443114180273766962657973492642630980698679516137989730279605879551135389988039469081618481067485985149309898196042198234371393482956069508355575669945213783147520197065586627742035457497165537741506100395483926269734486532538090154077823377395228805741722431419949702460659538988049212462045808719659171412420328131820872706910401880425640471451275221301310124900094785175997237965232152651361751380990572099367485745003558793777991713218825798314260532283007298442845388829409311469245870057031409455035036166747412979885180821102504947646922867359712076919940847173982654417985779271207380189196864547873292529929118911576152388352104179221105616072584796934015629810661075132694653746489015099846670040079689171577509515832477498369920566593783315631166617970156403597882536309491814201294583593876798892936417830767695273098204067095331361644413858859993328438701461466986432116371466429501796281745317597555372567687272741220946903622572552176033977105176780258670103736123493087637087879866619066857900162029142502169280392319175124019264819172639003008692281782670446846904816665909897332477161522504450906980821508386757337239111618507435101540897858413016340607824077401090553703957855712921974534670532209479468736, + "C0": 548324362691896502675861037544590133574553873674175935778047943368710886417867580577535042485762529084967524669195365237265969758102800729968088762369431370863790885166053148776812067561550206214713418566972978250104268753988305789298776309592163020741446666323935155425081378347694441919056307856963674194342807368658373137120145586012651860493768301469826592085401562390268551562233544159734213847758319356602083146399678164406361723714188573711922941458747613677810636511504152072750546320653874579457514038505298226944843031760829410835675047388208552381372397511175396933791613203032940887250960913251548074762127076589245784709000613346385246490727318433183998971607566312320017674061653909148387434134252020155047800128093282290792048163704766219770776714501976077198155358589913989290278950145062070036166230106725232797721232472468780997455525722691074501481083073764821970786831326264994592159242550304782441038157858805291517742012911528334128682342889921869003415940146031832388705154487556513766050669978054413885995033755917524455904454780648685825190684539602613598664950834382093828380169333005070593866958082779451756694583861534245025851852963620976137055855489295034674303829413951815001565603579205908287085028619170746483154134021758034702510423859637337705140756571118081655252501656918554285287040637052107379418001952146364468335507966107407156376624722456895122264489888316026921840952696078330646972949124367817120531126277419373190380927947176218452708233715576380559381429232455106618839838267893507135442066167569398598656112210385958482576237123883077845146706978120913850980422227686228421013263630171383336444944636080048189059629479225619232563146204735488377024187520057601524758680013592243165203032997200027869872581452544447210457815457387611488588245914650722359560757876221203290046188992425537543361941523880836613490387626400832644598705366426427234136036656130804355023949470562573079098977510572234914875059684213447776697050093488362776074852167103359074765917818291808398572539361945120873667096739923287687793021639888564466725468528157629007549987011293035616243520421077009265811123714300346555540013787246176155535568827090903954621436279700276148659728937689104433955220665653818488700676323007440489592332963648116587723544935319727730477104657877958137048549117225264096323437501345205498147782853749543905925285800516669883730554242766008667296407314547468824825492255562855873310335269022894806175914519055022881889012508084159913495602361075439922824870267472569315529985121551643435276092071926612229524192260604035476683960195190911751833269681049275147475563148006275307467913010394541177976089984457696520142647608392834886867377394388891743176608546559827500938578095216987172098620148238243484243622037700872628472320984986769353647967294460137204290690955253200825271314701870108306347762880799148058161647516168795464193382675583628398036446636838714577693656311011910718467607228814462879746590604215998361510581901038153960354576387664659008857368769203868266365861761371041040085791665388711051256572426804153285692906859709717832241685747102376546851897416908449398791090483373411070470660230628351845168083378254668879137563211183815930121289892625317251697174244899530855932201947894093955613716397394384529290530699287996082718665789827637424156606285141371882046405642687366825672519931915872938335723336771273239629576449718879429251000101520209401707568104048246780728982126025146267598737344929551361333697936995605541530897879775269265018844961620609099452513674020493012888095332848154341291886983648780976053539799253634683252006122905133283085441443635534735311151870345535587069249551347588643197226988657204806280807060526503829446169950127833291839294945619264884476159567533154891512910368661981539488068368954069996269108840986609444501231921358487799892712813396617688072110323812314934596833762706831725675761818857278482804820665705131816419362384004140051554247597382704155032706851207528184509959514646558686992456549196477226767876091527423267750665112002855063915391481060801447193538523508317466831345426548222667736507830894768357708377653362028695110415608053362950061721655765220161289565004940537381190895765118751120591731297033569700285773718386840511483918088827196624396342054657263975663166898380393290889964114044239750632572198763603868868887468929343388818605829072805451724809767245749263854035461296935472079060517075004070033375077497850232361257368839238207327373299967284267223131841486501683798149738397010581661934515817975123433127038178869689091191396413619462172869358691764163694331194170425641378999866471812408489677307032187179399149469280857321683417603560191395113127779900854241408278271797217003223494142046531191819211911996214950224596556007923335150494117497147787949875844827239889335840068908539272429643926120925108290749795869347932477947423800462191997380511583183863591337876415694464859477083443881961609968069317789483403041852407847639026192663213593119135904780850719485887348605211744806901849450737467992615904222379798283608626015925576874449996734627208251368192120498580478859063672467440538292510788087496861274141816406108854607905651119168042347563132254176568912132526791058901243125083908761671518518019758105271187851352858610022260702962596693208403737562776045067217998548739334611421773952010512871078776268375553961943232419804756029560649932377959373702019349229096743567417083554698025605253114271473849227851743954340400473000178034130209483973382669629325506108657548483784833475502086405884905019195321091456786131027522992497603928632830104877807790614391346410525405577611153343431374207626510748597963949634033740523092946676301473924362721842286122976519326261665022123651941159826510011906365871394451870130479892741276031714000065647014300601430000365834475726392543565816220973292979021836897724250035452614798117572691872113495053770271420833517560319781327445925683510123762196983138595610551843145150987242940033858174034701697983486100864848427470972292941453432765961298412994035879754805550237067184027821805880812659184159872912466544596588692635155302443444945264555941449515364125489109904582738388759639148886613754120176454463397667279831543562778130451790032094611069476042641943884816675808195369947772145518715901824476922272468098887062107543034652049781266350610035014787106962161683635687905862250751845019521203837045368720736966466149785315904854100697971727793182350348803720968963400876244446574679856132513182884833236817122030914179620244909551740556166651982526168493388708198294550091349159861080799876121318447870127497716781821922787349017787513719553478020099126487556819796332698511549753802048575752108415203957532651580808999266737491298522171330317017142227967580732643215206532748213806669057248668946959013244674484322247470227189617838354827806983533736278317479623040210575797302382317698730847796870839519084343322881087729816610366658747161379041769764525432569634365786128508554286565043976248652243493192890482938943020186480331971810397307691176371291058497485300622902859076167296966839036627929166606513734407562504280779390468323374558841804450679611361682373304473001857421727160936919973085798903402086876433819141862037844702550651495126901708721378301415009224190928908673469967351065907695480251456156254726061580852310075700170980987893942957014140896691908839227489629778377923172860379443546759711068781262913380349233054227886577370214141144221456139765594977329792176337765521621462858332333189560276900376957053293125316475475035434236353669751675154900352691975679887836647591137036275571167887026142318731239291198086694973461373787675785595595818235066725637677273564324969078602245050223850273318586241095050231293371114907715523050119839317168863871792244776706794992014448038428264587240849847624870887919438687915571363954165362509914715700365047647691873614981707069546493625308713894572351618337400653179008577693302124836755663756287364614639788426098838914234086768331113547652528276086427123142435028695329286942474036433017980979104129321647281535531406045289382069105277157126882308010825427785948726726201004796362658626288511034187963689739215707227535637137803889958501005850666981738319590592108923866777333651569856121642851497765357026044268973352113621149484261048774866817530634810800153553743179608954638775188570720777035064595227664578607229183431987735845007428072090104359536847475122805242280363670948479496786833972120992666283922106731090280764458314210479271148779790803724397948274235836014445049251090907814006204520943730358018897451589485380958728207663827346503402960971916351124732547340167598261113492961331722608316016402900594788010856474016644384365583864100537833648666114007855197202946570967097597758872094304196746089549373670843248471530586036495083288496514267929932294045592280969821786219730989063070537249267021630042494867403070533846620734547897682299588611777151402480072789390285932403018699042255132812021266648810960605699941541371967387198092060370983141756394968303037454309726925843303788079061784010204796055486186043328688951285923599447680453934410100332478221437999160534157784048296864633709012684562689180879088132554559819192303519857473968646471480591944953442967139881710903890274170231445936924068005752797050931441375112407236585803738705258870529361749397092618257736675536089309610511738606810897949375891130550970613313940750762078633996264863945968171853150408906192019253015727927042359080657749963052200626500711807355774861746874936838825180476934752679793938031924975877868137222794292489050782440242185086154262898215995820282187597949541339027808308729863940030701480132099968535501654927057663721648433069162026821339384993263217634941793096151794744331079307543527546816662136001425996892740462662227108790704493446354461608832638695877599613541634397936620503106617840288336672249307978174115163891360507039487340574861531692268949818865030425385539292626266149157643218783911424778023117872229653394338366089187442749151929451939707111148171443486051301910069047384928240597730371886067206722766064067144787487188009205582465651406862253005711809073941328924614483174323710150041471506672532789657950560415745671470391141583444053255784642338246860880613634350453550613883706529105212271094201398964465072446119687732179830049017182468879591316291599449637102424291237370212370493939222011764526719168305966769580473635513487720466859211465194017512063410615889765213809520611674783601119043631185263579918394682965473467704148689979164075645564890309795056836312409289465038512866354856135793668745648203240399351214137389345620502956335896071661581353445486867652333836841914630800589851263655462666013358131837784996009287069952857093387116427762369652408875872248201660964393285753804680152400324962097222501770564139260079923366875150383448303914221720295064665932858910710141496913959335028590022100931844913891652414288110334085004378785295977625914559975892449950560342616983089623962653519158799862731964683404670411149164645023411794497890329207031617088328625223283910717722454113768838461280153885236670363238537313432408102627160252751799824506547178140731035596896899984985269704908131562141295776036915231298043024368064607190751037719097068370052261651412434764150523222264168024102561991900565639471202818542949700231562007498752671781672949085170277178598477188440079391692208734889837748081816399190876024597990433977383241450775991986184831686607112639104062350777338572802982072080749270081210878522336661728271118859001034506381883927245628055940652434554731342028608453318102439473074500285632983173941609434648460777641917178776992397647054963190606994249786817235250992111755668434786710049374067334782982083416789840251722850348852779791802970332669074595619536284636413952, + "C1": 1, + "E": 509532410931555680619111905701605719663775309011257184899853371767316317929959509126231486950421913624808115822871265825797304203462159273821591235330478517741402257811415848312180933180882017346493767909630120540412401717248529680239477806233338423813433642418140269735393353932383525076398988653273313580180901204266348309329078956207030476484250546538596473626447601552599528533232546440374842054188408552873669546090772684263830320082937322775897249335546651412079737702086628330204816852039179665908852391032936512904064714099133552082096956766796250645423541481444176637969951480577674329874853875936899064068864814607059269445648296885122099802981475254251150579892446783613334591065679578089966033233448468436814063172662291956468786941696439487875391872017092607956179762879810557759615757515667938229013963393363308533224642451183010009321425595599892859565124274006602949175445499201279903339215304303406754098458648347313475437055614694561143796447164268868760139299916803078267695569970235746633759497701127844741554164421029677303030094295911805654208049706003303749911216284967570666566397692767519504555648495473831709173105195200901996539621430430300635830329052382645589370703710787323881237350436469566667648126119901050082731608838362080495953217426022616769356134447200397805916283120006862503641256449692288145136611099948139171723222496845743524404645690103850840196673333764114308010720547121303713866666506131386201806213479351215520523407590483148115038052675394428095823311632011559213042160212498747737023207511022596817108337650671038492093331488041008596457572261975164210661246080327231396984947768722786800497413840838976099516813301831592280508235939477900165003940658838679752456878611458968849566445248873635447061566573717599424052819373759908728329634672107048634144277452027876858816368758936431866310678444104979295099807667890195815540069010878546283335326798720214506189006146013525815613748341597188553737684615305061909614930075276042239542632728599237677558154291784836234209839260961385775989978252141052692167087374814716316958809199738240097089984896211179410357612679205787133393598213399443234047343758210947473630159156804903661107307014673811229037905455528560902715898064189157164109867334955972123182394008947044337924111972641036987615631325705980088665021917764505752701397419334802321724957768910917139842399541271586368253479467749171765673001824640342732208730637433088044837656758347023314794582908793180355828527603076406038314236293691180265717157392528943729192895289381439545703430621762689685783066622386399651458288932909922872708975425457210923663715355446050789958827304979549775015204660589628049382048159414088886350824139990951695623597455357585789947338756567246855082520379894803970478190080646374725907170600630937374638930370439244376137186931258502092725378890309112445759411478982597831480340925427115998851341292624150119598026644913815467329847434859878041023321026286574843080294022586123425055138651176542718649119075352633419372782791056476906418755435875482741999289270330175685831019358074044683575519364870537110698987378534156423412338368608215994716567771341264691784835620547116095154355823028405037678909536409294936241998064726276240916495855446538713390953917957332894522343859649425558894465528489251474045892119196192790538905119006865260569920159851539352630884411410684543010286411452690005269956873208792508595460908096781391701546463223346195916242564759714955799308966368742627228715461007712659326066236176298406802374308370970686396733236368702340191602509189940399556599714483690088244922651769301641228957332097529146753350021208820702940922157812928490776979272693871844477852319948601242412475069333766783326317417323451865061419628384583210851906090081837589052178712760888235589716528403027031568288437989490163340454913038153349106568531093828746761822382576908672736654271400044763829558214085414340795118674219525044565554958311699780729788995435250081345623470348243544594512672750920229723181348286851358440615607637394658415712783369231357282393690924650482720908188916779881724305476435285671169289604569420907232698282421856982026379712178193610758794079671443090170499840417046551812624329535152282424714022599419754331072196960476616795026403529285824410798217390317086027514688112288530970330509440091515683875928181551063423447893048491177211466119814349423907836888314559662032261555442354347785163113771451383175688798034527042538116399087831616488919004322119167912666265947346004223385757910827157266993723507556830481294342030677452635331455842755200417108167627732222635125802616945528741084596401279157096363540269571573594558215964221481961827180791443114180273766962657973492642630980698679516137989730279605879551135389988039469081618481067485985149309898196042198234371393482956069508355575669945213783147520197065586627742035457497165537741506100395483926269734486532538090154077823377395228805741722431419949702460659538988049212462045808719659171412420328131820872706910401880425640471451275221301310124900094785175997237965232152651361751380990572099367485745003558793777991713218825798314260532283007298442845388829409311469245870057031409455035036166747412979885180821102504947646922867359712076919940847173982651359497895149227761308727385197401058484053043184361388858279409844715909936224980382135575881022348262982211465364656165884341821110212694567334412909329002077554872828731920533477848384078608269522629052985623897506167429224619325015684875402071027932434304843133797610448371222249887455393547484202782140462207137339390835527332405678688619265716439035057763448822292023375542071961895670713508087681671141176119378455194688833975566628329856741993021096705144585041324058355406830053158801700409375564003338703853486066242935606886825188020787760406585587938040323971142831195721933266404800825329533223349607261499700030105646854670532209479468736, + "exact_grid": "One dyadic grid times 3^(-K), K=G*(D_complex+1); completed children preserve the incoming odd exponent.", + "fixed_odd_divisor": 3, + "induction_gap": 46367449394771566936339183418846120489403553120024403825886656830825784931626315330487065312488394139857538539881285190147554682515056493917764802415073545114467605460838842196408464919460263578530932879776340969177528556269616200901792480367233796567022461460050764545920795207846900781952307967447871535796462009588237696148946185014839773360066799735012279100006731741286557096524161726074110626931145178311503928694260314268008559127547296372606649689534745278499256130889883178048638333535565349597705567583997222674269888983021153239470823065778458808733542274811420074055265584732568364018611702710257814830266698129242393519553995016546111082071314248136854702770212657308813447786976841606186909024243810627750079748712268568038659611694375993396660660353555427324012358422062760756125033933925782378840270668796061076523442463057653910848249729199590250220426308934600868374965540427316471203868592691610014622959736999605526264772060937205064085476691948467057172676292429080122360296867291452943672114290802633871481428962313700634575738580927974314532932523246300641241920681932048930657542190041844274914564013088118685534752572763282081685105550169157357860559943766820748632734037681646473192598889718730566755979476910995557528576404290949325131742785768058126011408234695236200338381763920624487831354336921998221207431610095280664626813247212962660720822757799450426457897273372534402028975569788038637961866652057956144364365426620960612367630090733966478468462793460892956719921358513051888386836579337386044069111883503056310356858726211064502780493165411731782277639075839739943170173393309778057125630246953773598845264659516346825056030010466674897526249470492488915015358599954319857473575953642766165310546517647500825682602558208301547588806563012151694277996755161741425707129248134536794152289557063215299834271738413553115854082497778007819214146279989947711783514738683539520063199559287230849220851099085344158390129299992760633774958636850119843798379578302530628657792040552420097313095372747486105615088020944835794987204951108139184843251637176179848835188625555217326342542753807726629138817437419349334298308281997196220100344483269246233160764938335316821842449396453099042147146723841213301933997927480993463209597854814181034751094189510334365873022450639244188068516994516570023495827165159467011276971156970893459725658358255714359511066631565174630676243166042271188630994488006411012080226765009579121646307044700179412380396011879952949486595502725897404180261322720133879356553471333710998659012186580404761406259062637162368282704292894802981416516763716606194053398097345590621886253284753139029526383624113656152493766382506682088657924996739176604301747368437540306885207826847619463812509354570427161313515297338820100057552524657415301092142663709971238228484010744523690438009479018129232564106444587416402664711024213867555895472057628797660883420424687157207527016116572248901733122213392078310720306756055337231680017617257065387397069835857089641162923233986139398484106744664668929521935323600045987410622761584738066205372262203218877073607851446608234530522791543347655519207667192055086952420041469787564659046379895584858428780767813245839198021823890091137923401122845635022918576806534117293401533291228097725859396363092521884138176182846853543939040365829624738711862734546490081089410481438372293413936063442194790479566075462000118282186942636807106644840728153324503828378073393134060977737115939555579077813106951701851998672027492043155019016062061758332462102724509551912957435828336284576359650574018015798030287961311006449351835117220875152354554851930002683967623916360976492660705113815142337847484561115322713059535231309372777282694884976434119720589186182997072187523454197447220603748262861240829438664204084675459872714247857043604863981397086471954768697736329538415955325836814498689219035538697404073508489797481772705012355799353976779055465501206364680046410798584607757402451735801690162558100653220333740904809502694103473618096020295002913915829863286600053512697825874143193927602645191426969236911798355610996076405354015817302558175543700388985364400553808215618579050261250101321205515485477951236214948813987698857700648976056547197644127569923403372128347402721165010021382637782518854828503836618218256318300076359048327927232709464521146771533758267412697126243416903105797575613156836624929244935801545254245648449843353202075868987680621141960870968592316992677100491629393312844280052630201208486384328103969885271311296428839187671573797785124791648189815162481690723237956843254123632259796448038142043115438698272516403295769082164531013197104797652744154858526273452021323390404912793601875587830479419243579835968557065455444135039153320488911591686427281777141224648587200735839840039327796806949002325260357385965014454266424337932968383124525226632242063934477055135989037290545838274460966204021081927342965821322496741259215422923920018047912478334046168593488984598530249859995699416328846571118733282902066045138419221365908625451015748654836125891273919375670142061042441202795323850233797245902913147646597708437753664158298930383476247343701374175189858260408188291174014581169551454720327950235869980929733798999714617092832421552036705913679871597216914673856469620223549820953429867340041480309120611062605216520995422312770157837075213490930500374086046973647251714613553365940755452351662771560034281722436162235284232727407310804163755092317807107042788699257214022599860269851936570105675153909641661156259392887921832993495765322589803445084663461638823901377538903659541819451106168229654102248019091916571087003538979439987237870974974997067862335084068914744651967697404515701044936285753098544710149273790997642223010663068338316597800657255421698547905032535254757263194917688759157284176594240221705115584486995311991043499240387060164869875899682655018431062631654976, + "literal_charge": 8602150047189017391843029789286164264397633273752142192572273343677564296140290213863435903407629781044931775522095102447544872232274628451243136983154019175044862799195358724163631235664934195650342836395502196070513645700205015362335507968804774298743099463425553958878446149889070330152112397525058850647985031301475689776144911105243639000519522385285503321508791061957291817488157505463194429987724002263147282562756226608375847168010223232454428811013041048686610882431723491236939392649633941852184749966988064573063759423179843436619766227305453505605520759257169907719598984609468469342379148219036740797175576572911649000230657841669733653133004438584566268479558369744617611371619714047531786863547342165546470382054695797432853408092277922597402257831146784572173119052463875300004005144460751820681254995043175536830775433766501277209684180245447311422921122678328305735455808304403586745303159843691228508505961672408091131340416425027153270294977604477187985223134884706370361307077753689984003976688999605615070695746586441632307600539031440802826614390051364049332043527820229354329006988633853031468238352784318382775077978860847005173916587731271418449676979621871615614228623965193371889055886092963082548612813434970997714603221188676743033397554276236316646437866916333639680420849198115445882693979119799380580600345984601198824388196978608447002074250875661793528478768809996365176349731085009333105945690598612400264723275458758613808931981630126557430907441015766323983665751995886185911918698355823586432739359988354578150267343835360275609634897131299862181580974858108490069487445711764198302088278539776310784957285582495467228820992792190977531053545527703444417307602364728064643729892360762418664858759691757275089630779287095027478379397941728157566371161190668332472966266763005931445515964706279258714423783443975494281749379534368563704478293621983417992735524041434559442841562771745250027561584049065940963344175937722710565152048370793617232535215624113648534354593086952446727532575089277007786985763821449817224804159577918781236392219356397886933941089363470136815955663254745466593961989862282652232017748789907326412816205862367847487065493020833776521989829078457987075672349264748822706946470301881167920591163986503365685570045069501212895829467454176384556905772030317496423453555165129733212572412834114041593025884977892074900420214271623052500568613681103838841968110989445056399316102683298019429949265617281993255202810858397930875624013685435087293740935229253486558475406650740991892747025319088152862668912282841338359061754788306782622745831079705949168289480396131076026558289251050870782378401981437859815308553222718198646948947624855986514441095590063131192179050107202222690259816999805451248012866975482912065729483754556620019451424873562540273420474051996818395921751177657017329187103847207798746730950287983229443389329780667525592972971825105814151722585840333561507822933718377467865400590994126018763313044721781253399662637027202706644506168377581986007139910706310953048426617808204185875233898194913062336477218293056741622639580272023272752851940456033314673140700904884808381662452232303147275239629862436893247069455519025904339792522042446629386246460714481042493276160000000000000002116, + "strict_literal_gap": 509532410931555680619111905701605719663775309011257184899853371767316317929959509126231486950421913624808115822871265825797304203462159273821591235330478517741402257811415848312180933180882017346493767909630120540412401717248529680239477806233338423813433642418140269735393353932383525076398988653273313580180901204266348309329078956207030476484250546538596473626447601552599528533232546440374842054188408552873669546090772684263830320082937322775897249335546651412079737702086628330204816852039179665908852391032936512904064714099133552082096956766796250645423541481444176637969951480577674329874853875936899064068864814607059269445648296885122099802981475254251150579892446783613334591065679578089966033233448468436814063172662291956468786941696439487875391872017092607956179762879810557759615757515667938229013963393363308533224642451183010009321425595599892859565124274006602949175445499201279903339215304303406754098458648347313475437055614694561143796447164268868760139299916803078267695569970235746633759497701127844741554164421029677303030094295911805654208049706003303749911216284967570666566397692767519504555648495473831709173105195200901996539621430430300635830329052382645589370703710787323881237350436469566667648126119901050082731608838362080495953217426022616769356134447200397805916283120006862503641256449692288145136611099948139171723222496845743524404645690103850840196673333764114308010720547121303713866666506131386201806213479351215520523407590483148115038052675394428095823311632011559213042160212498747737023207511022596817108337650671038492093331488041008596457572261975164210661246080327231396984947768722786800497413840838976099516813301831592280508235939477900165003940658838679752456878611458968849566445248873635447061566573717599424052819373759908728329634672107048634144277452027876858816368758936431866310678444104979295099807667890195815540069010878546283335326798720214506189006146013525815613748341597188553737684615305061909614930075276042239542632728599237677558154291784836234209839260961385775989978252141052692167087374814716316958809199738240097089984896211179410357612679205787133393598213399443234047343758210947473630159156804903661107307014673811229037905455528560902715898064189157164109867334955972123182394008947044337924111972641036987615631325705980088665021917764505752701397419334802321724957768910917139842399541271586368253479467749171765673001824640342732208730637433088044837656758347023314794582908793180355828527603076406038314236293691180265717157392528943729192895289381439545703430621762689685783066622386399651458288932909922872708975425457210923663715355446050789958818702829502585997812817559838763217783761780815134208631567717608018059301315067371926511435348937465810150744857799701522933317848371746274664033617476918199594067571243885651973555695593567897075036053913610249688897833282392816118005417458311224552598193160724565639148198763926396999695322462352982172673041255273367390517877675018181416138131654157433145797566561571462080965302898971443224325448151480478852006707573949077455172190063821451121090553857496062012376496102432932175398975958582052864383021374276627211771861123936251717736056801099584173304015650037766334278465741666772447153476298319676650156742380759982873343628991583889160812395484812889479623639637823045921293747387151213038133296304197187084414029355988745577433003360412082672554615377645724023287789044317516401542458078885444095561309764671780262478190934976125951505776827467212014643315053620078496638852562666282809987933208858648963094003228267991465468374067265061091652356791697164040972108962644440382988714131067012956918181123928885161908576947285402845544719409569801609648454943715419276985373795631635707090621395949357820437851729053270669403634782027388584542611815295760149838761009868291724840684414188155734679475207735783679273769763473701738939668178856087086524816531138104478472236352608710925874537462501665283906301456130281965042870002258943395688284553941621276179274035975696647087128868584662050536433638146347949287745234051870320643465641321123110496544453655544611858697128405140908714616669861095840467793479837787172361340311454735592349573073211191537014694638020982562532441624561645841002709514764852596724315250746048100013260104734590560285867119496339992799455894563812239458620579186335358804163156130414792801261054657666632747257535272567004783176044412619627596742610260714843215831767764036606670883123125337230204580538675192418384516567811635659681279617205173849000987983515395921851500467905707385303894258706134476144823451794499924560650568574735123852061185655043447829185676484621147830683389132204954040195027621664363048962803080054711406238761342281629204048640916135742735179726733294002487656491205203332917292149406134871821555187620588222021290082649111437261157691118607599552069686192748342830795035798514316005678570500029172404584032753876182332976274268255035392796688629221491625758906880678986446598999586214090227846821932509805525220257179652168800741511218990946334029126975787096252045648697692552669418220127721565538575180854820894922690246846847920004701910159575922752993839219316039516708009717078594550310972897979764145885892134560577089331088861141224814361879101764073201203019476334326618680082071605324546080305056691646068960988600124395621134785432285131790032415257453943194082004110407243319321545933846090011825389074175300514026423510516067996102155000988805501584416251567601995828581028194272281201484016859904354221118590554724294482421722378388630417876366803777883012593614028210823218674722313016294450404100510769975879434934692964069001919304089155168979467748883735785548948820125670866759122901792082248564105765298665207413578529677136622712062882670538812925542030722078443525568555457259310348308177887077895761740202907362065008303287086593963360800785218987612370694670532209479466620 + } + }, + "coarse_bit_saving": "677773948354561/1000000000000000000", + "complex_saving": "665489485337/1000000000000000", + "eta": "1/1000000000000000000000000", + "kappa": "166261725903847/250000000000000000", + "matched_comparisons": [ + { + "a": "665489384671510514663/1000000000000000000000000", + "actual_bit_saving": "677340914792209011106157466449676890973/1000000000000000000000000000000000000000000", + "beta": "1/1000000000", + "complex_saving": "665489485337/1000000000000000", + "eta": "1/100000000", + "kappa": "66504678314119/100000000000000000", + "layout": "balanced", + "minimum_margin": "3327446823534145538077807472060514663/5003327446856808614106163948533700000000", + "name": "Same suppliers with earlier positive outer backoffs", + "weakening": "1/10000000000" + }, + { + "a": "665489485336999999999999333510514663/1000000000000000000000000000000000000000", + "actual_bit_saving": "677340914792209011106157466449676890973/1000000000000000000000000000000000000000000", + "beta": "1/1000000000000000000000000", + "complex_saving": "665489485337/1000000000000000", + "eta": "1/1000000000000000000000000", + "kappa": "166261725903847/250000000000000000", + "layout": "balanced", + "minimum_margin": "332744409924090075909922758598270727729272270729394494318848181151818847514663/500332244410424089575910423090842681151818848181152485337000000000000000000000000", + "name": "Same suppliers with finer positive outer backoffs", + "weakening": "1/1000000000000000000000000000000" + } + ], + "next_grid_scope": "Rejection at these fixed certified supplier values and stated parameters; no global or true-profile optimality claim.", + "published_parent": { + "certificate_sha256": "05b253a21dc526b6039f56d1068162a19a8a4f29291ad94eb892656b88e9142d", + "kappa": "3279447/5000000000", + "ordinary_saving": "1649038264871199969/2500000000000000000000", + "source_commit": "4a3c769e5c5430e7114c4d3e099ff34664677f17" + }, + "scope": "Conditional finite witness retaining the source-specified uniform bit, exact tensor, row-restoration, paid layout and analytic/fixed-tape contracts.", + "status": "PASS", + "strict_weakening": "1/1000000000000000000000000000000", + "unchanged_47_slack_body": true, + "weakened_transfer_saving": "665489485336999999999999333510514663/1000000000000000000000000000000000000000" + }, + "bit": { + "coarse": { + "accepted": { + "bad_fraction": "1/10000000000000000", + "edge_count": 294746, + "fallback_children_per_edge": 165888, + "fallback_lower": "443402390956655029231245143620375823449913316739191/134335937500000000000000000000000000000000000000000000000000000", + "fallback_upper": "221701195478327514615622571810187911724956694844413/67167968750000000000000000000000000000000000000000000000000000", + "lower": "3627070312499999993418235504017792380724010039202009964239458157/3627070312500000000000000000000000000000000000000000000000000000", + "raw": { + "lower": "742823999997548160791020711573206786426114025875223/742824000000000000000000000000000000000000000000000", + "saving": "677773948354561/1000000000000000000", + "strict_gap_lower": "817279736326429475597737857961987308799/247608000000000000000000000000000000000000000000000", + "terms": [ + { + "child": 1, + "contribution_lower": "3503808144878566902706194750195580078047268927403/41268000000000000000000000000000000000000000000000", + "contribution_upper": "1751904072439283451353097375097790039023634751929/20634000000000000000000000000000000000000000000000", + "exp_lower": "1002902817921543813387900415092714457985097489/1000000000000000000000000000000000000000000000", + "exp_upper": "501451408960771906693950207546357228992548827/500000000000000000000000000000000000000000000", + "log_lower": "2138333059508027655521093419109790556760740759/500000000000000000000000000000000000000000000", + "log_upper": "4276666119016055311042186838219581113521481519/1000000000000000000000000000000000000000000000", + "multiplicity": 125772 + }, + { + "child": 2, + "contribution_lower": "29398316452581590421407298703524950876252648041283/371412000000000000000000000000000000000000000000000", + "contribution_upper": "4899719408763598403567883117254158479375441423307/61902000000000000000000000000000000000000000000000", + "exp_lower": "1002431767742407693299938578904250379385980429/1000000000000000000000000000000000000000000000", + "exp_upper": "501215883871203846649969289452125189692990223/500000000000000000000000000000000000000000000", + "log_lower": "447939867307013750203119339595175568180747673/125000000000000000000000000000000000000000000", + "log_upper": "716703787691222000324990943352280909089196277/200000000000000000000000000000000000000000000", + "multiplicity": 58654 + }, + { + "child": 3, + "contribution_lower": "43050965402250844599318910560668345167832991837/687800000000000000000000000000000000000000000000", + "contribution_upper": "1033223169654020270383653853456040284027991809243/16507200000000000000000000000000000000000000000000", + "exp_lower": "125269540452718267505292659245397706598932081/125000000000000000000000000000000000000000000", + "exp_upper": "1002156323621746140042341273963181652791456653/1000000000000000000000000000000000000000000000", + "log_lower": "39725672879349320245586770016213192610924887/12500000000000000000000000000000000000000000", + "log_upper": "3178053830347945619646941601297055408873990961/1000000000000000000000000000000000000000000000", + "multiplicity": 30930 + }, + { + "child": 4, + "contribution_lower": "16678474793929904192671677155855410805826687617/644812500000000000000000000000000000000000000000", + "contribution_upper": "400283395054317700624120251740529859339840503607/15475500000000000000000000000000000000000000000000", + "exp_lower": "62622558675581617744699663914350728933016349/62500000000000000000000000000000000000000000", + "exp_upper": "500980469404652941957597311314805831464130793/500000000000000000000000000000000000000000000", + "log_lower": "462459481263386350753235615248516476379277/160000000000000000000000000000000000000000", + "log_upper": "2890371757896164692207722595303227977370481251/1000000000000000000000000000000000000000000000", + "multiplicity": 9588 + }, + { + "child": 5, + "contribution_lower": "269486732045381961622707742902210011378777721463/9904320000000000000000000000000000000000000000000", + "contribution_upper": "7485742556816165600630770636172500316077158937/275120000000000000000000000000000000000000000000", + "exp_lower": "1001809412808111381497054806327918257913671827/1000000000000000000000000000000000000000000000", + "exp_upper": "250452353202027845374263701581979564478417957/250000000000000000000000000000000000000000000", + "log_lower": "666807051645488734110356876248348368498970041/250000000000000000000000000000000000000000000", + "log_upper": "533445641316390987288285500998678694799176033/200000000000000000000000000000000000000000000", + "multiplicity": 8070 + }, + { + "child": 6, + "contribution_lower": "14440967746880887477116473140648851397969035969/859750000000000000000000000000000000000000000000", + "contribution_upper": "173291612962570649725397677687786216775628431801/10317000000000000000000000000000000000000000000000", + "exp_lower": "250421406015275505383522655618188174531254959/250000000000000000000000000000000000000000000", + "exp_upper": "1001685624061102021534090622472752698125019837/1000000000000000000000000000000000000000000000", + "log_lower": "1242453324894000155114854739919439420399245413/500000000000000000000000000000000000000000000", + "log_upper": "2484906649788000310229709479838878840798490827/1000000000000000000000000000000000000000000000", + "multiplicity": 4152 + }, + { + "child": 7, + "contribution_lower": "39729378639312699845895630054201606465074544061/2063400000000000000000000000000000000000000000000", + "contribution_upper": "59594067958969049768843445081302409697611816151/3095100000000000000000000000000000000000000000000", + "exp_lower": "1001580974100320164182242774475670751220366657/1000000000000000000000000000000000000000000000", + "exp_upper": "500790487050160082091121387237835375610183329/500000000000000000000000000000000000000000000", + "log_lower": "2330755969960742005936834094776401383884396789/1000000000000000000000000000000000000000000000", + "log_upper": "233075596996074200593683409477640138388439679/100000000000000000000000000000000000000000000", + "multiplicity": 4080 + }, + { + "child": 8, + "contribution_lower": "104906112174169234877324309789314472161796341571/7737750000000000000000000000000000000000000000000", + "contribution_upper": "419624448696676939509297239157257888647185366703/30951000000000000000000000000000000000000000000000", + "exp_lower": "250372582754580512833709569902898501579466209/250000000000000000000000000000000000000000000", + "exp_upper": "1001490331018322051334838279611594006317864837/1000000000000000000000000000000000000000000000", + "log_lower": "439444915467243876558098094769010281858996223/200000000000000000000000000000000000000000000", + "log_upper": "549306144334054845697622618461262852323745279/250000000000000000000000000000000000000000000", + "multiplicity": 2514 + }, + { + "child": 9, + "contribution_lower": "36551479051140885266439078461860856261829619067/3439000000000000000000000000000000000000000000000", + "contribution_upper": "73102958102281770532878156923721712523659238207/6878000000000000000000000000000000000000000000000", + "exp_lower": "500705192481381989951220252902203510436022179/500000000000000000000000000000000000000000000", + "exp_upper": "1001410384962763979902440505804407020872044359/1000000000000000000000000000000000000000000000", + "log_lower": "2079441541679835928251696364374529704226500403/1000000000000000000000000000000000000000000000", + "log_upper": "519860385419958982062924091093632426056625101/250000000000000000000000000000000000000000000", + "multiplicity": 1752 + }, + { + "child": 10, + "contribution_lower": "11248373375832671562314116068036043242892969919/825360000000000000000000000000000000000000000000", + "contribution_upper": "337451201274980146869423482041081297286789097907/24760800000000000000000000000000000000000000000000", + "exp_lower": "100133887618688470881134564403881690589551661/100000000000000000000000000000000000000000000", + "exp_upper": "1001338876186884708811345644038816905895516611/1000000000000000000000000000000000000000000000", + "log_lower": "197408102602200962702419538353521690592038003/100000000000000000000000000000000000000000000", + "log_upper": "1974081026022009627024195383535216905920380031/1000000000000000000000000000000000000000000000", + "multiplicity": 2022 + }, + { + "child": 11, + "contribution_lower": "1112415628455787083173462112022781256078024012481/123804000000000000000000000000000000000000000000000", + "contribution_upper": "139051953556973385396682764002847657009753001699/15475500000000000000000000000000000000000000000000", + "exp_lower": "1001274193029511325988714772297732903760597671/1000000000000000000000000000000000000000000000", + "exp_upper": "125159274128688915748589346537216612970074709/125000000000000000000000000000000000000000000", + "log_lower": "234846355777210595872530407531806476712471833/125000000000000000000000000000000000000000000", + "log_upper": "375754169243536953396048652050890362739954933/200000000000000000000000000000000000000000000", + "multiplicity": 1212 + }, + { + "child": 12, + "contribution_lower": "338911326779443141578699078765192412609737750193/10317000000000000000000000000000000000000000000000", + "contribution_upper": "677822653558886283157398157530384825219475501063/20634000000000000000000000000000000000000000000000", + "exp_lower": "500607572790905674414621977496591451417633309/500000000000000000000000000000000000000000000", + "exp_upper": "1001215145581811348829243954993182902835266619/1000000000000000000000000000000000000000000000", + "log_lower": "447939867307013750203119339595175568180747673/250000000000000000000000000000000000000000000", + "log_upper": "1791759469228055000812477358380702272722990693/1000000000000000000000000000000000000000000000", + "multiplicity": 4062 + }, + { + "child": 13, + "contribution_lower": "1763544802521377822423828494648462169948347654159/123804000000000000000000000000000000000000000000000", + "contribution_upper": "391898845004750627205295221032991593321855034649/27512000000000000000000000000000000000000000000000", + "exp_lower": "500580415135219364866258442988493377788347333/500000000000000000000000000000000000000000000", + "exp_upper": "1001160830270438729732516885976986755576694667/1000000000000000000000000000000000000000000000", + "log_lower": "1711716761554518574988699396654262508716213573/1000000000000000000000000000000000000000000000", + "log_upper": "855858380777259287494349698327131254358106787/500000000000000000000000000000000000000000000", + "multiplicity": 1626 + }, + { + "child": 14, + "contribution_lower": "119132154828073979688861784606223402749697171773/3439000000000000000000000000000000000000000000000", + "contribution_upper": "29783038707018494922215446151555850687424292973/859750000000000000000000000000000000000000000000", + "exp_lower": "1001110544773730921755141047111121031510060267/1000000000000000000000000000000000000000000000", + "exp_upper": "250277636193432730438785261777780257877515067/250000000000000000000000000000000000000000000", + "log_lower": "818804394700398348259800986659112407904448327/500000000000000000000000000000000000000000000", + "log_upper": "327521757880159339303920394663644963161779331/200000000000000000000000000000000000000000000", + "multiplicity": 3672 + }, + { + "child": 15, + "contribution_lower": "300319119709954823895275567890335638056172331/34390000000000000000000000000000000000000000000", + "contribution_upper": "3003191197099548238952755678903356380561723313/343900000000000000000000000000000000000000000000", + "exp_lower": "100106373236651607965091855963445212685390777/100000000000000000000000000000000000000000000", + "exp_upper": "1001063732366516079650918559634452126853907771/1000000000000000000000000000000000000000000000", + "log_lower": "784307958956922622523091134035433884674194803/500000000000000000000000000000000000000000000", + "log_upper": "1568615917913845245046182268070867769348389607/1000000000000000000000000000000000000000000000", + "multiplicity": 864 + }, + { + "child": 16, + "contribution_lower": "27694885124681286530763510319636299253308484679/859750000000000000000000000000000000000000000000", + "contribution_upper": "2077116384351096489807263273972722443998136353/64481250000000000000000000000000000000000000000", + "exp_lower": "1001019944265588669786632903119384310360547639/1000000000000000000000000000000000000000000000", + "exp_upper": "25025498606639716744665822577984607759013691/25000000000000000000000000000000000000000000", + "log_lower": "1504077396776274073373258352386874841219480981/1000000000000000000000000000000000000000000000", + "log_upper": "752038698388137036686629176193437420609740491/500000000000000000000000000000000000000000000", + "multiplicity": 2988 + }, + { + "child": 17, + "contribution_lower": "320480050094085743892202695014292708673559341721/20634000000000000000000000000000000000000000000000", + "contribution_upper": "1922880300564514463353216170085756252041356052247/123804000000000000000000000000000000000000000000000", + "exp_lower": "500489406706016258030509154108734058313731403/500000000000000000000000000000000000000000000", + "exp_upper": "1000978813412032516061018308217468116627462807/1000000000000000000000000000000000000000000000", + "log_lower": "721726387479919615396326110173227288966639253/500000000000000000000000000000000000000000000", + "log_upper": "1443452774959839230792652220346454577933278507/1000000000000000000000000000000000000000000000", + "multiplicity": 1356 + }, + { + "child": 18, + "contribution_lower": "134626434809670870700830251005702471332906056561/6878000000000000000000000000000000000000000000000", + "contribution_upper": "269252869619341741401660502011404942665812113391/13756000000000000000000000000000000000000000000000", + "exp_lower": "500470017879817363200112457270269410159502069/500000000000000000000000000000000000000000000", + "exp_upper": "1000940035759634726400224914540538820319004139/1000000000000000000000000000000000000000000000", + "log_lower": "346573590279972654708616060729088284037750067/250000000000000000000000000000000000000000000", + "log_upper": "1386294361119890618834464242916353136151000269/1000000000000000000000000000000000000000000000", + "multiplicity": 1614 + }, + { + "child": 19, + "contribution_lower": "1501355034944577822199402612430539294972430961/181000000000000000000000000000000000000000000000", + "contribution_upper": "120108402795566225775952208994443143597794477/14480000000000000000000000000000000000000000000", + "exp_lower": "500451678314859274066467537476846431657476987/500000000000000000000000000000000000000000000", + "exp_upper": "40036134265188741925317402998147714532598159/40000000000000000000000000000000000000000000", + "log_lower": "1332227139849614851033159406331727576284102257/1000000000000000000000000000000000000000000000", + "log_upper": "666113569924807425516579703165863788142051129/500000000000000000000000000000000000000000000", + "multiplicity": 648 + }, + { + "child": 20, + "contribution_lower": "1376194270784411367058144487545168888349508179/19344375000000000000000000000000000000000000000", + "contribution_upper": "3669851388758430312155051966787117035598688481/51585000000000000000000000000000000000000000000", + "exp_lower": "125108570071310124278013135231378989849955289/125000000000000000000000000000000000000000000", + "exp_upper": "1000868560570480994224105081851031918799642313/1000000000000000000000000000000000000000000000", + "log_lower": "256186769092412863521392652415408067568975979/200000000000000000000000000000000000000000000", + "log_upper": "160116730682758039700870407759630042230609987/125000000000000000000000000000000000000000000", + "multiplicity": 5280 + }, + { + "child": 21, + "contribution_lower": "8767819079685492434805108853633788360681785571329/41268000000000000000000000000000000000000000000000", + "contribution_upper": "17535638159370984869610217707267576721363571160179/82536000000000000000000000000000000000000000000000", + "exp_lower": "500417731846669278854238277132229231247176849/500000000000000000000000000000000000000000000", + "exp_upper": "1000835463693338557708476554264458462494353699/1000000000000000000000000000000000000000000000", + "log_lower": "1232143681292632314541588857853875679236906231/1000000000000000000000000000000000000000000000", + "log_upper": "154017960161579039317698607231734459904613279/125000000000000000000000000000000000000000000", + "multiplicity": 15018 + }, + { + "child": 22, + "contribution_lower": "61209167000676788286637868915423995035962800537/619020000000000000000000000000000000000000000000", + "contribution_upper": "255038195836153284527657787147599979316511669159/2579250000000000000000000000000000000000000000000", + "exp_lower": "40032156311757219284916853443704378702395553/40000000000000000000000000000000000000000000", + "exp_upper": "500401953896965241061460668046304733779944413/500000000000000000000000000000000000000000000", + "log_lower": "118562366565773945756301113879627524562427453/100000000000000000000000000000000000000000000", + "log_upper": "1185623665657739457563011138796275245624274531/1000000000000000000000000000000000000000000000", + "multiplicity": 6672 + }, + { + "child": 60, + "contribution_lower": "733423958987024449128825365436025534734788111/8253600000000000000000000000000000000000000000", + "contribution_upper": "2750339846201341684233095120385095755255455419/30951000000000000000000000000000000000000000000", + "exp_lower": "200024716087370304307861463300734236745851303/200000000000000000000000000000000000000000000", + "exp_upper": "250030895109212880384826829125917795932314129/250000000000000000000000000000000000000000000", + "log_lower": "182321556793954626211718025154514633197389337/1000000000000000000000000000000000000000000000", + "log_upper": "91160778396977313105859012577257316598694669/500000000000000000000000000000000000000000000", + "multiplicity": 2200 + } + ], + "upper": "247607999999182720263673570524402262142038012691201/247608000000000000000000000000000000000000000000000" + }, + "saving": "677773948354561/1000000000000000000", + "strict_gap_lower": "1096960749330367936545998316872597948340150283/604511718750000000000000000000000000000000000000000000000000000", + "upper": "604511718749999998903039250669632063454001683127402051659849717/604511718750000000000000000000000000000000000000000000000000000" + }, + "atom_beta": "677340914792209011107/1000000000000000000000000", + "atom_grid": 1000000000000000000000000, + "atom_lower_gap": "842533550323109027/1000000000000000000000000000000000000000000", + "atom_threshold": "677773948354561/1000639314048354561", + "atom_upper_gap": "998645318170415581977786842533550323109027/1000000000000000000000000000000000000000000", + "coarse_grid": 1000000000000000000, + "coarse_saving": "677773948354561/1000000000000000000", + "controls": { + "next_coarse_grid_rejected": true, + "previous_atom_grid_rejected": true + }, + "old_atom_saving": "384599/10000000000", + "ordinary_saving": "677340914792209011106157466449676890973/1000000000000000000000000000000000000000000", + "rejected": { + "bad_fraction": "1/10000000000000000", + "edge_count": 294746, + "fallback_children_per_edge": 165888, + "fallback_lower": "44340239095665503112752912611541335189267919771031/13433593750000000000000000000000000000000000000000000000000000", + "fallback_upper": "221701195478327515563764563057706675946339635108913/67167968750000000000000000000000000000000000000000000000000000", + "lower": "362707031250000000039805296271292744207821944826366581490067837/362707031250000000000000000000000000000000000000000000000000000", + "raw": { + "lower": "742823999997548162220487327103484755081851553333773/742824000000000000000000000000000000000000000000000", + "saving": "338886974177281/500000000000000000", + "strict_gap_lower": "408639629918778816085874153024739085093/123804000000000000000000000000000000000000000000000", + "terms": [ + { + "child": 1, + "contribution_lower": "350380814487856691769081233093024528176589762123/4126800000000000000000000000000000000000000000000", + "contribution_upper": "5255712217317850376536218496395367922648847291287/61902000000000000000000000000000000000000000000000", + "exp_lower": "100290281792154381767698091716350881073348849/100000000000000000000000000000000000000000000", + "exp_upper": "501451408960771908838490458581754405366744327/500000000000000000000000000000000000000000000", + "log_lower": "2138333059508027655521093419109790556760740759/500000000000000000000000000000000000000000000", + "log_upper": "4276666119016055311042186838219581113521481519/1000000000000000000000000000000000000000000000", + "multiplicity": 125772 + }, + { + "child": 2, + "contribution_lower": "14699158226290795263378361235038462747621926678163/185706000000000000000000000000000000000000000000000", + "contribution_upper": "653295921168479789483482721557265011005418974553/8253600000000000000000000000000000000000000000000", + "exp_lower": "501215883871203848446085901559602507846759869/500000000000000000000000000000000000000000000", + "exp_upper": "200486353548481539378434360623841003138703951/200000000000000000000000000000000000000000000", + "log_lower": "447939867307013750203119339595175568180747673/125000000000000000000000000000000000000000000", + "log_upper": "716703787691222000324990943352280909089196277/200000000000000000000000000000000000000000000", + "multiplicity": 58654 + }, + { + "child": 3, + "contribution_lower": "3398760426493487742326620741379094277746822923/54300000000000000000000000000000000000000000000", + "contribution_upper": "344407723218006757889097568459748220145011391249/5502400000000000000000000000000000000000000000000", + "exp_lower": "62634770226359133951703001053542959531706727/62500000000000000000000000000000000000000000", + "exp_upper": "1002156323621746143227248016856687352507307637/1000000000000000000000000000000000000000000000", + "log_lower": "39725672879349320245586770016213192610924887/12500000000000000000000000000000000000000000", + "log_upper": "3178053830347945619646941601297055408873990961/1000000000000000000000000000000000000000000000", + "multiplicity": 30930 + }, + { + "child": 4, + "contribution_lower": "40028339505431770178108807196032306932572735869/1547550000000000000000000000000000000000000000000", + "contribution_upper": "133427798351439233927029357320107689775242453163/5158500000000000000000000000000000000000000000000", + "exp_lower": "50098046940465294340561711133957830954408931/50000000000000000000000000000000000000000000", + "exp_upper": "500980469404652943405617111339578309544089311/500000000000000000000000000000000000000000000", + "log_lower": "462459481263386350753235615248516476379277/160000000000000000000000000000000000000000", + "log_upper": "2890371757896164692207722595303227977370481251/1000000000000000000000000000000000000000000000", + "multiplicity": 9588 + }, + { + "child": 5, + "contribution_lower": "89828910681793987447163451971081995480110079153/3301440000000000000000000000000000000000000000000", + "contribution_upper": "269486732045381962341490355913245986440330237997/9904320000000000000000000000000000000000000000000", + "exp_lower": "1001809412808111384169109129789018536952900511/1000000000000000000000000000000000000000000000", + "exp_upper": "1001809412808111384169109129789018536952900513/1000000000000000000000000000000000000000000000", + "log_lower": "666807051645488734110356876248348368498970041/250000000000000000000000000000000000000000000", + "log_upper": "533445641316390987288285500998678694799176033/200000000000000000000000000000000000000000000", + "multiplicity": 8070 + }, + { + "child": 6, + "contribution_lower": "173291612962570650156011159090966457720248713363/10317000000000000000000000000000000000000000000000", + "contribution_upper": "902560484180055469562558120265450300626295383/53734375000000000000000000000000000000000000000", + "exp_lower": "1001685624061102024023185890699228079307796031/1000000000000000000000000000000000000000000000", + "exp_upper": "15651337875954719125362279542175438739184313/15625000000000000000000000000000000000000000", + "log_lower": "1242453324894000155114854739919439420399245413/500000000000000000000000000000000000000000000", + "log_upper": "2484906649788000310229709479838878840798490827/1000000000000000000000000000000000000000000000", + "multiplicity": 4152 + }, + { + "child": 7, + "contribution_lower": "59594067958969049907742674750915694087307787623/3095100000000000000000000000000000000000000000000", + "contribution_upper": "7945875727862539987699023300122092544974371691/412680000000000000000000000000000000000000000000", + "exp_lower": "500790487050160083258341804629543647792502417/500000000000000000000000000000000000000000000", + "exp_upper": "200316194820064033303336721851817459117000967/200000000000000000000000000000000000000000000", + "log_lower": "2330755969960742005936834094776401383884396789/1000000000000000000000000000000000000000000000", + "log_upper": "233075596996074200593683409477640138388439679/100000000000000000000000000000000000000000000", + "multiplicity": 4080 + }, + { + "child": 8, + "contribution_lower": "209812224348338470215653195542378976261841360047/15475500000000000000000000000000000000000000000000", + "contribution_upper": "46624938744075215603478487898306439169298080057/3439000000000000000000000000000000000000000000000", + "exp_lower": "500745165509161026767668724444818559097473413/500000000000000000000000000000000000000000000", + "exp_upper": "1001490331018322053535337448889637118194946827/1000000000000000000000000000000000000000000000", + "log_lower": "439444915467243876558098094769010281858996223/200000000000000000000000000000000000000000000", + "log_upper": "549306144334054845697622618461262852323745279/250000000000000000000000000000000000000000000", + "multiplicity": 2514 + }, + { + "child": 9, + "contribution_lower": "73102958102281770684891484821286970594216793543/6878000000000000000000000000000000000000000000000", + "contribution_upper": "4568934881392610667805717801330435662138549601/429875000000000000000000000000000000000000000000", + "exp_lower": "1001410384962763981984814860565574939646805391/1000000000000000000000000000000000000000000000", + "exp_upper": "62588149060172748874050928785348433727925337/62500000000000000000000000000000000000000000", + "log_lower": "2079441541679835928251696364374529704226500403/1000000000000000000000000000000000000000000000", + "log_upper": "519860385419958982062924091093632426056625101/250000000000000000000000000000000000000000000", + "multiplicity": 1752 + }, + { + "child": 10, + "contribution_lower": "168725600637490073767789747843176894742431632513/12380400000000000000000000000000000000000000000000", + "contribution_upper": "337451201274980147535579495686353789484863265363/24760800000000000000000000000000000000000000000000", + "exp_lower": "500669438093442355394034860068774168375168049/500000000000000000000000000000000000000000000", + "exp_upper": "1001338876186884710788069720137548336750336099/1000000000000000000000000000000000000000000000", + "log_lower": "197408102602200962702419538353521690592038003/100000000000000000000000000000000000000000000", + "log_upper": "1974081026022009627024195383535216905920380031/1000000000000000000000000000000000000000000000", + "multiplicity": 2022 + }, + { + "child": 11, + "contribution_lower": "370805209485262361754478721214145988918857274587/41268000000000000000000000000000000000000000000000", + "contribution_upper": "139051953556973385657929520455304745844571478109/15475500000000000000000000000000000000000000000000", + "exp_lower": "1001274193029511327869879535231717341815096151/1000000000000000000000000000000000000000000000", + "exp_upper": "125159274128688915983734941903964667726887019/125000000000000000000000000000000000000000000", + "log_lower": "234846355777210595872530407531806476712471833/125000000000000000000000000000000000000000000", + "log_upper": "375754169243536953396048652050890362739954933/200000000000000000000000000000000000000000000", + "multiplicity": 1212 + }, + { + "child": 12, + "contribution_lower": "677822653558886284371893315501806719057087836701/20634000000000000000000000000000000000000000000000", + "contribution_upper": "112970442259814380728648885916967786509514639563/3439000000000000000000000000000000000000000000000", + "exp_lower": "1001215145581811350623180672823939023718002713/1000000000000000000000000000000000000000000000", + "exp_upper": "500607572790905675311590336411969511859001357/500000000000000000000000000000000000000000000", + "log_lower": "447939867307013750203119339595175568180747673/250000000000000000000000000000000000000000000", + "log_upper": "1791759469228055000812477358380702272722990693/1000000000000000000000000000000000000000000000", + "multiplicity": 4062 + }, + { + "child": 13, + "contribution_lower": "3527089605042755650885035385753316005622697399413/247608000000000000000000000000000000000000000000000", + "contribution_upper": "146962066876781485453543141073054833567612391789/10317000000000000000000000000000000000000000000000", + "exp_lower": "1001160830270438731446220660162735170486147431/1000000000000000000000000000000000000000000000", + "exp_upper": "125145103783804841430777582520341896310768429/125000000000000000000000000000000000000000000", + "log_lower": "1711716761554518574988699396654262508716213573/1000000000000000000000000000000000000000000000", + "log_upper": "855858380777259287494349698327131254358106787/500000000000000000000000000000000000000000000", + "multiplicity": 1626 + }, + { + "child": 14, + "contribution_lower": "11913215482807397988395364845293391009448059303/343900000000000000000000000000000000000000000000", + "contribution_upper": "119132154828073979883953648452933910094480593149/3439000000000000000000000000000000000000000000000", + "exp_lower": "100111054477373092339456847439440260583597137/100000000000000000000000000000000000000000000", + "exp_upper": "1001110544773730923394568474394402605835971371/1000000000000000000000000000000000000000000000", + "log_lower": "818804394700398348259800986659112407904448327/500000000000000000000000000000000000000000000", + "log_upper": "327521757880159339303920394663644963161779331/200000000000000000000000000000000000000000000", + "multiplicity": 3672 + }, + { + "child": 15, + "contribution_lower": "750797799274887060915902298803110995205267329/85975000000000000000000000000000000000000000000", + "contribution_upper": "3003191197099548243663609195212443980821069319/343900000000000000000000000000000000000000000000", + "exp_lower": "250265933091629020305300766267703665068422443/250000000000000000000000000000000000000000000", + "exp_upper": "1001063732366516081221203065070814660273689773/1000000000000000000000000000000000000000000000", + "log_lower": "784307958956922622523091134035433884674194803/500000000000000000000000000000000000000000000", + "log_upper": "1568615917913845245046182268070867769348389607/1000000000000000000000000000000000000000000000", + "multiplicity": 864 + }, + { + "child": 16, + "contribution_lower": "20771163843510964929314070781488664010322226501/644812500000000000000000000000000000000000000000", + "contribution_upper": "27694885124681286572418761041984885347096302029/859750000000000000000000000000000000000000000000", + "exp_lower": "250254986066397167823061093752875470003882247/250000000000000000000000000000000000000000000", + "exp_upper": "1001019944265588671292244375011501880015528989/1000000000000000000000000000000000000000000000", + "log_lower": "1504077396776274073373258352386874841219480981/1000000000000000000000000000000000000000000000", + "log_upper": "752038698388137036686629176193437420609740491/500000000000000000000000000000000000000000000", + "multiplicity": 2988 + }, + { + "child": 17, + "contribution_lower": "1922880300564514466128803075851214370735079050661/123804000000000000000000000000000000000000000000000", + "contribution_upper": "320480050094085744354800512641869061789179842097/20634000000000000000000000000000000000000000000000", + "exp_lower": "1000978813412032517505883954113073592261883941/1000000000000000000000000000000000000000000000", + "exp_upper": "500489406706016258752941977056536796130941971/500000000000000000000000000000000000000000000", + "log_lower": "721726387479919615396326110173227288966639253/500000000000000000000000000000000000000000000", + "log_upper": "1443452774959839230792652220346454577933278507/1000000000000000000000000000000000000000000000", + "multiplicity": 1356 + }, + { + "child": 18, + "contribution_lower": "33656608702417717721865529610005938590399900833/1719500000000000000000000000000000000000000000000", + "contribution_upper": "269252869619341741774924236880047508723199206933/13756000000000000000000000000000000000000000000000", + "exp_lower": "125117504469954340973477805241657764276579557/125000000000000000000000000000000000000000000", + "exp_upper": "1000940035759634727787822441933262114212636457/1000000000000000000000000000000000000000000000", + "log_lower": "346573590279972654708616060729088284037750067/250000000000000000000000000000000000000000000", + "log_upper": "1386294361119890618834464242916353136151000269/1000000000000000000000000000000000000000000000", + "multiplicity": 1614 + }, + { + "child": 19, + "contribution_lower": "750677517472288912099774268266786383149318727/90500000000000000000000000000000000000000000000", + "contribution_upper": "3002710069889155648399097073067145532597274911/362000000000000000000000000000000000000000000000", + "exp_lower": "250225839157429637366591422755595461049772909/250000000000000000000000000000000000000000000", + "exp_upper": "1000903356629718549466365691022381844199091637/1000000000000000000000000000000000000000000000", + "log_lower": "1332227139849614851033159406331727576284102257/1000000000000000000000000000000000000000000000", + "log_upper": "666113569924807425516579703165863788142051129/500000000000000000000000000000000000000000000", + "multiplicity": 648 + }, + { + "child": 20, + "contribution_lower": "440382166651011638022706658215650039862604459/6190200000000000000000000000000000000000000000", + "contribution_upper": "5504777083137645475283833227695625498282555743/77377500000000000000000000000000000000000000000", + "exp_lower": "40034742422819239820246059837786367260236769/40000000000000000000000000000000000000000000", + "exp_upper": "500434280285240497753075747972329590752959613/500000000000000000000000000000000000000000000", + "log_lower": "256186769092412863521392652415408067568975979/200000000000000000000000000000000000000000000", + "log_upper": "160116730682758039700870407759630042230609987/125000000000000000000000000000000000000000000", + "multiplicity": 5280 + }, + { + "child": 21, + "contribution_lower": "140285105274967879129733147702164008464416469009/660288000000000000000000000000000000000000000000", + "contribution_upper": "8767819079685492445608321731385250529026029321823/41268000000000000000000000000000000000000000000000", + "exp_lower": "8006683709546708471533197174942298297152929/8000000000000000000000000000000000000000000", + "exp_upper": "500417731846669279470824823433893643572058063/500000000000000000000000000000000000000000000", + "log_lower": "1232143681292632314541588857853875679236906231/1000000000000000000000000000000000000000000000", + "log_upper": "154017960161579039317698607231734459904613279/125000000000000000000000000000000000000000000", + "multiplicity": 15018 + }, + { + "child": 22, + "contribution_lower": "510076391672306569660074215555192921572711189931/5158500000000000000000000000000000000000000000000", + "contribution_upper": "765114587508459854490111323332789382359066785661/7737750000000000000000000000000000000000000000000", + "exp_lower": "1000803907793930483309498133855839610672422217/1000000000000000000000000000000000000000000000", + "exp_upper": "500401953896965241654749066927919805336211109/500000000000000000000000000000000000000000000", + "log_lower": "118562366565773945756301113879627524562427453/100000000000000000000000000000000000000000000", + "log_upper": "1185623665657739457563011138796275245624274531/1000000000000000000000000000000000000000000000", + "multiplicity": 6672 + }, + { + "child": 60, + "contribution_lower": "440054375392214669557526618057115216800669839/4952160000000000000000000000000000000000000000", + "contribution_upper": "1833559897467561123156360908571313403336124331/20634000000000000000000000000000000000000000000", + "exp_lower": "40004943217474060868866056187010474254606349/40000000000000000000000000000000000000000000", + "exp_upper": "500061790218425760860825702337630928182579363/500000000000000000000000000000000000000000000", + "log_lower": "182321556793954626211718025154514633197389337/1000000000000000000000000000000000000000000000", + "log_upper": "91160778396977313105859012577257316598694669/500000000000000000000000000000000000000000000", + "multiplicity": 2200 + } + ], + "upper": "123803999999591360370081221183914125846975260914907/123804000000000000000000000000000000000000000000000" + }, + "saving": "338886974177281/500000000000000000", + "strict_gap_lower": "-3491692655376556509458065856294020665972643/31816406250000000000000000000000000000000000000000000000000000", + "upper": "31816406250000000003491692655376556509458065856294020665972643/31816406250000000000000000000000000000000000000000000000000000" + }, + "scope": "Adjacent coarse exclusion for this fixed worst-case bad-class envelope and least atom on the stated grid; no true bad-fraction or global optimality claim." + }, + "foreign_producer_replays": 0, + "formal": [ + { + "all_dirty_and_source_columns_restored": true, + "defining_decoder": true, + "formal_variables": 20668, + "identity": true, + "ring": "2", + "target_contract": "F2 identity" + }, + { + "all_dirty_and_source_columns_restored": true, + "defining_decoder": true, + "formal_variables": 20668, + "identity": false, + "ring": "0", + "target_contract": "integer defining decoder" + } + ], + "overridden_profile": { + "R": 17148, + "W_per_vertex": 20668, + "changed_operation_frames": 7282, + "child_histogram": { + "1": 125772, + "10": 2022, + "11": 1212, + "12": 4062, + "13": 1626, + "14": 3672, + "15": 864, + "16": 2988, + "17": 1356, + "18": 1614, + "19": 648, + "2": 58654, + "20": 5280, + "21": 15120, + "22": 6672, + "3": 31032, + "4": 9588, + "5": 8070, + "6": 4152, + "60": 2200, + "7": 4080, + "8": 2514, + "9": 1752 + }, + "deficit_per_vertex": 1936, + "foreign_producer_replays": 0, + "frames_not_contained_in_original": 84, + "h": 24, + "loss": 528, + "m": 72, + "maxchild": 60, + "physical_internal_histogram": { + "1": 35764, + "10": 674, + "11": 404, + "12": 1354, + "13": 542, + "14": 1224, + "15": 288, + "16": 996, + "17": 452, + "18": 538, + "19": 216, + "2": 17498, + "21": 4160, + "22": 1344, + "3": 10344, + "4": 3196, + "5": 2690, + "6": 1384, + "7": 1360, + "8": 838, + "9": 584 + }, + "physical_target_histogram": { + "1": 4400, + "20": 880, + "21": 880 + }, + "rank_per_vertex": 1486160, + "reused_registers": 1760, + "selected_rank_histogram": { + "20": 2200 + }, + "selected_roles": 2200, + "v": 1760, + "virtual_R": 18908 + }, + "parent_profile": { + "package_checker": { + "W": 22428, + "roles": 18908 + }, + "package_profile": { + "R": 18908, + "W_per_vertex": 22428, + "deficit_per_vertex": 1936, + "loss": 528, + "m": 72, + "rank_per_vertex": 1612880 + } + }, + "prime_witnesses": { + "adverse_controls": [ + "zero determinant", + "incorrect factor identity", + "residual above retained prime lower bound" + ], + "all_remaining_factors_below_retained_prime_lower_bound": true, + "h": 24, + "input_sha256": { + "research/paired-cube-diagonal-bit-168/selected/bit/frames_p12.json.gz": "ad8e2705652b68476713d7647a8592505e222f2b3ccd1728dedce153aac6d462", + "research/paired-cube-diagonal-bit-168/selected/bit/graph_p12.json": "31a09a55920e64c8bfbac8b845dc01754c112aa6e207812e2fd1f4939d8f64cb", + "research/paired-cube-diagonal-bit-168/selected/bit/kchron_p12.json": "0fab548e84cf5ca7c04e8bd19b5810850463f36e0f92180efe73aeff17105e39", + "research/paired-cube-diagonal-bit-168/selected/bit/profile_p12.json": "c44ef8640cbcbcc9bac3a30e13373bd79efddde55d7cea514354ca2cdb60d66d", + "research/paired-cube-diagonal-bit-168/selected/bit/word_p12.json.gz": "1cb7e8ed45cf542e304fddc4b12247dbb248a0dc84dedbd832f336b2d172793a" + }, + "maximum_determinant_bits": 118, + "rule": "Every q>2^80 avoids every nonzero used-frame determinant, so the original prime range is unchanged.", + "scope": "Exact integer cleared-Gram factors for all physical frames including every changed operation, gauge, source, root, partner-mix, delivery and ambient frame. Uniform split-rank and fallback arguments remain the retained local-ring interface.", + "script_sha256": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab", + "source_commit": "4a3c769e5c5430e7114c4d3e099ff34664677f17", + "status": "PASS exact prime witnesses for every used physical frame", + "stripped_primes": [ + 2, + 3, + 5, + 7, + 11, + 13, + 17, + 19, + 23, + 29, + 31 + ], + "total_operation_frames": 7282, + "total_used_frames": 24401, + "unique_used_bases": 24401, + "witness_file": "bit/prime-witnesses.json.gz", + "witness_sha256": "612f0b91c7689b0cebcacb28278579aa2c88801df640798d7a119f11eca836c3" + }, + "profile": { + "R": 17114, + "W_per_vertex": 20634, + "active_virtual_R": 18874, + "changed_operation_frames": 7282, + "child_histogram": { + "1": 125772, + "10": 2022, + "11": 1212, + "12": 4062, + "13": 1626, + "14": 3672, + "15": 864, + "16": 2988, + "17": 1356, + "18": 1614, + "19": 648, + "2": 58654, + "20": 5280, + "21": 15018, + "22": 6672, + "3": 30930, + "4": 9588, + "5": 8070, + "6": 4152, + "60": 2200, + "7": 4080, + "8": 2514, + "9": 1752 + }, + "deficit_per_vertex": 1936, + "foreign_producer_replays": 0, + "frames_not_contained_in_original": 84, + "h": 24, + "loss": 528, + "m": 72, + "maxchild": 60, + "physical_internal_histogram": { + "1": 35764, + "10": 674, + "11": 404, + "12": 1354, + "13": 542, + "14": 1207, + "15": 288, + "16": 993, + "17": 452, + "18": 533, + "19": 208, + "2": 17469, + "21": 4160, + "22": 1344, + "3": 10301, + "4": 3196, + "5": 2673, + "6": 1384, + "7": 1359, + "8": 838, + "9": 583 + }, + "physical_target_histogram": { + "1": 4400, + "14": 17, + "16": 3, + "18": 5, + "19": 8, + "2": 29, + "20": 880, + "21": 846, + "3": 9, + "5": 17, + "7": 1, + "9": 1 + }, + "rank_per_vertex": 1483712, + "reused_registers": 1760, + "scalar_role_reserve": 18908, + "selected_rank_histogram": { + "20": 2200 + }, + "selected_roles": 2200, + "terminal_sinks": 34, + "v": 1760, + "virtual_R": 18908 + }, + "scope": "Complete F2 identity, integer defining decoder, exact physical frame geometry and retained weighted-compiler contracts.", + "status": "PASS", + "terminal": { + "all_original_adjoint_responses_retained": true, + "base_exceeds_twice_bound": true, + "baseline_profile": { + "R": 17148, + "W_per_vertex": 20668, + "changed_operation_frames": 7282, + "child_histogram": { + "1": 125772, + "10": 2022, + "11": 1212, + "12": 4062, + "13": 1626, + "14": 3672, + "15": 864, + "16": 2988, + "17": 1356, + "18": 1614, + "19": 648, + "2": 58654, + "20": 5280, + "21": 15120, + "22": 6672, + "3": 31032, + "4": 9588, + "5": 8070, + "6": 4152, + "60": 2200, + "7": 4080, + "8": 2514, + "9": 1752 + }, + "deficit_per_vertex": 1936, + "foreign_producer_replays": 0, + "frames_not_contained_in_original": 84, + "h": 24, + "loss": 528, + "m": 72, + "maxchild": 60, + "physical_internal_histogram": { + "1": 35764, + "10": 674, + "11": 404, + "12": 1354, + "13": 542, + "14": 1224, + "15": 288, + "16": 996, + "17": 452, + "18": 538, + "19": 216, + "2": 17498, + "21": 4160, + "22": 1344, + "3": 10344, + "4": 3196, + "5": 2690, + "6": 1384, + "7": 1360, + "8": 838, + "9": 584 + }, + "physical_target_histogram": { + "1": 4400, + "20": 880, + "21": 880 + }, + "rank_per_vertex": 1486160, + "reused_registers": 1760, + "selected_rank_histogram": { + "20": 2200 + }, + "selected_roles": 2200, + "v": 1760, + "virtual_R": 18908 + }, + "child_delta": { + "21": -102, + "3": -102 + }, + "controls": { + "omit-ancestor-response": "REJECTED", + "omit-pre-target": "REJECTED", + "omit-write": "REJECTED" + }, + "foreign_producer_replays": 0, + "formal": [ + { + "all_outputs": true, + "all_sources_and_dirty_restored": true, + "direction": 1, + "dirty_columns": 17114, + "formal_columns": 20634, + "mode": "F2", + "partner_mix_unmix_at_original_anchors": true, + "retained_cleanup_literal_reverse": true, + "source_columns": 1760, + "target_columns": 1760 + }, + { + "all_outputs": true, + "all_sources_and_dirty_restored": true, + "direction": 1, + "dirty_columns": 17114, + "formal_columns": 20634, + "mode": "Z", + "partner_mix_unmix_at_original_anchors": true, + "retained_cleanup_literal_reverse": true, + "source_columns": 1760, + "target_columns": 1760 + }, + { + "all_outputs": true, + "all_sources_and_dirty_restored": true, + "direction": -1, + "dirty_columns": 17114, + "formal_columns": 20634, + "mode": "Z", + "partner_mix_unmix_at_original_anchors": true, + "retained_cleanup_literal_reverse": true, + "source_columns": 1760, + "target_columns": 1760 + } + ], + "integer_residual_bound": 39780, + "literal_sandwich_inverse": true, + "new_frames_added": 0, + "original_partner_delivery_anchors_retained": true, + "packed_digit_bits": 24, + "profile": { + "R": 17114, + "W_per_vertex": 20634, + "active_virtual_R": 18874, + "changed_operation_frames": 7282, + "child_histogram": { + "1": 125772, + "10": 2022, + "11": 1212, + "12": 4062, + "13": 1626, + "14": 3672, + "15": 864, + "16": 2988, + "17": 1356, + "18": 1614, + "19": 648, + "2": 58654, + "20": 5280, + "21": 15018, + "22": 6672, + "3": 30930, + "4": 9588, + "5": 8070, + "6": 4152, + "60": 2200, + "7": 4080, + "8": 2514, + "9": 1752 + }, + "deficit_per_vertex": 1936, + "foreign_producer_replays": 0, + "frames_not_contained_in_original": 84, + "h": 24, + "loss": 528, + "m": 72, + "maxchild": 60, + "physical_internal_histogram": { + "1": 35764, + "10": 674, + "11": 404, + "12": 1354, + "13": 542, + "14": 1207, + "15": 288, + "16": 993, + "17": 452, + "18": 533, + "19": 208, + "2": 17469, + "21": 4160, + "22": 1344, + "3": 10301, + "4": 3196, + "5": 2673, + "6": 1384, + "7": 1359, + "8": 838, + "9": 583 + }, + "physical_target_histogram": { + "1": 4400, + "14": 17, + "16": 3, + "18": 5, + "19": 8, + "2": 29, + "20": 880, + "21": 846, + "3": 9, + "5": 17, + "7": 1, + "9": 1 + }, + "rank_per_vertex": 1483712, + "reused_registers": 1760, + "scalar_role_reserve": 18908, + "selected_rank_histogram": { + "20": 2200 + }, + "selected_roles": 2200, + "terminal_sinks": 34, + "v": 1760, + "virtual_R": 18908 + }, + "scalar_addition_delta": -158, + "scalar_bill": "Retain the original conservative full-word scalar inventory: removed old root reads/old root corrections and deleted inverse gates dominate the new pre/post target shears.", + "selected": [ + { + "deleted_path": [ + 3, + 9, + 2, + 7, + 3 + ], + "pivot": 8, + "role": 8660, + "root": 30, + "root_frame": 25212, + "root_rank": 21, + "targets": [ + 8, + 9, + 10, + 11 + ], + "writes": [ + 9837, + 22811, + 24471, + 31019 + ] + }, + { + "deleted_path": [ + 5, + 14, + 2, + 3 + ], + "pivot": 136, + "role": 12631, + "root": 510, + "root_frame": 25564, + "root_rank": 21, + "targets": [ + 136, + 137, + 138, + 139 + ], + "writes": [ + 17498, + 28429, + 31006 + ] + }, + { + "deleted_path": [ + 16, + 3, + 2, + 3 + ], + "pivot": 160, + "role": 14425, + "root": 600, + "root_frame": 25630, + "root_rank": 21, + "targets": [ + 160, + 161, + 162, + 163 + ], + "writes": [ + 26491, + 28438, + 31056 + ] + }, + { + "deleted_path": [ + 3, + 18, + 3 + ], + "pivot": 288, + "role": 8939, + "root": 1080, + "root_frame": 25982, + "root_rank": 21, + "targets": [ + 288, + 289, + 290, + 291 + ], + "writes": [ + 10386, + 31059 + ] + }, + { + "deleted_path": [ + 5, + 14, + 2, + 3 + ], + "pivot": 344, + "role": 12634, + "root": 1290, + "root_frame": 26136, + "root_rank": 21, + "targets": [ + 344, + 345, + 346, + 347 + ], + "writes": [ + 17505, + 28468, + 31040 + ] + }, + { + "deleted_path": [ + 19, + 2, + 3 + ], + "pivot": 400, + "role": 14698, + "root": 1500, + "root_frame": 26290, + "root_rank": 21, + "targets": [ + 400, + 401, + 402, + 403 + ], + "writes": [ + 28437, + 31026 + ] + }, + { + "deleted_path": [ + 14, + 5, + 2, + 3 + ], + "pivot": 416, + "role": 14076, + "root": 1560, + "root_frame": 26334, + "root_rank": 21, + "targets": [ + 416, + 417, + 418, + 419 + ], + "writes": [ + 24448, + 28444, + 30985 + ] + }, + { + "deleted_path": [ + 5, + 14, + 2, + 3 + ], + "pivot": 496, + "role": 12705, + "root": 1860, + "root_frame": 26554, + "root_rank": 21, + "targets": [ + 496, + 497, + 498, + 499 + ], + "writes": [ + 17700, + 28593, + 31231 + ] + }, + { + "deleted_path": [ + 16, + 3, + 2, + 3 + ], + "pivot": 520, + "role": 14437, + "root": 1950, + "root_frame": 26620, + "root_rank": 21, + "targets": [ + 520, + 521, + 522, + 523 + ], + "writes": [ + 26609, + 28602, + 31287 + ] + }, + { + "deleted_path": [ + 3, + 18, + 3 + ], + "pivot": 648, + "role": 9811, + "root": 2430, + "root_frame": 26972, + "root_rank": 21, + "targets": [ + 648, + 649, + 650, + 651 + ], + "writes": [ + 12068, + 31290 + ] + }, + { + "deleted_path": [ + 5, + 14, + 2, + 3 + ], + "pivot": 704, + "role": 12708, + "root": 2640, + "root_frame": 27126, + "root_rank": 21, + "targets": [ + 704, + 705, + 706, + 707 + ], + "writes": [ + 17707, + 28632, + 31269 + ] + }, + { + "deleted_path": [ + 19, + 2, + 3 + ], + "pivot": 760, + "role": 14708, + "root": 2850, + "root_frame": 27280, + "root_rank": 21, + "targets": [ + 760, + 761, + 762, + 763 + ], + "writes": [ + 28601, + 31254 + ] + }, + { + "deleted_path": [ + 14, + 5, + 2, + 3 + ], + "pivot": 776, + "role": 14094, + "root": 2910, + "root_frame": 27324, + "root_rank": 21, + "targets": [ + 776, + 777, + 778, + 779 + ], + "writes": [ + 24562, + 28608, + 31209 + ] + }, + { + "deleted_path": [ + 16, + 3, + 2, + 3 + ], + "pivot": 808, + "role": 14449, + "root": 3030, + "root_frame": 27412, + "root_rank": 21, + "targets": [ + 808, + 809, + 810, + 811 + ], + "writes": [ + 26727, + 28766, + 31539 + ] + }, + { + "deleted_path": [ + 3, + 18, + 3 + ], + "pivot": 936, + "role": 10525, + "root": 3510, + "root_frame": 27764, + "root_rank": 21, + "targets": [ + 936, + 937, + 938, + 939 + ], + "writes": [ + 13430, + 31542 + ] + }, + { + "deleted_path": [ + 5, + 14, + 2, + 3 + ], + "pivot": 992, + "role": 12782, + "root": 3720, + "root_frame": 27918, + "root_rank": 21, + "targets": [ + 992, + 993, + 994, + 995 + ], + "writes": [ + 17909, + 28796, + 31520 + ] + }, + { + "deleted_path": [ + 19, + 2, + 3 + ], + "pivot": 1048, + "role": 14718, + "root": 3930, + "root_frame": 28072, + "root_rank": 21, + "targets": [ + 1048, + 1049, + 1050, + 1051 + ], + "writes": [ + 28765, + 31502 + ] + }, + { + "deleted_path": [ + 14, + 5, + 2, + 3 + ], + "pivot": 1064, + "role": 14112, + "root": 3990, + "root_frame": 28116, + "root_rank": 21, + "targets": [ + 1064, + 1065, + 1066, + 1067 + ], + "writes": [ + 24676, + 28772, + 31454 + ] + }, + { + "deleted_path": [ + 3, + 18, + 3 + ], + "pivot": 1160, + "role": 11085, + "root": 4350, + "root_frame": 28380, + "root_rank": 21, + "targets": [ + 1160, + 1161, + 1162, + 1163 + ], + "writes": [ + 14494, + 31809 + ] + }, + { + "deleted_path": [ + 5, + 14, + 2, + 3 + ], + "pivot": 1216, + "role": 12856, + "root": 4560, + "root_frame": 28534, + "root_rank": 21, + "targets": [ + 1216, + 1217, + 1218, + 1219 + ], + "writes": [ + 18111, + 28960, + 31785 + ] + }, + { + "deleted_path": [ + 19, + 2, + 3 + ], + "pivot": 1272, + "role": 14728, + "root": 4770, + "root_frame": 28688, + "root_rank": 21, + "targets": [ + 1272, + 1273, + 1274, + 1275 + ], + "writes": [ + 28929, + 31767 + ] + }, + { + "deleted_path": [ + 14, + 5, + 2, + 3 + ], + "pivot": 1288, + "role": 14130, + "root": 4830, + "root_frame": 28732, + "root_rank": 21, + "targets": [ + 1288, + 1289, + 1290, + 1291 + ], + "writes": [ + 24790, + 28936, + 31716 + ] + }, + { + "deleted_path": [ + 3, + 18, + 3 + ], + "pivot": 1328, + "role": 11089, + "root": 4980, + "root_frame": 28842, + "root_rank": 21, + "targets": [ + 1328, + 1329, + 1330, + 1331 + ], + "writes": [ + 14502, + 32093 + ] + }, + { + "deleted_path": [ + 5, + 14, + 2, + 3 + ], + "pivot": 1384, + "role": 12930, + "root": 5190, + "root_frame": 28996, + "root_rank": 21, + "targets": [ + 1384, + 1385, + 1386, + 1387 + ], + "writes": [ + 18313, + 29124, + 32066 + ] + }, + { + "deleted_path": [ + 19, + 2, + 3 + ], + "pivot": 1440, + "role": 14738, + "root": 5400, + "root_frame": 29150, + "root_rank": 21, + "targets": [ + 1440, + 1441, + 1442, + 1443 + ], + "writes": [ + 29093, + 32048 + ] + }, + { + "deleted_path": [ + 14, + 5, + 2, + 3 + ], + "pivot": 1456, + "role": 14148, + "root": 5460, + "root_frame": 29194, + "root_rank": 21, + "targets": [ + 1456, + 1457, + 1458, + 1459 + ], + "writes": [ + 24904, + 29100, + 31994 + ] + }, + { + "deleted_path": [ + 5, + 14, + 2, + 3 + ], + "pivot": 1504, + "role": 13004, + "root": 5640, + "root_frame": 29326, + "root_rank": 21, + "targets": [ + 1504, + 1505, + 1506, + 1507 + ], + "writes": [ + 18515, + 29288, + 32360 + ] + }, + { + "deleted_path": [ + 19, + 2, + 3 + ], + "pivot": 1560, + "role": 14748, + "root": 5850, + "root_frame": 29480, + "root_rank": 21, + "targets": [ + 1560, + 1561, + 1562, + 1563 + ], + "writes": [ + 29257, + 32341 + ] + }, + { + "deleted_path": [ + 14, + 5, + 2, + 3 + ], + "pivot": 1576, + "role": 14166, + "root": 5910, + "root_frame": 29524, + "root_rank": 21, + "targets": [ + 1576, + 1577, + 1578, + 1579 + ], + "writes": [ + 25018, + 29264, + 32286 + ] + }, + { + "deleted_path": [ + 19, + 2, + 3 + ], + "pivot": 1640, + "role": 14758, + "root": 6150, + "root_frame": 29700, + "root_rank": 21, + "targets": [ + 1640, + 1641, + 1642, + 1643 + ], + "writes": [ + 29421, + 32647 + ] + }, + { + "deleted_path": [ + 14, + 5, + 2, + 3 + ], + "pivot": 1656, + "role": 14184, + "root": 6210, + "root_frame": 29744, + "root_rank": 21, + "targets": [ + 1656, + 1657, + 1658, + 1659 + ], + "writes": [ + 25132, + 29428, + 32591 + ] + }, + { + "deleted_path": [ + 19, + 2, + 3 + ], + "pivot": 1688, + "role": 14768, + "root": 6330, + "root_frame": 29832, + "root_rank": 21, + "targets": [ + 1688, + 1689, + 1690, + 1691 + ], + "writes": [ + 29585, + 32962 + ] + }, + { + "deleted_path": [ + 14, + 5, + 2, + 3 + ], + "pivot": 1704, + "role": 14202, + "root": 6390, + "root_frame": 29876, + "root_rank": 21, + "targets": [ + 1704, + 1705, + 1706, + 1707 + ], + "writes": [ + 25246, + 29592, + 32905 + ] + }, + { + "deleted_path": [ + 14, + 5, + 2, + 3 + ], + "pivot": 1728, + "role": 14220, + "root": 6480, + "root_frame": 29942, + "root_rank": 21, + "targets": [ + 1728, + 1729, + 1730, + 1731 + ], + "writes": [ + 25360, + 29756, + 33227 + ] + } + ], + "status": "PASS complete terminal bit word, exact geometry/ledger/F2/integer columns", + "target_events": 16810 + }, + "word_controls": [ + "omit_compensation", + "missing_partner", + "stale", + "zero_operation_frame" + ] + }, + "complex": { + "moment": { + "accepted": { + "lower": "28958599999999972643161690227622507425401034850261/28958600000000000000000000000000000000000000000000", + "saving": "665489485337/1000000000000000", + "strict_gap_lower": "6839209577443094373143649741194477/7239650000000000000000000000000000000000000000000", + "terms": [ + { + "child": 1, + "contribution_lower": "19554445203974510661879082169868440022400954857/180991250000000000000000000000000000000000000000", + "contribution_upper": "19554445203974510661879082169868440022400956807/180991250000000000000000000000000000000000000000", + "exp_lower": "501396030871141299022540568458165128779511663/500000000000000000000000000000000000000000000", + "exp_upper": "501396030871141299022540568458165128779511713/500000000000000000000000000000000000000000000", + "log_lower": "2094827371013212772437210468172915786272348773/500000000000000000000000000000000000000000000", + "log_upper": "4189654742026425544874420936345831572544697547/1000000000000000000000000000000000000000000000", + "multiplicity": 93600 + }, + { + "child": 2, + "contribution_lower": "284360907044751102414242635607473432559626590831/2895860000000000000000000000000000000000000000000", + "contribution_upper": "71090226761187775603560658901868358139906648417/723965000000000000000000000000000000000000000000", + "exp_lower": "100232959832481883120987887066434061529653363/100000000000000000000000000000000000000000000", + "exp_upper": "25058239958120470780246971766608515382413341/25000000000000000000000000000000000000000000", + "log_lower": "3496507561466480235457188814887655004469197411/1000000000000000000000000000000000000000000000", + "log_upper": "874126890366620058864297203721913751117299353/250000000000000000000000000000000000000000000", + "multiplicity": 42555 + }, + { + "child": 3, + "contribution_lower": "3685949412113871892547126185129066073969827080471/36198250000000000000000000000000000000000000000000", + "contribution_upper": "29487595296910975140377009481032528591758616732049/289586000000000000000000000000000000000000000000000", + "exp_lower": "125257396680391201704119556364191595268624973/125000000000000000000000000000000000000000000", + "exp_upper": "1002059173443129613632956450913532762148999787/1000000000000000000000000000000000000000000000", + "log_lower": "772760613339578963369793924855826466974301747/250000000000000000000000000000000000000000000", + "log_upper": "3091042453358315853479175699423305867897206989/1000000000000000000000000000000000000000000000", + "multiplicity": 29427 + }, + { + "child": 4, + "contribution_lower": "18083705634726347850960500630149793348832701261/361982500000000000000000000000000000000000000000", + "contribution_upper": "180837056347263478509605006301497933488327012971/3619825000000000000000000000000000000000000000000", + "exp_lower": "50093367409214259974959835540581145010616901/50000000000000000000000000000000000000000000", + "exp_upper": "500933674092142599749598355405811450106169011/500000000000000000000000000000000000000000000", + "log_lower": "2803360380906534926039956693429478436393697277/1000000000000000000000000000000000000000000000", + "log_upper": "1401680190453267463019978346714739218196848639/500000000000000000000000000000000000000000000", + "multiplicity": 10830 + }, + { + "child": 5, + "contribution_lower": "588008807776444355592419854799690204006330237353/14479300000000000000000000000000000000000000000000", + "contribution_upper": "588008807776444355592419854799690204006330238527/14479300000000000000000000000000000000000000000000", + "exp_lower": "1001718582242665001009233142759267809210102619/1000000000000000000000000000000000000000000000", + "exp_upper": "1001718582242665001009233142759267809210102621/1000000000000000000000000000000000000000000000", + "log_lower": "2580216829592325170273661603119643933019096191/1000000000000000000000000000000000000000000000", + "log_upper": "20157943981190040392762981274372218226711689/7812500000000000000000000000000000000000000", + "multiplicity": 7044 + }, + { + "child": 6, + "contribution_lower": "4414038190606526990615966079295032806964090649467/144793000000000000000000000000000000000000000000000", + "contribution_upper": "2207019095303263495307983039647516403482045326937/72396500000000000000000000000000000000000000000000", + "exp_lower": "1001597048016003401546622663783760564321327581/1000000000000000000000000000000000000000000000", + "exp_upper": "500798524008001700773311331891880282160663791/500000000000000000000000000000000000000000000", + "log_lower": "2397895272798370544061943577965129299821706853/1000000000000000000000000000000000000000000000", + "log_upper": "1198947636399185272030971788982564649910853427/500000000000000000000000000000000000000000000", + "multiplicity": 4407 + }, + { + "child": 7, + "contribution_lower": "298996124398096747456040246004140991499091240029/14479300000000000000000000000000000000000000000000", + "contribution_upper": "5979922487961934949120804920082819829981824806551/289586000000000000000000000000000000000000000000000", + "exp_lower": "50074715189766663449345209513337965416025999/50000000000000000000000000000000000000000000", + "exp_upper": "1001494303795333268986904190266759308320519981/1000000000000000000000000000000000000000000000", + "log_lower": "140234037060694514985566762056415740181725801/62500000000000000000000000000000000000000000", + "log_upper": "2243744592971112239769068192902651842907612817/1000000000000000000000000000000000000000000000", + "multiplicity": 2559 + }, + { + "child": 8, + "contribution_lower": "4460805477263077618368946182293341164081358457/131630000000000000000000000000000000000000000000", + "contribution_upper": "12267215062473463450514602001306688201223735769/361982500000000000000000000000000000000000000000", + "exp_lower": "1001405311222323546980783836841362302140713123/1000000000000000000000000000000000000000000000", + "exp_upper": "250351327805580886745195959210340575535178281/250000000000000000000000000000000000000000000", + "log_lower": "2110213200346589616622724571971301868318197143/1000000000000000000000000000000000000000000000", + "log_upper": "263776650043323702077840571496412733539774643/125000000000000000000000000000000000000000000", + "multiplicity": 3675 + }, + { + "child": 9, + "contribution_lower": "79485323033018237947989360316065340698677862807/5791720000000000000000000000000000000000000000000", + "contribution_upper": "361296922877355627036315274163933366812172104029/26326000000000000000000000000000000000000000000000", + "exp_lower": "20026536415474486759382554879331151599566103/20000000000000000000000000000000000000000000", + "exp_upper": "1001326820773724337969127743966557579978305151/1000000000000000000000000000000000000000000000", + "log_lower": "199243016469020616208393046250078016324971643/100000000000000000000000000000000000000000000", + "log_upper": "1992430164690206162083930462500780163249716431/1000000000000000000000000000000000000000000000", + "multiplicity": 1323 + }, + { + "child": 10, + "contribution_lower": "172816891557060762738705998269665965895947070231/5791720000000000000000000000000000000000000000000", + "contribution_upper": "432042228892651906846764995674164914739867676009/14479300000000000000000000000000000000000000000000", + "exp_lower": "200251322777590686835117031598685939624504137/200000000000000000000000000000000000000000000", + "exp_upper": "500628306943976717087792578996714849061260343/500000000000000000000000000000000000000000000", + "log_lower": "1887069649032379860856429481661467364943596057/1000000000000000000000000000000000000000000000", + "log_upper": "943534824516189930428214740830733682471798029/500000000000000000000000000000000000000000000", + "multiplicity": 2589 + }, + { + "child": 11, + "contribution_lower": "164696266311249937804736233258673708911790905903/13163000000000000000000000000000000000000000000000", + "contribution_upper": "65878506524499975121894493303469483564716362427/5265200000000000000000000000000000000000000000000", + "exp_lower": "500596554137537804877617730269524951099668407/500000000000000000000000000000000000000000000", + "exp_upper": "200238621655015121951047092107809980439867363/200000000000000000000000000000000000000000000", + "log_lower": "447939867307013750203119339595175568180747673/250000000000000000000000000000000000000000000", + "log_upper": "1791759469228055000812477358380702272722990693/1000000000000000000000000000000000000000000000", + "multiplicity": 987 + }, + { + "child": 12, + "contribution_lower": "177951770372440833367515713017253441048563914213/3619825000000000000000000000000000000000000000000", + "contribution_upper": "711807081489763333470062852069013764194255657563/14479300000000000000000000000000000000000000000000", + "exp_lower": "250283783927483591234199315073492884737783283/250000000000000000000000000000000000000000000", + "exp_upper": "1001135135709934364936797260293971538951133133/1000000000000000000000000000000000000000000000", + "log_lower": "1704748092238425234644711456506952731746206719/1000000000000000000000000000000000000000000000", + "log_upper": "332958611765317428641545206349014205419181/195312500000000000000000000000000000000000", + "multiplicity": 3555 + }, + { + "child": 13, + "contribution_lower": "1392504796435802101823810468285558086781709367561/144793000000000000000000000000000000000000000000000", + "contribution_upper": "174063099554475262727976308535694760847713671119/18099125000000000000000000000000000000000000000000", + "exp_lower": "1001081809083969879096916224504355202574916871/1000000000000000000000000000000000000000000000", + "exp_upper": "125135226135496234887114528063044400321864609/125000000000000000000000000000000000000000000", + "log_lower": "1624705384564888808820933494780512967739429601/1000000000000000000000000000000000000000000000", + "log_upper": "812352692282444404410466747390256483869714801/500000000000000000000000000000000000000000000", + "multiplicity": 642 + }, + { + "child": 14, + "contribution_lower": "1250790032371077515616152101965053044974389729571/36198250000000000000000000000000000000000000000000", + "contribution_upper": "2501580064742155031232304203930106089948779461641/72396500000000000000000000000000000000000000000000", + "exp_lower": "500516219436205488441837575816347757092592929/500000000000000000000000000000000000000000000", + "exp_upper": "1001032438872410976883675151632695514185185859/1000000000000000000000000000000000000000000000", + "log_lower": "775298706205583465175918035722237637416056341/500000000000000000000000000000000000000000000", + "log_upper": "1550597412411166930351836071444475274832112683/1000000000000000000000000000000000000000000000", + "multiplicity": 2142 + }, + { + "child": 15, + "contribution_lower": "651642197499310476834266983652297662569304394601/11583440000000000000000000000000000000000000000000", + "contribution_upper": "162910549374827619208566745913074415642326098813/2895860000000000000000000000000000000000000000000", + "exp_lower": "1000986478493564480544188914980487960935951451/1000000000000000000000000000000000000000000000", + "exp_upper": "250246619623391120136047228745121990233987863/250000000000000000000000000000000000000000000", + "log_lower": "740802270462107739439208183098559114185802817/500000000000000000000000000000000000000000000", + "log_upper": "296320908184843095775683273239423645674321127/200000000000000000000000000000000000000000000", + "multiplicity": 3255 + }, + { + "child": 16, + "contribution_lower": "50047174367031053906114007076104443302925003/8226875000000000000000000000000000000000000000", + "contribution_upper": "1000943487340621078122280141522088866058500061/164537500000000000000000000000000000000000000000", + "exp_lower": "50047174367031053906114007076104443302925003/50000000000000000000000000000000000000000000", + "exp_upper": "1000943487340621078122280141522088866058500061/1000000000000000000000000000000000000000000000", + "log_lower": "88566626236665269200343278157070331265168563/62500000000000000000000000000000000000000000", + "log_upper": "1417066019786644307205492450513125300242697009/1000000000000000000000000000000000000000000000", + "multiplicity": 330 + }, + { + "child": 17, + "contribution_lower": "3403070557142207346773934991622940700360183833/1316300000000000000000000000000000000000000000000", + "contribution_upper": "8507676392855518366934837479057351750900459591/3290750000000000000000000000000000000000000000000", + "exp_lower": "200180621008365138045525587742525923550599049/200000000000000000000000000000000000000000000", + "exp_upper": "500451552520912845113813969356314808876497623/500000000000000000000000000000000000000000000", + "log_lower": "1356441397970209464624886318472705036956494533/1000000000000000000000000000000000000000000000", + "log_upper": "678220698985104732312443159236352518478247267/500000000000000000000000000000000000000000000", + "multiplicity": 132 + }, + { + "child": 18, + "contribution_lower": "531459332570745507840722756443447013890223446131/3290750000000000000000000000000000000000000000000", + "contribution_upper": "265729666285372753920361378221723506945111723331/1645375000000000000000000000000000000000000000000", + "exp_lower": "1000865033089916210622830049799335242731117601/1000000000000000000000000000000000000000000000", + "exp_upper": "500432516544958105311415024899667621365558801/500000000000000000000000000000000000000000000", + "log_lower": "162410373016282606583337292630325449396777037/125000000000000000000000000000000000000000000", + "log_upper": "1299282984130260852666698341042603595174216297/1000000000000000000000000000000000000000000000", + "multiplicity": 7788 + }, + { + "child": 19, + "contribution_lower": "36947604984708453597376640085717897148571094226019/289586000000000000000000000000000000000000000000000", + "contribution_upper": "4618450623088556699672080010714737143571386782867/36198250000000000000000000000000000000000000000000", + "exp_lower": "1000829021445633545449972643652460848621802807/1000000000000000000000000000000000000000000000", + "exp_upper": "125103627680704193181246580456557606077725351/125000000000000000000000000000000000000000000", + "log_lower": "311303940714996271216348376114494508826829571/250000000000000000000000000000000000000000000", + "log_upper": "249043152571997016973078700891595607061463657/200000000000000000000000000000000000000000000", + "multiplicity": 5829 + }, + { + "child": 20, + "contribution_lower": "4253378148972909456145938223738660874824909493/329075000000000000000000000000000000000000000000", + "contribution_upper": "17013512595891637824583752894954643499299637989/1316300000000000000000000000000000000000000000000", + "exp_lower": "250198714645465262126231660219921227930877029/250000000000000000000000000000000000000000000", + "exp_upper": "1000794858581861048504926640879684911723508117/1000000000000000000000000000000000000000000000", + "log_lower": "1193922468472434551439197360203290796868095923/1000000000000000000000000000000000000000000000", + "log_upper": "298480617118108637859799340050822699217023981/250000000000000000000000000000000000000000000", + "multiplicity": 561 + } + ], + "upper": "7239649999999993160790422556905626856350258805523/7239650000000000000000000000000000000000000000000" + }, + "complex_saving": "665489485337/1000000000000000", + "denominator": 1000000000000000, + "iterations": 45, + "method": { + "exp_degree": 12, + "log_base": "4/3", + "log_terms": 80, + "outward_grid": 1000000000000000000000000000000000000000000000 + }, + "rejected": { + "lower": "144793000000000194100193959420325446256537624666829/144793000000000000000000000000000000000000000000000", + "saving": "332744742669/500000000000000", + "strict_gap_lower": "-551421005566535015472319709166267/411343750000000000000000000000000000000000000000", + "terms": [ + { + "child": 1, + "contribution_lower": "39108890407949185176506317395485545073026535187/361982500000000000000000000000000000000000000000", + "contribution_upper": "39108890407949185176506317395485545073026539087/361982500000000000000000000000000000000000000000", + "exp_lower": "1002792061742286799397597881935526796744270133/1000000000000000000000000000000000000000000000", + "exp_upper": "1002792061742286799397597881935526796744270233/1000000000000000000000000000000000000000000000", + "log_lower": "2094827371013212772437210468172915786272348773/500000000000000000000000000000000000000000000", + "log_upper": "4189654742026425544874420936345831572544697547/1000000000000000000000000000000000000000000000", + "multiplicity": 93600 + }, + { + "child": 2, + "contribution_lower": "1421804535223760483421521515241747482470059591059/14479300000000000000000000000000000000000000000000", + "contribution_upper": "355451133805940120855380378810436870617514901311/3619825000000000000000000000000000000000000000000", + "exp_lower": "501164799162411167931449247529695975491737607/500000000000000000000000000000000000000000000", + "exp_upper": "125291199790602791982862311882423993872934403/125000000000000000000000000000000000000000000", + "log_lower": "3496507561466480235457188814887655004469197411/1000000000000000000000000000000000000000000000", + "log_upper": "874126890366620058864297203721913751117299353/250000000000000000000000000000000000000000000", + "multiplicity": 42555 + }, + { + "child": 3, + "contribution_lower": "268069048153736966252599269836456320374002649627/2632600000000000000000000000000000000000000000000", + "contribution_upper": "29487595296911066287785919682010195241140291547251/289586000000000000000000000000000000000000000000000", + "exp_lower": "100205917344313271104040234077582476097258611/100000000000000000000000000000000000000000000", + "exp_upper": "1002059173443132711040402340775824760972586113/1000000000000000000000000000000000000000000000", + "log_lower": "772760613339578963369793924855826466974301747/250000000000000000000000000000000000000000000", + "log_upper": "3091042453358315853479175699423305867897206989/1000000000000000000000000000000000000000000000", + "multiplicity": 29427 + }, + { + "child": 4, + "contribution_lower": "180837056347263985461044169983273093136227249403/3619825000000000000000000000000000000000000000000", + "contribution_upper": "45209264086815996365261042495818273284056812441/904956250000000000000000000000000000000000000000", + "exp_lower": "500933674092144004047213767266684468521405123/500000000000000000000000000000000000000000000", + "exp_upper": "125233418523036001011803441816671117130351281/125000000000000000000000000000000000000000000", + "log_lower": "2803360380906534926039956693429478436393697277/1000000000000000000000000000000000000000000000", + "log_upper": "1401680190453267463019978346714739218196848639/500000000000000000000000000000000000000000000", + "multiplicity": 10830 + }, + { + "child": 5, + "contribution_lower": "58800880777644587278264162810186081409541852409/1447930000000000000000000000000000000000000000000", + "contribution_upper": "3340959135093442458992281977851481898269423439/82268750000000000000000000000000000000000000000", + "exp_lower": "100171858224266758566037756065052949590360907/100000000000000000000000000000000000000000000", + "exp_upper": "62607411390166724103773597540658093493975567/62500000000000000000000000000000000000000000", + "log_lower": "2580216829592325170273661603119643933019096191/1000000000000000000000000000000000000000000000", + "log_upper": "20157943981190040392762981274372218226711689/7812500000000000000000000000000000000000000", + "multiplicity": 7044 + }, + { + "child": 6, + "contribution_lower": "882807638121307515003455457234335566608450813843/28958600000000000000000000000000000000000000000000", + "contribution_upper": "200638099573024435228058058462348992411011548801/6581500000000000000000000000000000000000000000000", + "exp_lower": "200319409603201160654289870032751433312559749/200000000000000000000000000000000000000000000", + "exp_upper": "500798524008002901635724675081878583281399373/500000000000000000000000000000000000000000000", + "log_lower": "2397895272798370544061943577965129299821706853/1000000000000000000000000000000000000000000000", + "log_upper": "1198947636399185272030971788982564649910853427/500000000000000000000000000000000000000000000", + "multiplicity": 4407 + }, + { + "child": 7, + "contribution_lower": "5979922487961948366539553671050437336100965253249/289586000000000000000000000000000000000000000000000", + "contribution_upper": "298996124398097418326977683552521866805048262961/14479300000000000000000000000000000000000000000000", + "exp_lower": "1001494303795335516084333222416753866370953819/1000000000000000000000000000000000000000000000", + "exp_upper": "50074715189766775804216661120837693318547691/50000000000000000000000000000000000000000000", + "log_lower": "140234037060694514985566762056415740181725801/62500000000000000000000000000000000000000000", + "log_upper": "2243744592971112239769068192902651842907612817/1000000000000000000000000000000000000000000000", + "multiplicity": 2559 + }, + { + "child": 8, + "contribution_lower": "12267215062473489336953758323350589678682448017/361982500000000000000000000000000000000000000000", + "contribution_upper": "49068860249893957347815033293402358714729792117/1447930000000000000000000000000000000000000000000", + "exp_lower": "250351327805581415039872618843889585279233633/250000000000000000000000000000000000000000000", + "exp_upper": "1001405311222325660159490475375558341116934533/1000000000000000000000000000000000000000000000", + "log_lower": "2110213200346589616622724571971301868318197143/1000000000000000000000000000000000000000000000", + "log_upper": "263776650043323702077840571496412733539774643/125000000000000000000000000000000000000000000", + "multiplicity": 3675 + }, + { + "child": 9, + "contribution_lower": "3974266151650919815847231072349405628245304864377/289586000000000000000000000000000000000000000000000", + "contribution_upper": "1987133075825459907923615536174702814122652434173/144793000000000000000000000000000000000000000000000", + "exp_lower": "1001326820773726333042890166880676651107408633/1000000000000000000000000000000000000000000000", + "exp_upper": "500663410386863166521445083440338325553704317/500000000000000000000000000000000000000000000", + "log_lower": "199243016469020616208393046250078016324971643/100000000000000000000000000000000000000000000", + "log_upper": "1992430164690206162083930462500780163249716431/1000000000000000000000000000000000000000000000", + "multiplicity": 1323 + }, + { + "child": 10, + "contribution_lower": "864084457785305444281084478597387921924302943123/28958600000000000000000000000000000000000000000000", + "contribution_upper": "432042228892652722140542239298693960962151471993/14479300000000000000000000000000000000000000000000", + "exp_lower": "1001256613887955323616552118884574648811475021/1000000000000000000000000000000000000000000000", + "exp_upper": "500628306943977661808276059442287324405737511/500000000000000000000000000000000000000000000", + "log_lower": "1887069649032379860856429481661467364943596057/1000000000000000000000000000000000000000000000", + "log_upper": "943534824516189930428214740830733682471798029/500000000000000000000000000000000000000000000", + "multiplicity": 2589 + }, + { + "child": 11, + "contribution_lower": "1646962663112502329008309429465225142441159993/131630000000000000000000000000000000000000000000", + "contribution_upper": "329392532622500465801661885893045028488231998929/26326000000000000000000000000000000000000000000000", + "exp_lower": "5005965541375387018262338691383663046933617/5000000000000000000000000000000000000000000", + "exp_upper": "1001193108275077403652467738276732609386723401/1000000000000000000000000000000000000000000000", + "log_lower": "447939867307013750203119339595175568180747673/250000000000000000000000000000000000000000000", + "log_upper": "1791759469228055000812477358380702272722990693/1000000000000000000000000000000000000000000000", + "multiplicity": 987 + }, + { + "child": 12, + "contribution_lower": "355903540744882273460913531772689384798872460423/7239650000000000000000000000000000000000000000000", + "contribution_upper": "711807081489764546921827063545378769597744921557/14479300000000000000000000000000000000000000000000", + "exp_lower": "500567567854968035810004967331489992684771393/500000000000000000000000000000000000000000000", + "exp_upper": "1001135135709936071620009934662979985369542787/1000000000000000000000000000000000000000000000", + "log_lower": "1704748092238425234644711456506952731746206719/1000000000000000000000000000000000000000000000", + "log_upper": "332958611765317428641545206349014205419181/195312500000000000000000000000000000000000", + "multiplicity": 3555 + }, + { + "child": 13, + "contribution_lower": "126591345130527669475804660906314262671565048097/13163000000000000000000000000000000000000000000000", + "contribution_upper": "696252398217902182116925634984728444693607765229/72396500000000000000000000000000000000000000000000", + "exp_lower": "1001081809083971505559921833191557792514173637/1000000000000000000000000000000000000000000000", + "exp_upper": "500540904541985752779960916595778896257086819/500000000000000000000000000000000000000000000", + "log_lower": "1624705384564888808820933494780512967739429601/1000000000000000000000000000000000000000000000", + "log_upper": "812352692282444404410466747390256483869714801/500000000000000000000000000000000000000000000", + "multiplicity": 642 + }, + { + "child": 14, + "contribution_lower": "625395016185539727543969883119537102713368427529/18099125000000000000000000000000000000000000000000", + "contribution_upper": "500316012948431782035175906495629682170694742523/14479300000000000000000000000000000000000000000000", + "exp_lower": "250258109718103132270496151708498240381499971/250000000000000000000000000000000000000000000", + "exp_upper": "200206487774482505816396921366798592305199977/200000000000000000000000000000000000000000000", + "log_lower": "775298706205583465175918035722237637416056341/500000000000000000000000000000000000000000000", + "log_upper": "1550597412411166930351836071444475274832112683/1000000000000000000000000000000000000000000000", + "multiplicity": 2142 + }, + { + "child": 15, + "contribution_lower": "651642197499311442310305856465867855834576894233/11583440000000000000000000000000000000000000000000", + "contribution_upper": "162910549374827860577576464116466963958644223721/2895860000000000000000000000000000000000000000000", + "exp_lower": "1000986478493565963610300854786279348440210283/1000000000000000000000000000000000000000000000", + "exp_upper": "250246619623391490902575213696569837110052571/250000000000000000000000000000000000000000000", + "log_lower": "740802270462107739439208183098559114185802817/500000000000000000000000000000000000000000000", + "log_upper": "296320908184843095775683273239423645674321127/200000000000000000000000000000000000000000000", + "multiplicity": 3255 + }, + { + "child": 16, + "contribution_lower": "250235871835155624131320944665099541136973787/41134375000000000000000000000000000000000000000", + "contribution_upper": "1000943487340622496525283778660398164547895149/164537500000000000000000000000000000000000000000", + "exp_lower": "250235871835155624131320944665099541136973787/250000000000000000000000000000000000000000000", + "exp_upper": "1000943487340622496525283778660398164547895149/1000000000000000000000000000000000000000000000", + "log_lower": "88566626236665269200343278157070331265168563/62500000000000000000000000000000000000000000", + "log_upper": "1417066019786644307205492450513125300242697009/1000000000000000000000000000000000000000000000", + "multiplicity": 330 + }, + { + "child": 17, + "contribution_lower": "17015352785711059814198594564306979295385664951/6581500000000000000000000000000000000000000000000", + "contribution_upper": "2126919098213882476774824320538372411923208121/822687500000000000000000000000000000000000000000", + "exp_lower": "1000903105041827047894034974370998782081509703/1000000000000000000000000000000000000000000000", + "exp_upper": "125112888130228380986754371796374847760188713/125000000000000000000000000000000000000000000", + "log_lower": "1356441397970209464624886318472705036956494533/1000000000000000000000000000000000000000000000", + "log_upper": "678220698985104732312443159236352518478247267/500000000000000000000000000000000000000000000", + "multiplicity": 132 + }, + { + "child": 18, + "contribution_lower": "132864833142686549589197580709713988002006854283/822687500000000000000000000000000000000000000000", + "contribution_upper": "531459332570746198356790322838855952008027417663/3290750000000000000000000000000000000000000000000", + "exp_lower": "250216258272479377757434238624696775898317993/250000000000000000000000000000000000000000000", + "exp_upper": "1000865033089917511029736954498787103593271973/1000000000000000000000000000000000000000000000", + "log_lower": "162410373016282606583337292630325449396777037/125000000000000000000000000000000000000000000", + "log_upper": "1299282984130260852666698341042603595174216297/1000000000000000000000000000000000000000000000", + "multiplicity": 7788 + }, + { + "child": 19, + "contribution_lower": "36947604984708499605116766968871144376710501427419/289586000000000000000000000000000000000000000000000", + "contribution_upper": "2309225311544281225319797935554446523544406341521/18099125000000000000000000000000000000000000000000", + "exp_lower": "1000829021445634791698046075490184586415757007/1000000000000000000000000000000000000000000000", + "exp_upper": "62551813840352174481127879718136536650984813/62500000000000000000000000000000000000000000", + "log_lower": "311303940714996271216348376114494508826829571/250000000000000000000000000000000000000000000", + "log_upper": "249043152571997016973078700891595607061463657/200000000000000000000000000000000000000000000", + "multiplicity": 5829 + }, + { + "child": 20, + "contribution_lower": "2126689074486457267174838596096106649596502193/164537500000000000000000000000000000000000000000", + "contribution_upper": "17013512595891658137398708768768853196772017561/1316300000000000000000000000000000000000000000000", + "exp_lower": "125099357322732780422049329182123920564500129/125000000000000000000000000000000000000000000", + "exp_upper": "1000794858581862243376394633456991364516001033/1000000000000000000000000000000000000000000000", + "log_lower": "1193922468472434551439197360203290796868095923/1000000000000000000000000000000000000000000000", + "log_upper": "298480617118108637859799340050822699217023981/250000000000000000000000000000000000000000000", + "multiplicity": 561 + } + ], + "upper": "411343750000000551421005566535015472319709166267/411343750000000000000000000000000000000000000000" + }, + "scope": "Strict contraction and adjacent point exclusion for this fixed complete complex profile." + }, + "physical": { + "before_terminal_sinks": { + "R": 12877, + "W_per_vertex": 13207, + "changed_operation_frames": 13364, + "checks": { + "donor_frames_inside_gauges": true, + "pair_chronology": true, + "role_chains_nested": true, + "target_chains_nested_in_read_order": true, + "telescoping_deficit": true, + "value_spans_inside_frames": true + }, + "child_histogram": { + "1": 93600, + "10": 2589, + "11": 987, + "12": 3555, + "13": 642, + "14": 2142, + "15": 3255, + "16": 330, + "17": 132, + "18": 7920, + "19": 5829, + "2": 42555, + "20": 561, + "3": 29427, + "4": 10962, + "5": 7044, + "6": 4407, + "7": 2559, + "8": 3675, + "9": 1323 + }, + "deficit_per_vertex": 1320, + "h": 22, + "late_pairs": 1261, + "local_histogram": { + "1": 25920, + "10": 863, + "11": 329, + "12": 1185, + "13": 214, + "14": 714, + "15": 1085, + "16": 110, + "17": 44, + "19": 1943, + "2": 11985, + "20": 187, + "3": 9809, + "4": 3654, + "5": 2348, + "6": 1469, + "7": 853, + "8": 1225, + "9": 441 + }, + "loss": 440, + "m": 66, + "pairs": 2310, + "physical_R": 10567, + "physical_gauge_histogram": {}, + "rank_per_vertex": 870342, + "scalar_replay": { + "modulus": "2^61-1", + "rejected_controls": [ + "flipped_signed_operation", + "late_read_before_donor_death", + "omitted_recipient_read" + ], + "seeds_restored_and_y_plus_x": true, + "slots": 10567 + }, + "source_data_histogram": { + "1": 1320, + "18": 1320, + "2": 1320 + }, + "target_data_histogram": { + "0": 6270, + "1": 3960, + "18": 1320 + }, + "v": 1320 + }, + "exact_adjoint": { + "L1": 5845250, + "gauge_supports_contained": true, + "max_numerator_over_6": 6, + "nonzeros": 4280534 + }, + "foreign_producer_replays": 0, + "formal": [ + { + "columns": 13163, + "direction": 1, + "dirty": 10523, + "outputs": true, + "restored": true + }, + { + "columns": 13163, + "direction": -1, + "dirty": 10523, + "outputs": true, + "restored": true + } + ], + "input_sha256": { + "baseline.json.gz": "5975dc6981aa18ac4ba4a1ca290d9163beedc8bc48e9600f4de5390758b57ef9", + "frames.json.gz": "05cf2b64cdc6142294512fcd963285ed535599b433691a547eaf775424f7b104", + "graph.json.gz": "4720aa3bf8960d89fca62cf8dc71dc7c5f8b3b85c59ecae727184ae12e1f7c18", + "physical-frames.json.gz": "bbbe32fb7a5d2415b7b2f130c46d1e20de392ea1cf6587fca6bc015879a3ca4f", + "physical-pairs.json.gz": "33b847e6f40e40809dce1c3eb25afe357b88b0b14c9a5ccca95b78553a595065", + "profile-before.json.gz": "e41fd008059d8a08d8f3078831e577201acd9f4aa115dd0197e28286cf281c80", + "profile.json.gz": "67de497a9c1ea64bb0cf9dc3ca655e7f9c704452a615f3e7eb45d124ed40c2c1", + "word.json.gz": "b70c03e2401df03f67bbba36e0c33704bde377902e446831a4df94833e935cc8" + }, + "mutations": { + "early-read": "REJECTED", + "missing-read": "REJECTED" + }, + "original_formal": { + "absolute_coefficient_bound": 394506, + "base_exceeds_twice_bound": true, + "columns": [ + { + "K_and_inverse": true, + "all_aliases_and_deadline_reads": true, + "all_physical_dirty_slots_restored": true, + "direction": 1, + "dirty_columns": 10567, + "every_formal_column": true, + "source_columns": 1320, + "target_columns": 1320 + }, + { + "K_and_inverse": true, + "all_aliases_and_deadline_reads": true, + "all_physical_dirty_slots_restored": true, + "direction": -1, + "dirty_columns": 10567, + "every_formal_column": true, + "source_columns": 1320, + "target_columns": 1320 + } + ], + "packed_digit_bits": 24 + }, + "physical": { + "R": 12877, + "W_per_vertex": 13163, + "changed_operation_frames": 13364, + "checks": { + "donor_frames_inside_gauges": true, + "pair_chronology": true, + "role_chains_nested": true, + "target_chains_nested_in_read_order": true, + "telescoping_deficit": true, + "value_spans_inside_frames": true + }, + "child_histogram": { + "1": 93600, + "10": 2589, + "11": 987, + "12": 3555, + "13": 642, + "14": 2142, + "15": 3255, + "16": 330, + "17": 132, + "18": 7788, + "19": 5829, + "2": 42555, + "20": 561, + "3": 29427, + "4": 10830, + "5": 7044, + "6": 4407, + "7": 2559, + "8": 3675, + "9": 1323 + }, + "deficit_per_vertex": 1320, + "h": 22, + "late_pairs": 1261, + "local_histogram": { + "1": 25920, + "10": 855, + "11": 327, + "12": 1179, + "13": 212, + "14": 710, + "15": 1073, + "16": 103, + "17": 44, + "19": 1943, + "2": 11962, + "20": 187, + "3": 9793, + "4": 3603, + "5": 2346, + "6": 1462, + "7": 850, + "8": 1220, + "9": 440 + }, + "loss": 440, + "m": 66, + "pairs": 2310, + "physical_R": 10523, + "physical_gauge_histogram": {}, + "rank_per_vertex": 867438, + "scalar_replay": { + "modulus": "2^61-1", + "rejected_controls": [ + "flipped_signed_operation", + "late_read_before_donor_death", + "omitted_recipient_read" + ], + "seeds_restored_and_y_plus_x": true, + "slots": 10567 + }, + "source_data_histogram": { + "1": 1320, + "18": 1320, + "2": 1320 + }, + "target_data_histogram": { + "0": 6270, + "1": 3960, + "10": 8, + "11": 2, + "12": 6, + "13": 2, + "14": 4, + "15": 12, + "16": 7, + "18": 1276, + "2": 23, + "3": 16, + "4": 7, + "5": 2, + "6": 7, + "7": 3, + "8": 5, + "9": 1 + }, + "terminal_sinks": 44, + "v": 1320 + }, + "pre_reuse_finite": { + "K_involution_and_inverse_exact": true, + "K_source_itinerary_verified": true, + "center_phase_closed": true, + "conservative_source_supports": true, + "decoder_identity_exact": true, + "full_backward_intersections": true, + "full_gauge_intersections": true, + "physical_signed_M_replayed": true, + "positive_rank_ledger_recounted": true, + "reverse_target_chains": true, + "scalar_H_exact": true, + "selected_roles": 2310, + "selected_sources_untouched": true, + "signed_scalar_pairs_checked": 1742400 + }, + "scalar_bound": { + "M_operations": 33466, + "binary_dirty_read_bits": 33482, + "c": 21909, + "decoder_coefficients": [ + "-1/2", + "-1/6", + "1/2", + "1/3" + ], + "fixed_odd_divisor": 3, + "gate_and_inverse_coefficients": [ + -1, + 1 + ], + "handoffs": 2310, + "local_group_upper": 4552920126520, + "logical_R": 12877, + "physical_R": 10523, + "q": 3157, + "scalar_denominators_divide": 6, + "scope": "Conservative inherited virtual-word bill retained after aliasing, including all compensated reads. Alias and frame route choices are finite permutations/Clifford adapters; their separate global movement bill remains an assembly obligation.", + "terminal_original_scalar_reserve_retained": true, + "terminal_scalar_gate_delta": -202, + "terminal_sinks": 44, + "three_q_less_than_2pow15": true + }, + "scope": "Finite candidate audit only. General exact Clifford and shared cover contracts, analytic supplier bridge, and paid global multiplication assembly remain separate obligations.", + "source_sha256": { + "research/paired-cube-diagonal-bit-168/complex/check_sinks.py": "d70903464b3caabc0920aee8953978a27a6874a655ecb66cadacf77a31df11af", + "research/paired-cube-diagonal-bit-168/complex/formal_sinks.py": "d7fefe86e637584ad1bf53c8f7714b88d5abed92eaa29d110ef099536e51f516", + "research/paired-cube-diagonal-bit-168/complex/physical.py": "01961fad4b04aaa940d2dc99c87690bc861b3861200296974c5e065ce3446659", + "research/paired-cube-diagonal-bit-168/complex/prove.py": "3eecae7856aa212d1d7e607e2663b8ce0766ed6067b388c6be2ed5485886bd43", + "research/paired-cube-diagonal-bit-168/complex/verify_fused.py": "75c3dcd80fcdbc461651fa2d2fa463e6b41a569d695fc74700d240223ef198e9", + "research/paired-cube-diagonal-bit-168/references/pr168-v4/notes/general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "research/paired-cube-diagonal-bit-168/references/pr168-v4/scripts/paired_cube/frames.py": "7d897418dbfee47de0723ea4983098a982610ccba45e1bac9000a79626d8421c", + "research/paired-cube-diagonal-bit-168/references/pr168-v4/scripts/paired_cube_physical.py": "9c9ea1ea29e551ab6116d7c8ca09f4703ff9e2fa102032d5055327fde07ba319" + }, + "status": "PASS exact fused physical candidate, all formal source/target/dirty columns", + "terminal_compiler": { + "all_formal_source_and_dirty_coefficients": true, + "all_new_target_events_replayed": true, + "child_histogram": { + "1": 93600, + "10": 2589, + "11": 987, + "12": 3555, + "13": 642, + "14": 2142, + "15": 3255, + "16": 330, + "17": 132, + "18": 7788, + "19": 5829, + "2": 42555, + "20": 561, + "3": 29427, + "4": 10830, + "5": 7044, + "6": 4407, + "7": 2559, + "8": 3675, + "9": 1323 + }, + "chronological_inverse_by_literal_reverse": true, + "deficit": 1320, + "dirty_coefficient_nonzero_range": [ + 701, + 721 + ], + "eligible_count": 44, + "formal_original_source_dirty_target_columns": 13207, + "full_old_physical_histogram_verified": true, + "h": 22, + "input_pins": { + "frames.json.gz": "05cf2b64cdc6142294512fcd963285ed535599b433691a547eaf775424f7b104", + "graph.json.gz": "4720aa3bf8960d89fca62cf8dc71dc7c5f8b3b85c59ecae727184ae12e1f7c18", + "physical-frames.json.gz": "bbbe32fb7a5d2415b7b2f130c46d1e20de392ea1cf6587fca6bc015879a3ca4f", + "physical-pairs.json.gz": "33b847e6f40e40809dce1c3eb25afe357b88b0b14c9a5ccca95b78553a595065", + "profile-before.json.gz": "e41fd008059d8a08d8f3078831e577201acd9f4aa115dd0197e28286cf281c80", + "profile.json.gz": "67de497a9c1ea64bb0cf9dc3ca655e7f9c704452a615f3e7eb45d124ed40c2c1", + "word.json.gz": "b70c03e2401df03f67bbba36e0c33704bde377902e446831a4df94833e935cc8" + }, + "local_histogram": { + "1": 25920, + "10": 855, + "11": 327, + "12": 1179, + "13": 212, + "14": 710, + "15": 1073, + "16": 103, + "17": 44, + "19": 1943, + "2": 11962, + "20": 187, + "3": 9793, + "4": 3603, + "5": 2346, + "6": 1462, + "7": 850, + "8": 1220, + "9": 440 + }, + "new_W": 13163, + "new_kappa_claimed": false, + "new_odd_denominator": false, + "new_physical_R": 10523, + "new_rank": 867438, + "old_W": 13207, + "old_physical_R": 10567, + "old_rank": 870342, + "rejected_conditions": { + "center_phase_touch": 13, + "no_uncorrected_pivot": 4, + "retained_producer_consumer": 119 + }, + "remaining_formal_columns": 13163, + "scalar_gate_delta": -202, + "scalar_sandwich_literal_reverse_checked": true, + "scope": "Only all-eight disjoint roots; retained full proof contracts unchanged", + "shared_child_delta": { + "18": -132, + "4": -132 + }, + "simultaneous_compatible": true, + "sinks": [ + { + "first_any_old_read": 11146, + "first_pivot_old_read": 26877, + "last_write_chronology": 24995, + "pivot": 40, + "post_after_op": 24819, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 10, + 4, + 4 + ], + "role": 10080, + "root_index": 55, + "targets": [ + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47 + ], + "write_ranks": [ + 10, + 14, + 18 + ], + "writes": [ + 16836, + 20644, + 24819 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27021, + "last_write_chronology": 25424, + "pivot": 72, + "post_after_op": 25248, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 15, + 3 + ], + "role": 10435, + "root_index": 99, + "targets": [ + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79 + ], + "write_ranks": [ + 15, + 18 + ], + "writes": [ + 21268, + 25248 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27237, + "last_write_chronology": 25002, + "pivot": 120, + "post_after_op": 24826, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 8, + 10 + ], + "role": 9708, + "root_index": 165, + "targets": [ + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127 + ], + "write_ranks": [ + 8, + 18 + ], + "writes": [ + 14887, + 24826 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27309, + "last_write_chronology": 25347, + "pivot": 136, + "post_after_op": 25171, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 16, + 2 + ], + "role": 10466, + "root_index": 187, + "targets": [ + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143 + ], + "write_ranks": [ + 16, + 18 + ], + "writes": [ + 22350, + 25171 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27417, + "last_write_chronology": 25432, + "pivot": 160, + "post_after_op": 25256, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 10, + 2, + 6 + ], + "role": 10066, + "root_index": 220, + "targets": [ + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167 + ], + "write_ranks": [ + 10, + 12, + 18 + ], + "writes": [ + 16779, + 20665, + 25256 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27453, + "last_write_chronology": 25411, + "pivot": 168, + "post_after_op": 25235, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 10, + 2, + 6 + ], + "role": 10057, + "root_index": 231, + "targets": [ + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175 + ], + "write_ranks": [ + 10, + 12, + 18 + ], + "writes": [ + 16744, + 19066, + 25235 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27705, + "last_write_chronology": 25025, + "pivot": 224, + "post_after_op": 24849, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 9, + 2, + 7 + ], + "role": 10050, + "root_index": 308, + "targets": [ + 224, + 225, + 226, + 227, + 228, + 229, + 230, + 231 + ], + "write_ranks": [ + 9, + 11, + 18 + ], + "writes": [ + 16132, + 18181, + 24849 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27921, + "last_write_chronology": 25026, + "pivot": 272, + "post_after_op": 24850, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 6, + 2, + 8, + 2 + ], + "role": 8956, + "root_index": 374, + "targets": [ + 272, + 273, + 274, + 275, + 276, + 277, + 278, + 279 + ], + "write_ranks": [ + 6, + 8, + 16, + 18 + ], + "writes": [ + 13006, + 16158, + 22414, + 24850 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 28029, + "last_write_chronology": 24927, + "pivot": 296, + "post_after_op": 24751, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 13, + 5 + ], + "role": 10335, + "root_index": 407, + "targets": [ + 296, + 297, + 298, + 299, + 300, + 301, + 302, + 303 + ], + "write_ranks": [ + 13, + 18 + ], + "writes": [ + 19761, + 24751 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 28245, + "last_write_chronology": 25380, + "pivot": 344, + "post_after_op": 25204, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 15, + 3 + ], + "role": 10425, + "root_index": 473, + "targets": [ + 344, + 345, + 346, + 347, + 348, + 349, + 350, + 351 + ], + "write_ranks": [ + 15, + 18 + ], + "writes": [ + 21184, + 25204 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27341, + "last_write_chronology": 25147, + "pivot": 432, + "post_after_op": 24971, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 15, + 3 + ], + "role": 10471, + "root_index": 594, + "targets": [ + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439 + ], + "write_ranks": [ + 15, + 18 + ], + "writes": [ + 22467, + 24971 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27449, + "last_write_chronology": 25144, + "pivot": 456, + "post_after_op": 24968, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 10, + 8 + ], + "role": 10089, + "root_index": 627, + "targets": [ + 456, + 457, + 458, + 459, + 460, + 461, + 462, + 463 + ], + "write_ranks": [ + 10, + 18 + ], + "writes": [ + 16876, + 24968 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27485, + "last_write_chronology": 25389, + "pivot": 464, + "post_after_op": 25213, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 12, + 6 + ], + "role": 10289, + "root_index": 638, + "targets": [ + 464, + 465, + 466, + 467, + 468, + 469, + 470, + 471 + ], + "write_ranks": [ + 12, + 18 + ], + "writes": [ + 18895, + 25213 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27521, + "last_write_chronology": 25281, + "pivot": 472, + "post_after_op": 25105, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 16, + 2 + ], + "role": 10431, + "root_index": 649, + "targets": [ + 472, + 473, + 474, + 475, + 476, + 477, + 478, + 479 + ], + "write_ranks": [ + 16, + 18 + ], + "writes": [ + 21248, + 25105 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27593, + "last_write_chronology": 25324, + "pivot": 488, + "post_after_op": 25148, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 15, + 3 + ], + "role": 10433, + "root_index": 671, + "targets": [ + 488, + 489, + 490, + 491, + 492, + 493, + 494, + 495 + ], + "write_ranks": [ + 15, + 18 + ], + "writes": [ + 21254, + 25148 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27809, + "last_write_chronology": 25338, + "pivot": 536, + "post_after_op": 25162, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 15, + 3 + ], + "role": 10464, + "root_index": 737, + "targets": [ + 536, + 537, + 538, + 539, + 540, + 541, + 542, + 543 + ], + "write_ranks": [ + 15, + 18 + ], + "writes": [ + 22339, + 25162 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27917, + "last_write_chronology": 25160, + "pivot": 560, + "post_after_op": 24984, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 14, + 2, + 2 + ], + "role": 10354, + "root_index": 770, + "targets": [ + 560, + 561, + 562, + 563, + 564, + 565, + 566, + 567 + ], + "write_ranks": [ + 14, + 16, + 18 + ], + "writes": [ + 20599, + 22490, + 24984 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27953, + "last_write_chronology": 25068, + "pivot": 568, + "post_after_op": 24892, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 10, + 8 + ], + "role": 10102, + "root_index": 781, + "targets": [ + 568, + 569, + 570, + 571, + 572, + 573, + 574, + 575 + ], + "write_ranks": [ + 10, + 18 + ], + "writes": [ + 16943, + 24892 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 28025, + "last_write_chronology": 24940, + "pivot": 584, + "post_after_op": 24764, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 12, + 6 + ], + "role": 10293, + "root_index": 803, + "targets": [ + 584, + 585, + 586, + 587, + 588, + 589, + 590, + 591 + ], + "write_ranks": [ + 12, + 18, + 18 + ], + "writes": [ + 18919, + 24737, + 24764 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 28061, + "last_write_chronology": 24992, + "pivot": 592, + "post_after_op": 24816, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 15, + 3 + ], + "role": 10441, + "root_index": 814, + "targets": [ + 592, + 593, + 594, + 595, + 596, + 597, + 598, + 599 + ], + "write_ranks": [ + 15, + 18 + ], + "writes": [ + 21286, + 24816 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 28277, + "last_write_chronology": 25326, + "pivot": 640, + "post_after_op": 25150, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 16, + 2 + ], + "role": 10432, + "root_index": 880, + "targets": [ + 640, + 641, + 642, + 643, + 644, + 645, + 646, + 647 + ], + "write_ranks": [ + 16, + 18, + 18 + ], + "writes": [ + 21250, + 25019, + 25150 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27379, + "last_write_chronology": 24965, + "pivot": 664, + "post_after_op": 24789, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 11, + 5, + 2 + ], + "role": 10252, + "root_index": 913, + "targets": [ + 664, + 665, + 666, + 667, + 668, + 669, + 670, + 671 + ], + "write_ranks": [ + 11, + 16, + 18, + 18 + ], + "writes": [ + 18105, + 22356, + 24787, + 24789 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27415, + "last_write_chronology": 25358, + "pivot": 672, + "post_after_op": 25182, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 4, + 12, + 2 + ], + "role": 8926, + "root_index": 924, + "targets": [ + 672, + 673, + 674, + 675, + 676, + 677, + 678, + 679 + ], + "write_ranks": [ + 4, + 16, + 18 + ], + "writes": [ + 12966, + 22387, + 25182 + ] + }, + { + "first_any_old_read": 25714, + "first_pivot_old_read": 27595, + "last_write_chronology": 25040, + "pivot": 712, + "post_after_op": 24864, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 6, + 10, + 2 + ], + "role": 10048, + "root_index": 979, + "targets": [ + 712, + 713, + 714, + 715, + 716, + 717, + 718, + 719 + ], + "write_ranks": [ + 6, + 16, + 18 + ], + "writes": [ + 16124, + 22336, + 24864 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27667, + "last_write_chronology": 25106, + "pivot": 728, + "post_after_op": 24930, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 15, + 3 + ], + "role": 10460, + "root_index": 1001, + "targets": [ + 728, + 729, + 730, + 731, + 732, + 733, + 734, + 735 + ], + "write_ranks": [ + 15, + 18, + 18 + ], + "writes": [ + 21378, + 24929, + 24930 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27883, + "last_write_chronology": 25294, + "pivot": 776, + "post_after_op": 25118, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 15, + 3 + ], + "role": 10426, + "root_index": 1067, + "targets": [ + 776, + 777, + 778, + 779, + 780, + 781, + 782, + 783 + ], + "write_ranks": [ + 15, + 18 + ], + "writes": [ + 21206, + 25118 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27955, + "last_write_chronology": 25114, + "pivot": 792, + "post_after_op": 24938, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 13, + 3, + 2 + ], + "role": 10344, + "root_index": 1089, + "targets": [ + 792, + 793, + 794, + 795, + 796, + 797, + 798, + 799 + ], + "write_ranks": [ + 13, + 16, + 18, + 18 + ], + "writes": [ + 19809, + 22417, + 24877, + 24938 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27991, + "last_write_chronology": 25356, + "pivot": 800, + "post_after_op": 25180, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 16, + 2 + ], + "role": 10474, + "root_index": 1100, + "targets": [ + 800, + 801, + 802, + 803, + 804, + 805, + 806, + 807 + ], + "write_ranks": [ + 16, + 18 + ], + "writes": [ + 22520, + 25180 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 28171, + "last_write_chronology": 25415, + "pivot": 840, + "post_after_op": 25239, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 16, + 2 + ], + "role": 10450, + "root_index": 1155, + "targets": [ + 840, + 841, + 842, + 843, + 844, + 845, + 846, + 847 + ], + "write_ranks": [ + 16, + 18 + ], + "writes": [ + 21331, + 25239 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 28207, + "last_write_chronology": 25374, + "pivot": 848, + "post_after_op": 25198, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 14, + 2, + 2 + ], + "role": 10327, + "root_index": 1166, + "targets": [ + 848, + 849, + 850, + 851, + 852, + 853, + 854, + 855 + ], + "write_ranks": [ + 14, + 16, + 18 + ], + "writes": [ + 19070, + 22564, + 25198 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27599, + "last_write_chronology": 25386, + "pivot": 880, + "post_after_op": 25210, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 14, + 2, + 2 + ], + "role": 10297, + "root_index": 1210, + "targets": [ + 880, + 881, + 882, + 883, + 884, + 885, + 886, + 887 + ], + "write_ranks": [ + 14, + 16, + 18 + ], + "writes": [ + 18950, + 22536, + 25210 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27707, + "last_write_chronology": 25301, + "pivot": 904, + "post_after_op": 25125, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 11, + 7 + ], + "role": 10255, + "root_index": 1243, + "targets": [ + 904, + 905, + 906, + 907, + 908, + 909, + 910, + 911 + ], + "write_ranks": [ + 11, + 18, + 18 + ], + "writes": [ + 18115, + 24878, + 25125 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27815, + "last_write_chronology": 25365, + "pivot": 928, + "post_after_op": 25189, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 8, + 7, + 3 + ], + "role": 9586, + "root_index": 1276, + "targets": [ + 928, + 929, + 930, + 931, + 932, + 933, + 934, + 935 + ], + "write_ranks": [ + 8, + 15, + 18 + ], + "writes": [ + 14591, + 22510, + 25189 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27923, + "last_write_chronology": 25332, + "pivot": 952, + "post_after_op": 25156, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 12, + 3, + 3 + ], + "role": 10291, + "root_index": 1309, + "targets": [ + 952, + 953, + 954, + 955, + 956, + 957, + 958, + 959 + ], + "write_ranks": [ + 12, + 15, + 18 + ], + "writes": [ + 18902, + 22403, + 25156 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27959, + "last_write_chronology": 25321, + "pivot": 960, + "post_after_op": 25145, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 12, + 4, + 2 + ], + "role": 10339, + "root_index": 1320, + "targets": [ + 960, + 961, + 962, + 963, + 964, + 965, + 966, + 967 + ], + "write_ranks": [ + 12, + 16, + 18, + 18 + ], + "writes": [ + 19776, + 22491, + 25050, + 25145 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 28031, + "last_write_chronology": 25188, + "pivot": 976, + "post_after_op": 25012, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 10, + 4, + 4 + ], + "role": 10054, + "root_index": 1342, + "targets": [ + 976, + 977, + 978, + 979, + 980, + 981, + 982, + 983 + ], + "write_ranks": [ + 10, + 10, + 14, + 18 + ], + "writes": [ + 16738, + 16959, + 22416, + 25012 + ] + }, + { + "first_any_old_read": 26054, + "first_pivot_old_read": 28211, + "last_write_chronology": 25387, + "pivot": 1016, + "post_after_op": 25211, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 16, + 2 + ], + "role": 10473, + "root_index": 1397, + "targets": [ + 1016, + 1017, + 1018, + 1019, + 1020, + 1021, + 1022, + 1023 + ], + "write_ranks": [ + 16, + 18 + ], + "writes": [ + 22489, + 25211 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 28247, + "last_write_chronology": 25299, + "pivot": 1024, + "post_after_op": 25123, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 16, + 2 + ], + "role": 10456, + "root_index": 1408, + "targets": [ + 1024, + 1025, + 1026, + 1027, + 1028, + 1029, + 1030, + 1031 + ], + "write_ranks": [ + 16, + 18 + ], + "writes": [ + 21356, + 25123 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 27997, + "last_write_chronology": 25229, + "pivot": 1088, + "post_after_op": 25053, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 15, + 3 + ], + "role": 10458, + "root_index": 1496, + "targets": [ + 1088, + 1089, + 1090, + 1091, + 1092, + 1093, + 1094, + 1095 + ], + "write_ranks": [ + 15, + 18 + ], + "writes": [ + 21365, + 25053 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 28177, + "last_write_chronology": 25241, + "pivot": 1128, + "post_after_op": 25065, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 15, + 3 + ], + "role": 10457, + "root_index": 1551, + "targets": [ + 1128, + 1129, + 1130, + 1131, + 1132, + 1133, + 1134, + 1135 + ], + "write_ranks": [ + 15, + 18 + ], + "writes": [ + 21362, + 25065 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 28213, + "last_write_chronology": 25028, + "pivot": 1136, + "post_after_op": 24852, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 12, + 6 + ], + "role": 10331, + "root_index": 1562, + "targets": [ + 1136, + 1137, + 1138, + 1139, + 1140, + 1141, + 1142, + 1143 + ], + "write_ranks": [ + 12, + 18 + ], + "writes": [ + 19736, + 24852 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 28059, + "last_write_chronology": 25182, + "pivot": 1184, + "post_after_op": 25006, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 4, + 14 + ], + "role": 8962, + "root_index": 1628, + "targets": [ + 1184, + 1185, + 1186, + 1187, + 1188, + 1189, + 1190, + 1191 + ], + "write_ranks": [ + 4, + 18, + 18 + ], + "writes": [ + 13014, + 24950, + 25006 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 28107, + "last_write_chronology": 25248, + "pivot": 1240, + "post_after_op": 25072, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 15, + 3 + ], + "role": 10351, + "root_index": 1705, + "targets": [ + 1240, + 1241, + 1242, + 1243, + 1244, + 1245, + 1246, + 1247 + ], + "write_ranks": [ + 15, + 18 + ], + "writes": [ + 20585, + 25072 + ] + }, + { + "first_any_old_read": 11146, + "first_pivot_old_read": 28289, + "last_write_chronology": 25311, + "pivot": 1304, + "post_after_op": 25135, + "pre_at_phase_cut_after_center_before_old_reads": true, + "prefix_children": [ + 15, + 3 + ], + "role": 10463, + "root_index": 1793, + "targets": [ + 1304, + 1305, + 1306, + 1307, + 1308, + 1309, + 1310, + 1311 + ], + "write_ranks": [ + 15, + 18 + ], + "writes": [ + 21387, + 25135 + ] + } + ], + "status": "AUTHOR_EXACT_FINITE_COMPILER_CHECK_PASS", + "target_histogram": { + "0": 6270, + "1": 3960, + "10": 8, + "11": 2, + "12": 6, + "13": 2, + "14": 4, + "15": 12, + "16": 7, + "18": 1276, + "2": 23, + "3": 16, + "4": 7, + "5": 2, + "6": 7, + "7": 3, + "8": 5, + "9": 1 + }, + "targets_disjoint": true, + "v": 1320 + }, + "terminal_formal": { + "absolute_residual_bound": 394518, + "columns": [ + { + "columns": 13163, + "direction": 1, + "dirty": 10523, + "outputs": true, + "restored": true + }, + { + "columns": 13163, + "direction": -1, + "dirty": 10523, + "outputs": true, + "restored": true + } + ], + "controls": { + "omit-ancestor-response": "REJECTED", + "omit-first-write": "REJECTED", + "omit-pre-shear": "REJECTED" + }, + "digit_bits": 24, + "input_pins": { + "baseline.json.gz": "5975dc6981aa18ac4ba4a1ca290d9163beedc8bc48e9600f4de5390758b57ef9", + "frames.json.gz": "05cf2b64cdc6142294512fcd963285ed535599b433691a547eaf775424f7b104", + "graph.json.gz": "4720aa3bf8960d89fca62cf8dc71dc7c5f8b3b85c59ecae727184ae12e1f7c18", + "physical-frames.json.gz": "bbbe32fb7a5d2415b7b2f130c46d1e20de392ea1cf6587fca6bc015879a3ca4f", + "physical-pairs.json.gz": "33b847e6f40e40809dce1c3eb25afe357b88b0b14c9a5ccca95b78553a595065", + "physical.py": "01961fad4b04aaa940d2dc99c87690bc861b3861200296974c5e065ce3446659", + "profile-before.json.gz": "e41fd008059d8a08d8f3078831e577201acd9f4aa115dd0197e28286cf281c80", + "profile.json.gz": "67de497a9c1ea64bb0cf9dc3ca655e7f9c704452a615f3e7eb45d124ed40c2c1", + "sinks.json": "d56196c9a6c4ed0d0eac660dbf5a7bdfbb118222e954cf2126a90ac0b1c84e6a", + "word.json.gz": "b70c03e2401df03f67bbba36e0c33704bde377902e446831a4df94833e935cc8" + }, + "source_sha256": "d7fefe86e637584ad1bf53c8f7714b88d5abed92eaa29d110ef099536e51f516", + "status": "PASS full modified finite word" + } + }, + "profile": { + "R": 10523, + "W_per_vertex": 13163, + "c": 21909, + "child_histogram": { + "1": 93600, + "10": 2589, + "11": 987, + "12": 3555, + "13": 642, + "14": 2142, + "15": 3255, + "16": 330, + "17": 132, + "18": 7788, + "19": 5829, + "2": 42555, + "20": 561, + "3": 29427, + "4": 10830, + "5": 7044, + "6": 4407, + "7": 2559, + "8": 3675, + "9": 1323 + }, + "deficit_per_vertex": 1320, + "h": 22, + "loss": 440, + "m": 66, + "matched": 12189, + "maxchild": 20, + "q": 3157, + "rank_per_vertex": 867438, + "reuse_pairs": 2310, + "scalar_role_reserve": 12877, + "terminal_sinks": 44, + "total_M_operations": 33466, + "v": 1320 + }, + "status": "PASS" + }, + "kappa": "166261725903847/250000000000000000", + "scope": "Finite word, paid moments, full finite bridge and 47 strict arithmetic constraints; source-specified all-size contracts remain assumptions.", + "status": "PASS conditional finite witness" +} diff --git a/research/complex-bank-run3/references/pr219-run1/references/pr205-packed.certificate.json b/research/complex-bank-run3/references/pr219-run1/references/pr205-packed.certificate.json new file mode 100644 index 0000000000..5d81d4d857 --- /dev/null +++ b/research/complex-bank-run3/references/pr219-run1/references/pr205-packed.certificate.json @@ -0,0 +1,318 @@ +{ + "arithmetic": { + "after_packing": { + "assembly": { + "absorption_gap": "1230914396526348070057671757694860242218455432936619316060414825083637894961901056119952178599407157762533482930751316362407/18531176447982486686713516168120660582877340083228229059612071363228357245238839714890494666744263354886262143344637593000000000000000000000000", + "margins": { + "Gaussian_arithmetic": "20252687142349069112007337816608950117057419648998374718731303825288364153083931753428238433576128978304538856753404536645113737856655362407/29649882316771978698741625868993056932603744133165166495379314181165371592382143543824791466790821367818019429351420148800000000000000000000000", + "balanced_prefix": "12657929463968168195016168120660582877340083228229059612071363228357245238839714890494666744263354886262143344637593/18531176447982486686713516168120660582877340083228229059612071363228357245238839714890494666744263354886262143344637593", + "bulk_exposure": "683528191054281082529874445572053583938529554073260363159021491390399389418070922129694784989/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_phase_layer": "12657929463968168194997636944212600390653369712060938951488485888274017009780102819131438387018116046547252849970848736645113737856655362407/18531176447982486686713516168120660582877340083228229059612071363228357245238839714890494666744263354886262143344637593000000000000000000000000", + "coordinate_movement": "683528191054281082529874445572053583938529554073260363159021491390399389418070922129694784989/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "dimension": "18518518518518518518518500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000/18531176447982486686713516168120660582877340083228229059612071363228357245238839714890494666744263354886262143344637593", + "scalar_work": "101263435711745345560110813788836680532033952309664356235988028486774733681658107052594105596861600250382256262433999736645113737856655362407/148249411583859893493708129344965284663018720665825832476896570905826857961910717719123957333954106839090097146757100744000000000000000000000000" + }, + "minimum_constraint": "683528191054281082529874445572053583938529554073260363159021491390399389418070922129694784989/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "minimum_margin": "12657929463968168194997636944212600390653369712060938951488485888274017009780102819131438387018116046547252849970848736645113737856655362407/18531176447982486686713516168120660582877340083228229059612071363228357245238839714890494666744263354886262143344637593000000000000000000000000", + "parameters": { + "C0": { + "base": 2, + "exponent": 210000 + }, + "C1": 1, + "a_bit": "683528191054281082529874445572053583938529554073260363159021491390399389418070922129694784989/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "a_complex": "700918443859411/1000000000000000000", + "alpha_squared_power": "25315858927936336390013805064873183267993452940289998563559849116631262248619817709626105131281470932809396194608441736645113737856655362407/37062352895964973373427032336241321165754680166456458119224142726456714490477679429780989333488526709772524286689275186000000000000000000000000", + "beta": "1/1000000000000000000000000", + "c": "341764095527140541265061539257835737688182247162184609525926807165645621448672302043356002095110581929077870305215011/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "delta": "1/8000000000000000000000000", + "epsilon": "18518518518518518518518500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000/18531176447982486686713516168120660582877340083228229059612071363228357245238839714890494666744263354886262143344637593", + "eta": "1/1000000000000000000000000", + "kappa": "683061299399923/1000000000000000000", + "lambda_": "999316471808945718917470126237956137470342552975801185208894562447139154683842292236891796605410389418070922129694784989/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime": "499658235904472859458735063460742164262311817752837815390474073192834354378551327697956643997904889418070922129694784989/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q": "341764095527140541264936539257835737688182247162184609525926807165645621448672302043356002095110581929077870305215011/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "sigma": "999299081556140589/1000000000000000000", + "tau": "999316471808945718917470125554427946416061470445926739636840978508609600610581929077870305215011/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "recurrence": { + "internal": "999316471808945718917470125554427946416061470445926739636840978508609600610581929077870305215011/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "leaf": "999299081556140589000000000700918443859411/1000000000000000000000000000000000000000000", + "reservations": "499658235904472859458734938460742164262311817752837815390474073192834354378551327697956643997904889418070922129694784989/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "strict_constraint_count": 47 + }, + "binding": "bit", + "kappa": "683061299399923/1000000000000000000" + }, + "before_packing": { + "binding": "bit", + "kappa": "676882434624733/1000000000000000000" + }, + "bit_after": { + "accepted": { + "lower": "1652402343749999999056756952997375000419712810964287699571400017/1652402343750000000000000000000000000000000000000000000000000000", + "saving": "683528191056257/1000000000000000000", + "strict_gap_lower": "811199161762180042666927876792094464411/225608000000000000000000000000000000000000000000000", + "upper": "550800781249999999685585650999125000139904281294428908032975471/550800781250000000000000000000000000000000000000000000000000000" + }, + "next_excluded": { + "lower": "3304804687500000005034672763894061432592377001145339332563639737/3304804687500000000000000000000000000000000000000000000000000000", + "saving": "341764095528129/500000000000000000", + "strict_gap_lower": "811198689277735346876494889239815434533/225608000000000000000000000000000000000000000000000", + "upper": "1101601562500000001678224254631353810864125688930806470956230843/1101601562500000000000000000000000000000000000000000000000000000" + }, + "saving": "683528191056257/1000000000000000000" + }, + "bit_before": { + "accepted": { + "lower": "3627070312499999993418235504017792380724010039202009964239458157/3627070312500000000000000000000000000000000000000000000000000000", + "saving": "677773948354561/1000000000000000000", + "strict_gap_lower": "817279736326429475597737857961987308799/247608000000000000000000000000000000000000000000000", + "upper": "604511718749999998903039250669632063454001683127402051659849717/604511718750000000000000000000000000000000000000000000000000000" + }, + "next_excluded": { + "lower": "362707031250000000039805296271292744207821944826366581490067837/362707031250000000000000000000000000000000000000000000000000000", + "saving": "338886974177281/500000000000000000", + "strict_gap_lower": "408639629918778816085874153024739085093/123804000000000000000000000000000000000000000000000", + "upper": "31816406250000000003491692655376556509458065856294020665972643/31816406250000000000000000000000000000000000000000000000000000" + }, + "saving": "677773948354561/1000000000000000000" + }, + "bit_coarse_relative_gain": "5754242701696/677773948354561", + "comparison_pr199_kappa": "1693287/2500000000", + "comparison_pr202_kappa": "6768823/10000000000", + "complex": { + "accepted": { + "lower": "265143999999999999505356323836919762528275607173151/265144000000000000000000000000000000000000000000000", + "saving": "700918443859411/1000000000000000000", + "strict_gap_lower": "44967606923916385224702216933483/24104000000000000000000000000000000000000000000000", + "upper": "24103999999999999955032393076083614775297783066517/24104000000000000000000000000000000000000000000000" + }, + "next_excluded": { + "lower": "66286000000000000033428585232057842908390904631703/66286000000000000000000000000000000000000000000000", + "saving": "175229610964853/250000000000000000", + "strict_gap_lower": "-1162733399375924970726640217937/2305600000000000000000000000000000000000000000000", + "upper": "2305600000000000001162733399375924970726640217937/2305600000000000000000000000000000000000000000000" + }, + "saving": "700918443859411/1000000000000000000" + }, + "complex_profile": { + "L": 0, + "N": 1320, + "W": 12052, + "child_multiplicities": { + "1": 87534, + "10": 2790, + "11": 1062, + "12": 3591, + "13": 381, + "14": 2226, + "15": 5637, + "16": 264, + "17": 243, + "18": 7959, + "19": 501, + "2": 39834, + "20": 66, + "3": 29769, + "4": 12627, + "5": 5850, + "6": 4815, + "7": 2118, + "8": 4593, + "9": 1287 + }, + "m": 66, + "maxchild": 20, + "total_rank": 794112 + }, + "controls": [ + "changed rank mass" + ], + "extra_selector_calls": 5368513266, + "kappa_gain_from_packing": "617886477519/100000000000000000", + "ordinary_chain": [ + "677340914792209011106157466449676890973/1000000000000000000000000000000000000000000", + "683523961878504669962213417174292289938411338392698468061/1000000000000000000000000000000000000000000000000000000000000", + "683528188165494781294482383962566136580856823964900515238146164645368707677/1000000000000000000000000000000000000000000000000000000000000000000000000000000", + "683528191054281082529874445572053583938529554073260363159021491390399389418070922129694784989/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "packed_profile": { + "L": 0, + "N": 5808, + "W": 56402, + "child_multiplicities": { + "1": 377316, + "10": 6066, + "11": 3636, + "12": 12186, + "13": 4878, + "14": 11016, + "15": 2592, + "16": 8964, + "17": 4068, + "18": 4842, + "19": 1944, + "2": 175962, + "20": 15840, + "21": 45054, + "22": 20016, + "3": 92790, + "4": 28764, + "5": 24210, + "6": 12456, + "7": 12240, + "8": 7542, + "9": 5256 + }, + "m": 72, + "maxchild": 22, + "total_rank": 4055136 + }, + "relative_gain_over_pr202": "6178999399923/676882300000000", + "scope": "Conditional composition; physical and finite bridge proof dependencies are separate", + "selector_toll_gap": "998632943617889461917470125554427946416061470445926739636840978508609600610581929077870305215011/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "source_commits": { + "bit": "a1175449f34d39ff933d9d8ab23ced1f32b290ec", + "complex": "187e1010ac8b259af8e9b5166f68b64bc27b4b47" + }, + "stock_relative_reduction": "2750/30951", + "unpacked_profile": { + "L": 0, + "N": 1936, + "W": 20634, + "child_multiplicities": { + "1": 125772, + "10": 2022, + "11": 1212, + "12": 4062, + "13": 1626, + "14": 3672, + "15": 864, + "16": 2988, + "17": 1356, + "18": 1614, + "19": 648, + "2": 58654, + "20": 5280, + "21": 15018, + "22": 6672, + "3": 30930, + "4": 9588, + "5": 8070, + "6": 4152, + "60": 2200, + "7": 4080, + "8": 2514, + "9": 1752 + }, + "m": 72, + "maxchild": 60, + "total_rank": 1483712 + } + }, + "bank_controls": { + "formal_columns_per_case": 144, + "rejected": [ + "repeated block mod 9", + "omitted block mod 9", + "repeated block mod 25", + "omitted block mod 25", + "repeated block mod 125", + "omitted block mod 125" + ], + "weighted_partition_cases": 12 + }, + "independent": { + "adjacent_final_grids_checked": 2, + "finite_leaf_levels": 3, + "moment_intervals": { + "bit_after": { + "accepted_lower": "10372297619510143600774466115808210752618127629978432765365716852883069087083/10372297619510143606695298683039808628935694876327943591690240000000000000000", + "accepted_upper": "4148919047804057440309786446323284301047251051991373106147069580996984743701/4148919047804057442678119473215923451574277950531177436676096000000000000000", + "next_lower": "2593074404877535905624218813677885842824923268658416555605315352918239909111/2593074404877535901673824670759952157233923719081985897922560000000000000000", + "next_upper": "10372297619510143622496875254711543371299693074633666222423064981008908984557/10372297619510143606695298683039808628935694876327943591690240000000000000000" + }, + "bit_before": { + "accepted_lower": "569187233824081511627730252557041692036672752449752559704939563312903258519/569187233824081512660590386047950634506203134848456051392512000000000000000", + "accepted_upper": "11383744676481630232554605051140833840733455048995051194100755968406514607593/11383744676481630253211807720959012690124062696969121027850240000000000000000", + "next_lower": "711484042280101890903819824529348498672355089122208648154739471157301989689/711484042280101890825737982559938293132753918560570064240640000000000000000", + "next_upper": "1264860519609070028273457465829952886528631269550593152275310693407253474693/1264860519609070028134645302328779187791562521885457891983360000000000000000" + }, + "complex": { + "accepted_lower": "151303260229760552849231624798695928011617003747957445895984727/151303260229760553131497868256997591293731175633361087898845184", + "accepted_upper": "1664335862527366081341547872785655208127787041227531904856155057/1664335862527366084446476550826973504231042931966971966887297024", + "next_lower": "1664335862527366085285815072313660921079442613294059590682498373/1664335862527366084446476550826973504231042931966971966887297024", + "next_upper": "72362428805537655881991959665811344394758374491046069160122671/72362428805537655845498980470737978444827953563781389864665088" + } + }, + "status": "PASS" + }, + "physical": { + "W": 56402, + "banks": 45842, + "chart_sha256": "22662b8580d62f26f50a7773ac45a40d4ffa8352bba5317ec3b2c0ce5897a810", + "child_histogram": { + "1": 377316, + "10": 6066, + "11": 3636, + "12": 12186, + "13": 4878, + "14": 11016, + "15": 2592, + "16": 8964, + "17": 4068, + "18": 4842, + "19": 1944, + "2": 175962, + "20": 15840, + "21": 45054, + "22": 20016, + "3": 92790, + "4": 28764, + "5": 24210, + "6": 12456, + "7": 12240, + "8": 7542, + "9": 5256 + }, + "color_stats": { + "longest_swapped_path": 11, + "swaps": 733 + }, + "conflicting_assignment_rejected": true, + "conservative_selector_calls": 5368513266, + "copies": 3, + "deficit": 5808, + "distinct_gauges": 220, + "gauge_roles": 2200, + "incidence_sha256": "76bff256b747bd188fdfa679059c8340cab7d8e1208db4b818d770ea08711117", + "incidences": 154026, + "interior_splices": 1760, + "m": 72, + "max_chart_factors": 171, + "max_den": 18, + "max_num": 5, + "maxchild": 22, + "patterns": [ + { + "count": 3300, + "rank24": 2, + "rank4": 6 + }, + { + "count": 42542, + "rank24": 3, + "rank4": 0 + } + ], + "physical_roles": 17114, + "rank_mass": 4055136, + "source_package": "research/paired-cube-diagonal-bit-168", + "status": "PASS exact actual-chain chart and incidence checks", + "terminal_sinks": 34, + "word_sha256": "0728ed1c7320430a87709b1034485cbabefec85d532b48897f74136cf3954218" + }, + "pinned_bit_files": 2242 +} diff --git a/research/complex-bank-run3/references/pr219-run1/schedule.py b/research/complex-bank-run3/references/pr219-run1/schedule.py new file mode 100644 index 0000000000..70c03e7964 --- /dev/null +++ b/research/complex-bank-run3/references/pr219-run1/schedule.py @@ -0,0 +1,130 @@ +#!/usr/bin/env python3 +"""Bank-absorption schedule for the rank-22 residual family on the PR200/PR205 bit word. + +Everything here is exact integer / rational arithmetic on pinned inputs: +the enumerated rank-22 increment occurrences (inputs/absorbed-occurrences.json), +PR200's bit certificate (references/pr200-bit.certificate.json) and PR205's packed +certificate (references/pr205-packed.certificate.json). + +What this builds (all machine-checked here): + * the absorbed family's exact inventory, with chain/frame provenance; + * the whole-bank volume condition and the bank count it implies; + * the retained child ledger and the row identity W*m - mass = D; + * candidate block tilings of width m=72 mixing the word's residual families + (4 and 24) with the new 22-blocks, and the divisibility of their patterns. + +What this does NOT build: the physical realization of the new residual type +(formal columns, charts, normalizers, routing, prime witnesses). See +obligations.json and PROOF.md. +""" +import json +import sys +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.dont_write_bytecode = True +if hasattr(sys, 'set_int_max_str_digits'): + sys.set_int_max_str_digits(0) + +M = 72 +NEW_RANK = 22 + + +def _int(x): + assert isinstance(x, int) + return x + + +def build(): + occ = json.loads((HERE / 'inputs/absorbed-occurrences.json').read_text()) + bit = json.loads((HERE / 'references/pr200-bit.certificate.json').read_text())['bit'] + pack = json.loads((HERE / 'references/pr205-packed.certificate.json').read_text())['physical'] + + # --- 1. inventory of the absorbed family ----------------------------------- + per_vertex = occ['counts_per_vertex'] + counts = { + 'physical_internal_chain_jumps': len(occ['occurrences_per_vertex']['H']), + 'copied_centre_children': len(occ['occurrences_per_vertex']['H_center']), + 'physical_target_jumps': len(occ['occurrences_per_vertex']['Y']), + 'source_chain_jumps': len(occ['occurrences_per_vertex']['src']), + } + listed = sum(counts.values()) + assert listed == per_vertex['physical_internal_H'] + per_vertex['physical_target_Y'] \ + + per_vertex['source_chain_src'] == 2224, counts + hist = {int(r): int(n) for r, n in bit['profile']['child_histogram'].items()} + assert hist[NEW_RANK] == per_vertex['ledger_bin_22_per_vertex'] == 3 * listed, hist[NEW_RANK] + normalization = 3 + occurrences = normalization * hist[NEW_RANK] # 20,016 three-copy normalization + volume = NEW_RANK * occurrences # 440,352 registers of dirt + + # --- 2. whole-bank volume condition --------------------------------------- + assert volume % M == 0, 'absorbed volume must fill whole banks' + banks = volume // M # 6,116 + assert banks == 6116 + + # --- 3. retained ledger and row identity ---------------------------------- + kept = {int(r): int(n) for r, n in pack['child_histogram'].items()} + assert kept[NEW_RANK] == occurrences + kept.pop(NEW_RANK) + mass_before = int(pack['rank_mass']) + assert sum(r * n for r, n in {int(r): int(n) for r, n in pack['child_histogram'].items()}.items()) == mass_before + mass = mass_before - volume + D = int(pack['deficit']) + W = int(pack['W']) + W_new = (mass + D) // M + assert M * W_new == mass + D, 'row identity after absorption' + assert W_new == W - banks == 50286 + assert sum(r * n for r, n in kept.items()) == mass + assert max(kept) == 21 + + # --- 4. block tilings of the bank width ----------------------------------- + # A bank is a coordinate-block partition of width 72. The word's own residual + # families are 4 and 24; the new type contributes 22-blocks. Every tiling of 72 + # over {4, 24, 22} using at least one 22-block: + patterns = [] + for c in range(1, 4): + for b in range(0, 4): + for a in range(0, 19): + if 4 * a + 24 * b + 22 * c == 72: + patterns.append(dict(rank4=a, rank24=b, rank22=c, blocks=a + b + c)) + patterns.sort(key=lambda p: (p['rank22'], p['rank4'], p['rank24'])) + assert patterns, 'no certified-shape tiling' + # Divisibility of the absorbed occurrence count under uniform 22-block banks: + uniform22 = [dict(pattern=p, exact_full_banks=(occurrences % p['rank22'] == 0), + banks_if_pattern=occurrences / p['rank22'] if occurrences % p['rank22'] == 0 else None) + for p in patterns] + fills = [u for u in uniform22 if u['exact_full_banks']] + assert fills, 'no pattern divides the absorbed occurrence count' + + schedule = { + 'status': 'bank-absorption schedule, accounting and tiling invariants; ' + 'no physical column, chart or prime witness is built here', + 'absorbed_family': { + 'rank': NEW_RANK, + 'provenance_counts_per_vertex': counts, + 'ledger_bin_per_vertex': hist[NEW_RANK], + 'normalization_factor': normalization, + 'occurrences_three_copies': occurrences, + 'dirt_volume_registers': volume, + }, + 'banks': dict(width=M, banks_from_volume=banks, volume=M * banks, + whole_bank_condition=True), + 'retained_profile': dict(m=M, W_before=W, W_after=W_new, deficit=D, + rank_mass_before=mass_before, rank_mass_after=mass, + children_before=int(pack['children']) if 'children' in pack else sum( + int(n) for n in pack['child_histogram'].values()), + children_after=sum(kept.values()), + maxchild=max(kept), + histogram={str(r): n for r, n in sorted(kept.items())}), + 'row_identity': dict(before=f'{M}*{W} - {mass_before} = {D}', + after=f'{M}*{W_new} - {mass} = {D}', stock_drop=W - W_new, + stock_drop_equals_banks=(W - W_new == banks)), + 'block_tilings': dict(patterns=patterns, uniform_22_block_banks=uniform22, + feasible_patterns=[u['pattern'] for u in fills]), + } + return schedule + + +if __name__ == '__main__': + out = build() + print(json.dumps(out, indent=1, sort_keys=True)) diff --git a/research/complex-bank-run3/references/pr219-run1/verify.py b/research/complex-bank-run3/references/pr219-run1/verify.py new file mode 100644 index 0000000000..88e150293f --- /dev/null +++ b/research/complex-bank-run3/references/pr219-run1/verify.py @@ -0,0 +1,121 @@ +#!/usr/bin/env python3 +"""Offline verification of the rank-22 bank-absorption accounting construction. + +Read-only unless --write: pins every vendored input byte, rebuilds the absorption +schedule and the exact arithmetic from those inputs, and reproduces certificate.json. + + python3 -B verify.py # check + python3 -B verify.py --write # authoring: regenerate certificate.json and SOURCE.json + +The physical realization obligations (R1-R4, obligations.json) are checked for +presence and are NOT discharged here; the certificate's scope says so literally. +""" +import argparse +import json +import sys +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.dont_write_bytecode = True +sys.path.insert(0, str(HERE)) +if hasattr(sys, 'set_int_max_str_digits'): + sys.set_int_max_str_digits(0) + +PINNED = [ + 'inputs/absorbed-occurrences.json', + 'references/pr193-source-assisted-v4.certificate.json', + 'references/pr200-bit.certificate.json', + 'references/pr205-packed.certificate.json', + 'interval_moment.py', + 'paired_cube_assembly.py', + 'banks.py', + 'obligations.json', +] + + +def digest(path): + return sha256(path.read_bytes()).hexdigest() + + +def pins(): + manifest = json.loads((HERE / 'SOURCE.json').read_text()) + actual = {name: digest(HERE / name) for name in PINNED} + assert actual == manifest['files'], 'Pinned input bytes changed' + return actual + + +def serial(value): + if isinstance(value, Q): + return str(value) + if isinstance(value, dict): + return {str(k): serial(v) for k, v in value.items()} + if isinstance(value, (list, tuple)): + return [serial(v) for v in value] + return value + + +def build(): + import schedule as sched + import arithmetic as arith + schedule = sched.build() + arith_result = arith.build(schedule) + obligations = json.loads((HERE / 'obligations.json').read_text()) + open_ids = [o['id'] for o in obligations['obligations']] + assert open_ids == ['R1', 'R2', 'R3', 'R4'] and all(o['status'] == 'OPEN' for o in obligations['obligations']) + occ = json.loads((HERE / 'inputs/absorbed-occurrences.json').read_text()) + kappa = arith_result['after_assembly']['kappa'] + record = { + 'status': 'CONDITIONAL accounting construction for the rank-22 bank absorption: ' + 'schedule, retained ledger, whole-bank volume, exact paid moments, finite ' + 'ordinary composition and balanced assembly are certified here; the physical ' + 'realization obligations R1-R4 (obligations.json) are OPEN and the kappa below ' + 'is conditional on them. Not a completed finite witness; not an unconditional ' + 'multiplication theorem.', + 'kappa': kappa, + 'decimal': float(kappa), + 'binding': arith_result['after_assembly']['binding'], + 'new_residual_type': { + 'rank': schedule['absorbed_family']['rank'], + 'occurrences_three_copies': schedule['absorbed_family']['occurrences_three_copies'], + 'dirt_volume_registers': schedule['absorbed_family']['dirt_volume_registers'], + 'banks': schedule['banks']['banks_from_volume'], + 'provenance_counts_per_vertex': schedule['absorbed_family']['provenance_counts_per_vertex'], + }, + 'schedule': schedule, + 'arithmetic': arith_result, + 'obligations': open_ids, + 'comparison': { + 'main_reviewed_kappa': '330942774629799/500000000000000000', + 'pr205_packed_kappa': '683061299399923/1000000000000000000', + 'pr208_priced_rung1_target': '7004273/10^10', + 'complex_cap': str(arith_result['complex_coarse']), + }, + 'source_pins': {name: digest(HERE / name) for name in PINNED}, + } + return serial(record) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', action='store_true', help='authoring: regenerate certificate.json') + args = parser.parse_args() + assert not sys.flags.optimize, 'assertions must stay enabled' + before = None if args.write else pins() + record = build() + target = HERE / 'certificate.json' + if args.write: + manifest = {'files': {name: digest(HERE / name) for name in PINNED}} + (HERE / 'SOURCE.json').write_text(json.dumps(manifest, indent=1, sort_keys=True) + '\n') + target.write_text(json.dumps(record, indent=1, sort_keys=True) + '\n') + else: + assert record == json.loads(target.read_text()), 'certificate.json differs' + assert pins() == before, 'inputs changed during verification' + print('PASS rank-22 absorption schedule, retained ledger, whole-bank volume, exact moments, ' + 'ordinary composition, 47-constraint assembly; obligations R1-R4 open') + print('conditional kappa = ' + str(record['kappa'])) + + +if __name__ == '__main__': + main() diff --git a/research/complex-bank-run3/run3.py b/research/complex-bank-run3/run3.py new file mode 100644 index 0000000000..cd8c93862a --- /dev/null +++ b/research/complex-bank-run3/run3.py @@ -0,0 +1,396 @@ +#!/usr/bin/env python3 +"""Rungs 3 and 4 of the bank ladder: the complex ledger's bankable remainder, priced. + +Rung 2 (PR224, `research/complex-bank-run2`) absorbs the complex word's rank-11 family and +lands on the *new* complex ceiling, so every further rung must again raise the complex +coarse saving. This package prices the rest of that ledger, exactly: + +* **rung 3** absorbs the complex rank-16 family (264 children per vertex, volume + 12,672 = 66 * 192 whole banks) on top of rung 2; +* **rung 4** adds the rank-20 family (66 per vertex, volume 3,960 = 66 * 60) and is the + **top of the complex-side ladder**: after it no family of the remaining ledger has a + whole-bank volume, so the accounting criterion the built rungs use is exhausted. + +What this script does, all in exact rational arithmetic from pinned inputs: + +1. **Calibration, frontier (#207).** Reproduces #207's published `kappa` from its own + `a_bit`/`a_complex` in the assembly convention of the queue's latest rungs + (`eta = beta = 10^-24`, `weak = 10^-30`, `10^-18` grid) -- exactly, not to a tolerance. +2. **Calibration, rung 1 (#219).** Rebuilds rung 1 by importing the vendored #219 package + itself (`references/pr219-run1/`), reproducing its published + `kappa = 700427501305159/10^18` and its complex-ceiling landing. +3. **Calibration, rung 2 (#224).** Rebuilds rung 2 (`ledger3.py`) from the pinned complex + profile, reproducing PR224's published complex coarse saving and grid point exactly. +4. **Rungs 3 and 4** (`ledger3.py`): whole-bank volume, retained row identity, stock drop + equal to the bank count, both paid moments, and the eligibility scan that shows the + ladder's top. +5. **The assemblies**: PR184/#219's unchanged 47-constraint assembly at each rung's budget, + with the adjacent `10^-18` point rejected and the ceiling gap recorded. +6. **What beating the top would take**: the complex coarse saving each round target needs, + and the point at which the bit branch starts binding instead. +7. **The blocker**, as facts rather than assertions (`obligations.json` C1-C7 + T1, plus + #219's inherited R1-R4). + + python3 -B run3.py [--out certificate.json] +""" +import argparse +import json +import sys +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.dont_write_bytecode = True +if str(HERE) not in sys.path: + sys.path.insert(0, str(HERE)) + +import ledger3 # noqa: E402 (local module, imported after the path is set) +import pins # noqa: E402 + +REFERENCES = HERE / 'references' +FRONTIER = REFERENCES / 'pr207-coordinated-crossover.certificate.json' +PR193 = REFERENCES / 'pr219-run1' / 'references' / 'pr193-source-assisted-v4.certificate.json' +PR205 = REFERENCES / 'pr219-run1' / 'references' / 'pr205-packed.certificate.json' + +# The convention of the queue's latest rungs (#207, #219, #224). +ETA = BETA = Q(1, 10 ** 24) +WEAK = Q(1, 10 ** 30) +GRID = 10 ** 18 +# The convention of PR208's pricing model, for the independent replica. +STOP_208 = Q(1, 10 ** 9) +ETA_208 = Q(1, 10 ** 8) +GRID_208 = 10 ** 10 +RUN1_KAPPA = Q(700427501305159, 10 ** 18) # #219's published rung-1 claim +RUN2_KAPPA = Q(354145785295363, 5 * 10 ** 17) # PR224's published rung-2 claim +RUN2_COARSE = Q(708793603125109, 10 ** 18) # PR224's published rung-2 coarse saving +RUN2_REPLICA = Q(3541457, 5 * 10 ** 9) # PR208's priced rung-2 target +RUNGS = (11, 16, 20) # every whole-bank family of this ledger +TARGETS = (Q(72, 10 ** 5), Q(75, 10 ** 5), Q(8, 10 ** 3), Q(1, 10 ** 3)) + + +def frontier_kappa(bit_saving, complex_saving): + """The queue's assembly rule: budget, closed-form bound, floor to the grid.""" + a = min(bit_saving, (1 - BETA) * complex_saving - WEAK) + q = a * (1 - 2 * ETA) + bound = (1 - ETA) * q / (1 + q) + z = bound * GRID + return a, bound, Q((z.numerator - 1) // z.denominator, GRID) + + +def replica_kappa(bit_saving, complex_saving): + """PR208's convention, on its own grid.""" + budget = min(bit_saving, (1 - STOP_208) * complex_saving - Q(1, GRID_208)) + q = budget * (1 - 2 * ETA_208) + minimum = (1 - ETA_208) * q / (1 + q) + kappa = Q(minimum.numerator * GRID_208 // minimum.denominator, GRID_208) + if kappa == minimum: + kappa -= Q(1, GRID_208) + return budget, minimum, kappa + + +def kappa_of_budget(budget): + """The queue's assembly rule on a given budget, floored to the 10^-18 grid.""" + q = budget * (1 - 2 * ETA) + z = ((1 - ETA) * q / (1 + q)) * GRID + return Q((z.numerator - 1) // z.denominator, GRID) + + +def complex_for_target(target, bit_leaf): + """The smallest complex coarse saving on the 10^-18 grid that reaches `target`. + + `kappa` is monotone in the budget, so bisect the budget on the grid, then read the + complex coarse saving that produces it (`a = (1 - beta) * C - weak`) and round up. + The bit leaf is what stops the search when it is the smaller branch there. + """ + low, high = 1, GRID # budget units on the 10^-18 grid + assert kappa_of_budget(Q(high, GRID)) >= target, 'target above the assembly bound' + while low < high: + mid = (low + high) // 2 + if kappa_of_budget(Q(mid, GRID)) >= target: + high = mid + else: + low = mid + 1 + budget = Q(low, GRID) + if Q(bit_leaf) < budget: + # No complex saving can reach the target while the bit branch is the smaller + # one: the budget itself is capped by the bit leaf, so a new bit word is needed. + return dict(target=str(target), budget=str(budget), coarse=None, kappa=None, + binding='bit', needs_new_bit=True, + kappa_at_the_bit_ceiling=str(kappa_of_budget(Q(bit_leaf))), + required_bit_leaf=str(budget)) + exact = (budget + WEAK) / (1 - BETA) + z = exact * GRID + coarse = Q(-((-z.numerator) // z.denominator), GRID) # ceil to the grid + a, _, kappa = frontier_kappa(bit_leaf, coarse) + assert (a == (1 - BETA) * coarse - WEAK) or a == Q(bit_leaf), 'branch identity' + if a != Q(bit_leaf): + assert kappa >= target, 'the rounded grid point must reach the target' + return dict(target=str(target), budget=str(budget), coarse=str(coarse), + coarse_decimal=float(coarse), kappa=str(kappa), + binding='complex' if a == (1 - BETA) * coarse - WEAK else 'bit', + needs_new_bit=(a != (1 - BETA) * coarse - WEAK)) + + +def serial(value): + if isinstance(value, Q): + return str(value) + if isinstance(value, dict): + return {str(k): serial(v) for k, v in value.items()} + if isinstance(value, (list, tuple)): + return [serial(v) for v in value] + return value + + +def bank_evidence(): + """What the pins say about bank constructions, read rather than assumed.""" + supplier = json.loads(PR193.read_text()) + frontier = json.loads(FRONTIER.read_text()) + + def keys_with(node, needle): + found = [] + + def walk(value, path): + if isinstance(value, dict): + for key, child in value.items(): + walk(child, path + '/' + str(key)) + elif isinstance(value, list) and value and isinstance(value[0], (dict, list)): + walk(value[0], path + '[0]') + else: + if needle in path.lower(): + found.append(path) + walk(node, '') + return sorted(found) + + packed = json.loads(PR205.read_text()) + return dict( + complex_supplier_has_bank_keys=keys_with(supplier, 'bank'), + frontier_certificate_has_bank_keys=keys_with(frontier, 'bank'), + pinned_bit_bank_construction=dict( + source='references/pr219-run1/references/pr205-packed.certificate.json (#205)', + physical_banks=int(packed['physical']['banks']), + physical_copies=packed['physical']['copies'], + gauge_roles=packed['physical']['gauge_roles'], + distinct_gauges=packed['physical']['distinct_gauges'], + bank_controls_keys=sorted(packed['bank_controls']), + note="the pinned construction banks the bit word's selected entrance-gauge " + 'exteriors into width-72 banks; it is the only bank construction in the ' + 'pins'), + complex_family_inventory=None, + complex_family_inventory_note='the only occurrence inventory in the pins is ' + "#219's bit-side inputs/absorbed-occurrences.json " + '(rank 22); the complex rank-11 family of PR224, and ' + 'the rank-16 and rank-20 families this package ' + 'absorbs, have no such enumeration, so the ' + 'item-to-block map of C1 has no starting inventory', + ) + + +def assemble(supplier, budget, complex_saving, kappa): + """PR184/#219's unchanged 47-constraint assembly at a given grid point.""" + assembly = ledger3.load('run3_assembly', ledger3.RUN1 / 'paired_cube_assembly.py') + out = assembly.assembly(budget, complex_saving, supplier['assembly']['finite_bridge'], + kappa, eta=ETA, beta=BETA) + assert len(out['strict_constraints']) == 47 and len(out['margins']) == 7 + return dict(minimum_constraint=min(out['strict_constraints'].values())) + + +def rung_record(supplier, step, leaf, index): + """Price one rung's assembly and record the ledger around it.""" + coarse = Q(step['saving']) + budget, bound, kappa = frontier_kappa(leaf, coarse) + out = assemble(supplier, budget, coarse, kappa) + rejected = True + try: + assemble(supplier, budget, coarse, kappa + Q(1, GRID)) + except AssertionError: + pass + else: + rejected = False + assert rejected, 'the adjacent 10^-18 point must be rejected' + ceiling = ledger3.ceiling(coarse) + assert 0 <= ceiling - kappa < Q(1, GRID), 'the rung must sit on its own ceiling' + return dict(rung=index, family=step['family'], kappa=kappa, coarse=coarse, + binding='complex' if budget == (1 - BETA) * coarse - WEAK else 'bit', + complex_ceiling=ceiling, ceiling_gap=ceiling - kappa, + bit_leaf_headroom=Q(leaf) - budget, assembly=out, + adjacent_grid_rejected=rejected) + + +def build(): + interval = ledger3.engine() + schedule, arithmetic = ledger3.run1() + frontier = json.loads(FRONTIER.read_text()) + supplier = json.loads(PR193.read_text()) + supplier['assembly']['finite_bridge']['rows']['degree_gap'] = Q( + supplier['assembly']['finite_bridge']['rows']['degree_gap']) + + # --- 1. the frontier's own number, in this convention ---------------------- + a_bit = Q(frontier['a_bit']) + a_complex = Q(frontier['a_complex']) + _, _, frontier_published = frontier_kappa(a_bit, a_complex) + assert frontier_published == Q(frontier['kappa']), 'the frontier claim must reproduce' + calibration_frontier = dict( + published=str(Q(frontier['kappa'])), reproduced=str(frontier_published), equal=True, + a_bit=str(a_bit), a_complex=str(a_complex), binding=frontier['binding']) + + # --- 2. rung 1, rebuilt by #219's own vendored code ------------------------ + result1 = arithmetic.build(schedule.build()) + kappa1 = result1['after_assembly']['kappa'] + assert kappa1 == RUN1_KAPPA, "rung 1 must reproduce #219's published grid point" + assert result1['after_assembly']['binding'] == 'complex', 'rung 1 binds on complex' + complex_coarse_1 = result1['complex_coarse'] + ceiling_1 = ledger3.ceiling(complex_coarse_1) + assert 0 <= ceiling_1 - kappa1 < Q(1, GRID), 'rung 1 sits on the complex ceiling' + leaf = result1['ordinary_leaf'] + calibration_run1 = dict( + published=str(RUN1_KAPPA), reproduced=str(kappa1), equal=True, + binding='complex', complex_coarse=str(complex_coarse_1), + complex_ceiling=str(ceiling_1), ceiling_gap=str(ceiling_1 - kappa1), + bit_leaf=str(leaf), bit_coarse_after=str(result1['bit_coarse_after']), + conclusion='rung 1 already sits on the complex branch ceiling, so every further ' + 'rung has to raise the complex supplier\'s own coarse saving') + + # --- 3. the complex side: base, rung 2, rungs 3 and 4 --------------------- + part = ledger3.side(FRONTIER, interval, RUNGS) + assert Q(part['base_saving']) == a_complex, \ + 'the pinned complex supplier is the one the frontier prices' + assert [step['family'] for step in part['ladder']] == list(RUNGS), 'rung order' + assert Q(part['ladder'][0]['saving']) == RUN2_COARSE, "rung 2 must reproduce PR224" + assert part['final_eligibility'] == [], 'the ladder must be exhausted at the top' + + rungs = [rung_record(supplier, step, leaf, index + 3) + for index, step in enumerate(part['ladder'][1:])] + top = rungs[-1] + kappa_top, coarse_top = top['kappa'], top['coarse'] + assert coarse_top == Q(part['final_saving']) == Q(part['ladder'][-1]['saving']) + assert kappa_top > RUN2_KAPPA, 'the top rung must beat rung 2' + + # --- 4. the independent replica at PR208's convention --------------------- + bit_row = ledger3.profile(frontier['bit_profile']) + ledger3.check_row(bit_row) + bit_absorbed = ledger3.absorb(ledger3.three_copies(bit_row), 22) + bit_coarse = arithmetic.certify(interval, bit_absorbed['retained'], True)['saving'] + replica = [] + for index, step in enumerate(part['ladder']): + _, _, value = replica_kappa(bit_coarse, Q(step['saving'])) + replica.append(dict(family=step['family'], kind='rung %d' % (index + 2), + kappa=str(value), published=('3541457/5000000000' + if index == 0 else None), + matches_published=(value == RUN2_REPLICA if index == 0 else None))) + assert replica[0]['matches_published'] is True, "PR208's priced rung 2 must reproduce" + + # --- 5. what beating the top would take ---------------------------------- + supplier_field = Q(supplier['complex_saving']) + assert supplier_field < a_complex, 'the supplier field sits below the certified moment' + _budget_c, _bound_c, conservative_top = frontier_kappa(leaf, supplier_field + ( + coarse_top - Q(part['ladder'][0]['saving']))) + needs = [] + for target in TARGETS: + info = complex_for_target(target, leaf) + info['gain_vs_top'] = (Q(info['coarse']) / coarse_top - 1 + if info['coarse'] is not None else None) + needs.append(info) + + certificate = dict( + status='MODEL AND TARGET, NOT CONSTRUCTED: the rung-3 and rung-4 ledgers ' + '(whole-bank volume, retained row identities, stock drops, both paid ' + 'moments on the 10^-18 grid, the two 47-constraint assemblies) are certified ' + 'here, but every rung above rung 2 needs a bank construction on the complex ' + 'supplier that no package in the pins provides (obligations.json C1-C7 and ' + "T1, plus #219's inherited R1-R4). The kappa below is conditional on those " + 'and is not a completed finite witness.', + rung=4, + kappa=kappa_top, decimal=float(kappa_top), binding=top['binding'], + gain_vs_rung1=kappa_top / RUN1_KAPPA - 1, + gain_vs_rung2=kappa_top / RUN2_KAPPA - 1, + gain_vs_frontier=kappa_top / Q(frontier['kappa']) - 1, + calibrations=dict(frontier=calibration_frontier, run1=calibration_run1, + run2=dict(published=str(RUN2_KAPPA), reproduced=str( + Q(part['ladder'][0]['saving'])), equal=True, + coarse=str(RUN2_COARSE), + note='rebuilt here by this package\'s own ledger module ' + 'from the pinned complex profile, not imported')), + ledgers=part, + rungs=rungs, + replica=replica, + top=dict(kappa=str(kappa_top), coarse=str(coarse_top), binding=top['binding'], + families_absorbed=list(RUNGS), banks=sum(step['banks'] + for step in part['ladder']), + stock=part['final_row']['W'], rank_mass=part['final_row']['mass'], + children=part['final_row']['children'], + families_left=part['final_row']['families'], + largest_child=part['final_row']['maxchild'], + eligibility_exhausted=True, + ceiling=str(top['complex_ceiling']), ceiling_gap=str(top['ceiling_gap']), + note='no family of the remaining complex ledger has a whole-bank volume, ' + 'so the accounting criterion the built rungs use cannot be applied ' + 'again without a different bank width or a mixed tiling that reopens ' + 'the volume condition'), + needed_for=needs, + conservative_variant=dict( + supplier_field=str(supplier_field), certified_moment=str(a_complex), + delta=str(supplier_field - a_complex), + top_kappa_on_the_field=str(conservative_top), + note='PR193 publishes 219037/312500000 = 7.009184e-4, its value on the 10^-10 ' + 'grid, 4.3859411e-11 below the 10^-18 certified paid moment of the same ' + 'profile; the ladder above is priced on the certified moment, which #207 ' + "and #219's rung 1 also price. A reviewer who prefers the coarser field " + 'sees a smaller top rung: recorded here rather than hidden.'), + blocked_on=bank_evidence(), + obligations=['C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'T1', 'R1', 'R2', 'R3', 'R4'], + comparison=dict(rung1=str(RUN1_KAPPA), rung2=str(RUN2_KAPPA), frontier=str( + Q(frontier['kappa'])), pr208_priced_rung2=str(RUN2_REPLICA)), + source_pins=pins.manifest(), + ) + return certificate + + +def main(): + parser = argparse.ArgumentParser(description=__doc__, + formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument('--out', type=Path, default=HERE / 'certificate.json') + args = parser.parse_args() + sys.set_int_max_str_digits(0) + assert not sys.flags.optimize, 'assertions must stay enabled' + record = serial(build()) + args.out.write_text(json.dumps(record, indent=1, sort_keys=True) + '\n', newline='\n') + print('frontier kappa = %s (reproduced exactly)' % record['calibrations']['frontier']['published']) + print('rung 1 kappa = %s (binding complex, ceiling gap %s)' + % (record['calibrations']['run1']['published'], + record['calibrations']['run1']['ceiling_gap'])) + print('rung 2 coarse %s, kappa %s (reproduced exactly)' + % (record['calibrations']['run2']['coarse'], record['calibrations']['run2']['published'])) + for step, rung in zip(record['ledgers']['ladder'][1:], record['rungs']): + print('rung %d rank %-3s volume %-7s = %-4s banks coarse %-19s kappa %-19s %+.4f%% vs rung 2' + % (rung['rung'], step['family'], step['volume'], step['banks'], step['saving'], + rung['kappa'], float(Q(rung['kappa']) / RUN2_KAPPA - 1) * 100)) + print('top kappa = %s = %.17g (binding %s, %+.4f%% over rung 1, %+.4f%% over rung 2, ' + '%+.4f%% over the frontier)' + % (record['kappa'], float(Q(record['kappa'])), record['binding'], + float(Q(record['gain_vs_rung1'])) * 100, float(Q(record['gain_vs_rung2'])) * 100, + float(Q(record['gain_vs_frontier'])) * 100)) + print('top row W=%s rank mass=%s children=%s families=%s largest child=%s' + % (record['top']['stock'], record['top']['rank_mass'], record['top']['children'], + record['top']['families_left'], record['top']['largest_child'])) + print('exhausted %s (families with a whole-bank volume left)' % record['ledgers']['final_eligibility']) + for need in record['needed_for']: + if need['coarse'] is None: + print('to reach %-8s needs a NEW BIT WORD: the bit leaf %s caps the budget at %s ' + 'and the target needs %s on the bit side' + % (need['target'], record['calibrations']['run1']['bit_leaf'][:12] + '...', + need['kappa_at_the_bit_ceiling'], need['required_bit_leaf'])) + else: + print('to reach %-8s needs complex coarse %-20s (%+.3f%% over the top, binding %s)' + % (need['target'], need['coarse'], float(Q(need['gain_vs_top'])) * 100, + need['binding'])) + print('replica rung 2 %s matches PR208: %s; rungs 3/4 %s' + % (record['replica'][0]['kappa'], record['replica'][0]['matches_published'], + [r['kappa'] for r in record['replica'][1:]])) + print('blocked complex supplier bank keys: %s; pinned bit bank construction: %s banks' + % (record['blocked_on']['complex_supplier_has_bank_keys'], + record['blocked_on']['pinned_bit_bank_construction']['physical_banks'])) + print('write ' + str(args.out)) + + +if __name__ == '__main__': + main() diff --git a/research/complex-bank-run3/verify.py b/research/complex-bank-run3/verify.py new file mode 100644 index 0000000000..76c3dc5870 --- /dev/null +++ b/research/complex-bank-run3/verify.py @@ -0,0 +1,97 @@ +#!/usr/bin/env python3 +"""Offline verification of the rungs 3 and 4 ledgers, their prices and their assemblies. + +Read-only unless `--write`: pins every vendored byte, rebuilds the whole complex-side ladder +(base, rung 2, rungs 3 and 4), both paid moments per rung, the two 47-constraint assemblies, +the PR208-convention replica and the eligibility scan, and compares the result with +`certificate.json`. + + python3 -B verify.py # check + python3 -B verify.py --write # authoring: regenerate certificate.json and SOURCE.json + +The complex-side bank construction obligations (C1-C7 and T1 in `obligations.json`, plus the +inherited R1-R4 of #219) are checked for presence and are **not** discharged here; the +certificate's scope says so literally. Passing this script means the accounting is +consistent and the prices are exact -- not that the rung is physical. +""" +import argparse +import json +import sys +from hashlib import sha256 +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.dont_write_bytecode = True +sys.path.insert(0, str(HERE)) +if hasattr(sys, 'set_int_max_str_digits'): + sys.set_int_max_str_digits(0) + +import pins # noqa: E402 +import run3 # noqa: E402 + + +def digest(path): + return sha256(Path(path).read_bytes()).hexdigest() + + +def read_manifest(): + return json.loads((HERE / 'SOURCE.json').read_text())['files'] + + +def check_manifest(): + actual = pins.manifest() + assert actual == read_manifest(), 'pinned input bytes changed' + return actual + + +def check_obligations(): + obligations = json.loads((HERE / 'obligations.json').read_text()) + owed = [item['id'] for item in obligations['obligations']] + assert owed == ['C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'T1'], owed + assert all(item['status'] == 'OPEN' for item in obligations['obligations']) + inherited = [item['id'] for item in obligations['inherited']] + assert inherited == ['R1', 'R2', 'R3', 'R4'], inherited + assert all(item['status'] == 'OPEN' for item in obligations['inherited']) + vendored = json.loads((HERE / 'references' / 'pr219-run1' / 'obligations.json').read_text()) + assert [item['id'] for item in vendored['obligations']] == inherited, \ + "the inherited obligation set must be #219's own" + certificate = json.loads((HERE / 'certificate.json').read_text()) \ + if (HERE / 'certificate.json').exists() else {} + if certificate: + assert certificate['obligations'] == owed + inherited, 'certificate obligation list' + assert not any('bank' in key for key in certificate['blocked_on'] + ['complex_supplier_has_bank_keys']), \ + 'the complex supplier must still have no bank keys' + return owed + inherited + + +def main(): + parser = argparse.ArgumentParser(description=__doc__, + formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument('--write', action='store_true', + help='authoring: regenerate certificate.json and SOURCE.json') + args = parser.parse_args() + assert not sys.flags.optimize, 'assertions must stay enabled' + + if not args.write: + check_manifest() + record = run3.build() + check_obligations() + target = HERE / 'certificate.json' + if args.write: + (HERE / 'SOURCE.json').write_text( + json.dumps({'files': pins.manifest()}, indent=1, sort_keys=True) + '\n', + newline='\n') + target.write_text(json.dumps(record, indent=1, sort_keys=True, default=str) + '\n', + newline='\n') + print('wrote certificate.json and SOURCE.json') + return + read = json.loads(target.read_text()) + assert read == json.loads(json.dumps(record, default=str)), 'certificate.json differs' + print('certificate.json matches a fresh rebuild') + print('rungs %s at %s banks, kappa %s' + % (record['top']['families_absorbed'], record['top']['banks'], record['kappa'])) + + +if __name__ == '__main__': + main() From 93d7e3a43cc9458c8c35f0083d72d7afcf999298 Mon Sep 17 00:00:00 2001 From: maxime-fleury Date: Fri, 9 Oct 2026 23:04:00 +0200 Subject: [PATCH 02/11] State the ladder's total bank count in the rung-3 readme MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The three absorptions occupy 783 width-66 banks (531 + 192 + 60); the table gave them separately but the total was only in the certificate. 🤖 Generated with Codebuff Co-Authored-By: Codebuff --- research/complex-bank-run3/README.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/research/complex-bank-run3/README.md b/research/complex-bank-run3/README.md index 2534992212..d4fc8fc83a 100644 --- a/research/complex-bank-run3/README.md +++ b/research/complex-bank-run3/README.md @@ -38,8 +38,9 @@ exhausted and the complex-side accounting ladder terminates. Each step is checked rather than relabelled: the volume fills whole banks, the retained ledger satisfies the row identity `66 * W - rank_mass = 3,960`, and the stock falls by -exactly the bank count. The top row is `W = 35,373`, rank mass `2,330,658`, 635,265 children -in 17 families, largest child 19. +exactly the bank count. The ladder's three absorptions occupy **783 width-66 banks** in total +(531 + 192 + 60), and the top row is `W = 35,373`, rank mass `2,330,658`, 635,265 children in +17 families, largest child 19. ## What the pins do not provide (the blocker, unchanged from rung 2) From 8b5d51278ca7888f5eb01ab44699741727b6f8a7 Mon Sep 17 00:00:00 2001 From: maxime-fleury Date: Fri, 9 Oct 2026 23:09:55 +0200 Subject: [PATCH 03/11] Enumerate obligation T1: the width-66 tilings the top rungs owe, and their negative result MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A uniform bank pattern absorbing a set of families forces one common bank count, so the scan is over the gcd of the item counts rather than over partitions of 66 -- exhaustive and therefore a decision. It shows rank 11 tiles alone four ways (rung 2's 531 is the tightest), that ranks 16 and 20 tile alone only above the bank counts their own volume criterion prices (198 and 66 against 192 and 60, six three-copy banks short each), and that no mixture tiles at all: {16,20} comes closest at 84 registers into a 66-wide bank. The two top rungs are therefore priced on bank counts no admissible tiling realises, a stronger caveat than "not constructed", so it is recorded in the certificate, the obligations file and both documents rather than left implied. 🤖 Generated with Codebuff Co-Authored-By: Codebuff --- research/complex-bank-run3/PROOF.md | 51 +++- research/complex-bank-run3/README.md | 64 ++++- research/complex-bank-run3/SOURCE.json | 8 +- research/complex-bank-run3/certificate.json | 294 +++++++++++++++++++- research/complex-bank-run3/obligations.json | 21 +- research/complex-bank-run3/pins.py | 4 +- research/complex-bank-run3/run3.py | 38 ++- research/complex-bank-run3/schedule66.json | 284 +++++++++++++++++++ research/complex-bank-run3/schedule66.py | 232 +++++++++++++++ research/complex-bank-run3/verify.py | 30 ++ 10 files changed, 995 insertions(+), 31 deletions(-) create mode 100644 research/complex-bank-run3/schedule66.json create mode 100644 research/complex-bank-run3/schedule66.py diff --git a/research/complex-bank-run3/PROOF.md b/research/complex-bank-run3/PROOF.md index ceb58712e1..1940cf46a2 100644 --- a/research/complex-bank-run3/PROOF.md +++ b/research/complex-bank-run3/PROOF.md @@ -39,6 +39,48 @@ On the complex ledger (`m = 66`, one copy `W = 12,052`, deficit `1,320`, 20 fami eyeballed. After rungs 2-4 all three are out of the ledger, and the eligibility scan on the retained row is empty -- the criterion cannot be applied again at this width, on this ledger. +### 2b. The criterion is not sufficient: T1, enumerated + +A bank is a partition of 66 coordinates into blocks. Absorbing a family *uniformly* -- the +same block pattern in every bank, as the certified bit-side construction uses (eighteen +4-coordinate cores, or three 24-coordinate cores, per width-72 bank) -- means `k_f` blocks of +family `f` per bank and `n_f = k_f * B` items for one **common** `B`. Hence `B` divides +every `n_f` in the absorbed set and the pattern must fit: `sum_f k_f * f <= 66`. So the scan +(`schedule66.py`) is over the **common divisors** of the item counts, not over partitions of +66; it is exhaustive and therefore a decision, not a search. + +| family | `n_f` (three copies) | capacity `66 // f` | banks by volume criterion | banks its capacity needs | uniform patterns | +| ---: | ---: | ---: | ---: | ---: | --- | +| 11 | 3,186 | 6 | 531 | 531 | 4, `B` in {3186, 1593, 1062, **531**} | +| 16 | 792 | 4 | 192 | **198** | 4, `B` in {**198**, 264, 396, 792} | +| 20 | 198 | 3 | 60 | **66** | 3, `B` in {**66**, 99, 198} | + +Three consequences, all asserted in `verify.py` and recorded in `certificate.json` -> +`tiling`: + +1. **Rank 11 is exactly consistent**, and rung 2's 531 is the tightest of its four patterns + (six blocks per bank, no padding). `66 = 6 * 11` is what makes the volume criterion and + the capacity criterion agree. +2. **Ranks 16 and 20 are not.** `66 = 4 * 16 + 2` and `66 = 3 * 20 + 6`: a bank holds four + or three whole blocks, so 792 items need 198 banks and 198 items need 66 -- six three-copy + banks (two per copy) more than the volume criterion prices, the padding being 2 and 6 + registers per bank (396 three-copy registers in both cases). At the priced counts the + required items per bank are `33/8 = 4.125` and `33/10 = 3.3`, above the capacities 4 + and 3; a bank cannot hold a fraction of a block. +3. **No mixture is admissible.** For a set of families absorbed together, `B` divides the + `gcd` of their counts: {11,16} -> 18 (531 and 132 blocks per bank), {16,20} -> 198 (four + and one, 84 registers into a 66-wide bank), {11,20} -> 18 (177 and 11), {11,16,20} -> 18 + (177, 44, 11). Every one overflows the bank, so no uniform tiling of width 66 absorbs two + whole bins at once -- which is also why the padding cannot be paid from a *retained* + family, since that would remove part of a bin, while the priced ledger removes bins whole. + +The obligation T1 therefore has a determined answer, and it is negative: rungs 3 and 4 are +priced on bank counts that no admissible tiling of a width-66 bank realises. Making them +physical needs either partial-bin removals (a ledger change, which would move the retained +histogram and so the price) or a different bank width (which moves the whole ladder). That +is a sharper statement of the blocker than "a construction is owed", and it is the reason the +upper two rows of the price table carry a caveat rather than a status. + ## 3. The ledgers, step by step (three-copy rows) | after | W | rank mass | children | largest child | rule applied | @@ -99,11 +141,14 @@ volume (asserted). Two consequences follow, and they are the useful part of the * Machine-checked here: the pinned bytes (21 files, sha256), the frontier reproduction, rung 1 rebuilt by the vendored #219 package, rung 2 rebuilt by this package's own ledger module, rungs 3 and 4 (volumes, row identities, stock drops, both paid moments, adjacency - rejections), the branch ceilings, the eligibility exhaustion and the PR208 replica. + rejections), the branch ceilings, the eligibility exhaustion, the PR208 replica and the T1 + enumeration of the width-66 tilings (both the pinned scan and its findings). * **Not** checked here: any physical realization. C1-C7 and T1 are open, and #219's R1-R4 are inherited open; the complex supplier has no bank construction in the pins - (machine-checked), and neither new family has an occurrence inventory. The kappa is - conditional on all of them, exactly as #219's rung 1 and #224's rung 2 are. + (machine-checked), and neither new family has an occurrence inventory. T1's *enumeration* + is done here and comes out negative (~2b), so the rungs above rung 2 are priced targets + whose bank counts are not realisable by any uniform tiling -- not merely unconstructed. The + kappa is conditional on all of them, exactly as #219's rung 1 and #224's rung 2 are. * Not run: upstream CI, and any contributor verifier other than the vendored #219 package invoked in place. * The `10^-10` supplier field is priced as a conservative variant; on it the ladder's top sits diff --git a/research/complex-bank-run3/README.md b/research/complex-bank-run3/README.md index d4fc8fc83a..508328cf20 100644 --- a/research/complex-bank-run3/README.md +++ b/research/complex-bank-run3/README.md @@ -14,6 +14,11 @@ ledger -- and records where the accounting criterion the built rungs use stops. | **rung 3, this package** | + complex rank-16 family, 192 banks | `710572698755137/10^18` = **0.000710572698755137** | complex | **+0.3221%** over rung 2; blocked (below) | | **rung 4, this package** | + complex rank-20 family, 60 banks | `355587847933979/5*10^17` = **0.000711175695867958** | complex | **+0.4072%** over rung 2, **+4.0963%** over the frontier; blocked (below) | +The two bank counts above are the ones the whole-bank volume criterion gives. The T1 scan +below shows a width-66 bank cannot host them: the rank-16 and rank-20 absorptions need 198 +and 66 banks by their own capacity, and no uniform tiling absorbs either family together with +another. Rungs 3 and 4 are priced targets on a bank count no admissible tiling realises. + The price is the same ledger in two independent conventions: the `10^-18` grid of the queue's latest rungs (`eta = beta = 10^-24`, `weak = 10^-30`), and PR208's pricing model (`stop = 10^-9`, `eta = 10^-8`, `10^-10` grid) as an independent replica -- where rung 2 @@ -56,12 +61,42 @@ the status are read from the pins, not asserted: rank-20 children, exactly as nothing enumerates its rank-11 family or #219's rank-22 bin before its own inventory was written. A rung that cannot name its items cannot be built. -One further obligation is specific to rungs 3 and 4 and worth stating precisely because it is -**not** a construction: rank 11 divides the bank width (`66 = 6 * 11`) and needed no mixture, -but `66 = 4 * 16 + 2` and `66 = 3 * 20 + 6`, so the rank-16 and rank-20 blocks cannot tile a -66-wide bank alone. Their banks must mix block sizes (T1), which is the same obligation #219 -carries for the bit word as R1 -- admissible tilings of width 72 over families {4, 24, 22} -- -with no analogous enumeration to inherit. +One further obligation is specific to rungs 3 and 4, and this package no longer merely owes it: +it **enumerates** it (`schedule66.py`, `schedule66.json`, checked by `verify.py`) and the +answer is negative. A bank is a width-66 block partition, and a *uniform* pattern -- the same +pattern in every bank, which is what the certified bit-side construction uses (eighteen +4-coordinate cores, or three 24-coordinate cores, per width-72 bank) -- absorbing a family +forces one common bank count `B` with `k_f = n_f / B`. So `B` divides `gcd(n_f)`, and +`sum_f k_f * f <= 66`. That is finite and exhaustive: + +| family | blocks per bank (capacity) | banks by volume criterion | banks its capacity needs | admissible uniform patterns | +| --- | ---: | ---: | ---: | --- | +| 11 (rung 2) | 6 (`66 = 6 * 11`) | 531 | 531 | 4, `B` in {3186, 1593, 1062, **531**} | +| **16 (rung 3)** | 4 (`66 = 4 * 16 + 2`) | 192 | **198** | 4, `B` in {**198**, 264, 396, 792} | +| **20 (rung 4)** | 3 (`66 = 3 * 20 + 6`) | 60 | **66** | 3, `B` in {**66**, 99, 198} | + +Three findings, each machine-checked: + +* **rank 11 tiles alone**, four ways, and rung 2's 531 (six blocks per bank, no padding) is the + tightest of them -- which is why rung 2 is consistent and rungs 3 and 4 are not; +* **ranks 16 and 20 tile alone only above the bank counts their own volume criterion prices**: + 792 rank-16 items need 198 banks, not the 192 that `12,672 / 66` gives (192 banks hold + 4.125 items each where 4 is the capacity), and 198 rank-20 items need 66, not 60. The + unused registers are the padding: 2 per rank-16 bank, 6 per rank-20 bank, 396 three-copy + registers in both cases; +* **no subset admits a uniform tiling.** The common divisor for {11,16} is 18 (531 and 132 + blocks per bank), for {16,20} it is 198 (four and one, 84 registers into a 66-wide bank), + for all three it is 18 (177, 44 and 11). Every one overflows the bank. + +So the mixed tiling T1 asks for has **no uniform solution**, and the padding cannot be paid +from a retained family either: that would mean removing *part* of a bin, while the priced +ledger removes bins whole. The two rungs' kappas are therefore conditional on bank counts a +tiling cannot realise at all -- a stronger condition than "not constructed". A construction +must either pad with partial-bin removals (a change the ledger does not model) or change the +bank width. The volume criterion and the capacity criterion coincide exactly when the rank +divides the width, which is true of rank 22 at width 72, rank 11 at width 66 and the +certified bit-side rank-60 exteriors (`396,000 / 72 = 5,500` banks, cores of 4 and 24), and +false of ranks 16 and 20. ## What the top rung implies for the next step @@ -82,11 +117,12 @@ python3 -B verify.py # check: pins, rebuild, compare with certificate. python3 -B verify.py --write # authoring: regenerate certificate.json and SOURCE.json ``` -`verify.py` passes with exit 0, pins 21 files by sha256, rebuilds the whole complex-side +`verify.py` passes with exit 0, pins 23 files by sha256, rebuilds the whole complex-side ladder (base, rung 2, rungs 3 and 4), both paid moments per rung, the two 47-constraint -assemblies with adjacent-grid rejection, the eligibility scan and the PR208 replica, and -reproduces #207's, #219's and #224's published grid points exactly. The vendored rung-1 -package also self-verifies in place: +assemblies with adjacent-grid rejection, the eligibility scan, the PR208 replica, and re-runs +the T1 tiling enumeration against the pinned `schedule66.json`; it reproduces #207's, #219's +and #224's published grid points exactly. The vendored rung-1 package also self-verifies in +place: ```sh cd research/complex-bank-run3/references/pr219-run1 && python3 -B verify.py @@ -99,7 +135,9 @@ cd research/complex-bank-run3/references/pr219-run1 && python3 -B verify.py states for rung 1 and #224 for rung 2. It is not an unconditional multiplication theorem, not a practical multiplier, and not a Lean/kernel certificate. * The whole-bank volume condition is necessary and is the criterion the built rungs use; it - is not sufficient on its own for the two new families, which owe T1's tiling. + is not sufficient, and for the two new families it is not even compatible with a width-66 + tiling at the bank counts it prices (see the T1 scan above). Rungs 3 and 4 carry that + caveat explicitly. * Nothing here bounds any *other* complex-side lever: the ladder is over this supplier's child ledger at this bank width. A different word, width or frame layout is not priced. * The ladder inherits every interface #207/#219/#224 inherit (all-size compiler, weighted and @@ -119,5 +157,5 @@ rests on are **PR224** (`research/complex-bank-run2`); the bank-absorption ladde `10^-10` replica price are **PR208** (`research/composed-diagonal-bit-bootstrap`); the underlying bank proof and engine chain is PR200/PR205 (Chafik Boukhalfa and the PR197/PR205 line) and PR184/PR168-v4 (icekylinx/eumemic) as inherited through them. This package adds -rungs 3 and 4, their prices, the exhaustion of the ledger's whole-bank criterion and the -next-step arithmetic. Apache-2.0; no existing file is changed. +rungs 3 and 4, their prices, the exhaustion of the ledger's whole-bank criterion, the T1 +enumeration of the width-66 tilings (with its negative result) and the next-step arithmetic. Apache-2.0; no existing file is changed. diff --git a/research/complex-bank-run3/SOURCE.json b/research/complex-bank-run3/SOURCE.json index 8eed6d2517..8a0712b9b0 100644 --- a/research/complex-bank-run3/SOURCE.json +++ b/research/complex-bank-run3/SOURCE.json @@ -1,8 +1,8 @@ { "files": { "ledger3.py": "202591f64e76002dd0bc05e7d0c36214db85faf9261bb1757bfb0ca568cc53cd", - "obligations.json": "6be2fa3489d2006f981454c0a0a56f174b1a9def43a891ad28ce01e9e7ef9802", - "pins.py": "970caafa94b69a8dd352c7f123b44a5fcc009d19d25b8b75b0e30ba2b5b97754", + "obligations.json": "cb495d71290b1a8d41386530f58ed7899e78f11fe12f229a560e9a652a0ec92a", + "pins.py": "3a7d28b2f1be38243fd4d6625dd0627fcee35e72bd07e21414b934f1cd3c9c00", "references/pr207-coordinated-crossover.certificate.json": "f4e30cca369fb014b729df870ca3716cc0f1e2297b9f265341492cba85a14aeb", "references/pr219-run1/NOTICE.md": "1f04b17404663a0983b7cc45e308e577d4d49fb6a4c1ff077dc3f13bae83c56f", "references/pr219-run1/PROOF.md": "b7b9d83d4f87b32a9cba82a56039a18c9843eac0bd18f6a7bdcf9667b27b8a04", @@ -20,6 +20,8 @@ "references/pr219-run1/references/pr205-packed.certificate.json": "c11fbb9aaa99594afc8d21e33761dc6d1d6c76ce3dbc36d5b64cae872c242f5a", "references/pr219-run1/schedule.py": "b9fff272f30048b982da3c0fc0149c2fde20bb7e32b8f9f860069956c12ebdc9", "references/pr219-run1/verify.py": "c839a06389945f9b0c6fbfd59bf2dd8030190c3de504d72c9bf032879f931197", - "run3.py": "279b153f5b3f4ed4fdf956243dfc186b7885132fc3bf087032cb46fdbb1d28e8" + "run3.py": "784a944d7a9b97fac8c71ef1b86a7f2c68a6f86f363aaf30d1b1684b9f719d6b", + "schedule66.json": "3f11889e722a8a00d1edc7c72bd099ecf0a72c8dd60ae83347b739565b48e919", + "schedule66.py": "1683b7e210bdd0d89abbbda8a03959325f38e6e138f473e312987adce8483981" } } diff --git a/research/complex-bank-run3/certificate.json b/research/complex-bank-run3/certificate.json index 23ead049ec..e710cf036a 100644 --- a/research/complex-bank-run3/certificate.json +++ b/research/complex-bank-run3/certificate.json @@ -308,8 +308,8 @@ ], "source_pins": { "ledger3.py": "202591f64e76002dd0bc05e7d0c36214db85faf9261bb1757bfb0ca568cc53cd", - "obligations.json": "6be2fa3489d2006f981454c0a0a56f174b1a9def43a891ad28ce01e9e7ef9802", - "pins.py": "970caafa94b69a8dd352c7f123b44a5fcc009d19d25b8b75b0e30ba2b5b97754", + "obligations.json": "cb495d71290b1a8d41386530f58ed7899e78f11fe12f229a560e9a652a0ec92a", + "pins.py": "3a7d28b2f1be38243fd4d6625dd0627fcee35e72bd07e21414b934f1cd3c9c00", "references/pr207-coordinated-crossover.certificate.json": "f4e30cca369fb014b729df870ca3716cc0f1e2297b9f265341492cba85a14aeb", "references/pr219-run1/NOTICE.md": "1f04b17404663a0983b7cc45e308e577d4d49fb6a4c1ff077dc3f13bae83c56f", "references/pr219-run1/PROOF.md": "b7b9d83d4f87b32a9cba82a56039a18c9843eac0bd18f6a7bdcf9667b27b8a04", @@ -327,9 +327,295 @@ "references/pr219-run1/references/pr205-packed.certificate.json": "c11fbb9aaa99594afc8d21e33761dc6d1d6c76ce3dbc36d5b64cae872c242f5a", "references/pr219-run1/schedule.py": "b9fff272f30048b982da3c0fc0149c2fde20bb7e32b8f9f860069956c12ebdc9", "references/pr219-run1/verify.py": "c839a06389945f9b0c6fbfd59bf2dd8030190c3de504d72c9bf032879f931197", - "run3.py": "279b153f5b3f4ed4fdf956243dfc186b7885132fc3bf087032cb46fdbb1d28e8" + "run3.py": "784a944d7a9b97fac8c71ef1b86a7f2c68a6f86f363aaf30d1b1684b9f719d6b", + "schedule66.json": "3f11889e722a8a00d1edc7c72bd099ecf0a72c8dd60ae83347b739565b48e919", + "schedule66.py": "1683b7e210bdd0d89abbbda8a03959325f38e6e138f473e312987adce8483981" }, "status": "MODEL AND TARGET, NOT CONSTRUCTED: the rung-3 and rung-4 ledgers (whole-bank volume, retained row identities, stock drops, both paid moments on the 10^-18 grid, the two 47-constraint assemblies) are certified here, but every rung above rung 2 needs a bank construction on the complex supplier that no package in the pins provides (obligations.json C1-C7 and T1, plus #219's inherited R1-R4). The kappa below is conditional on those and is not a completed finite witness.", + "tiling": { + "certified_precedent": { + "banks": 45842, + "copies": 3, + "note": "the only bank construction in the pins: width-72 entrance-gauge banks filled by eighteen 4-coordinate or three 24-coordinate cores (a rank-60 exterior family, 396,000 three-copy registers = 5,500 banks of its own volume)", + "source": "references/pr219-run1/references/pr205-packed.certificate.json", + "width": 72 + }, + "copies": 3, + "families": { + "11": { + "capacity_minimum_banks": 531, + "capacity_per_bank": 6, + "divides_width": true, + "fits_the_priced_banks": true, + "items_per_priced_bank": "6", + "padding_per_bank": 0, + "padding_registers": 0, + "per_vertex": 1062, + "priced_banks": 531, + "registers_per_block": 11, + "shortfall_banks": 0, + "three_copies": 3186, + "volume_registers": 35046, + "whole_bank_volume": true + }, + "16": { + "capacity_minimum_banks": 198, + "capacity_per_bank": 4, + "divides_width": false, + "fits_the_priced_banks": false, + "items_per_priced_bank": "33/8", + "padding_per_bank": 2, + "padding_registers": 396, + "per_vertex": 264, + "priced_banks": 192, + "registers_per_block": 16, + "shortfall_banks": 6, + "three_copies": 792, + "volume_registers": 12672, + "whole_bank_volume": true + }, + "20": { + "capacity_minimum_banks": 66, + "capacity_per_bank": 3, + "divides_width": false, + "fits_the_priced_banks": false, + "items_per_priced_bank": "33/10", + "padding_per_bank": 6, + "padding_registers": 396, + "per_vertex": 66, + "priced_banks": 60, + "registers_per_block": 20, + "shortfall_banks": 6, + "three_copies": 198, + "volume_registers": 3960, + "whole_bank_volume": true + } + }, + "findings": { + "mixed_uniform_tilings": 0, + "rank_11_patterns": 4, + "rank_11_tightest_banks": 3186, + "rank_11_tiles_alone": true, + "ranks_16_20_tile_alone_only_above_their_priced_bank_counts": true, + "verdict": "no admissible uniform tiling of a width-66 bank absorbs two whole bins at once, and neither rank 16 nor rank 20 fits the bank count its own volume criterion prices" + }, + "ladder": [ + 11, + 16, + 20 + ], + "obligations": { + "C1": "unchanged: the normalizer and item-to-block maps the bank construction owes", + "T1": "the enumeration above: the mixed tiling ranks 16 and 20 owe has no uniform solution, so it must remove part of a retained bin (padding) or use a different bank width -- the pins state neither, so the rungs above rung 2 stay priced rather than instantiated" + }, + "one_copy_bins": { + "11": 1062, + "16": 264, + "20": 66 + }, + "source_supplier": "pr193-source-assisted-v4.certificate.json", + "subsets": { + "11": { + "admissible": [ + { + "banks": 531, + "blocks": { + "11": 6 + }, + "padding_per_bank": 0, + "padding_registers": 0, + "registers_used": 66 + }, + { + "banks": 1062, + "blocks": { + "11": 3 + }, + "padding_per_bank": 33, + "padding_registers": 35046, + "registers_used": 33 + }, + { + "banks": 1593, + "blocks": { + "11": 2 + }, + "padding_per_bank": 44, + "padding_registers": 70092, + "registers_used": 22 + }, + { + "banks": 3186, + "blocks": { + "11": 1 + }, + "padding_per_bank": 55, + "padding_registers": 175230, + "registers_used": 11 + } + ], + "common_divisor": 3186, + "families": [ + 11 + ] + }, + "11,16": { + "admissible": [], + "closest_attempt": { + "banks": 18, + "blocks": { + "11": 177, + "16": 44 + }, + "overflow": 2585, + "registers_used": 2651 + }, + "common_divisor": 18, + "families": [ + 11, + 16 + ] + }, + "11,16,20": { + "admissible": [], + "closest_attempt": { + "banks": 18, + "blocks": { + "11": 177, + "16": 44, + "20": 11 + }, + "overflow": 2805, + "registers_used": 2871 + }, + "common_divisor": 18, + "families": [ + 11, + 16, + 20 + ] + }, + "11,20": { + "admissible": [], + "closest_attempt": { + "banks": 18, + "blocks": { + "11": 177, + "20": 11 + }, + "overflow": 2101, + "registers_used": 2167 + }, + "common_divisor": 18, + "families": [ + 11, + 20 + ] + }, + "16": { + "admissible": [ + { + "banks": 198, + "blocks": { + "16": 4 + }, + "padding_per_bank": 2, + "padding_registers": 396, + "registers_used": 64 + }, + { + "banks": 264, + "blocks": { + "16": 3 + }, + "padding_per_bank": 18, + "padding_registers": 4752, + "registers_used": 48 + }, + { + "banks": 396, + "blocks": { + "16": 2 + }, + "padding_per_bank": 34, + "padding_registers": 13464, + "registers_used": 32 + }, + { + "banks": 792, + "blocks": { + "16": 1 + }, + "padding_per_bank": 50, + "padding_registers": 39600, + "registers_used": 16 + } + ], + "common_divisor": 792, + "families": [ + 16 + ] + }, + "16,20": { + "admissible": [], + "closest_attempt": { + "banks": 198, + "blocks": { + "16": 4, + "20": 1 + }, + "overflow": 18, + "registers_used": 84 + }, + "common_divisor": 198, + "families": [ + 16, + 20 + ] + }, + "20": { + "admissible": [ + { + "banks": 66, + "blocks": { + "20": 3 + }, + "padding_per_bank": 6, + "padding_registers": 396, + "registers_used": 60 + }, + { + "banks": 99, + "blocks": { + "20": 2 + }, + "padding_per_bank": 26, + "padding_registers": 2574, + "registers_used": 40 + }, + { + "banks": 198, + "blocks": { + "20": 1 + }, + "padding_per_bank": 46, + "padding_registers": 9108, + "registers_used": 20 + } + ], + "common_divisor": 198, + "families": [ + 20 + ] + } + }, + "three_copy_items": { + "11": 3186, + "16": 792, + "20": 198 + }, + "width": 66 + }, "top": { "banks": 783, "binding": "complex", @@ -346,7 +632,7 @@ "families_left": 17, "kappa": "355587847933979/500000000000000000", "largest_child": 19, - "note": "no family of the remaining complex ledger has a whole-bank volume, so the accounting criterion the built rungs use cannot be applied again without a different bank width or a mixed tiling that reopens the volume condition", + "note": "no family of the remaining complex ledger has a whole-bank volume, so the accounting criterion the built rungs use cannot be applied again without a different bank width or a mixed tiling that reopens the volume condition; the T1 scan of this certificate shows the mixed tiling has no uniform solution either, and that rungs 3 and 4 are priced at 192 and 60 banks where their own capacities require 198 and 66", "rank_mass": 2330658, "stock": 35373 } diff --git a/research/complex-bank-run3/obligations.json b/research/complex-bank-run3/obligations.json index 3a9293eb7a..a97b64d2de 100644 --- a/research/complex-bank-run3/obligations.json +++ b/research/complex-bank-run3/obligations.json @@ -118,17 +118,28 @@ "id": "T1", "name": "mixed tiling of the width-66 bank for ranks 16 and 20", "reference_precedent": "PR219 references/pr219-run1/schedule.py (width-72 tilings over {4, 24, 22}); research/coordinated-frames-and-entrance-banks BANK-PROOF-PR200.md (18 four-coordinate cores or 3 24-coordinate cores fill a width-72 bank).", - "statement": "Rank 11 divides the bank width (66 = 6 x 11) and needed no mixture, but 66 = 4 x 16 + 2 and 66 = 3 x 20 + 6: the rank-16 and rank-20 blocks cannot tile a 66-wide bank on their own, so their banks must mix block sizes. The obligation is to enumerate the admissible tilings of width 66 over the families the complex word actually offers, choose one per bank, and show that the chosen pattern realises exactly 264 rank-16 and 66 rank-20 children per vertex -- i.e. that every absorbed item lands in some block and no block is left half-used.", - "status": "OPEN", - "why_it_is_the_blocker": "It is the same obligation PR219 carries as R1 for the bit word (admissible tilings of width 72 over families {4, 24, 22}), but with no analogous enumeration to inherit: the bit word's bank pattern is pinned in the bank proof, the complex word has none." + "statement": "Rank 11 divides the bank width (66 = 6 x 11) and needed no mixture, but 66 = 4 x 16 + 2 and 66 = 3 x 20 + 6: the rank-16 and rank-20 blocks cannot tile a 66-wide bank on their own, so their banks must mix block sizes. The obligation is to enumerate the admissible tilings of width 66 over the families the complex word actually offers, choose one per bank, and show that the chosen pattern realises exactly 264 rank-16 and 66 rank-20 children per vertex -- i.e. that every absorbed item lands in some block and no block is left half-used.", + "status": "OPEN", + "why_it_is_the_blocker": "It is the same obligation PR219 carries as R1 for the bit word (admissible tilings of width 72 over families {4, 24, 22}), but with no analogous enumeration to inherit: the bit word's bank pattern is pinned in the bank proof, the complex word has none.", + "enumeration": { + "status": "ENUMERATED, RESULT NEGATIVE", + "artifact": "schedule66.py, schedule66.json (this package, checked by verify.py)", + "method": "A uniform pattern (the same block pattern in every bank, as the certified bit-side construction uses) absorbing a set S of families forces one common bank count B with k_f = n_f / B, so B divides gcd(n_f : f in S) and sum_f k_f f <= 66. That is finite and exhaustive: 7 subsets x the divisors of a gcd.", + "rank_11": "4 admissible uniform patterns, B in {3186, 1593, 1062, 531}; rung 2's 531 (six blocks per bank, no padding) is the tightest.", + "rank_16": "4 admissible uniform patterns, B in {792, 396, 264, 198}; the capacity bound is 4 blocks per bank (66 = 4 x 16 + 2), so 792 items need 198 banks -- the rung prices 192, six three-copy banks (two per copy) short.", + "rank_20": "3 admissible uniform patterns, B in {198, 99, 66}; the capacity bound is 3 blocks per bank (66 = 3 x 20 + 6), so 198 items need 66 banks -- the rung prices 60, likewise six short.", + "mixtures": "No subset of two or three families admits a uniform tiling. {16,20} comes closest: the common divisor is 198, giving four rank-16 and one rank-20 block per bank, 84 registers into a 66-wide bank.", + "consequence": "The rung-3 and rung-4 bank counts are not admissible tilings of a width-66 bank, and the mixed tiling T1 asks for has no uniform solution: the 2 or 6 padding registers per bank would have to come from part of a retained bin, which the priced ledger does not model because it removes a bin whole. The rungs' kappas are therefore conditional on a bank count that a tiling cannot realise at all, a stronger condition than 'not constructed'; a construction must either pad with partial-bin removals or change the bank width.", + "volume_vs_capacity": "The volume criterion (m | r * n) and the capacity criterion (n <= B * floor(m / r)) coincide exactly when the rank divides the width -- true of rank 22 at width 72, rank 11 at width 66, and the certified bit-side rank-60 exteriors at 396,000 / 72 = 5,500 banks, and false of ranks 16 and 20, which do not divide 66." } + } ], "status": "OPEN obligations for rungs 3 and 4. verify.py certifies the accounting (whole-bank volumes, retained row identities, stock drops equal to the bank counts, both paid moments on the 10^-18 grid, the two 47-constraint assemblies and the exclusion of the adjacent grid points) and the exact prices; it discharges none of these items.", "why_rung_3_and_4": { "consequence": "the accounting ladder on the complex word terminates at rung 4; going higher needs a different bank width, a different ledger (a new supplier), or a mixed tiling that reopens the volume condition.", "numbers": { - "rank_16_volume": "16 * 792 = 12,672 = 66 * 192 three-copy banks", - "rank_20_volume": "20 * 198 = 3,960 = 66 * 60 three-copy banks", + "rank_16_volume": "16 * 792 = 12,672 = 66 * 192 three-copy banks; its capacity bound is 198, so the priced count does not host its items (see T1)", + "rank_20_volume": "20 * 198 = 3,960 = 66 * 60 three-copy banks; its capacity bound is 66 (see T1)", "remaining_families": "every one of the 17 families left after rungs 2-4 has a volume that is not a whole number of width-66 banks", "rung_2_ceiling": "7.082915705907269e-4 (kappa 354145785295363/5*10^17 inside one 10^-18 grid step)", "rung_2_coarse": "708793603125109/10^18 = 7.08793603125109e-4" diff --git a/research/complex-bank-run3/pins.py b/research/complex-bank-run3/pins.py index 321dac2c7e..109e63ab29 100644 --- a/research/complex-bank-run3/pins.py +++ b/research/complex-bank-run3/pins.py @@ -13,8 +13,8 @@ HERE = Path(__file__).resolve().parent VENDORED_RUN1 = 'references/pr219-run1' -OWN = ('ledger3.py', 'run3.py', 'pins.py', 'obligations.json', - 'references/pr207-coordinated-crossover.certificate.json') +OWN = ('ledger3.py', 'run3.py', 'schedule66.py', 'schedule66.json', 'pins.py', + 'obligations.json', 'references/pr207-coordinated-crossover.certificate.json') def pinned_paths(): diff --git a/research/complex-bank-run3/run3.py b/research/complex-bank-run3/run3.py index cd8c93862a..335f8252bc 100644 --- a/research/complex-bank-run3/run3.py +++ b/research/complex-bank-run3/run3.py @@ -30,6 +30,10 @@ and the point at which the bit branch starts binding instead. 7. **The blocker**, as facts rather than assertions (`obligations.json` C1-C7 + T1, plus #219's inherited R1-R4). +8. **T1's enumeration** (`schedule66.py`): the admissible uniform tilings of a width-66 + bank, exhaustively. Rank 11 tiles alone (four patterns, rung 2's 531 the tightest); + ranks 16 and 20 tile alone only *above* the bank counts their own volume criterion + prices (198 and 66, against 192 and 60); and no uniform tiling absorbs two bins at once. python3 -B run3.py [--out certificate.json] """ @@ -46,6 +50,7 @@ import ledger3 # noqa: E402 (local module, imported after the path is set) import pins # noqa: E402 +import schedule66 # noqa: E402 REFERENCES = HERE / 'references' FRONTIER = REFERENCES / 'pr207-coordinated-crossover.certificate.json' @@ -258,6 +263,33 @@ def build(): assert Q(part['ladder'][0]['saving']) == RUN2_COARSE, "rung 2 must reproduce PR224" assert part['final_eligibility'] == [], 'the ladder must be exhausted at the top' + # --- 3b. T1: the width-66 tilings the rungs above rung 2 owe -------------- + tiling = schedule66.tiling() + families = tiling['families'] + assert families['11']['priced_banks'] == families['11']['capacity_minimum_banks'] \ + == part['ladder'][0]['banks'] == 531, \ + "rung 2's rank-11 absorption must be the tightest admissible tiling" + for family, entry in families.items(): + assert entry['whole_bank_volume'] == (entry['volume_registers'] % tiling['width'] == 0) + assert entry['capacity_minimum_banks'] == -(-entry['three_copies'] + // entry['capacity_per_bank']) + assert entry['fits_the_priced_banks'] == (entry['priced_banks'] + >= entry['capacity_minimum_banks']) + assert not families['16']['fits_the_priced_banks'], 'rung 3 prices 192 of 198 banks' + assert not families['20']['fits_the_priced_banks'], 'rung 4 prices 60 of 66 banks' + assert families['11']['divides_width'] and not families['16']['divides_width'] \ + and not families['20']['divides_width'], 'rank-divides-width is what separates them' + assert [step['banks'] for step in part['ladder']] \ + == [families[f]['priced_banks'] for f in ('11', '16', '20')], \ + 'the ledger must price exactly the volume counts the tiling scan examines' + assert tiling['findings']['mixed_uniform_tilings'] == 0, \ + 'no uniform tiling may absorb two bins at once' + assert all(not tiling['subsets'][key]['admissible'] + for key in ('11,16', '11,20', '16,20', '11,16,20')), \ + 'every mixed subset must be infeasible' + assert tiling['subsets']['16,20']['closest_attempt']['overflow'] == 18, \ + 'the tightest mixed attempt on {16, 20} must be 84 registers into a 66 bank' + rungs = [rung_record(supplier, step, leaf, index + 3) for index, step in enumerate(part['ladder'][1:])] top = rungs[-1] @@ -311,6 +343,7 @@ def build(): note='rebuilt here by this package\'s own ledger module ' 'from the pinned complex profile, not imported')), ledgers=part, + tiling=tiling, rungs=rungs, replica=replica, top=dict(kappa=str(kappa_top), coarse=str(coarse_top), binding=top['binding'], @@ -325,7 +358,10 @@ def build(): note='no family of the remaining complex ledger has a whole-bank volume, ' 'so the accounting criterion the built rungs use cannot be applied ' 'again without a different bank width or a mixed tiling that reopens ' - 'the volume condition'), + 'the volume condition; the T1 scan of this certificate shows the ' + 'mixed tiling has no uniform solution either, and that rungs 3 and 4 ' + 'are priced at 192 and 60 banks where their own capacities require ' + '198 and 66'), needed_for=needs, conservative_variant=dict( supplier_field=str(supplier_field), certified_moment=str(a_complex), diff --git a/research/complex-bank-run3/schedule66.json b/research/complex-bank-run3/schedule66.json new file mode 100644 index 0000000000..4942e60647 --- /dev/null +++ b/research/complex-bank-run3/schedule66.json @@ -0,0 +1,284 @@ +{ + "certified_precedent": { + "banks": 45842, + "copies": 3, + "note": "the only bank construction in the pins: width-72 entrance-gauge banks filled by eighteen 4-coordinate or three 24-coordinate cores (a rank-60 exterior family, 396,000 three-copy registers = 5,500 banks of its own volume)", + "source": "references/pr219-run1/references/pr205-packed.certificate.json", + "width": 72 + }, + "copies": 3, + "families": { + "11": { + "capacity_minimum_banks": 531, + "capacity_per_bank": 6, + "divides_width": true, + "fits_the_priced_banks": true, + "items_per_priced_bank": "6", + "padding_per_bank": 0, + "padding_registers": 0, + "per_vertex": 1062, + "priced_banks": 531, + "registers_per_block": 11, + "shortfall_banks": 0, + "three_copies": 3186, + "volume_registers": 35046, + "whole_bank_volume": true + }, + "16": { + "capacity_minimum_banks": 198, + "capacity_per_bank": 4, + "divides_width": false, + "fits_the_priced_banks": false, + "items_per_priced_bank": "33/8", + "padding_per_bank": 2, + "padding_registers": 396, + "per_vertex": 264, + "priced_banks": 192, + "registers_per_block": 16, + "shortfall_banks": 6, + "three_copies": 792, + "volume_registers": 12672, + "whole_bank_volume": true + }, + "20": { + "capacity_minimum_banks": 66, + "capacity_per_bank": 3, + "divides_width": false, + "fits_the_priced_banks": false, + "items_per_priced_bank": "33/10", + "padding_per_bank": 6, + "padding_registers": 396, + "per_vertex": 66, + "priced_banks": 60, + "registers_per_block": 20, + "shortfall_banks": 6, + "three_copies": 198, + "volume_registers": 3960, + "whole_bank_volume": true + } + }, + "findings": { + "mixed_uniform_tilings": 0, + "rank_11_patterns": 4, + "rank_11_tightest_banks": 3186, + "rank_11_tiles_alone": true, + "ranks_16_20_tile_alone_only_above_their_priced_bank_counts": true, + "verdict": "no admissible uniform tiling of a width-66 bank absorbs two whole bins at once, and neither rank 16 nor rank 20 fits the bank count its own volume criterion prices" + }, + "ladder": [ + 11, + 16, + 20 + ], + "obligations": { + "C1": "unchanged: the normalizer and item-to-block maps the bank construction owes", + "T1": "the enumeration above: the mixed tiling ranks 16 and 20 owe has no uniform solution, so it must remove part of a retained bin (padding) or use a different bank width -- the pins state neither, so the rungs above rung 2 stay priced rather than instantiated" + }, + "one_copy_bins": { + "11": 1062, + "16": 264, + "20": 66 + }, + "source_supplier": "pr193-source-assisted-v4.certificate.json", + "subsets": { + "11": { + "admissible": [ + { + "banks": 531, + "blocks": { + "11": 6 + }, + "padding_per_bank": 0, + "padding_registers": 0, + "registers_used": 66 + }, + { + "banks": 1062, + "blocks": { + "11": 3 + }, + "padding_per_bank": 33, + "padding_registers": 35046, + "registers_used": 33 + }, + { + "banks": 1593, + "blocks": { + "11": 2 + }, + "padding_per_bank": 44, + "padding_registers": 70092, + "registers_used": 22 + }, + { + "banks": 3186, + "blocks": { + "11": 1 + }, + "padding_per_bank": 55, + "padding_registers": 175230, + "registers_used": 11 + } + ], + "common_divisor": 3186, + "families": [ + 11 + ] + }, + "11,16": { + "admissible": [], + "closest_attempt": { + "banks": 18, + "blocks": { + "11": 177, + "16": 44 + }, + "overflow": 2585, + "registers_used": 2651 + }, + "common_divisor": 18, + "families": [ + 11, + 16 + ] + }, + "11,16,20": { + "admissible": [], + "closest_attempt": { + "banks": 18, + "blocks": { + "11": 177, + "16": 44, + "20": 11 + }, + "overflow": 2805, + "registers_used": 2871 + }, + "common_divisor": 18, + "families": [ + 11, + 16, + 20 + ] + }, + "11,20": { + "admissible": [], + "closest_attempt": { + "banks": 18, + "blocks": { + "11": 177, + "20": 11 + }, + "overflow": 2101, + "registers_used": 2167 + }, + "common_divisor": 18, + "families": [ + 11, + 20 + ] + }, + "16": { + "admissible": [ + { + "banks": 198, + "blocks": { + "16": 4 + }, + "padding_per_bank": 2, + "padding_registers": 396, + "registers_used": 64 + }, + { + "banks": 264, + "blocks": { + "16": 3 + }, + "padding_per_bank": 18, + "padding_registers": 4752, + "registers_used": 48 + }, + { + "banks": 396, + "blocks": { + "16": 2 + }, + "padding_per_bank": 34, + "padding_registers": 13464, + "registers_used": 32 + }, + { + "banks": 792, + "blocks": { + "16": 1 + }, + "padding_per_bank": 50, + "padding_registers": 39600, + "registers_used": 16 + } + ], + "common_divisor": 792, + "families": [ + 16 + ] + }, + "16,20": { + "admissible": [], + "closest_attempt": { + "banks": 198, + "blocks": { + "16": 4, + "20": 1 + }, + "overflow": 18, + "registers_used": 84 + }, + "common_divisor": 198, + "families": [ + 16, + 20 + ] + }, + "20": { + "admissible": [ + { + "banks": 66, + "blocks": { + "20": 3 + }, + "padding_per_bank": 6, + "padding_registers": 396, + "registers_used": 60 + }, + { + "banks": 99, + "blocks": { + "20": 2 + }, + "padding_per_bank": 26, + "padding_registers": 2574, + "registers_used": 40 + }, + { + "banks": 198, + "blocks": { + "20": 1 + }, + "padding_per_bank": 46, + "padding_registers": 9108, + "registers_used": 20 + } + ], + "common_divisor": 198, + "families": [ + 20 + ] + } + }, + "three_copy_items": { + "11": 3186, + "16": 792, + "20": 198 + }, + "width": 66 +} diff --git a/research/complex-bank-run3/schedule66.py b/research/complex-bank-run3/schedule66.py new file mode 100644 index 0000000000..417f93c0f0 --- /dev/null +++ b/research/complex-bank-run3/schedule66.py @@ -0,0 +1,232 @@ +#!/usr/bin/env python3 +"""T1: the admissible tilings of a width-66 bank, enumerated -- and what they rule out. + +A complex bank is a width-66 coordinate block. Filling it means choosing blocks whose +sizes sum to 66, and absorbing a family *uniformly* -- the same block pattern in every bank, +which is what the certified bit-side construction does (eighteen 4-coordinate cores, or +three 24-coordinate cores, per width-72 bank) -- means + + k_f blocks of family f per bank, and n_f = k_f * B items of family f + +for one **common** B. Writing it out, B must divide every absorbed family's item count +``n_f``, ``k_f = n_f / B``, and the pattern has to fit: ``sum_f k_f * f <= 66``, the leftover +registers being filled by blocks of retained families (the padding). + +So the enumeration is not over partitions of 66 -- it is over the common divisors of the +absorbed item counts, which is exact and small. Run on the pinned complex word +(``references/pr219-run1/references/pr193-source-assisted-v4.certificate.json``) it answers +the obligation this package carries as T1: + +* **rank 11 tiles alone.** 3186 three-copy items, ``66 = 6 * 11``: four admissible uniform + patterns, B in {3186, 1593, 1062, 531}, of which rung 2's 531 is the tightest (six blocks + per bank, no padding). +* **ranks 16 and 20 tile alone too** -- but only at bank counts *above* the ones the volume + criterion prices. ``66 = 4 * 16 + 2`` and ``66 = 3 * 20 + 6``, so a bank holds at most 4 + rank-16 or 3 rank-20 blocks; 792 rank-16 items therefore need **198** banks, not the 192 + that ``12,672 / 66`` gives, and 198 rank-20 items need **66**, not 60. The priced counts + are below their own capacity bound: 792/192 = 4.125 items per bank in a bank that fits + 4. +* **no mixture is admissible.** For a set of families absorbed together B must divide every + count in the set, and the pattern must fit in 66; for {11,16} the only common divisor is 6 + (k = 531 and 132 blocks per bank), for {16,20} it is 198 (k = 4 and 1, using 84 of the 66 + registers), and for all three it is 18 (k = 177, 44, 11). Every one of them overflows the + bank, so **no uniform tiling of width 66 absorbs two whole bins at once**. +* consequently the rungs' shortfall cannot be repaired by mixing in a *retained* family + either: the padding registers are 2 per rank-16 bank (396 three-copy registers) and 6 per + rank-20 bank (again 396), and paying them from a retained family means removing *part* of + that family's bin -- an absorption the priced ledger does not model, since it removes a + bin whole. That is the precise form of T1's obstruction, and it is what rungs 3 and 4 + owe on top of C1's normalizer. + +The volume criterion (``m | r * n``) and the capacity criterion (``n <= B * floor(m / r)``) +agree exactly when the rank divides the bank width -- which is why rung 1 (rank 22, width +72), rung 2 (rank 11, width 66) and the certified bit-side absorption (rank 60 exteriors, +396,000 / 72 = 5,500 banks, cores of 4 and 24) are all consistent, and why ranks 16 and 20 +are not. +""" +import json +import sys +from fractions import Fraction as Q +from math import gcd +from pathlib import Path + +HERE = Path(__file__).resolve().parent +SUPPLIER = (HERE / 'references' / 'pr219-run1' / 'references' + / 'pr193-source-assisted-v4.certificate.json') +PR205 = HERE / 'references' / 'pr219-run1' / 'references' / 'pr205-packed.certificate.json' +WIDTH = 66 +COPIES = 3 +LADDER = (11, 16, 20) + + +def supplier(): + """The pinned complex profile: width, ledger bins, local rings, stock, deficit.""" + row = json.loads(SUPPLIER.read_text())['complex_profile'] + return dict(m=int(row['m']), + ledger={int(r): int(n) for r, n in row['child_histogram'].items() if n}, + local={int(r): int(n) for r, n in row['local_histogram'].items() if n}, + W=int(row['W_per_vertex']), deficit=int(row['deficit_per_vertex']), + v=int(row['v']), h=int(row['h']), rank=int(row['rank_per_vertex'])) + + +def divisors(n): + out = [] + for d in range(1, int(n ** 0.5) + 1): + if n % d == 0: + out.append(d) + if d != n // d: + out.append(n // d) + return sorted(out) + + +def capacity(width, family): + """Whole blocks of `family` that fit in a bank: the leftover is padding.""" + return width // family + + +def uniform_patterns(counts, width): + """Every uniform pattern absorbing the whole set: B | gcd(counts), sum k_f f <= width.""" + common = 0 + for n in counts.values(): + common = gcd(common, n) + out = [] + for B in divisors(common): + blocks = {f: n // B for f, n in counts.items()} + used = sum(blocks[f] * f for f in blocks) + if used <= width: + out.append(dict(banks=B, blocks=blocks, registers_used=used, + padding_per_bank=width - used, + padding_registers=(width - used) * B)) + return sorted(out, key=lambda entry: entry['banks']) + + +def best_overflow(counts, width): + """The closest a uniform pattern gets for `counts`: its smallest-blocking pattern.""" + common = 0 + for n in counts.values(): + common = gcd(common, n) + attempts = [] + for B in divisors(common): + blocks = {f: n // B for f, n in counts.items()} + used = sum(blocks[f] * f for f in blocks) + attempts.append(dict(banks=B, blocks=blocks, registers_used=used, + overflow=used - width)) + if not attempts: + return None + return min(attempts, key=lambda entry: entry['overflow']) + + +def subset_scan(items, width, families): + """For every subset of the ladder: admissible patterns, or the shortest overflow.""" + from itertools import combinations + out = {} + for size in range(1, len(families) + 1): + for subset in combinations(families, size): + counts = {f: items[f] for f in subset} + patterns = uniform_patterns(counts, width) + entry = dict(families=list(subset), + common_divisor=0, admissible=patterns) + common = 0 + for n in counts.values(): + common = gcd(common, n) + entry['common_divisor'] = common + if not patterns: + entry['closest_attempt'] = best_overflow(counts, width) + out[','.join(map(str, subset))] = entry + return out + + +def tiling(): + """The whole T1 record: capacities, priced counts, patterns, feasibility per subset.""" + data = supplier() + width = data['m'] + one_copy = {f: data['ledger'][f] for f in LADDER} + items = {f: one_copy[f] * COPIES for f in LADDER} + assert width == WIDTH + + families = {} + for f in LADDER: + cap = capacity(width, f) + priced = f * items[f] // width + whole = (f * items[f]) % width == 0 + minimum = -(-items[f] // cap) + families[str(f)] = dict( + per_vertex=one_copy[f], three_copies=items[f], + capacity_per_bank=cap, registers_per_block=f, + whole_bank_volume=whole, volume_registers=f * items[f], + priced_banks=priced, capacity_minimum_banks=minimum, + shortfall_banks=minimum - priced, + items_per_priced_bank=str(Q(items[f], priced)), + fits_the_priced_banks=(Q(items[f], priced) <= cap), + padding_per_bank=width - cap * f, + padding_registers=(width - cap * f) * minimum, + divides_width=(width % f == 0), + ) + + # the certified precedent, read from the pinned bit-side certificate + packed = json.loads(PR205.read_text())['physical'] + precedent = dict(source='references/pr219-run1/references/pr205-packed.certificate.json', + width=72, banks=int(packed['banks']), copies=int(packed['copies']), + note='the only bank construction in the pins: width-72 entrance-gauge ' + 'banks filled by eighteen 4-coordinate or three 24-coordinate ' + 'cores (a rank-60 exterior family, 396,000 three-copy registers = ' + '5,500 banks of its own volume)') + + scan = subset_scan(items, width, LADDER) + return dict( + width=width, copies=COPIES, ladder=list(LADDER), + source_supplier=SUPPLIER.name, one_copy_bins=one_copy, + three_copy_items=items, families=families, + certified_precedent=precedent, + subsets=scan, + findings=dict( + rank_11_tiles_alone=True, + rank_11_patterns=len(scan['11']['admissible']), + rank_11_tightest_banks=scan['11']['admissible'][-1]['banks'], + ranks_16_20_tile_alone_only_above_their_priced_bank_counts=True, + mixed_uniform_tilings=sum(len(entry['admissible']) + for key, entry in scan.items() if ',' in key), + verdict='no admissible uniform tiling of a width-66 bank absorbs two whole ' + 'bins at once, and neither rank 16 nor rank 20 fits the bank count ' + 'its own volume criterion prices', + ), + obligations=dict( + T1='the enumeration above: the mixed tiling ranks 16 and 20 owe has no uniform ' + 'solution, so it must remove part of a retained bin (padding) or use a ' + 'different bank width -- the pins state neither, so the rungs above rung 2 ' + 'stay priced rather than instantiated', + C1='unchanged: the normalizer and item-to-block maps the bank construction owes', + ), + ) + + +def main(): + sys.set_int_max_str_digits(0) + sys.dont_write_bytecode = True + record = tiling() + target = HERE / 'schedule66.json' + target.write_text(json.dumps(record, indent=1, sort_keys=True, default=str) + '\n', + newline='\n') + print('width %d; three-copy items %s' % (record['width'], record['three_copy_items'])) + for f, entry in sorted(record['families'].items(), key=lambda kv: int(kv[0])): + print(' rank %-3s %4d per vertex %5d three-copy: capacity %d/bank -> %4d banks ' + '(priced %4d, short by %d); priced = %s items per bank' + % (f, entry['per_vertex'], entry['three_copies'], entry['capacity_per_bank'], + entry['capacity_minimum_banks'], entry['priced_banks'], + entry['shortfall_banks'], entry['items_per_priced_bank'])) + for key, entry in sorted(record['subsets'].items()): + if entry['admissible']: + print(' {%-8s} %d admissible uniform pattern(s): %s' + % (key, len(entry['admissible']), + [p['banks'] for p in entry['admissible']])) + else: + near = entry['closest_attempt'] + print(' {%-8s} NO uniform pattern: common divisor %d, closest uses %d registers ' + '(%+d)' % (key, entry['common_divisor'], near['registers_used'], + near['overflow'])) + print('verdict %s' % record['findings']['verdict']) + print('write ' + str(target)) + + +if __name__ == '__main__': + main() diff --git a/research/complex-bank-run3/verify.py b/research/complex-bank-run3/verify.py index 76c3dc5870..dd2c1bd672 100644 --- a/research/complex-bank-run3/verify.py +++ b/research/complex-bank-run3/verify.py @@ -28,6 +28,7 @@ import pins # noqa: E402 import run3 # noqa: E402 +import schedule66 # noqa: E402 def digest(path): @@ -44,6 +45,27 @@ def check_manifest(): return actual +def check_schedule(): + """T1's enumeration: the pinned scan must equal a fresh one, findings and all.""" + pinned = json.loads((HERE / 'schedule66.json').read_text()) + fresh = json.loads(json.dumps(schedule66.tiling(), default=str)) + assert pinned == fresh, 'schedule66.json differs from a fresh enumeration' + families = pinned['families'] + assert pinned['width'] == 66 and pinned['copies'] == 3, 'the scan must be width 66' + assert families['11']['priced_banks'] == families['11']['capacity_minimum_banks'] == 531 + for family in ('16', '20'): + entry = families[family] + assert entry['whole_bank_volume'], 'the family must fill whole banks by volume' + assert entry['priced_banks'] < entry['capacity_minimum_banks'], \ + 'the priced bank count must fall below the capacity bound' + assert not entry['fits_the_priced_banks'], 'and the priced count must not fit' + assert pinned['findings']['mixed_uniform_tilings'] == 0 + assert all(not pinned['subsets'][key]['admissible'] + for key in ('11,16', '11,20', '16,20', '11,16,20')), \ + 'no mixed subset may admit a uniform tiling' + return pinned + + def check_obligations(): obligations = json.loads((HERE / 'obligations.json').read_text()) owed = [item['id'] for item in obligations['obligations']] @@ -75,6 +97,7 @@ def main(): if not args.write: check_manifest() + check_schedule() record = run3.build() check_obligations() target = HERE / 'certificate.json' @@ -89,6 +112,13 @@ def main(): read = json.loads(target.read_text()) assert read == json.loads(json.dumps(record, default=str)), 'certificate.json differs' print('certificate.json matches a fresh rebuild') + print('tiling rank 16 and rank 20 price %s and %s banks where their capacity ' + 'requires %s and %s; mixed uniform tilings: %d' + % (record['tiling']['families']['16']['priced_banks'], + record['tiling']['families']['20']['priced_banks'], + record['tiling']['families']['16']['capacity_minimum_banks'], + record['tiling']['families']['20']['capacity_minimum_banks'], + record['tiling']['findings']['mixed_uniform_tilings'])) print('rungs %s at %s banks, kappa %s' % (record['top']['families_absorbed'], record['top']['banks'], record['kappa'])) From 1296f3c4d8c4a5078a367057db261ae2aed11835 Mon Sep 17 00:00:00 2001 From: maxime-fleury Date: Fri, 9 Oct 2026 23:23:05 +0200 Subject: [PATCH 04/11] Prototype the padded width-66 bank schedule, and move the top of the ladder onto it MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The T1 enumeration left exactly one repair: pad the bank. A bank the family cannot fill alone can be filled by the family plus a fixed pattern of retained blocks, so rank 16 fits 198 banks of (4 blocks + 2 registers) and rank 20 fits 66 banks of (3 blocks + 6), every bank exactly full, every item in a block with no slot unused, and the padding drawn as a partial removal from a retained bin (396 rank-1 children of 262,602). Because the mass that leaves is banks * 66 by construction, the row identity and stock-drop-equals-bank-count rule both survive, every padding option can be enumerated and priced, and the padded schedule prices above the volume-criterion rows it replaces: the top of the ladder is now the padded rung 4 at kappa = 711599961413937/10^18, +4.1584% over the frontier. T1 is therefore settled at the schedule level rather than merely owed, and the certificate, the obligations file and both documents say what is still open: C1-C7, the normalizer, frames, charts and prime witnesses, since the padding blocks are ordinary retained children and no new frame family is introduced. 🤖 Generated with Codebuff Co-Authored-By: Codebuff --- research/complex-bank-run3/PROOF.md | 88 +++-- research/complex-bank-run3/README.md | 125 ++++--- research/complex-bank-run3/SOURCE.json | 7 +- research/complex-bank-run3/certificate.json | 357 ++++++++++++++++++-- research/complex-bank-run3/obligations.json | 43 +-- research/complex-bank-run3/pins.py | 5 +- research/complex-bank-run3/prototype66.py | 222 ++++++++++++ research/complex-bank-run3/run3.py | 107 ++++-- research/complex-bank-run3/verify.py | 42 ++- 9 files changed, 868 insertions(+), 128 deletions(-) create mode 100644 research/complex-bank-run3/prototype66.py diff --git a/research/complex-bank-run3/PROOF.md b/research/complex-bank-run3/PROOF.md index 1940cf46a2..92cbcfcb4d 100644 --- a/research/complex-bank-run3/PROOF.md +++ b/research/complex-bank-run3/PROOF.md @@ -74,12 +74,15 @@ Three consequences, all asserted in `verify.py` and recorded in `certificate.jso whole bins at once -- which is also why the padding cannot be paid from a *retained* family, since that would remove part of a bin, while the priced ledger removes bins whole. -The obligation T1 therefore has a determined answer, and it is negative: rungs 3 and 4 are -priced on bank counts that no admissible tiling of a width-66 bank realises. Making them -physical needs either partial-bin removals (a ledger change, which would move the retained -histogram and so the price) or a different bank width (which moves the whole ladder). That -is a sharper statement of the blocker than "a construction is owed", and it is the reason the -upper two rows of the price table carry a caveat rather than a status. +T1's enumeration therefore has a determined answer, and for *uniform* tilings it is negative: +rungs 3 and 4 cannot be priced on the bank counts the volume criterion gives. What the +criterion leaves is the padding -- and the padding is constructible, in exactly the way this +section's third bullet forbids for a *retained* bin but allows for the banks themselves: the +2 or 6 registers are filled by blocks of a retained family, drawn as a partial removal from +that bin. The retained histogram then carries the reduced count, the mass that leaves is +`banks * 66` by construction, and the row identity and the stock-drop-equals-bank-count rule +both survive. Section 3b builds that schedule and prices it; it is what the certificate's top +rung now is, and it prices *above* the unpadded rows because it removes more. ## 3. The ledgers, step by step (three-copy rows) @@ -87,13 +90,46 @@ upper two rows of the price table carry a caveat rather than a status. | --- | ---: | ---: | ---: | ---: | --- | | base | 36,156 | 2,382,336 | 639,441 | 20 | row identity `66 * 12,052 - 794,112 = 1,320` | | rung 2 (+11) | 35,625 | 2,347,290 | 636,255 | 20 | removed 35,046 = 66 x 531; stock drop 531 | -| **rung 3 (+16)** | **35,433** | **2,334,618** | **635,463** | 19 | removed 12,672 = 66 x 192; stock drop 192 | -| **rung 4 (+20)** | **35,373** | **2,330,658** | **635,265** | 19 | removed 3,960 = 66 x 60; stock drop 60 | +| rung 3 (+16), volume criterion | 35,433 | 2,334,618 | 635,463 | 19 | removed 12,672 = 66 x 192; stock drop 192 (not a width-66 tiling, 2b) | +| rung 4 (+20), volume criterion | 35,373 | 2,330,658 | 635,265 | 19 | removed 3,960 = 66 x 60; stock drop 60 (not a width-66 tiling, 2b) | Every row re-satisfies `66 * W - rank_mass = 3,960` (= three copies of the deficit `1,320`, unchanged by banking). The deficit is untouched, which is the point: banking moves dirt from paid children into bank structure, it does not create or destroy rank mass. +### 3b. The padded schedule (`prototype66.py`) + +The rows above are the volume criterion's; the schedule a width-66 bank admits is the padded +one, and this is where it is built. A bank carries the family's whole blocks plus a fixed +pattern of retained ones, with item `i` of the family going to bank `i // k_f`, block +`i % k_f`: + +| rung | banks | per bank | padding per bank | draw (best option) | +| ---: | ---: | --- | ---: | --- | +| 11 | 531 | 6 x rank 11 | 0 | none | +| 16 | 198 | 4 x rank 16 | 2 | 2 rank-1 blocks, i.e. 396 rank-1 children of 262,602 (0.15%) | +| 20 | 66 | 3 x rank 20 | 6 | 6 rank-1 blocks, i.e. 396 rank-1 children | + +Every bank is exactly full (`4 * 16 + 2 = 3 * 20 + 6 = 66`), every item of the family lands in +some block with no slot unused (`4 * 198 = 792`, `3 * 66 = 198`, `6 * 531 = 3,186`), and the +padding is a partial removal from a bin the ledger keeps, so the retained histogram carries the +reduced count. The ledger follows mechanically, because the mass that leaves is `banks * 66`: + +| after | W | rank mass | children | rule applied | +| --- | ---: | ---: | ---: | --- | +| rung 2 (unpadded, as PR224) | 35,625 | 2,347,290 | 636,255 | removed 35,046 = 66 x 531 | +| **rung 3 (padded)** | **35,427** | **2,334,222** | **635,067** | removed 198 x 66 = 12,672 + 396; stock drop **198** | +| **rung 4 (padded)** | **35,361** | **2,329,866** | **634,473** | removed 66 x 66 = 3,960 + 396; stock drop **66** | + +Each padded step re-satisfies the row identity, the stock falls by exactly the bank count, and +the eligibility scan is still empty afterwards, so the padded top is still the top of the +criterion. The padding pattern is a free parameter and every option is enumerated and compared +on the coarse saving it induces (rank 16: two options, `177822495639541/25*10^16` or +`88906856814031/125*10^15`; rank 20: eleven, from `356053348255849/5*10^17` down to +`712015725758741/10^18`); the best is the one claimed, and rank-1 padding wins in both rungs. +What this does *not* do is construct anything physically: the padding blocks are ordinary +retained children, and the normalizer, frames, charts and prime witnesses remain C1-C7. + ## 4. The prices For each rung the complex paid moment is recomputed by the pinned engine on the retained row @@ -104,8 +140,10 @@ complex side), on the `10^-18` grid with the adjacent grid point rejected in bot | --- | ---: | ---: | | base | 7.00918443859411e-4 | — | | rung 2 | 7.08793603125109e-4 | (PR224, reproduced to the digit) | -| **rung 3** | **7.11077971348264e-4** | adjacent point rejected | -| **rung 4** | **7.11681826686289e-4** | adjacent point rejected | +| rung 3, volume criterion | 7.11077971348264e-4 | adjacent point rejected; not a width-66 tiling (2b) | +| rung 4, volume criterion | 7.11681826686289e-4 | adjacent point rejected; not a width-66 tiling (2b) | +| **rung 3, padded schedule** | **7.11289982558164e-4** | adjacent point rejected; 198 banks of (4 rank-16 + 2 registers) | +| **rung 4, padded schedule (the top)** | **7.12106696511698e-4** | adjacent point rejected; 66 banks of (3 rank-20 + 6 registers) | The assembly rule is the queue's own: `a = min(bit_leaf, (1-beta) * C - weak)`, `q = a(1-2 eta)`, `kappa = floor((1-eta) q/(1+q) * 10^18)/10^18`, with @@ -116,8 +154,10 @@ rather than chosen here. | rung | kappa | binding | assembly bound | ceiling gap | | --- | ---: | --- | ---: | ---: | | rung 2 | 7.08291570590726e-4 | complex | 7.082915705907269e-4 | 8.6e-19 | -| **rung 3** | **7.10572698755137e-4** | complex | 7.105726987551371e-4 | < 1e-18 | -| **rung 4** | **7.11175695867958e-4** | complex | 7.111756958679581e-4 | < 1e-18 | +| rung 3, volume criterion | 7.10572698755137e-4 | complex | 7.105726987551371e-4 | < 1e-18 | +| rung 4, volume criterion | 7.11175695867958e-4 | complex | 7.111756958679581e-4 | < 1e-18 | +| **rung 3, padded schedule** | **7.10784408728476e-4** | complex | 7.107844087284761e-4 | < 1e-18 | +| **rung 4, padded schedule (the top)** | **7.11599961413937e-4** | complex | 7.115999614139371e-4 | < 1e-18 | Each rung lands on its own branch ceiling: the complex budget `(1-beta) C - weak` is what the minimum selects (asserted), the adjacent `10^-18` point is rejected by the unchanged @@ -129,8 +169,8 @@ Rung 4 is the top of the accounting ladder: no family of the remaining 17 has a volume (asserted). Two consequences follow, and they are the useful part of the result: * **Above the top, the bank mechanism has nothing left to take.** Reaching `kappa = 7.2e-4` - needs a complex coarse saving of `7.2051877e-4`, i.e. +1.242% over the top rung's coarse - saving -- more banking than this ledger's remaining mass can supply at this width. + needs a complex coarse saving of `7.20518773516934e-4`, i.e. +1.181% over the top rung's + coarse saving -- more banking than this ledger's remaining mass can supply at this width. * **Above `kappa = 7.277251e-4` the bit word is the wall.** While the complex branch caps the budget, the ceiling is `budget/(1+budget)`, and the budget is in turn capped by #219's rung-1 bit leaf (7.2825e-4). Targets `7.5e-4`, `8e-4` and `1e-3` are therefore unreachable @@ -138,17 +178,19 @@ volume (asserted). Two consequences follow, and they are the useful part of the ## 6. Verification boundary -* Machine-checked here: the pinned bytes (21 files, sha256), the frontier reproduction, rung 1 +* Machine-checked here: the pinned bytes (24 files, sha256), the frontier reproduction, rung 1 rebuilt by the vendored #219 package, rung 2 rebuilt by this package's own ledger module, rungs 3 and 4 (volumes, row identities, stock drops, both paid moments, adjacency - rejections), the branch ceilings, the eligibility exhaustion, the PR208 replica and the T1 - enumeration of the width-66 tilings (both the pinned scan and its findings). -* **Not** checked here: any physical realization. C1-C7 and T1 are open, and #219's R1-R4 are - inherited open; the complex supplier has no bank construction in the pins - (machine-checked), and neither new family has an occurrence inventory. T1's *enumeration* - is done here and comes out negative (~2b), so the rungs above rung 2 are priced targets - whose bank counts are not realisable by any uniform tiling -- not merely unconstructed. The - kappa is conditional on all of them, exactly as #219's rung 1 and #224's rung 2 are. + rejections), the branch ceilings, the eligibility exhaustion, the PR208 replica, the T1 + enumeration of the width-66 tilings (both the pinned scan and its findings) and the padded + schedule of 3b (795 banks, every bank exactly filled, stock drops 531/198/66, the residual + eligibility empty, the padded top above the volume-criterion rows it replaces). +* **Not** checked here: any physical realization. C1-C7 are open and #219's R1-R4 are inherited + open; the complex supplier has no bank construction in the pins (machine-checked), and + neither new family has an occurrence inventory. T1 is settled here at the *schedule* level + (~2b and ~3b): no uniform width-66 tiling hosts the rungs, the padded schedule does, and the + padded top is what this package claims. The kappa is conditional on C1-C7 and R1-R4, exactly + as #219's rung 1 and #224's rung 2 are. * Not run: upstream CI, and any contributor verifier other than the vendored #219 package invoked in place. * The `10^-10` supplier field is priced as a conservative variant; on it the ladder's top sits diff --git a/research/complex-bank-run3/README.md b/research/complex-bank-run3/README.md index 508328cf20..d339ebfbba 100644 --- a/research/complex-bank-run3/README.md +++ b/research/complex-bank-run3/README.md @@ -1,8 +1,12 @@ -# Rungs 3 and 4 of the bank ladder: the complex ledger's remainder priced to kappa = 7.11175695867958e-4, and the ladder's top +# Rungs 3 and 4 of the bank ladder: the complex ledger's remainder, its padded width-66 bank schedule, and kappa = 7.11599961413937e-4 -**A priced target, not a witness, and the same blocker as rung 2.** This package prices the +**A scheduled target, not a witness, and the same blocker as rung 2.** This package prices the rest of the bank ladder above PR224's rung 2 -- two more whole-bank families of the complex -ledger -- and records where the accounting criterion the built rungs use stops. +ledger -- records where the accounting criterion the built rungs use stops, and then builds the +bank schedule those rungs need: a width-66 bank tiled by the family's blocks plus a fixed +pattern of retained ones (`prototype66.py`). The padded schedule is admissible where the +unpadded bank count was not, and it prices **higher**, so the top of the ladder is the padded +rung 4. ## Result @@ -11,13 +15,18 @@ ledger -- and records where the accounting criterion the built rungs use stops. | frontier, #207 | — | `1366380910073/2*10^15` = 0.0006831904550365 | bit | reproduced here **exactly** | | rung 1, #219 | bit rank-22 bin, 6,116 width-72 banks | `700427501305159/10^18` = 0.000700427501305159 | complex | reproduced here **exactly**, by importing the vendored #219 package | | rung 2, #224 | complex rank-11 family, 531 banks | `354145785295363/5*10^17` = 0.000708291570590726 | complex | rebuilt here **exactly** by this package's own ledger module | -| **rung 3, this package** | + complex rank-16 family, 192 banks | `710572698755137/10^18` = **0.000710572698755137** | complex | **+0.3221%** over rung 2; blocked (below) | -| **rung 4, this package** | + complex rank-20 family, 60 banks | `355587847933979/5*10^17` = **0.000711175695867958** | complex | **+0.4072%** over rung 2, **+4.0963%** over the frontier; blocked (below) | - -The two bank counts above are the ones the whole-bank volume criterion gives. The T1 scan -below shows a width-66 bank cannot host them: the rank-16 and rank-20 absorptions need 198 -and 66 banks by their own capacity, and no uniform tiling absorbs either family together with -another. Rungs 3 and 4 are priced targets on a bank count no admissible tiling realises. +| rung 3, **volume criterion** | + complex rank-16 family, 192 banks | `710572698755137/10^18` = 0.000710572698755137 | complex | accounting only: no width-66 tiling hosts 192 banks (T1) | +| rung 3, **padded schedule** | + rank-16 family, 198 banks x (4 blocks + 2 registers) | `177696102182119/25*10^16` = **0.000710784408728476** | complex | **+0.3520%** over rung 2 | +| rung 4, **volume criterion** | + complex rank-20 family, 60 banks | `355587847933979/5*10^17` = 0.000711175695867958 | complex | accounting only: no width-66 tiling hosts 60 banks (T1) | +| **rung 4, padded schedule (the top)** | + rank-20 family, 66 banks x (3 blocks + 6 registers) | `711599961413937/10^18` = **0.000711599961413937** | complex | **+0.4671%** over rung 2, **+1.5951%** over rung 1, **+4.1584%** over the frontier | + +The 192- and 60-bank rows are what the whole-bank volume criterion gives, and they are kept +because they are the accounting the criterion produces -- but a width-66 bank cannot host +them: the rank-16 and rank-20 absorptions need 198 and 66 banks by their own capacity, and no +uniform tiling absorbs either family together with another (T1, below). The padded rows are +the schedule a bank actually admits: every bank exactly filled, every item in a block, the +remainder padded from a retained bin, and the retained ledger re-derived. The padded schedule +is the one this package claims. The price is the same ledger in two independent conventions: the `10^-18` grid of the queue's latest rungs (`eta = beta = 10^-24`, `weak = 10^-30`), and PR208's pricing model @@ -43,14 +52,15 @@ exhausted and the complex-side accounting ladder terminates. Each step is checked rather than relabelled: the volume fills whole banks, the retained ledger satisfies the row identity `66 * W - rank_mass = 3,960`, and the stock falls by -exactly the bank count. The ladder's three absorptions occupy **783 width-66 banks** in total -(531 + 192 + 60), and the top row is `W = 35,373`, rank mass `2,330,658`, 635,265 children in +exactly the bank count. The padded schedule occupies **795 width-66 banks** in total +(531 + 198 + 66), and the top row is `W = 35,361`, rank mass `2,329,866`, 634,473 children in 17 families, largest child 19. ## What the pins do not provide (the blocker, unchanged from rung 2) -`obligations.json` states C1-C7 and T1 and inherits #219's R1-R4. The two facts that decide -the status are read from the pins, not asserted: +`obligations.json` states C1-C7 and inherits #219's R1-R4; **T1**, which this package carried as +an obligation, is settled just below -- enumerated, then built at the schedule level. The two +facts that decide the status are read from the pins, not asserted: * **The complex supplier still has no bank construction.** Its certificate carries no key containing `bank` at all (`certificate.json` -> `blocked_on`, machine-checked), and neither @@ -88,23 +98,57 @@ Three findings, each machine-checked: blocks per bank), for {16,20} it is 198 (four and one, 84 registers into a 66-wide bank), for all three it is 18 (177, 44 and 11). Every one overflows the bank. -So the mixed tiling T1 asks for has **no uniform solution**, and the padding cannot be paid -from a retained family either: that would mean removing *part* of a bin, while the priced -ledger removes bins whole. The two rungs' kappas are therefore conditional on bank counts a -tiling cannot realise at all -- a stronger condition than "not constructed". A construction -must either pad with partial-bin removals (a change the ledger does not model) or change the -bank width. The volume criterion and the capacity criterion coincide exactly when the rank -divides the width, which is true of rank 22 at width 72, rank 11 at width 66 and the -certified bit-side rank-60 exteriors (`396,000 / 72 = 5,500` banks, cores of 4 and 24), and -false of ranks 16 and 20. +So T1 has **no uniform solution**, and the unpadded bank counts the volume criterion prices +are not admissible tilings. The volume criterion and the capacity criterion coincide exactly +when the rank divides the width, which is true of rank 22 at width 72, rank 11 at width 66 +and the certified bit-side rank-60 exteriors (`396,000 / 72 = 5,500` banks, cores of 4 and +24), and false of ranks 16 and 20. What the criterion leaves is the padding, and the padding +is constructible: see the prototype below. + +## The prototype: the padded schedule (`prototype66.py`) + +A bank that the family cannot fill alone can still be filled -- by the family plus a fixed +pattern of **retained** blocks. Then every register is accounted for, and the item-to-block +assignment is as explicit as it is for rank 11: item `i` of the family goes to bank +`i // k_f`, block `i % k_f`. + +| rung | banks | blocks per bank | padding per bank | padding registers | padding draw (chosen) | +| --- | ---: | ---: | ---: | ---: | --- | +| 2 (rank 11) | 531 | 6 x rank 11 | 0 | 0 | none: `66 = 6 * 11` | +| 3 (rank 16) | 198 | 4 x rank 16 | 2 | 396 | 2 rank-1 blocks per bank (396 rank-1 children) | +| 4 (rank 20) | 66 | 3 x rank 20 | 6 | 396 | 6 rank-1 blocks per bank (396 rank-1 children) | + +Every bank is exactly full (`4 * 16 + 2 = 66`, `3 * 20 + 6 = 66`), every family item lands in +a block with no slot unused (`4 * 198 = 792`, `3 * 66 = 198`, `6 * 531 = 3,186`), and the +retained ledger is re-derived rather than assumed: the mass that leaves is exactly +`banks * 66`, so the row identity still holds and **the stock falls by exactly the bank count** +(531, 198, 66 on top of rung 2's row). The padding is a *partial* draw from a bin the ledger +keeps -- 396 of the 262,602 rank-1 children, 0.15% -- which is the one step the priced ledger +never took and does not need to: the retained histogram carries the reduced count. + +The padding pattern is a free parameter of the construction, so all of them are enumerated and +compared on the complex coarse saving each induces (the assembly rule of section 4 then maps +the winner to κ, which is the κ in the table above and in `padded_rungs`): + +* rank 16: two options -- 2 rank-1 blocks per bank, coarse `177822495639541/25*10^16`, or 1 + rank-2 block, coarse `88906856814031/125*10^15`; +* rank 20: eleven options, from 6 rank-1 blocks per bank, coarse `356053348255849/5*10^17`, down + to one rank-6 block, coarse `712015725758741/10^18`; the padding rank matters only in the + fifth digit of the saving, and rank-1 padding wins in both rungs. + +The prototype is a **schedule-level** construction and says so: banks, blocks per bank, the +item-to-block map, the padding draw and the ledger it induces are all machine-checked, but the +normalizer that sends each item's residual projector to its block, the frames, charts and prime +witnesses are C1-C7 and remain open. No new frame family is introduced -- the padding blocks +are ordinary retained children. ## What the top rung implies for the next step While the complex branch caps the budget, the assembly's ceiling is `budget/(1+budget)` with the budget capped in turn by the bit leaf of #219's rung-1 bit word (7.2825e-4). So: -* reaching `kappa = 7.2e-4` needs a complex coarse saving of `7.2051877e-4`, i.e. **+1.242%** - over the top rung's own coarse saving -- more banking than this ledger contains; +* reaching `kappa = 7.2e-4` needs a complex coarse saving of `7.20518773516934e-4`, i.e. + **+1.181%** over the top rung's own coarse saving -- more banking than this ledger contains; * reaching `7.5e-4`, `8e-4` or `1e-3` is **impossible on this bit word**: the leaf caps kappa at `1819302815717/25*10^16 = 7.277251...e-4` there, so those targets need a new bit word before any complex-side work can matter. @@ -117,12 +161,12 @@ python3 -B verify.py # check: pins, rebuild, compare with certificate. python3 -B verify.py --write # authoring: regenerate certificate.json and SOURCE.json ``` -`verify.py` passes with exit 0, pins 23 files by sha256, rebuilds the whole complex-side +`verify.py` passes with exit 0, pins 24 files by sha256, rebuilds the whole complex-side ladder (base, rung 2, rungs 3 and 4), both paid moments per rung, the two 47-constraint -assemblies with adjacent-grid rejection, the eligibility scan, the PR208 replica, and re-runs -the T1 tiling enumeration against the pinned `schedule66.json`; it reproduces #207's, #219's -and #224's published grid points exactly. The vendored rung-1 package also self-verifies in -place: +assemblies with adjacent-grid rejection, the eligibility scan, the PR208 replica, the padded +schedule (795 banks, padding 0/2/6 registers per bank, stock drops 531/198/66), and re-runs the +T1 tiling enumeration against the pinned `schedule66.json`; it reproduces #207's, #219's and +#224's published grid points exactly. The vendored rung-1 package also self-verifies in place: ```sh cd research/complex-bank-run3/references/pr219-run1 && python3 -B verify.py @@ -130,14 +174,16 @@ cd research/complex-bank-run3/references/pr219-run1 && python3 -B verify.py ## Scope and limits -* **This is a priced target, not a witness.** The accounting is certified; C1-C7, T1 and the - inherited R1-R4 are open, so the kappa is conditional on them in exactly the sense #219 - states for rung 1 and #224 for rung 2. It is not an unconditional multiplication theorem, - not a practical multiplier, and not a Lean/kernel certificate. -* The whole-bank volume condition is necessary and is the criterion the built rungs use; it - is not sufficient, and for the two new families it is not even compatible with a width-66 - tiling at the bank counts it prices (see the T1 scan above). Rungs 3 and 4 carry that - caveat explicitly. +* **This is a scheduled target, not a witness.** The accounting and the padded bank schedule + are certified; C1-C7 and the inherited R1-R4 are open, so the kappa is conditional on them in + exactly the sense #219 states for rung 1 and #224 for rung 2. It is not an unconditional + multiplication theorem, not a practical multiplier, and not a Lean/kernel certificate. +* T1 is settled here (the enumeration above, plus the padded schedule), and what it settles is + a *schedule*, not a construction: the bank geometry, the item-to-block map and the padding + draw are checked, the normalizer, frames, charts and prime witnesses are C1-C7. +* The whole-bank volume condition is necessary and is the criterion the built rungs use; it is + not sufficient -- for the two new families it is not even compatible with a width-66 tiling + at the bank count it prices, which is why the padded schedule exists. * Nothing here bounds any *other* complex-side lever: the ladder is over this supplier's child ledger at this bank width. A different word, width or frame layout is not priced. * The ladder inherits every interface #207/#219/#224 inherit (all-size compiler, weighted and @@ -158,4 +204,5 @@ rests on are **PR224** (`research/complex-bank-run2`); the bank-absorption ladde underlying bank proof and engine chain is PR200/PR205 (Chafik Boukhalfa and the PR197/PR205 line) and PR184/PR168-v4 (icekylinx/eumemic) as inherited through them. This package adds rungs 3 and 4, their prices, the exhaustion of the ledger's whole-bank criterion, the T1 -enumeration of the width-66 tilings (with its negative result) and the next-step arithmetic. Apache-2.0; no existing file is changed. +enumeration of the width-66 tilings (with its negative result), the padded bank schedule +(`prototype66.py`) and the next-step arithmetic. Apache-2.0; no existing file is changed. diff --git a/research/complex-bank-run3/SOURCE.json b/research/complex-bank-run3/SOURCE.json index 8a0712b9b0..4ad74c20a2 100644 --- a/research/complex-bank-run3/SOURCE.json +++ b/research/complex-bank-run3/SOURCE.json @@ -1,8 +1,9 @@ { "files": { "ledger3.py": "202591f64e76002dd0bc05e7d0c36214db85faf9261bb1757bfb0ca568cc53cd", - "obligations.json": "cb495d71290b1a8d41386530f58ed7899e78f11fe12f229a560e9a652a0ec92a", - "pins.py": "3a7d28b2f1be38243fd4d6625dd0627fcee35e72bd07e21414b934f1cd3c9c00", + "obligations.json": "462be5adf26a6b08ca3a9dc91e16930d22eb4bc1855896b3a32789fb6a66e0c7", + "pins.py": "a6a45735a3b3c7fa329929a6a11d2e5afeba2552adeba0a97be095863b3b6974", + "prototype66.py": "74adbe605ceba533cba1e38b0eca466f67961f4a41e9c839094faa9d503dc2cc", "references/pr207-coordinated-crossover.certificate.json": "f4e30cca369fb014b729df870ca3716cc0f1e2297b9f265341492cba85a14aeb", "references/pr219-run1/NOTICE.md": "1f04b17404663a0983b7cc45e308e577d4d49fb6a4c1ff077dc3f13bae83c56f", "references/pr219-run1/PROOF.md": "b7b9d83d4f87b32a9cba82a56039a18c9843eac0bd18f6a7bdcf9667b27b8a04", @@ -20,7 +21,7 @@ "references/pr219-run1/references/pr205-packed.certificate.json": "c11fbb9aaa99594afc8d21e33761dc6d1d6c76ce3dbc36d5b64cae872c242f5a", "references/pr219-run1/schedule.py": "b9fff272f30048b982da3c0fc0149c2fde20bb7e32b8f9f860069956c12ebdc9", "references/pr219-run1/verify.py": "c839a06389945f9b0c6fbfd59bf2dd8030190c3de504d72c9bf032879f931197", - "run3.py": "784a944d7a9b97fac8c71ef1b86a7f2c68a6f86f363aaf30d1b1684b9f719d6b", + "run3.py": "005568b019277593d742cdd4bd4f506ac7b7d1b3f07a8606763594676890265d", "schedule66.json": "3f11889e722a8a00d1edc7c72bd099ecf0a72c8dd60ae83347b739565b48e919", "schedule66.py": "1683b7e210bdd0d89abbbda8a03959325f38e6e138f473e312987adce8483981" } diff --git a/research/complex-bank-run3/certificate.json b/research/complex-bank-run3/certificate.json index e710cf036a..662f747f0d 100644 --- a/research/complex-bank-run3/certificate.json +++ b/research/complex-bank-run3/certificate.json @@ -50,22 +50,25 @@ }, "comparison": { "frontier": "1366380910073/2000000000000000", + "note": "the volume-criterion rows are the accounting the criterion gives; the padded prototype is the schedule a width-66 bank actually admits, and it is higher, so the top of the ladder is the padded rung 4", + "padded_top": "711599961413937/1000000000000000000", "pr208_priced_rung2": "3541457/5000000000", "rung1": "700427501305159/1000000000000000000", - "rung2": "354145785295363/500000000000000000" + "rung2": "354145785295363/500000000000000000", + "volume_criterion_top": "355587847933979/500000000000000000" }, "conservative_variant": { "certified_moment": "700918443859411/1000000000000000000", "delta": "-43859411/1000000000000000000", "note": "PR193 publishes 219037/312500000 = 7.009184e-4, its value on the 10^-10 grid, 4.3859411e-11 below the 10^-18 certified paid moment of the same profile; the ladder above is priced on the certified moment, which #207 and #219's rung 1 also price. A reviewer who prefers the coarser field sees a smaller top rung: recorded here rather than hidden.", "supplier_field": "219037/312500000", - "top_kappa_on_the_field": "17582790704471/25000000000000000" + "top_kappa_on_the_field": "351867950201249/500000000000000000" }, - "decimal": 0.000711175695867958, - "gain_vs_frontier": "13992620415729/341595227518250", - "gain_vs_rung1": "10748194562799/700427501305159", - "gain_vs_rung2": "1442062638616/354145785295363", - "kappa": "355587847933979/500000000000000000", + "decimal": 0.000711599961413937, + "gain_vs_frontier": "28409506377437/683190455036500", + "gain_vs_rung1": "11172460108778/700427501305159", + "gain_vs_rung2": "3308390823211/708291570590726", + "kappa": "711599961413937/1000000000000000000", "ledgers": { "base_excluded": true, "base_saving": "700918443859411/1000000000000000000", @@ -199,7 +202,7 @@ "budget": "720518773516933/1000000000000000000", "coarse": "360259386758467/500000000000000000", "coarse_decimal": 0.000720518773516934, - "gain_vs_top": "8836946830645/711681826686289", + "gain_vs_top": "4206038502618/356053348255849", "kappa": "720000000000001/1000000000000000000", "needs_new_bit": false, "target": "9/12500" @@ -252,6 +255,317 @@ "R3", "R4" ], + "padded_rungs": [ + { + "adjacent_grid_rejected": true, + "assembly": { + "minimum_constraint": "1/1000000000000000000000000000000" + }, + "binding": "complex", + "bit_leaf_headroom": "16961107432064079570667772624880817987066154658013234139282580595702841889832933964476516783/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "ceiling_gap": "56712147440432621/62544455623909885250000000000000000", + "coarse": "177822495639541/250000000000000000", + "complex_ceiling": "177822495639541/250177822495639541", + "family": 16, + "kappa": "177696102182119/250000000000000000", + "rung": 3 + }, + { + "adjacent_grid_rejected": true, + "assembly": { + "minimum_constraint": "1/1000000000000000000000000000000" + }, + "binding": "complex", + "bit_leaf_headroom": "16144393478530079570667773441594771521066154658013234139282580595702841889832933964476516783/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "ceiling_gap": "334778761129632487/500356053348255849000000000000000000", + "coarse": "356053348255849/500000000000000000", + "complex_ceiling": "356053348255849/500356053348255849", + "family": 20, + "kappa": "711599961413937/1000000000000000000", + "rung": 4 + } + ], + "padded_schedule": { + "base_saving": "700918443859411/1000000000000000000", + "copies": 3, + "exhaustive": true, + "final": { + "W": 35361, + "children": 634473, + "deficit": 3960, + "families": 17, + "largest_child": 19, + "mass": 2329866 + }, + "ladder": [ + { + "alternatives": [ + { + "ceiling": "708793603125109/1000708793603125109", + "draw": {}, + "padding_per_bank": {}, + "saving": "708793603125109/1000000000000000000" + } + ], + "banks": 531, + "block_assignment": 531, + "blocks_per_bank": 6, + "capacity_per_bank": 6, + "ceiling": "708793603125109/1000708793603125109", + "children": 636255, + "chosen": { + "draw": {}, + "padding_per_bank": {}, + "registers_drawn": 0, + "share_of_padding_bin": {} + }, + "eligibility_after": [ + 16, + 20 + ], + "families_left": 19, + "family": 11, + "items": 3186, + "largest_child": 20, + "mass": 2347290, + "options": 1, + "padding_per_bank": 0, + "padding_registers": 0, + "pattern_sum": 66, + "saving": "708793603125109/1000000000000000000", + "stock": 35625, + "stock_drop": 531, + "volume_criterion_banks": 531, + "whole_bank_volume": true + }, + { + "alternatives": [ + { + "ceiling": "177822495639541/250177822495639541", + "draw": { + "1": 396 + }, + "padding_per_bank": { + "1": 2 + }, + "saving": "177822495639541/250000000000000000" + }, + { + "ceiling": "88906856814031/125088906856814031", + "draw": { + "2": 198 + }, + "padding_per_bank": { + "2": 1 + }, + "saving": "88906856814031/125000000000000000" + } + ], + "banks": 198, + "block_assignment": 198, + "blocks_per_bank": 4, + "capacity_per_bank": 4, + "ceiling": "177822495639541/250177822495639541", + "children": 635067, + "chosen": { + "draw": { + "1": 396 + }, + "padding_per_bank": { + "1": 2 + }, + "registers_drawn": 396, + "share_of_padding_bin": { + "1": "22/14589" + } + }, + "eligibility_after": [ + 20 + ], + "families_left": 18, + "family": 16, + "items": 792, + "largest_child": 20, + "mass": 2334222, + "options": 2, + "padding_per_bank": 2, + "padding_registers": 396, + "pattern_sum": 66, + "saving": "177822495639541/250000000000000000", + "stock": 35427, + "stock_drop": 198, + "volume_criterion_banks": 192, + "whole_bank_volume": true + }, + { + "alternatives": [ + { + "ceiling": "356053348255849/500356053348255849", + "draw": { + "1": 396 + }, + "padding_per_bank": { + "1": 6 + }, + "saving": "356053348255849/500000000000000000" + }, + { + "ceiling": "356047479925741/500356047479925741", + "draw": { + "1": 264, + "2": 66 + }, + "padding_per_bank": { + "1": 4, + "2": 1 + }, + "saving": "356047479925741/500000000000000000" + }, + { + "ceiling": "712078797923959/1000712078797923959", + "draw": { + "1": 198, + "3": 66 + }, + "padding_per_bank": { + "1": 3, + "3": 1 + }, + "saving": "712078797923959/1000000000000000000" + }, + { + "ceiling": "178020805894703/250178020805894703", + "draw": { + "1": 132, + "2": 132 + }, + "padding_per_bank": { + "1": 2, + "2": 2 + }, + "saving": "178020805894703/250000000000000000" + }, + { + "ceiling": "35602988188869/50035602988188869", + "draw": { + "1": 132, + "4": 66 + }, + "padding_per_bank": { + "1": 2, + "4": 1 + }, + "saving": "35602988188869/50000000000000000" + }, + { + "ceiling": "712067062184881/1000712067062184881", + "draw": { + "1": 66, + "2": 66, + "3": 66 + }, + "padding_per_bank": { + "1": 1, + "2": 1, + "3": 1 + }, + "saving": "712067062184881/1000000000000000000" + }, + { + "ceiling": "71203859492753/100071203859492753", + "draw": { + "1": 66, + "5": 66 + }, + "padding_per_bank": { + "1": 1, + "5": 1 + }, + "saving": "71203859492753/100000000000000000" + }, + { + "ceiling": "178017871923417/250178017871923417", + "draw": { + "2": 198 + }, + "padding_per_bank": { + "2": 3 + }, + "saving": "178017871923417/250000000000000000" + }, + { + "ceiling": "35602401433333/50035602401433333", + "draw": { + "2": 66, + "4": 66 + }, + "padding_per_bank": { + "2": 1, + "4": 1 + }, + "saving": "35602401433333/50000000000000000" + }, + { + "ceiling": "356025450762813/500356025450762813", + "draw": { + "3": 132 + }, + "padding_per_bank": { + "3": 2 + }, + "saving": "356025450762813/500000000000000000" + }, + { + "ceiling": "712015725758741/1000712015725758741", + "draw": { + "6": 66 + }, + "padding_per_bank": { + "6": 1 + }, + "saving": "712015725758741/1000000000000000000" + } + ], + "banks": 66, + "block_assignment": 66, + "blocks_per_bank": 3, + "capacity_per_bank": 3, + "ceiling": "356053348255849/500356053348255849", + "children": 634473, + "chosen": { + "draw": { + "1": 396 + }, + "padding_per_bank": { + "1": 6 + }, + "registers_drawn": 396, + "share_of_padding_bin": { + "1": "22/14567" + } + }, + "eligibility_after": [], + "families_left": 17, + "family": 20, + "items": 198, + "largest_child": 19, + "mass": 2329866, + "options": 11, + "padding_per_bank": 6, + "padding_registers": 396, + "pattern_sum": 66, + "saving": "356053348255849/500000000000000000", + "stock": 35361, + "stock_drop": 66, + "volume_criterion_banks": 60, + "whole_bank_volume": true + } + ], + "ledger_check": true, + "residual_eligibility": [], + "source": "pr207-coordinated-crossover.certificate.json", + "width": 66 + }, "replica": [ { "family": 11, @@ -308,8 +622,9 @@ ], "source_pins": { "ledger3.py": "202591f64e76002dd0bc05e7d0c36214db85faf9261bb1757bfb0ca568cc53cd", - "obligations.json": "cb495d71290b1a8d41386530f58ed7899e78f11fe12f229a560e9a652a0ec92a", - "pins.py": "3a7d28b2f1be38243fd4d6625dd0627fcee35e72bd07e21414b934f1cd3c9c00", + "obligations.json": "462be5adf26a6b08ca3a9dc91e16930d22eb4bc1855896b3a32789fb6a66e0c7", + "pins.py": "a6a45735a3b3c7fa329929a6a11d2e5afeba2552adeba0a97be095863b3b6974", + "prototype66.py": "74adbe605ceba533cba1e38b0eca466f67961f4a41e9c839094faa9d503dc2cc", "references/pr207-coordinated-crossover.certificate.json": "f4e30cca369fb014b729df870ca3716cc0f1e2297b9f265341492cba85a14aeb", "references/pr219-run1/NOTICE.md": "1f04b17404663a0983b7cc45e308e577d4d49fb6a4c1ff077dc3f13bae83c56f", "references/pr219-run1/PROOF.md": "b7b9d83d4f87b32a9cba82a56039a18c9843eac0bd18f6a7bdcf9667b27b8a04", @@ -327,11 +642,11 @@ "references/pr219-run1/references/pr205-packed.certificate.json": "c11fbb9aaa99594afc8d21e33761dc6d1d6c76ce3dbc36d5b64cae872c242f5a", "references/pr219-run1/schedule.py": "b9fff272f30048b982da3c0fc0149c2fde20bb7e32b8f9f860069956c12ebdc9", "references/pr219-run1/verify.py": "c839a06389945f9b0c6fbfd59bf2dd8030190c3de504d72c9bf032879f931197", - "run3.py": "784a944d7a9b97fac8c71ef1b86a7f2c68a6f86f363aaf30d1b1684b9f719d6b", + "run3.py": "005568b019277593d742cdd4bd4f506ac7b7d1b3f07a8606763594676890265d", "schedule66.json": "3f11889e722a8a00d1edc7c72bd099ecf0a72c8dd60ae83347b739565b48e919", "schedule66.py": "1683b7e210bdd0d89abbbda8a03959325f38e6e138f473e312987adce8483981" }, - "status": "MODEL AND TARGET, NOT CONSTRUCTED: the rung-3 and rung-4 ledgers (whole-bank volume, retained row identities, stock drops, both paid moments on the 10^-18 grid, the two 47-constraint assemblies) are certified here, but every rung above rung 2 needs a bank construction on the complex supplier that no package in the pins provides (obligations.json C1-C7 and T1, plus #219's inherited R1-R4). The kappa below is conditional on those and is not a completed finite witness.", + "status": "MODEL AND TARGET, NOT CONSTRUCTED: the ledger and the bank schedule above rung 2 are certified here -- whole-bank volumes, the padded width-66 schedule itself (banks, blocks per bank, item-to-block assignment, padding draw), the retained row identities with the stock falling by exactly the bank count, both paid moments on the 10^-18 grid, and the two 47-constraint assemblies -- but the physical construction on the complex supplier is still owed (obligations.json C1-C7, plus #219's inherited R1-R4; T1 is settled by the schedule prototype and its negative uniform-tiling result). The kappa below is conditional on those and is not a completed finite witness.", "tiling": { "certified_precedent": { "banks": 45842, @@ -617,12 +932,13 @@ "width": 66 }, "top": { - "banks": 783, + "banks": 795, + "banks_by_volume_criterion": 783, "binding": "complex", - "ceiling": "711681826686289/1000711681826686289", - "ceiling_gap": "399469263583486069/500355840913343144500000000000000000", - "children": 635265, - "coarse": "711681826686289/1000000000000000000", + "ceiling": "356053348255849/500356053348255849", + "ceiling_gap": "334778761129632487/500356053348255849000000000000000000", + "children": 634473, + "coarse": "356053348255849/500000000000000000", "eligibility_exhausted": true, "families_absorbed": [ 11, @@ -630,10 +946,11 @@ 20 ], "families_left": 17, - "kappa": "355587847933979/500000000000000000", + "kappa": "711599961413937/1000000000000000000", "largest_child": 19, "note": "no family of the remaining complex ledger has a whole-bank volume, so the accounting criterion the built rungs use cannot be applied again without a different bank width or a mixed tiling that reopens the volume condition; the T1 scan of this certificate shows the mixed tiling has no uniform solution either, and that rungs 3 and 4 are priced at 192 and 60 banks where their own capacities require 198 and 66", - "rank_mass": 2330658, - "stock": 35373 + "rank_mass": 2329866, + "schedule": "padded prototype (prototype66.py): 531 + 198 + 66 = 795 banks, the rank-16 and rank-20 banks padded with 2 and 6 registers of retained blocks", + "stock": 35361 } } diff --git a/research/complex-bank-run3/obligations.json b/research/complex-bank-run3/obligations.json index a97b64d2de..f8111488d9 100644 --- a/research/complex-bank-run3/obligations.json +++ b/research/complex-bank-run3/obligations.json @@ -1,5 +1,5 @@ { - "claim_scope": "This package certifies an accounting ledger and its exact price: the whole-bank volume condition, the retained row identity with the stock falling by the bank count, both complex paid moments with the adjacent 10^-18 grid point excluded, the unchanged 47-constraint assembly at the rung-2 budget with its adjacent point rejected, and an independent replica of the same ledger in PR208's pricing convention. The rung is NOT constructed: C1 has no precedent in the pins and C5 has no inventory. The kappa is therefore a priced, exactly certified target conditional on C1-C5 and on #219's inherited R1-R4, and it is not a completed finite witness or an unconditional multiplication theorem in any case.", + "claim_scope": "This package certifies an accounting ledger, the padded bank schedule the rungs need, and the exact price: the whole-bank volume condition, the T1 enumeration of the width-66 tilings (no uniform solution) and the padded schedule that replaces it (every bank exactly filled, the padding drawn as a partial removal from a retained bin), the retained row identity with the stock falling by the bank count, both complex paid moments with the adjacent 10^-18 grid point excluded, the unchanged 47-constraint assembly at each rung's budget with its adjacent point rejected, and an independent replica of the same ledger in PR208's pricing convention. The rung is NOT constructed physically: C1 has no precedent in the pins and C5-C7 have no inventory, so the schedule is instanced but the normalizer, frames, charts and prime witnesses are not. The kappa is therefore a scheduled, exactly certified target conditional on C1-C7 and on #219's inherited R1-R4, and it is not a completed finite witness or an unconditional multiplication theorem in any case.", "inherited": [ { "id": "R1", @@ -29,10 +29,10 @@ "obligations": [ { "generalized_to_rungs_3_4": { - "banks_one_copy": 783, - "banks_three_copies": 783, + "banks_one_copy": 265, + "banks_three_copies": 795, "blocks": "six rank-11 blocks per bank where the rank divides the width; the rank-16 and rank-20 blocks need the mixed tiling of T1", - "note": "This item was written for rung 2 (rank 11, 531 three-copy banks). The ladder of this package applies it to ranks 11, 16 and 20 together: 783 three-copy banks, 261 per copy, with rungs 3 and 4 replacing 192 and 60 of them respectively.", + "note": "This item was written for rung 2 (rank 11, 531 three-copy banks). The ladder of this package applies it to ranks 11, 16 and 20 together, at the padded schedule's bank counts: 795 three-copy banks, 265 per copy, with rungs 3 and 4 taking 198 and 66 of them.", "ranks": "11, 16, 20 (the whole-bank families of this ledger)" }, "id": "C1", @@ -44,10 +44,10 @@ }, { "generalized_to_rungs_3_4": { - "banks_one_copy": 783, - "banks_three_copies": 783, + "banks_one_copy": 265, + "banks_three_copies": 795, "blocks": "six rank-11 blocks per bank where the rank divides the width; the rank-16 and rank-20 blocks need the mixed tiling of T1", - "note": "This item was written for rung 2 (rank 11, 531 three-copy banks). The ladder of this package applies it to ranks 11, 16 and 20 together: 783 three-copy banks, 261 per copy, with rungs 3 and 4 replacing 192 and 60 of them respectively.", + "note": "This item was written for rung 2 (rank 11, 531 three-copy banks). The ladder of this package applies it to ranks 11, 16 and 20 together, at the padded schedule's bank counts: 795 three-copy banks, 265 per copy, with rungs 3 and 4 taking 198 and 66 of them.", "ranks": "11, 16, 20 (the whole-bank families of this ledger)" }, "id": "C2", @@ -58,10 +58,10 @@ }, { "generalized_to_rungs_3_4": { - "banks_one_copy": 783, - "banks_three_copies": 783, + "banks_one_copy": 265, + "banks_three_copies": 795, "blocks": "six rank-11 blocks per bank where the rank divides the width; the rank-16 and rank-20 blocks need the mixed tiling of T1", - "note": "This item was written for rung 2 (rank 11, 531 three-copy banks). The ladder of this package applies it to ranks 11, 16 and 20 together: 783 three-copy banks, 261 per copy, with rungs 3 and 4 replacing 192 and 60 of them respectively.", + "note": "This item was written for rung 2 (rank 11, 531 three-copy banks). The ladder of this package applies it to ranks 11, 16 and 20 together, at the padded schedule's bank counts: 795 three-copy banks, 265 per copy, with rungs 3 and 4 taking 198 and 66 of them.", "ranks": "11, 16, 20 (the whole-bank families of this ledger)" }, "id": "C3", @@ -72,10 +72,10 @@ }, { "generalized_to_rungs_3_4": { - "banks_one_copy": 783, - "banks_three_copies": 783, + "banks_one_copy": 265, + "banks_three_copies": 795, "blocks": "six rank-11 blocks per bank where the rank divides the width; the rank-16 and rank-20 blocks need the mixed tiling of T1", - "note": "This item was written for rung 2 (rank 11, 531 three-copy banks). The ladder of this package applies it to ranks 11, 16 and 20 together: 783 three-copy banks, 261 per copy, with rungs 3 and 4 replacing 192 and 60 of them respectively.", + "note": "This item was written for rung 2 (rank 11, 531 three-copy banks). The ladder of this package applies it to ranks 11, 16 and 20 together, at the padded schedule's bank counts: 795 three-copy banks, 265 per copy, with rungs 3 and 4 taking 198 and 66 of them.", "ranks": "11, 16, 20 (the whole-bank families of this ledger)" }, "id": "C4", @@ -86,10 +86,10 @@ }, { "generalized_to_rungs_3_4": { - "banks_one_copy": 783, - "banks_three_copies": 783, + "banks_one_copy": 265, + "banks_three_copies": 795, "blocks": "six rank-11 blocks per bank where the rank divides the width; the rank-16 and rank-20 blocks need the mixed tiling of T1", - "note": "This item was written for rung 2 (rank 11, 531 three-copy banks). The ladder of this package applies it to ranks 11, 16 and 20 together: 783 three-copy banks, 261 per copy, with rungs 3 and 4 replacing 192 and 60 of them respectively.", + "note": "This item was written for rung 2 (rank 11, 531 three-copy banks). The ladder of this package applies it to ranks 11, 16 and 20 together, at the padded schedule's bank counts: 795 three-copy banks, 265 per copy, with rungs 3 and 4 taking 198 and 66 of them.", "ranks": "11, 16, 20 (the whole-bank families of this ledger)" }, "id": "C5", @@ -102,7 +102,7 @@ "id": "C6", "name": "rank-16 family inventory on the complex word", "reference_precedent": "PR219 references/pr219-run1/inputs/absorbed-occurrences.json (rank-22 provenance), which this family has no counterpart of.", - "statement": "Enumerate the complex word's rank-16 child family: its 264 occurrences per vertex (792 over the three copies), their frame or chain identity, a bijection onto the 192 three-copy blocks the absorption of rung 3 needs, and a proof that no other bin of the ledger moves. Nothing in the pins enumerates this family, exactly as nothing enumerates the rank-11 family of PR224 or the rank-22 bin of PR219's bit-side absorption, whose inventory (inputs/absorbed-occurrences.json) is what made that rung a closed checklist.", + "statement": "Enumerate the complex word's rank-16 child family: its 264 occurrences per vertex (792 over the three copies), their frame or chain identity, a bijection onto the 792 three-copy blocks the absorption of rung 3 needs (four per bank over 198 banks), and a proof that no other bin of the ledger moves. Nothing in the pins enumerates this family, exactly as nothing enumerates the rank-11 family of PR224 or the rank-22 bin of PR219's bit-side absorption, whose inventory (inputs/absorbed-occurrences.json) is what made that rung a closed checklist.", "status": "OPEN", "why_it_is_the_blocker": "A rung that cannot name its items cannot be built: the item-to-block map of C1 has no starting inventory for this family, so its absorption is priced but not instantiated." }, @@ -110,7 +110,7 @@ "id": "C7", "name": "rank-20 family inventory on the complex word", "reference_precedent": "PR219 references/pr219-run1/inputs/absorbed-occurrences.json.", - "statement": "The same enumeration for the rank-20 family: 66 occurrences per vertex (198 over the three copies) onto the 60 three-copy blocks of rung 4, with the same no-other-bin-moves proof.", + "statement": "The same enumeration for the rank-20 family: 66 occurrences per vertex (198 over the three copies) onto the 198 three-copy blocks of rung 4 (three per bank over 66 banks), with the same no-other-bin-moves proof.", "status": "OPEN", "why_it_is_the_blocker": "Same gap as C6, one rung further; it is the last family of the ledger that satisfies the whole-bank volume condition." }, @@ -119,8 +119,9 @@ "name": "mixed tiling of the width-66 bank for ranks 16 and 20", "reference_precedent": "PR219 references/pr219-run1/schedule.py (width-72 tilings over {4, 24, 22}); research/coordinated-frames-and-entrance-banks BANK-PROOF-PR200.md (18 four-coordinate cores or 3 24-coordinate cores fill a width-72 bank).", "statement": "Rank 11 divides the bank width (66 = 6 x 11) and needed no mixture, but 66 = 4 x 16 + 2 and 66 = 3 x 20 + 6: the rank-16 and rank-20 blocks cannot tile a 66-wide bank on their own, so their banks must mix block sizes. The obligation is to enumerate the admissible tilings of width 66 over the families the complex word actually offers, choose one per bank, and show that the chosen pattern realises exactly 264 rank-16 and 66 rank-20 children per vertex -- i.e. that every absorbed item lands in some block and no block is left half-used.", - "status": "OPEN", - "why_it_is_the_blocker": "It is the same obligation PR219 carries as R1 for the bit word (admissible tilings of width 72 over families {4, 24, 22}), but with no analogous enumeration to inherit: the bit word's bank pattern is pinned in the bank proof, the complex word has none.", + "status": "SETTLED_AT_SCHEDULE_LEVEL", + "why_it_is_the_blocker": "It was: the same obligation PR219 carries as R1 for the bit word (admissible tilings of width 72 over families {4, 24, 22}), but with no analogous enumeration to inherit, the bit word's bank pattern being pinned in the bank proof and the complex word having none. Both halves are now done here: the enumeration has no uniform solution, and the padded schedule fills every bank exactly at the capacity bank count.", + "resolution": "prototype66.py (checked by verify.py, recorded in certificate.json -> padded_schedule): rank 16 into 198 banks of 4 rank-16 blocks + 2 registers of padding, rank 20 into 66 banks of 3 rank-20 blocks + 6 registers, rank 11 unchanged (531 banks of 6 blocks). Every bank is exactly filled, every item lands in a block with no slot unused, the padding is drawn as a partial removal from a retained bin (396 rank-1 children of 262,602, 0.15%), the mass that leaves is exactly banks * 66 so the row identity holds and the stock falls by exactly the bank count, and every padding option is enumerated and priced (the best is claimed). The padded schedule prices higher than the volume-criterion rows it replaces, and it is what certificate.json's top rung is. Still open on top of it: C1-C7 -- the normalizer, frames, charts and prime witnesses -- since the padding blocks are ordinary retained children and no new frame family is introduced.", "enumeration": { "status": "ENUMERATED, RESULT NEGATIVE", "artifact": "schedule66.py, schedule66.json (this package, checked by verify.py)", @@ -134,7 +135,7 @@ } } ], - "status": "OPEN obligations for rungs 3 and 4. verify.py certifies the accounting (whole-bank volumes, retained row identities, stock drops equal to the bank counts, both paid moments on the 10^-18 grid, the two 47-constraint assemblies and the exclusion of the adjacent grid points) and the exact prices; it discharges none of these items.", + "status": "C1-C7 and the inherited R1-R4 remain OPEN; T1 is SETTLED_AT_SCHEDULE_LEVEL. verify.py certifies the accounting (whole-bank volumes, retained row identities, stock drops equal to the bank counts, both paid moments on the 10^-18 grid, the two 47-constraint assemblies and the exclusion of the adjacent grid points), the T1 enumeration, the padded schedule and the exact prices; it discharges no other item.", "why_rung_3_and_4": { "consequence": "the accounting ladder on the complex word terminates at rung 4; going higher needs a different bank width, a different ledger (a new supplier), or a mixed tiling that reopens the volume condition.", "numbers": { diff --git a/research/complex-bank-run3/pins.py b/research/complex-bank-run3/pins.py index 109e63ab29..2f9d2faec0 100644 --- a/research/complex-bank-run3/pins.py +++ b/research/complex-bank-run3/pins.py @@ -13,8 +13,9 @@ HERE = Path(__file__).resolve().parent VENDORED_RUN1 = 'references/pr219-run1' -OWN = ('ledger3.py', 'run3.py', 'schedule66.py', 'schedule66.json', 'pins.py', - 'obligations.json', 'references/pr207-coordinated-crossover.certificate.json') +OWN = ('ledger3.py', 'run3.py', 'schedule66.py', 'schedule66.json', 'prototype66.py', + 'pins.py', 'obligations.json', + 'references/pr207-coordinated-crossover.certificate.json') def pinned_paths(): diff --git a/research/complex-bank-run3/prototype66.py b/research/complex-bank-run3/prototype66.py new file mode 100644 index 0000000000..5a08003d02 --- /dev/null +++ b/research/complex-bank-run3/prototype66.py @@ -0,0 +1,222 @@ +#!/usr/bin/env python3 +"""The complex-side bank construction, prototyped at the schedule level. + +`schedule66.py` settles obligation T1 the hard way: no *uniform* tiling of a width-66 bank +absorbs a whole rank-16 or rank-20 bin, and none absorbs two bins at once. What it leaves is +the obvious repair -- **pad the bank**. A bank that cannot be filled by the family alone can +be filled by the family plus a fixed pattern of *retained* blocks, and then every register of +the bank is accounted for: + +* rank 16: ``66 = 4 * 16 + 2``, so a bank carries **four rank-16 blocks and 2 registers of + padding**; 792 three-copy items fill 198 banks exactly (4 x 198 = 792, no family slot + unused), and the padding is 396 registers; +* rank 20: ``66 = 3 * 20 + 6``, so **three rank-20 blocks and 6 registers of padding**; 198 + items fill 66 banks exactly, padding again 396 registers; +* rank 11: ``66 = 6 * 11``, no padding (rung 2 as PR224 built it). + +The padding is drawn from a family the ledger keeps -- 2 registers is one rank-2 block or two +rank-1 blocks; 6 is one rank-6, two rank-3, three rank-2, or six rank-1 blocks, and so on -- +so the padded absorption removes *part* of a retained bin. That is the step the priced ledger +never took, and it is exactly consistent: if the padding registers leave with the blocks, the +retained row still satisfies ``m * W - rank_mass = deficit`` and the stock falls by **exactly +the bank count**, because the mass removed is ``banks * m`` by construction. Each padding +option is a free parameter of the construction, so this module enumerates them and prices each +one with the pinned engine, reporting the best. + +What this is and is not: it is a **schedule-level construction** -- banks, blocks per bank, the +item-to-bank/offset assignment (``item i -> bank i // k_f, block i % k_f``), the padding draw +and the ledger it induces, all checked. It is not the physical construction: the normalizer +that sends each item's residual projector to its block, the charts and the prime witnesses are +still C1-C7, and the padding blocks are ordinary retained children, not new frames. + +Everything is exact rational arithmetic from the pinned complex profile, through the pinned +interval-moment engine, priced on the complex side (`bit=False`) exactly as PR219 prices it. +""" +import importlib.util +import json +import sys +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +if str(HERE) not in sys.path: + sys.path.insert(0, str(HERE)) + +import ledger3 # noqa: E402 + +WIDTH = 66 +COPIES = 3 +RUNGS = (11, 16, 20) +FRONTIER = HERE / 'references' / 'pr207-coordinated-crossover.certificate.json' + + +def partitions(total, sizes): + """Every multiset of `sizes` summing to exactly `total`, largest block first.""" + sizes = sorted(s for s in sizes if 0 < s <= total) + out = [] + + def walk(remaining, index, chosen): + if remaining == 0: + out.append(tuple(sorted(chosen, reverse=True))) + return + for j in range(index, len(sizes)): + if sizes[j] > remaining: + break + walk(remaining - sizes[j], j, chosen + [sizes[j]]) + + walk(total, 0, []) + return out + + +def schedule(row, family, width=WIDTH): + """The saturated bank schedule for one family, with every padding option. + + Returns the bank count (the family's capacity minimum, not the volume criterion's + number), the blocks per bank, and one entry per padding tiling: the draw it takes from + the ledger, the retained row, and the ledger facts that must hold for each. + """ + m, W, D = row['m'], row['W'], row['N'] + hist = dict(row['child_multiplicities']) + n = hist[family] + capacity = width // family + banks = -(-n // capacity) # capacity minimum, ceil(n / k_f) + assert banks * capacity >= n, 'every item must land in a block' + assert (n + capacity - 1) // capacity == banks, 'the bank count is the minimum' + padding = banks * width - family * n # registers of padding, total + assert banks * width == family * n + padding, 'the bank must be exactly filled' + assert n == capacity * banks, 'the schedule must be saturated: no family slot unused' + assert padding % banks == 0, 'every bank must carry the same padding' + per_bank_padding = padding // banks + assert per_bank_padding == width - family * capacity, 'padding = the unfilled registers' + + options = [] + for pattern in (partitions(per_bank_padding, sorted(hist)) + if per_bank_padding else [()]): + assert sum(pattern) == per_bank_padding, 'the padding must fill the bank' + assert all(size in hist for size in pattern), 'padding blocks come from the ledger' + if any(size == family for size in pattern): + continue # a padding block of the same rank is that family's item + per_bank = {} + for size in pattern: + per_bank[size] = per_bank.get(size, 0) + 1 + draw = {size: per_bank[size] * banks for size in per_bank} + if any(draw[size] > hist[size] for size in draw): + continue # the ledger cannot supply the draw + kept = dict(hist) + kept[family] -= n # the whole bin leaves + del kept[family] + for size in draw: + kept[size] -= draw[size] + if kept[size] == 0: + del kept[size] + mass = sum(r * c for r, c in kept.items()) + stock, remainder = divmod(mass + D, m) + assert remainder == 0, 'half-filled stock' + assert W - stock == banks, 'the stock must fall by exactly the bank count' + retained = dict(m=m, W=stock, N=D, L=row.get('L', 0), child_multiplicities=kept, + total_rank=mass, maxchild=max(kept)) + assert ledger3.check_row(retained) == mass + assert family * n + sum(s * draw[s] for s in draw) == banks * m, \ + 'the removed mass must be exactly the bank volume' + options.append(dict( + padding_per_bank={str(s): per_bank[s] for s in sorted(per_bank)}, + padding_registers=padding, draw={str(s): draw[s] for s in sorted(draw)}, + registers_drawn=sum(s * draw[s] for s in draw), + retained=retained, stock=stock, stock_drop=W - stock, + children=sum(kept.values()), + share_of_padding_bin={str(s): Q(draw[s], hist[s]) for s in sorted(draw)}, + )) + + # the assignment itself: item i of the family -> bank i // k_f, block i % k_f + blocks_per_bank = {} + for block in range(capacity): + blocks_per_bank[block + 1] = [i for i in range(n) if i % capacity == block] + assert sum(len(items) for items in blocks_per_bank.values()) == n, 'an item was lost' + assert all(len(items) == banks for items in blocks_per_bank.values()), \ + 'every block must be filled in every bank' + return dict(family=family, banks=banks, items=n, capacity_per_bank=capacity, + blocks_per_bank=capacity, padding_registers=padding, + padding_per_bank=padding // banks, + pattern_sum=family * capacity + padding // banks, + options=options, block_assignment=banks) + + +def priced_ladder(certificate_path=FRONTIER, interval=None, width=WIDTH): + """Rung 2, then the padded rungs 3 and 4: the schedule, the ledger; and the price. + + Each rung takes the padding option that raises the complex paid moment the most, and the + chain is carried on from there, since the padding changes the retained histogram. + """ + interval = interval or ledger3.engine() + certificate = json.loads(Path(certificate_path).read_text()) + row = ledger3.profile(certificate['complex_profile']) + ledger3.check_row(row) + + base = ledger3.certify(interval, row) + work = ledger3.three_copies(row) + ladder, exhaustive = [], True + for family in RUNGS: + step = schedule(work, family, width) + priced = [] + for option in step['options']: + saving = ledger3.certify(interval, option['retained'])['saving'] + priced.append(dict(option, saving=saving, ceiling=ledger3.ceiling(saving))) + assert priced, 'a family that fills whole banks must have a padding option' + best = max(priced, key=lambda entry: entry['saving']) + work = best['retained'] + ladder.append(dict( + family=family, banks=step['banks'], items=step['items'], + blocks_per_bank=step['blocks_per_bank'], capacity_per_bank=step['capacity_per_bank'], + padding_registers=step['padding_registers'], + padding_per_bank=step['padding_per_bank'], pattern_sum=step['pattern_sum'], + block_assignment=step['block_assignment'], + options=len(priced), chosen=dict( + padding_per_bank=best['padding_per_bank'], draw=best['draw'], + registers_drawn=best['registers_drawn'], + share_of_padding_bin={k: str(v) + for k, v in best['share_of_padding_bin'].items()}), + alternatives=[dict(padding_per_bank=entry['padding_per_bank'], + draw=entry['draw'], saving=entry['saving'], + ceiling=entry['ceiling']) for entry in priced], + saving=best['saving'], ceiling=best['ceiling'], + stock=best['stock'], stock_drop=best['stock_drop'], + children=best['children'], mass=best['retained']['total_rank'], + families_left=len(best['retained']['child_multiplicities']), + largest_child=max(best['retained']['child_multiplicities']), + whole_bank_volume=(family * step['items']) % width == 0, + volume_criterion_banks=family * step['items'] // width, + eligibility_after=ledger3.eligibility(best['retained']), + )) + exhaustive = ladder[-1]['eligibility_after'] == [] + return dict(width=width, copies=COPIES, source=Path(certificate_path).name, + base_saving=base['saving'], ledger_check=ledger3.check_row(work) == work['total_rank'], + ladder=ladder, exhaustive=exhaustive, + final=dict(W=work['W'], deficit=work['N'], mass=work['total_rank'], + children=sum(work['child_multiplicities'].values()), + families=len(work['child_multiplicities']), + largest_child=max(work['child_multiplicities'])), + residual_eligibility=ledger3.eligibility(work)) + + +def main(): + sys.set_int_max_str_digits(0) + sys.dont_write_bytecode = True + out = priced_ladder() + print('padded schedule prototype, width %d, source %s' % (out['width'], out['source'])) + print('base complex coarse saving %s' % out['base_saving']) + for step in out['ladder']: + print(' rank %-3d %4d items -> %4d banks x %d blocks/bank + %d registers padding ' + '(%d options)' % (step['family'], step['items'], step['banks'], + step['blocks_per_bank'], step['padding_per_bank'], + step['options'])) + print(' chosen padding %s (draw %s), coarse saving %s, ceiling %s' + % (step['padding_per_bank'], step['chosen']['draw'], step['saving'], + step['ceiling'])) + print(' stock %d (drop %d = banks), children %d, families left %d, ' + 'eligibility after %s' % (step['stock'], step['stock_drop'], step['children'], + step['families_left'], step['eligibility_after'])) + print('exhausted at the padded top: %s' % out['exhaustive']) + + +if __name__ == '__main__': + main() diff --git a/research/complex-bank-run3/run3.py b/research/complex-bank-run3/run3.py index 335f8252bc..d6e3525475 100644 --- a/research/complex-bank-run3/run3.py +++ b/research/complex-bank-run3/run3.py @@ -34,6 +34,12 @@ bank, exhaustively. Rank 11 tiles alone (four patterns, rung 2's 531 the tightest); ranks 16 and 20 tile alone only *above* the bank counts their own volume criterion prices (198 and 66, against 192 and 60); and no uniform tiling absorbs two bins at once. +9. **The prototype** (`prototype66.py`): the bank schedule those rungs need, at the bank + count their capacity requires -- every bank exactly filled (four rank-16 blocks and 2 + registers of padding, three rank-20 blocks and 6), the item-to-block assignment, the + padding drawn from a retained bin, the ledger it induces (the stock falling by exactly + the bank count) and the price of every padding option. The padded schedule beats the + volume-criterion accounting it replaces, so the certificate's top rung is the padded one. python3 -B run3.py [--out certificate.json] """ @@ -50,6 +56,7 @@ import ledger3 # noqa: E402 (local module, imported after the path is set) import pins # noqa: E402 +import prototype66 # noqa: E402 import schedule66 # noqa: E402 REFERENCES = HERE / 'references' @@ -292,10 +299,52 @@ def build(): rungs = [rung_record(supplier, step, leaf, index + 3) for index, step in enumerate(part['ladder'][1:])] - top = rungs[-1] + + # --- 3c. the prototype: the padded schedule those rungs need -------------- + padded = prototype66.priced_ladder(FRONTIER, interval) + assert Q(padded['base_saving']) == a_complex, 'the prototype prices the same supplier' + assert [step['family'] for step in padded['ladder']] == list(RUNGS), 'rung order' + pad_rung2 = padded['ladder'][0] + assert pad_rung2['banks'] == part['ladder'][0]['banks'] == 531 \ + and Q(pad_rung2['saving']) == RUN2_COARSE, \ + 'the prototype must reproduce rung 2 exactly, and it needs no padding there' + assert pad_rung2['padding_per_bank'] == 0, 'rank 11 tiles its banks on its own' + for step, priced_step in zip(part['ladder'], padded['ladder']): + assert step['banks'] <= priced_step['banks'], 'the padded count is the upper one' + assert priced_step['banks'] == families[str(priced_step['family'])][ + 'capacity_minimum_banks'], 'the prototype must use the capacity minimum' + assert priced_step['stock_drop'] == priced_step['banks'], \ + 'the stock must fall by exactly the bank count' + assert priced_step['pattern_sum'] == 66, 'every bank must be exactly filled' + assert priced_step['blocks_per_bank'] * priced_step['banks'] \ + == priced_step['items'], 'the schedule must be saturated' + assert all(step['whole_bank_volume'] for step in padded['ladder']), \ + 'the padded families are the ones the volume criterion already selects' + assert padded['ladder'][1]['banks'] == 198 and padded['ladder'][2]['banks'] == 66 + assert padded['ladder'][1]['padding_registers'] == 396 \ + and padded['ladder'][2]['padding_registers'] == 396, 'the padding of T1' + assert padded['exhaustive'] and padded['residual_eligibility'] == [], \ + 'the padded top must still exhaust the whole-bank criterion' + for step in padded['ladder']: + assert step['options'] >= 1, 'every step must offer a padding option' + assert all(Q(option['saving']) <= Q(step['saving']) + for option in step['alternatives']), 'the chosen option is the best one' + assert any(Q(option['saving']) == Q(step['saving']) + for option in step['alternatives']), 'the best must be among the options' + assert all(Q(option['saving']) > Q(part['base_saving']) + for option in step['alternatives']), \ + 'every padding option must raise the complex coarse saving' + assert step['whole_bank_volume'], 'the padded families are the volume ones' + assert all(Q(step['saving']) > Q(part['base_saving']) for step in padded['ladder']), \ + 'every rung must raise the complex coarse saving' + padded_rungs = [rung_record(supplier, step, leaf, index + 3) + for index, step in enumerate(padded['ladder'][1:])] + top = padded_rungs[-1] # the realizable top, not the volume one kappa_top, coarse_top = top['kappa'], top['coarse'] - assert coarse_top == Q(part['final_saving']) == Q(part['ladder'][-1]['saving']) + assert coarse_top == Q(padded['ladder'][-1]['saving']) assert kappa_top > RUN2_KAPPA, 'the top rung must beat rung 2' + assert kappa_top > rungs[-1]['kappa'], \ + 'the padded top must beat the unpadded count it replaces' # --- 4. the independent replica at PR208's convention --------------------- bit_row = ledger3.profile(frontier['bit_profile']) @@ -324,13 +373,15 @@ def build(): needs.append(info) certificate = dict( - status='MODEL AND TARGET, NOT CONSTRUCTED: the rung-3 and rung-4 ledgers ' - '(whole-bank volume, retained row identities, stock drops, both paid ' - 'moments on the 10^-18 grid, the two 47-constraint assemblies) are certified ' - 'here, but every rung above rung 2 needs a bank construction on the complex ' - 'supplier that no package in the pins provides (obligations.json C1-C7 and ' - "T1, plus #219's inherited R1-R4). The kappa below is conditional on those " - 'and is not a completed finite witness.', + status='MODEL AND TARGET, NOT CONSTRUCTED: the ledger and the bank schedule above ' + 'rung 2 are certified here -- whole-bank volumes, the padded width-66 schedule ' + 'itself (banks, blocks per bank, item-to-block assignment, padding draw), the ' + 'retained row identities with the stock falling by exactly the bank count, both ' + 'paid moments on the 10^-18 grid, and the two 47-constraint assemblies -- but ' + 'the physical construction on the complex supplier is still owed ' + '(obligations.json C1-C7, plus #219\'s inherited R1-R4; T1 is settled by the ' + 'schedule prototype and its negative uniform-tiling result). The kappa below ' + 'is conditional on those and is not a completed finite witness.', rung=4, kappa=kappa_top, decimal=float(kappa_top), binding=top['binding'], gain_vs_rung1=kappa_top / RUN1_KAPPA - 1, @@ -345,14 +396,20 @@ def build(): ledgers=part, tiling=tiling, rungs=rungs, + padded_schedule=padded, + padded_rungs=padded_rungs, replica=replica, top=dict(kappa=str(kappa_top), coarse=str(coarse_top), binding=top['binding'], families_absorbed=list(RUNGS), banks=sum(step['banks'] - for step in part['ladder']), - stock=part['final_row']['W'], rank_mass=part['final_row']['mass'], - children=part['final_row']['children'], - families_left=part['final_row']['families'], - largest_child=part['final_row']['maxchild'], + for step in padded['ladder']), + banks_by_volume_criterion=sum(step['banks'] for step in part['ladder']), + schedule='padded prototype (prototype66.py): 531 + 198 + 66 = 795 banks, ' + 'the rank-16 and rank-20 banks padded with 2 and 6 registers of ' + 'retained blocks', + stock=padded['final']['W'], rank_mass=padded['final']['mass'], + children=padded['final']['children'], + families_left=padded['final']['families'], + largest_child=padded['final']['largest_child'], eligibility_exhausted=True, ceiling=str(top['complex_ceiling']), ceiling_gap=str(top['ceiling_gap']), note='no family of the remaining complex ledger has a whole-bank volume, ' @@ -375,7 +432,12 @@ def build(): blocked_on=bank_evidence(), obligations=['C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'T1', 'R1', 'R2', 'R3', 'R4'], comparison=dict(rung1=str(RUN1_KAPPA), rung2=str(RUN2_KAPPA), frontier=str( - Q(frontier['kappa'])), pr208_priced_rung2=str(RUN2_REPLICA)), + Q(frontier['kappa'])), pr208_priced_rung2=str(RUN2_REPLICA), + volume_criterion_top=str(rungs[-1]['kappa']), + padded_top=str(padded_rungs[-1]['kappa']), + note='the volume-criterion rows are the accounting the criterion gives; the padded ' + 'prototype is the schedule a width-66 bank actually admits, and it is ' + 'higher, so the top of the ladder is the padded rung 4'), source_pins=pins.manifest(), ) return certificate @@ -397,18 +459,25 @@ def main(): print('rung 2 coarse %s, kappa %s (reproduced exactly)' % (record['calibrations']['run2']['coarse'], record['calibrations']['run2']['published'])) for step, rung in zip(record['ledgers']['ladder'][1:], record['rungs']): - print('rung %d rank %-3s volume %-7s = %-4s banks coarse %-19s kappa %-19s %+.4f%% vs rung 2' - % (rung['rung'], step['family'], step['volume'], step['banks'], step['saving'], + print('volume rank %-3s volume %-7s = %-4s banks coarse %-19s kappa %-19s %+.4f%% vs rung 2' + % (step['family'], step['volume'], step['banks'], step['saving'], rung['kappa'], float(Q(rung['kappa']) / RUN2_KAPPA - 1) * 100)) + for step, rung in zip(record['padded_schedule']['ladder'][1:], record['padded_rungs']): + print('prototype rank %-3s %4d items = %4d banks x %d blocks + %d pad coarse %-19s ' + 'kappa %-19s %+.4f%% vs rung 2' + % (step['family'], step['items'], step['banks'], step['blocks_per_bank'], + step['padding_per_bank'], step['saving'], rung['kappa'], + float(Q(rung['kappa']) / RUN2_KAPPA - 1) * 100)) print('top kappa = %s = %.17g (binding %s, %+.4f%% over rung 1, %+.4f%% over rung 2, ' '%+.4f%% over the frontier)' % (record['kappa'], float(Q(record['kappa'])), record['binding'], float(Q(record['gain_vs_rung1'])) * 100, float(Q(record['gain_vs_rung2'])) * 100, float(Q(record['gain_vs_frontier'])) * 100)) - print('top row W=%s rank mass=%s children=%s families=%s largest child=%s' + print('top row W=%s rank mass=%s children=%s families=%s largest child=%s (padded ledger)' % (record['top']['stock'], record['top']['rank_mass'], record['top']['children'], record['top']['families_left'], record['top']['largest_child'])) - print('exhausted %s (families with a whole-bank volume left)' % record['ledgers']['final_eligibility']) + print('exhausted %s (families with a whole-bank volume left)' + % record['padded_schedule']['residual_eligibility']) for need in record['needed_for']: if need['coarse'] is None: print('to reach %-8s needs a NEW BIT WORD: the bit leaf %s caps the budget at %s ' diff --git a/research/complex-bank-run3/verify.py b/research/complex-bank-run3/verify.py index dd2c1bd672..ec047b8680 100644 --- a/research/complex-bank-run3/verify.py +++ b/research/complex-bank-run3/verify.py @@ -17,6 +17,7 @@ import argparse import json import sys +from fractions import Fraction as Q from hashlib import sha256 from pathlib import Path @@ -66,11 +67,43 @@ def check_schedule(): return pinned +def check_prototype(record): + """The padded schedule's own invariants, as rebuilt into the certificate.""" + padded = record['padded_schedule'] + assert padded['width'] == 66 and padded['copies'] == 3, 'the prototype is width 66' + assert [step['family'] for step in padded['ladder']] == [11, 16, 20], 'rung order' + assert [step['banks'] for step in padded['ladder']] == [531, 198, 66], \ + 'the prototype must use the capacity minimum, not the volume criterion' + assert [step['padding_per_bank'] for step in padded['ladder']] == [0, 2, 6], \ + 'the padding of T1' + for step in padded['ladder']: + assert step['pattern_sum'] == 66, 'every bank must be exactly filled' + assert step['blocks_per_bank'] * step['banks'] == step['items'], \ + 'the schedule must be saturated' + assert step['stock_drop'] == step['banks'], \ + 'the stock must fall by exactly the bank count' + assert step['family'] == 11 or step['padding_registers'] % step['banks'] == 0 + assert step['eligibility_after'] in ([16, 20], [20], []), 'the ladder climbs' + assert padded['exhaustive'] and padded['residual_eligibility'] == [], \ + 'the whole-bank criterion must be exhausted at the padded top' + assert Q(record['top']['kappa']) > Q(record['comparison']['volume_criterion_top']), \ + 'the padded schedule must beat the volume-criterion accounting it replaces' + assert record['top']['banks'] == 795, '531 + 198 + 66 banks, the padded schedule' + return padded + + def check_obligations(): obligations = json.loads((HERE / 'obligations.json').read_text()) owed = [item['id'] for item in obligations['obligations']] assert owed == ['C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'T1'], owed - assert all(item['status'] == 'OPEN' for item in obligations['obligations']) + status = {item['id']: item['status'] for item in obligations['obligations']} + assert all(status[key] == 'OPEN' for key in owed if key != 'T1'), \ + 'every obligation but T1 must still be open' + assert status['T1'] == 'SETTLED_AT_SCHEDULE_LEVEL', \ + "T1 is settled by the schedule prototype, and must be recorded as such" + t1 = next(item for item in obligations['obligations'] if item['id'] == 'T1') + assert 'resolution' in t1 and 'prototype66' in t1['resolution'], \ + 'T1 must name the artifact that settles it' inherited = [item['id'] for item in obligations['inherited']] assert inherited == ['R1', 'R2', 'R3', 'R4'], inherited assert all(item['status'] == 'OPEN' for item in obligations['inherited']) @@ -99,6 +132,7 @@ def main(): check_manifest() check_schedule() record = run3.build() + check_prototype(record) check_obligations() target = HERE / 'certificate.json' if args.write: @@ -119,6 +153,12 @@ def main(): record['tiling']['families']['16']['capacity_minimum_banks'], record['tiling']['families']['20']['capacity_minimum_banks'], record['tiling']['findings']['mixed_uniform_tilings'])) + print('prototype padded schedule %s banks (%s + %s + %s), padding %s per bank, ' + 'stock drops %s' + % (record['top']['banks'], *[step['banks'] + for step in record['padded_schedule']['ladder']], + [step['padding_per_bank'] for step in record['padded_schedule']['ladder']], + [step['stock_drop'] for step in record['padded_schedule']['ladder']])) print('rungs %s at %s banks, kappa %s' % (record['top']['families_absorbed'], record['top']['banks'], record['kappa'])) From e1c4cbf78b237f07f91a776e67411c5d665abe18 Mon Sep 17 00:00:00 2001 From: maxime-fleury Date: Fri, 9 Oct 2026 23:40:23 +0200 Subject: [PATCH 05/11] Instance the bank schedule's items, and settle whether the width is a dial MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two questions the last commit left open, both answered by measurement rather than by argument. The bank width is the word's own modulus -- the pinned bit-side schedule fixes M = 72, banks = volume/72 and stock drop = bank count -- so a width scan is a word scan: the pinned ledger's rank mass over stock is 65.8905, which makes every modulus of 65 or under unposeable (66 is the smallest it admits), and every wider modulus leaves a row whose density has moved (95.5% at 69, 91.5% at 72), i.e. a different word, so only the pinned width is priced -- where the scan reproduces this package's top exactly, as its own calibration. The scan also shows the criterion is not the cap: at modulus 54 nine families would tile 1,549,098 registers (65% of the rank mass) whole, against 52,470 here, so the dial to turn is the supplier's density, not the bank layout. Then the schedule is instanced: all 4,176 items of the three families get a bank, a block and an offset under item i -> bank i//k, block i%k, with per-family table digests, every bank exactly filled, the padding named, and the ledger re-derived with the stock falling by exactly the bank count. That instantiates C1's combinatorial half and the C5-C7 inventories; what stays owed is stated from the pins rather than in prose -- the complex supplier's certificate has no bank key and its own status line says the operation program is not exported, so the residual projectors the normalizer must move are simply not there. 🤖 Generated with Codebuff Co-Authored-By: Codebuff --- research/complex-bank-run3/PROOF.md | 31 +- research/complex-bank-run3/README.md | 76 +- research/complex-bank-run3/SOURCE.json | 11 +- research/complex-bank-run3/certificate.json | 1275 ++++++++++++++++- research/complex-bank-run3/instantiate66.py | 230 +++ research/complex-bank-run3/obligations.json | 24 +- research/complex-bank-run3/occurrences66.json | 197 +++ research/complex-bank-run3/pins.py | 4 +- research/complex-bank-run3/run3.py | 74 + research/complex-bank-run3/verify.py | 57 +- research/complex-bank-run3/widths66.py | 177 +++ 11 files changed, 2124 insertions(+), 32 deletions(-) create mode 100644 research/complex-bank-run3/instantiate66.py create mode 100644 research/complex-bank-run3/occurrences66.json create mode 100644 research/complex-bank-run3/widths66.py diff --git a/research/complex-bank-run3/PROOF.md b/research/complex-bank-run3/PROOF.md index 92cbcfcb4d..0b26dcfb6c 100644 --- a/research/complex-bank-run3/PROOF.md +++ b/research/complex-bank-run3/PROOF.md @@ -130,6 +130,25 @@ on the coarse saving it induces (rank 16: two options, `177822495639541/25*10^16 What this does *not* do is construct anything physically: the padding blocks are ordinary retained children, and the normalizer, frames, charts and prime witnesses remain C1-C7. +### 3c. The instanced schedule, and the width question + +`instantiate66.py` instances the schedule: item `i` of a family goes to bank `i // k_f`, block +`i % k_f`, offset `(i % k_f) * rank`, which addresses 3,186 + 792 + 198 = **4,176 items** over +531 + 198 + 66 = **795 banks** with 792 registers of padding, each family's table digested +(`fb9bd2d1...`, `f96efd45...`, `f9d9567b...`) and the ledger re-derived with the stock falling +by exactly the bank count. That is C1's combinatorial half plus the C5-C7 inventories; the +physical half (the normalizer) and C2-C4 are still owed, because the supplier's own status line +says its operation program is not exported. + +`widths66.py` then settles whether the bank width is a dial. It is not: the pinned precedent +makes it the word's modulus (`M = 72` for the bit word, 66 here). The engine's contraction is +`rank mass < W * modulus`, the pinned row has `rank mass / W = 65.8905...`, so every `w <= 65` +leaves the row unposeable -- 66 is the smallest modulus this ledger admits -- and every wider +modulus leaves a row whose density has moved (99.834% at 66, 95.5% at 69, 91.5% at 72), i.e. a +different word, which the scan records rather than prices. At `w = 54` nine families would tile +whole banks and 1,549,098 registers (65% of the rank mass) could leave, against 52,470 (2.2%) +here: the criterion is not the cap, the density is, so the dial to turn is the supplier. + ## 4. The prices For each rung the complex paid moment is recomputed by the pinned engine on the retained row @@ -178,15 +197,19 @@ volume (asserted). Two consequences follow, and they are the useful part of the ## 6. Verification boundary -* Machine-checked here: the pinned bytes (24 files, sha256), the frontier reproduction, rung 1 +* Machine-checked here: the pinned bytes (27 files, sha256), the frontier reproduction, rung 1 rebuilt by the vendored #219 package, rung 2 rebuilt by this package's own ledger module, rungs 3 and 4 (volumes, row identities, stock drops, both paid moments, adjacency rejections), the branch ceilings, the eligibility exhaustion, the PR208 replica, the T1 enumeration of the width-66 tilings (both the pinned scan and its findings) and the padded schedule of 3b (795 banks, every bank exactly filled, stock drops 531/198/66, the residual - eligibility empty, the padded top above the volume-criterion rows it replaces). -* **Not** checked here: any physical realization. C1-C7 are open and #219's R1-R4 are inherited - open; the complex supplier has no bank construction in the pins (machine-checked), and + eligibility empty, the padded top above the volume-criterion rows it replaces), the instanced + inventories of 3c (4,176 items, 795 banks, 792 registers of padding, the digests, the ledger + cross-check) and the modulus scan of 3c (which widths are poseable, and that only the pinned + one is priced). +* **Not** checked here: any physical realization. C1's physical half, C2-C4 and #219's R1-R4 + are open (C5-C7 have their inventories instanced, each child's frame/chain identity still + owed); the complex supplier has no bank construction in the pins (machine-checked), and neither new family has an occurrence inventory. T1 is settled here at the *schedule* level (~2b and ~3b): no uniform width-66 tiling hosts the rungs, the padded schedule does, and the padded top is what this package claims. The kappa is conditional on C1-C7 and R1-R4, exactly diff --git a/research/complex-bank-run3/README.md b/research/complex-bank-run3/README.md index d339ebfbba..57b40409b9 100644 --- a/research/complex-bank-run3/README.md +++ b/research/complex-bank-run3/README.md @@ -142,6 +142,65 @@ normalizer that sends each item's residual projector to its block, the frames, c witnesses are C1-C7 and remain open. No new frame family is introduced -- the padding blocks are ordinary retained children. +## Is the bank width a lever? (`widths66.py`) + +The bank width is not a schedule parameter: the pinned precedent makes it **the word's own +modulus**. In `references/pr219-run1/schedule.py` the bit word has `M = 72`, its rank-22 bin's +20,016 occurrences carry `22 * 20,016 = 440,352` registers into `440,352 / 72 = 6,116` banks, +the row identity is `M * W - mass = D`, and the stock drops by exactly the bank count. The +complex word's modulus is 66, which is why its banks are width 66. So "use another width" is a +question about the word, and the scan answers it in three machine-checked parts: + +* **No narrower modulus exists for this ledger.** The engine's contraction is + `rank mass < W * modulus`, and the pinned row has `rank mass / W = 65.8905...`, so every + `w <= 65` leaves the row unposeable (`mass >= w * W`) -- checked at 48, 54, 58, 60, 63, 64 + and 65 in the certificate. 66 is the *smallest* modulus this ledger admits, by exact + arithmetic rather than by sampling. +* **At the pinned width the scan reproduces this package.** Running the whole criterion at + `w = 66` returns the same schedule and the same κ, which is the scan's calibration + (asserted in `verify.py`). +* **Wider moduli are different words, and the scan shows why instead of quoting a number.** + Holding the pinned ledger fixed while raising `w` leaves a row whose rank mass fills only + `mass / (W * w)` of its capacity: 99.834% at 66, **95.5% at 69, 91.5% at 72, 68.6% at 96**. + That is no longer the dense ledger the moment is calibrated on -- and the vendored + certifier's own bracket stops holding there, which is why the scan prices `66` and records + the rest as arithmetic. + +The useful part is what the scan exposes about the *criterion*: at `w = 54`, nine of the 20 +families would tile whole banks and **1,549,098 registers (65% of the rank mass)** could leave +-- for comparison, the pinned ladder leaves 52,470 (2.2%). The criterion is not what caps +the ladder; the ledger's density is. A **less** dense complex word -- more stock per unit of +rank mass -- would admit a narrower modulus where far more of its ledger tiles at once. That +is the concrete thing to look for in a new supplier, and it is a measurement, not a guess. + +## What is instanced, and what is still owed (`instantiate66.py`) + +The padded schedule is now instanced, which is C1's combinatorial half and C5-C7's +inventories: every item of every absorbed family has a bank, a block and an offset, under the +rule *item `i` -> bank `i // k_f`, block `i % k_f`, offset `(i % k_f) * rank`*. + +| family | per vertex | items (3 copies) | banks | blocks per bank | padding registers | table digest | +| ---: | ---: | ---: | ---: | ---: | ---: | --- | +| 11 | 1,062 | 3,186 | 531 | 6 | 0 | `fb9bd2d17f69...` | +| 16 | 264 | 792 | 198 | 4 | 396 | `f96efd45d9d9...` | +| 20 | 66 | 198 | 66 | 3 | 396 | `f9d9567b4b41...` | + +**795 banks, 4,176 items addressed**, 792 registers of padding (0.30% of the kept rank-1 bin), +every bank exactly filled, every block holding exactly one item, the map a bijection onto the +bank/block/offset grid, a digest per family over the whole table, and the ledger re-derived +with the stock falling by exactly the bank count. The artifact is pinned in +[occurrences66.json](research/complex-bank-run3/occurrences66.json). + +What is still owed is stated as facts read from the pins, not as prose: the complex supplier's +certificate carries **no key containing `bank`** and its own status line declares that a literal +globally renumbered operation program **is not exported** -- so the residual projectors the +normalizer must move (C1's physical half) are not in the pins, only the item counts are. C2, +C3 and C4 (formal columns, charts and prime witnesses, moment-envelope parity) follow the same +gap, and C5-C7 still owe each child's frame/chain identity. The *shape* of the inventory the +complex side owes is pinned -- for the bit word, at +`references/pr219-run1/inputs/absorbed-occurrences.json`, whose per-vertex keys +(`H`, `H_center`, `Y`, `src`) are recorded in the certificate. + ## What the top rung implies for the next step While the complex branch caps the budget, the assembly's ceiling is `budget/(1+budget)` with @@ -161,12 +220,14 @@ python3 -B verify.py # check: pins, rebuild, compare with certificate. python3 -B verify.py --write # authoring: regenerate certificate.json and SOURCE.json ``` -`verify.py` passes with exit 0, pins 24 files by sha256, rebuilds the whole complex-side +`verify.py` passes with exit 0, pins 27 files by sha256, rebuilds the whole complex-side ladder (base, rung 2, rungs 3 and 4), both paid moments per rung, the two 47-constraint assemblies with adjacent-grid rejection, the eligibility scan, the PR208 replica, the padded -schedule (795 banks, padding 0/2/6 registers per bank, stock drops 531/198/66), and re-runs the -T1 tiling enumeration against the pinned `schedule66.json`; it reproduces #207's, #219's and -#224's published grid points exactly. The vendored rung-1 package also self-verifies in place: +schedule (795 banks, padding 0/2/6 registers per bank, stock drops 531/198/66), the instanced +inventories (4,176 items, 795 banks, the digests), the modulus scan (which widths the pinned +row admits, and that only the pinned width is priced), and re-runs the T1 tiling enumeration +against the pinned `schedule66.json`; it reproduces #207's, #219's and #224's published grid +points exactly. The vendored rung-1 package also self-verifies in place: ```sh cd research/complex-bank-run3/references/pr219-run1 && python3 -B verify.py @@ -178,9 +239,10 @@ cd research/complex-bank-run3/references/pr219-run1 && python3 -B verify.py are certified; C1-C7 and the inherited R1-R4 are open, so the kappa is conditional on them in exactly the sense #219 states for rung 1 and #224 for rung 2. It is not an unconditional multiplication theorem, not a practical multiplier, and not a Lean/kernel certificate. -* T1 is settled here (the enumeration above, plus the padded schedule), and what it settles is - a *schedule*, not a construction: the bank geometry, the item-to-block map and the padding - draw are checked, the normalizer, frames, charts and prime witnesses are C1-C7. +* T1 is settled here (the enumeration above, plus the padded schedule), and C1's combinatorial + half with C5-C7's inventories are instanced on top of it; what all of that settles is a + *schedule*: the bank geometry, the item addresses and the padding draw are checked, the + normalizer, frames, charts and prime witnesses are C1 (physical half), C2, C3 and C4. * The whole-bank volume condition is necessary and is the criterion the built rungs use; it is not sufficient -- for the two new families it is not even compatible with a width-66 tiling at the bank count it prices, which is why the padded schedule exists. diff --git a/research/complex-bank-run3/SOURCE.json b/research/complex-bank-run3/SOURCE.json index 4ad74c20a2..90e9f01e51 100644 --- a/research/complex-bank-run3/SOURCE.json +++ b/research/complex-bank-run3/SOURCE.json @@ -1,8 +1,10 @@ { "files": { + "instantiate66.py": "add272a8507bf81810fe36a8e9193afcca5fa708d9149a6700868f01c99075a2", "ledger3.py": "202591f64e76002dd0bc05e7d0c36214db85faf9261bb1757bfb0ca568cc53cd", - "obligations.json": "462be5adf26a6b08ca3a9dc91e16930d22eb4bc1855896b3a32789fb6a66e0c7", - "pins.py": "a6a45735a3b3c7fa329929a6a11d2e5afeba2552adeba0a97be095863b3b6974", + "obligations.json": "cf887f237fc02204c25c7fd5234d4ded392a8a5397b4ab6bffc9d26a32b7d20e", + "occurrences66.json": "d755258f115236356ee1b34a84ee98414eee42dd9eeb4f7034abf39b0dac5653", + "pins.py": "c2d6034b0282b6c73d30eb41c2510597b2fdfb5df26dea3d99b0004deda76fa0", "prototype66.py": "74adbe605ceba533cba1e38b0eca466f67961f4a41e9c839094faa9d503dc2cc", "references/pr207-coordinated-crossover.certificate.json": "f4e30cca369fb014b729df870ca3716cc0f1e2297b9f265341492cba85a14aeb", "references/pr219-run1/NOTICE.md": "1f04b17404663a0983b7cc45e308e577d4d49fb6a4c1ff077dc3f13bae83c56f", @@ -21,8 +23,9 @@ "references/pr219-run1/references/pr205-packed.certificate.json": "c11fbb9aaa99594afc8d21e33761dc6d1d6c76ce3dbc36d5b64cae872c242f5a", "references/pr219-run1/schedule.py": "b9fff272f30048b982da3c0fc0149c2fde20bb7e32b8f9f860069956c12ebdc9", "references/pr219-run1/verify.py": "c839a06389945f9b0c6fbfd59bf2dd8030190c3de504d72c9bf032879f931197", - "run3.py": "005568b019277593d742cdd4bd4f506ac7b7d1b3f07a8606763594676890265d", + "run3.py": "57c50303d5cff110ec6a4c9c2501b052850cacbdeec9a08f9ff52787b6940418", "schedule66.json": "3f11889e722a8a00d1edc7c72bd099ecf0a72c8dd60ae83347b739565b48e919", - "schedule66.py": "1683b7e210bdd0d89abbbda8a03959325f38e6e138f473e312987adce8483981" + "schedule66.py": "1683b7e210bdd0d89abbbda8a03959325f38e6e138f473e312987adce8483981", + "widths66.py": "8b230906566113c0f1b742f2a246925ad11c0ab8ad51dc5167fb4d3e7b7dc905" } } diff --git a/research/complex-bank-run3/certificate.json b/research/complex-bank-run3/certificate.json index 662f747f0d..1daf8d7008 100644 --- a/research/complex-bank-run3/certificate.json +++ b/research/complex-bank-run3/certificate.json @@ -64,6 +64,203 @@ "supplier_field": "219037/312500000", "top_kappa_on_the_field": "351867950201249/500000000000000000" }, + "construction": { + "copies": 3, + "inventories": { + "11": { + "address_rule": "item i -> bank i // k, block i % k, offset (i % k) * rank", + "bank_table_digest": "fb9bd2d17f69823324ef9212248ba2741be5f7dd504cfb61a9992872b32f0a59", + "banks": 531, + "capacity_per_bank": 6, + "children_per_vertex": 1062, + "copies": 3, + "family": 11, + "first_addresses": [ + { + "bank": 0, + "block": 0, + "item": 0, + "offset": 0, + "padding_registers": [], + "registers": 11 + }, + { + "bank": 0, + "block": 1, + "item": 1, + "offset": 11, + "padding_registers": [], + "registers": 11 + } + ], + "items": 3186, + "last_address": { + "bank": 530, + "block": 5, + "item": 3185, + "offset": 55, + "padding_registers": [], + "registers": 11 + }, + "padding_blocks_per_bank": 0, + "padding_per_bank": 0, + "padding_registers": 0 + }, + "16": { + "address_rule": "item i -> bank i // k, block i % k, offset (i % k) * rank", + "bank_table_digest": "f96efd45d9d912cec54d9d1633fdc47af34e05948cd8e3ab4305432e0ce35fbb", + "banks": 198, + "capacity_per_bank": 4, + "children_per_vertex": 264, + "copies": 3, + "family": 16, + "first_addresses": [ + { + "bank": 0, + "block": 0, + "item": 0, + "offset": 0, + "padding_registers": [], + "registers": 16 + }, + { + "bank": 0, + "block": 1, + "item": 1, + "offset": 16, + "padding_registers": [], + "registers": 16 + } + ], + "items": 792, + "last_address": { + "bank": 197, + "block": 3, + "item": 791, + "offset": 48, + "padding_registers": [], + "registers": 16 + }, + "padding_blocks_per_bank": 2, + "padding_per_bank": 2, + "padding_registers": 396 + }, + "20": { + "address_rule": "item i -> bank i // k, block i % k, offset (i % k) * rank", + "bank_table_digest": "f9d9567b4b41d5ba567aafff43927d568820792667daf6590fb00a3478890a77", + "banks": 66, + "capacity_per_bank": 3, + "children_per_vertex": 66, + "copies": 3, + "family": 20, + "first_addresses": [ + { + "bank": 0, + "block": 0, + "item": 0, + "offset": 0, + "padding_registers": [], + "registers": 20 + }, + { + "bank": 0, + "block": 1, + "item": 1, + "offset": 20, + "padding_registers": [], + "registers": 20 + } + ], + "items": 198, + "last_address": { + "bank": 65, + "block": 2, + "item": 197, + "offset": 40, + "padding_registers": [], + "registers": 20 + }, + "padding_blocks_per_bank": 6, + "padding_per_bank": 6, + "padding_registers": 396 + } + }, + "ledger_cross_check": { + "children": 634473, + "criterion_exhausted": true, + "rank_mass": 2329866, + "retained_stock": 35361, + "stock_drops": [ + 531, + 198, + 66 + ] + }, + "pins_gap": { + "complex_supplier_bank_keys": [], + "complex_supplier_occurrence_keys": [], + "complex_supplier_status": "Exact local invertible flow, exact all-column fresh identity, paid source controls, target read chains, and integer histogram certified. A literal globally renumbered operation program is not exported; dense initial dirty-response subtraction is defined by the exact certified flow.", + "complex_supplier_status_says_no_operation_program": true, + "pinned_bank_construction": { + "bank_controls_keys": [ + "formal_columns_per_case", + "rejected", + "weighted_partition_cases" + ], + "gauge_roles": 2200, + "note": "width-72 entrance-gauge banks on the bit word: the only bank construction in the pins, and the one whose block/normalizer pattern a complex-side construction would have to mirror without inheriting", + "path": "references/pr219-run1/references/pr205-packed.certificate.json", + "physical_banks": 45842 + }, + "pinned_item_inventory": { + "counts_per_vertex": { + "ledger_bin_22_per_vertex": 6672, + "ledger_bin_22_three_copies": 20016, + "normalization_factor_in_row": 3, + "physical_internal_H": 1344, + "physical_target_Y": 0, + "source_chain_src": 880 + }, + "note": "the only per-child inventory in the pins: it is the bit word's rank-22 family, and it is what closes #219 R1. The shape the complex side owes is this shape -- one entry per child with its chain/frame provenance.", + "path": "references/pr219-run1/inputs/absorbed-occurrences.json", + "per_vertex_keys": [ + "H", + "H_center", + "Y", + "src" + ], + "top_level_keys": [ + "counts_per_vertex", + "occurrences_per_vertex", + "row_identity_per_vertex", + "source_pins", + "status" + ] + } + }, + "rungs": [ + 11, + 16, + 20 + ], + "status": "C1 combinatorial half and C5-C7 inventories INSTANCED at the schedule level: every item of every absorbed family has a bank, a block and an offset, and the ledger the schedule induces is re-derived. The physical half of C1 (the normalizer) and C2-C4 (formal columns, charts and prime witnesses, moment envelope parity) remain open: the pins export the item counts, not the residual projectors the normalizer must move.", + "still_owed": { + "C1_physical": "the normalizer sending each item's residual projector to its block: the addresses exist here (bank, block, offset), the projectors the pinned certificates export do not", + "C2": "formal columns of the modified complex word after re-assignment", + "C3": "charts, routing and prime witnesses for the new complex blocks", + "C4": "complex moment-envelope parity for the re-assigned word", + "C5": "per-child provenance for the rank-11 family: the item addresses exist, the chain/frame identity of each child does not (see the gap)", + "C6": "the same for the rank-16 family", + "C7": "the same for the rank-20 family" + }, + "totals": { + "banks": 795, + "items": 4176, + "padding_registers": 792, + "padding_share_of_the_kept_bin": "44/14589" + }, + "width": 66 + }, "decimal": 0.000711599961413937, "gain_vs_frontier": "28409506377437/683190455036500", "gain_vs_rung1": "11172460108778/700427501305159", @@ -621,9 +818,11 @@ } ], "source_pins": { + "instantiate66.py": "add272a8507bf81810fe36a8e9193afcca5fa708d9149a6700868f01c99075a2", "ledger3.py": "202591f64e76002dd0bc05e7d0c36214db85faf9261bb1757bfb0ca568cc53cd", - "obligations.json": "462be5adf26a6b08ca3a9dc91e16930d22eb4bc1855896b3a32789fb6a66e0c7", - "pins.py": "a6a45735a3b3c7fa329929a6a11d2e5afeba2552adeba0a97be095863b3b6974", + "obligations.json": "cf887f237fc02204c25c7fd5234d4ded392a8a5397b4ab6bffc9d26a32b7d20e", + "occurrences66.json": "d755258f115236356ee1b34a84ee98414eee42dd9eeb4f7034abf39b0dac5653", + "pins.py": "c2d6034b0282b6c73d30eb41c2510597b2fdfb5df26dea3d99b0004deda76fa0", "prototype66.py": "74adbe605ceba533cba1e38b0eca466f67961f4a41e9c839094faa9d503dc2cc", "references/pr207-coordinated-crossover.certificate.json": "f4e30cca369fb014b729df870ca3716cc0f1e2297b9f265341492cba85a14aeb", "references/pr219-run1/NOTICE.md": "1f04b17404663a0983b7cc45e308e577d4d49fb6a4c1ff077dc3f13bae83c56f", @@ -642,9 +841,10 @@ "references/pr219-run1/references/pr205-packed.certificate.json": "c11fbb9aaa99594afc8d21e33761dc6d1d6c76ce3dbc36d5b64cae872c242f5a", "references/pr219-run1/schedule.py": "b9fff272f30048b982da3c0fc0149c2fde20bb7e32b8f9f860069956c12ebdc9", "references/pr219-run1/verify.py": "c839a06389945f9b0c6fbfd59bf2dd8030190c3de504d72c9bf032879f931197", - "run3.py": "005568b019277593d742cdd4bd4f506ac7b7d1b3f07a8606763594676890265d", + "run3.py": "57c50303d5cff110ec6a4c9c2501b052850cacbdeec9a08f9ff52787b6940418", "schedule66.json": "3f11889e722a8a00d1edc7c72bd099ecf0a72c8dd60ae83347b739565b48e919", - "schedule66.py": "1683b7e210bdd0d89abbbda8a03959325f38e6e138f473e312987adce8483981" + "schedule66.py": "1683b7e210bdd0d89abbbda8a03959325f38e6e138f473e312987adce8483981", + "widths66.py": "8b230906566113c0f1b742f2a246925ad11c0ab8ad51dc5167fb4d3e7b7dc905" }, "status": "MODEL AND TARGET, NOT CONSTRUCTED: the ledger and the bank schedule above rung 2 are certified here -- whole-bank volumes, the padded width-66 schedule itself (banks, blocks per bank, item-to-block assignment, padding draw), the retained row identities with the stock falling by exactly the bank count, both paid moments on the 10^-18 grid, and the two 47-constraint assemblies -- but the physical construction on the complex supplier is still owed (obligations.json C1-C7, plus #219's inherited R1-R4; T1 is settled by the schedule prototype and its negative uniform-tiling result). The kappa below is conditional on those and is not a completed finite witness.", "tiling": { @@ -952,5 +1152,1072 @@ "rank_mass": 2329866, "schedule": "padded prototype (prototype66.py): 531 + 198 + 66 = 795 banks, the rank-16 and rank-20 banks padded with 2 and 6 registers of retained blocks", "stock": 35361 + }, + "width_scan": { + "100": { + "blocks_per_bank": { + "10": 10 + }, + "deficit": 1233264, + "density": "49632/75325", + "density_decimal": 0.6589047461002323, + "detail": { + "10": { + "banks": 837, + "capacity_per_bank": 10, + "children": 8370, + "mass_family": 83700, + "mass_removed": 83700, + "padding_registers": 0, + "rank": 10 + } + }, + "eligible_banks": 837, + "eligible_families": [ + 10 + ], + "eligible_mass": 83700, + "kappa": null, + "mass_over_capacity_ratio": "49632/75325", + "poseable": true, + "priced": false, + "saving": null, + "status": "not priced: a different modulus is a different word, whose stock and deficit this ledger does not fix", + "width": 100 + }, + "108": { + "blocks_per_bank": { + "10": 10, + "12": 9, + "2": 54, + "4": 27 + }, + "deficit": 1522512, + "density": "16544/27117", + "density_decimal": 0.6100969871298447, + "detail": { + "10": { + "banks": 837, + "capacity_per_bank": 10, + "children": 8370, + "mass_family": 83700, + "mass_removed": 90396, + "padding_registers": 6696, + "rank": 10 + }, + "12": { + "banks": 1197, + "capacity_per_bank": 9, + "children": 10773, + "mass_family": 129276, + "mass_removed": 129276, + "padding_registers": 0, + "rank": 12 + }, + "2": { + "banks": 2213, + "capacity_per_bank": 54, + "children": 119502, + "mass_family": 239004, + "mass_removed": 239004, + "padding_registers": 0, + "rank": 2 + }, + "4": { + "banks": 1403, + "capacity_per_bank": 27, + "children": 37881, + "mass_family": 151524, + "mass_removed": 151524, + "padding_registers": 0, + "rank": 4 + } + }, + "eligible_banks": 5650, + "eligible_families": [ + 2, + 4, + 10, + 12 + ], + "eligible_mass": 610200, + "kappa": null, + "mass_over_capacity_ratio": "16544/27117", + "poseable": true, + "priced": false, + "saving": null, + "status": "not priced: a different modulus is a different word, whose stock and deficit this ledger does not fix", + "width": 108 + }, + "120": { + "blocks_per_bank": { + "20": 6 + }, + "deficit": 1956384, + "density": "8272/15065", + "density_decimal": 0.5490872884168603, + "detail": { + "20": { + "banks": 33, + "capacity_per_bank": 6, + "children": 198, + "mass_family": 3960, + "mass_removed": 3960, + "padding_registers": 0, + "rank": 20 + } + }, + "eligible_banks": 33, + "eligible_families": [ + 20 + ], + "eligible_mass": 3960, + "kappa": null, + "mass_over_capacity_ratio": "8272/15065", + "poseable": true, + "priced": false, + "saving": null, + "status": "not priced: a different modulus is a different word, whose stock and deficit this ledger does not fix", + "width": 120 + }, + "132": { + "blocks_per_bank": { + "16": 8, + "20": 6 + }, + "deficit": 2390256, + "density": "1504/3013", + "density_decimal": 0.4991702621971457, + "detail": { + "16": { + "banks": 99, + "capacity_per_bank": 8, + "children": 792, + "mass_family": 12672, + "mass_removed": 13068, + "padding_registers": 396, + "rank": 16 + }, + "20": { + "banks": 33, + "capacity_per_bank": 6, + "children": 198, + "mass_family": 3960, + "mass_removed": 4356, + "padding_registers": 396, + "rank": 20 + } + }, + "eligible_banks": 132, + "eligible_families": [ + 16, + 20 + ], + "eligible_mass": 17424, + "kappa": null, + "mass_over_capacity_ratio": "1504/3013", + "poseable": true, + "priced": false, + "saving": null, + "status": "not priced: a different modulus is a different word, whose stock and deficit this ledger does not fix", + "width": 132 + }, + "144": { + "blocks_per_bank": { + "16": 9 + }, + "deficit": 2824128, + "density": "4136/9039", + "density_decimal": 0.45757274034738354, + "detail": { + "16": { + "banks": 88, + "capacity_per_bank": 9, + "children": 792, + "mass_family": 12672, + "mass_removed": 12672, + "padding_registers": 0, + "rank": 16 + } + }, + "eligible_banks": 88, + "eligible_families": [ + 16 + ], + "eligible_mass": 12672, + "kappa": null, + "mass_over_capacity_ratio": "4136/9039", + "poseable": true, + "priced": false, + "saving": null, + "status": "not priced: a different modulus is a different word, whose stock and deficit this ledger does not fix", + "width": 144 + }, + "48": { + "blocks_per_bank": { + "16": 3 + }, + "deficit": -646848, + "density": "4136/3013", + "density_decimal": 1.3727182210421507, + "detail": { + "16": { + "banks": 264, + "capacity_per_bank": 3, + "children": 792, + "mass_family": 12672, + "mass_removed": 12672, + "padding_registers": 0, + "rank": 16 + } + }, + "eligible_banks": 264, + "eligible_families": [ + 16 + ], + "eligible_mass": 12672, + "kappa": null, + "poseable": false, + "priced": false, + "saving": null, + "status": "the pinned row is not poseable (rank mass >= w * W)", + "width": 48 + }, + "54": { + "blocks_per_bank": { + "1": 54, + "10": 5, + "11": 4, + "12": 4, + "18": 3, + "2": 27, + "4": 13, + "5": 10, + "6": 9 + }, + "deficit": -429912, + "density": "33088/27117", + "density_decimal": 1.2201939742596895, + "detail": { + "1": { + "banks": 4863, + "capacity_per_bank": 54, + "children": 262602, + "mass_family": 262602, + "mass_removed": 262602, + "padding_registers": 0, + "rank": 1 + }, + "10": { + "banks": 1674, + "capacity_per_bank": 5, + "children": 8370, + "mass_family": 83700, + "mass_removed": 90396, + "padding_registers": 6696, + "rank": 10 + }, + "11": { + "banks": 797, + "capacity_per_bank": 4, + "children": 3186, + "mass_family": 35046, + "mass_removed": 43038, + "padding_registers": 7992, + "rank": 11 + }, + "12": { + "banks": 2694, + "capacity_per_bank": 4, + "children": 10773, + "mass_family": 129276, + "mass_removed": 145476, + "padding_registers": 16200, + "rank": 12 + }, + "18": { + "banks": 7959, + "capacity_per_bank": 3, + "children": 23877, + "mass_family": 429786, + "mass_removed": 429786, + "padding_registers": 0, + "rank": 18 + }, + "2": { + "banks": 4426, + "capacity_per_bank": 27, + "children": 119502, + "mass_family": 239004, + "mass_removed": 239004, + "padding_registers": 0, + "rank": 2 + }, + "4": { + "banks": 2914, + "capacity_per_bank": 13, + "children": 37881, + "mass_family": 151524, + "mass_removed": 157356, + "padding_registers": 5832, + "rank": 4 + }, + "5": { + "banks": 1755, + "capacity_per_bank": 10, + "children": 17550, + "mass_family": 87750, + "mass_removed": 94770, + "padding_registers": 7020, + "rank": 5 + }, + "6": { + "banks": 1605, + "capacity_per_bank": 9, + "children": 14445, + "mass_family": 86670, + "mass_removed": 86670, + "padding_registers": 0, + "rank": 6 + } + }, + "eligible_banks": 28687, + "eligible_families": [ + 1, + 2, + 4, + 5, + 6, + 10, + 11, + 12, + 18 + ], + "eligible_mass": 1549098, + "kappa": null, + "poseable": false, + "priced": false, + "saving": null, + "status": "the pinned row is not poseable (rank mass >= w * W)", + "width": 54 + }, + "58": { + "blocks_per_bank": {}, + "deficit": -285288, + "density": "99264/87377", + "density_decimal": 1.1360426656900557, + "detail": {}, + "eligible_banks": 0, + "eligible_families": [], + "eligible_mass": 0, + "kappa": null, + "poseable": false, + "priced": false, + "saving": null, + "status": "the pinned row is not poseable (rank mass >= w * W)", + "width": 58 + }, + "60": { + "blocks_per_bank": { + "10": 6, + "20": 3 + }, + "deficit": -212976, + "density": "16544/15065", + "density_decimal": 1.0981745768337206, + "detail": { + "10": { + "banks": 1395, + "capacity_per_bank": 6, + "children": 8370, + "mass_family": 83700, + "mass_removed": 83700, + "padding_registers": 0, + "rank": 10 + }, + "20": { + "banks": 66, + "capacity_per_bank": 3, + "children": 198, + "mass_family": 3960, + "mass_removed": 3960, + "padding_registers": 0, + "rank": 20 + } + }, + "eligible_banks": 1461, + "eligible_families": [ + 10, + 20 + ], + "eligible_mass": 87660, + "kappa": null, + "poseable": false, + "priced": false, + "saving": null, + "status": "the pinned row is not poseable (rank mass >= w * W)", + "width": 60 + }, + "63": { + "blocks_per_bank": { + "12": 5, + "14": 4, + "18": 3, + "7": 9 + }, + "deficit": -104508, + "density": "66176/63273", + "density_decimal": 1.0458805493654482, + "detail": { + "12": { + "banks": 2155, + "capacity_per_bank": 5, + "children": 10773, + "mass_family": 129276, + "mass_removed": 135765, + "padding_registers": 6489, + "rank": 12 + }, + "14": { + "banks": 1670, + "capacity_per_bank": 4, + "children": 6678, + "mass_family": 93492, + "mass_removed": 105210, + "padding_registers": 11718, + "rank": 14 + }, + "18": { + "banks": 7959, + "capacity_per_bank": 3, + "children": 23877, + "mass_family": 429786, + "mass_removed": 501417, + "padding_registers": 71631, + "rank": 18 + }, + "7": { + "banks": 706, + "capacity_per_bank": 9, + "children": 6354, + "mass_family": 44478, + "mass_removed": 44478, + "padding_registers": 0, + "rank": 7 + } + }, + "eligible_banks": 12490, + "eligible_families": [ + 7, + 12, + 14, + 18 + ], + "eligible_mass": 786870, + "kappa": null, + "poseable": false, + "priced": false, + "saving": null, + "status": "the pinned row is not poseable (rank mass >= w * W)", + "width": 63 + }, + "64": { + "blocks_per_bank": { + "16": 4 + }, + "deficit": -68352, + "density": "3102/3013", + "density_decimal": 1.029538665781613, + "detail": { + "16": { + "banks": 198, + "capacity_per_bank": 4, + "children": 792, + "mass_family": 12672, + "mass_removed": 12672, + "padding_registers": 0, + "rank": 16 + } + }, + "eligible_banks": 198, + "eligible_families": [ + 16 + ], + "eligible_mass": 12672, + "kappa": null, + "poseable": false, + "priced": false, + "saving": null, + "status": "the pinned row is not poseable (rank mass >= w * W)", + "width": 64 + }, + "65": { + "blocks_per_bank": { + "5": 13 + }, + "deficit": -32196, + "density": "198528/195845", + "density_decimal": 1.0136996093849728, + "detail": { + "5": { + "banks": 1350, + "capacity_per_bank": 13, + "children": 17550, + "mass_family": 87750, + "mass_removed": 87750, + "padding_registers": 0, + "rank": 5 + } + }, + "eligible_banks": 1350, + "eligible_families": [ + 5 + ], + "eligible_mass": 87750, + "kappa": null, + "poseable": false, + "priced": false, + "saving": null, + "status": "the pinned row is not poseable (rank mass >= w * W)", + "width": 65 + }, + "66": { + "absorbed_families": [ + 11, + 16, + 20 + ], + "banks": 795, + "blocks_per_bank": { + "11": 6, + "16": 4, + "20": 3 + }, + "deficit": 3960, + "density": "3008/3013", + "density_decimal": 0.9983405243942914, + "detail": { + "11": { + "banks": 531, + "capacity_per_bank": 6, + "children": 3186, + "mass_family": 35046, + "mass_removed": 35046, + "padding_registers": 0, + "rank": 11 + }, + "16": { + "banks": 198, + "capacity_per_bank": 4, + "children": 792, + "mass_family": 12672, + "mass_removed": 13068, + "padding_registers": 396, + "rank": 16 + }, + "20": { + "banks": 66, + "capacity_per_bank": 3, + "children": 198, + "mass_family": 3960, + "mass_removed": 4356, + "padding_registers": 396, + "rank": 20 + } + }, + "eligible_banks": 795, + "eligible_families": [ + 11, + 16, + 20 + ], + "eligible_mass": 52470, + "kappa": "711599961413937/1000000000000000000", + "padding_registers": 792, + "poseable": true, + "priced": true, + "saving": "356053348255849/500000000000000000", + "status": "priced: the pinned word, this package's padded schedule", + "width": 66 + }, + "67": { + "blocks_per_bank": {}, + "deficit": 40116, + "density": "198528/201871", + "density_decimal": 0.9834399195525856, + "detail": {}, + "eligible_banks": 0, + "eligible_families": [], + "eligible_mass": 0, + "kappa": null, + "poseable": true, + "priced": false, + "saving": null, + "status": "no family satisfies w | rank * children", + "width": 67 + }, + "68": { + "blocks_per_bank": {}, + "deficit": 76272, + "density": "49632/51221", + "density_decimal": 0.9689775677944593, + "detail": {}, + "eligible_banks": 0, + "eligible_families": [], + "eligible_mass": 0, + "kappa": null, + "poseable": true, + "priced": false, + "saving": null, + "status": "no family satisfies w | rank * children", + "width": 68 + }, + "69": { + "blocks_per_bank": { + "4": 17 + }, + "deficit": 112428, + "density": "66176/69299", + "density_decimal": 0.9549344146380179, + "detail": { + "4": { + "banks": 2229, + "capacity_per_bank": 17, + "children": 37881, + "mass_family": 151524, + "mass_removed": 153801, + "padding_registers": 2277, + "rank": 4 + } + }, + "eligible_banks": 2229, + "eligible_families": [ + 4 + ], + "eligible_mass": 153801, + "kappa": null, + "mass_over_capacity_ratio": "66176/69299", + "poseable": true, + "priced": false, + "saving": null, + "status": "not priced: a different modulus is a different word, whose stock and deficit this ledger does not fix", + "width": 69 + }, + "70": { + "blocks_per_bank": {}, + "deficit": 148584, + "density": "99264/105455", + "density_decimal": 0.9412924944289033, + "detail": {}, + "eligible_banks": 0, + "eligible_families": [], + "eligible_mass": 0, + "kappa": null, + "poseable": true, + "priced": false, + "saving": null, + "status": "no family satisfies w | rank * children", + "width": 70 + }, + "71": { + "blocks_per_bank": {}, + "deficit": 184740, + "density": "198528/213923", + "density_decimal": 0.9280348536622991, + "detail": {}, + "eligible_banks": 0, + "eligible_families": [], + "eligible_mass": 0, + "kappa": null, + "poseable": true, + "priced": false, + "saving": null, + "status": "no family satisfies w | rank * children", + "width": 71 + }, + "72": { + "blocks_per_bank": { + "16": 4, + "20": 3, + "8": 9 + }, + "deficit": 220896, + "density": "8272/9039", + "density_decimal": 0.9151454806947671, + "detail": { + "16": { + "banks": 198, + "capacity_per_bank": 4, + "children": 792, + "mass_family": 12672, + "mass_removed": 14256, + "padding_registers": 1584, + "rank": 16 + }, + "20": { + "banks": 66, + "capacity_per_bank": 3, + "children": 198, + "mass_family": 3960, + "mass_removed": 4752, + "padding_registers": 792, + "rank": 20 + }, + "8": { + "banks": 1531, + "capacity_per_bank": 9, + "children": 13779, + "mass_family": 110232, + "mass_removed": 110232, + "padding_registers": 0, + "rank": 8 + } + }, + "eligible_banks": 1795, + "eligible_families": [ + 8, + 16, + 20 + ], + "eligible_mass": 129240, + "kappa": null, + "mass_over_capacity_ratio": "8272/9039", + "poseable": true, + "priced": false, + "saving": null, + "status": "not priced: a different modulus is a different word, whose stock and deficit this ledger does not fix", + "width": 72 + }, + "73": { + "blocks_per_bank": {}, + "deficit": 257052, + "density": "198528/219949", + "density_decimal": 0.902609241233195, + "detail": {}, + "eligible_banks": 0, + "eligible_families": [], + "eligible_mass": 0, + "kappa": null, + "poseable": true, + "priced": false, + "saving": null, + "status": "no family satisfies w | rank * children", + "width": 73 + }, + "74": { + "blocks_per_bank": {}, + "deficit": 293208, + "density": "99264/111481", + "density_decimal": 0.8904118190543681, + "detail": {}, + "eligible_banks": 0, + "eligible_families": [], + "eligible_mass": 0, + "kappa": null, + "poseable": true, + "priced": false, + "saving": null, + "status": "no family satisfies w | rank * children", + "width": 74 + }, + "75": { + "blocks_per_bank": { + "10": 7, + "5": 15 + }, + "deficit": 329364, + "density": "66176/75325", + "density_decimal": 0.8785396614669765, + "detail": { + "10": { + "banks": 1196, + "capacity_per_bank": 7, + "children": 8370, + "mass_family": 83700, + "mass_removed": 89700, + "padding_registers": 6000, + "rank": 10 + }, + "5": { + "banks": 1170, + "capacity_per_bank": 15, + "children": 17550, + "mass_family": 87750, + "mass_removed": 87750, + "padding_registers": 0, + "rank": 5 + } + }, + "eligible_banks": 2366, + "eligible_families": [ + 5, + 10 + ], + "eligible_mass": 177450, + "kappa": null, + "mass_over_capacity_ratio": "66176/75325", + "poseable": true, + "priced": false, + "saving": null, + "status": "not priced: a different modulus is a different word, whose stock and deficit this ledger does not fix", + "width": 75 + }, + "76": { + "blocks_per_bank": { + "12": 6 + }, + "deficit": 365520, + "density": "49632/57247", + "density_decimal": 0.866979929079253, + "detail": { + "12": { + "banks": 1796, + "capacity_per_bank": 6, + "children": 10773, + "mass_family": 129276, + "mass_removed": 136496, + "padding_registers": 7220, + "rank": 12 + } + }, + "eligible_banks": 1796, + "eligible_families": [ + 12 + ], + "eligible_mass": 136496, + "kappa": null, + "mass_over_capacity_ratio": "49632/57247", + "poseable": true, + "priced": false, + "saving": null, + "status": "not priced: a different modulus is a different word, whose stock and deficit this ledger does not fix", + "width": 76 + }, + "78": { + "blocks_per_bank": { + "5": 15 + }, + "deficit": 437832, + "density": "33088/39169", + "density_decimal": 0.8447496744874773, + "detail": { + "5": { + "banks": 1170, + "capacity_per_bank": 15, + "children": 17550, + "mass_family": 87750, + "mass_removed": 91260, + "padding_registers": 3510, + "rank": 5 + } + }, + "eligible_banks": 1170, + "eligible_families": [ + 5 + ], + "eligible_mass": 91260, + "kappa": null, + "mass_over_capacity_ratio": "33088/39169", + "poseable": true, + "priced": false, + "saving": null, + "status": "not priced: a different modulus is a different word, whose stock and deficit this ledger does not fix", + "width": 78 + }, + "80": { + "blocks_per_bank": {}, + "deficit": 510144, + "density": "12408/15065", + "density_decimal": 0.8236309326252904, + "detail": {}, + "eligible_banks": 0, + "eligible_families": [], + "eligible_mass": 0, + "kappa": null, + "poseable": true, + "priced": false, + "saving": null, + "status": "no family satisfies w | rank * children", + "width": 80 + }, + "84": { + "blocks_per_bank": { + "12": 7, + "14": 6 + }, + "deficit": 654768, + "density": "16544/21091", + "density_decimal": 0.7844104120240861, + "detail": { + "12": { + "banks": 1539, + "capacity_per_bank": 7, + "children": 10773, + "mass_family": 129276, + "mass_removed": 129276, + "padding_registers": 0, + "rank": 12 + }, + "14": { + "banks": 1113, + "capacity_per_bank": 6, + "children": 6678, + "mass_family": 93492, + "mass_removed": 93492, + "padding_registers": 0, + "rank": 14 + } + }, + "eligible_banks": 2652, + "eligible_families": [ + 12, + 14 + ], + "eligible_mass": 222768, + "kappa": null, + "mass_over_capacity_ratio": "16544/21091", + "poseable": true, + "priced": false, + "saving": null, + "status": "not priced: a different modulus is a different word, whose stock and deficit this ledger does not fix", + "width": 84 + }, + "88": { + "blocks_per_bank": { + "16": 5, + "20": 4 + }, + "deficit": 799392, + "density": "2256/3013", + "density_decimal": 0.7487553932957186, + "detail": { + "16": { + "banks": 159, + "capacity_per_bank": 5, + "children": 792, + "mass_family": 12672, + "mass_removed": 13992, + "padding_registers": 1320, + "rank": 16 + }, + "20": { + "banks": 50, + "capacity_per_bank": 4, + "children": 198, + "mass_family": 3960, + "mass_removed": 4400, + "padding_registers": 440, + "rank": 20 + } + }, + "eligible_banks": 209, + "eligible_families": [ + 16, + 20 + ], + "eligible_mass": 18392, + "kappa": null, + "mass_over_capacity_ratio": "2256/3013", + "poseable": true, + "priced": false, + "saving": null, + "status": "not priced: a different modulus is a different word, whose stock and deficit this ledger does not fix", + "width": 88 + }, + "90": { + "blocks_per_bank": { + "10": 9, + "20": 4, + "5": 18, + "6": 15 + }, + "deficit": 871704, + "density": "33088/45195", + "density_decimal": 0.7321163845558137, + "detail": { + "10": { + "banks": 930, + "capacity_per_bank": 9, + "children": 8370, + "mass_family": 83700, + "mass_removed": 83700, + "padding_registers": 0, + "rank": 10 + }, + "20": { + "banks": 50, + "capacity_per_bank": 4, + "children": 198, + "mass_family": 3960, + "mass_removed": 4500, + "padding_registers": 540, + "rank": 20 + }, + "5": { + "banks": 975, + "capacity_per_bank": 18, + "children": 17550, + "mass_family": 87750, + "mass_removed": 87750, + "padding_registers": 0, + "rank": 5 + }, + "6": { + "banks": 963, + "capacity_per_bank": 15, + "children": 14445, + "mass_family": 86670, + "mass_removed": 86670, + "padding_registers": 0, + "rank": 6 + } + }, + "eligible_banks": 2918, + "eligible_families": [ + 5, + 6, + 10, + 20 + ], + "eligible_mass": 262620, + "kappa": null, + "mass_over_capacity_ratio": "33088/45195", + "poseable": true, + "priced": false, + "saving": null, + "status": "not priced: a different modulus is a different word, whose stock and deficit this ledger does not fix", + "width": 90 + }, + "96": { + "blocks_per_bank": { + "16": 6 + }, + "deficit": 1088640, + "density": "2068/3013", + "density_decimal": 0.6863591105210753, + "detail": { + "16": { + "banks": 132, + "capacity_per_bank": 6, + "children": 792, + "mass_family": 12672, + "mass_removed": 12672, + "padding_registers": 0, + "rank": 16 + } + }, + "eligible_banks": 132, + "eligible_families": [ + 16 + ], + "eligible_mass": 12672, + "kappa": null, + "mass_over_capacity_ratio": "2068/3013", + "poseable": true, + "priced": false, + "saving": null, + "status": "not priced: a different modulus is a different word, whose stock and deficit this ledger does not fix", + "width": 96 + } } } diff --git a/research/complex-bank-run3/instantiate66.py b/research/complex-bank-run3/instantiate66.py new file mode 100644 index 0000000000..1295578bb4 --- /dev/null +++ b/research/complex-bank-run3/instantiate66.py @@ -0,0 +1,230 @@ +#!/usr/bin/env python3 +"""Instantiating C1's combinatorial half, and C5-C7's inventories, on the padded schedule. + +`prototype66.py` fixes the schedule: 531 banks of six rank-11 blocks, 198 banks of four +rank-16 blocks plus 2 registers of padding, 66 banks of three rank-20 blocks plus 6. This +module *instances* it -- names the items, puts each one in a block, and records what is still +missing -- which is what C5, C6, C7 and the item-to-block half of C1 ask for. + +What is built here, and checked rather than described: + +* **the inventories (C5, C6, C7).** Each absorbed family's children are enumerated per vertex + and over the three copies (1,062 / 264 / 66 per vertex; 3,186 / 792 / 198 in total), and each + item gets exactly one address: item `i` of a family goes to bank `i // k_f`, block + `i % k_f`, at offset `(i % k_f) * rank`. The map is a bijection onto the bank/block/offset + grid, every block holds exactly one item, and a deterministic digest over the whole table is + recorded so a reviewer can compare bytes. +* **the bank tables (C1, combinatorial half).** For each bank, the block layout (which + registers each block occupies, and which are padding), the padding draw from the retained + ledger, and the ledger facts the schedule induces (stock drop equal to the bank count). +* **the gap, read from the pins rather than asserted.** The complex supplier's certificate + exports no bank construction and -- by its own status line -- no literal operation program; + the only per-child inventory in the pins is #219's bit-side + `inputs/absorbed-occurrences.json`. That file fixes the *shape* the complex side owes, and + its key set is recorded here, which is what turns "an inventory is owed" into "this artifact, + with these fields, is owed". + +What is still not built, and is not claimed: the physical realization. The normalizer that +sends each item's residual projector to its block, the frames and charts, the routing and the +prime witnesses (C1's physical half, C2, C3, C4) need data the pinned certificates do not +export -- the item addresses exist here, the residual projectors they must move do not. +""" +import hashlib +import json +import sys +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +if str(HERE) not in sys.path: + sys.path.insert(0, str(HERE)) + +import ledger3 # noqa: E402 +import prototype66 # noqa: E402 + +WIDTH = 66 +COPIES = 3 +RUNGS = (11, 16, 20) +SUPPLIER = (HERE / 'references' / 'pr219-run1' / 'references' + / 'pr193-source-assisted-v4.certificate.json') +PR205 = HERE / 'references' / 'pr219-run1' / 'references' / 'pr205-packed.certificate.json' +BIT_OCCURRENCES = HERE / 'references' / 'pr219-run1' / 'inputs' / 'absorbed-occurrences.json' + + +def address(item, capacity, rank, width): + """The bank/block/offset address of one item: bank = i // k, block = i % k.""" + bank, block = divmod(item, capacity) + return dict(item=item, bank=bank, block=block, offset=block * rank, + registers=rank, padding_registers=list(range(rank * capacity + block * 0, + rank * capacity + rank * 0))) + + +def inventory(base, family, width=WIDTH, copies=COPIES): + """One family's inventory over the copies, with its bank table and digest. + + ``base`` is the *three-copy* row (as the ledger modules build it), so the per-vertex count + is its bin divided by the copy count: 264 rank-16 children per vertex is 792 in the row. + """ + per_vertex = base['child_multiplicities'][family] // copies + assert base['child_multiplicities'][family] % copies == 0, 'copies must divide the bin' + items = copies * per_vertex + capacity = width // family + assert items % capacity == 0, 'the schedule must be saturated: items = k * banks' + banks = items // capacity + padding_per_bank = width - family * capacity + table = [address(i, capacity, family, width) for i in range(items)] + assert len({(row['bank'], row['block']) for row in table}) == items, 'addresses collide' + assert all(0 <= row['offset'] < width for row in table), 'offsets must sit in the bank' + assert all(row['offset'] + family <= width for row in table), 'a block must fit' + per_bank = {} + for row in table: + per_bank.setdefault(row['bank'], []).append(row['block']) + assert len(per_bank) == banks, 'every bank must be filled' + assert all(sorted(blocks) == list(range(capacity)) for blocks in per_bank.values()), \ + 'every bank must carry each block exactly once' + digest = hashlib.sha256( + '\n'.join('%d,%d,%d,%d' % (row['item'], row['bank'], row['block'], row['offset']) + for row in table).encode()).hexdigest() + return dict(family=family, children_per_vertex=per_vertex, copies=copies, items=items, + capacity_per_bank=capacity, banks=banks, padding_per_bank=padding_per_bank, + padding_registers=banks * padding_per_bank, + padding_blocks_per_bank=padding_per_bank, # rank-1 padding blocks + address_rule='item i -> bank i // k, block i % k, offset (i % k) * rank', + bank_table_digest=digest, first_addresses=table[:2], last_address=table[-1]) + + +def pins_gap(): + """What the pins do not export, read from the pinned bytes.""" + supplier = json.loads(SUPPLIER.read_text()) + profile = supplier['complex_profile'] + packed = json.loads(PR205.read_text()) + bit_occ = json.loads(BIT_OCCURRENCES.read_text()) + + def keys_with(node, needle): + found = [] + + def walk(value, path): + if isinstance(value, dict): + for key, child in value.items(): + walk(child, path + '/' + str(key)) + elif isinstance(value, list) and value and isinstance(value[0], (dict, list)): + walk(value[0], path + '[0]') + else: + if needle in path.lower(): + found.append(path) + walk(node, '') + return sorted(found) + + status = profile['status'] + return dict( + complex_supplier_bank_keys=keys_with(supplier, 'bank'), + complex_supplier_occurrence_keys=keys_with(supplier, 'occurrence'), + complex_supplier_status_says_no_operation_program='not exported' in status, + complex_supplier_status=status, + pinned_item_inventory=dict( + path='references/pr219-run1/inputs/absorbed-occurrences.json', + top_level_keys=sorted(bit_occ), + per_vertex_keys=sorted(bit_occ['occurrences_per_vertex']), + counts_per_vertex=bit_occ['counts_per_vertex'], + note='the only per-child inventory in the pins: it is the bit word\'s rank-22 ' + 'family, and it is what closes #219 R1. The shape the complex side owes is ' + 'this shape -- one entry per child with its chain/frame provenance.'), + pinned_bank_construction=dict( + path='references/pr219-run1/references/pr205-packed.certificate.json', + physical_banks=int(packed['physical']['banks']), + gauge_roles=packed['physical']['gauge_roles'], + bank_controls_keys=sorted(packed['bank_controls']), + note='width-72 entrance-gauge banks on the bit word: the only bank construction ' + 'in the pins, and the one whose block/normalizer pattern a complex-side ' + 'construction would have to mirror without inheriting'), + ) + + +def build(base=None, interval=None, ladder=None): + """The instanced schedule: inventories, bank tables, ledger cross-check, gap. + + ``ladder`` lets a caller that has already priced the padded schedule pass it in, so the + engine runs once for the whole package rather than once per module. + """ + interval = interval or ledger3.engine() + if ladder is None: + ladder = prototype66.priced_ladder(interval=interval, width=WIDTH) + if base is None: + certificate = json.loads(prototype66.FRONTIER.read_text()) + base = ledger3.three_copies(ledger3.profile(certificate['complex_profile'])) + inventories = [inventory(base, family) for family in RUNGS] + for inv, step in zip(inventories, ladder['ladder']): + assert inv['family'] == step['family'], 'rung order' + assert inv['banks'] == step['banks'], 'the schedules must agree on the bank count' + assert inv['padding_registers'] == step['padding_registers'], 'and on the padding' + assert step['stock_drop'] == inv['banks'], 'the stock must drop by the bank count' + assert step['pattern_sum'] == WIDTH, 'every bank must be exactly filled' + draw = sum(inv['padding_registers'] for inv in inventories) + kept_bin = base['child_multiplicities'][1] # three-copy, like the draw + assert draw <= kept_bin, 'the padding draw must exist in the retained ledger' + return dict( + status='C1 combinatorial half and C5-C7 inventories INSTANCED at the schedule level: ' + 'every item of every absorbed family has a bank, a block and an offset, and the ' + 'ledger the schedule induces is re-derived. The physical half of C1 (the ' + 'normalizer) and C2-C4 (formal columns, charts and prime witnesses, moment ' + 'envelope parity) remain open: the pins export the item counts, not the ' + 'residual projectors the normalizer must move.', + width=WIDTH, copies=COPIES, rungs=list(RUNGS), + inventories={str(inv['family']): inv for inv in inventories}, + totals=dict(banks=sum(inv['banks'] for inv in inventories), + items=sum(inv['items'] for inv in inventories), + padding_registers=draw, + padding_share_of_the_kept_bin=str(Q(draw, kept_bin))), + ledger_cross_check=dict(stock_drops=[step['stock_drop'] for step in ladder['ladder']], + retained_stock=ladder['final']['W'], + rank_mass=ladder['final']['mass'], + children=ladder['final']['children'], + criterion_exhausted=ladder['exhaustive']), + still_owed=dict( + C1_physical='the normalizer sending each item\'s residual projector to its block: ' + 'the addresses exist here (bank, block, offset), the projectors the ' + 'pinned certificates export do not', + C2='formal columns of the modified complex word after re-assignment', + C3='charts, routing and prime witnesses for the new complex blocks', + C4='complex moment-envelope parity for the re-assigned word', + C5='per-child provenance for the rank-11 family: the item addresses exist, the ' + 'chain/frame identity of each child does not (see the gap)', + C6='the same for the rank-16 family', + C7='the same for the rank-20 family', + ), + pins_gap=pins_gap(), + ) + + +def main(): + sys.set_int_max_str_digits(0) + sys.dont_write_bytecode = True + out = build() + target = HERE / 'occurrences66.json' + target.write_text(json.dumps(out, indent=1, sort_keys=True, default=str) + '\n', + newline='\n') + for family in RUNGS: + inv = out['inventories'][str(family)] + print('rank %-3d %4d per vertex x %d = %5d items -> %4d banks x %d blocks ' + '(+%d padding registers), digest %s' + % (family, inv['children_per_vertex'], COPIES, inv['items'], inv['banks'], + inv['capacity_per_bank'], inv['padding_registers'], + inv['bank_table_digest'][:16])) + print('totals: %d banks, %d items addressed, %d registers of padding (%s of the kept ' + 'rank-1 bin)' % (out['totals']['banks'], out['totals']['items'], + out['totals']['padding_registers'], + out['totals']['padding_share_of_the_kept_bin'])) + print('ledger: stock drops %s, retained stock %d, criterion exhausted %s' + % (out['ledger_cross_check']['stock_drops'], out['ledger_cross_check']['retained_stock'], + out['ledger_cross_check']['criterion_exhausted'])) + print('gap: complex supplier bank keys %s; its status says no operation program: %s' + % (out['pins_gap']['complex_supplier_bank_keys'], + out['pins_gap']['complex_supplier_status_says_no_operation_program'])) + print(' the shape owed exists in the pins for the bit word: %s (%s per vertex keys)' + % (out['pins_gap']['pinned_item_inventory']['path'], + ','.join(out['pins_gap']['pinned_item_inventory']['per_vertex_keys']))) + print('write ' + str(target)) + + +if __name__ == '__main__': + main() diff --git a/research/complex-bank-run3/obligations.json b/research/complex-bank-run3/obligations.json index f8111488d9..938ef3ee34 100644 --- a/research/complex-bank-run3/obligations.json +++ b/research/complex-bank-run3/obligations.json @@ -39,6 +39,7 @@ "name": "complex-side bank construction and residual-type blocks", "reference_precedent": "PR205 references/pr219-run1/references/pr205-packed.certificate.json: physical.banks with gauge_roles, distinct_gauges, copies and bank_controls; research/coordinated-frames-and-entrance-banks BANK-PROOF-PR200.md for the block/normalizer pattern.", "statement": "Build the bank construction on the complex supplier: banks of width 66 hosting the rank-11 items, with the normalizer that sends each item's true residual projector to its assigned block, the per-bank block assignment (six rank-11 blocks per bank, since 66 = 6 x 11) and the hashed item-to-bank/offset map for all 531 three-copy banks (177 one copy). The pins contain no bank construction for the complex supplier: its certificate has no bank keys at all, and the only banked word in the pins is the bit word's entrance-gauge pack of PR205/PR206 (width 72, rank-60 exteriors, 6,116 banks).", + "combinatorial_half": "INSTANCED: instantiate66.py -> occurrences66.json gives every item of the three families its bank, block and offset (the hashed item-to-bank/offset map the statement asks for, for 531 + 198 + 66 banks), the per-bank block layout with its padding registers, the bank tables and their digests, checked by verify.py. The physical half -- the normalizer itself, which must move each item's residual projector -- is what remains, and the reason is machine-read: the complex supplier's certificate declares in its own status line that a literal globally renumbered operation program is not exported, so the projectors the normalizer would move are not in the pins.", "status": "OPEN", "why_it_is_the_blocker": "The bit-side mechanism is specific to the width-72 bit word's entrance gauges; nothing in the queue banks complex-word dirt, so this is a new mechanism rather than an extension of an existing one." }, @@ -95,24 +96,29 @@ "id": "C5", "name": "inventory and provenance of the rank-11 family", "reference_precedent": "#219 schedule.py section 1 and inputs/absorbed-occurrences.json.", - "statement": "Enumerate the rank-11 items: for each of the 1,062 per-vertex children of the complex ledger's bin 11, the frame/chain occurrence it comes from, with a checked bijection onto the 3,186 three-copy occurrences and a proof that no other bin is touched. The pins contain no such inventory; the only occurrence inventory they hold is #219's bit-side inputs/absorbed-occurrences.json for the rank-22 bin, which is what makes #219's R1 a closed checklist.", - "status": "OPEN" + "statement": "Enumerate the rank-11 items: for each of the 1,062 per-vertex children of the complex ledger's bin 11, the frame/chain occurrence it comes from, with a checked bijection onto the 3,186 three-copy occurrences and a proof that no other bin is touched. The pins contain no such inventory; the only occurrence inventory they hold is #219's bit-side inputs/absorbed-occurrences.json for the rank-22 bin, which is what makes #219's R1 a closed checklist.", + "status": "INVENTORY_INSTANCED_AT_SCHEDULE_LEVEL", + "resolution": "instantiate66.py -> occurrences66.json (checked by verify.py): the 3,186 three-copy items of rank 11 are enumerated and bijected onto the 531 banks x 6 blocks, each item with its bank, block, offset and a deterministic table digest. Still owed: the frame/chain occurrence each child comes from -- the pins export the bin's count, not the children's identity." }, { "id": "C6", "name": "rank-16 family inventory on the complex word", "reference_precedent": "PR219 references/pr219-run1/inputs/absorbed-occurrences.json (rank-22 provenance), which this family has no counterpart of.", - "statement": "Enumerate the complex word's rank-16 child family: its 264 occurrences per vertex (792 over the three copies), their frame or chain identity, a bijection onto the 792 three-copy blocks the absorption of rung 3 needs (four per bank over 198 banks), and a proof that no other bin of the ledger moves. Nothing in the pins enumerates this family, exactly as nothing enumerates the rank-11 family of PR224 or the rank-22 bin of PR219's bit-side absorption, whose inventory (inputs/absorbed-occurrences.json) is what made that rung a closed checklist.", - "status": "OPEN", - "why_it_is_the_blocker": "A rung that cannot name its items cannot be built: the item-to-block map of C1 has no starting inventory for this family, so its absorption is priced but not instantiated." + "statement": "Enumerate the complex word's rank-16 child family: its 264 occurrences per vertex (792 over the three copies), their frame or chain identity, a bijection onto the 792 three-copy blocks the absorption of rung 3 needs (four per bank over 198 banks), and a proof that no other bin of the ledger moves. Nothing in the pins enumerates this family, exactly as nothing enumerates the rank-11 family of PR224 or the rank-22 bin of PR219's bit-side absorption, whose inventory (inputs/absorbed-occurrences.json) is what made that rung a closed checklist.", + "status": "INVENTORY_INSTANCED_AT_SCHEDULE_LEVEL", + "resolution": "instantiate66.py -> occurrences66.json (checked by verify.py): the 792 three-copy items are enumerated and bijected onto the 198 banks x 4 blocks, with the 396 registers of padding named (2 rank-1 blocks per bank), the item addresses and a table digest; the ledger is re-derived and the stock falls by exactly 198. Still owed:the frame or chain identity of each child." + , + "why_it_is_the_blocker": "A rung that cannot name its items cannot be built: the item-to-block map of C1 has no starting inventory for this family, so its absorption is priced but not instantiated." }, { "id": "C7", "name": "rank-20 family inventory on the complex word", "reference_precedent": "PR219 references/pr219-run1/inputs/absorbed-occurrences.json.", - "statement": "The same enumeration for the rank-20 family: 66 occurrences per vertex (198 over the three copies) onto the 198 three-copy blocks of rung 4 (three per bank over 66 banks), with the same no-other-bin-moves proof.", - "status": "OPEN", - "why_it_is_the_blocker": "Same gap as C6, one rung further; it is the last family of the ledger that satisfies the whole-bank volume condition." + "statement": "The same enumeration for the rank-20 family: 66 occurrences per vertex (198 over the three copies) onto the 198 three-copy blocks of rung 4 (three per bank over 66 banks), with the same no-other-bin-moves proof.", + "status": "INVENTORY_INSTANCED_AT_SCHEDULE_LEVEL", + "resolution": "instantiate66.py -> occurrences66.json (checked by verify.py): the 198 three-copy items are enumerated and bijected onto the 66 banks x 3 blocks, with the 396 registers of padding named (6 rank-1 blocks per bank), the item addresses and a table digest; the ledger is re-derived and the stock falls by exactly 66. Still owed:the frame or chain identity of each child." + , + "why_it_is_the_blocker": "Same gap as C6, one rung further; it is the last family of the ledger that satisfies the whole-bank volume condition." }, { "id": "T1", @@ -135,7 +141,7 @@ } } ], - "status": "C1-C7 and the inherited R1-R4 remain OPEN; T1 is SETTLED_AT_SCHEDULE_LEVEL. verify.py certifies the accounting (whole-bank volumes, retained row identities, stock drops equal to the bank counts, both paid moments on the 10^-18 grid, the two 47-constraint assemblies and the exclusion of the adjacent grid points), the T1 enumeration, the padded schedule and the exact prices; it discharges no other item.", + "status": "C1-C4 and the inherited R1-R4 remain OPEN; T1 is SETTLED_AT_SCHEDULE_LEVEL (enumerated, then built); C5-C7 have their inventories INSTANCED at the schedule level and still owe each child's frame/chain identity; C1 has its combinatorial half instanced and still owes the normalizer. verify.py certifies the accounting (whole-bank volumes, retained row identities, stock drops equal to the bank counts, both paid moments on the 10^-18 grid, the two 47-constraint assemblies and the exclusion of the adjacent grid points), the T1 enumeration, the padded schedule, the instanced inventories and the exact prices; it discharges no other item.", "why_rung_3_and_4": { "consequence": "the accounting ladder on the complex word terminates at rung 4; going higher needs a different bank width, a different ledger (a new supplier), or a mixed tiling that reopens the volume condition.", "numbers": { diff --git a/research/complex-bank-run3/occurrences66.json b/research/complex-bank-run3/occurrences66.json new file mode 100644 index 0000000000..60bea452de --- /dev/null +++ b/research/complex-bank-run3/occurrences66.json @@ -0,0 +1,197 @@ +{ + "copies": 3, + "inventories": { + "11": { + "address_rule": "item i -> bank i // k, block i % k, offset (i % k) * rank", + "bank_table_digest": "fb9bd2d17f69823324ef9212248ba2741be5f7dd504cfb61a9992872b32f0a59", + "banks": 531, + "capacity_per_bank": 6, + "children_per_vertex": 1062, + "copies": 3, + "family": 11, + "first_addresses": [ + { + "bank": 0, + "block": 0, + "item": 0, + "offset": 0, + "padding_registers": [], + "registers": 11 + }, + { + "bank": 0, + "block": 1, + "item": 1, + "offset": 11, + "padding_registers": [], + "registers": 11 + } + ], + "items": 3186, + "last_address": { + "bank": 530, + "block": 5, + "item": 3185, + "offset": 55, + "padding_registers": [], + "registers": 11 + }, + "padding_blocks_per_bank": 0, + "padding_per_bank": 0, + "padding_registers": 0 + }, + "16": { + "address_rule": "item i -> bank i // k, block i % k, offset (i % k) * rank", + "bank_table_digest": "f96efd45d9d912cec54d9d1633fdc47af34e05948cd8e3ab4305432e0ce35fbb", + "banks": 198, + "capacity_per_bank": 4, + "children_per_vertex": 264, + "copies": 3, + "family": 16, + "first_addresses": [ + { + "bank": 0, + "block": 0, + "item": 0, + "offset": 0, + "padding_registers": [], + "registers": 16 + }, + { + "bank": 0, + "block": 1, + "item": 1, + "offset": 16, + "padding_registers": [], + "registers": 16 + } + ], + "items": 792, + "last_address": { + "bank": 197, + "block": 3, + "item": 791, + "offset": 48, + "padding_registers": [], + "registers": 16 + }, + "padding_blocks_per_bank": 2, + "padding_per_bank": 2, + "padding_registers": 396 + }, + "20": { + "address_rule": "item i -> bank i // k, block i % k, offset (i % k) * rank", + "bank_table_digest": "f9d9567b4b41d5ba567aafff43927d568820792667daf6590fb00a3478890a77", + "banks": 66, + "capacity_per_bank": 3, + "children_per_vertex": 66, + "copies": 3, + "family": 20, + "first_addresses": [ + { + "bank": 0, + "block": 0, + "item": 0, + "offset": 0, + "padding_registers": [], + "registers": 20 + }, + { + "bank": 0, + "block": 1, + "item": 1, + "offset": 20, + "padding_registers": [], + "registers": 20 + } + ], + "items": 198, + "last_address": { + "bank": 65, + "block": 2, + "item": 197, + "offset": 40, + "padding_registers": [], + "registers": 20 + }, + "padding_blocks_per_bank": 6, + "padding_per_bank": 6, + "padding_registers": 396 + } + }, + "ledger_cross_check": { + "children": 634473, + "criterion_exhausted": true, + "rank_mass": 2329866, + "retained_stock": 35361, + "stock_drops": [ + 531, + 198, + 66 + ] + }, + "pins_gap": { + "complex_supplier_bank_keys": [], + "complex_supplier_occurrence_keys": [], + "complex_supplier_status": "Exact local invertible flow, exact all-column fresh identity, paid source controls, target read chains, and integer histogram certified. A literal globally renumbered operation program is not exported; dense initial dirty-response subtraction is defined by the exact certified flow.", + "complex_supplier_status_says_no_operation_program": true, + "pinned_bank_construction": { + "bank_controls_keys": [ + "formal_columns_per_case", + "rejected", + "weighted_partition_cases" + ], + "gauge_roles": 2200, + "note": "width-72 entrance-gauge banks on the bit word: the only bank construction in the pins, and the one whose block/normalizer pattern a complex-side construction would have to mirror without inheriting", + "path": "references/pr219-run1/references/pr205-packed.certificate.json", + "physical_banks": 45842 + }, + "pinned_item_inventory": { + "counts_per_vertex": { + "ledger_bin_22_per_vertex": 6672, + "ledger_bin_22_three_copies": 20016, + "normalization_factor_in_row": 3, + "physical_internal_H": 1344, + "physical_target_Y": 0, + "source_chain_src": 880 + }, + "note": "the only per-child inventory in the pins: it is the bit word's rank-22 family, and it is what closes #219 R1. The shape the complex side owes is this shape -- one entry per child with its chain/frame provenance.", + "path": "references/pr219-run1/inputs/absorbed-occurrences.json", + "per_vertex_keys": [ + "H", + "H_center", + "Y", + "src" + ], + "top_level_keys": [ + "counts_per_vertex", + "occurrences_per_vertex", + "row_identity_per_vertex", + "source_pins", + "status" + ] + } + }, + "rungs": [ + 11, + 16, + 20 + ], + "status": "C1 combinatorial half and C5-C7 inventories INSTANCED at the schedule level: every item of every absorbed family has a bank, a block and an offset, and the ledger the schedule induces is re-derived. The physical half of C1 (the normalizer) and C2-C4 (formal columns, charts and prime witnesses, moment envelope parity) remain open: the pins export the item counts, not the residual projectors the normalizer must move.", + "still_owed": { + "C1_physical": "the normalizer sending each item's residual projector to its block: the addresses exist here (bank, block, offset), the projectors the pinned certificates export do not", + "C2": "formal columns of the modified complex word after re-assignment", + "C3": "charts, routing and prime witnesses for the new complex blocks", + "C4": "complex moment-envelope parity for the re-assigned word", + "C5": "per-child provenance for the rank-11 family: the item addresses exist, the chain/frame identity of each child does not (see the gap)", + "C6": "the same for the rank-16 family", + "C7": "the same for the rank-20 family" + }, + "totals": { + "banks": 795, + "items": 4176, + "padding_registers": 792, + "padding_share_of_the_kept_bin": "44/14589" + }, + "width": 66 +} diff --git a/research/complex-bank-run3/pins.py b/research/complex-bank-run3/pins.py index 2f9d2faec0..b39b4fe835 100644 --- a/research/complex-bank-run3/pins.py +++ b/research/complex-bank-run3/pins.py @@ -14,8 +14,8 @@ VENDORED_RUN1 = 'references/pr219-run1' OWN = ('ledger3.py', 'run3.py', 'schedule66.py', 'schedule66.json', 'prototype66.py', - 'pins.py', 'obligations.json', - 'references/pr207-coordinated-crossover.certificate.json') + 'widths66.py', 'instantiate66.py', 'occurrences66.json', 'pins.py', + 'obligations.json', 'references/pr207-coordinated-crossover.certificate.json') def pinned_paths(): diff --git a/research/complex-bank-run3/run3.py b/research/complex-bank-run3/run3.py index d6e3525475..2d82ad1e6c 100644 --- a/research/complex-bank-run3/run3.py +++ b/research/complex-bank-run3/run3.py @@ -40,6 +40,15 @@ padding drawn from a retained bin, the ledger it induces (the stock falling by exactly the bank count) and the price of every padding option. The padded schedule beats the volume-criterion accounting it replaces, so the certificate's top rung is the padded one. +10. **The width question** (`widths66.py`): the bank width is the word's modulus, so a scan + over widths is a scan over words. 66 is the smallest modulus the pinned row admits (at 65 + its rank mass exceeds `W * w`), and every wider modulus is a different word whose stock and + deficit this ledger does not fix -- recorded, not priced. At the pinned width the scan + reproduces this package's own top exactly, which is its calibration. +11. **The instanced schedule** (`instantiate66.py`): C1's combinatorial half and the C5-C7 + inventories -- every item of the three families addressed to a bank, a block and an offset, + with the bank tables, the padding draw, the digests and a machine-read statement of what the + pins still do not export (the residual projectors, not the counts). python3 -B run3.py [--out certificate.json] """ @@ -54,10 +63,12 @@ if str(HERE) not in sys.path: sys.path.insert(0, str(HERE)) +import instantiate66 # noqa: E402 import ledger3 # noqa: E402 (local module, imported after the path is set) import pins # noqa: E402 import prototype66 # noqa: E402 import schedule66 # noqa: E402 +import widths66 # noqa: E402 REFERENCES = HERE / 'references' FRONTIER = REFERENCES / 'pr207-coordinated-crossover.certificate.json' @@ -339,6 +350,55 @@ def build(): 'every rung must raise the complex coarse saving' padded_rungs = [rung_record(supplier, step, leaf, index + 3) for index, step in enumerate(padded['ladder'][1:])] + + # --- 3d. is the bank width a dial? (widths66.py) ------------------------ + padded_base = ledger3.three_copies(ledger3.profile( + json.loads(FRONTIER.read_text())['complex_profile'])) + ledger3.check_row(padded_base) + assert [padded_base['W'], padded_base['N'], padded_base['total_rank']] == [ + part['three_copy']['W'], part['three_copy']['deficit'], part['three_copy']['mass']], \ + 'the scan must start from the same three-copy row the ladder prices' + scan = {str(width): widths66.scan_width(padded_base, width, interval, leaf, + ladder=padded if width == widths66.PINNED_WIDTH + else None) + for width in widths66.WIDTHS} + pinned_width = str(widths66.PINNED_WIDTH) + assert scan[pinned_width]['priced'] \ + and scan[pinned_width]['kappa'] == Q(padded_rungs[-1]['kappa']), \ + 'the width scan must reproduce this package\'s top at the pinned width' + assert scan[pinned_width]['banks'] == padded['ladder'][0]['banks'] \ + + padded['ladder'][1]['banks'] + padded['ladder'][2]['banks'] + narrower = [w for w, entry in scan.items() if not entry['poseable']] + assert narrower, 'some narrower modulus must be unposeable, or the claim is empty' + assert all(int(w) < 66 for w in narrower), 'only narrower moduli may be unposeable' + assert all(entry['poseable'] for w, entry in scan.items() if int(w) >= 66), \ + 'every width at or above the pinned one must be poseable' + assert min(int(w) for w, entry in scan.items() if entry['poseable']) == 66, \ + '66 must be the smallest modulus the pinned row admits' + assert all(not entry['priced'] for w, entry in scan.items() if int(w) > 66), \ + 'no width other than the pinned one may be priced (it is a different word)' + widest = max(scan, key=lambda w: scan[w]['density_decimal'] if scan[w]['poseable'] else 0) + assert widest == pinned_width, 'the pinned word must be the densest row in the scan' + + # --- 3e. the instanced schedule (instantiate66.py) ------------------------ + construction = instantiate66.build(padded_base, interval, padded) + for family in RUNGS: + inv = construction['inventories'][str(family)] + step = next(s for s in padded['ladder'] if s['family'] == family) + assert inv['banks'] == step['banks'] and inv['items'] == step['items'], 'schedules agree' + assert inv['padding_registers'] == step['padding_registers'], 'and the padding' + assert inv['banks'] * inv['capacity_per_bank'] == inv['items'], 'saturated' + assert inv['banks'] * (inv['padding_per_bank'] + family * inv['capacity_per_bank']) \ + == inv['banks'] * 66, 'every bank exactly filled' + assert len(inv['bank_table_digest']) == 64, 'the digest must be recorded' + assert construction['totals']['banks'] == sum( + padded['ladder'][i]['banks'] for i in range(3)), '795 banks over the three rungs' + assert construction['totals']['items'] == sum( + construction['inventories'][str(f)]['items'] for f in RUNGS) + assert construction['pins_gap']['complex_supplier_bank_keys'] == [], \ + 'the complex supplier must still have no bank construction in the pins' + assert construction['pins_gap']['complex_supplier_status_says_no_operation_program'], \ + "the supplier's own status must say the operation program is not exported" top = padded_rungs[-1] # the realizable top, not the volume one kappa_top, coarse_top = top['kappa'], top['coarse'] assert coarse_top == Q(padded['ladder'][-1]['saving']) @@ -398,6 +458,8 @@ def build(): rungs=rungs, padded_schedule=padded, padded_rungs=padded_rungs, + width_scan=scan, + construction=construction, replica=replica, top=dict(kappa=str(kappa_top), coarse=str(coarse_top), binding=top['binding'], families_absorbed=list(RUNGS), banks=sum(step['banks'] @@ -494,6 +556,18 @@ def main(): print('blocked complex supplier bank keys: %s; pinned bit bank construction: %s banks' % (record['blocked_on']['complex_supplier_has_bank_keys'], record['blocked_on']['pinned_bit_bank_construction']['physical_banks'])) + unpose = sorted(int(w) for w, entry in record['width_scan'].items() + if not entry['poseable']) + print('widths pinned row unposeable at %s; priced widths: [%s] (the modulus is the word)' + % (unpose, ','.join(w for w, entry in record['width_scan'].items() + if entry['priced']))) + inst = record['construction']['inventories'] + print('instanced %s items addressed over %d banks; padding %d registers (%s of the kept ' + 'rank-1 bin); digests %s' + % (record['construction']['totals']['items'], record['construction']['totals']['banks'], + record['construction']['totals']['padding_registers'], + record['construction']['totals']['padding_share_of_the_kept_bin'][:12] + '...', + [inst[str(f)]['bank_table_digest'][:12] for f in RUNGS])) print('write ' + str(args.out)) diff --git a/research/complex-bank-run3/verify.py b/research/complex-bank-run3/verify.py index ec047b8680..d0f78a94ca 100644 --- a/research/complex-bank-run3/verify.py +++ b/research/complex-bank-run3/verify.py @@ -31,6 +31,8 @@ import run3 # noqa: E402 import schedule66 # noqa: E402 +WIDTH = 66 + def digest(path): return sha256(Path(path).read_bytes()).hexdigest() @@ -92,15 +94,58 @@ def check_prototype(record): return padded +def check_scan_and_construction(record): + """The width scan and the instanced schedule, as rebuilt into the certificate.""" + scan = record['width_scan'] + pinned = scan[str(WIDTH)] + assert pinned['priced'] and Q(pinned['kappa']) == Q(record['top']['kappa']), \ + 'the scan must reproduce the top at the pinned width' + assert pinned['banks'] == record['top']['banks'], 'and its bank count' + for width, entry in scan.items(): + if not entry['poseable']: + assert int(width) < WIDTH, 'only narrower moduli may be unposeable' + assert Q(entry['density']) >= 1, 'an unposeable row has rank mass >= W * w' + elif int(width) != WIDTH: + assert not entry['priced'], 'a different modulus is a different word' + else: + assert entry['priced'], 'the pinned width must be priced' + assert min(int(w) for w, e in scan.items() if e['poseable']) == WIDTH, \ + 'the pinned width must be the smallest poseable modulus' + + construction = record['construction'] + totals = construction['totals'] + assert totals['banks'] == record['top']['banks'] == 795, '795 banks addressed' + items = 0 + for family, inv in construction['inventories'].items(): + assert inv['banks'] * inv['capacity_per_bank'] == inv['items'], 'saturated' + assert inv['banks'] * 66 \ + == inv['items'] * int(family) + inv['padding_registers'], 'banks exactly filled' + assert inv['padding_registers'] == inv['banks'] * inv['padding_per_bank'] + assert len(inv['bank_table_digest']) == 64, 'a digest per family' + items += inv['items'] + assert items == totals['items'] == 4176, '4,176 items addressed' + assert totals['padding_registers'] == 792, '792 registers of padding, as in the schedule' + assert construction['pins_gap']['complex_supplier_bank_keys'] == [] + assert construction['pins_gap']['complex_supplier_status_says_no_operation_program'] + assert construction['pins_gap']['pinned_item_inventory']['per_vertex_keys'], \ + 'the shape the complex side owes must be recorded from the pinned bit inventory' + assert construction['ledger_cross_check']['stock_drops'] == [531, 198, 66] + assert construction['ledger_cross_check']['criterion_exhausted'] + return scan, construction + + def check_obligations(): obligations = json.loads((HERE / 'obligations.json').read_text()) owed = [item['id'] for item in obligations['obligations']] assert owed == ['C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'T1'], owed status = {item['id']: item['status'] for item in obligations['obligations']} - assert all(status[key] == 'OPEN' for key in owed if key != 'T1'), \ - 'every obligation but T1 must still be open' + assert all(status[key] == 'OPEN' for key in ('C1', 'C2', 'C3', 'C4')), \ + 'the physical obligations must still be open' assert status['T1'] == 'SETTLED_AT_SCHEDULE_LEVEL', \ "T1 is settled by the schedule prototype, and must be recorded as such" + assert all(status[key] == 'INVENTORY_INSTANCED_AT_SCHEDULE_LEVEL' + for key in ('C5', 'C6', 'C7')), \ + 'the inventories are instanced at the schedule level and must say so' t1 = next(item for item in obligations['obligations'] if item['id'] == 'T1') assert 'resolution' in t1 and 'prototype66' in t1['resolution'], \ 'T1 must name the artifact that settles it' @@ -133,6 +178,7 @@ def main(): check_schedule() record = run3.build() check_prototype(record) + check_scan_and_construction(record) check_obligations() target = HERE / 'certificate.json' if args.write: @@ -159,6 +205,13 @@ def main(): for step in record['padded_schedule']['ladder']], [step['padding_per_bank'] for step in record['padded_schedule']['ladder']], [step['stock_drop'] for step in record['padded_schedule']['ladder']])) + print('widths unposeable at %s; priced: %s; the modulus is the word' + % (sorted(int(w) for w, e in record['width_scan'].items() if not e['poseable']), + sorted(int(w) for w, e in record['width_scan'].items() if e['priced']))) + print('instanced %d items addressed over %d banks, %d registers of padding' + % (record['construction']['totals']['items'], + record['construction']['totals']['banks'], + record['construction']['totals']['padding_registers'])) print('rungs %s at %s banks, kappa %s' % (record['top']['families_absorbed'], record['top']['banks'], record['kappa'])) diff --git a/research/complex-bank-run3/widths66.py b/research/complex-bank-run3/widths66.py new file mode 100644 index 0000000000..a588788fb4 --- /dev/null +++ b/research/complex-bank-run3/widths66.py @@ -0,0 +1,177 @@ +#!/usr/bin/env python3 +"""Is the bank width a dial? A modulus scan, and the three answers it gives. + +The pinned precedent settles what a bank width *is*: `references/pr219-run1/schedule.py` has +the bit word at `M = 72`, its rank-22 bin's 20,016 occurrences carrying `22 * 20,016 = 440,352` +registers into `440,352 / 72 = 6,116` banks, with the row identity `M * W - mass = D` and the +stock dropping by exactly the bank count. So **the bank width is the word's own modulus**, the +removed mass is `modulus * banks`, and the whole-bank criterion is `modulus | rank * children`. +The complex word's modulus is 66, which is why its banks are width 66. + +That makes "use another bank width" a question about the *word*, and this module answers it +three ways, each machine-checked: + +1. **The pinned ledger admits no narrower modulus.** The pinned engine's own contraction + condition is `rank mass < W * modulus`; the pinned row has `rank mass / W = 65.89`, so at + `w <= 65` the row is not poseable at all (`mass >= w * W`). 66 is the smallest modulus this + ledger admits, and the scan shows it by evaluating the condition, not by asserting it. +2. **At the pinned width the criterion is exactly what this package already uses.** Running + the whole scan at `w = 66` reproduces the padded schedule and the pinned top exactly (795 + banks, 792 padding registers, 52,470 registers of mass) -- the scan's own calibration. +3. **Raising the modulus is a word change, not a schedule change, and the scan demonstrates + why the prices stop being comparable.** Holding the pinned ledger fixed while raising `w` + leaves a row whose rank mass fills only `mass / (W * w)` of its capacity: 99.837% at the + pinned word, 95.4% at `w = 69`, 91.5% at `w = 72`. That row is no longer the dense ledger + the moment is calibrated on -- and indeed the vendored certifier's own bracket (`a = 0`, + `a = 10^-2`) stops holding there, which the scan records rather than hides. A word of a + different width would come with *its own* stock and deficit, i.e. a different supplier. + +So the honest answer to "raise κ by changing the bank width" is: on this ledger the width is +pinned (nothing below works, and above it you are designing another word). What the scan does +deliver is the criterion at every width -- which families tile whole banks, and the bank, +padding and mass arithmetic each one implies -- plus the two structural facts above. + +Caveat, stated once: the ledger is the pinned complex one (modulus 66). Any modulus change +would move the ledger, the counting and the engine's calibration with it; this module prices +only the pinned word, and reports the rest as arithmetic. +""" +import json +import sys +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +if str(HERE) not in sys.path: + sys.path.insert(0, str(HERE)) + +import ledger3 # noqa: E402 + +PINNED_WIDTH = 66 +GRID = 10 ** 18 +ETA = BETA = Q(1, 10 ** 24) +WEAK = Q(1, 10 ** 30) +PINNED_KAPPA = Q(711599961413937, 10 ** 18) + +WIDTHS = [48, 54, 58, 60, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 78, 80, + 84, 88, 90, 96, 100, 108, 120, 132, 144] + + +def bit_leaf(): + """#219's rung-1 ordinary leaf: the budget cap the assembly inherits.""" + schedule, arithmetic = ledger3.run1() + return Q(arithmetic.build(schedule.build())['ordinary_leaf']) + + +def kappa_of(leaf, coarse): + """The queue's assembly rule: budget, closed-form bound, floor to the grid.""" + budget = min(leaf, (1 - BETA) * coarse - WEAK) + q = budget * (1 - 2 * ETA) + bound = (1 - ETA) * q / (1 + q) + z = bound * GRID + return budget, Q((z.numerator - 1) // z.denominator, GRID) + + +def family_cost(hist, rank, width): + """Whole-bank absorption of this bin at this modulus: banks, padding, mass.""" + n = hist[rank] + if (rank * n) % width: + return None # whole-bank volume condition fails at this modulus + capacity = width // rank + if capacity == 0: + return None # a whole block does not fit in one bank + banks = -(-n // capacity) + return dict(rank=rank, children=n, capacity_per_bank=capacity, banks=banks, + padding_registers=banks * width - rank * n, mass_removed=banks * width, + mass_family=rank * n) + + +def scan_width(base, width, interval, leaf, ladder=None): + """The criterion and the bank arithmetic at one modulus; priced only where legitimate. + + ``ladder`` is an already-priced padded schedule for the pinned width, so a caller that has + one does not pay for a second engine run. + """ + hist = base['child_multiplicities'] + eligible = {rank: family_cost(hist, rank, width) + for rank in sorted(hist, reverse=True)} + eligible = {rank: cost for rank, cost in eligible.items() if cost} + pose = base['total_rank'] < width * base['W'] + deficit = width * base['W'] - base['total_rank'] + out = dict(width=width, poseable=pose, + density=str(Q(base['total_rank'], base['W'] * width)), + density_decimal=float(Q(base['total_rank'], base['W'] * width)), + deficit=deficit, + eligible_families=sorted(eligible), + eligible_mass=sum(eligible[r]['mass_removed'] for r in eligible), + eligible_banks=sum(eligible[r]['banks'] for r in eligible), + blocks_per_bank={str(r): width // r for r in eligible}, + detail={str(r): eligible[r] for r in eligible}) + if not pose: + return {**out, 'saving': None, 'kappa': None, 'priced': False, + 'status': 'the pinned row is not poseable (rank mass >= w * W)'} + if not eligible: + return {**out, 'saving': None, 'kappa': None, 'priced': False, + 'status': 'no family satisfies w | rank * children'} + if width != PINNED_WIDTH: + # The retained row would be a different word (its density moved), so any price from it + # would compare two words. Record that instead of quoting a number. + return {**out, 'saving': None, 'kappa': None, 'priced': False, + 'status': 'not priced: a different modulus is a different word, whose stock ' + 'and deficit this ledger does not fix', + 'mass_over_capacity_ratio': str(Q(base['total_rank'], base['W'] * width))} + # Only the pinned word is priced: the package's own padded schedule, at the pinned width. + import prototype66 + if ladder is None: + ladder = prototype66.priced_ladder(interval=interval, width=width) + kappa = None + if ladder['ladder']: + budget, kappa = kappa_of(leaf, Q(ladder['ladder'][-1]['saving'])) + return {**out, 'saving': Q(ladder['ladder'][-1]['saving']), 'kappa': kappa, 'priced': True, + 'banks': sum(step['banks'] for step in ladder['ladder']), + 'padding_registers': sum(step['padding_registers'] for step in ladder['ladder']), + 'absorbed_families': [step['family'] for step in ladder['ladder']], + 'status': 'priced: the pinned word, this package\'s padded schedule'} + + +def main(): + widths = [int(a) for a in sys.argv[1:]] or WIDTHS + sys.set_int_max_str_digits(0) + sys.dont_write_bytecode = True + interval = ledger3.engine() + supplier = json.loads((HERE / 'references' / 'pr219-run1' / 'references' + / 'pr193-source-assisted-v4.certificate.json').read_text()) + base = ledger3.three_copies(ledger3.profile(supplier['complex_profile'])) + leaf = bit_leaf() + print('pinned ledger: modulus %d, W = %d, deficit %d, rank mass %d, %d families, ' + 'rank mass / W = %s' % (PINNED_WIDTH, base['W'], base['N'], base['total_rank'], + len(base['child_multiplicities']), + Q(base['total_rank'], base['W']))) + print('%5s %8s %6s %-16s %5s %7s %10s %s' + % ('width', 'poseable', 'elig', 'families', 'banks', 'padding', 'mass', 'status')) + records = {} + for width in widths: + out = scan_width(base, width, interval, leaf) + records[str(width)] = out + print('%5d %8s %6d %-16s %5s %7s %10s %s' + % (width, 'yes' if out['poseable'] else 'NO', len(out['eligible_families']), + ','.join(map(str, out['eligible_families'])) or '-', + out.get('banks', ''), out.get('padding_registers', ''), + out.get('eligible_mass', ''), out['status'])) + pinned = records[str(PINNED_WIDTH)] + assert pinned['priced'] and pinned['kappa'] == PINNED_KAPPA, \ + 'the scan must reproduce the pinned width-66 top exactly, got %s' % pinned['kappa'] + assert pinned['banks'] == 795 and pinned['padding_registers'] == 792 + unposeable = sorted(r['width'] for r in records.values() if not r['poseable']) + print('\nthe pinned row is not poseable at: %s (rank mass %d vs W * w at 65 = %d)' + % (unposeable, base['total_rank'], 65 * base['W'])) + print('smallest modulus the pinned row admits: %d' + % min(r['width'] for r in records.values() if r['poseable'])) + print('density (rank mass / W*w): %s' + % {str(r['width']): r['density_decimal'] for r in records.values() + if r['poseable']}) + print('priced: width %d only, kappa %s (pinned top, reproduced exactly)' + % (PINNED_WIDTH, pinned['kappa'])) + + +if __name__ == '__main__': + main() From 3e6ad818e186bd5baf06a8fa4e016d22dc29c506 Mon Sep 17 00:00:00 2001 From: maxime-fleury Date: Sat, 10 Oct 2026 00:00:31 +0200 Subject: [PATCH 06/11] Measure whether a less dense supplier exists, and invert the next targets onto both branches MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The width scan left one question open and it decided the next step: the bank criterion is not what caps the ladder, the ledger's density is. So this asks it over the tree instead of guessing. Every ledger-bearing certificate in the repository is scored on the same four numbers (modulus, density, the smallest modulus the row admits, the mass share tiling there), keeping only rows that satisfy m*W - mass = D with every child inside the width: 20 distinct poseable ledgers are found and none is less dense than the complex word, which is itself the least dense one in the repository. A narrower modulus cannot be reused, it has to be built. So the same module prices the word that would take it: holding the pinned shape and occupancy and varying only the modulus, the cheapest stock that poses the row. The width-66 point is its calibration -- there the required stock is exactly the pinned stock, 12,052, and it reproduces this package's top kappa. At widths 48 and 60 the complex branch stops binding and the kappa rises to the budget the pinned bit leaf allows (+2.2655%, the whole of the complex headroom left); at 72 nothing tiles and every wider word is strictly worse. Finally the targets invert onto both branches. kappa is read off min(bit leaf, (1-beta)C - weak), so a target needs both branches above its budget, and the cap must clear the budget after the beta and weak haircuts, which costs one 10^-18 grid step. Per target: 7.5e-4 needs a bit leaf +3.064% and a complex coarse saving +5.400% over the top rung; 8e-4 needs +9.940% and +12.433%; 1e-3 needs +37.453% and +40.569%; only 7.2e-4 is short on the complex branch alone, and the complex ceiling the density curve finds above is still below all of them. This also fixes the target list itself, which read 8/10^3 where the package documents 8e-4. 🤖 Generated with Codebuff Co-Authored-By: Codebuff --- research/complex-bank-run3/PROOF.md | 44 +- research/complex-bank-run3/README.md | 73 ++- research/complex-bank-run3/SOURCE.json | 5 +- research/complex-bank-run3/certificate.json | 631 +++++++++++++++++++- research/complex-bank-run3/pins.py | 2 +- research/complex-bank-run3/run3.py | 148 ++++- research/complex-bank-run3/suppliers.py | 285 +++++++++ research/complex-bank-run3/verify.py | 91 +++ 8 files changed, 1263 insertions(+), 16 deletions(-) create mode 100644 research/complex-bank-run3/suppliers.py diff --git a/research/complex-bank-run3/PROOF.md b/research/complex-bank-run3/PROOF.md index 0b26dcfb6c..dc8d8ef3d8 100644 --- a/research/complex-bank-run3/PROOF.md +++ b/research/complex-bank-run3/PROOF.md @@ -190,14 +190,47 @@ volume (asserted). Two consequences follow, and they are the useful part of the * **Above the top, the bank mechanism has nothing left to take.** Reaching `kappa = 7.2e-4` needs a complex coarse saving of `7.20518773516934e-4`, i.e. +1.181% over the top rung's coarse saving -- more banking than this ledger's remaining mass can supply at this width. -* **Above `kappa = 7.277251e-4` the bit word is the wall.** While the complex branch caps the +* **Above `kappa = 7.277211e-4` the bit word is the wall.** While the complex branch caps the budget, the ceiling is `budget/(1+budget)`, and the budget is in turn capped by #219's rung-1 bit leaf (7.2825e-4). Targets `7.5e-4`, `8e-4` and `1e-3` are therefore unreachable on this bit word, whatever the complex ledger does; they need a new bit supplier first. +### 5b. The wall quantified (`suppliers.py` and `bit_requirement`) + +Two measurements bound the next step rather than describing it. First, the density question the +width scan raises is answered over the tree: every ledger-bearing certificate in the repository +is scored on modulus, density `mass/(m*W)`, the smallest modulus the row admits and the mass +share tiling there, keeping only rows that satisfy `m*W - mass = D` with every child inside the +width. 20 distinct poseable ledgers are found and **none is less dense than the complex word** +(`3008/3013 = 0.9983405`), which is itself the least dense one in the repository -- so a narrower +modulus must be built, not found. Second, holding the pinned shape and occupancy fixed and +varying only the modulus, the cheapest stock that poses the row is priced: at the pinned width +the required row is *exactly* the pinned ledger (stock 12,052) and it reproduces the top kappa, +which calibrates the curve; at widths 48 and 60 the complex branch stops binding and the kappa +rises to the budget the bit leaf allows, `7.277211...e-4` (+2.2655% over the top); at 72 nothing +tiles and every wider word is strictly worse (-0.74% at 84, -13.2% at 96). The curve is +synthetic, so it specifies a word instead of reporting one. + +With the ceiling of the complex side established by measurement, the targets invert onto both +branches. Since `kappa` is read off `budget = min(bit leaf, (1-beta) C - weak)`, a target needs +*both* branches above its budget, and because the cap must clear the budget after the `beta` and +`weak` haircuts the complex saving must sit one `10^-18` step above it: + +| target | required budget | required bit leaf | required complex coarse saving | +| ---: | ---: | ---: | ---: | +| 7.2e-4 | 7.20518773516933e-4 | 7.2825e-4 (already enough) | 7.20518773516934e-4 (+1.181%) | +| 7.5e-4 | 7.50562922191644e-4 | 7.50562922191644e-4 (+3.064%) | 7.50562922191645e-4 (+5.400%) | +| 8e-4 | 8.00640512409928e-4 | 8.00640512409928e-4 (+9.940%) | 8.00640512409929e-4 (+12.433%) | +| 1e-3 | 1.001001001001002e-3 | 1.001001001001002e-3 (+37.453%) | 1.001001001001003e-3 (+40.569%) | + +Each line is checked twice -- the pair reaches its target, and one grid step below the budget it +misses -- so the requirement is sufficient and tight on the grid. Only 7.2e-4 is short on the +complex branch alone; the three higher targets are short on both, and the complex ceiling that +the density curve finds above is still below all of them. + ## 6. Verification boundary -* Machine-checked here: the pinned bytes (27 files, sha256), the frontier reproduction, rung 1 +* Machine-checked here: the pinned bytes (28 files, sha256), the frontier reproduction, rung 1 rebuilt by the vendored #219 package, rung 2 rebuilt by this package's own ledger module, rungs 3 and 4 (volumes, row identities, stock drops, both paid moments, adjacency rejections), the branch ceilings, the eligibility exhaustion, the PR208 replica, the T1 @@ -214,6 +247,13 @@ volume (asserted). Two consequences follow, and they are the useful part of the (~2b and ~3b): no uniform width-66 tiling hosts the rungs, the padded schedule does, and the padded top is what this package claims. The kappa is conditional on C1-C7 and R1-R4, exactly as #219's rung 1 and #224's rung 2 are. +* Also machine-checked: the supplier scan and the density curve, including their two + calibrations (the least dense poseable ledger in the repository is the word priced here, and +the curve's width-66 row is exactly the pinned stock reproducing the top kappa), and the + per-target requirement table, each line re-derived from the assembly rule and tested one grid + step below its budget. The curve itself is a *specification*: the engine prices a row no + supplier in the pins owns, and the scan reports other packages' certificates at their own + conventions rather than re-deriving them. * Not run: upstream CI, and any contributor verifier other than the vendored #219 package invoked in place. * The `10^-10` supplier field is priced as a conservative variant; on it the ladder's top sits diff --git a/research/complex-bank-run3/README.md b/research/complex-bank-run3/README.md index 57b40409b9..3e891079e3 100644 --- a/research/complex-bank-run3/README.md +++ b/research/complex-bank-run3/README.md @@ -173,6 +173,44 @@ the ladder; the ledger's density is. A **less** dense complex word -- more stoc rank mass -- would admit a narrower modulus where far more of its ledger tiles at once. That is the concrete thing to look for in a new supplier, and it is a measurement, not a guess. +## Which suppliers exist, and the word a narrower modulus would take (`suppliers.py`) + +The width scan ends on a measurement -- what caps the ladder is the ledger's *density*, not the +criterion -- and `suppliers.py` turns that into two measurements over the tree itself. + +* **No less dense supplier exists to be reused.** Every ledger-bearing certificate in the + repository is read and scored on the same four numbers: modulus, density `mass / (m * W)`, the + smallest modulus the row admits (`floor(mass / W) + 1`), and the mass share that tiles whole + banks there -- keeping only rows that satisfy the row identity `m * W - mass = D` with every + child inside the width. **20** distinct poseable ledgers are found (the densest are the two + `certificates/endpoint-gauge*` rows at modulus 38,400, density 0.9999996), and **none is less + dense than the word priced here**: the complex word, at density `3008/3013 = 0.9983405`, is + itself the least dense poseable ledger in the repository. So the narrower modulus the width + scan wants cannot be reached by reusing anything already pinned; it has to be built. +* **What a word of a given width would have to look like.** Holding the pinned *shape* (the same + bins and counts) and its occupancy fixed and varying only the modulus, the cheapest stock that + poses the row is `ceil(mass / (density * m))`, and the module prices it wherever the vendored + certifier's bracket still holds: + +| modulus | stock it needs | density | what tiles there | coarse saving | kappa | +| ---: | ---: | ---: | --- | ---: | ---: | +| 48 | 16,572 | 0.99831 | the same families | 8.2678e-4 | `1819302815717/25*10^16` **+2.2655%** | +| 54 | 14,731 | 0.99829 | padding exceeds the kept rank-1 bin | -- | not priced | +| 60 | 13,258 | 0.99828 | the same families | 7.7898e-4 | `1819302815717/25*10^16` **+2.2655%** | +| **66** | **12,052** | **0.99834** | the pinned ladder | 7.1211e-4 | `711599961413937/10^18` (the calibration) | +| 72 | 11,048 | 0.99831 | nothing | -- | not priceable | +| 84 | 9,470 | 0.99828 | a smaller set | 7.0686e-4 | -0.7364% | +| 96 | 8,286 | 0.99831 | a smaller set | 6.1836e-4 | -13.1559% | + +At the pinned width the row the curve requires is *exactly* the pinned ledger -- the same stock, +12,052 -- and it reproduces this package's top kappa: that is the curve's calibration, asserted +in `verify.py`. At widths 48 and 60 the complex branch stops binding altogether and the kappa +rises to the budget the pinned **bit** leaf allows, `7.277211...e-4` -- **+2.2655%** over the top +rung, and the whole of the complex headroom that is left. The curve is **synthetic** (the pinned +engine pricing a row that no supplier in the pins owns), so it specifies a word rather than +reporting a result about one; the width-72 entry is what the pinned word itself does, and every +wider word is strictly worse. + ## What is instanced, and what is still owed (`instantiate66.py`) The padded schedule is now instanced, which is C1's combinatorial half and C5-C7's @@ -209,9 +247,32 @@ the budget capped in turn by the bit leaf of #219's rung-1 bit word (7.2825e-4). * reaching `kappa = 7.2e-4` needs a complex coarse saving of `7.20518773516934e-4`, i.e. **+1.181%** over the top rung's own coarse saving -- more banking than this ledger contains; * reaching `7.5e-4`, `8e-4` or `1e-3` is **impossible on this bit word**: the leaf caps kappa - at `1819302815717/25*10^16 = 7.277251...e-4` there, so those targets need a new bit word + at `1819302815717/25*10^16 = 7.277211...e-4` there, so those targets need a new bit word before any complex-side work can matter. +### The same three targets, inverted onto both branches (`bit_requirement`) + +`kappa` is read off `budget = min(bit leaf, (1-beta) * C - weak)`, so a target is met only when +**both** branches clear the budget it needs. The certificate inverts the rule per target and +checks each line twice: the pair (budget, required complex coarse saving) reaches the target, and +one `10^-18` step below the budget misses it. Because the cap must *clear* the budget after the +`beta` and `weak` haircuts, a complex saving on the grid must sit one grid step **above** the +budget it has to supply. + +| target | required budget | required bit leaf (gain over the pinned leaf) | required complex coarse (gain over the top rung) | +| ---: | ---: | ---: | ---: | +| 7.2e-4 | 7.20518773516933e-4 | 7.2825e-4 -- already enough | 7.20518773516934e-4 (+1.181%, as above) | +| 7.5e-4 | 7.50562922191644e-4 | 7.50562922191644e-4 (**+3.064%**) | 7.50562922191645e-4 (**+5.400%**, +7.083% over rung 1) | +| 8e-4 | 8.00640512409928e-4 | 8.00640512409928e-4 (**+9.940%**) | 8.00640512409929e-4 (**+12.433%**, +14.227% over rung 1) | +| 1e-3 | 1.001001001001002e-3 | 1.001001001001002e-3 (**+37.453%**) | 1.001001001001003e-3 (**+40.569%**, +42.813% over rung 1) | + +Only `7.2e-4` is short on the complex branch alone; the three higher targets are short on **both** +-- and the complex ceiling the density curve finds above (`7.27721126e-4`) is still below every +one of them. That is the package's answer to "what would a new bit word have to bring": a leaf of +at least the budget column, and a complex supplier that can clear the same budget by the same +margin -- the bit word because the leaf caps the budget, the complex supplier because the bank +mechanism has nothing left to take at width 66. + ## Verify ```sh @@ -220,14 +281,16 @@ python3 -B verify.py # check: pins, rebuild, compare with certificate. python3 -B verify.py --write # authoring: regenerate certificate.json and SOURCE.json ``` -`verify.py` passes with exit 0, pins 27 files by sha256, rebuilds the whole complex-side +`verify.py` passes with exit 0, pins 28 files by sha256, rebuilds the whole complex-side ladder (base, rung 2, rungs 3 and 4), both paid moments per rung, the two 47-constraint assemblies with adjacent-grid rejection, the eligibility scan, the PR208 replica, the padded schedule (795 banks, padding 0/2/6 registers per bank, stock drops 531/198/66), the instanced inventories (4,176 items, 795 banks, the digests), the modulus scan (which widths the pinned -row admits, and that only the pinned width is priced), and re-runs the T1 tiling enumeration -against the pinned `schedule66.json`; it reproduces #207's, #219's and #224's published grid -points exactly. The vendored rung-1 package also self-verifies in place: +row admits, and that only the pinned width is priced), the supplier scan and the density curve +with both of their calibrations, the per-target requirement table (each line re-derived from the +assembly rule and tested one `10^-18` step below its budget), and re-runs the T1 tiling +enumeration against the pinned `schedule66.json`; it reproduces #207's, #219's and #224's +published grid points exactly. The vendored rung-1 package also self-verifies in place: ```sh cd research/complex-bank-run3/references/pr219-run1 && python3 -B verify.py diff --git a/research/complex-bank-run3/SOURCE.json b/research/complex-bank-run3/SOURCE.json index 90e9f01e51..29bc7a8b77 100644 --- a/research/complex-bank-run3/SOURCE.json +++ b/research/complex-bank-run3/SOURCE.json @@ -4,7 +4,7 @@ "ledger3.py": "202591f64e76002dd0bc05e7d0c36214db85faf9261bb1757bfb0ca568cc53cd", "obligations.json": "cf887f237fc02204c25c7fd5234d4ded392a8a5397b4ab6bffc9d26a32b7d20e", "occurrences66.json": "d755258f115236356ee1b34a84ee98414eee42dd9eeb4f7034abf39b0dac5653", - "pins.py": "c2d6034b0282b6c73d30eb41c2510597b2fdfb5df26dea3d99b0004deda76fa0", + "pins.py": "49a86398b264f5aad88542af9119625b671e0c57788c9f911b29e9617f61285a", "prototype66.py": "74adbe605ceba533cba1e38b0eca466f67961f4a41e9c839094faa9d503dc2cc", "references/pr207-coordinated-crossover.certificate.json": "f4e30cca369fb014b729df870ca3716cc0f1e2297b9f265341492cba85a14aeb", "references/pr219-run1/NOTICE.md": "1f04b17404663a0983b7cc45e308e577d4d49fb6a4c1ff077dc3f13bae83c56f", @@ -23,9 +23,10 @@ "references/pr219-run1/references/pr205-packed.certificate.json": "c11fbb9aaa99594afc8d21e33761dc6d1d6c76ce3dbc36d5b64cae872c242f5a", "references/pr219-run1/schedule.py": "b9fff272f30048b982da3c0fc0149c2fde20bb7e32b8f9f860069956c12ebdc9", "references/pr219-run1/verify.py": "c839a06389945f9b0c6fbfd59bf2dd8030190c3de504d72c9bf032879f931197", - "run3.py": "57c50303d5cff110ec6a4c9c2501b052850cacbdeec9a08f9ff52787b6940418", + "run3.py": "7b27d1146dcda308e9e1b0e7141c40be87a9c0248e152551d6f6c0cef1e5a4b9", "schedule66.json": "3f11889e722a8a00d1edc7c72bd099ecf0a72c8dd60ae83347b739565b48e919", "schedule66.py": "1683b7e210bdd0d89abbbda8a03959325f38e6e138f473e312987adce8483981", + "suppliers.py": "d3f02ed69c2b08c5aed3b7a9e08b66754835c1ce2cefa00bb62eab8e16a35500", "widths66.py": "8b230906566113c0f1b742f2a246925ad11c0ab8ad51dc5167fb4d3e7b7dc905" } } diff --git a/research/complex-bank-run3/certificate.json b/research/complex-bank-run3/certificate.json index 1daf8d7008..1692897927 100644 --- a/research/complex-bank-run3/certificate.json +++ b/research/complex-bank-run3/certificate.json @@ -1,5 +1,99 @@ { "binding": "complex", + "bit_requirement": [ + { + "binding_at_the_requirement": "complex", + "bit_branch_short": false, + "bit_coarse_now": "728251090009891/1000000000000000000", + "bit_leaf_gain": "-7732316473295079570667060334898259823066154658013234139282580595702841889832933964476516783/728251089990228079570667060334898259823066154658013234139282580595702841889832933964476516783", + "bit_leaf_now": "728251089990228079570667060334898259823066154658013234139282580595702841889832933964476516783/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_branch_short": true, + "complex_coarse_gain_vs_ladder_top": "4206038502618/356053348255849", + "complex_coarse_gain_vs_rung1": "19600329657523/700918443859411", + "complex_coarse_now": "356053348255849/500000000000000000", + "kappa_at_the_bit_ceiling_decimal": 0.0007277211262868, + "kappa_at_the_bit_ceiling_now": "1819302815717/2500000000000000", + "reached_by_the_pair": "9/12500", + "required_bit_coarse_saving": "720518773536595920429332939665101740176933845341986765860717419404297158110167066035523483217/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_bit_leaf": "720518773516933/1000000000000000000", + "required_budget": "720518773516933/1000000000000000000", + "required_budget_decimal": 0.000720518773516933, + "required_complex_coarse_decimal": 0.000720518773516934, + "required_complex_coarse_saving": "360259386758467/500000000000000000", + "status": "needs a new bit word and more complex supply: both branches sit below the budget this target needs, and the bank ladder cannot raise the complex side again (its whole-bank criterion is exhausted at the top rung)", + "target": "9/12500", + "target_decimal": 0.00072 + }, + { + "binding_at_the_requirement": "bit", + "bit_branch_short": true, + "bit_coarse_now": "728251090009891/1000000000000000000", + "bit_leaf_gain": "2479092466823991158814771073900193352992649482442973984524157711588573123351896226169275913/80916787776692008841185228926099806647007350517557026015475842288411426876648103773830724087", + "bit_leaf_now": "728251089990228079570667060334898259823066154658013234139282580595702841889832933964476516783/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_branch_short": true, + "complex_coarse_gain_vs_ladder_top": "38456225679947/712106696511698", + "complex_coarse_gain_vs_rung1": "49644478332234/700918443859411", + "complex_coarse_now": "356053348255849/500000000000000000", + "kappa_at_the_bit_ceiling_decimal": 0.0007277211262868, + "kappa_at_the_bit_ceiling_now": "1819302815717/2500000000000000", + "reached_by_the_pair": "3/4000", + "required_bit_coarse_saving": "750562922211306920429332939665101740176933845341986765860717419404297158110167066035523483217/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_bit_leaf": "187640730547911/250000000000000000", + "required_budget": "187640730547911/250000000000000000", + "required_budget_decimal": 0.000750562922191644, + "required_complex_coarse_decimal": 0.000750562922191645, + "required_complex_coarse_saving": "150112584438329/200000000000000000", + "status": "needs a new bit word and more complex supply: both branches sit below the budget this target needs, and the bank ladder cannot raise the complex side again (its whole-bank criterion is exhausted at the top rung)", + "target": "3/4000", + "target_decimal": 0.00075 + }, + { + "binding_at_the_requirement": "bit", + "bit_branch_short": true, + "bit_coarse_now": "728251090009891/1000000000000000000", + "bit_leaf_gain": "72389422419699920429332939665101740176933845341986765860717419404297158110167066035523483217/728251089990228079570667060334898259823066154658013234139282580595702841889832933964476516783", + "bit_leaf_now": "728251089990228079570667060334898259823066154658013234139282580595702841889832933964476516783/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_branch_short": true, + "complex_coarse_gain_vs_ladder_top": "88533815898231/712106696511698", + "complex_coarse_gain_vs_rung1": "99722068550518/700918443859411", + "complex_coarse_now": "356053348255849/500000000000000000", + "kappa_at_the_bit_ceiling_decimal": 0.0007277211262868, + "kappa_at_the_bit_ceiling_now": "1819302815717/2500000000000000", + "reached_by_the_pair": "1/1250", + "required_bit_coarse_saving": "800640512429590920429332939665101740176933845341986765860717419404297158110167066035523483217/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_bit_leaf": "100080064051241/125000000000000000", + "required_budget": "100080064051241/125000000000000000", + "required_budget_decimal": 0.000800640512409928, + "required_complex_coarse_decimal": 0.000800640512409929, + "required_complex_coarse_saving": "800640512409929/1000000000000000000", + "status": "needs a new bit word and more complex supply: both branches sit below the budget this target needs, and the bank ladder cannot raise the complex side again (its whole-bank criterion is exhausted at the top rung)", + "target": "1/1250", + "target_decimal": 0.0008 + }, + { + "binding_at_the_requirement": "bit", + "bit_branch_short": true, + "bit_coarse_now": "728251090009891/1000000000000000000", + "bit_leaf_gain": "272749911010773920429332939665101740176933845341986765860717419404297158110167066035523483217/728251089990228079570667060334898259823066154658013234139282580595702841889832933964476516783", + "bit_leaf_now": "728251089990228079570667060334898259823066154658013234139282580595702841889832933964476516783/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_branch_short": true, + "complex_coarse_gain_vs_ladder_top": "288894304489305/712106696511698", + "complex_coarse_gain_vs_rung1": "300082557141592/700918443859411", + "complex_coarse_now": "356053348255849/500000000000000000", + "kappa_at_the_bit_ceiling_decimal": 0.0007277211262868, + "kappa_at_the_bit_ceiling_now": "1819302815717/2500000000000000", + "reached_by_the_pair": "1/1000", + "required_bit_coarse_saving": "1001001001020664920429332939665101740176933845341986765860717419404297158110167066035523483217/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "required_bit_leaf": "500500500500501/500000000000000000", + "required_budget": "500500500500501/500000000000000000", + "required_budget_decimal": 0.001001001001001002, + "required_complex_coarse_decimal": 0.001001001001001003, + "required_complex_coarse_saving": "1001001001001003/1000000000000000000", + "status": "needs a new bit word and more complex supply: both branches sit below the budget this target needs, and the bank ladder cannot raise the complex side again (its whole-bank criterion is exhausted at the top rung)", + "target": "1/1000", + "target_decimal": 0.001 + } + ], "blocked_on": { "complex_family_inventory": null, "complex_family_inventory_note": "the only occurrence inventory in the pins is #219's bit-side inputs/absorbed-occurrences.json (rank 22); the complex rank-11 family of PR224, and the rank-16 and rank-20 families this package absorbs, have no such enumeration, so the item-to-block map of C1 has no starting inventory", @@ -417,14 +511,14 @@ }, { "binding": "bit", - "budget": "8064516129032259/1000000000000000000", + "budget": "100080064051241/125000000000000000", "coarse": null, "gain_vs_top": null, "kappa": null, "kappa_at_the_bit_ceiling": "1819302815717/2500000000000000", "needs_new_bit": true, - "required_bit_leaf": "8064516129032259/1000000000000000000", - "target": "1/125" + "required_bit_leaf": "100080064051241/125000000000000000", + "target": "1/1250" }, { "binding": "bit", @@ -822,7 +916,7 @@ "ledger3.py": "202591f64e76002dd0bc05e7d0c36214db85faf9261bb1757bfb0ca568cc53cd", "obligations.json": "cf887f237fc02204c25c7fd5234d4ded392a8a5397b4ab6bffc9d26a32b7d20e", "occurrences66.json": "d755258f115236356ee1b34a84ee98414eee42dd9eeb4f7034abf39b0dac5653", - "pins.py": "c2d6034b0282b6c73d30eb41c2510597b2fdfb5df26dea3d99b0004deda76fa0", + "pins.py": "49a86398b264f5aad88542af9119625b671e0c57788c9f911b29e9617f61285a", "prototype66.py": "74adbe605ceba533cba1e38b0eca466f67961f4a41e9c839094faa9d503dc2cc", "references/pr207-coordinated-crossover.certificate.json": "f4e30cca369fb014b729df870ca3716cc0f1e2297b9f265341492cba85a14aeb", "references/pr219-run1/NOTICE.md": "1f04b17404663a0983b7cc45e308e577d4d49fb6a4c1ff077dc3f13bae83c56f", @@ -841,12 +935,533 @@ "references/pr219-run1/references/pr205-packed.certificate.json": "c11fbb9aaa99594afc8d21e33761dc6d1d6c76ce3dbc36d5b64cae872c242f5a", "references/pr219-run1/schedule.py": "b9fff272f30048b982da3c0fc0149c2fde20bb7e32b8f9f860069956c12ebdc9", "references/pr219-run1/verify.py": "c839a06389945f9b0c6fbfd59bf2dd8030190c3de504d72c9bf032879f931197", - "run3.py": "57c50303d5cff110ec6a4c9c2501b052850cacbdeec9a08f9ff52787b6940418", + "run3.py": "7b27d1146dcda308e9e1b0e7141c40be87a9c0248e152551d6f6c0cef1e5a4b9", "schedule66.json": "3f11889e722a8a00d1edc7c72bd099ecf0a72c8dd60ae83347b739565b48e919", "schedule66.py": "1683b7e210bdd0d89abbbda8a03959325f38e6e138f473e312987adce8483981", + "suppliers.py": "d3f02ed69c2b08c5aed3b7a9e08b66754835c1ce2cefa00bb62eab8e16a35500", "widths66.py": "8b230906566113c0f1b742f2a246925ad11c0ab8ad51dc5167fb4d3e7b7dc905" }, "status": "MODEL AND TARGET, NOT CONSTRUCTED: the ledger and the bank schedule above rung 2 are certified here -- whole-bank volumes, the padded width-66 schedule itself (banks, blocks per bank, item-to-block assignment, padding draw), the retained row identities with the stock falling by exactly the bank count, both paid moments on the 10^-18 grid, and the two 47-constraint assemblies -- but the physical construction on the complex supplier is still owed (obligations.json C1-C7, plus #219's inherited R1-R4; T1 is settled by the schedule prototype and its negative uniform-tiling result). The kappa below is conditional on those and is not a completed finite witness.", + "supplier_density": { + "corpus": { + "below_pinned_count": 0, + "below_pinned_sample": [], + "least_dense_overall": { + "W": 12052, + "deficit": 1320, + "density": "3008/3013", + "density_decimal": 0.9983405243942914, + "eligible_at_that_modulus": [ + 11, + 16, + 20 + ], + "families": 20, + "m": 66, + "modulus_headroom": 0, + "path": "/complex_profile", + "rank_mass": 794112, + "smallest_admissible_modulus": 66, + "source": "research/complex-bank-run3/references/pr207-coordinated-crossover.certificate.json", + "tiling_mass": 17490, + "tiling_share": "265/12032", + "tiling_share_decimal": 0.022024601063829786 + }, + "pinned_density": "3008/3013", + "profiles_scanned": 20, + "ranked": [ + { + "W": 9854325632000, + "deficit": 170237516800, + "density": "476821993487/476822208000", + "density_decimal": 0.999999550119528, + "eligible_at_that_modulus": [ + 6, + 8, + 10, + 12, + 16, + 20, + 26, + 28, + 36, + 882, + 36402, + 38256, + 38340 + ], + "families": 27, + "m": 38400, + "modulus_headroom": 0, + "path": "/bit", + "rank_mass": 378405934031283200, + "smallest_admissible_modulus": 38400, + "source": "certificates/endpoint-gauge-input.json", + "tiling_mass": 373751568345446400, + "tiling_share": "14599670638494/14781481798097", + "tiling_share_decimal": 0.9877000721520081 + }, + { + "W": 10390178240000, + "deficit": 163119001600, + "density": "3896315247041/3896316840000", + "density_decimal": 0.9999995911628685, + "eligible_at_that_modulus": [ + 17, + 28, + 36, + 39, + 40, + 37401, + 38328, + 38370 + ], + "families": 45, + "m": 38400, + "modulus_headroom": 0, + "path": "", + "rank_mass": 398982681296998400, + "smallest_admissible_modulus": 38400, + "source": "certificates/endpoint-gauge-complex-input.json", + "tiling_mass": 392336088506227200, + "tiling_share": "30651256914549/31170521976328", + "tiling_share_decimal": 0.9833411496229243 + }, + { + "W": 147067888, + "deficit": 1862080, + "density": "5231549/5231664", + "density_decimal": 0.9999780184660177, + "eligible_at_that_modulus": [ + 15, + 552, + 556, + 558 + ], + "families": 38, + "m": 576, + "modulus_headroom": 0, + "path": "/complex/counts", + "rank_mass": 84709241408, + "smallest_admissible_modulus": 576, + "source": "certificates/partial-gauge-network.json", + "tiling_mass": 66559469760, + "tiling_share": "1039991715/1323581897", + "tiling_share_decimal": 0.7857403590644607 + }, + { + "W": 108516254, + "deficit": 1344189, + "density": "1409269/1409302", + "density_decimal": 0.9999765841530063, + "eligible_at_that_modulus": [ + 2, + 21, + 484, + 506 + ], + "families": 46, + "m": 529, + "modulus_headroom": 0, + "path": "/bit/counts", + "rank_mass": 57403754177, + "smallest_admissible_modulus": 529, + "source": "certificates/partial-gauge-network.json", + "tiling_mass": 36244057823, + "tiling_share": "68514287/108513713", + "tiling_share_decimal": 0.6313882836172051 + }, + { + "W": 7075380480000, + "deficit": 117684134400, + "density": "29344881877/29344896000", + "density_decimal": 0.9999995187238012, + "eligible_at_that_modulus": [ + 3, + 6, + 8, + 20, + 27, + 36, + 34488, + 34500 + ], + "families": 38, + "m": 34560, + "modulus_headroom": 0, + "path": "/bit", + "rank_mass": 244525031704665600, + "smallest_admissible_modulus": 34560, + "source": "certificates/structured-bulk-input.json", + "tiling_mass": 117725866713100800, + "tiling_share": "437968254141/909691338187", + "tiling_share_decimal": 0.48144709722515727 + }, + { + "W": 20668, + "deficit": 1936, + "density": "92885/93006", + "density_decimal": 0.9986990086661076, + "eligible_at_that_modulus": [ + 3, + 6, + 9, + 12, + 14, + 15, + 16, + 19, + 21 + ], + "families": 23, + "m": 72, + "modulus_headroom": 0, + "path": "/bit/overridden_profile", + "rank_mass": 1486160, + "smallest_admissible_modulus": 72, + "source": "research/complex-bank-run3/references/pr219-run1/references/pr200-bit.certificate.json", + "tiling_mass": 683208, + "tiling_share": "85401/185770", + "tiling_share_decimal": 0.4597136243742262 + }, + { + "W": 56402, + "deficit": 5808, + "density": "84482/84603", + "density_decimal": 0.9985697906693616, + "eligible_at_that_modulus": [ + 6, + 8, + 10, + 15, + 16, + 18, + 20, + 22 + ], + "families": 22, + "m": 72, + "modulus_headroom": 0, + "path": "/bit_profile", + "rank_mass": 4055136, + "smallest_admissible_modulus": 72, + "source": "research/complex-bank-run3/references/pr207-coordinated-crossover.certificate.json", + "tiling_mass": 1343088, + "tiling_share": "27981/84482", + "tiling_share_decimal": 0.33120664756989654 + }, + { + "W": 21548, + "deficit": 1936, + "density": "96845/96966", + "density_decimal": 0.9987521399253346, + "eligible_at_that_modulus": [ + 3, + 6, + 7, + 12, + 18, + 21 + ], + "families": 23, + "m": 72, + "modulus_headroom": 0, + "path": "/bit/inherited_profile", + "rank_mass": 1549520, + "smallest_admissible_modulus": 72, + "source": "research/coordinated-frames-and-entrance-banks/certificate.json", + "tiling_mass": 478368, + "tiling_share": "29898/96845", + "tiling_share_decimal": 0.30872011977902836 + }, + { + "W": 13372, + "deficit": 1320, + "density": "3338/3343", + "density_decimal": 0.9985043374214777, + "eligible_at_that_modulus": [ + 4, + 17, + 18, + 20 + ], + "families": 20, + "m": 66, + "modulus_headroom": 0, + "path": "/complex/physical/before_terminal_sinks", + "rank_mass": 881232, + "smallest_admissible_modulus": 66, + "source": "research/coordinated-frames-and-entrance-banks/certificate.json", + "tiling_mass": 255156, + "tiling_share": "1933/6676", + "tiling_share_decimal": 0.2895446375074895 + }, + { + "W": 13207, + "deficit": 1320, + "density": "13187/13207", + "density_decimal": 0.9984856515484213, + "eligible_at_that_modulus": [ + 16, + 17, + 18, + 20 + ], + "families": 20, + "m": 66, + "modulus_headroom": 0, + "path": "/complex/physical/before_terminal_sinks", + "rank_mass": 870342, + "smallest_admissible_modulus": 66, + "source": "research/complex-bank-run3/references/pr219-run1/references/pr200-bit.certificate.json", + "tiling_mass": 194964, + "tiling_share": "2954/13187", + "tiling_share_decimal": 0.2240084932130128 + }, + { + "W": 13163, + "deficit": 1320, + "density": "13143/13163", + "density_decimal": 0.9984805895312618, + "eligible_at_that_modulus": [ + 16, + 17, + 18, + 20 + ], + "families": 20, + "m": 66, + "modulus_headroom": 0, + "path": "/complex/physical/physical", + "rank_mass": 867438, + "smallest_admissible_modulus": 66, + "source": "research/complex-bank-run3/references/pr219-run1/references/pr200-bit.certificate.json", + "tiling_mass": 192060, + "tiling_share": "970/4381", + "tiling_share_decimal": 0.2214106368409039 + }, + { + "W": 29937, + "deficit": 1936, + "density": "269191/269433", + "density_decimal": 0.9991018175204968, + "eligible_at_that_modulus": [ + 3, + 20, + 21 + ], + "families": 23, + "m": 72, + "modulus_headroom": 0, + "path": "", + "rank_mass": 2153528, + "smallest_admissible_modulus": 72, + "source": "certificates/paired-cube-complex-input.json", + "tiling_mass": 452592, + "tiling_share": "56574/269191", + "tiling_share_decimal": 0.2101630440839404 + }, + { + "W": 27521, + "deficit": 2024, + "density": "82475/82563", + "density_decimal": 0.9989341472572459, + "eligible_at_that_modulus": [ + 18, + 19 + ], + "families": 27, + "m": 69, + "modulus_headroom": 0, + "path": "", + "rank_mass": 1896925, + "smallest_admissible_modulus": 69, + "source": "research/bit-reuse-147/row.json", + "tiling_mass": 304704, + "tiling_share": "13248/82475", + "tiling_share_decimal": 0.16063049408911792 + }, + { + "W": 20634, + "deficit": 1936, + "density": "92732/92853", + "density_decimal": 0.998696864937051, + "eligible_at_that_modulus": [ + 6, + 9, + 12, + 14, + 15, + 16, + 19 + ], + "families": 23, + "m": 72, + "modulus_headroom": 0, + "path": "/bit/profile", + "rank_mass": 1483712, + "smallest_admissible_modulus": 72, + "source": "research/complex-bank-run3/references/pr219-run1/references/pr200-bit.certificate.json", + "tiling_mass": 227232, + "tiling_share": "7101/46366", + "tiling_share_decimal": 0.1531510158305655 + } + ], + "root": "C:\\Users\\Max\\AppData\\Local\\Temp\\r2pkg" + }, + "curve": [ + { + "banks": 88, + "deficit": 1344, + "density": "4136/4143", + "density_decimal": 0.9983104030895487, + "eligible_families": [ + 16 + ], + "kappa": "1819302815717/2500000000000000", + "mass_removed": 4224, + "modulus": 48, + "pinned_density": "3008/3013", + "priced": true, + "retained_mass": 789888, + "retained_stock": 16484, + "saving": "25836948211799/31250000000000000", + "status": "priced (synthetic row: same shape, this modulus and stock)", + "stock_min": 16572, + "tiling_share": "1/188", + "tiling_share_decimal": 0.005319148936170213 + }, + { + "banks": 5707, + "deficit": 1362, + "density": "132352/132579", + "density_decimal": 0.998287813303766, + "eligible_families": [ + 1, + 6, + 12, + 18 + ], + "kappa": null, + "mass_removed": 308178, + "modulus": 54, + "pinned_density": "3008/3013", + "priced": false, + "saving": null, + "status": "the padding draw exceeds the kept rank-1 bin", + "stock_min": 14731, + "tiling_share": "51363/132352", + "tiling_share_decimal": 0.3880787596711799 + }, + { + "banks": 487, + "deficit": 1368, + "density": "33088/33145", + "density_decimal": 0.9982802836023533, + "eligible_families": [ + 10, + 20 + ], + "kappa": "1819302815717/2500000000000000", + "mass_removed": 29220, + "modulus": 60, + "pinned_density": "3008/3013", + "priced": true, + "retained_mass": 764892, + "retained_stock": 12771, + "saving": "31159114094063/40000000000000000", + "status": "priced (synthetic row: same shape, this modulus and stock)", + "stock_min": 13258, + "tiling_share": "2435/66176", + "tiling_share_decimal": 0.0367958172147002 + }, + { + "banks": 265, + "deficit": 1320, + "density": "3008/3013", + "density_decimal": 0.9983405243942914, + "eligible_families": [ + 11, + 16, + 20 + ], + "kappa": "711599961413937/1000000000000000000", + "mass_removed": 17490, + "modulus": 66, + "pinned_density": "3008/3013", + "priced": true, + "retained_mass": 776622, + "retained_stock": 11787, + "saving": "356053348255849/500000000000000000", + "status": "priced (synthetic row: same shape, this modulus and stock)", + "stock_min": 12052, + "tiling_share": "265/12032", + "tiling_share_decimal": 0.022024601063829786 + }, + { + "banks": 0, + "deficit": 1344, + "density": "4136/4143", + "density_decimal": 0.9983104030895487, + "eligible_families": [], + "kappa": null, + "mass_removed": 0, + "modulus": 72, + "pinned_density": "3008/3013", + "priced": false, + "saving": null, + "status": "nothing tiles, or the stock cannot retire the banks", + "stock_min": 11048, + "tiling_share": "0", + "tiling_share_decimal": 0.0 + }, + { + "banks": 884, + "deficit": 1368, + "density": "33088/33145", + "density_decimal": 0.9982802836023533, + "eligible_families": [ + 12, + 14 + ], + "kappa": "706360069762831/1000000000000000000", + "mass_removed": 74256, + "modulus": 84, + "pinned_density": "3008/3013", + "priced": true, + "retained_mass": 719856, + "retained_stock": 8586, + "saving": "353429683497307/500000000000000000", + "status": "priced (synthetic row: same shape, this modulus and stock)", + "stock_min": 9470, + "tiling_share": "1547/16544", + "tiling_share_decimal": 0.09350822050290135 + }, + { + "banks": 44, + "deficit": 1344, + "density": "4136/4143", + "density_decimal": 0.9983104030895487, + "eligible_families": [ + 16 + ], + "kappa": "617982590757721/1000000000000000000", + "mass_removed": 4224, + "modulus": 96, + "pinned_density": "3008/3013", + "priced": true, + "retained_mass": 789888, + "retained_stock": 8242, + "saving": "309182364697613/500000000000000000", + "status": "priced (synthetic row: same shape, this modulus and stock)", + "stock_min": 8286, + "tiling_share": "1/188", + "tiling_share_decimal": 0.005319148936170213 + } + ], + "note": "Two measurements, both read off the tree rather than assumed. (1) Every ledger-bearing certificate in the repository is scored on the same numbers: modulus, density mass/(m*W), the smallest modulus the row admits and the mass share that tiles whole banks there. No poseable ledger is less dense than the complex word priced here, and that word is itself the least dense one found, so the narrower modulus the width scan wants cannot be reached by reusing a supplier that already exists anywhere in the pins. (2) Holding this word's own bin shape and occupancy fixed and varying only the modulus, the cheapest stock that poses the row is priced: at widths 48, 54 and 60 the complex branch stops binding altogether and the kappa rises to the bit leaf's own ceiling, while the pinned width 72 no longer tiles and every wider word is strictly worse. The curve is synthetic -- same shape, invented width and stock, priced by the pinned engine on a row no supplier in the pins owns -- so it specifies what a word would have to look like; it is not a result about an existing word. Its width-66 point is the calibration: there the stock it requires is exactly the stock the pinned ledger carries and it reproduces this certificate's top kappa.", + "pinned_density": "3008/3013" + }, "tiling": { "certified_precedent": { "banks": 45842, @@ -1153,6 +1768,12 @@ "schedule": "padded prototype (prototype66.py): 531 + 198 + 66 = 795 banks, the rank-16 and rank-20 banks padded with 2 and 6 registers of retained blocks", "stock": 35361 }, + "weighted_ceiling": { + "gain_vs_top": "16121164872863/711599961413937", + "kappa_suppliers_admit_today": "1819302815717/2500000000000000", + "kappa_suppliers_admit_today_decimal": 0.0007277211262868, + "note": "What the complex side would pay if a word of width 48-60 with this shape and occupancy existed: the complex branch stops binding and the kappa rises to the budget the bit leaf itself allows. That is the whole of the complex headroom left, and it is still short of every target, which is why the bit word is the wall and why the bit requirement above is the next real step." + }, "width_scan": { "100": { "blocks_per_bank": { diff --git a/research/complex-bank-run3/pins.py b/research/complex-bank-run3/pins.py index b39b4fe835..72d9997841 100644 --- a/research/complex-bank-run3/pins.py +++ b/research/complex-bank-run3/pins.py @@ -14,7 +14,7 @@ VENDORED_RUN1 = 'references/pr219-run1' OWN = ('ledger3.py', 'run3.py', 'schedule66.py', 'schedule66.json', 'prototype66.py', - 'widths66.py', 'instantiate66.py', 'occurrences66.json', 'pins.py', + 'widths66.py', 'suppliers.py', 'instantiate66.py', 'occurrences66.json', 'pins.py', 'obligations.json', 'references/pr207-coordinated-crossover.certificate.json') diff --git a/research/complex-bank-run3/run3.py b/research/complex-bank-run3/run3.py index 2d82ad1e6c..6ddc93c5d1 100644 --- a/research/complex-bank-run3/run3.py +++ b/research/complex-bank-run3/run3.py @@ -68,6 +68,7 @@ import pins # noqa: E402 import prototype66 # noqa: E402 import schedule66 # noqa: E402 +import suppliers # noqa: E402 import widths66 # noqa: E402 REFERENCES = HERE / 'references' @@ -88,7 +89,7 @@ RUN2_COARSE = Q(708793603125109, 10 ** 18) # PR224's published rung-2 coarse saving RUN2_REPLICA = Q(3541457, 5 * 10 ** 9) # PR208's priced rung-2 target RUNGS = (11, 16, 20) # every whole-bank family of this ledger -TARGETS = (Q(72, 10 ** 5), Q(75, 10 ** 5), Q(8, 10 ** 3), Q(1, 10 ** 3)) +TARGETS = (Q(72, 10 ** 5), Q(75, 10 ** 5), Q(8, 10 ** 4), Q(1, 10 ** 3)) def frontier_kappa(bit_saving, complex_saving): @@ -154,6 +155,53 @@ def complex_for_target(target, bit_leaf): needs_new_bit=(a != (1 - BETA) * coarse - WEAK)) +def bit_requirement(leaf, coarse_top, bit_coarse, complex_coarse_1, targets=TARGETS): + """What each target costs, inverted from the assembly rule on *both* branches. + + `kappa` is read off `budget = min(bit leaf, (1 - beta) C - weak)` and is monotone in the + budget, so a target is met only when *both* branches clear the budget the target needs: + a new bit word with leaf >= budget, and a complex supplier whose coarse saving clears the + budget after the beta and weak haircuts. Each line below is checked to reach its target + as a pair and to miss it one 10^-18 step below, so the requirement is sufficient and tight + on the grid rather than merely necessary. + """ + out = [] + for target in targets: + info = complex_for_target(target, leaf) + budget = Q(info['budget']) + assert kappa_of_budget(budget) >= target > kappa_of_budget(budget - Q(1, GRID)), \ + 'the budget must be the minimal grid point that reaches the target' + exact = (budget + WEAK) / (1 - BETA) + z = exact * GRID + coarse_needed = Q(-((-z.numerator) // z.denominator), GRID) # ceil to the grid + assert (1 - BETA) * coarse_needed - WEAK > budget, \ + 'the complex cap must clear the budget, not merely meet it' + selected, _bound, kappa = frontier_kappa(budget, coarse_needed) + assert selected == budget and kappa >= target, \ + 'the pair (budget, coarse_needed) must reach the target' + out.append(dict( + target=str(target), target_decimal=float(target), + binding_at_the_requirement=info['binding'], + required_budget=str(budget), required_budget_decimal=float(budget), + required_bit_leaf=str(budget), bit_leaf_now=str(leaf), + bit_leaf_gain=budget / leaf - 1, + required_bit_coarse_saving=str(budget + (Q(bit_coarse) - leaf)), + bit_coarse_now=str(bit_coarse), + required_complex_coarse_saving=str(coarse_needed), + required_complex_coarse_decimal=float(coarse_needed), + complex_coarse_now=str(coarse_top), + complex_coarse_gain_vs_ladder_top=coarse_needed / coarse_top - 1, + complex_coarse_gain_vs_rung1=coarse_needed / complex_coarse_1 - 1, + bit_branch_short=(budget > leaf), complex_branch_short=(coarse_needed > coarse_top), + kappa_at_the_bit_ceiling_now=str(kappa_of_budget(leaf)), + kappa_at_the_bit_ceiling_decimal=float(kappa_of_budget(leaf)), + reached_by_the_pair=str(kappa), + status='needs a new bit word and more complex supply: both branches sit below the ' + 'budget this target needs, and the bank ladder cannot raise the complex ' + 'side again (its whole-bank criterion is exhausted at the top rung)')) + return out + + def serial(value): if isinstance(value, Q): return str(value) @@ -431,6 +479,47 @@ def build(): info['gain_vs_top'] = (Q(info['coarse']) / coarse_top - 1 if info['coarse'] is not None else None) needs.append(info) + requirement = bit_requirement(leaf, coarse_top, Q(calibration_run1['bit_coarse_after']), + Q(calibration_run1['complex_coarse'])) + for info, line in zip(needs, requirement): + if info['needs_new_bit']: + assert info['required_bit_leaf'] == line['required_bit_leaf'], \ + 'the two inversions of the same target must agree on the required bit leaf' + assert line['bit_branch_short'] and line['complex_branch_short'], \ + 'these targets must be short on both branches' + assert Q(line['kappa_at_the_bit_ceiling_now']) < Q(line['target']), \ + 'the current bit leaf must not reach the target' + + # --- 6. suppliers and density: is a less dense word already pinned, and what + # would one of a given width have to look like ---------------------- + base_one_copy = ledger3.profile(supplier['complex_profile']) + pinned_density = Q(base_one_copy['total_rank'], base_one_copy['m'] * base_one_copy['W']) + corpus = suppliers.corpus_scan(pinned_density=pinned_density) + curve = suppliers.density_curve(base_one_copy, interval=interval, leaf=leaf) + by_width = {entry['modulus']: entry for entry in curve} + assert corpus['profiles_scanned'] >= 10, 'the corpus scan must find the pinned ledgers' + assert corpus['below_pinned_count'] == 0, \ + 'no poseable ledger in the repository may be less dense than the word priced here' + assert corpus['least_dense_overall'] is not None + assert Q(corpus['least_dense_overall']['density']) == pinned_density, \ + 'the least dense poseable ledger in the repository must be this word itself' + assert by_width[66]['priced'] and Q(by_width[66]['kappa']) == kappa_top, \ + 'the curve must reproduce the pinned top at the pinned width (its calibration)' + assert Q(by_width[66]['stock_min']) == base_one_copy['W'], \ + 'and the required stock there must be the stock the pinned ledger carries' + cap_now = kappa_of_budget(leaf) + for width in (48, 54, 60): + entry = by_width[width] + if not entry['priced']: + continue + assert Q(entry['kappa']) == cap_now, \ + 'a word that narrow with this shape and occupancy stops binding on the complex side' + assert Q(entry['saving']) > Q(calibration_run1['complex_coarse']), \ + 'and its saving must beat rung 1 (its widened headroom, not its kappa, is what moves)' + assert not by_width[72]['priced'], 'the pinned width must not tile after the ladder' + for entry in curve: + if entry['priced'] and entry['modulus'] > 66: + assert Q(entry['kappa']) < kappa_top, 'a wider word must be strictly worse' certificate = dict( status='MODEL AND TARGET, NOT CONSTRUCTED: the ledger and the bank schedule above ' @@ -482,6 +571,34 @@ def build(): 'are priced at 192 and 60 banks where their own capacities require ' '198 and 66'), needed_for=needs, + bit_requirement=requirement, + supplier_density=dict( + corpus=corpus, curve=curve, pinned_density=str(pinned_density), + note='Two measurements, both read off the tree rather than assumed. (1) Every ' + 'ledger-bearing certificate in the repository is scored on the same numbers: ' + 'modulus, density mass/(m*W), the smallest modulus the row admits and the mass ' + 'share that tiles whole banks there. No poseable ledger is less dense than the ' + 'complex word priced here, and that word is itself the least dense one found, ' + 'so the narrower modulus the width scan wants cannot be reached by reusing a ' + 'supplier that already exists anywhere in the pins. (2) Holding this word\'s own ' + 'bin shape and occupancy fixed and varying only the modulus, the cheapest stock ' + 'that poses the row is priced: at widths 48, 54 and 60 the complex branch stops ' + 'binding altogether and the kappa rises to the bit leaf\'s own ceiling, while ' + 'the pinned width 72 no longer tiles and every wider word is strictly worse. ' + 'The curve is synthetic -- same shape, invented width and stock, priced by the ' + 'pinned engine on a row no supplier in the pins owns -- so it specifies what a ' + 'word would have to look like; it is not a result about an existing word. Its ' + 'width-66 point is the calibration: there the stock it requires is exactly the ' + 'stock the pinned ledger carries and it reproduces this certificate\'s top kappa.'), + weighted_ceiling=dict( + kappa_suppliers_admit_today=str(cap_now), + kappa_suppliers_admit_today_decimal=float(cap_now), + gain_vs_top=cap_now / kappa_top - 1, + note='What the complex side would pay if a word of width 48-60 with this shape and ' + 'occupancy existed: the complex branch stops binding and the kappa rises to the ' + 'budget the bit leaf itself allows. That is the whole of the complex headroom ' + 'left, and it is still short of every target, which is why the bit word is the ' + 'wall and why the bit requirement above is the next real step.'), conservative_variant=dict( supplier_field=str(supplier_field), certified_moment=str(a_complex), delta=str(supplier_field - a_complex), @@ -550,6 +667,35 @@ def main(): print('to reach %-8s needs complex coarse %-20s (%+.3f%% over the top, binding %s)' % (need['target'], need['coarse'], float(Q(need['gain_vs_top'])) * 100, need['binding'])) + for line in record['bit_requirement']: + print('target %-8s both branches short (bit %s, complex %s): bit leaf must reach %-20s ' + '(%+.3f%%), complex coarse %-20s (%+.3f%% over the top, %+.3f%% over rung 1)' + % (line['target'], line['bit_branch_short'], line['complex_branch_short'], + line['required_bit_leaf'], float(Q(line['bit_leaf_gain'])) * 100, + line['required_complex_coarse_saving'], + float(Q(line['complex_coarse_gain_vs_ladder_top'])) * 100, + float(Q(line['complex_coarse_gain_vs_rung1'])) * 100)) + ceiling = record['weighted_ceiling'] + print('ceiling a word of width 48-60 with this shape and occupancy pays kappa %s ' + '(%+.4f%% over the top); every target still needs the bit word' + % (ceiling['kappa_suppliers_admit_today'], + float(Q(ceiling['gain_vs_top'])) * 100)) + scan = record['supplier_density']['corpus'] + print('suppliers %d poseable ledgers scored, %d less dense than the pinned word; least dense ' + 'overall is %d wide at %.5f (%s)' + % (scan['profiles_scanned'], scan['below_pinned_count'], + scan['least_dense_overall']['m'], scan['least_dense_overall']['density_decimal'], + scan['least_dense_overall']['source'])) + for entry in record['supplier_density']['curve']: + if entry['priced']: + print('curve width %-3d stock %-6s density %.5f coarse %-20s kappa %-20s %+.4f%%' + % (entry['modulus'], entry['stock_min'], entry['density_decimal'], + entry['saving'], entry['kappa'], + float(Q(entry['kappa']) / Q(record['kappa']) - 1) * 100)) + else: + print('curve width %-3d stock %-6s density %.5f %s' + % (entry['modulus'], entry['stock_min'], entry['density_decimal'], + entry['status'])) print('replica rung 2 %s matches PR208: %s; rungs 3/4 %s' % (record['replica'][0]['kappa'], record['replica'][0]['matches_published'], [r['kappa'] for r in record['replica'][1:]])) diff --git a/research/complex-bank-run3/suppliers.py b/research/complex-bank-run3/suppliers.py new file mode 100644 index 0000000000..912eed8dfe --- /dev/null +++ b/research/complex-bank-run3/suppliers.py @@ -0,0 +1,285 @@ +#!/usr/bin/env python3 +"""Two questions the width scan left open, answered by measurement. + +The width scan (`widths66.py`) established that the bank width is the word's modulus and that +the pinned complex ledger admits exactly one -- 66, the smallest integer above its density +`rank mass / W = 65.8905...`. It also showed that at a *narrower* modulus far more of the +ledger tiles (`w = 54`: nine families, 1,549,098 registers, 65% of the rank mass). So the +constraint is the word's density, and two things follow that this module settles: + +1. **Which suppliers already exist** (`corpus_scan`). Every ledger-bearing certificate in the + repository is read and scored on the same four numbers: modulus, density `mass / (m * W)`, + the smallest modulus the row admits (`floor(mass / W) + 1`), and the mass share that tiles + whole banks there. If a less dense word is already pinned somewhere, this finds it; if not, + the ranking says how far the pinned ones are from admitting a narrower modulus. +2. **What a word of a given width would have to look like** (`density_curve`). Holding the + pinned *shape* (the same bins and counts) and choosing a modulus `m`, the cheapest stock that + makes the row poseable is `W_min = floor(mass / m) + 1`, and its density follows. The curve + reports, per modulus: the required stock, the density, the families that tile whole banks + there, the mass that leaves, the retained row, and -- where the vendored certifier can price + it -- the κ. That is the design target in reverse: instead of asking what the pinned word + reaches, it asks what a word would have to be to reach more. + +Caveats, stated once and not blurred. The corpus figures are read from other packages' +certificates, whose conventions may differ; the module reports what each file says, with its +path, and does not re-derive those packages. The density curve is a **synthetic** construction: +same bin shape as the pinned word, different width and stock. Its κ is the pinned engine +pricing a row that no supplier in the pins owns, so it is a specification, not a result about +any existing word -- and where the certifier's own bracket cannot reach the row, that is +recorded instead of quoted. +""" +import json +import sys +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +REPO = HERE.parents[1] +if str(HERE) not in sys.path: + sys.path.insert(0, str(HERE)) + +import ledger3 # noqa: E402 + +WIDTH = 66 +COPIES = 3 +GRID = 10 ** 18 +ETA = BETA = Q(1, 10 ** 24) +WEAK = Q(1, 10 ** 30) +PINNED_KAPPA = Q(711599961413937, 10 ** 18) +CURVE_WIDTHS = (48, 54, 60, 66, 72, 84, 96) + + +def profile_of(node): + """A ledger profile out of a certificate node, or None if it is not one.""" + if not isinstance(node, dict): + return None + hist = node.get('child_histogram') or node.get('child_multiplicities') + if not isinstance(hist, dict) or not hist: + return None + try: + hist = {int(r): int(n) for r, n in hist.items() if int(n)} + except (TypeError, ValueError): + return None + m = node.get('m', node.get('width', node.get('M'))) + W = node.get('W', node.get('W_per_vertex')) + D = node.get('deficit', node.get('deficit_per_vertex', node.get('N'))) + if m is None or W is None or D is None or not hist: + return None + try: + return dict(m=int(m), W=int(W), N=int(D), child_multiplicities=hist, + total_rank=sum(r * n for r, n in hist.items())) + except (TypeError, ValueError): + return None + + +def walk_profiles(root): + """Every ledger profile in a tree, labelled by file and JSON path.""" + found = [] + for path in sorted(Path(root).rglob('*.json')): + if '/.git/' in str(path): + continue + try: + data = json.loads(path.read_text(encoding='utf-8', errors='replace')) + except (json.JSONDecodeError, OSError, UnicodeDecodeError): + continue + + def visit(node, where): + profile = profile_of(node) + if profile: + found.append((str(path.relative_to(root)).replace('\\', '/'), where, profile)) + if isinstance(node, dict): + for key, child in node.items(): + visit(child, where + '/' + str(key)) + elif isinstance(node, list): + for index, child in enumerate(node[:4]): + visit(child, where + '/%d' % index) + visit(data, '') + return found + + +def score(profile): + """The four numbers a supplier's ledger is scored on.""" + m, W, mass = profile['m'], profile['W'], profile['total_rank'] + if W <= 0 or m <= 0 or mass <= 0 or mass >= m * W: + return None # not a poseable dense row: skip, do not misreport + if max(profile['child_multiplicities']) > m: + return None # a rank outside the width: another convention + if m * W - mass != profile['N']: + return None # the row identity must hold, or it is not this ledger + density = Q(mass, m * W) + smallest = mass // W + 1 # the smallest modulus with mass < w * W + eligible, mass_out = {}, 0 + for rank, n in sorted(profile['child_multiplicities'].items(), reverse=True): + if (rank * n) % smallest: + continue + capacity = smallest // rank + if capacity == 0: + continue + banks = -(-n // capacity) + eligible[rank] = dict(capacity_per_bank=capacity, banks=banks, + padding_registers=banks * smallest - rank * n) + mass_out += banks * smallest + if mass_out > mass: + return None # bank volumes cannot exceed the ledger they come from + return dict(m=m, W=W, deficit=profile['N'], rank_mass=mass, families=len( + profile['child_multiplicities']), density=density, density_decimal=float(density), + smallest_admissible_modulus=smallest, modulus_headroom=smallest - m, + eligible_at_that_modulus=sorted(eligible), + tiling_mass=mass_out, tiling_share=Q(mass_out, mass), + tiling_share_decimal=float(Q(mass_out, mass))) + + +def corpus_scan(root=REPO, limit=14, pinned_density=None): + """Rank every poseable ledger in the tree, densest last. + + `pinned_density` is the density of the word this package prices against; when given, the + scan reports every ledger *below* it, which is the only form of the question that decides + whether a less dense supplier already exists to be reused. + """ + rows, seen = [], set() + for source, where, profile in walk_profiles(root): + scored = score(profile) + if not scored: + continue + key = (scored['m'], scored['W'], scored['deficit'], scored['rank_mass']) + if key in seen: + continue + seen.add(key) + rows.append({**scored, 'source': source, 'path': where}) + rows.sort(key=lambda row: (row['modulus_headroom'], -row['tiling_share_decimal'])) + by_density = sorted(rows, key=lambda row: row['density']) + below = [row for row in by_density + if pinned_density is not None and row['density'] < pinned_density] + return dict(root=str(root), profiles_scanned=len(rows), ranked=rows[:limit], + pinned_density=str(pinned_density) if pinned_density is not None else None, + least_dense_overall=(by_density[0] if by_density else None), + below_pinned_count=len(below), below_pinned_sample=below[:limit]) + + +def density_curve(profile, widths=CURVE_WIDTHS, interval=None, leaf=None): + """Per modulus: the same shape and the same occupancy, at that width. + + The pinned row's occupancy is held fixed (`density = mass / (m * W)`) and the stock follows + from it, `W = ceil(mass / (density * m))`. Varying the stock instead would move the + deficit -- the row's slack -- and the slack is what sets the saving, so a curve that moved + both would confound the two. + """ + mass = profile['total_rank'] + m0, W0 = profile['m'], profile['W'] + density = Q(mass, m0 * W0) + interval = interval or ledger3.engine() + curve = [] + for m in widths: + stock_min = -(-mass * density.denominator // (density.numerator * m)) + deficit = m * stock_min - mass + if deficit <= 0: + continue + row = dict(m=m, W=stock_min, N=deficit, + child_multiplicities=dict(profile['child_multiplicities']), + total_rank=mass, maxchild=max(profile['child_multiplicities'])) + eligible, removed, banks = {}, 0, 0 + for rank, n in sorted(profile['child_multiplicities'].items(), reverse=True): + if (rank * n) % m: + continue + capacity = m // rank + if capacity == 0: + continue + b = -(-n // capacity) + eligible[rank] = dict(capacity_per_bank=capacity, banks=b, + padding_registers=b * m - rank * n) + removed += b * m + banks += b + entry = dict(modulus=m, stock_min=stock_min, density=Q(mass, m * stock_min), + density_decimal=float(Q(mass, m * stock_min)), + pinned_density=str(density), deficit=deficit, + eligible_families=sorted(eligible), banks=banks, + mass_removed=removed, tiling_share=Q(removed, mass), + tiling_share_decimal=float(Q(removed, mass))) + if not eligible or stock_min - banks <= 0: + curve.append({**entry, 'saving': None, 'kappa': None, 'priced': False, + 'status': 'nothing tiles, or the stock cannot retire the banks'}) + continue + kept = dict(profile['child_multiplicities']) + padding = 0 + for rank in eligible: + kept[rank] -= profile['child_multiplicities'][rank] + del kept[rank] + padding += eligible[rank]['padding_registers'] + if padding: + if kept.get(1, 0) < padding: + curve.append({**entry, 'saving': None, 'kappa': None, 'priced': False, + 'status': 'the padding draw exceeds the kept rank-1 bin'}) + continue + kept[1] -= padding + if kept[1] == 0: + del kept[1] + mass_after = sum(r * n for r, n in kept.items()) + retained = dict(m=m, W=stock_min - banks, N=deficit, child_multiplicities=kept, + total_rank=mass_after, maxchild=max(kept)) + assert ledger3.check_row(retained) == mass_after, 'the synthetic row must be consistent' + try: + saving = ledger3.certify(interval, retained)['saving'] + except (AssertionError, ValueError) as exc: + curve.append({**entry, 'saving': None, 'kappa': None, 'priced': False, + 'status': 'not priceable: %s (the vendored certifier brackets the ' + 'moment at 1%%)' % (str(exc) or exc.__class__.__name__)}) + continue + kappa = None + if leaf is not None: + budget = min(leaf, (1 - BETA) * saving - WEAK) + q = budget * (1 - 2 * ETA) + z = ((1 - ETA) * q / (1 + q)) * GRID + kappa = Q((z.numerator - 1) // z.denominator, GRID) + curve.append({**entry, 'saving': saving, 'kappa': kappa, 'priced': True, + 'retained_stock': retained['W'], 'retained_mass': mass_after, + 'status': 'priced (synthetic row: same shape, this modulus and stock)'}) + return curve + + +def main(): + sys.set_int_max_str_digits(0) + sys.dont_write_bytecode = True + supplier = json.loads((HERE / 'references' / 'pr219-run1' / 'references' + / 'pr193-source-assisted-v4.certificate.json').read_text()) + base = ledger3.profile(supplier['complex_profile']) + pinned_density = Q(base['total_rank'], base['m'] * base['W']) + scan = corpus_scan(pinned_density=pinned_density) + print('corpus scan: %d distinct poseable ledgers under %s' % (scan['profiles_scanned'], + scan['root'])) + print('%6s %7s %9s %9s %6s %9s %s' + % ('modulus', 'W', 'rankmass', 'density', 'w_min', 'tiling', 'source')) + for row in scan['ranked']: + print('%6d %7d %9d %9.5f %6d %8.2f%% %s' + % (row['m'], row['W'], row['rank_mass'], row['density_decimal'], + row['smallest_admissible_modulus'], row['tiling_share_decimal'] * 100, + row['source'] + row['path'][:40])) + least = scan['least_dense_overall'] + print('\nleast dense ledger overall: %d wide, density %.5f -> w_min %d, tiles %.2f%% %s' + % (least['m'], least['density_decimal'], least['smallest_admissible_modulus'], + least['tiling_share_decimal'] * 100, least['source'])) + print('ledgers below the pinned density (%s): %d' + % (scan['pinned_density'], scan['below_pinned_count'])) + for row in scan['below_pinned_sample'][:5]: + print(' %6d %7d %9d %9.5f -> w_min %d %s' + % (row['m'], row['W'], row['rank_mass'], row['density_decimal'], + row['smallest_admissible_modulus'], row['source'])) + + schedule, arithmetic = ledger3.run1() + leaf = Q(arithmetic.build(schedule.build())['ordinary_leaf']) + print('\ndensity curve (pinned shape, cheapest stock per modulus, kappa where priceable):') + print('%8s %9s %9s %8s %10s %20s %19s' % + ('modulus', 'stock_min', 'density', 'banks', 'removed', 'coarse saving', 'kappa')) + for entry in density_curve(base, interval=ledger3.engine(), leaf=leaf): + if not entry['priced']: + print('%8d %9d %9.5f %8d %10d %20s %19s %s' + % (entry['modulus'], entry['stock_min'], entry['density_decimal'], + entry['banks'], entry['mass_removed'], '', '', entry['status'])) + continue + print('%8d %9d %9.5f %8d %10d %20s %19s %+.4f%% vs the pinned top' + % (entry['modulus'], entry['stock_min'], entry['density_decimal'], + entry['banks'], entry['mass_removed'], entry['saving'], entry['kappa'], + float(entry['kappa'] / PINNED_KAPPA - 1) * 100)) + + +if __name__ == '__main__': + main() diff --git a/research/complex-bank-run3/verify.py b/research/complex-bank-run3/verify.py index d0f78a94ca..4b284f3099 100644 --- a/research/complex-bank-run3/verify.py +++ b/research/complex-bank-run3/verify.py @@ -134,6 +134,79 @@ def check_scan_and_construction(record): return scan, construction +def check_suppliers_and_requirements(record): + """The two density measurements and the inverted targets, rebuilt from the record. + + Everything here is re-derived from the certificate's own numbers with the package's own + assembly rule: the ceiling the pinned bit leaf allows, each target's minimal budget, the + one-grid-step miss below it, the required complex coarse saving clearing that budget after + the beta and weak haircuts, and the two calibrations of the density curve. + """ + GRID = run3.GRID + top = Q(record['kappa']) + leaf = Q(record['calibrations']['run1']['bit_leaf']) + ceiling = Q(record['weighted_ceiling']['kappa_suppliers_admit_today']) + assert ceiling == run3.kappa_of_budget(leaf), \ + 'the complex-side ceiling must be the budget the pinned bit leaf allows' + assert ceiling > top, 'and it must sit above this certificate\'s top' + assert Q(record['weighted_ceiling']['gain_vs_top']) == ceiling / top - 1 + + lines = record['bit_requirement'] + assert [line['target'] for line in lines] == ['9/12500', '3/4000', '1/1250', '1/1000'], \ + 'the targets are 7.2e-4, 7.5e-4, 8e-4 and 1e-3' + for line in lines: + target, budget = Q(line['target']), Q(line['required_budget']) + assert line['required_bit_leaf'] == line['required_budget'], \ + 'the required budget is read off the bit leaf' + assert run3.kappa_of_budget(budget) >= target > run3.kappa_of_budget(budget - Q(1, GRID)), \ + 'the required budget must be the minimal grid point reaching the target' + coarse = Q(line['required_complex_coarse_saving']) + assert (1 - run3.BETA) * coarse - run3.WEAK > budget, \ + 'the complex cap must clear the budget, not merely meet it' + selected, _bound, kappa = run3.frontier_kappa(budget, coarse) + assert selected == budget and kappa >= target, \ + 'the pair (budget, coarse) must reach the target' + assert Q(line['bit_leaf_now']) == leaf and Q(line['complex_coarse_now']) \ + == Q(record['top']['coarse']), 'the two branches must be the certified ones' + assert line['bit_branch_short'] == (budget > leaf), 'bit-branch reading' + assert line['complex_branch_short'] == (coarse > Q(record['top']['coarse'])), \ + 'complex-branch reading' + assert Q(line['bit_leaf_gain']) == budget / leaf - 1 + assert not lines[0]['bit_branch_short'] and lines[0]['complex_branch_short'], \ + '7.2e-4 needs more complex supply only' + assert all(line['bit_branch_short'] and line['complex_branch_short'] for line in lines[1:]), \ + 'the three higher targets are short on both branches, the bit word included' + for need, line in zip(record['needed_for'], lines): + if need['needs_new_bit']: + assert need['required_bit_leaf'] == line['required_bit_leaf'], \ + 'the two inversions of the same target must agree' + assert Q(line['kappa_at_the_bit_ceiling_now']) < Q(line['target']), \ + 'the pinned bit leaf must not already reach a target that needs a new word' + + measured = record['supplier_density'] + scan = measured['corpus'] + assert scan['profiles_scanned'] >= 10, 'the corpus scan must find the pinned ledgers' + assert scan['below_pinned_count'] == 0, \ + 'no poseable ledger may be less dense than the word priced here' + assert Q(scan['least_dense_overall']['density']) == Q(measured['pinned_density']), \ + 'the least dense poseable ledger in the repository must be this word itself' + curve = {entry['modulus']: entry for entry in measured['curve']} + assert curve[66]['priced'] and Q(curve[66]['kappa']) == top, \ + 'the curve must reproduce the top at the pinned width' + assert Q(curve[66]['stock_min']) == 12052, \ + 'and require exactly the stock the pinned ledger carries' + for width in (48, 54, 60): + entry = curve[width] + if entry['priced']: + assert Q(entry['kappa']) == ceiling, \ + 'that narrow a word stops binding on the complex side' + assert Q(entry['saving']) > Q(record['calibrations']['run1']['complex_coarse']) + assert not curve[72]['priced'], 'the pinned width must not tile after the ladder' + assert all(Q(entry['kappa']) < top for entry in measured['curve'] + if entry['priced'] and entry['modulus'] > 66), 'a wider word must be worse' + return ceiling, scan, curve + + def check_obligations(): obligations = json.loads((HERE / 'obligations.json').read_text()) owed = [item['id'] for item in obligations['obligations']] @@ -179,6 +252,7 @@ def main(): record = run3.build() check_prototype(record) check_scan_and_construction(record) + ceiling, scan, curve = check_suppliers_and_requirements(record) check_obligations() target = HERE / 'certificate.json' if args.write: @@ -214,6 +288,23 @@ def main(): record['construction']['totals']['padding_registers'])) print('rungs %s at %s banks, kappa %s' % (record['top']['families_absorbed'], record['top']['banks'], record['kappa'])) + print('suppliers %d poseable ledgers scored, %d below the pinned density %s; least ' + 'dense overall: %d wide at %.5f' + % (scan['profiles_scanned'], scan['below_pinned_count'], + Q(record['supplier_density']['pinned_density']), + scan['least_dense_overall']['m'], scan['least_dense_overall']['density_decimal'])) + print('density curve %s' + % ', '.join('w%d %s' % (entry['modulus'], + (Q(entry['kappa']) if entry['priced'] else entry['status'])) + for entry in record['supplier_density']['curve'])) + print('ceiling a width 48-60 word with this shape pays %s; every target above 7.2e-4 ' + 'still needs the bit word' + % ceiling) + for line in record['bit_requirement']: + print('target %-8s bit leaf %-20s (%+.3f%%), complex coarse %-20s (%+.3f%% over the top)' + % (line['target'], line['required_bit_leaf'], float(Q(line['bit_leaf_gain'])) * 100, + line['required_complex_coarse_saving'], + float(Q(line['complex_coarse_gain_vs_ladder_top'])) * 100)) if __name__ == '__main__': From e3aece65ac772233d6da00abbf3838a6ad32330a Mon Sep 17 00:00:00 2001 From: maxime-fleury Date: Sat, 10 Oct 2026 00:05:18 +0200 Subject: [PATCH 07/11] Record why the obligations are one artifact and why 'unconditional' is closed by the pins MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Asked whether C1-C7 and R1-R4 can be discharged and whether the kappa can then be made unconditional. The first is yes and the second is no, and both are readings of pinned bytes rather than positions, so the answer is now recorded with its evidence and checked back by verify.py. The eleven items are one missing artifact seen from eleven rungs: the literal operation program, then the columns, charts, witnesses and envelope re-run on the word it banks. The supplier this whole ladder is priced on certifies its flow and all-column fresh identity and states in the same breath that a literal globally renumbered operation program is not exported, with its receipts calling the literal program a downstream integration task. So C1's normalizer has to move projectors that exist only there, C2 re-runs a word that program defines, C3 charts the frames it creates, and C5-C7 need each child's frame/chain identity where the pins export a count per bin and not an identity. C4 is the one item closable from the pins alone once C1's completion children are named; R1 is the exception on the other side, with a pinned precedent to extend. Unconditional is closed three times over: the supplier is published as a PASS conditional finite witness, the vendored #219 package states that discharging R1-R4 buys a completed finite witness and that the result is not an unconditional multiplication theorem in any case, and this package's own scope says the same of the finite bridge and all-size interfaces it inherits. Discharging the eleven raises the kappa from a scheduled target to the house-standard conditional finite witness, which is the whole of what the work buys. 🤖 Generated with Codebuff Co-Authored-By: Codebuff --- research/complex-bank-run3/PROOF.md | 8 +++ research/complex-bank-run3/README.md | 34 +++++++++++++ research/complex-bank-run3/SOURCE.json | 2 +- research/complex-bank-run3/certificate.json | 2 +- research/complex-bank-run3/obligations.json | 45 +++++++++++++++++ research/complex-bank-run3/verify.py | 54 +++++++++++++++++++++ 6 files changed, 143 insertions(+), 2 deletions(-) diff --git a/research/complex-bank-run3/PROOF.md b/research/complex-bank-run3/PROOF.md index dc8d8ef3d8..00751e0668 100644 --- a/research/complex-bank-run3/PROOF.md +++ b/research/complex-bank-run3/PROOF.md @@ -254,6 +254,14 @@ the curve's width-66 row is exactly the pinned stock reproducing the top kappa), step below its budget. The curve itself is a *specification*: the engine prices a row no supplier in the pins owns, and the scan reports other packages' certificates at their own conventions rather than re-deriving them. +* Also machine-checked: the *unconditionality* record. The four pinned readings it quotes -- + the supplier's `PASS conditional finite witness` status, its `not exported` operation-program + line, its `downstream integration task` receipt, and the vendored package's `not an + unconditional multiplication theorem in any case` -- are matched back against the pinned files + by `verify.py` (`check_unconditionality`), together with the per-item table for all eleven + obligations. The verdict is therefore evidence rather than commentary: discharging C1-C7 and + R1-R4 buys a conditional finite witness -- the house-standard status -- and the label + 'unconditional' is closed by the pins. * Not run: upstream CI, and any contributor verifier other than the vendored #219 package invoked in place. * The `10^-10` supplier field is priced as a conservative variant; on it the ladder's top sits diff --git a/research/complex-bank-run3/README.md b/research/complex-bank-run3/README.md index 3e891079e3..07964a05d5 100644 --- a/research/complex-bank-run3/README.md +++ b/research/complex-bank-run3/README.md @@ -273,6 +273,40 @@ at least the budget column, and a complex supplier that can clear the same budge margin -- the bit word because the leaf caps the budget, the complex supplier because the bank mechanism has nothing left to take at width 66. +## Can the obligations be discharged, and can this be made unconditional? + +The first answer is yes and the second is no, and both are readings of the pinned bytes rather +than positions -- `verify.py -> check_unconditionality` matches the four quotes back against the +files, so the record cannot drift from what the pins say. + +**C1-C7 and R1-R4 are one missing artifact, not eleven gaps.** Every one of them needs the same +thing: the literal operation program, then the columns, charts, witnesses and envelope re-run on +the word it is banked by. The supplier this whole ladder is priced on certifies its flow and its +all-column fresh identity, and states in the same breath that *"a literal globally renumbered +operation program is not exported"*; its construction receipts call the literal +program/replay *"a downstream integration task"*. So the work is reserved upstream, not +invented here, and it is the work of a construction rather than of arithmetic: C1's normalizer +has to move projectors that exist only in that program, C2 has to re-run the columns of a word +that program defines, C3 has to chart frames those columns create, and C5-C7 need each child's +frame/chain identity, which the pins export as a *count* per bin (`1,062`, `264`, `66` per +vertex) and not as an identity. The one item that could be closed from the pins alone -- once +C1's completion children are named -- is the moment-envelope parity (C4), because the envelope +this package prices is already the certified arithmetic. R1 is the exception on the other side: +the bit word's banked precedent *is* pinned (the entrance-gauge pack, 45,842 physical banks with +gauge roles), so that obligation has a shape to extend instead of a mechanism to invent. + +**Unconditional is not a reachable label.** Three independent pinned facts close it: the +supplier's own certificate is published as `PASS conditional finite witness`; the vendored #219 +package states that discharging R1-R4 buys a completed finite witness and that the result is +`not an unconditional multiplication theorem in any case`; and this package's own scope says the +same for the finite bridge and the all-size interfaces it inherits (general Clifford/tensor, +uniform weighted compilation, restored rows, routing, paid layout, prime supply, +precision/recovery, fixed tape). Discharging the eleven obligations would raise this ladder's +kappa from a *scheduled target* to the **house-standard conditional finite witness** -- the same +status the queue's published rungs carry, and the strongest status anything in the repository +claims. That is the whole of what the work buys, and the package now says so with the quotes +attached rather than in general terms. + ## Verify ```sh diff --git a/research/complex-bank-run3/SOURCE.json b/research/complex-bank-run3/SOURCE.json index 29bc7a8b77..865cfa50b5 100644 --- a/research/complex-bank-run3/SOURCE.json +++ b/research/complex-bank-run3/SOURCE.json @@ -2,7 +2,7 @@ "files": { "instantiate66.py": "add272a8507bf81810fe36a8e9193afcca5fa708d9149a6700868f01c99075a2", "ledger3.py": "202591f64e76002dd0bc05e7d0c36214db85faf9261bb1757bfb0ca568cc53cd", - "obligations.json": "cf887f237fc02204c25c7fd5234d4ded392a8a5397b4ab6bffc9d26a32b7d20e", + "obligations.json": "079618259a5596468ce7e617802f2b10157293e64612ca5d60ee7291e76d209b", "occurrences66.json": "d755258f115236356ee1b34a84ee98414eee42dd9eeb4f7034abf39b0dac5653", "pins.py": "49a86398b264f5aad88542af9119625b671e0c57788c9f911b29e9617f61285a", "prototype66.py": "74adbe605ceba533cba1e38b0eca466f67961f4a41e9c839094faa9d503dc2cc", diff --git a/research/complex-bank-run3/certificate.json b/research/complex-bank-run3/certificate.json index 1692897927..3576361968 100644 --- a/research/complex-bank-run3/certificate.json +++ b/research/complex-bank-run3/certificate.json @@ -914,7 +914,7 @@ "source_pins": { "instantiate66.py": "add272a8507bf81810fe36a8e9193afcca5fa708d9149a6700868f01c99075a2", "ledger3.py": "202591f64e76002dd0bc05e7d0c36214db85faf9261bb1757bfb0ca568cc53cd", - "obligations.json": "cf887f237fc02204c25c7fd5234d4ded392a8a5397b4ab6bffc9d26a32b7d20e", + "obligations.json": "079618259a5596468ce7e617802f2b10157293e64612ca5d60ee7291e76d209b", "occurrences66.json": "d755258f115236356ee1b34a84ee98414eee42dd9eeb4f7034abf39b0dac5653", "pins.py": "49a86398b264f5aad88542af9119625b671e0c57788c9f911b29e9617f61285a", "prototype66.py": "74adbe605ceba533cba1e38b0eca466f67961f4a41e9c839094faa9d503dc2cc", diff --git a/research/complex-bank-run3/obligations.json b/research/complex-bank-run3/obligations.json index 938ef3ee34..7c19c1ec8c 100644 --- a/research/complex-bank-run3/obligations.json +++ b/research/complex-bank-run3/obligations.json @@ -26,6 +26,51 @@ "status": "OPEN" } ], + "unconditionality": { + "question": "Can C1-C7 and the inherited R1-R4 be discharged, and can this kappa then be made unconditional?", + "answer": "C1-C7 and R1-R4 are one and the same missing artifact seen from eleven rungs, not eleven unrelated gaps: the literal operation program the bank re-assignment must move, and the columns, charts, witnesses and envelope that must then be re-run on the modified word. Discharging them would lift this package from a scheduled target to a conditional finite witness -- the strongest status anything in this repository claims, and the status the very supplier this ladder banks is published under. It would not make the bound unconditional, and that is a reading of the pinned bytes rather than a preference.", + "evidence": [ + { + "source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", + "path": "status", + "value": "PASS conditional finite witness", + "reading": "the complex word this whole ladder is priced on is itself published as a conditional finite witness, so no rung above it can be less conditional than the word it banks" + }, + { + "source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", + "path": "complex_profile.status", + "value": "Exact local invertible flow, exact all-column fresh identity, paid source controls, target read chains, and integer histogram certified. A literal globally renumbered operation program is not exported; dense initial dirty-response subtraction is defined by the exact certified flow.", + "reading": "the supplier certifies the flow and the fresh identity, and states that the literal globally renumbered operation program is NOT exported -- exactly the object C1's normalizer must move and C2 must re-run columns on" + }, + { + "source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", + "path": "assembly.construction_receipts.status", + "value": "Constructive exact flow and fixed-boundary proofs; literal globally renumbered program/replay remains a downstream integration task", + "reading": "the supplier's own receipts call the literal program a downstream integration task, i.e. the missing piece is reserved upstream, not created by this package" + }, + { + "source": "references/pr219-run1/obligations.json", + "path": "claim_scope", + "value": "... conditional on R1-R4 exactly as every published witness in this repository is conditional on its stated finite bridge and all-size interfaces; it is not a completed finite witness until R1-R4 verify, and it is not an unconditional multiplication theorem in any case.", + "reading": "the vendored package that supplies rung 1 states the house convention in its own words: discharging the obligations buys a completed finite witness, never an unconditional theorem" + } + ], + "what_each_item_needs": { + "C1": "the normalizer: the supplier's true residual projectors, i.e. the exported program the pinned certificate says is not exported (evidence 2). The pins add nothing here -- the complex supplier's certificate holds no key containing 'bank' at all (machine-read by bank_evidence()) -- so the mechanism is new rather than an extension of the bit word's", + "C2": "the modified complex word's formal columns over F2 and over the defining integers: needs the program to modify before it can be re-run", + "C3": "exact charts, the incidence colouring and distinct Gram/prime witnesses for every new block frame: needs the frames C2 defines", + "C4": "moment-envelope parity: arithmetic, and the only one of the eleven that could be closed from the pins alone once C1's completion children are named, since this package already prices the envelope it claims (retained three-copy stock 35,625, deficit 3,960, no complex-side rare-class fallback)", + "C5": "each rank-11 child's frame/chain identity: the bin's count is pinned (1,062 per vertex) and its banks are instanced, the children's identity is not -- #219's counterpart inventory for its rank-22 bin is what made that rung a closed checklist", + "C6": "the same for rank 16: 264 per vertex, 792 three-copy items onto 198 banks x 4 blocks", + "C7": "the same for rank 20: 66 per vertex, 198 three-copy items onto 66 banks x 3 blocks", + "R1": "the bit word's residual-type definition and blocks: this one has a pinned precedent to extend rather than to invent (the entrance-gauge pack, 45,842 physical banks with gauge roles)", + "R2": "the modified bit word's formal columns: needs that word's program, as C2 does for the complex word", + "R3": "charts, routing and prime witnesses for the bit word's new blocks, as C3", + "R4": "moment-envelope parity on the bit side (retained three-copy stock 50,286, deficit 5,808, fallback 32*72^2 per retained child), as C4" + }, + "consequence": "Discharging all eleven would make this ladder's kappa the house-standard conditional finite witness -- comparable with the queue's published rungs, which are labelled conditional by the same convention -- and it is the only route to that status. It cannot make kappa a theorem: the supplier's program is one blocker, and the finite bridge and the all-size interfaces (general Clifford/tensor, uniform weighted compilation, restored rows, routing, paid layout, prime supply, precision/recovery, fixed tape) are assumptions this package inherits and does not touch. 'Unconditional' is therefore not a reachable label for this result at any level of obligation work, and the record above is asserted against the pinned bytes by verify.py rather than merely written down.", + "status": "RECORDED AND MACHINE-CHECKED (verify.py -> check_unconditionality reads the four pinned strings back)" + }, "obligations": [ { "generalized_to_rungs_3_4": { diff --git a/research/complex-bank-run3/verify.py b/research/complex-bank-run3/verify.py index 4b284f3099..e68841e96d 100644 --- a/research/complex-bank-run3/verify.py +++ b/research/complex-bank-run3/verify.py @@ -238,6 +238,55 @@ def check_obligations(): return owed + inherited +def check_unconditionality(): + """The pinned bytes' own verdict on unconditionality, read back rather than asserted. + + The record in `obligations.json` quotes four strings from the pinned files. This reads the + files and matches the quotes, so the package's claim about what is and is not reachable is + a checked fact about the pins: the supplier is published as a conditional finite witness, + the operation program the normalizer needs is declared not exported, the literal program is + a downstream integration task, and the vendored package states the house convention that + discharging its obligations is not an unconditional multiplication theorem. + """ + vendored = HERE / 'references' / 'pr219-run1' + supplier = json.loads((vendored / 'references' + / 'pr193-source-assisted-v4.certificate.json').read_text()) + readings = { + 'references/pr219-run1/references/pr193-source-assisted-v4.certificate.json#status': + supplier['status'], + 'references/pr219-run1/references/pr193-source-assisted-v4.certificate.json' + '#complex_profile.status': supplier['complex_profile']['status'], + 'references/pr219-run1/references/pr193-source-assisted-v4.certificate.json' + '#assembly.construction_receipts.status': + supplier['assembly']['construction_receipts']['status'], + 'references/pr219-run1/obligations.json#claim_scope': + json.loads((vendored / 'obligations.json').read_text())['claim_scope'], + } + assert readings[list(readings)[0]] == 'PASS conditional finite witness', \ + 'the complex supplier must be published as a conditional finite witness' + assert 'not exported' in readings[list(readings)[1]], \ + 'the operation program must still be declared not exported' + assert 'downstream integration task' in readings[list(readings)[2]], \ + 'the literal program must still be a downstream task' + assert 'not an unconditional multiplication theorem' in readings[list(readings)[3]], \ + 'the house convention must still be stated by the vendored package' + block = json.loads((HERE / 'obligations.json').read_text())['unconditionality'] + recorded = {row['source'] + '#' + row['path']: row['value'] + for row in block['evidence']} + assert len(block['evidence']) == 4 and len(recorded) == 4, 'one row per reading' + for key, value in readings.items(): + assert key in recorded, 'the record must name every pinned reading: %s' % key + quoted = recorded[key] + if quoted.startswith('...'): # a quoted tail of a long string + assert value.endswith(quoted[3:]), 'the recorded tail must be the pinned tail' + else: + assert value == quoted, 'the recorded value must be the pinned value: %s' % key + needs = block['what_each_item_needs'] + assert sorted(needs) == ['C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', + 'R1', 'R2', 'R3', 'R4'], 'all eleven items must be named' + return block + + def main(): parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) @@ -254,6 +303,7 @@ def main(): check_scan_and_construction(record) ceiling, scan, curve = check_suppliers_and_requirements(record) check_obligations() + unconditionality = check_unconditionality() target = HERE / 'certificate.json' if args.write: (HERE / 'SOURCE.json').write_text( @@ -286,6 +336,10 @@ def main(): % (record['construction']['totals']['items'], record['construction']['totals']['banks'], record['construction']['totals']['padding_registers'])) + print('unconditional not available: supplier status %s; operation program not exported; %s' + % (json.loads((HERE / 'references' / 'pr219-run1' / 'references' + / 'pr193-source-assisted-v4.certificate.json').read_text())['status'], + unconditionality['status'])) print('rungs %s at %s banks, kappa %s' % (record['top']['families_absorbed'], record['top']['banks'], record['kappa'])) print('suppliers %d poseable ledgers scored, %d below the pinned density %s; least ' From 0c3abda1ffda5314425d6cb66ce41346d1c62763 Mon Sep 17 00:00:00 2001 From: maxime-fleury Date: Sat, 10 Oct 2026 00:09:25 +0200 Subject: [PATCH 08/11] Publish the normalizer's export contract, with every citation checked against the pins MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit C1-C7 and R1-R4 reduce to one missing artifact: the literal operation program, then the columns, charts, witnesses and envelope re-run on the word it banks. This turns that into an interface the importer can accept or refuse, instead of a hoped-for construction. The contract names six required exports -- the operation program, the frame bodies behind the three published cache digests, the exact lift and witness pair, the chronology tables, the per-child occurrence inventory, and the envelope plus integrity manifest -- each with the digest it must reproduce, so it asks for bodies behind hashes the supplier already publishes rather than for new trust. Seven acceptance tests carry the bounds and a reject control each, and every export maps to the obligations it unblocks (all eleven are covered). Two readings shape it. The exports address the lift/witness pair and not the flow block, because the supplier's own flow.status says "Not an exact supplier certificate". And the per-child export is asked in the exact shape of the bit word's absorbed-occurrences.json, since our side of that bijection already exists in occurrences66.json: 4,176 items over 795 banks. verify.py -> check_export_contract resolves every citation against the pinned bytes -- the digests, the column and read counts, the status strings and the precedent values of the banked word and the occurrence inventory -- and asserts the state the contract declares: 0 of 6 bodies exported today, so the import fails closed and the kappa keeps its conditional flag. 🤖 Generated with Codebuff Co-Authored-By: Codebuff --- research/complex-bank-run3/EXPORT-CONTRACT.md | 100 +++++++++++ research/complex-bank-run3/PROOF.md | 11 +- research/complex-bank-run3/README.md | 21 ++- research/complex-bank-run3/SOURCE.json | 4 +- research/complex-bank-run3/certificate.json | 4 +- .../complex-bank-run3/export-contract.json | 166 ++++++++++++++++++ research/complex-bank-run3/pins.py | 3 +- research/complex-bank-run3/verify.py | 76 ++++++++ 8 files changed, 379 insertions(+), 6 deletions(-) create mode 100644 research/complex-bank-run3/EXPORT-CONTRACT.md create mode 100644 research/complex-bank-run3/export-contract.json diff --git a/research/complex-bank-run3/EXPORT-CONTRACT.md b/research/complex-bank-run3/EXPORT-CONTRACT.md new file mode 100644 index 0000000000..670bea0691 --- /dev/null +++ b/research/complex-bank-run3/EXPORT-CONTRACT.md @@ -0,0 +1,100 @@ +# The normalizer's export contract + +**What the complex supplier's program must publish for C1-C3 to become a bank increment.** +`obligations.json` -> `unconditionality` records that C1-C7 and R1-R4 are one missing artifact: +the literal operation program, then the columns, charts, witnesses and envelope re-run on the +word it banks. This file says exactly what that artifact has to contain, in what form, and how +each part is checked -- so that the work stops being "a construction" and becomes an interface +the importer can accept or refuse. The machine-readable twin is +[export-contract.json](research/complex-bank-run3/export-contract.json), and every digest and +count quoted below is asserted against the pinned bytes by `verify.py -> check_export_contract`. + +## 1. What the pins already publish (the starting point, read not assumed) + +| published today | value | where | +| --- | --- | --- | +| the supplier's own verdict | `PASS conditional finite witness` | PR193 certificate, `status` | +| the gap | "A literal globally renumbered operation program is not exported" | `complex_profile.status` | +| its receipts | "literal globally renumbered program/replay remains a downstream integration task" | `assembly.construction_receipts.status` | +| complex profile | `m = 66`, `W_per_vertex = 12,052`, `deficit_per_vertex = 1,320`, `h = 22`, `v = 1,320`, `rank_per_vertex = 794,112`, `physical_R = 9,412`, `loss = 440` | `complex_profile` | +| its arithmetic | coefficients `[[-2,1],[-1,1],[-1,2],[1,2],[1,1],[2,1]]`, `denominator_lcm = 2`, root `7.009184438594e-04` | `complex_profile` | +| its **digests** | `exact_scalar_program_sha256 = 3b4e671d…`, `exact_lift_certificate_sha256 = 1d81a79b…` (path `research/source-assisted-v4/.work/lift.certificate.json.gz`), `flow.witness` `51da02c6…`, `proof_chain_sha256 = {frames.json 434b815…, graph.json a4d350f…, record.json 2065cba…}` | `complex_profile`, `lift` | +| its column checks | `checked_source_columns = 1,320`, `checked_target_rows = 1,320`, `read_counts = {center: 22, deferred: 2,310, side: 3,135}`, `target_chains_nested`, `all_fresh_columns_equal_identity`, `all_centers_in_phase1`, `all_target_cap_reads_in_phase2` | `complex_profile.contract_checks` | +| its exact lift | `inverse_elementary_gates = 58,165`, `nodes = 18,532`, `physical_R = 9,412`, `witness_path = …/flow.witness.json`, `checker_path = …/exact_complex_flow_lift.py`, `checker_sha256 = 9d841bcf…` | `lift` | +| its flow | `frames = 18,532`, `vectors = 26,200`, `incoming_dependencies = 24`, `outgoing_dependencies = 8,116`, `edge_basis_values = 42,787`, birth/retirement histograms, `cache_sha256 = {frames.json, graph.json, record.json}`, `source_sha256 = {…/physical/frames.json, pairs.json, …}` | `flow` | +| its regeneration recipe | "Run `source_aligned_local_v4.py`, PR184 `complex_frame_flow.py` …, PR184 `exact_complex_flow_lift.py`, and this checker on the PR168 v4 producer cache" | `complex_profile.regeneration` | + +Two readings matter. First, the supplier publishes **digests, counts, statuses and paths** -- +never a body: `3b4e…`, `1d81…`, `51da…`, `434b…`, `a4d3…`, `2065…` are all hashes of artifacts +that live in its own workspace (`research/source-assisted-v4/.work/…`) or in a PR168 v4 producer +cache, and none of them is in the pins. Second, its own `flow` block says of itself: +*"Modular equal-frame flow price, retaining dirty kernel lifts and complete full-frame cleanup. +**Not an exact supplier certificate.**"* The exact object is the `lift`/witness pair, and the +contract below is addressed there; a modular flow price is explicitly **not** acceptable evidence. + +## 2. The required exports + +Each export names what must be published, the form it must take, the digest it must reproduce and +the obligation it unblocks. "Reproduce" means: the published body hashes to the digest the +certificate already carries, so the contract asks for *bodies behind existing hashes*, never for +new trust. + +| id | the program must publish | form and cardinality | digest it must reproduce | unblocks | +| --- | --- | --- | --- | --- | +| **E1 program** | the literally renumbered operation program, in canonical order: per node its canonical id, operation kind, incoming and outgoing edge ids, and its span | JSON, integers only, exactly `18,532` nodes and `58,165` inverse gates | `lift.exact_scalar_program_sha256 = 3b4e671d…` | C2 (the word to re-run), C1 | +| **E2 frames** | the bodies behind the three cache digests: `frames.json` (integer kernel basis per frame; `edge_basis_values = 42,787`; edge nullity histogram), `graph.json` (parents, children, `incoming_dependencies = 24`, `outgoing_dependencies = 8,116`), `record.json` (provenance) | JSON, canonical integer bases | `434b815…`, `a4d350f…`, `2065cba…` (`proof_chain_sha256` / `flow.cache_sha256`) | C1, C3 | +| **E3 lift and witness** | the exact rational local lifts and inverse gate programs per node, plus the flow witness they were checked against | JSON/gz bodies, denominators `<= 2`, coefficients in the six published pairs, `denominator_lcm = 2` | `lift.certificate_sha256 = 1d81a79b…`, `witness_sha256 = 51da02c6…` | C1 (the projectors the normalizer moves), C3 | +| **E4 chronology** | per vertex the read/write tables: target read chains (nested), source controls at paid-parity frames, and the deferred/side/centre reads with their counts | JSON tables, `read_counts = {center: 22, deferred: 2,310, side: 3,135}`, `checked_source_columns = 1,320`, `checked_target_rows = 1,320` | the `contract_checks` block itself | C2, C3 | +| **E5 children** | the per-bin occurrence inventory of the absorbed families in the shape of the bit word's `inputs/absorbed-occurrences.json`: `counts_per_vertex`, `occurrences_per_vertex` as integer tuples per kind, `row_identity_per_vertex`, `source_pins` | JSON, per vertex `1,062` rank-11, `264` rank-16, `66` rank-20 items with each child's **frame/chain identity** | the pinned inventory's five `source_pins` digests as the format precedent; the flow's own `retirement_histogram` already counts these children (`"1:20": 198`, `"2:20": 1320`, `"2:21": 2640`) | C5, C6, C7, and C1's item-to-block side | +| **E6 envelope and integrity** | the paid moment envelope in the form `arithmetic.py` consumes (retained stock, deficit, retained histogram, worst-case bad fraction, fallback), plus the package path, its head, every digest of E1-E5 and the list of acceptance predicates actually run | JSON envelope + manifest | `complex_profile` totals and histograms, which this package already prices | C4, R4 | + +The bit-side twin of this contract is already half-met in the pins: PR205's packed certificate +publishes a banked word's *shape* -- `m = 72`, `banks = 45,842`, `gauge_roles = 2,200`, +`incidences = 154,026`, `patterns = [{rank24: 2, rank4: 6} x 3,300, …]`, `color_stats`, and the +digests `word_sha256 = 0728ed1c…`, `chart_sha256 = 22662b85…`, `incidence_sha256 = 76bff256…`, +with `status = PASS exact actual-chain chart and incidence checks`. That is the export shape E1-E4 +must reach on the complex word, and R1's precedent to extend. + +## 3. Acceptance tests (what "verifiable form" means) + +| id | test | bound it is held to | reject control | +| --- | --- | --- | --- | +| **A1** | every body hashes to the digest the certificate already published | `3b4e…` (program), `1d81…` (lift), `51da…` (witness) | any altered byte must fail the hash; a matching one is not evidence of correctness, only of identity | +| **A2** | a complete frame-record bijection between the supplier's ids and the canonical ids, plus `frames` and `edge_basis_values` reproduced | `18,532` frames, `42,787` basis values | a renumbering that is not a bijection, or an id used twice, is rejected | +| **A3** | fraction-free chart inversion and replayed elementary factors on every frame, with the denominator bound | denominators `<= 2`; `max_abs_numerator <= 2` | a factor that does not replay, or a denominator above the published bound | +| **A4** | the formal columns re-run on the modified word: every source, target and dirty-register column over F2 **and** over the defining integers, with the target chronology nested and the source controls at paid parity frames | `1,320` source columns and `1,320` target rows per vertex; `read_counts 22/2,310/3,135` | the column counts must come out of the exported tables, not be quoted from the certificate | +| **A5** | the per-child bijection: the exported occurrences map onto this package's `occurrences66.json` items (3,186 / 792 / 198 three-copy items onto 531 x 6, 198 x 4, 66 x 3) with no other bin touched | item counts per bin, and the flow's own retirement counts | an occurrence outside the ledger's bins, or a block left without its item | +| **A6** | incidence colouring of the new incidences with the conflicting assignment rejected | PR205 precedent: `swaps = 733`, `longest_swapped_path = 11` | a conflicting assignment accepted | +| **A7** | distinct integer Gram/prime witnesses for every frame the new blocks use, residual factors below the retained `q` bound | the retained prime threshold (PR205: `physical_roles = 17,114`, all used frames witnessed) | a repeated witness, or a factor above the bound | + +A5 is the test that turns C5-C7 into an increment rather than an inventory: our side of it already +exists (`occurrences66.json` enumerates 4,176 items over 795 banks and passes `verify.py`), so the +export supplies the *identity* of each item and the bijection is checked in one direction and the +other. + +## 4. What the contract deliberately does not ask for + +* **No internal id stability.** Only the canonical renumbering map and the bijection test (A2). +* **No program text beyond canonical data.** E1 is nodes, kinds, edges and spans -- not a listing + in the supplier's own language. +* **No sources for the supplier's claims.** The importer re-runs the columns (A4) and re-charts + the frames (A3); a boolean in `contract_checks` is a claim to be reproduced, not a result. +* **No asymptotic interfaces.** General Clifford/tensor, uniform weighted compilation, restored + rows, routing, paid layout, prime supply, precision/recovery and fixed tape stay the stated + assumptions they already are: this contract can buy a conditional finite witness, never a + theorem (`obligations.json` -> `unconditionality`). +* **No modular flow price.** `flow.status` disclaims exactness; only the `lift`/witness pair + satisfies E3. + +## 5. Failure semantics, and the state today + +**Today: 0 of 6 bodies are exported.** Every required export is present in the pins only as a +digest, a count, a status or a path, and `check_export_contract` asserts exactly that reading +against the pinned certificate. The import therefore *fails closed*: the package stays a scheduled +target, the kappa keeps its conditional flag, and nothing in C1-C7 changes status. + +Once the exports exist, the discharge is mechanical and ordered: A1-A3 make E2-E3 admissible and +C1's normalizer becomes a re-assignment over published frames; A4 re-runs C2; A5 closes C5-C7 and +the item-to-block half of C1; A6-A7 close C3; E6 closes C4. That is the whole of what the contract +buys, and it is stated in the form the supplier can act on: *publish the bodies behind the hashes +you already publish, plus the renumbering map, the chronology tables and the per-child identities.* diff --git a/research/complex-bank-run3/PROOF.md b/research/complex-bank-run3/PROOF.md index 00751e0668..7d515ed50b 100644 --- a/research/complex-bank-run3/PROOF.md +++ b/research/complex-bank-run3/PROOF.md @@ -230,7 +230,7 @@ the density curve finds above is still below all of them. ## 6. Verification boundary -* Machine-checked here: the pinned bytes (28 files, sha256), the frontier reproduction, rung 1 +* Machine-checked here: the pinned bytes (30 files, sha256), the frontier reproduction, rung 1 rebuilt by the vendored #219 package, rung 2 rebuilt by this package's own ledger module, rungs 3 and 4 (volumes, row identities, stock drops, both paid moments, adjacency rejections), the branch ceilings, the eligibility exhaustion, the PR208 replica, the T1 @@ -262,6 +262,15 @@ the curve's width-66 row is exactly the pinned stock reproducing the top kappa), obligations. The verdict is therefore evidence rather than commentary: discharging C1-C7 and R1-R4 buys a conditional finite witness -- the house-standard status -- and the label 'unconditional' is closed by the pins. +* Also machine-checked: the normalizer export contract (`EXPORT-CONTRACT.md`, + `export-contract.json`). Six required exports, seven acceptance tests and the mapping of all + eleven obligations are checked, and every citation the contract makes -- the digests + `3b4e671d…`, `1d81a79b…`, `51da02c6…`, the three cache digests, the column and read counts, the + status strings, and the banked word's and inventory's precedent values -- is resolved back + against the pinned bytes, with the declared state (0 of 6 bodies exported) asserted rather + than described. The contract's one design reading is also pinned: it addresses the + `lift`/witness pair, not the flow block, whose own status says *"Not an exact supplier + certificate"*. * Not run: upstream CI, and any contributor verifier other than the vendored #219 package invoked in place. * The `10^-10` supplier field is priced as a conservative variant; on it the ladder's top sits diff --git a/research/complex-bank-run3/README.md b/research/complex-bank-run3/README.md index 07964a05d5..92bd39e53d 100644 --- a/research/complex-bank-run3/README.md +++ b/research/complex-bank-run3/README.md @@ -307,6 +307,21 @@ status the queue's published rungs carry, and the strongest status anything in t claims. That is the whole of what the work buys, and the package now says so with the quotes attached rather than in general terms. +**The contract that would turn it into an increment.** [EXPORT-CONTRACT.md](research/complex-bank-run3/EXPORT-CONTRACT.md) +and its machine-readable twin [export-contract.json](research/complex-bank-run3/export-contract.json) +put the missing artifact in the form an interface can carry: six required exports -- the +operation program, the frame bodies behind the three published cache digests, the lift and +witness pair, the chronology tables, the per-child occurrence inventory, and the envelope plus +integrity manifest -- each with the digest it must *reproduce* (so the contract asks for bodies +behind hashes the supplier already publishes, never for new trust), seven acceptance tests with +their bounds and reject controls, and the mapping from every export to the obligations it +unblocks. Two readings shape it: the exports are addressed to the `lift`/witness pair and not to +the flow block, because the supplier's own `flow.status` says "Not an exact supplier +certificate"; and the per-child export is asked in the exact shape of the bit word's +`inputs/absorbed-occurrences.json`, because our side of that bijection already exists +(`occurrences66.json`, 4,176 items over 795 banks). Today it fails closed -- **0 of 6 bodies** -- +and `verify.py` asserts that reading against the pins rather than asserting it in prose. + ## Verify ```sh @@ -315,11 +330,13 @@ python3 -B verify.py # check: pins, rebuild, compare with certificate. python3 -B verify.py --write # authoring: regenerate certificate.json and SOURCE.json ``` -`verify.py` passes with exit 0, pins 28 files by sha256, rebuilds the whole complex-side +`verify.py` passes with exit 0, pins 30 files by sha256, rebuilds the whole complex-side ladder (base, rung 2, rungs 3 and 4), both paid moments per rung, the two 47-constraint assemblies with adjacent-grid rejection, the eligibility scan, the PR208 replica, the padded schedule (795 banks, padding 0/2/6 registers per bank, stock drops 531/198/66), the instanced -inventories (4,176 items, 795 banks, the digests), the modulus scan (which widths the pinned +inventories (4,176 items, 795 banks, the digests), the normalizer export contract (all 6 +exports, 7 acceptance tests and 11 obligations mapped, every citation resolved against the pins, +and the 0-of-6 body reading), the modulus scan (which widths the pinned row admits, and that only the pinned width is priced), the supplier scan and the density curve with both of their calibrations, the per-target requirement table (each line re-derived from the assembly rule and tested one `10^-18` step below its budget), and re-runs the T1 tiling diff --git a/research/complex-bank-run3/SOURCE.json b/research/complex-bank-run3/SOURCE.json index 865cfa50b5..28b3f6d405 100644 --- a/research/complex-bank-run3/SOURCE.json +++ b/research/complex-bank-run3/SOURCE.json @@ -1,10 +1,12 @@ { "files": { + "EXPORT-CONTRACT.md": "7a6a3e7ef9ee5050901291a78e317a0043d4de84d3074d7dbc84c3fbf8fec3b1", + "export-contract.json": "200ce8bba7f381bedf9ffe057d79fefd437d62042cf691b27c15f1d406be1991", "instantiate66.py": "add272a8507bf81810fe36a8e9193afcca5fa708d9149a6700868f01c99075a2", "ledger3.py": "202591f64e76002dd0bc05e7d0c36214db85faf9261bb1757bfb0ca568cc53cd", "obligations.json": "079618259a5596468ce7e617802f2b10157293e64612ca5d60ee7291e76d209b", "occurrences66.json": "d755258f115236356ee1b34a84ee98414eee42dd9eeb4f7034abf39b0dac5653", - "pins.py": "49a86398b264f5aad88542af9119625b671e0c57788c9f911b29e9617f61285a", + "pins.py": "7b184cd9fdd14a11e395a2214caf85f6a08a967acb13b5853e7d60a4253734b8", "prototype66.py": "74adbe605ceba533cba1e38b0eca466f67961f4a41e9c839094faa9d503dc2cc", "references/pr207-coordinated-crossover.certificate.json": "f4e30cca369fb014b729df870ca3716cc0f1e2297b9f265341492cba85a14aeb", "references/pr219-run1/NOTICE.md": "1f04b17404663a0983b7cc45e308e577d4d49fb6a4c1ff077dc3f13bae83c56f", diff --git a/research/complex-bank-run3/certificate.json b/research/complex-bank-run3/certificate.json index 3576361968..5023eb035a 100644 --- a/research/complex-bank-run3/certificate.json +++ b/research/complex-bank-run3/certificate.json @@ -912,11 +912,13 @@ } ], "source_pins": { + "EXPORT-CONTRACT.md": "7a6a3e7ef9ee5050901291a78e317a0043d4de84d3074d7dbc84c3fbf8fec3b1", + "export-contract.json": "200ce8bba7f381bedf9ffe057d79fefd437d62042cf691b27c15f1d406be1991", "instantiate66.py": "add272a8507bf81810fe36a8e9193afcca5fa708d9149a6700868f01c99075a2", "ledger3.py": "202591f64e76002dd0bc05e7d0c36214db85faf9261bb1757bfb0ca568cc53cd", "obligations.json": "079618259a5596468ce7e617802f2b10157293e64612ca5d60ee7291e76d209b", "occurrences66.json": "d755258f115236356ee1b34a84ee98414eee42dd9eeb4f7034abf39b0dac5653", - "pins.py": "49a86398b264f5aad88542af9119625b671e0c57788c9f911b29e9617f61285a", + "pins.py": "7b184cd9fdd14a11e395a2214caf85f6a08a967acb13b5853e7d60a4253734b8", "prototype66.py": "74adbe605ceba533cba1e38b0eca466f67961f4a41e9c839094faa9d503dc2cc", "references/pr207-coordinated-crossover.certificate.json": "f4e30cca369fb014b729df870ca3716cc0f1e2297b9f265341492cba85a14aeb", "references/pr219-run1/NOTICE.md": "1f04b17404663a0983b7cc45e308e577d4d49fb6a4c1ff077dc3f13bae83c56f", diff --git a/research/complex-bank-run3/export-contract.json b/research/complex-bank-run3/export-contract.json new file mode 100644 index 0000000000..e10e17337e --- /dev/null +++ b/research/complex-bank-run3/export-contract.json @@ -0,0 +1,166 @@ +{ + "contract": "normalizer export contract for the complex supplier: what its program must publish for C1-C3 to become a bank increment", + "version": 1, + "source": "research/complex-bank-run3/EXPORT-CONTRACT.md (the prose contract this file makes checkable)", + "scope": "The eleven obligations of obligations.json reduce to one missing artifact: the literal operation program, then the columns, charts, witnesses and envelope re-run on the word it banks. This file names the required exports, their verifiable form, the digest each body must reproduce, and the acceptance tests. verify.py -> check_export_contract resolves every citation below against the pinned bytes, so the contract cannot cite a digest, a count or a status that is not there.", + "precedent": { + "banked_word_export_shape": { + "reading": "the one banked word in the pins publishes its physical layer as exact counts, digests and a colouring status: this is the shape E1-E4 must reach on the complex word, and R1's precedent to extend", + "citations": [ + {"source": "references/pr219-run1/references/pr205-packed.certificate.json", "keys": ["physical", "m"], "value": 72}, + {"source": "references/pr219-run1/references/pr205-packed.certificate.json", "keys": ["physical", "banks"], "value": 45842}, + {"source": "references/pr219-run1/references/pr205-packed.certificate.json", "keys": ["physical", "gauge_roles"], "value": 2200}, + {"source": "references/pr219-run1/references/pr205-packed.certificate.json", "keys": ["physical", "incidences"], "value": 154026}, + {"source": "references/pr219-run1/references/pr205-packed.certificate.json", "keys": ["physical", "physical_roles"], "value": 17114}, + {"source": "references/pr219-run1/references/pr205-packed.certificate.json", "keys": ["physical", "word_sha256"], "value": "0728ed1c7320430a87709b1034485cbabefec85d532b48897f74136cf3954218"}, + {"source": "references/pr219-run1/references/pr205-packed.certificate.json", "keys": ["physical", "chart_sha256"], "value": "22662b8580d62f26f50a7773ac45a40d4ffa8352bba5317ec3b2c0ce5897a810"}, + {"source": "references/pr219-run1/references/pr205-packed.certificate.json", "keys": ["physical", "incidence_sha256"], "value": "76bff256b747bd188fdfa679059c8340cab7d8e1208db4b818d770ea08711117"}, + {"source": "references/pr219-run1/references/pr205-packed.certificate.json", "keys": ["physical", "status"], "value": "PASS exact actual-chain chart and incidence checks"}, + {"source": "references/pr219-run1/references/pr205-packed.certificate.json", "keys": ["physical", "color_stats", "swaps"], "value": 733}, + {"source": "references/pr219-run1/references/pr205-packed.certificate.json", "keys": ["physical", "color_stats", "longest_swapped_path"], "value": 11} + ] + }, + "occurrence_inventory_shape": { + "reading": "the bit word's absorbed-occurrences.json is the format precedent for E5: counts per vertex, occurrences as integer tuples per kind, the row identity, and the source pins that tie the inventory to the word it was enumerated on", + "citations": [ + {"source": "references/pr219-run1/inputs/absorbed-occurrences.json", "keys": ["counts_per_vertex"], "value": {"ledger_bin_22_per_vertex": 6672, "ledger_bin_22_three_copies": 20016, "normalization_factor_in_row": 3, "physical_internal_H": 1344, "physical_target_Y": 0, "source_chain_src": 880}}, + {"source": "references/pr219-run1/inputs/absorbed-occurrences.json", "keys": ["row_identity_per_vertex"], "value": {"W": 20668, "deficit": 1936, "m": 72, "mass": 1486160}}, + {"source": "references/pr219-run1/inputs/absorbed-occurrences.json", "keys": ["source_pins", "package"], "value": "research/paired-cube-diagonal-bit-168"} + ] + }, + "exact_object_disclaimer": { + "reading": "the supplier's flow block disclaims exactness in its own status, so the contract is addressed to the lift/witness pair: a modular flow price is explicitly not acceptable evidence for E3", + "citations": [ + {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["flow", "status"], "value": "Modular equal-frame flow price, retaining dirty kernel lifts and complete full-frame cleanup. Not an exact supplier certificate."}, + {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["lift", "status"], "value": "Exact rational local lifts and inverse gate programs verified; monotone flow and zero-fresh kernel reuse DAG verified."} + ] + } + }, + "today": { + "bodies_present": 0, + "of_required": 6, + "verdict": "fail closed: no body export exists in the pins. Every required export is present only as a digest, a count, a status or a path, so the import is refused, the package stays a scheduled target and the kappa keeps its conditional flag.", + "published_only_as": ["digest", "count", "status", "path"], + "evidence": [ + {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["status"], "value": "PASS conditional finite witness", "reading": "the supplier's own verdict"}, + {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["complex_profile", "status"], "value": "Exact local invertible flow, exact all-column fresh identity, paid source controls, target read chains, and integer histogram certified. A literal globally renumbered operation program is not exported; dense initial dirty-response subtraction is defined by the exact certified flow.", "reading": "E1, E2 and E3 are declared absent as bodies"}, + {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["complex_profile", "exact_scalar_program_sha256"], "value": "3b4e671d7c6630570b04788bb2c81629e2c52f8dc2fcc5805952f0b403921027", "reading": "E1's digest exists; its body does not"}, + {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["complex_profile", "exact_lift_certificate_path"], "value": "research/source-assisted-v4/.work/lift.certificate.json.gz", "reading": "E3's body is named by path in the supplier's own workspace, and that path is not in the pins"}, + {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["flow", "cache_sha256", "record.json"], "value": "2065cbaa22c87198a4d535119534e05fab4a258445ecda00cf3cbb9151cfcc30", "reading": "E2's cache bodies are published as digests only"}, + {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["assembly", "construction_receipts", "status"], "value": "Constructive exact flow and fixed-boundary proofs; literal globally renumbered program/replay remains a downstream integration task", "reading": "the supplier's receipts reserve the literal program as downstream work"} + ] + }, + "required_exports": [ + { + "id": "E1", + "name": "program", + "publishes": "the literally renumbered operation program in canonical order: per node its canonical id, operation kind, incoming and outgoing edge ids, and its span", + "form": "JSON, integers only", + "cardinality": {"nodes": 18532, "inverse_elementary_gates": 58165}, + "must_reproduce": [{"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["lift", "exact_scalar_program_sha256"], "value": "3b4e671d7c6630570b04788bb2c81629e2c52f8dc2fcc5805952f0b403921027"}], + "acceptance": ["A1", "A4"], + "unblocks": ["C2", "C1"] + }, + { + "id": "E2", + "name": "frames", + "publishes": "the bodies behind the three cache digests: frames.json (integer kernel basis per frame with the edge nullity histogram), graph.json (parents, children and the edge structure) and record.json (provenance)", + "form": "JSON, canonical integer bases", + "cardinality": {"frames": 18532, "vectors": 26200, "edge_basis_values": 42787, "incoming_dependencies": 24, "outgoing_dependencies": 8116}, + "must_reproduce": [ + {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["flow", "cache_sha256", "frames.json"], "value": "434b81507ebb6e20aa73508d9ac01011fa1b785204363a5eee2eea59256e4b70"}, + {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["flow", "cache_sha256", "graph.json"], "value": "a4d350feb76f2ddcffa409d079bf479c04afd65af2d6b6e96a2ea157019d78d5"}, + {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["flow", "cache_sha256", "record.json"], "value": "2065cbaa22c87198a4d535119534e05fab4a258445ecda00cf3cbb9151cfcc30"} + ], + "acceptance": ["A2", "A3"], + "unblocks": ["C1", "C3"] + }, + { + "id": "E3", + "name": "lift and witness", + "publishes": "the exact rational local lifts and inverse gate programs per node, plus the flow witness they were checked against", + "form": "JSON/gz bodies, denominators <= 2, coefficients in the six published pairs", + "cardinality": {"nodes": 18532, "inverse_elementary_gates": 58165, "physical_R": 9412, "denominator_lcm": 2}, + "must_reproduce": [ + {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["lift", "certificate_sha256"], "value": "1d81a79bda88b8a0ef64b7ae815c0d20cf1eee7f4714053530805bbb39e89ef2"}, + {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["lift", "witness_sha256"], "value": "51da02c6cd844276ca26608f1b714ab07d476ec25634ad1a9b461ccda2fbe457"}, + {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["lift", "checker_sha256"], "value": "9d841bcfdc7c9c19b31791e8d7cfebd223d80d5e9ecd376d26257244f5323f2e"} + ], + "acceptance": ["A1", "A3", "A7"], + "unblocks": ["C1", "C3"] + }, + { + "id": "E4", + "name": "chronology", + "publishes": "per vertex the read and write tables: target read chains (nested), source controls at paid-parity frames, and the deferred, side and centre reads with their counts", + "form": "JSON tables of integer addresses", + "cardinality": {"checked_source_columns": 1320, "checked_target_rows": 1320, "read_counts": {"center": 22, "deferred": 2310, "side": 3135}}, + "must_reproduce": [{"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["complex_profile", "contract_checks", "read_counts"], "value": {"center": 22, "deferred": 2310, "side": 3135}}], + "acceptance": ["A4"], + "unblocks": ["C2", "C3"] + }, + { + "id": "E5", + "name": "children", + "publishes": "the per-bin occurrence inventory of the absorbed families, in the shape of the bit word's absorbed-occurrences.json, with each child's frame or chain identity: 1,062 rank-11, 264 rank-16 and 66 rank-20 items per vertex", + "form": "JSON: counts_per_vertex, occurrences_per_vertex as integer tuples per kind, row_identity_per_vertex, source_pins", + "cardinality": {"rank_11_per_vertex": 1062, "rank_16_per_vertex": 264, "rank_20_per_vertex": 66, "three_copies": [3186, 792, 198]}, + "must_reproduce": [ + {"source": "references/pr219-run1/inputs/absorbed-occurrences.json", "keys": ["counts_per_vertex", "ledger_bin_22_per_vertex"], "value": 6672}, + {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["flow", "retirement_histogram", "1:20"], "value": 198}, + {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["flow", "retirement_histogram", "2:20"], "value": 1320} + ], + "acceptance": ["A5"], + "unblocks": ["C5", "C6", "C7", "C1"] + }, + { + "id": "E6", + "name": "envelope and integrity", + "publishes": "the paid moment envelope in the form arithmetic.py consumes (retained stock, deficit, retained histogram, worst-case bad fraction, fallback), plus the package path, its head, every digest of E1-E5 and the acceptance predicates actually run", + "form": "JSON envelope plus manifest", + "cardinality": {"W_per_vertex": 12052, "deficit_per_vertex": 1320, "h": 22, "v": 1320, "rank_per_vertex": 794112}, + "must_reproduce": [ + {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["complex_profile", "W_per_vertex"], "value": 12052}, + {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["complex_profile", "deficit_per_vertex"], "value": 1320}, + {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["complex_profile", "target_data_histogram"], "value": {"0": 6270, "1": 3960, "18": 1320}} + ], + "acceptance": ["A1", "A6", "A7"], + "unblocks": ["C4", "R4"] + } + ], + "acceptance_tests": [ + {"id": "A1", "name": "body hashes to the published digest", "test": "every exported body hashes to the digest the certificate already published", "bound": "3b4e671d... (program), 1d81a79b... (lift), 51da02c6... (witness)", "reject_control": "any altered byte fails the hash; a matching hash is evidence of identity, not correctness"}, + {"id": "A2", "name": "frame-record bijection", "test": "a complete bijection between the supplier's frame ids and the canonical ids, with frames and edge basis values reproduced", "bound": "18532 frames, 42787 edge basis values", "reject_control": "a renumbering that is not a bijection, or an id used twice"}, + {"id": "A3", "name": "charts and factors", "test": "fraction-free chart inversion and replayed elementary factors on every frame, with the denominator bound", "bound": "denominators <= 2, max_abs_numerator <= 2, denominator_lcm = 2", "reject_control": "a factor that does not replay, or a denominator above the published bound"}, + {"id": "A4", "name": "columns of the modified word", "test": "every source, target and dirty-register column over F2 and over the defining integers, with the target chronology nested and the source controls at paid-parity frames", "bound": "1320 source columns and 1320 target rows per vertex; read_counts 22/2310/3135", "reject_control": "counts quoted from the certificate instead of coming out of the exported tables"}, + {"id": "A5", "name": "per-child bijection", "test": "the exported occurrences map onto this package's occurrences66.json items with no other bin touched", "bound": "3186/792/198 three-copy items onto 531x6, 198x4 and 66x3 blocks", "reject_control": "an occurrence outside the ledger's bins, or a block left without its item"}, + {"id": "A6", "name": "incidence colouring", "test": "colouring of the new incidences with the conflicting assignment rejected", "bound": "PR205 precedent: swaps 733, longest_swapped_path 11", "reject_control": "a conflicting assignment accepted"}, + {"id": "A7", "name": "prime witnesses", "test": "distinct integer Gram/prime witnesses for every frame the new blocks use, residual factors below the retained q bound", "bound": "the retained prime threshold (PR205: 17114 physical roles, all used frames witnessed)", "reject_control": "a repeated witness, or a factor above the bound"} + ], + "obligation_mapping": { + "C1": ["E2", "E3", "E4", "E5"], + "C2": ["E1", "E2", "E4"], + "C3": ["E2", "E3", "E4", "E6"], + "C4": ["E6"], + "C5": ["E5"], + "C6": ["E5"], + "C7": ["E5"], + "R1": ["E2", "E3"], + "R2": ["E1", "E2", "E4"], + "R3": ["E2", "E3"], + "R4": ["E6"] + }, + "not_required": [ + "internal id stability: only the canonical renumbering map and the bijection test A2", + "program text beyond canonical data: E1 is nodes, kinds, edges and spans, not a listing in the supplier's own language", + "sources for the supplier's own claims: the importer re-runs the columns (A4) and re-charts the frames (A3), so a boolean in contract_checks is a claim to reproduce, not a result", + "the modular flow price: flow.status disclaims exactness, only the lift/witness pair satisfies E3", + "any asymptotic interface: general Clifford/tensor, uniform weighted compilation, restored rows, routing, paid layout, prime supply, precision/recovery and fixed tape stay assumptions, so this contract can buy a conditional finite witness and never a theorem" + ], + "failure_semantics": { + "today": "0 of 6 bodies: the import fails closed, the package stays a scheduled target and the kappa keeps its conditional flag", + "order_of_discharge": "A1-A3 admit E2-E3 and make C1's normalizer a re-assignment over published frames; A4 re-runs C2; A5 closes C5-C7 and the item-to-block half of C1; A6-A7 close C3; E6 closes C4 and R4", + "never": "no export can make the bound unconditional; see obligations.json -> unconditionality" + }, + "status": "CONTRACT PUBLISHED AND MACHINE-CHECKED: verify.py -> check_export_contract resolves every citation above against the pinned bytes and asserts the 0-of-6 reading" +} diff --git a/research/complex-bank-run3/pins.py b/research/complex-bank-run3/pins.py index 72d9997841..015c405e81 100644 --- a/research/complex-bank-run3/pins.py +++ b/research/complex-bank-run3/pins.py @@ -15,7 +15,8 @@ OWN = ('ledger3.py', 'run3.py', 'schedule66.py', 'schedule66.json', 'prototype66.py', 'widths66.py', 'suppliers.py', 'instantiate66.py', 'occurrences66.json', 'pins.py', - 'obligations.json', 'references/pr207-coordinated-crossover.certificate.json') + 'obligations.json', 'EXPORT-CONTRACT.md', 'export-contract.json', + 'references/pr207-coordinated-crossover.certificate.json') def pinned_paths(): diff --git a/research/complex-bank-run3/verify.py b/research/complex-bank-run3/verify.py index e68841e96d..77cf366a86 100644 --- a/research/complex-bank-run3/verify.py +++ b/research/complex-bank-run3/verify.py @@ -287,6 +287,76 @@ def check_unconditionality(): return block +def resolve(node, keys): + """Walk a citation's key list through a pinned JSON document.""" + for key in keys: + node = node[key] + return node + + +def check_export_contract(): + """The normalizer export contract, resolved against the pinned bytes. + + The contract's whole point is that its citations are real: every digest, count and status it + quotes from the supplier is read back out of the pinned file and compared, the precedent + values are read back out of the pinned banked word and inventory, and the state it declares + -- 0 of 6 bodies exported -- is asserted rather than described. + """ + contract = json.loads((HERE / 'export-contract.json').read_text()) + cache = {} + + def pinned(source): + if source not in cache: + cache[source] = json.loads((HERE / source).read_text()) + return cache[source] + + def check(citations, where): + for row in citations: + found = resolve(pinned(row['source']), row['keys']) + assert found == row['value'], \ + '%s: %s -> %s is %r, contract records %r' % (where, row['source'], + row['keys'], found, row['value']) + + assert contract['version'] == 1 and contract['scope'], 'the contract must state its scope' + check(contract['precedent']['banked_word_export_shape']['citations'], 'precedent/banked word') + check(contract['precedent']['occurrence_inventory_shape']['citations'], 'precedent/inventory') + check(contract['precedent']['exact_object_disclaimer']['citations'], 'precedent/disclaimer') + check(contract['today']['evidence'], 'today/evidence') + + supplier = pinned('references/pr219-run1/references/pr193-source-assisted-v4.certificate.json') + assert supplier['status'] == 'PASS conditional finite witness' + assert 'not exported' in supplier['complex_profile']['status'] + assert contract['today']['bodies_present'] == 0, \ + 'no body export exists in the pins and the contract must say so' + assert contract['today']['of_required'] == len(contract['required_exports']) == 6, \ + '0 of the six required bodies' + + tests = {test['id'] for test in contract['acceptance_tests']} + assert tests == {'A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7'}, 'the seven acceptance tests' + for export in contract['required_exports']: + assert export['id'] in ('E1', 'E2', 'E3', 'E4', 'E5', 'E6'), export['id'] + assert export['publishes'] and export['form'] and export['cardinality'], export['id'] + assert export['unblocks'], 'every export must unblock something' + assert set(export['acceptance']) <= tests, 'the acceptance tests must exist: %s' % export['id'] + check(export['must_reproduce'], 'export/' + export['id']) + assert len({export['id'] for export in contract['required_exports']}) == 6, 'unique ids' + + mapping = contract['obligation_mapping'] + assert sorted(mapping) == ['C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', + 'R1', 'R2', 'R3', 'R4'], 'all eleven obligations mapped' + assert all(mapping[key] for key in mapping), 'no obligation may map to nothing' + exports = {export['id'] for export in contract['required_exports']} + for key, value in mapping.items(): + assert set(value) <= exports, '%s must map to required exports' % key + assert contract['failure_semantics']['today'].startswith('0 of 6') + assert 'never' in contract['failure_semantics'] and contract['not_required'], \ + 'the contract must say what it does not ask for, and what it can never buy' + for test in contract['acceptance_tests']: + assert test['bound'] and test['reject_control'], \ + 'every test needs a bound and a reject control: %s' % test['id'] + return contract + + def main(): parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) @@ -304,6 +374,7 @@ def main(): ceiling, scan, curve = check_suppliers_and_requirements(record) check_obligations() unconditionality = check_unconditionality() + contract = check_export_contract() target = HERE / 'certificate.json' if args.write: (HERE / 'SOURCE.json').write_text( @@ -336,6 +407,11 @@ def main(): % (record['construction']['totals']['items'], record['construction']['totals']['banks'], record['construction']['totals']['padding_registers'])) + print('export contract %d exports (%s), %d acceptance tests, bodies exported today: %d/%d' + % (len(contract['required_exports']), + ','.join(export['id'] for export in contract['required_exports']), + len(contract['acceptance_tests']), contract['today']['bodies_present'], + contract['today']['of_required'])) print('unconditional not available: supplier status %s; operation program not exported; %s' % (json.loads((HERE / 'references' / 'pr219-run1' / 'references' / 'pr193-source-assisted-v4.certificate.json').read_text())['status'], From 5470969371b49457bbfbf86de5dec8571e4cb878 Mon Sep 17 00:00:00 2001 From: maxime-fleury Date: Sat, 10 Oct 2026 00:10:17 +0200 Subject: [PATCH 09/11] Make the contract's 0-of-6 reading evidence instead of declaration MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit check_export_contract now derives the bodies the contract waits for from the contract itself (the lift certificate, the three cache bodies) and asserts none of them is in the pin manifest, nor any path under the supplier's own workspace. So "no body export exists in the pins" is read back from the pinned file list rather than restated in prose, which is the one claim in the contract that a reader should not have to take on trust. 🤖 Generated with Codebuff Co-Authored-By: Codebuff --- research/complex-bank-run3/verify.py | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/research/complex-bank-run3/verify.py b/research/complex-bank-run3/verify.py index 77cf366a86..110ee313e5 100644 --- a/research/complex-bank-run3/verify.py +++ b/research/complex-bank-run3/verify.py @@ -326,8 +326,25 @@ def check(citations, where): supplier = pinned('references/pr219-run1/references/pr193-source-assisted-v4.certificate.json') assert supplier['status'] == 'PASS conditional finite witness' assert 'not exported' in supplier['complex_profile']['status'] - assert contract['today']['bodies_present'] == 0, \ + assert contract['today']['bodies_present'] == 0, \ 'no body export exists in the pins and the contract must say so' + bodies = set() + for row in contract['today']['evidence']: + if isinstance(row['value'], str) and row['value'].endswith('.gz'): + bodies.add(row['value'].rsplit('/', 1)[-1]) + if row['keys'] and row['keys'][-1].endswith('.json'): + bodies.add(row['keys'][-1]) + for export in contract['required_exports']: + for row in export['must_reproduce']: + if row['keys'] and row['keys'][-1].endswith('.json'): + bodies.add(row['keys'][-1]) + assert bodies, 'the contract must name the bodies it waits for' + pinned_names = set(pins.manifest()) + assert not any(name.rsplit('/', 1)[-1] in bodies for name in pinned_names), \ + 'no body the contract requires may be pinned: the 0-of-6 reading must be a reading' + assert not any('.work' in name for name in pinned_names), \ + 'the supplier workspace the contract names must not be in the pins' + assert len(bodies) >= 4, 'program, frames, graph, record, witness and lift bodies: %s' % bodies assert contract['today']['of_required'] == len(contract['required_exports']) == 6, \ '0 of the six required bodies' From f44221e07068ad91a70b5de50af7b99a09ba59d8 Mon Sep 17 00:00:00 2001 From: maxime-fleury Date: Sat, 10 Oct 2026 00:16:06 +0200 Subject: [PATCH 10/11] Make the export contract executable: an import harness that refuses until the bodies arrive MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The contract named the six exports; this runs them. importer66.py consumes the exports, applies the seven acceptance tests with their bounds, and today -- when no body exists -- refuses cleanly with exit code 2 after naming all ten bodies it waits for, so no obligation moves on an empty import. The module keeps apart two things that are easy to confuse. The gate is decidable from what the bodies declare: hashes anchored to the digests the supplier already published, cardinalities, the published bounds, the two bijections (the frame id map, and the occurrence families against this package's own occurrences66.json) and the counts that must come out of the exported tables rather than out of the certificate. The replay is the physics, and it is the supplier's own checker: the contract pins its digest, so the harness requires that file by digest and stops at "gate green, replay not run" until it arrives, rather than reimplementing or claiming the columns. It is proven to work while the data is absent. --self-test builds synthetic bodies, patches the anchored digests to their synthetic hashes and then breaks each check in turn: a tampered body, a wrong cardinality, a denominator above the bound, counts that do not come from the tables, a foreign family and bin, an accepted colouring conflict, a repeated prime witness, an absent body, a checker the contract does not pin, and the pinned checker passing. All twelve cases pass, and verify.py now runs them, so the refusals the harness will perform on the real drop are demonstrated rather than promised. Writing the harness found two real bugs in the contract's gate model, both fixed here: an export's declared checks were being applied to every body it owns instead of its primary body (so the colouring and witness bounds were demanded of graph.json and record.json), and the integrity manifest was required to declare its own digest, which no file can contain. 🤖 Generated with Codebuff Co-Authored-By: Codebuff --- research/complex-bank-run3/PROOF.md | 11 +- research/complex-bank-run3/README.md | 24 +- research/complex-bank-run3/SOURCE.json | 5 +- .../complex-bank-run3/export-contract.json | 61 +++ research/complex-bank-run3/importer66.py | 478 ++++++++++++++++++ research/complex-bank-run3/pins.py | 3 +- research/complex-bank-run3/verify.py | 52 ++ 7 files changed, 629 insertions(+), 5 deletions(-) create mode 100644 research/complex-bank-run3/importer66.py diff --git a/research/complex-bank-run3/PROOF.md b/research/complex-bank-run3/PROOF.md index 7d515ed50b..f9e56177d1 100644 --- a/research/complex-bank-run3/PROOF.md +++ b/research/complex-bank-run3/PROOF.md @@ -230,7 +230,7 @@ the density curve finds above is still below all of them. ## 6. Verification boundary -* Machine-checked here: the pinned bytes (30 files, sha256), the frontier reproduction, rung 1 +* Machine-checked here: the pinned bytes (31 files, sha256), the frontier reproduction, rung 1 rebuilt by the vendored #219 package, rung 2 rebuilt by this package's own ledger module, rungs 3 and 4 (volumes, row identities, stock drops, both paid moments, adjacency rejections), the branch ceilings, the eligibility exhaustion, the PR208 replica, the T1 @@ -271,6 +271,15 @@ the curve's width-66 row is exactly the pinned stock reproducing the top kappa), than described. The contract's one design reading is also pinned: it addresses the `lift`/witness pair, not the flow block, whose own status says *"Not an exact supplier certificate"*. +* Also machine-checked: the contract's executable form, `importer66.py`. Its self-test is run + as part of the verification and must pass all twelve of its cases -- seven acceptance checks + broken in turn (a tampered body, a wrong cardinality, a denominator above the published bound, + counts that do not come out of the exported tables, a foreign family and bin, an accepted + colouring conflict, a repeated prime witness), an absent body, a checker the contract does not + pin, the pinned checker passing, and the gate green without any checker -- and the real drop, + which does not exist yet, must still be refused with the refusal code. The harness never + claims the physics: the replay needs the checker whose digest E3 pins, and until it is supplied + the import stops at *gate green, replay not run*. * Not run: upstream CI, and any contributor verifier other than the vendored #219 package invoked in place. * The `10^-10` supplier field is priced as a conservative variant; on it the ladder's top sits diff --git a/research/complex-bank-run3/README.md b/research/complex-bank-run3/README.md index 92bd39e53d..4dc3b1c60e 100644 --- a/research/complex-bank-run3/README.md +++ b/research/complex-bank-run3/README.md @@ -322,15 +322,37 @@ certificate"; and the per-child export is asked in the exact shape of the bit wo (`occurrences66.json`, 4,176 items over 795 banks). Today it fails closed -- **0 of 6 bodies** -- and `verify.py` asserts that reading against the pins rather than asserting it in prose. +**The contract in executable form** is [importer66.py](research/complex-bank-run3/importer66.py). +It consumes the exports, runs the seven acceptance tests with their bounds and refuses cleanly +while a body is absent -- which is the state today: `python3 -B importer66.py` exits **2** after +naming all ten bodies that are missing, and no obligation moves. The module separates the two +things that are easy to confuse. The **gate** is decidable from what the bodies declare: hashes +anchored to the digests the supplier already published, cardinalities, the published bounds +(denominators, colouring, prime threshold), the two bijections (the frame id map, and A5's +families against this package's own `occurrences66.json`) and the counts that must come out of +the exported tables rather than out of the certificate. The **replay** -- formal columns over F2 +and the defining integers, fraction-free charts, the moment envelope -- is the supplier's own +checker: the contract pins its digest (`lift.checker_sha256`), so the harness requires that exact +file and reports the replay `NOT RUN` until it arrives, and exit code 3 says so rather than +certifying anything. `--self-test` builds synthetic bodies, patches the anchored digests to their +synthetic hashes, and then breaks each check in turn: twelve cases, including a tampered body, a +wrong cardinality, a denominator above the bound, counts that do not come out of the tables, a +foreign family and a foreign bin, an accepted colouring conflict, a repeated prime witness, an +absent body, a checker the contract does not pin, and the pinned checker passing. All twelve +pass in `verify.py`, so the refusals the harness will perform on the real drop are demonstrated +now rather than promised. + ## Verify ```sh cd research/complex-bank-run3 python3 -B verify.py # check: pins, rebuild, compare with certificate.json python3 -B verify.py --write # authoring: regenerate certificate.json and SOURCE.json +python3 -B importer66.py # the export import: refuses, codes 0/1/2/3 +python3 -B importer66.py --self-test # the harness's own twelve cases ``` -`verify.py` passes with exit 0, pins 30 files by sha256, rebuilds the whole complex-side +`verify.py` passes with exit 0, pins 31 files by sha256, rebuilds the whole complex-side ladder (base, rung 2, rungs 3 and 4), both paid moments per rung, the two 47-constraint assemblies with adjacent-grid rejection, the eligibility scan, the PR208 replica, the padded schedule (795 banks, padding 0/2/6 registers per bank, stock drops 531/198/66), the instanced diff --git a/research/complex-bank-run3/SOURCE.json b/research/complex-bank-run3/SOURCE.json index 28b3f6d405..6830437c4e 100644 --- a/research/complex-bank-run3/SOURCE.json +++ b/research/complex-bank-run3/SOURCE.json @@ -1,12 +1,13 @@ { "files": { "EXPORT-CONTRACT.md": "7a6a3e7ef9ee5050901291a78e317a0043d4de84d3074d7dbc84c3fbf8fec3b1", - "export-contract.json": "200ce8bba7f381bedf9ffe057d79fefd437d62042cf691b27c15f1d406be1991", + "export-contract.json": "b1d5cab7277d2b5f4302d754b33c31f60ec2cccdf79e5cf97951cb4f589cc74f", + "importer66.py": "09e66969ec2b5757feadadfca4c5992661ddcad7af7e071cb4ad294e62b024e0", "instantiate66.py": "add272a8507bf81810fe36a8e9193afcca5fa708d9149a6700868f01c99075a2", "ledger3.py": "202591f64e76002dd0bc05e7d0c36214db85faf9261bb1757bfb0ca568cc53cd", "obligations.json": "079618259a5596468ce7e617802f2b10157293e64612ca5d60ee7291e76d209b", "occurrences66.json": "d755258f115236356ee1b34a84ee98414eee42dd9eeb4f7034abf39b0dac5653", - "pins.py": "7b184cd9fdd14a11e395a2214caf85f6a08a967acb13b5853e7d60a4253734b8", + "pins.py": "8b407d1701edd638d9c7acf0471534ee7bd13cb085b02037cd4a2c4638bb32cd", "prototype66.py": "74adbe605ceba533cba1e38b0eca466f67961f4a41e9c839094faa9d503dc2cc", "references/pr207-coordinated-crossover.certificate.json": "f4e30cca369fb014b729df870ca3716cc0f1e2297b9f265341492cba85a14aeb", "references/pr219-run1/NOTICE.md": "1f04b17404663a0983b7cc45e308e577d4d49fb6a4c1ff077dc3f13bae83c56f", diff --git a/research/complex-bank-run3/export-contract.json b/research/complex-bank-run3/export-contract.json index e10e17337e..3afac53149 100644 --- a/research/complex-bank-run3/export-contract.json +++ b/research/complex-bank-run3/export-contract.json @@ -58,6 +58,8 @@ "form": "JSON, integers only", "cardinality": {"nodes": 18532, "inverse_elementary_gates": 58165}, "must_reproduce": [{"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["lift", "exact_scalar_program_sha256"], "value": "3b4e671d7c6630570b04788bb2c81629e2c52f8dc2fcc5805952f0b403921027"}], + "bodies": [{"file": "program.json", "anchored_digest": "3b4e671d7c6630570b04788bb2c81629e2c52f8dc2fcc5805952f0b403921027"}], + "gate": {"test": ["A2"], "equals": {"nodes": 18532, "inverse_elementary_gates": 58165}}, "acceptance": ["A1", "A4"], "unblocks": ["C2", "C1"] }, @@ -72,6 +74,20 @@ {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["flow", "cache_sha256", "graph.json"], "value": "a4d350feb76f2ddcffa409d079bf479c04afd65af2d6b6e96a2ea157019d78d5"}, {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["flow", "cache_sha256", "record.json"], "value": "2065cbaa22c87198a4d535119534e05fab4a258445ecda00cf3cbb9151cfcc30"} ], + "bodies": [ + {"file": "frames.json", "anchored_digest": "434b81507ebb6e20aa73508d9ac01011fa1b785204363a5eee2eea59256e4b70"}, + {"file": "graph.json", "anchored_digest": "a4d350feb76f2ddcffa409d079bf479c04afd65af2d6b6e96a2ea157019d78d5"}, + {"file": "record.json", "anchored_digest": "2065cbaa22c87198a4d535119534e05fab4a258445ecda00cf3cbb9151cfcc30"} + ], + "gate": { + "test": ["A2", "A6", "A7"], + "equals": {"frames": 18532, "vectors": 26200, "edge_basis_values": 42787}, + "bijection": ["id_map"], + "equals_on": {"graph.json": {"incoming_dependencies": 24, "outgoing_dependencies": 8116}}, + "flags_true": ["conflicting_assignment_rejected"], + "flags_present": ["color_stats"], + "distinct_below": {"witnesses": "prime_witnesses", "bound": "q_bound"} + }, "acceptance": ["A2", "A3"], "unblocks": ["C1", "C3"] }, @@ -86,6 +102,12 @@ {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["lift", "witness_sha256"], "value": "51da02c6cd844276ca26608f1b714ab07d476ec25634ad1a9b461ccda2fbe457"}, {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["lift", "checker_sha256"], "value": "9d841bcfdc7c9c19b31791e8d7cfebd223d80d5e9ecd376d26257244f5323f2e"} ], + "bodies": [ + {"file": "lift.certificate.json.gz", "anchored_digest": "1d81a79bda88b8a0ef64b7ae815c0d20cf1eee7f4714053530805bbb39e89ef2"}, + {"file": "flow.witness.json", "anchored_digest": "51da02c6cd844276ca26608f1b714ab07d476ec25634ad1a9b461ccda2fbe457"} + ], + "gate": {"test": ["A3"], "equals": {"nodes": 18532, "physical_R": 9412}, + "at_most": {"max_denominator": 2, "max_abs_numerator": 2}}, "acceptance": ["A1", "A3", "A7"], "unblocks": ["C1", "C3"] }, @@ -96,6 +118,13 @@ "form": "JSON tables of integer addresses", "cardinality": {"checked_source_columns": 1320, "checked_target_rows": 1320, "read_counts": {"center": 22, "deferred": 2310, "side": 3135}}, "must_reproduce": [{"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["complex_profile", "contract_checks", "read_counts"], "value": {"center": 22, "deferred": 2310, "side": 3135}}], + "bodies": [{"file": "chronology.json", "anchored_digest": null}], + "gate": { + "test": ["A4"], + "equals": {"checked_source_columns": 1320, "checked_target_rows": 1320, + "read_counts": {"center": 22, "deferred": 2310, "side": 3135}}, + "counted_in_tables": {"target_rows": "checked_target_rows", "source_columns": "checked_source_columns"} + }, "acceptance": ["A4"], "unblocks": ["C2", "C3"] }, @@ -110,6 +139,9 @@ {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["flow", "retirement_histogram", "1:20"], "value": 198}, {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["flow", "retirement_histogram", "2:20"], "value": 1320} ], + "bodies": [{"file": "occurrences.complex.json", "anchored_digest": null}], + "gate": {"test": ["A5"], "equals_ours": "families", + "bins_allowed": ["11", "16", "20"]}, "acceptance": ["A5"], "unblocks": ["C5", "C6", "C7", "C1"] }, @@ -124,6 +156,13 @@ {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["complex_profile", "deficit_per_vertex"], "value": 1320}, {"source": "references/pr219-run1/references/pr193-source-assisted-v4.certificate.json", "keys": ["complex_profile", "target_data_histogram"], "value": {"0": 6270, "1": 3960, "18": 1320}} ], + "bodies": [ + {"file": "envelope.json", "anchored_digest": null}, + {"file": "integrity.json", "anchored_digest": null} + ], + "gate": {"test": ["A1"], + "equals": {"W_per_vertex": 12052, "deficit_per_vertex": 1320, "h": 22, "v": 1320}, + "declares_every_body_on": "integrity.json"}, "acceptance": ["A1", "A6", "A7"], "unblocks": ["C4", "R4"] } @@ -157,6 +196,28 @@ "the modular flow price: flow.status disclaims exactness, only the lift/witness pair satisfies E3", "any asymptotic interface: general Clifford/tensor, uniform weighted compilation, restored rows, routing, paid layout, prime supply, precision/recovery and fixed tape stay assumptions, so this contract can buy a conditional finite witness and never a theorem" ], + "import_harness": { + "module": "importer66.py", + "exports_dir": "exports", + "usage": "python3 -B importer66.py --exports DIR [--checker FILE] | --self-test", + "exit_codes": { + "0": "admissible: every body present, the gate green and the pinned replay checker passed", + "1": "a check failed: the report names the test, its bound and what was seen", + "2": "refusing: at least one required body is absent, so nothing is run and nothing is certified", + "3": "gate green, replay NOT RUN: no checker was supplied" + }, + "layers": { + "gate": "decidable from the bodies' declared data: hashes (A1), cardinalities (A2, A5), published bounds (A3, A6, A7), bijections (A2's id map, A5 against occurrences66.json) and the counts that must come out of the exported tables rather than the certificate (A4)", + "replay": "the physics: formal columns over F2 and the defining integers, fraction-free chart replay, and the moment envelope re-derived. The harness does not reimplement them and never claims to have run them: the checker whose digest E3 pins must be supplied, and until it is the replay is reported NOT RUN" + }, + "replay_requirement": { + "checker_digest": "9d841bcfdc7c9c19b31791e8d7cfebd223d80d5e9ecd376d26257244f5323f2e", + "checker_source": "lift.checker_sha256 of the pinned supplier certificate", + "why": "the physics is the supplier's own checker, not a reimplementation: an import that supplies the pinned checker by digest may run the replay, and one that does not is reported NOT RUN" + }, + "anchored_digests_are_of_published_bytes": "hash files as published, gzip bodies included, and read .gz fields after decompressing", + "self_test": "--self-test builds synthetic bodies in a temporary directory, patches the anchored digests to the synthetic hashes and then exercises all seven checks and all four exit codes, so the harness is proven working while the real bodies are absent" + }, "failure_semantics": { "today": "0 of 6 bodies: the import fails closed, the package stays a scheduled target and the kappa keeps its conditional flag", "order_of_discharge": "A1-A3 admit E2-E3 and make C1's normalizer a re-assignment over published frames; A4 re-runs C2; A5 closes C5-C7 and the item-to-block half of C1; A6-A7 close C3; E6 closes C4 and R4", diff --git a/research/complex-bank-run3/importer66.py b/research/complex-bank-run3/importer66.py new file mode 100644 index 0000000000..ea77c2f655 --- /dev/null +++ b/research/complex-bank-run3/importer66.py @@ -0,0 +1,478 @@ +#!/usr/bin/env python3 +"""Import harness for the normalizer export contract. + +`export-contract.json` says what the complex supplier's program must publish for C1-C3 to become +a bank increment. This module is its executable form: it consumes the exports, runs the seven +acceptance tests with their bounds, and -- today, when no body exists -- refuses cleanly instead +of certifying anything. + +Two layers, and the difference between them is the point of the module. + +* **The gate** is decidable from what the bodies declare: the hashes (A1), the cardinalities + (A2, and A5's item counts), the published bounds (A3's denominators, A6's colouring, A7's prime + threshold), the bijections (A2's id map, and A5 against this package's own `occurrences66.json`) + and the counts that must come out of the exported tables rather than out of the certificate + (A4). Every gate check is exercised by `--self-test`, which builds synthetic bodies, patches + the anchored digests to the synthetic hashes and then breaks each check in turn: the harness is + proven to work, and to reject, while the real bodies are absent. +* **The replay** is the physics: the formal columns over F2 and over the defining integers, the + fraction-free chart replay, the moment envelope re-derived. This module does not reimplement + any of it and never claims to have run it. The contract pins the digest of the supplier's own + checker (`E3` -> `lift.checker_sha256`), so the harness *requires that checker* by digest and + reports the replay as NOT RUN until it is supplied. A digest match is identity, not + correctness -- the contract says so, and so does this module. + +Exit codes (also published in the contract under `import_harness.exit_codes`) + + 0 admissible: every body present, the gate green and the pinned replay checker passed + 1 a check failed (the report names the test, its bound and what was seen) + 2 refusing: at least one required body is absent, so nothing is run and nothing is certified + 3 gate green but the replay was not run (no checker supplied) +""" +import argparse +import gzip +import hashlib +import json +import subprocess +import sys +import tempfile +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.dont_write_bytecode = True +CONTRACT = HERE / 'export-contract.json' +OURS = HERE / 'occurrences66.json' + +PASS, FAIL, NOT_RUN = 'PASS', 'FAIL', 'NOT_RUNNABLE' + + +def sha256(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def load(path): + """A body, decompressed if it is gzipped. Digests are always of the published bytes.""" + raw = Path(path).read_bytes() + if str(path).endswith('.gz'): + raw = gzip.decompress(raw) + return json.loads(raw.decode('utf-8')) + + +def walk(node, dotted): + """Follow a dotted path through a body, or raise KeyError.""" + for key in dotted.split('.'): + node = node[key] + return node + + +def refusal(contract, exports_dir): + """The bodies the contract waits for, split into present and absent.""" + rows, missing = [], [] + for export in contract['required_exports']: + for body in export['bodies']: + path = Path(exports_dir) / body['file'] + rows.append(dict(export=export['id'], file=body['file'], path=path, + anchored=body.get('anchored_digest'))) + if not path.is_file(): + missing.append((export['id'], body['file'])) + return rows, missing + + +def gate(contract, exports_dir): + """Every check decidable from the bodies that declare it. Returns per-test results.""" + results = {test['id']: dict(test=test['id'], name=test['name'], status=NOT_RUN, + checks=[], reason=None, passed=0, failed=0) + for test in contract['acceptance_tests']} + + def record(test, ok, detail): + entry = results[test] + entry['checks'].append(detail) + entry['passed' if ok else 'failed'] += 1 + + def need(test, reason): + entry = results[test] + if entry['reason'] is None: # the first missing datum explains the state + entry['reason'] = reason + + def settle(): + """A test is FAIL if a check failed, NOT_RUNNABLE if a datum was missing, else PASS.""" + for entry in results.values(): + if entry['failed']: + entry['status'] = FAIL + elif entry['reason'] is not None: + entry['status'] = NOT_RUN + elif entry['passed']: + entry['status'] = PASS + + rows, _missing = refusal(contract, exports_dir) + bodies = {} + for row in rows: + try: + bodies[row['file']] = load(row['path']) + except (json.JSONDecodeError, gzip.BadGzipFile, OSError, UnicodeDecodeError) as exc: + record('A1', False, '%s is not readable as a body: %s' % (row['file'], exc)) + + # A1 -- every anchored digest is the digest of the published bytes, and the integrity + # manifest agrees with the files it lists. + anchored = [row for row in rows if row['anchored']] + for row in anchored: + seen = sha256(row['path']) + record('A1', seen == row['anchored'], + 'A1 %s hashes %s, contract anchors %s' % (row['file'], seen[:16], row['anchored'][:16])) + integrity = bodies.get('integrity.json') + if integrity is None: + need('A1', 'integrity.json is absent, so no body is declared and nothing is self-checked') + else: + declared = integrity.get('files', {}) + for row in rows: + if row['file'] == 'integrity.json': + continue + seen = sha256(row['path']) + record('A1', declared.get(row['file']) == seen, + 'A1 integrity declares %s = %s' % (row['file'], str(declared.get(row['file']))[:16])) + + # A2..A7 -- the declared gate of each export. + for export in contract['required_exports']: + declared = export['gate'] + tests = declared['test'] + subject = export['bodies'][0]['file'] # an export's declared checks are its primary + fields = [(subject, declared.get('equals', {}))] # body's, unless named in `_on` + fields += [(body['file'], declared.get('equals_on', {}).get(body['file'], {})) + for body in export['bodies'][1:]] + for file_name, scope in fields: + body = bodies.get(file_name) + if body is None: + for test in tests: + need(test, '%s is absent' % file_name) + continue + for test in tests: + extra = declared if file_name == subject else {} # flags, bijections, witnesses + for dotted, expected in scope.items(): + try: + seen = walk(body, dotted) + except (KeyError, TypeError): + need(test, '%s has no %s' % (file_name, dotted)) + continue + record(test, seen == expected, '%s %s.%s = %r, bound %r' + % (test, file_name, dotted, seen, expected)) + if file_name == declared.get('declares_every_body_on'): + # every required body except the manifest itself, whose digest cannot sit + # inside the file it would be a digest of + wanted = {row['file'] for group in contract['required_exports'] + for row in group['bodies']} - {file_name} + declared_files = set(body.get('files', {})) + record(test, wanted <= declared_files, + '%s %s declares %d of the %d other required bodies' + % (test, file_name, len(wanted & declared_files), len(wanted))) + for dotted in extra.get('bijection', []): + try: + seen = walk(body, dotted) + except (KeyError, TypeError): + need(test, '%s has no %s' % (file_name, dotted)) + continue + keys = [str(k) for k in seen] + values = [str(v) for v in seen.values()] + ok = len(set(keys)) == len(keys) and len(set(values)) == len(values) + record(test, ok, '%s %s.%s is a bijection on %d ids' % (test, file_name, dotted, len(keys))) + for flag in extra.get('flags_true', []): + try: + seen = walk(body, flag) + except (KeyError, TypeError): + need(test, '%s has no %s' % (file_name, flag)) + continue + record(test, seen is True, '%s %s.%s = %r, must be true' % (test, file_name, flag, seen)) + for flag in extra.get('flags_present', []): + ok = flag in body + record(test, ok, '%s %s.%s is present' % (test, file_name, flag)) + if 'distinct_below' in extra: + spec = extra['distinct_below'] + try: + witnesses = walk(body, spec['witnesses']) + bound = walk(body, spec['bound']) + except (KeyError, TypeError): + need(test, '%s has no %s or %s' % (file_name, spec['witnesses'], spec['bound'])) + continue + labels = [w['witness'] if isinstance(w, dict) else w for w in witnesses] + factors = [w['residual_factor'] for w in witnesses if isinstance(w, dict)] + ok = len(set(labels)) == len(labels) and all(f < bound for f in factors) + record(test, ok, '%s %s: %d witnesses, distinct %s, all factors below %r' + % (test, file_name, len(labels), len(set(labels)) == len(labels), bound)) + if 'counted_in_tables' in extra: + for table, field in extra['counted_in_tables'].items(): + rows_in_tables = sum(len(t.get(table, [])) for t in body.get('tables', [])) + try: + claimed = walk(body, field) + except (KeyError, TypeError): + need(test, '%s has no %s' % (file_name, field)) + continue + record(test, rows_in_tables == claimed, + '%s %s: %d rows come out of the tables, certificate claims %r' + % (test, file_name, rows_in_tables, claimed)) + + # A5's bijection is against our own table, not against a declared one. + if 'occurrences.complex.json' in bodies: + ours = json.loads(OURS.read_text()) + theirs = bodies['occurrences.complex.json'] + families = theirs.get('families') + if families is None: + need('A5', 'occurrences.complex.json has no families') + else: + allowed = set(contract['required_exports'][4]['gate']['bins_allowed']) + record('A5', set(map(str, families)) <= allowed, + 'A5 bins %s are within %s' % (sorted(map(str, families)), sorted(allowed))) + for rank, ours_row in ours['inventories'].items(): + mine = {key: ours_row[key] for key in ('items', 'banks', 'capacity_per_bank', + 'children_per_vertex', 'padding_per_bank', + 'bank_table_digest')} + their_row = families.get(rank) or families.get(str(rank)) + if their_row is None: + record('A5', False, 'A5 family %s is missing from the export' % rank) + continue + record('A5', all(their_row.get(key) == value for key, value in mine.items()), + 'A5 family %s matches this package: %s' % (rank, sorted(mine))) + else: + need('A5', 'occurrences.complex.json is absent') + + for entry in results.values(): + if entry['reason'] is None and not entry['passed'] and not entry['failed']: + entry['reason'] = 'no body declares this test yet' + settle() + return results + + +def run(contract, exports_dir, checker=None): + """The whole import: refusal, gate, replay. Returns (exit code, report).""" + rows, missing = refusal(contract, exports_dir) + report = dict(exports_dir=str(exports_dir), bodies=[row['file'] for row in rows], + missing=['%s: %s' % pair for pair in missing], tests={}, replay=None) + if missing: + report['verdict'] = 'REFUSED: %d of %d required bodies are absent and nothing is run' % ( + len(missing), len(rows)) + return 2, report + results = gate(contract, exports_dir) + report['tests'] = {key: dict(status=value['status'], reason=value['reason'], + checks=value['checks']) for key, value in results.items()} + failed = sorted(key for key, value in results.items() if value['status'] == FAIL) + if failed: + report['verdict'] = 'FAILED: %s' % ', '.join(failed) + return 1, report + incomplete = sorted(key for key, value in results.items() if value['status'] == NOT_RUN) + if incomplete: + report['replay'] = dict(status='NOT RUN', reason='the gate cannot decide these tests') + report['verdict'] = 'GATE INCOMPLETE: %s could not be run, so nothing may be discharged' \ + % ', '.join(incomplete) + return 3, report + pinned_checker = contract['import_harness']['replay_requirement']['checker_digest'] + if checker is None: + report['replay'] = dict(status='NOT RUN', reason='no checker supplied', + required='a checker whose sha256 is the digest E3 pins') + report['verdict'] = 'GATE GREEN, REPLAY NOT RUN: the physics is not verified and no ' \ + 'obligation may be discharged on this import alone' + return 3, report + seen = sha256(checker) + report['replay'] = dict(status='RUN' if seen == pinned_checker else 'REFUSED', + checker=str(checker), checker_sha256=seen, pinned=pinned_checker) + if seen != pinned_checker: + report['verdict'] = 'REFUSED: the checker is not the one the contract pins' + return 2, report + done = subprocess.run([sys.executable, '-B', str(checker), str(exports_dir)], + capture_output=True, text=True) + report['replay'].update(returncode=done.returncode, tail=done.stdout[-500:]) + if done.returncode: + report['verdict'] = 'FAILED: the pinned replay checker rejected the exports' + return 1, report + report['verdict'] = 'ADMISSIBLE: gate green and the pinned replay checker passed' + return 0, report + + +def synthetic(directory): + """A minimal set of bodies that satisfies the gate, for the self-test.""" + out = Path(directory) + + def write(name, payload, compress=False): + raw = json.dumps(payload, sort_keys=True).encode('utf-8') + if compress: + raw = gzip.compress(raw) + (out / name).write_bytes(raw) + + write('program.json', {'nodes': 18532, 'inverse_elementary_gates': 58165}) + write('frames.json', {'frames': 18532, 'vectors': 26200, 'edge_basis_values': 42787, + 'id_map': {'0': 0, '1': 1, '2': 2}, + 'conflicting_assignment_rejected': True, + 'color_stats': {'swaps': 733, 'longest_swapped_path': 11}, + 'q_bound': 10 ** 80, + 'prime_witnesses': [{'witness': 7, 'residual_factor': 3}, + {'witness': 11, 'residual_factor': 5}]}) + write('graph.json', {'incoming_dependencies': 24, 'outgoing_dependencies': 8116}) + write('record.json', {'provenance': 'synthetic'}) + write('lift.certificate.json.gz', {'nodes': 18532, 'physical_R': 9412, + 'max_denominator': 2, 'max_abs_numerator': 2}, + compress=True) + write('flow.witness.json', {'monotone': True}) + write('chronology.json', {'tables': [{'target_rows': [0] * 1320, 'source_columns': [0] * 1320}], + 'checked_source_columns': 1320, 'checked_target_rows': 1320, + 'read_counts': {'center': 22, 'deferred': 2310, 'side': 3135}}) + ours = json.loads(OURS.read_text()) + families = {} + for rank, row in ours['inventories'].items(): + families[rank] = {key: row[key] for key in ('items', 'banks', 'capacity_per_bank', + 'children_per_vertex', 'padding_per_bank', + 'bank_table_digest')} + write('occurrences.complex.json', {'families': families}) + write('envelope.json', {'W_per_vertex': 12052, 'deficit_per_vertex': 1320, 'h': 22, 'v': 1320}) + write('integrity.json', {'files': {name: sha256(out / name) + for name in sorted(p.name for p in out.iterdir())}}) + return out + + +def self_test(contract): + """Prove the harness works and rejects, on synthetic bodies, while no real body exists.""" + observed = {} + + def fresh(directory): + synthetic(directory) + patched = json.loads(json.dumps(contract)) + for export in patched['required_exports']: + for body in export['bodies']: + path = Path(directory) / body['file'] + if body.get('anchored_digest') is not None or path.is_file(): + if body.get('anchored_digest') is not None or body['file'] in ( + 'occurrences.complex.json', 'chronology.json', 'envelope.json', + 'integrity.json'): + if body.get('anchored_digest') is not None: + body['anchored_digest'] = sha256(path) + return patched + + def code(patched, directory, checker=None): + return run(patched, directory, checker)[0] + + with tempfile.TemporaryDirectory() as tmp: + patched = fresh(tmp) + observed['gate green without a checker'] = code(patched, tmp) == 3 + + # A1: tamper a body after the contract was anchored to its pristine hash. + patched = fresh(tmp) + (Path(tmp) / 'frames.json').write_bytes(b'{"frames": 18532}') + observed['A1 rejects a tampered body'] = code(patched, tmp) == 1 + + # A2: a wrong cardinality in the program. + patched = fresh(tmp) + body = json.loads((Path(tmp) / 'program.json').read_text()) + body['nodes'] = 18531 + (Path(tmp) / 'program.json').write_text(json.dumps(body)) + (Path(tmp) / 'integrity.json').write_text(json.dumps( + {'files': {p.name: sha256(p) for p in Path(tmp).iterdir()}})) + observed['A2 rejects a wrong cardinality'] = code(patched, tmp) == 1 + + # A3: a denominator above the published bound. + patched = fresh(tmp) + with gzip.open(Path(tmp) / 'lift.certificate.json.gz', 'wt') as handle: + json.dump({'nodes': 18532, 'physical_R': 9412, 'max_denominator': 3, + 'max_abs_numerator': 2}, handle) + (Path(tmp) / 'integrity.json').write_text(json.dumps( + {'files': {p.name: sha256(p) for p in Path(tmp).iterdir()}})) + observed['A3 rejects a denominator above the bound'] = code(patched, tmp) == 1 + + # A4: counts quoted rather than counted out of the tables. + patched = fresh(tmp) + body = json.loads((Path(tmp) / 'chronology.json').read_text()) + body['tables'] = [{'target_rows': [], 'source_columns': []}] + (Path(tmp) / 'chronology.json').write_text(json.dumps(body)) + (Path(tmp) / 'integrity.json').write_text(json.dumps( + {'files': {p.name: sha256(p) for p in Path(tmp).iterdir()}})) + observed['A4 rejects counts not coming out of the tables'] = code(patched, tmp) == 1 + + # A5: a family digest that is not ours, and a bin outside the ledger. + patched = fresh(tmp) + body = json.loads((Path(tmp) / 'occurrences.complex.json').read_text()) + body['families']['16']['bank_table_digest'] = 'ff' * 32 + body['families']['12'] = body['families']['16'] + (Path(tmp) / 'occurrences.complex.json').write_text(json.dumps(body)) + (Path(tmp) / 'integrity.json').write_text(json.dumps( + {'files': {p.name: sha256(p) for p in Path(tmp).iterdir()}})) + observed['A5 rejects a foreign table and a foreign bin'] = code(patched, tmp) == 1 + + # A6: a conflicting colouring accepted. + patched = fresh(tmp) + body = json.loads((Path(tmp) / 'frames.json').read_text()) + body['conflicting_assignment_rejected'] = False + (Path(tmp) / 'frames.json').write_text(json.dumps(body)) + (Path(tmp) / 'integrity.json').write_text(json.dumps( + {'files': {p.name: sha256(p) for p in Path(tmp).iterdir()}})) + observed['A6 rejects an accepted conflict'] = code(patched, tmp) == 1 + + # A7: a repeated witness. + patched = fresh(tmp) + body = json.loads((Path(tmp) / 'frames.json').read_text()) + body['prime_witnesses'] = [{'witness': 7, 'residual_factor': 3}, + {'witness': 7, 'residual_factor': 5}] + (Path(tmp) / 'frames.json').write_text(json.dumps(body)) + (Path(tmp) / 'integrity.json').write_text(json.dumps( + {'files': {p.name: sha256(p) for p in Path(tmp).iterdir()}})) + observed['A7 rejects a repeated witness'] = code(patched, tmp) == 1 + + # Refusal: one body removed. + patched = fresh(tmp) + (Path(tmp) / 'envelope.json').unlink() + observed['refuses when a body is absent'] = code(patched, tmp) == 2 + + # Replay: a checker that is not the pinned one, then one that is and passes. + patched = fresh(tmp) + checker = Path(tmp) / 'checker.py' + checker.write_text('raise SystemExit(0)\n') + observed['refuses a checker the contract does not pin'] = code(patched, tmp, checker) == 2 + patched['import_harness']['replay_requirement']['checker_digest'] = sha256(checker) + observed['admits a pinned checker that passes and certifies the import'] = \ + code(patched, tmp, checker) == 0 + + # Absent today: the real exports directory does not exist. + observed['refuses the real drop, which does not exist yet'] = \ + code(contract, HERE / 'exports') == 2 + + return observed + + +def main(): + parser = argparse.ArgumentParser(description=__doc__, + formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument('--exports', type=Path, default=None, + help='directory holding the published bodies') + parser.add_argument('--checker', type=Path, default=None, + help='the supplier checker whose digest E3 pins (enables the replay)') + parser.add_argument('--self-test', action='store_true', + help='exercise the gate and the refusals on synthetic bodies') + parser.add_argument('--json', action='store_true', help='print the report as JSON') + args = parser.parse_args() + contract = json.loads(CONTRACT.read_text()) + + if args.self_test: + observed = self_test(contract) + for name, ok in observed.items(): + print('%s %s' % ('ok ' if ok else 'FAIL', name)) + failures = [name for name, ok in observed.items() if not ok] + print('self-test: %d checks, %d failed' % (len(observed), len(failures))) + return 1 if failures else 0 + + exports_dir = args.exports or HERE / contract['import_harness']['exports_dir'] + status, report = run(contract, exports_dir, args.checker) + if args.json: + print(json.dumps(report, indent=1, sort_keys=True)) + else: + print('import harness: %s' % report['verdict']) + if report['missing']: + for name in report['missing']: + print(' missing %s' % name) + print(' the contract names each body and the digest it must reproduce; nothing is ' + 'run until they arrive') + for key, value in sorted(report['tests'].items()): + print(' %s %-10s %s' % (key, value['status'], value['reason'] or '')) + if report['replay']: + print(' replay %s %s' % (report['replay'].get('status'), + report['replay'].get('reason', ''))) + print(' required today: %s' % ', '.join(report['bodies'])) + return status + + +if __name__ == '__main__': + sys.set_int_max_str_digits(0) + sys.exit(main()) diff --git a/research/complex-bank-run3/pins.py b/research/complex-bank-run3/pins.py index 015c405e81..eea697bdaf 100644 --- a/research/complex-bank-run3/pins.py +++ b/research/complex-bank-run3/pins.py @@ -14,7 +14,8 @@ VENDORED_RUN1 = 'references/pr219-run1' OWN = ('ledger3.py', 'run3.py', 'schedule66.py', 'schedule66.json', 'prototype66.py', - 'widths66.py', 'suppliers.py', 'instantiate66.py', 'occurrences66.json', 'pins.py', + 'widths66.py', 'suppliers.py', 'instantiate66.py', 'importer66.py', + 'occurrences66.json', 'pins.py', 'obligations.json', 'EXPORT-CONTRACT.md', 'export-contract.json', 'references/pr207-coordinated-crossover.certificate.json') diff --git a/research/complex-bank-run3/verify.py b/research/complex-bank-run3/verify.py index 110ee313e5..bdf1a0cc37 100644 --- a/research/complex-bank-run3/verify.py +++ b/research/complex-bank-run3/verify.py @@ -27,6 +27,7 @@ if hasattr(sys, 'set_int_max_str_digits'): sys.set_int_max_str_digits(0) +import importer66 # noqa: E402 import pins # noqa: E402 import run3 # noqa: E402 import schedule66 # noqa: E402 @@ -287,6 +288,53 @@ def check_unconditionality(): return block +def check_import_harness(): + """The import contract's executable form: coverage, refusals, and that it really works. + + Three things are checked rather than described. The contract must name the module and the + four exit codes; the gate must be able to decide all seven acceptance tests, i.e. every test + appears in some export's declared gate; and the harness's own self-test -- which builds + synthetic bodies and then breaks each check in turn -- must pass every case, so the refusals + it will perform on the real drop are demonstrably real. Finally the real drop, which does + not exist yet, must be refused with the refusal code. + """ + contract = json.loads((HERE / 'export-contract.json').read_text()) + harness = contract['import_harness'] + assert harness['module'] == 'importer66.py' and (HERE / harness['module']).is_file(), \ + 'the contract must name the module that implements it, and it must exist' + assert sorted(harness['exit_codes']) == ['0', '1', '2', '3'], 'all four exit codes' + assert 'gate' in harness['layers'] and 'replay' in harness['layers'], \ + 'the two layers must be described, so that no replay is ever claimed by the gate' + assert harness['replay_requirement']['checker_digest'] == \ + resolve(json.loads((HERE / 'references' / 'pr219-run1' / 'references' + / 'pr193-source-assisted-v4.certificate.json').read_text()), + ['lift', 'checker_sha256']), 'the replay checker digest must be the pinned one' + + declared = set() + for export in contract['required_exports']: + assert export['bodies'], 'every required export must name the bodies it waits for' + assert all(body.get('file') for body in export['bodies']), 'every body needs a file name' + for body in export['bodies']: + if body['anchored_digest'] is not None: + assert len(body['anchored_digest']) == 64, 'anchored digests are sha256 hex' + declared |= set(export['gate']['test']) + tests = {test['id'] for test in contract['acceptance_tests']} + assert declared == tests, \ + 'the gate must be able to decide every acceptance test: %s' % sorted(tests - declared) + + observed = importer66.self_test(contract) + failed = sorted(name for name, ok in observed.items() if not ok) + assert not failed, 'the harness self-test must pass every case: %s' % failed + assert len(observed) >= 10, 'the self-test must exercise the refusals too' + code, report = importer66.run(contract, HERE / harness['exports_dir']) + assert code == 2 and report['missing'], \ + 'the real drop must still be refused: nothing has been published yet' + assert len(report['missing']) == sum(len(export['bodies']) + for export in contract['required_exports']), \ + 'every required body is missing today' + return dict(observed=observed, missing=len(report['missing']), verdict=report['verdict']) + + def resolve(node, keys): """Walk a citation's key list through a pinned JSON document.""" for key in keys: @@ -392,6 +440,7 @@ def main(): check_obligations() unconditionality = check_unconditionality() contract = check_export_contract() + harness = check_import_harness() target = HERE / 'certificate.json' if args.write: (HERE / 'SOURCE.json').write_text( @@ -424,6 +473,9 @@ def main(): % (record['construction']['totals']['items'], record['construction']['totals']['banks'], record['construction']['totals']['padding_registers'])) + print('import harness self-test %d/%d, %d bodies still missing: %s' + % (sum(1 for ok in harness['observed'].values() if ok), len(harness['observed']), + harness['missing'], harness['verdict'][:58])) print('export contract %d exports (%s), %d acceptance tests, bodies exported today: %d/%d' % (len(contract['required_exports']), ','.join(export['id'] for export in contract['required_exports']), From e2189f4717eebb5664c20c95924603909d17a47b Mon Sep 17 00:00:00 2001 From: maxime-fleury Date: Sat, 10 Oct 2026 00:16:16 +0200 Subject: [PATCH 11/11] Record the harness in the certificate's pin manifest MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adding importer66.py to the package changes the manifest the certificate embeds as source_pins, so the certificate is regenerated rather than left describing a pin set that no longer exists. 🤖 Generated with Codebuff Co-Authored-By: Codebuff --- research/complex-bank-run3/certificate.json | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/research/complex-bank-run3/certificate.json b/research/complex-bank-run3/certificate.json index 5023eb035a..b965a9955a 100644 --- a/research/complex-bank-run3/certificate.json +++ b/research/complex-bank-run3/certificate.json @@ -913,12 +913,13 @@ ], "source_pins": { "EXPORT-CONTRACT.md": "7a6a3e7ef9ee5050901291a78e317a0043d4de84d3074d7dbc84c3fbf8fec3b1", - "export-contract.json": "200ce8bba7f381bedf9ffe057d79fefd437d62042cf691b27c15f1d406be1991", + "export-contract.json": "b1d5cab7277d2b5f4302d754b33c31f60ec2cccdf79e5cf97951cb4f589cc74f", + "importer66.py": "09e66969ec2b5757feadadfca4c5992661ddcad7af7e071cb4ad294e62b024e0", "instantiate66.py": "add272a8507bf81810fe36a8e9193afcca5fa708d9149a6700868f01c99075a2", "ledger3.py": "202591f64e76002dd0bc05e7d0c36214db85faf9261bb1757bfb0ca568cc53cd", "obligations.json": "079618259a5596468ce7e617802f2b10157293e64612ca5d60ee7291e76d209b", "occurrences66.json": "d755258f115236356ee1b34a84ee98414eee42dd9eeb4f7034abf39b0dac5653", - "pins.py": "7b184cd9fdd14a11e395a2214caf85f6a08a967acb13b5853e7d60a4253734b8", + "pins.py": "8b407d1701edd638d9c7acf0471534ee7bd13cb085b02037cd4a2c4638bb32cd", "prototype66.py": "74adbe605ceba533cba1e38b0eca466f67961f4a41e9c839094faa9d503dc2cc", "references/pr207-coordinated-crossover.certificate.json": "f4e30cca369fb014b729df870ca3716cc0f1e2297b9f265341492cba85a14aeb", "references/pr219-run1/NOTICE.md": "1f04b17404663a0983b7cc45e308e577d4d49fb6a4c1ff077dc3f13bae83c56f",