From 894a3edbcd90fc379a277eb07a5ae2b706c7a8e1 Mon Sep 17 00:00:00 2001 From: Dugongue <49054532+Dugongue@users.noreply.github.com> Date: Thu, 15 Oct 2026 22:48:08 -0700 Subject: [PATCH] Add files via upload --- research/kappa-action-theory/ACTION-ROUTES.md | 80 + research/kappa-action-theory/BRANCH.txt | 1 + research/kappa-action-theory/CREDITS.md | 19 + research/kappa-action-theory/FRONTIER.md | 36 + research/kappa-action-theory/INDEX.md | 416 + research/kappa-action-theory/LICENSE | 201 + research/kappa-action-theory/MANIFEST.json | 211 + research/kappa-action-theory/NOTICE | 7 + research/kappa-action-theory/PR-BODY.md | 7 + research/kappa-action-theory/PR-TITLE.txt | 1 + research/kappa-action-theory/README.md | 24 + research/kappa-action-theory/RELEASE.json | 37 + research/kappa-action-theory/RESEARCH-PLAN.md | 11 + research/kappa-action-theory/REVIEW.md | 16 + research/kappa-action-theory/THEOREMS.json | 7580 +++++++++++++++++ research/kappa-action-theory/UPLOAD.md | 18 + .../kappa-action-theory/check_collection.py | 62 + .../kappa-action-theory/indexes/ANALYTIC.json | 1070 +++ .../kappa-action-theory/indexes/NATIVE.json | 1697 ++++ .../kappa-action-theory/indexes/PHYSICAL.json | 1348 +++ .../kappa-action-theory/indexes/TENSOR.json | 1729 ++++ .../provenance/BOUNDED-CENSUS.json | 1590 ++++ .../provenance/DAG-NOTE-REFRESH.json | 11 + .../provenance/FINAL-CALLER-MAP-PIN.json | 5 + .../provenance/FINAL-MAIN-SOURCES.json | 62 + .../provenance/FINAL-REFRESH.json | 20 + .../provenance/FINAL-SOURCE-PINS.json | 98 + .../provenance/LOCAL-SOURCE-GUARDS.json | 236 + .../provenance/ROOT-LOCAL-PRECEDENTS.json | 169 + .../provenance/VOLUME-PINS.json | 30 + .../reviews/ANALYTIC-self-review.md | 118 + .../reviews/NATIVE-reviews-TENSOR.md | 73 + .../reviews/NATIVE-self-review.md | 123 + .../reviews/PHYSICAL-reviews-NATIVE.md | 32 + .../reviews/PHYSICAL-self-review.md | 37 + .../reviews/ROOT-reviews-PHYSICAL.md | 116 + .../reviews/TENSOR-reviews-ANALYTIC.md | 45 + .../reviews/TENSOR-self-review.md | 176 + .../kappa-action-theory/volumes/01-native.md | 1044 +++ .../volumes/02-physical.md | 1053 +++ .../kappa-action-theory/volumes/03-tensor.md | 737 ++ .../volumes/04-analytic.md | 1209 +++ 42 files changed, 21555 insertions(+) create mode 100644 research/kappa-action-theory/ACTION-ROUTES.md create mode 100644 research/kappa-action-theory/BRANCH.txt create mode 100644 research/kappa-action-theory/CREDITS.md create mode 100644 research/kappa-action-theory/FRONTIER.md create mode 100644 research/kappa-action-theory/INDEX.md create mode 100644 research/kappa-action-theory/LICENSE create mode 100644 research/kappa-action-theory/MANIFEST.json create mode 100644 research/kappa-action-theory/NOTICE create mode 100644 research/kappa-action-theory/PR-BODY.md create mode 100644 research/kappa-action-theory/PR-TITLE.txt create mode 100644 research/kappa-action-theory/README.md create mode 100644 research/kappa-action-theory/RELEASE.json create mode 100644 research/kappa-action-theory/RESEARCH-PLAN.md create mode 100644 research/kappa-action-theory/REVIEW.md create mode 100644 research/kappa-action-theory/THEOREMS.json create mode 100644 research/kappa-action-theory/UPLOAD.md create mode 100644 research/kappa-action-theory/check_collection.py create mode 100644 research/kappa-action-theory/indexes/ANALYTIC.json create mode 100644 research/kappa-action-theory/indexes/NATIVE.json create mode 100644 research/kappa-action-theory/indexes/PHYSICAL.json create mode 100644 research/kappa-action-theory/indexes/TENSOR.json create mode 100644 research/kappa-action-theory/provenance/BOUNDED-CENSUS.json create mode 100644 research/kappa-action-theory/provenance/DAG-NOTE-REFRESH.json create mode 100644 research/kappa-action-theory/provenance/FINAL-CALLER-MAP-PIN.json create mode 100644 research/kappa-action-theory/provenance/FINAL-MAIN-SOURCES.json create mode 100644 research/kappa-action-theory/provenance/FINAL-REFRESH.json create mode 100644 research/kappa-action-theory/provenance/FINAL-SOURCE-PINS.json create mode 100644 research/kappa-action-theory/provenance/LOCAL-SOURCE-GUARDS.json create mode 100644 research/kappa-action-theory/provenance/ROOT-LOCAL-PRECEDENTS.json create mode 100644 research/kappa-action-theory/provenance/VOLUME-PINS.json create mode 100644 research/kappa-action-theory/reviews/ANALYTIC-self-review.md create mode 100644 research/kappa-action-theory/reviews/NATIVE-reviews-TENSOR.md create mode 100644 research/kappa-action-theory/reviews/NATIVE-self-review.md create mode 100644 research/kappa-action-theory/reviews/PHYSICAL-reviews-NATIVE.md create mode 100644 research/kappa-action-theory/reviews/PHYSICAL-self-review.md create mode 100644 research/kappa-action-theory/reviews/ROOT-reviews-PHYSICAL.md create mode 100644 research/kappa-action-theory/reviews/TENSOR-reviews-ANALYTIC.md create mode 100644 research/kappa-action-theory/reviews/TENSOR-self-review.md create mode 100644 research/kappa-action-theory/volumes/01-native.md create mode 100644 research/kappa-action-theory/volumes/02-physical.md create mode 100644 research/kappa-action-theory/volumes/03-tensor.md create mode 100644 research/kappa-action-theory/volumes/04-analytic.md diff --git a/research/kappa-action-theory/ACTION-ROUTES.md b/research/kappa-action-theory/ACTION-ROUTES.md new file mode 100644 index 0000000000..e82f60847a --- /dev/null +++ b/research/kappa-action-theory/ACTION-ROUTES.md @@ -0,0 +1,80 @@ +# Concrete routes from the theorems to a better complete contract + +The actionable unit is a constructed word, recovered map or certified budget. A future κ improvement requires its **complete** caller invoice and uniform outer interface to improve. The routes below identify actual inputs, delivered objects, payment and the first useful application. They are research recipes justified by the numbered sufficient results, not claims that the current multiplier already meets every premise. + +## 1. A changed helper word with a proved arbitrary-dirt response + +Start from the literal `A`, `compensation`, `cleanup`, `start_extra`, `helper_final`, `warps` and `cut` fields of the pinned PR #2857 words, rather than from their rank histogram. Extract their exact response columns and source footprints. N003–N020 emit kernel charts fixing declared protected helpers; N094–N096 compute the actual effect of staged insertions, including the ordered two-insertion cross term. N097 supplies a source borrow along a verified dirty-response kernel. N099 tests every declared input/dirt column and N100 emits the compensated forward/cleanup word. + +The deliverable to the next worker is a literal changed word, its complete response matrix, a proof of restored inputs and an expanded scalar/native transition ledger. A006 prices favorable and unfavorable width changes together; A008/A009 permit safe price/exponent intervals; A001 composes genuinely disjoint gains. A positive complete saving then has a quantified adapter allowance by A002–A005 and a symbolic exponent interval by A011–A018. No gain follows merely from deleting a compensation column: chart creation, inverse cleanup, source reads and frame transitions remain paid. The existing #2857 quartet is credited background, not a new instance of this route. + +## 2. A consumer that repairs its actual order, or avoids repeated physical work + +Use the real PR #2850 emitter/invoice and #2859 literal consumer permutation. P006/P058 derive its actual crossing phase, and P012–P019 turn that phase into finite returned-bank circuits. P091 realizes a caller-fixed correction physically, with rank charts, full operand volume and wrappers. P092 provides a completely corrected aggregate producer, not the predecessor's invalid uncorrected aggregate shortcut. P056 constructs a specific encoded assignment beyond the restricted one-bit-per-column model, with its increased controls charged. + +There is also a guaranteed finite improvement independent of a speculative new caller: P080 changes each two-cell butterfly's output order to high-address then low-address after both outputs are computed. For N cells and address stride h=2ᵃ, the total return-to-zero travel drops by exactly Nh while additions, halvings, accesses and eight private real slots remain. P073 can further remove only genuine inter-record returns; P078 licenses record reordering only with disjoint supports. These are alternative emitted schedules; a frozen predecessor invoice is not silently edited. + +If a real unobserved common-chart region contains several closed Q jobs, P100 replaces it by the actual phase-sum controller, with two rank-r C children and all charts paid. P098 similarly compiles a monomial wrapper run into one table, counting both its LN generation and execution. The next worker should return the changed literal emitter, full endpoint identity, new prefix grid/range bounds and actual movement/control ledger. A035–A040/A091–A095 allocate deterministic precision; A019/A056 admit only improvements surviving every integration charge. Existing all-size unit-shear #2776 and whole-word grid #2772 remain separate credited components. + +## 3. A usable tensor certificate, rather than bare orbit existence + +The input is an actual labelled bilinear coefficient table or a supplied finite query certificate. T006/T038 verify or recover the complete table with charged probes; T030 returns an actual common-label matching from normalized coefficients; T033–T040 construct frames, ratio maps and a decoder from explicit finite data. T081–T090 supply recovery algorithms only for their declared restricted transporter instances. No theorem assumes that arbitrary tensor isomorphism has an efficient recovery oracle, or that TI = TI_SL has been proved. + +Then choose an explicit transformation: T001/T002 fuse queries while modifying the decoder; T014 aligns a tree of actual label frames; T026 prices tensor-power adapters by fibres; T041–T050 perform scalar descent with actual maps. T051–T060/T071–T080 recover exact coefficient responses from sampled or border certificates, counting interpolation, jets, roots, denominators and reconstruction. T091–T100 provide concrete matrix/convolution/residue/NTT arithmetic children with label and bit costs. + +The output is a certificate with recovered maps, finite operation/bit/workspace bounds, source embedding and a complete decoder. It is a **changed tensor/block-query consumer**; the existing native C operation is linear and cannot be replaced by bilinear rank arithmetic alone. A real compatible source realization and paid native/physical adapter are required. N021–N030 can implement an explicitly factored linear response, and P088 can implement a specified binary phase matrix, but neither supplies a universal conversion from an arbitrary bilinear certificate. Evaluate the resulting actual profile through A007/A010/A024/A032/A059, keeping exact live normalization and full operand volume. + +## 4. Preserve a strict reserve through precision, resources and uniform execution + +Take the actual complete profile and concrete error/source bounds produced by a construction. A033–A040 and A071–A080/A091–A095 give deterministic magnitude, coupled-error, quotient and exact-output budgets; shared error symbols may cancel only when their reuse is real. A030/A086–A090 allocate fraction fields under the actual price/shared-field constraints. A063–A065 control half-rank parity and dyadic grids; they complement T064's general denominator ledger. A096/A097 output explicit scratch/recursive-space schedules, and A098 supplies a bit-growth bound for a fixed dyadic word across logarithmic depth. + +For a typed recurrence, construct a positive weight certificate by A052–A055, rationalize it using A060, and charge every returning adapter with A056. A041–A049/A051/A057 then prove bounds from the actual implementation recurrences; A066–A070 retain finite bootstrap and outer losses. A100 assembles only a fully specified uniform implementation. Use the existing all-size logical caller #2753 and current storage successor map to identify the actual physical/H2/outer boundary, rather than rebuilding or ignoring that caller. + +## Coverage of every numbered theorem + +The [400-entry index](INDEX.md) gives each theorem's concrete action. The chapter map below assigns every ID to a delivered interface; the chapters are collections of different constructions, not 40 claims of attained global improvement. + +| IDs | Delivered objects or quantitative decisions | +| --- | --- | +| N001–N010 | Compensated dirty-response words, quotient consumers and correction transport | +| N011–N020 | Explicit protected/kernel/compression charts and their emitted costs | +| N021–N030 | Shared low-rank, tree, polynomial and structured-response circuits | +| N031–N040 | Ordered crossing repairs, legal rescheduling and triangular/path response words | +| N041–N050 | Actual inverse cleanup, source-consuming interfaces and invariant consumers | +| N051–N060 | Checked block/low-rank/nilpotent/structured solve and chart circuits | +| N061–N070 | Legal frame schedules, paid common entrances and constrained kernel words | +| N071–N080 | Reversible coefficient synthesis, denominator/gauge certificates and explicit inverse data | +| N081–N090 | Transposed/complex/sliding/laminar multioutput circuits and dirt localization | +| N091–N100 | Credited quartet reconstruction, staged insertion corrections and full local assembly | +| P001–P010 | Complete arbitrary-dirt consumers, reverse returns and paid order/label corrections | +| P011–P020 | Actual crossing-error circuits and fully paid physical-basis corrections | +| P021–P030 | Encoded/source-promised/affine/quadratic bank charts with exact signs | +| P031–P040 | Split, block, tensor, sparse graph and selector phase consumers | +| P041–P050 | Genuine subsystem release, dirty borrowing, timed allocation and live-bank migration | +| P051–P060 | Caller-respecting corrected schedules, allowed locations and encoded/fused controls | +| P061–P070 | Operand-preserving endpoint, Fourier, affine, window and Clifford adapters | +| P071–P080 | Literal records, cycle routing and the proved reverse-write movement saving | +| P081–P090 | Full-array sign/translation/Walsh/Q realizations and a finite bit-machine bill | +| P091–P100 | Corrected live-frontier physical assemblies, accumulator writes and common-chart fusion | +| T001–T010 | Fused/cached/shared query and decoder constructions | +| T011–T020 | Actual common-label alignment, joins, invariant-source compression and batching | +| T021–T030 | Paid tensor/basis/gauge/transpose adapters and deterministic label recovery | +| T031–T040 | Explicit matrix-unit, ratio, table, transporter and decoder recovery | +| T041–T050 | Extension-field, prime-field, trace, modular and basis descent | +| T051–T060 | Sample/jet/small-field/modular exact response reconstruction | +| T061–T070 | Rational, dyadic, extension, signed-radix, CRT and bit-cost implementations | +| T071–T080 | Constructive restriction, degeneration, character and finite-difference recovery | +| T081–T090 | Exact recovery for stated restricted transporter and normalization instances | +| T091–T100 | Fully labelled matrix, convolution, residue and NTT–CRT–carry children | +| A001–A010 | Explicit complete saving and live-normalization allowances | +| A011–A020 | Positive common-exponent/outer-margin intervals and caller gain propagation | +| A021–A030 | Finite amortization/potential/selection constructions and precision allocation | +| A031–A040 | Sufficient complete deficit/stock, prefix, rounding and feedback certificates | +| A041–A050 | Actual scalar/adaptive/alternating/log-scale uniform recurrence bounds | +| A051–A060 | Constructive typed-state contraction and adapter-reserve certificates | +| A061–A070 | Active grids, parity, finite bootstraps and paid outer parameter transfer | +| A071–A080 | Coupled nonlinear errors, explicit integer recovery and visible-quotient budgets | +| A081–A090 | Exact finite certificate arithmetic and optimal declared precision plans | +| A091–A100 | Correlated/lattice/integral rounding, resource schedules and complete symbolic admission | + +Nearby cross-volume results retain different outputs: N042/N081 transpose an actual reversible scalar response, while T028/T029 transpose query/decoder maps with labels; N074 records a native denominator-depth convention, T064 a rational circuit ledger and A065 its least dyadic assignment; P099 absorbs an actual physical symmetry, while T022 cancels adjacent supplied tensor adapters. None licenses an unpriced conversion between those models. diff --git a/research/kappa-action-theory/BRANCH.txt b/research/kappa-action-theory/BRANCH.txt new file mode 100644 index 0000000000..6c122b7ced --- /dev/null +++ b/research/kappa-action-theory/BRANCH.txt @@ -0,0 +1 @@ +research/kappa-action-theory-400-20261015 diff --git a/research/kappa-action-theory/CREDITS.md b/research/kappa-action-theory/CREDITS.md new file mode 100644 index 0000000000..61ce86552f --- /dev/null +++ b/research/kappa-action-theory/CREDITS.md @@ -0,0 +1,19 @@ +# Attribution and overlap + +Prepared with substantial OpenAI Codex assistance by the root and three Codex agents, including derivation, actual source inspection, author readback, cross-review and packaging. No independent human review, maintainer acceptance, formal verification or global novelty is claimed. The 400 results are complete informal constructive/sufficiency proofs in their stated models; many use classical ideas. + +The previous pure-math atlas [#2849](https://github.com/CrocSwap/integer-mult-bounds/pull/2849) and its concrete applications [#2855](https://github.com/CrocSwap/integer-mult-bounds/pull/2855) are acknowledged as earlier project work. They are not re-counted as 400 new generic facts. Dugongue's [#2839](https://github.com/CrocSwap/integer-mult-bounds/pull/2839) supplies the actual tensor-block norm/replica and owner interfaces used as scoped precedents. The complete inherited norm, chart and private-work hypotheses remain necessary to apply that source. + +Jeremy Kothe / jeremykothe2's [#2833](https://github.com/CrocSwap/integer-mult-bounds/pull/2833) supplies dirt-entry native words and their retained lineage. Yiyang / Lyy-iiis's [#2857](https://github.com/CrocSwap/integer-mult-bounds/pull/2857) supplies the actual shared-kernel chart and complete compensation/cleanup, and [#2848](https://github.com/CrocSwap/integer-mult-bounds/pull/2848) supplies interleaving/residue exchange. Philippe Van Velzen / philippeVV's concurrent [#2853](https://github.com/CrocSwap/integer-mult-bounds/pull/2853) identifies the quartet/entrance route with a different paid schedule. Marius-Paul Dumitrean / mdumitrean's [#2843](https://github.com/CrocSwap/integer-mult-bounds/pull/2843) supplies owner-flow/construction lineage and [#2856](https://github.com/CrocSwap/integer-mult-bounds/pull/2856) the vacancy-path method. Our [#2863](https://github.com/CrocSwap/integer-mult-bounds/pull/2863) is the fixed-word/inventory packing attainment, not a bound on changed constructions. Tekalign / tekuuu, David Arias, Mason Hale and the retained native, admission, source and outer contributors keep their original attribution; this collection makes no exclusive method-priority claim. + +Gareth Davidson / bitplane's [#2850](https://github.com/CrocSwap/integer-mult-bounds/pull/2850) supplies the concrete phase-accumulator boundary, emitter, inverse convention, invoice and reverse/tensor controls. Dennis / antunishdPursuit's [#2859](https://github.com/CrocSwap/integer-mult-bounds/pull/2859) supplies the bank-return/cross-phase audit, exact order criterion and restricted assigned-bit optimum. P003, P063, P088, P089 and P093 explicitly reconstruct/extend their methods; these are not claimed first discoveries. The new paid repairs and adapters retain all predecessor phase and volume terms. + +David Arias's [#2776](https://github.com/CrocSwap/integer-mult-bounds/pull/2776) already gives a literal all-size unit ordered-shear machine, building on the ordered-affine stream method and Jose Manuel / jmbarrancoml's selected stream reduction. Jose Manuel's [#2697](https://github.com/CrocSwap/integer-mult-bounds/pull/2697) supplies the first-range BIT node; David Arias's [#2753](https://github.com/CrocSwap/integer-mult-bounds/pull/2753) the all-size logical caller and ledger. Main's source-bound caller/storage map and its component authors are credited: ywz65 [#2688](https://github.com/CrocSwap/integer-mult-bounds/pull/2688), starship-s [#2731](https://github.com/CrocSwap/integer-mult-bounds/pull/2731), and Nick Petalas [#2708](https://github.com/CrocSwap/integer-mult-bounds/pull/2708), [#2743](https://github.com/CrocSwap/integer-mult-bounds/pull/2743), [#2749](https://github.com/CrocSwap/integer-mult-bounds/pull/2749), [#2758](https://github.com/CrocSwap/integer-mult-bounds/pull/2758), [#2759](https://github.com/CrocSwap/integer-mult-bounds/pull/2759). These latter sources were followed through main's inspected scope map; their full proofs are not claimed independently replayed here. + +ywz65's [#2540](https://github.com/CrocSwap/integer-mult-bounds/pull/2540) QQ16 and [#2586](https://github.com/CrocSwap/integer-mult-bounds/pull/2586) P104 supply the decoder/physical-word precedents to the later rounded-line and grid work. Nick Petalas's actual [#2770](https://github.com/CrocSwap/integer-mult-bounds/pull/2770)/[#2778](https://github.com/CrocSwap/integer-mult-bounds/pull/2778) lifetime proofs and [#2771](https://github.com/CrocSwap/integer-mult-bounds/pull/2771)/[#2772](https://github.com/CrocSwap/integer-mult-bounds/pull/2772) rounded-line/whole-word-grid sources retain credit. The grid lineage includes Arham Tahir's #2674/#2665, ywz65's #2586/#2730, Nick Petalas's #2754/#2549/#2550 and Alejandro Zarzuelo Urdiales's Gaussian parity methods. No claim is made that these results already admit a complete favorable supplier. + +The latest overlap read also acknowledges Wentao Li / VictorLiwentao's [#2867](https://github.com/CrocSwap/integer-mult-bounds/pull/2867)/[#2868](https://github.com/CrocSwap/integer-mult-bounds/pull/2868) scoped readout alphabets; digitalis-p's [#2866](https://github.com/CrocSwap/integer-mult-bounds/pull/2866) superseded concentration; and Sagar Thakrar's [#2865](https://github.com/CrocSwap/integer-mult-bounds/pull/2865) audit of tekuuu's #2751 against petalas's #2720. Their reported validation is their evidence, not a replay performed for this collection. DreamingOfClouds's #2862/#2864 and Wentao Li's #2860/#2861 were included in the scope census, not assumed to exhaust unrelated alphabets. + +Classical inputs include elementary transvections and block/Schur/Woodbury identities, reversible compute/uncompute, finite Fourier/Pauli/Clifford algebra, sparse linear circuits, finite-field trace/descent, interpolation, CRT, Strassen/Karatsuba/NTT constructions, integral bipartite flow, convex precision allocation, potentials and strong induction. Specific primary references and exact inspected source paths/hashes appear in the volume ledgers. Tensor methods retain Strassen and Bini's exact/approximate bilinear lineage; no new asymptotic theorem is attributed to a historical identity. + +No upstream executable module or mathematical prose is vendored in this collection. The manuscripts give explicit reconstructions/adaptations and citations. Source-specific copyrights and licenses continue to govern their original sources; this attribution does not replace those notices. Newly authored text and the structural checker are offered under Apache-2.0, with the included LICENSE. Local source/DAG references are provenance, not imported duplicate active modules. diff --git a/research/kappa-action-theory/FRONTIER.md b/research/kappa-action-theory/FRONTIER.md new file mode 100644 index 0000000000..13d2c13372 --- /dev/null +++ b/research/kappa-action-theory/FRONTIER.md @@ -0,0 +1,36 @@ +# Frontier, required interfaces and bounded overlap + +## What the refreshed evidence supports + +The entry snapshot read main `189b527cfe20897b7e91a18f124b7f1e9cc77938`; the completion refresh read main `734ef056148cea45daf9af0bd089a7b5c46fea8f`. Priority revision 5, family status, task catalog, selected result and autoresearch guidance were byte-identical between these heads. The bottleneck brief gained a link to the selected-BIT caller/storage successor map, which was read. Main's selected result and pending conditional proposals are distinct evidence levels; this collection does not change the selected record. [Pinned caller/storage map](https://github.com/CrocSwap/integer-mult-bounds/blob/734ef056148cea45daf9af0bd089a7b5c46fea8f/docs/research/selected-bit-caller-storage-map.md). + +The prior package [#2863](https://github.com/CrocSwap/integer-mult-bounds/pull/2863), head `34328b1d5e5bebac62d5cabec993dfbfd7b2123f`, attains its **fixed native words, inventory and transfer-capacity** packing optimum. That proof is not a global optimum over changed native tables or consumer contracts. Continuing the same frozen packing search is therefore not the selected route here. [#2866](https://github.com/CrocSwap/integer-mult-bounds/pull/2866) explicitly describes its two-copy concentration as superseded by #2863. Its proposal and #2865's audit were read as overlap metadata; their full packages were not replayed here. + +The most useful sufficient constructions are currently those that change a complete executable interface and retain a favorable bill. Four routes are developed in the collection: remove helper response with a paid dirty-state word; repair or redesign an actual phase/order consumer; recover and price real common-label tensor maps; and transfer a fully charged symbolic margin through a uniform precision/recurrence contract. A smaller scalar ADD count or tensor rank alone supplies none of those complete conclusions. + +## Existing results that must retain their scope and credit + +| Existing source | Actual inspected content and relevance | Consequence for this collection | +| --- | --- | --- | +| [#2857, Yiyang / Lyy-iiis](https://github.com/CrocSwap/integer-mult-bounds/pull/2857), `0b2e2537b368a0cade07ce3f71452ea018ebe394` | Actual shared-kernel chart, C_new = C S, staged helper quartets and paid compensation/cleanup; source read through the prior pinned package | N generalizes explicit response constructions; it does not discover that quartet anew | +| [#2850, Gareth Davidson / bitplane](https://github.com/CrocSwap/integer-mult-bounds/pull/2850), `a007c32f992195ad372806db38c9359dd49382ad` | Actual finite phase accumulator, emitter and invoice; literal unfused schedule retains 4f C calls | P reconstructs and extends complete consumers with all wrappers and operand volume paid | +| [#2859, Dennis / antunishdPursuit](https://github.com/CrocSwap/integer-mult-bounds/pull/2859), current readback `186a38eb124bc2fead44ae9d03a6edcf7649c882` | Bank return versus data phase, exact order/cross terms, restricted one-bit-per-column optimum; scientific README/audit/physical bytes match the earlier pinned head | P gives sufficient corrected/encoded consumers beyond that restricted model; no general bank optimum is claimed | +| [#2776, David Arias](https://github.com/CrocSwap/integer-mult-bounds/pull/2776), `7de16285a02ebb45cf46e7501baa7eafa78335e3` | Read actual all-size ordered unit-shear proof: fixed 14 tapes, explicit control and source-preserving inverse/cleanup | An all-size unit shear is already supplied; carry, rational scaling, actual caller allocation and the stronger H2 recurrence are separate | +| [#2771, Nick Petalas](https://github.com/CrocSwap/integer-mult-bounds/pull/2771), `e707681c3f6db70d0432501403e2122794a36ade` | Actual rounded QQ16 line and defect proofs, including state-relative scaling and the remaining whole-caller bill | Theorems A033–A040/A071–A080 supply generic charged error tools, not the first local rounded-line theorem | +| [#2772, Nick Petalas](https://github.com/CrocSwap/integer-mult-bounds/pull/2772), `69ba5a423246a1c9281bdd5c1f51240b454f2aa6` | Actual whole-P104 internal-grid proof, including internal native prefixes and strict-zero erasures | Internal grids already have a source-bound sufficient result; efficient recursive storage/tape, other corrections and complete admission remain distinct | +| [#2770](https://github.com/CrocSwap/integer-mult-bounds/pull/2770), `687372b807f5ec635f6a748c2585fc0090a7dc2a`, and [#2778](https://github.com/CrocSwap/integer-mult-bounds/pull/2778), `6dfdbaa004540f5d89f390a9a78fa38c46d225d6`, Nick Petalas | Read actual source-lifetime arguments for callback/evaluation and form construction, with borrowed entry residents and backing/physical exclusions | A096–A097 are scoped alternative schedule theorems; they do not claim first numerical reserve admission or transfer predecessor constants without a new lifetime check | +| [#2753, David Arias](https://github.com/CrocSwap/integer-mult-bounds/pull/2753), and [#2697, Jose Manuel / jmbarrancoml](https://github.com/CrocSwap/integer-mult-bounds/pull/2697) | Main's inspected caller/storage map distinguishes the all-size logical caller from the first-range node and its physical/H2/outer boundaries; their entire proofs were not independently replayed here | Do not describe an all-size logical caller as absent. This collection's recurrence lemmas apply only to an actual compatible implementation | +| [#2839, Dugongue](https://github.com/CrocSwap/integer-mult-bounds/pull/2839), and [#2855](https://github.com/CrocSwap/integer-mult-bounds/pull/2855) | Actual prior pinned block-owner/replica sources and mixed-fibre proof retain label, private-work and norm premises | Tensor basis/recovery results retain full labels, source embeddings, precision and decoder bills | +| [#2849](https://github.com/CrocSwap/integer-mult-bounds/pull/2849), prior pure-math atlas | Prior generic algebra, geometry, combinatorics and analysis are background | The counted entries add explicit dirt, cost, label or execution conclusions, rather than recounting generic facts | + +The source chain also credits Jeremy Kothe's #2833 dirt-entry/native words, Philippe Van Velzen's #2853 concurrent quartet route, Marius-Paul Dumitrean's #2843 owner-flow and #2856 vacancy method, Yiyang's #2848 interleaving/residue exchange, Tekalign and the retained native/outer/source contributors. These are precedents and inherited attributions, not sources of new κ claims in this collection. + +Recent [#2867](https://github.com/CrocSwap/integer-mult-bounds/pull/2867), head `fc3a2cb3362934b1e34df974e64f9d0acfe07b77`, and [#2868](https://github.com/CrocSwap/integer-mult-bounds/pull/2868), head `0aa5cf439fdf210a455b78b46b16b3c92ca38f87`, by Wentao Li, were read in their actual scoped proof sources. They concern specified shared-dirt and three-repeat partitioned readout alphabets. Their restricted obstructions are not general impossibility theorems and are not counted among this collection's sufficient results. Nearby #2860–#2862/#2864 were inspected for scope/overlap in the bounded census; their classifications/floors are not imported as new universal facts here. + +## What is most necessary to prove next + +A useful next construction must emit a literal compatible changed native or consumer word, including arbitrary-dirt response and cleanup, then account for its complete recursive child profile and all adapter costs. For a tensor route it must return actual maps/labels and an implementable recovery algorithm; mere isomorphism existence is insufficient. For physical reuse it must prove equality of the complete operator, not only returned coordinates. For the all-size multiplier it must bind source access, precision, physical bank placement/erasure, stronger primitive time contracts and the outer borrowing/padding wrapper to the same caller. The present 400 theorems give constructive pieces and quantitative sufficient admission tests for these tasks. They do not assert that all these independent application premises have been simultaneously instantiated. + +## Coverage and evidence limits + +The entry refresh inspected the 100 most recently created and 100 most recently updated PR records. The final refresh inspected 30 in each order, plus the specific source files pinned in provenance and the source ledgers. These are overlapping bounded windows, not a census of all PRs/discussions or unpublished work. Read-only canonical DAG/registered-library searches and selected actual Lean-tree sources supplied precedents; source-only records and old checked snapshots were never promoted to fresh verification. A broad root moment/multiplication query completed with lexical source-only or unreviewed-note hits; those extra hits were not semantically reviewed or used as proof premises. No full-library semantic completeness, priority guarantee or claim that nobody previously used an idea is made. No external package replay, Lean/kernel run or numerical exponent computation was performed for this collection. Actual inspected sources, reported receipts and proved manuscript statements are kept distinct. diff --git a/research/kappa-action-theory/INDEX.md b/research/kappa-action-theory/INDEX.md new file mode 100644 index 0000000000..ed88f73537 --- /dev/null +++ b/research/kappa-action-theory/INDEX.md @@ -0,0 +1,416 @@ +# Index of 400 proved application theorems + +Each ID counts once. The four manuscripts contain the full proofs; JSON repeats them for search and is not another count. Costs and interface hypotheses are part of each theorem. + +## NATIVE: 100 theorems + +- [N001 — Dirty-middle product echo](volumes/01-native.md#n001): Replace an explicitly factored response product in `A`/`compensation` by this no-clean-middle circuit when its full charge is favorable. +- [N002 — Correct orientation of transported compensation](volumes/01-native.md#n002): Generate the exact `compensation` replacement after a changed `A` helper basis, as in the inspected quartet mechanism. +- [N003 — One sparse kernel direction removes a response source](volumes/01-native.md#n003): Turn a verified sparse compensation-kernel vector into an actual `A`/`cleanup` basis word and delete its now-zero compensation source. +- [N004 — Incrementally absorb a newly dependent helper](volumes/01-native.md#n004): Extend an established shared-kernel chart to a new dependent `compensation` column. +- [N005 — Rank-one response bank with one shared aggregate](volumes/01-native.md#n005): Share compensation columns with a common target vector across a complete invocation. +- [N006 — Collect response reads across a known helper trajectory](volumes/01-native.md#n006): Move and share `compensation` reads only after accounting for actual helper prefixes in `A` or `B`. +- [N007 — Explicit quotient consumer erases a dirty response](volumes/01-native.md#n007): Expose a source-consuming quotient output before paying standalone target compensation. +- [N008 — Fuse a residual correction into a known consumer](volumes/01-native.md#n008): Replace separate producer correction and consumer multiplication by the composed `SOURCE` read D C. +- [N009 — Disjoint kernel rewrites compose without cross terms](volumes/01-native.md#n009): Combine independently proved quartet kernel edits before generating one complete `compensation` and inverse `cleanup`. +- [N010 — Defer correction through a fully known helper change](volumes/01-native.md#n010): Retiming `compensation` past a known `B` helper change, with an honest transformed-helper or restored-helper boundary. +- [N011 — Nilpotent kernel stabilizer with a paid implementation](volumes/01-native.md#n011): Search cheap kernel stabilizers that alter `start_extra` geometry while leaving `compensation` unchanged. +- [N012 — One helper chart serving several response banks](volumes/01-native.md#n012): Build a common `A` chart for several target/centre response ledgers instead of independently incompatible rewrites. +- [N013 — Global response compression with explicitly certified pivots](volumes/01-native.md#n013): Compress an actual multi-column `compensation` matrix using its checked dyadic column basis. +- [N014 — Kernel extraction that fixes protected helpers pointwise](volumes/01-native.md#n014): Apply response compression when some `A` helpers are source partners with a fixed input ABI. +- [N015 — Integer two-column compression without dividing a runtime value](volumes/01-native.md#n015): Compress proportional integer `compensation` columns without introducing an unavailable odd-denominator scale. +- [N016 — An annihilating polynomial yields a paid Krylov kernel](volumes/01-native.md#n016): Exploit repeated single-warp response orbits in `A`/`warps` with a verified annihilator. +- [N017 — Fundamental-cycle compensation elimination](volumes/01-native.md#n017): Recognize incidence-like sparse receiver responses and remove entire cycle banks in `compensation`. +- [N018 — Block elimination removes a dense off-diagonal response](volumes/01-native.md#n018): Remove cross-bank compensation using an actual rectangular solve rather than a free Schur-complement label. +- [N019 — Reuse a helper kernel across known target charts](volumes/01-native.md#n019): Reuse verified quartet kernels across `cut`/consumer target bases with honest chart costs. +- [N020 — Signed relabelling transports a kernel word without runtime swaps](volumes/01-native.md#n020): Reuse a proved native kernel edit across the actual `base`/`extra` or symmetry-related source labels. +- [N021 — A certified low-rank factor becomes a restored-input circuit](volumes/01-native.md#n021): Compile a concrete response factor into `compensation` with an honest r-register private contract. +- [N022 — Streaming the same factor with one aggregate](volumes/01-native.md#n022): Realize a large response factor under a one-aggregate `LOCAL` scratch budget. +- [N023 — Share one analysis map across several target banks](volumes/01-native.md#n023): Share a common compensation analysis between multiple receiver groups inside one complete invocation. +- [N024 — Keep an explicitly factored intermediate instead of multiplying it out](volumes/01-native.md#n024): Preserve a useful multi-level response DAG when flattening it would densify `compensation`. +- [N025 — Add a low-rank response correction to an existing supplier](volumes/01-native.md#n025): Repair a changed kernel's small residual response without discarding an already checked native compensation circuit. +- [N026 — Tree aggregation compiles a dense subtree response sparsely](volumes/01-native.md#n026): Replace an incidence-derived dense receiver response by a paid tree word and inverse. +- [N027 — Diagonal-plus-rank-one compensation](volumes/01-native.md#n027): Compile a response whose dense part is a shared mode plus independent local corrections. +- [N028 — Karatsuba response sharing with global uncomputation](volumes/01-native.md#n028): Replace an actual Toeplitz/convolution response block by a checked shared straight-line circuit. +- [N029 — Walsh-structured response with dyadic inverse cleanup](volumes/01-native.md#n029): Share an explicit ±1 receiver block using scalar butterflies, with every inverse and scale paid. +- [N030 — Horner evaluation of a known operator polynomial](volumes/01-native.md#n030): Share repeated-power response reads in a native `compensation`/`B` block. +- [N031 — Fuse identical complete wrappers without commuting their interiors](volumes/01-native.md#n031): Fuse repeated exact entry/exit charts around a block of `A`/`B` reads, paying the retained chart lifetime. +- [N032 — Repair a source-target crossing by its ordered product](volumes/01-native.md#n032): Move a native read across a write to its source only with its explicitly compiled path correction. +- [N033 — Topological rescheduling with read/write footprints](volumes/01-native.md#n033): Construct alternate `A`/`B` schedules for shared entrance frames without silently commuting dependent gates. +- [N034 — A balanced diamond creates an explicit zero dirt direction](volumes/01-native.md#n034): Build new staged kernel schedules with compensating paths rather than requiring each individual read to be dirt-free. +- [N035 — Refactor opposing scalar shears through a permitted unit](volumes/01-native.md#n035): Retiming a two-helper feedback block across a legal diagonal entrance chart. +- [N036 — Construct an explicit block-diagonal preconditioner from four shears](volumes/01-native.md#n036): Generate a coupled native helper preconditioner when an explicit dyadic resolvent is available. +- [N037 — Merge repeated reads on the same directed edge](volumes/01-native.md#n037): Collect adjacent same-source/same-target compensation reads and choose a fully charged emitted word. +- [N038 — A feedback commutator with all residual blocks explicit](volumes/01-native.md#n038): Use a known feedback word as a changed native block with complete residuals and cleanup, rather than dropping its noncentral terms. +- [N039 — Series-parallel response circuits with recursive dirty echoes](volumes/01-native.md#n039): Compile explicit shared response expression trees into candidate native words with an a priori complete invoice. +- [N040 — Acyclic path sums with one triangular sweep and its inverse](volumes/01-native.md#n040): Replace a verified acyclic response path table by a paid sparse staged word. +- [N041 — Construct cleanup by reversing only the non-target word](volumes/01-native.md#n041): Regenerate `cleanup` after a changed `A`/`B` word instead of assuming the old cleanup remains correct. +- [N042 — Transpose and inverse-transpose a complete scalar response](volumes/01-native.md#n042): Produce an explicit `LOCAL` scalar dual before the native frame/phase audit. +- [N043 — A dyadic reflection with exact aggregate cleanup](volumes/01-native.md#n043): Build an explicitly paid norm-preserving helper chart for N002 when its entries are dyadic. +- [N044 — Collision-free logical layers for a bipartite read block](volumes/01-native.md#n044): Generate noncolliding native read batches for later entrance/retention construction. +- [N045 — Balanced dirty aggregation with restored inputs](volumes/01-native.md#n045): Replace a high-fan-in unit-coefficient compensation read by an explicit low-depth aggregate word. +- [N046 — Retain a helper chart as an explicit consumer boundary](volumes/01-native.md#n046): Form a source-consuming `SOURCE` candidate instead of silently dropping `cleanup` from the old ABI. +- [N047 — Mutable-source shear with an explicit inverse](volumes/01-native.md#n047): Build a typed source-consuming preparation/consumer interface with a real inverse word. +- [N048 — Telescope target corrections across source evolution](volumes/01-native.md#n048): Fuse a chain of explicit correction differences in a mutable `SOURCE` schedule. +- [N049 — Omit cleanup only for an explicitly invariant consumer](volumes/01-native.md#n049): Match a changed helper chart to a verified final consumer before deleting its cleanup. +- [N050 — A Schur consumer removes dirt using the returned helper](volumes/01-native.md#n050): Compose preparation and consumer so dirty response is canceled at a changed native boundary. +- [N051 — Two-sided response normalization with both charts charged](volumes/01-native.md#n051): Evaluate a low-complexity normal form without forgetting target-basis restoration in `compensation`. +- [N052 — Full block elimination with a checked Schur block](volumes/01-native.md#n052): Jointly redesign preparation and consumer around an actual Schur response rather than pricing each cross block separately. +- [N053 — Low-rank inverse update as a finite response circuit](volumes/01-native.md#n053): Compile a changed decoder/helper inverse from a small certified correction problem. +- [N054 — A nilpotent inverse without any runtime division](volumes/01-native.md#n054): Realize triangular/nilpotent correction inverses by a bounded explicit word. +- [N055 — Idempotent correction with an allowed scalar unit](volumes/01-native.md#n055): Invert a known projector-like compensation update without a general matrix inversion at runtime. +- [N056 — A square-zero full-bank chart with exact private return](volumes/01-native.md#n056): Build a simultaneous helper gauge from a checked nilpotent response operator. +- [N057 — Dyadic orbit-mean reflection](volumes/01-native.md#n057): Change common-mode receiver coordinates without introducing non-dyadic normalization. +- [N058 — Block-tridiagonal inverse with a sparse retained solve](volumes/01-native.md#n058): Compile a banded native response inverse without materializing its dense inverse matrix. +- [N059 — Arrowhead inverse through one shared aggregate](volumes/01-native.md#n059): Replace an arrowhead correction/decoder block by its charged shared response. +- [N060 — Change only a split helper image and preserve its kernel](volumes/01-native.md#n060): Alter only a chosen response image while preserving protected kernel directions in a helper chart. +- [N061 — One common-frame batch with all promotions listed](volumes/01-native.md#n061): Emit an explicit shared-frame `A` batch and its exact CHILD ledger. +- [N062 — Nested requirements admit a deterministic promotion schedule](volumes/01-native.md#n062): Generate a complete staged reader ledger before comparing shared-kernel schedules. +- [N063 — Equal-frame helper mixing adds no recursive promotion](volumes/01-native.md#n063): Delay a kernel basis change until its actual helper operands have equal frames, as in staged `A` sharing. +- [N064 — A certified common entrance replaces only first climbs](volumes/01-native.md#n064): Turn a proved dirt-entry change into exact first-climb and width edits. +- [N065 — A row-ordered triangular helper word has a monotone flag schedule](volumes/01-native.md#n065): Build a legal staged triangular `A` rewrite without dropping fill-in or inventing demotions. +- [N066 — Full-frame cleanup accepts inverse scalar and monomial words](volumes/01-native.md#n066): Charge changed inverse cleanup honestly while avoiding fictitious extra climbs already absent at FULL. +- [N067 — Componentwise joins avoid a needless global common frame](volumes/01-native.md#n067): Price several disjoint shared-kernel banks separately instead of forcing one global entrance chart. +- [N068 — Move helper mixing across an identical fibre operator](volumes/01-native.md#n068): Retiming a common helper basis through a genuinely identical native child block. +- [N069 — Split a response across explicitly known frame maps](volumes/01-native.md#n069): Construct an early-read/late-read native schedule with its exact transported coefficients. +- [N070 — Solve a constrained legal kernel and emit its word](volumes/01-native.md#n070): Replace unconstrained kernel guesses by an actual frame-legal dirt-entry word. +- [N071 — Compile a matrix-addition program with one clean coefficient register](volumes/01-native.md#n071): Turn a rational `A`/`B`/`compensation` matrix witness into a literal scalar word with a complete private-work contract. +- [N072 — Reuse an addition-chain bank for several coefficient reads](volumes/01-native.md#n072): Share expensive dyadic coefficient analysis across repeated native response reads, while charging retained workspace and cleanup. +- [N073 — Batch a common denominator without dividing a dirty source](volumes/01-native.md#n073): Replace independently synthesized denominators in a compensation row by one explicitly paid aggregate denominator. +- [N074 — Construct a native denominator-depth certificate](volumes/01-native.md#n074): Attach a source-derived denominator-depth table to `LOCAL`, preserving the separate global precision proof. +- [N075 — Signed-digit coefficient words with reversible cleanup](volumes/01-native.md#n075): Compile compensation coefficients using an explicit sparse signed expansion when its complete clean-work charge improves on binary synthesis. +- [N076 — Pay for a dyadic wire gauge before using its coefficient discounts](volumes/01-native.md#n076): Test bit-cost-reducing helper wire scales with their actual entrance and exit charges included. +- [N077 — Solve a bounded tree gauge exactly and emit it](volumes/01-native.md#n077): Produce a certified finite helper-gauge nominee rather than choosing scales from coefficient bit lengths alone. +- [N078 — Build dyadic inverse entries from a determinant certificate](volumes/01-native.md#n078): Replace an assumed rational chart inverse by a concrete dyadic entry witness and runtime charge. +- [N079 — Complete a primitive integer kernel without a unit coordinate](volumes/01-native.md#n079): Turn a primitive integral dirt-kernel direction into an emitted helper chart without illegally dividing by an odd pivot. +- [N080 — A coefficient macro that never erases input-dependent garbage](volumes/01-native.md#n080): Use this macro, rather than an input-dependent scratch erasure, in every compiled native coefficient read. +- [N081 — Reverse accumulation constructs a transposed response circuit](volumes/01-native.md#n081): Obtain an emitted dual response compiler from a shared analysis DAG, including its private work rather than assuming a work-free transpose. +- [N082 — Merge equal linear-analysis nodes with explicit lifetimes](volumes/01-native.md#n082): Deduplicate equal compensation aggregates in a changed native DAG, with a precise cleanup and storage certificate. +- [N083 — Lower complex dyadic reads to real native arithmetic](volumes/01-native.md#n083): Compile complex compensation coefficients into a fully specified real scalar consumer, or reject a proposed physical use lacking the doubled-register interface. +- [N084 — Construct the complex adjoint word through realification](volumes/01-native.md#n084): Generate the scalar part of a dual `LOCAL` program with exact coefficient conjugation and private cleanup. +- [N085 — Three real coefficient analyses for one complex multiplication](volumes/01-native.md#n085): Compare direct four-read and shared three-analysis compilation for actual complex coefficients in a new scalar consumer. +- [N086 — Walk neighboring response rows instead of recomputing them](volumes/01-native.md#n086): Search response-row orders with sparse adjacent differences, then emit the actual analysis walk and inverse. +- [N087 — Compile sliding weighted windows from coefficient jumps](volumes/01-native.md#n087): Recognize and compile piecewise-constant or short-jump response windows without inventing an uncharged source permutation. +- [N088 — Answer a laminar response family with a reversible sum tree](volumes/01-native.md#n088): Share a source analysis bank for genuinely laminar compensation supports, with explicit stored aggregates. +- [N089 — Concentrate common dirt in one output bank by an invertible chart](volumes/01-native.md#n089): Offer a changed `SOURCE` consumer with m−1 dirt-free response channels, while explicitly retaining the common dirty channel and charging any basis restoration. +- [N090 — Localize separable grid dirt to the boundary](volumes/01-native.md#n090): Convert a supplied two-dimensional separable dirt pattern into boundary-only dirty channels for an explicitly changed consumer. +- [N091 — Emit the actual four-helper shared-kernel chart](volumes/01-native.md#n091): Emit and check the PR #2857 quartet chart without confusing its three-gate boundary form with its separately charged staged implementation. +- [N092 — Work-free compression of a repeated response column bank](volumes/01-native.md#n092): Concentrate repeated dirty responses in one existing helper instead of allocating a private sum bank. +- [N093 — Delete inverse pairs across a certified independent interval](volumes/01-native.md#n093): Simplify a newly emitted helper/cleanup word with a replayable cancellation certificate, rather than deleting commuting-looking gates by inspection. +- [N094 — Compute the exact response of one staged insertion](volumes/01-native.md#n094): Evaluate a literal dirt-entry insertion at an internal `A`/`B` cut, preserving noncommuting transport instead of treating it as an entrance basis change. +- [N095 — Retain the cross term of two ordered insertions](volumes/01-native.md#n095): Construct or reject paired staged dirt-entry rewrites using their complete interference term. +- [N096 — Construct paired zero-target-defect insertions](volumes/01-native.md#n096): Emit a coordinated two-cut preconditioner that may change entrance geometry without creating an uncharged target correction. +- [N097 — Borrow source signal along a dirty-response kernel](volumes/01-native.md#n097): Store a controlled source borrow in a compensation-invisible helper direction, with a complete old-ABI restoration path. +- [N098 — Reversibly dilate a possibly singular response without inverting it](volumes/01-native.md#n098): Embed a cheap singular response analysis into a reversible native boundary while retaining the displaced dirt bank for its consumer. +- [N099 — Finite symbolic columns certify arbitrary-dirt endpoints](volumes/01-native.md#n099): Produce a deterministic all-dirt response and restoration certificate for a changed literal word, including every private column restriction. +- [N100 — Assemble a fully compensated local native invocation from a finite word](volumes/01-native.md#n100): Turn an explicitly edited shared-kernel word into a complete local old-ABI supplier, recomputing compensation and cleanup instead of assuming the previous supplier's certificates still apply. + +## PHYSICAL: 100 theorems + +- [P001 — A terminating consumer for every finite Pauli prefix](volumes/02-physical.md#p001): Normalize an open predecessor boundary instead of calling it restored. The repair adds one S, one T and one explicitly charged data sign mask; the prefix bill is retained. Its control tables and sign table are finite objects computed from the displayed sums. +- [P002 — A doubled prefix closes to its aggregate pairing](volumes/02-physical.md#p002): A target F with the explicitly checked identity F=A·B has a two-copy consumer costing twice every instruction of the prefix and no repair. A different target requires the D_{F+A·B} mask and its bill. +- [P003 — Palindromic consumption with no clean bank](volumes/02-physical.md#p003): Use a reverse consumer when the caller admits that order. It uses 2f W instructions, hence 2f S and 2f T, and no correction mask or bank preparation. Any required caller reordering or movement is an additional bill. +- [P004 — Reverse consumers with separately prescribed local phases](volumes/02-physical.md#p004): A consumer may request a different local phase from the producer’s self-pairing, provided it executes the displayed mask. The bill is 2f S, 2f T and at most f data masks, with zero masks omitted. +- [P005 — Quadratic bank echoes produce data phase and return both dirt and gauge](volumes/02-physical.md#p005): Implement a specified bilinear data interaction through an existing quadratic bank gauge. Pay four bank sign masks and four translations; neither the gauge nor either translation is a free resource. +- [P006 — Arbitrary consumer permutation repaired by its actual crossings](volumes/02-physical.md#p006): Keep a caller-required consumer order rather than commuting it for free. The word uses 2f S, 2f T and one charged correction mask. P012–P019 provide smaller explicit circuits for that mask. +- [P007 — A locally corrected adjacent exchange](volumes/02-physical.md#p007): Exchange a producer/consumer pair to meet an actual window, paying one D mask and preserving the other instructions. If Ω_ij is the identically zero function, the correction emits nothing. +- [P008 — Transport through a paid data permutation](volumes/02-physical.md#p008): A consumer may read a changed coordinate chart when the labels are transported explicitly. Pay two W words, R and R⁻¹; a chart is not a promise of unchanged data. +- [P009 — Nontrivial intervening data work that is safe for the open bank](volumes/02-physical.md#p009): Insert only work proved to preserve the two control labels; its full circuit cost is added to two W words. This is an explicit sufficient mutable-data condition, not a deduction from bank return. +- [P010 — Affine label offsets with all linear and global signs paid](volumes/02-physical.md#p010): Reuse an affine rather than purely linear bank encoding without silently discarding its gauge. Pay two W words and at most two linear data phase masks plus one global sign; constants in the controls also require the corresponding bank flips/signs. +- [P011 — A crossing-graph correction from the actual literal schedule](volumes/02-physical.md#p011): Extract edges from the actual schedule, not from a claim that the bank returned. Pay 2f W and one edge mask per listed edge. P016 or P017 may compile several edge masks jointly, but their costs are then substituted explicitly. +- [P012 — A bilinear correction with explicit paired controls](volumes/02-physical.md#p012): A correction never requires an assumed phase oracle. For linear controls the stated word costs 2 wt(A) elementary bank signs and 2 wt(B) controlled XORs; alternatively count four aggregate control maps. All r bank coordinates and all spectator lanes remain in the operand. +- [P013 — Rank corrections serialized through one dirty bank bit](volumes/02-physical.md#p013): Trade active bank width for an explicitly longer schedule. The bill is 4r aggregate maps, or 2Σ wt(a_k) elementary signs plus 2Σ wt(b_k) XORs; bank stock is one bit when r>0. This is a constructive upper bound, not a claim that child volume shrinks. +- [P014 — Bounded-width factor chunks with returned boundaries](volumes/02-physical.md#p014): Choose a concrete bank-width/time tradeoff without invoking a general bank optimum. Aggregate-map count is as stated; elementary control count is the same weighted support sum as P013. Any b-axis basis implementation pays full b-axis children and full operand volume. +- [P015 — Every assigned-bit order has a finite corrected consumer](volumes/02-physical.md#p015): A rank-r factorization yields 2f W plus the explicit 4r scalar-map correction, or four maps on r bank bits. A repaired schedule need not satisfy the old zero-cross-term criterion because its missing data phase is now executed and charged. +- [P016 — Complete bipartite crossing blocks need two phase factors](volumes/02-physical.md#p016): Repair exchanging two fully interacting batches without issuing a separate correction per pair. Pay eight aggregate maps, or 4(|A|+|B|) elementary sign/XOR gates in total. This count includes computing each parity by its elementary controls, not a free parity register. +- [P017 — An edge-parity star cover compiles a crossing correction](volumes/02-physical.md#p017): A concrete star cover with s nonempty stars costs 8s aggregate maps and 4Σ_k(1+|L_k|) elementary gates. One always obtains such a cover by assigning each graph edge to its lower-numbered endpoint. A smaller supplied cover is checked by edge parity, not assumed. +- [P018 — Clique crossing correction by aggregate parity plus diagonals](volumes/02-physical.md#p018): Pay 4(f+1) aggregate maps and exactly 8f elementary linear-control gates before any cancellation optimization. This replaces a quadratic list of separate edge repairs by a linear-size explicit controller, with no free data phase. +- [P019 — Canonical polynomial repair removes all degree-two data phase](volumes/02-physical.md#p019): If t quadratic and ℓ linear coefficients survive, the bill is 4t aggregate bank maps, ℓ data signs and at most one global sign. Coefficient collection uses the literal word’s polynomial, not a claim that returned coordinates imply zero phase. +- [P020 — A fully paid physical-basis correction](volumes/02-physical.md#p020): Charge n forward and n inverse one-axis Walsh transforms, the complete sign-mask controller, all chart translations, and the inverse scale. P085 gives finite butterfly counts and P089 gives the predecessor’s C expansion. This theorem supplies a physical correction even when label access is unavailable; it does not call that correction cheap. +- [P021 — Kernel-preserving changed labels admit the original consumer](volumes/02-physical.md#p021): A source update confined to these kernels is a usable changed-label caller contract. Pay two W words and the full R/R⁻¹ circuits, rather than asserting that the entire source was untouched. +- [P022 — Contravariant consumer controls for invertible label updates](volumes/02-physical.md#p022): Compile the consumer from AL⁻¹ and BK⁻¹. Charge the producer controls, these new consumer supports, and both directions of the L,K circuits. Dense transported controls may cost more than the originals. +- [P023 — Active-bank compaction from a nondegenerate pairing](volumes/02-physical.md#p023): Compile the chart and its inverse by row elimination: each uses at most b(b−1)+3b elementary XORs, counting a row swap as three XORs. Pay both charts and all transformed controls; every spectator lane remains in N. +- [P024 — A promised linear source subspace permits a smaller corrected phase](volumes/02-physical.md#p024): First certify the actual caller’s two linear equations; then explicitly factor a chosen M′ and charge its controls. This is a usable sufficient promised-domain construction, not a free assumption that independent labels satisfy a convenient relation. +- [P025 — Affine source promises retain their exact correction signs](volumes/02-physical.md#p025): Pay the M′ factor controller and both nonzero linear phase masks. Check the affine equations as actual admission facts; a zero-offset theorem cannot justify dropping these masks. +- [P026 — Time-varying bank charts with a literal transport word](volumes/02-physical.md#p026): An actual frame change is paid by the L_jL_{j−1}⁻¹ circuit; all endpoint encoders and transported control supports are also paid. Identity transitions emit no chart. +- [P027 — A quadratic bank gauge has a computable phase-corrected consumer](volumes/02-physical.md#p027): A bank-gauge adapter requires two actual q masks or the transformed controls plus one q(b) data mask. Choose between those explicit bills; do not infer unitarity or free cost from a similarity alone. +- [P028 — Adjacent bank-gauge adapters fuse by polynomial difference](volumes/02-physical.md#p028): Emit the two endpoint gauges and all nonzero differences. If masks are compiled monomial by monomial, the cost is their actual support weight, which can be smaller than 2Σ wt(q_j). This is adapter cancellation at genuine adjacency, not arbitrary phase commutation. +- [P029 — Orthogonal control re-encoding preserves every closed phase](volumes/02-physical.md#p029): Compare the explicitly recomputed support weights of all transformed linear controls. If a bank chart is also physically materialized, pay O and O⁻¹; the identity alone licenses only the closed-word replacement. +- [P030 — Affine bank adapters with the global sign exposed](volumes/02-physical.md#p030): Use a concrete affine location change without losing its central sign. Pay two linear charts, two fixed translations, the transported controls and the possible a·t mask if using the right-side implementation. +- [P031 — Disjoint bank axes allow a literal split controller](volumes/02-physical.md#p031): A wide bank operation may be implemented in separate native axis blocks. Charge both pairs of control maps and both native basis changes when those are used; the factorization itself does not reduce N or grant parallel hardware. +- [P032 — Dependency components compile to tensor-independent circuits](volumes/02-physical.md#p032): Form the actual dependency graph before splitting or reordering. Serial bills add; any parallel schedule also needs its own processor model. In the inherited whole-array model every component child still runs on the full N-cell array. +- [P033 — Block diagonal phase forms give independent returned-bank modules](volumes/02-physical.md#p033): Pay every block factor controller and both directions of the row/column permutations. The bank width may be the maximum block width when returned blocks are serialized. All data/bank/spectator lanes remain counted. +- [P034 — A triangular interaction is three closed physical phases](volumes/02-physical.md#p034): Factor A,B,C separately and pay all three control support sums. Shared-bank stock is at most the maximum supplied factor width; data volume is unchanged. This supplies an explicit off-diagonal consumer rather than omitting triangular cross terms. +- [P035 — A Kronecker interaction has an explicit product-bank circuit](volumes/02-physical.md#p035): The elementary bill is 2 wt(A)wt(C) bank signs and 2 wt(B)wt(D) XORs. Any physical reshaping permutation and its inverse must be emitted. This is not a claim that tensorization preserves a favorable recursion invoice. +- [P036 — Closed block phases reuse one arbitrary bank allocation](volumes/02-physical.md#p036): Replace separate allocated banks by a shared bank only at these closed boundaries. The bill is the sum of the emitted controller bills; no reset, clean preparation or lane deletion is introduced. +- [P037 — A rooted tree phase compiles by parent parity stars](volumes/02-physical.md#p037): If s vertices have children and e edges, the construction uses 4s aggregate maps and 2(s+e) elementary sign/XOR controls. It needs no stored child-parity register: the controls are applied directly to the dirty bank. +- [P038 — A bipartite phase chooses the cheaper explicit parity side](volumes/02-physical.md#p038): With e nonzero entries and r nonzero rows, the row bill is 4r aggregate maps and 2(r+e) elementary controls. With c nonzero columns the column bill is 4c and 2(c+e). Choose the actual smaller paid implementation, retaining any physical basis adapters. +- [P039 — Removing an actual bank-bank quadratic interaction](volumes/02-physical.md#p039): Pay the r four-map factors and one extra live dirty coordinate during correction, unless a previously returned coordinate is explicitly available. A mere return of bank coordinates would not justify omitting the interaction phase. +- [P040 — Selector-controlled phase modules with dirty-bank preservation](volumes/02-physical.md#p040): This is a finite multiplexed consumer with no assumed clean branch flag. Pay all masked-control evaluations or their explicit truth tables, plus the maximum live bank width; no branch is free in a whole-array scan. +- [P041 — Certifying a reusable subbank while another part remains open](volumes/02-physical.md#p041): Compute the actual coordinate sums and reuse precisely their common zero subset, without resetting it. The prefix cost is unchanged; later users pay their own controls. Checking only B_J=0 would be insufficient because A_J may still phase the returned coordinates. +- [P042 — Compute–accumulate–uncompute with one dirty borrowed bit](volumes/02-physical.md#p042): This supplies an actual mutable-output consumer for a borrowed bit. Pay two f-controlled bank translations and two c g-controlled accumulator translations, including whatever finite circuits evaluate f and g. For given truth tables these maps are explicit involutive permutations. +- [P043 — A bank automorphism between producer and consumer is explicitly transportable](volumes/02-physical.md#p043): An intervening bank operation is permitted only with its transported consumer. Pay both chart circuits and both control sets; dense L can increase the control support bill. +- [P044 — An eight-vertex dirty-bank echo for cubic phases](volumes/02-physical.md#p044): Pay eight actual bank-q masks and eight controlled translations. The theorem implements a specified trilinear correction without preparing a bank; it does not assume the cubic mask has a cheap native realization. +- [P045 — An anticommuting scratch pair yields a returned dirty-bank phase](volumes/02-physical.md#p045): Pay eight controlled scratch involutions and two bank translations, plus their concrete control circuits. One may take literal single-bit X and Z on scratch, so no unproved anticommuting gadget is required. +- [P046 — Interval allocation of single-bit bank jobs](volumes/02-physical.md#p046): Emit the same job instructions with fixed physical coordinates; bank stock is b bits. No runtime migration is required by this construction, but descriptor generation and the full N-cell volume remain paid. +- [P047 — Variable-width bank jobs admit a noncontiguous peak-stock allocation](volumes/02-physical.md#p047): Bank stock is B, with no movement if the native interface accepts arbitrary listed axes. If it requires a contiguous block, gathering/scattering must be paid using P061 or P077. This theorem explicitly provides noncontiguous allocation, not a false contiguous-packing claim. +- [P048 — Repairing coordinate return into actual subsystem return](volumes/02-physical.md#p048): Pay wt(R) elementary bank XORs and the explicit correction mask, including inverse-image evaluation or its finite table. For quadratic q and linear b the correction remains quadratic and can be compiled by P019/P039. +- [P049 — Migrating a live bank through arbitrary spare dirt](volumes/02-physical.md#p049): Pay 2b bit swaps, or 6b controlled XORs using three XORs per swap, and U’s full bill. Both bank stocks count during migration. The construction gives a legal location change for an open bank, not a free move to a clean register. +- [P050 — Releasing and reopening an open Pauli summary](volumes/02-physical.md#p050): Pay two extra W words and one A·B data mask for the inverse; physical implementations of all three are explicit. A released bank may serve a closed intervening job, but its use is not free. +- [P051 — Topologically scheduled consumers with exact inversion repairs](volumes/02-physical.md#p051): The constructive output is the actual topological task list, 2f W words and its fully compiled crossing correction. Precedence may encode source windows or data availability, but those obligations must really be present in the graph. +- [P052 — Whole-module exchange uses only aggregate bank response](volumes/02-physical.md#p052): Exchange two actual batches only when their task windows permit it. Pay one aggregate correction, whose binary coefficient matrix can be factored by P012, rather than assuming all pairwise gates commute. Module circuits and their movement bills remain. +- [P053 — A reverse-consumer schedule with explicit release/deadline feasibility](volumes/02-physical.md#p053): This is a computable sufficient caller-window test, not a promise that reversing consumers is always legal. Emit the recurrence’s start times and the literal reverse circuit; charge waiting, durations and movement as chosen. +- [P054 — Physical allowed-bank lists give a sufficient allocation algorithm](volumes/02-physical.md#p054): Emit those actual locations and the unchanged caller order. Pay 2f W words, their native wrappers, any routed access to the assigned bits and the full operand volume of the used physical bank. This is a sufficient list-constrained placement, not a general optimality claim. +- [P055 — Bipartite bank choices can minimize an actual location bill](volumes/02-physical.md#p055): Emit the selected locations; actual routing costs are the supplied c values and must already describe concrete paths. The 4f unfused C-call bill and all full-array lanes remain. +- [P056 — Odd-incidence codes construct a correct encoded bank assignment](volumes/02-physical.md#p056): Bank stock is k plus the number of even-incidence columns. The literal elementary control bill is 4Σ_j wt(g_j), and any physical bank basis calls use their actual active supports and full N. These extra controls are not free merely because the encoding is correct. +- [P057 — Closed batch barriers construct a reusable one-bank schedule](volumes/02-physical.md#p057): Emit the legal batch order and its barriers. The schedule retains 2f W instructions and, in the predecessor’s unfused physical alphabet, 4f one-axis C calls plus all wrappers and barrier control. +- [P058 — Arbitrarily interleaved matched words have a chord correction](volumes/02-physical.md#p058): Use the actual recursively interleaved word, not just a producer-prefix abstraction. Charge its 2f W instructions and compile its explicitly extracted chord correction by P012–P019. +- [P059 — Certified zero-pairings permit dependency-safe rescheduling](volumes/02-physical.md#p059): Reorder only with the explicit zero-pairing and dependency certificate. Instruction counts are unchanged; movement and new task-window charges must be recounted for the selected order. +- [P060 — Producer fusion with its complete correction phase](volumes/02-physical.md#p060): Replace 2f scalar W words by two aggregate W words only together with the charged E implementation and all parity controls. A physical aggregate producer has two bank basis changes, so the pair has four; the correction may erase any apparent benefit and must be expanded as well. +- [P061 — Disjoint role placement by a paid coordinate permutation](volumes/02-physical.md#p061): Emit both endpoint permutations or their explicit swap circuits, plus the controller. No two distinct roles may be placed on the same axis. +- [P062 — Moving an accumulator endpoint without altering its operands](volumes/02-physical.md#p062): Pay U and 2k bit swaps, or 6k elementary XORs. F must have its explicit supplied circuit; for finite F a truth-table permutation is also constructive, but not granted cheap. +- [P063 — The physical chart is the inverse transpose, with a circuit bound](volumes/02-physical.md#p063): Emit the actual inverse-transpose chart and its inverse. Confusing L with L⁻ᵀ changes the physical consumer. +- [P064 — A bank Fourier exchange retains its central sign and scale](volumes/02-physical.md#p064): Use two paid bank basis changes and the retained data sign if implementing the exchanged normal form. Their finite/native expansions are P085 and P089; an inverse scale cannot be dropped. +- [P065 — Affine data re-encoding preserves a phase after explicit masks](volumes/02-physical.md#p065): Pay both directions of both charts, the N phase controller and all nonzero linear/global masks. +- [P066 — A bounded window can move across arbitrary dirty exterior](volumes/02-physical.md#p066): Emit the finite permutation, U and its inverse permutation. Charge every actual cell swap and head path; bounded support is not a license to assume the exterior is blank. +- [P067 — A selector can choose a bank location coherently](volumes/02-physical.md#p067): A literal implementation enumerates k selector values and uses 2kb controlled bit swaps, with each predicate evaluated and paid or tabulated explicitly. Each controlled swap is three controlled XORs. U’s full array volume includes all candidate banks. +- [P068 — Endpoint permutation adapters have an exact transposition bill](volumes/02-physical.md#p068): Pay 6(s−c) XORs if swaps use three XORs each, plus their actual full-array movement bills. The statement counts the explicit construction, not a hardware minimum. +- [P069 — Opposite-polarity output ports can be corrected without bank preparation](volumes/02-physical.md#p069): Pay the mask via P012 or its physical implementation P088/P091. Keep both original controls and every movement operation. This is a small but complete producer/consumer ABI adapter, not a claim that ordering is irrelevant. +- [P070 — A supplied Clifford chart has a fully computable Pauli adapter](volumes/02-physical.md#p070): Either execute G, W, G⁻¹ or the computed controls and scalar table, paying their actual circuits. This does not assume that an arbitrary abstract symplectic matrix has a free implementation. +- [P071 — A two-cell read/read/write/write record has an exact head path](volumes/02-physical.md#p071): Use this literal record for a butterfly or cell swap and charge its actual addresses, not just its gate name. The bill agrees with the predecessor’s declared record convention. +- [P072 — Reverse output visits legally halve the outer excursion](volumes/02-physical.md#p072): Pay 2k real reads and writes each, 4k private-real startup clears once, and up to 4k private-real clears per record, with the arithmetic bill retained. This is a concrete alternative record schedule, not free random access. +- [P073 — Removing only inter-record returns preserves every arithmetic prefix](volumes/02-physical.md#p073): Sum the displayed saving over actual adjacent records; pay all unchanged arithmetic/access/clear/dispatch costs. This is a declared alternative machine schedule, not an omission from the inherited invoice. +- [P074 — Arbitrary coefficient permutations need no second data array](volumes/02-physical.md#p074): Pay 2ℓ real reads and writes each, four private-real clears per cycle plus startup, and the literal cycle-visit head path. Fixed cells require no record. This realizes an arbitrary finite routing map without granting another N-cell operand. +- [P075 — A path transposition restores every intermediate bank axis](volumes/02-physical.md#p075): Pay three axis XORs per axis swap, and then the full coefficient-array permutation cost of each XOR if that is the implementation model. These graph-edge counts are not tape steps. +- [P076 — A live bank can walk to a remote port and return](volumes/02-physical.md#p076): Pay 2d axis swaps, or 6d axis XORs, plus the remote operation and all coefficient movement. For b axes on disjoint supplied paths sum these bills. +- [P077 — Arbitrary axis layouts have a terminating adjacent-swap router](volumes/02-physical.md#p077): A two-sided adapter costs 2K axis swaps, or 6K axis XORs, before their whole-array realization. The router is generated from fixed metadata, not by comparing live data amplitudes. +- [P078 — Disjoint coefficient records may be reordered with an actual support proof](volumes/02-physical.md#p078): Use actual read/write supports to reorder records for a shorter head path, then sum that new path explicitly. Shared-bank or merely similarly named gates do not satisfy the theorem automatically. +- [P079 — Closed travel formula for every butterfly of one axis](volumes/02-physical.md#p079): Add this exact formula for the actual emitted axes and retain every arithmetic/access/scratch charge. It directly reproduces the predecessor’s full-array C-axis movement, including spectators. +- [P080 — Reverse-write butterflies save a paid N·2ᵃ steps per axis](volumes/02-physical.md#p080): Keep the existing eight private real slots for a two-complex-input/two-output butterfly and every arithmetic/halving/clear/access count. Only the declared write order and head route change. This is a constructive finite movement reduction, not a new child-width or κ theorem. +- [P081 — A sign mask has an exact finite scalar-access bill](volumes/02-physical.md#p081): This realizes a finite correction mask without a phase oracle. Pay the mask table/generation and its actual selected-cell traversal. Bank and spectator lanes are included in S. +- [P082 — An arbitrary controlled bank translation is a known swap list](volumes/02-physical.md#p082): Pay four real reads, four real writes and four private-real clears per swap, plus startup and the P071 or P072 route. This explicitly counts every dirty bank lane. +- [P083 — Fusing linear XOR controls has a rank-dependent swap count](volumes/02-physical.md#p083): Choose between the aggregate truth-table swap list and the sparse XOR list, charging generation, storage and actual head paths for that choice. The count does not drop inactive bank lanes from N. +- [P084 — The negative entries of a bilinear sign mask are exactly counted](volumes/02-physical.md#p084): Substitute that exact number into P081’s scalar/access invoice, still paying basis adapters if the labels are Fourier labels. +- [P085 — Dyadic Walsh transforms have literal butterfly programs and inverses](volumes/02-physical.md#p085): Forward arithmetic is 2bN real additions and 2bN halvings; inverse arithmetic is 2bN additions and no halvings. Both retain four real reads/writes and eight private-real clears per butterfly, plus startup and actual movement. Exact-grid admission must guarantee even numerators when halvings are used. +- [P086 — A controlled translation has a paid Fourier-bank implementation](volumes/02-physical.md#p086): Pay two full bank Walsh transforms from P085 and the complete sign pass from P081/P084. This is an actual implementation when translation is unavailable but the specified basis operations exist; it is not a reduction of the bank’s full operand volume. +- [P087 — Every binary bilinear phase has an explicit physical kernel](volumes/02-physical.md#p087): This supplies an explicit reference endpoint on every dirty spectator lane. A direct realization is P020 with the completely enumerated mask, costing both data Walsh directions and the mask. +- [P088 — Rank-normalized physical Q uses two rank-r Walsh children](volumes/02-physical.md#p088): Pay two r-axis Walsh calls, r axis XORs, both directions of both charts and their native wrappers. In the predecessor’s alphabet this means two C_r children, each on the full N cells, not a half-volume child. +- [P089 — The predecessor’s unfused producer has a complete native wrapper count](volumes/02-physical.md#p089): Count two packed XORs per producer as well. The literal inherited denominator counter charges 3b per producer: two C widths plus the positive β scale; the inverse scale is retained rather than erased. This is a sufficient syntactic counter, not a minimal precision bound. +- [P090 — A declared finite record program has an explicit bit-machine implementation](volumes/02-physical.md#p090): This gives a constructive conservative control/ALU bill instead of setting it to zero. Computing the record list itself is not assumed free; if supplied as input, loading writes all descriptor bits. +- [P091 — A caller-fixed shared-bank order always has a bank-free physical repair](volumes/02-physical.md#p091): The unfused predecessor contributes 4f one-axis C calls and all wrappers. If rank E=r, the repair adds two C_r calls, the rank charts and their inverses, r XORs and all phase/scale wrappers, on the same full N. No contraction is asserted from that bill. +- [P092 — Correct aggregate production with arbitrary encoded bank controls](volumes/02-physical.md#p092): Pay four C_b children from the doubled producer, 2wt(A)+2wt(B) axis XORs and the P089 wrappers. A residual of rank r adds two C_r children, its charts/XORs and wrappers. At b=0 omit the producer and use the direct residual. +- [P093 — The ternary C/Q assembly is an all-size physical identity](volumes/02-physical.md#p093): The predecessor’s four packed XOR chart operations and their inverse give eight packed XORs; also pay one C_f, one Q_f, 3f fixed bit translations and every child’s full operand volume. This recovers its exact assembly, not a favorable recursive budget. +- [P094 — Exact child substitution remains valid at open and nested boundaries](volumes/02-physical.md#p094): Sum the replacement leaves and all remaining wrappers exactly once. A fully expanded butterfly bill must not also add its abstract child price. This supplies a constructive two-level or finite-depth emitter contract when using P088/P093; it is not an analytic exponent theorem. +- [P095 — A genuine accumulator write can occur inside an open bank interval](volumes/02-physical.md#p095): Pay both W words, U_F’s explicit permutation circuit and its access/movement bill. If F is a given finite table it is implementable by P074; if F is bilinear, P096 supplies a direct finite program. +- [P096 — A binary bilinear accumulator has a complete finite permutation program](volumes/02-physical.md#p096): Pay tN/8 swaps, four real reads/writes/clears per swap, startup and the exact swap routes. This is a fully finite realization, not an assertion that the predecessor has a cheap Toffoli child or that integer carries disappear. +- [P097 — An arbitrary finite residual phase has a physical table consumer](volumes/02-physical.md#p097): Load 2·2ⁿ phase-table bits, pay both Walsh directions and the actual counts of rotations, reads/writes, clears and head travel. This supplies a constructive nonlinear or fourth-root residual consumer from an explicit table, not from an assumed phase oracle. +- [P098 — Unobserved monomial wrapper runs can be compiled into one exact table](volumes/02-physical.md#p098): Generation performs L N permutation/phase-table lookups and additions and writes N(⌈log₂N⌉+2) output bits. Execution pays the complete rotation pass and P074 cycle routing, not a free fused gate. +- [P099 — Actual C symmetries permit paid chart absorption](volumes/02-physical.md#p099): Emit the same-width C child on the explicitly reindexed axes; omit only these proven adjacent adapters. Recount its head route, charts at other boundaries and all prefix/precision facts. Arbitrary symplectic or dense linear charts are not covered. +- [P100 — Common-label phase jobs fuse into one fully corrected physical consumer](volumes/02-physical.md#p100): A rank-r sum has two C_r children plus the explicit rank charts, XORs, phases, scales and their full-array/bit-machine costs from P088–P090. Compare that complete bill against all original jobs; do not infer a gain from rank alone. Fresh internal-prefix bounds are needed for the replacement, while completed endpoints are exact. + +## TENSOR: 100 theorems + +- [T001 — Proportional-query fusion with a paid decoder](volumes/03-tensor.md#t001): Fuse proportional paired queries and price the changed output vectors +- [T002 — Output-aware common-left-factor fusion](volumes/03-tensor.md#t002): Replace a group whose output vectors have a certified common line +- [T003 — Duplicate input-form caching across labelled outputs](volumes/03-tensor.md#t003): Price one evaluation of each distinct form while retaining all products +- [T004 — Shared response contraction without full output materialization](volumes/03-tensor.md#t004): Compile the consumer's requested linear observables directly +- [T005 — Certified zero-query elimination at a restricted source interface](volumes/03-tensor.md#t005): Delete terms proved zero on the actual allowed input subspaces +- [T006 — Sparse bilinear coefficient verification by basis probes](volumes/03-tensor.md#t006): Certify a proposed replacement table without orbit or recovery assumptions +- [T007 — Common-label multioutput decoding through a pivot subsystem](volumes/03-tensor.md#t007): Recover all requested labels from a smaller certified response basis +- [T008 — One-sided shared-input batch evaluation](volumes/03-tensor.md#t008): Amortize query forms when many independent right operands share one left operand +- [T009 — Decoder composition through exact quotient outputs](volumes/03-tensor.md#t009): Use quotient responses when a supplied section proves exact recoverability +- [T010 — Three-product quadratic-block provider over every commutative ring](volumes/03-tensor.md#t010): Replace four cross products by Karatsuba with exact labelled coefficient recovery +- [T011 — Input-independent label-chart transport](volumes/03-tensor.md#t011): Transport a provider through actual fixed label permutations +- [T012 — Coupled relabelling across a shared intermediate](volumes/03-tensor.md#t012): Fuse adjacent label permutations and cancel their actual inverse adapters +- [T013 — Constructive common-label alignment by a supplied perfect matching](volumes/03-tensor.md#t013): Recover a shared query ordering from verified coefficient equalities +- [T014 — Tree reconstruction of compatible label frames](volumes/03-tensor.md#t014): Recover all common label frames and check every overlap cycle +- [T015 — Query-orbit compression on a verified invariant source](volumes/03-tensor.md#t015): Compress equal query orbits on certified invariant source subspaces +- [T016 — Tensor-product query composition with explicit label pairing](volumes/03-tensor.md#t016): Compose two actual bilinear certificates without a tensor-orbit oracle +- [T017 — Direct-sum batching with protected output namespaces](volumes/03-tensor.md#t017): Batch heterogeneous providers while preserving each original label set +- [T018 — Streaming common-label products with decoder sparsity](volumes/03-tensor.md#t018): Bound live response storage by decoder last-use rather than query count +- [T019 — Translation-covariant response reuse with explicit inputs](volumes/03-tensor.md#t019): Compute a shifted labelled response from an already computed one +- [T020 — Common-label joins through a verified overlap decoder](volumes/03-tensor.md#t020): Glue two response suppliers into one complete output, pricing duplicated overlap +- [T021 — Actual tensor transport with a complete adapter invoice](volumes/03-tensor.md#t021): Use a recovered tensor isomorphism as a usable provider +- [T022 — Cancellation of paid intermediate basis transforms](volumes/03-tensor.md#t022): Remove adjacent inverse adapters by composing actual coefficient tables +- [T023 — Query gauge normalization with exact decoder compensation](volumes/03-tensor.md#t023): Choose canonical nonzero pivots without changing any response +- [T024 — Triangular input transport without a dense inverse](volumes/03-tensor.md#t024): Apply a recovered triangular basis through exact substitution +- [T025 — Elementary arithmetic-factor adapters with certified inverses](volumes/03-tensor.md#t025): Use an actual short factorization of a basis change +- [T026 — Tensor-power adapters through fibres rather than dense tables](volumes/03-tensor.md#t026): Price repeated factorwise basis changes on tensor queries +- [T027 — Integral unimodular query transport with no rational denominators](volumes/03-tensor.md#t027): Keep a changed query basis inside the integer compiler +- [T028 — Bilinear adjoint provider with all labels exposed](volumes/03-tensor.md#t028): Reuse a certificate for a different queried contraction +- [T029 — Transposed linear-query circuit with explicit fanout accounting](volumes/03-tensor.md#t029): Compile a recovery map's transpose from its actual straight-line program +- [T030 — Deterministic recovery of common query labels from coefficients](volumes/03-tensor.md#t030): Recover the actual common-label matching and decoder scalings +- [T031 — Recovering a single-query provider from a coefficient pivot](volumes/03-tensor.md#t031): Return explicit factors when all rank-one identities hold +- [T032 — Recovering a Kronecker adapter from its actual entries](volumes/03-tensor.md#t032): Turn a certified reshaped rank-one matrix into two explicit basis maps +- [T033 — Matrix-unit frame recovery for a query factor](volumes/03-tensor.md#t033): Construct actual factor coordinates from verified matrix units +- [T034 — Joint recovery of two commuting query factors](volumes/03-tensor.md#t034): Recover a common tensor-product frame rather than incompatible separate ones +- [T035 — Complete matrix-unit transporter family with an actual formula](volumes/03-tensor.md#t035): Recover every intertwiner, including its residual degrees of freedom +- [T036 — Constructive ratio-graph recovery of query scalings](volumes/03-tensor.md#t036): Solve all nonzero scalar compatibility equations by an explicit forest +- [T037 — Actual response-basis transporter from information-set ratios](volumes/03-tensor.md#t037): Complete a recovered monomial response equivalence with matrices +- [T038 — Exact extraction of a black-box bilinear response table](volumes/03-tensor.md#t038): Recover coefficients with a finite paid set of actual queries +- [T039 — Recovering a complete decoder from the coefficient image](volumes/03-tensor.md#t039): Construct the image and its observation pivot rather than assume them +- [T040 — Complete coefficient-level transporter admission](volumes/03-tensor.md#t040): Verify every transported response and all adapter inverses explicitly +- [T041 — Coordinate descent of a supplied extension-field provider](volumes/03-tensor.md#t041): Return a base-field algorithm and price all extension coordinates +- [T042 — Scalar-readout descent through an explicit pairing matrix](volumes/03-tensor.md#t042): Reduce extension products to d per term for a requested scalar response +- [T043 — Polynomial-basis descent with 2d−1 products per query](volumes/03-tensor.md#t043): Avoid d² coordinate products using explicitly paid interpolation +- [T044 — A computable trace projection without division by extension degree](volumes/03-tensor.md#t044): Extract exact base-field outputs even when the characteristic divides d +- [T045 — Generator-commutation recovery of extension-linear maps](volumes/03-tensor.md#t045): Recover K-linear coefficient maps from actual base-field matrices +- [T046 — Two-graph descent with recovered nonzero private scalars](volumes/03-tensor.md#t046): Enforce common extension scalars through explicit graph constraints +- [T047 — Frobenius-fixed transporter entries give actual finite-field descent](volumes/03-tensor.md#t047): Certify that recovered matrices lie in the promised ground field +- [T048 — Good-prime specialization of rational query certificates](volumes/03-tensor.md#t048): Produce exact modular providers while preserving actual inverse adapters +- [T049 — Newton lifting of an actual modular inverse adapter](volumes/03-tensor.md#t049): Lift a verified inverse without lifting an unproved nonlinear orbit witness +- [T050 — Explicit power-basis change between scalar presentations](volumes/03-tensor.md#t050): Transport every query coefficient through a certified field isomorphism +- [T051 — Coefficient-query supplier from sampled bilinear providers](volumes/03-tensor.md#t051): Recover a target coefficient with every evaluation and decoder charged +- [T052 — Sparse-parameter recovery with a verified evaluation minor](volumes/03-tensor.md#t052): Replace degree-many samples by support-many samples when a certificate permits +- [T053 — Parity-filtered recovery of bilinear coefficient labels](volumes/03-tensor.md#t053): Eliminate odd parameter contamination with a fully priced paired sampler +- [T054 — Multigraded query recovery on an explicit product grid](volumes/03-tensor.md#t054): Recover selected mixed coefficients without an unpriced multivariate oracle +- [T055 — Characteristic-free jet recovery with priced truncated products](volumes/03-tensor.md#t055): Replace missing distinct samples by exact finite jets +- [T056 — Small-field coefficient queries with an explicit extension and descent](volumes/03-tensor.md#t056): Supply enough parameter labels while charging extension arithmetic +- [T057 — Signed convolution recovery from modular query suppliers](volumes/03-tensor.md#t057): Combine modular convolutions into an exact integer child +- [T058 — Known-denominator response recovery from modular providers](volumes/03-tensor.md#t058): Recover rational labelled outputs without assuming integral coefficients +- [T059 — Unknown bounded denominators with explicit finite recovery cost](volumes/03-tensor.md#t059): Return actual rational responses from a residue and a bounded search +- [T060 — Exact modular admission of a new rational bilinear table](volumes/03-tensor.md#t060): Turn modular agreement plus a proved coefficient bound into a universal identity +- [T061 — A complete schoolbook bit implementation of a rational provider](volumes/03-tensor.md#t061): Replace an arithmetic-cost certificate by an actual bounded-bit circuit +- [T062 — Explicit height and finite bit cost for recovered rational adapters](volumes/03-tensor.md#t062): Price a recovered inverse rather than treating rational entries as unit-cost +- [T063 — Dyadic provider evaluation with a fixed denominator schedule](volumes/03-tensor.md#t063): Prevent repeated rational normalization from inflating the bit invoice +- [T064 — A denominator certificate propagated through the actual query circuit](volumes/03-tensor.md#t064): Compute sufficient exact denominators from the circuit rather than its name +- [T065 — Bit-priced extension multiplication from a supplied structure table](volumes/03-tensor.md#t065): Implement scalar descent with bounded integer coordinate growth +- [T066 — Balanced-radix recovery of signed convolution coefficients](volumes/03-tensor.md#t066): Decode bounded signed coefficients without ambiguous carry conventions +- [T067 — Signed Kronecker compilation of a convolution provider](volumes/03-tensor.md#t067): Turn one packed integer multiplication into exact labelled convolution +- [T068 — Nonnegative-limb convolution for arbitrary signed integer inputs](volumes/03-tensor.md#t068): Preserve signed integer semantics while reusing a positive limb supplier +- [T069 — A uniform bit invoice for multioutput CRT recovery](volumes/03-tensor.md#t069): Price residue reconstruction in actual operand lengths +- [T070 — Polynomial-bit modular admission with an explicit height ledger](volumes/03-tensor.md#t070): Verify a changed rational provider without hiding coefficient growth +- [T071 — A restricted provider with recovered embeddings and output projection](volumes/03-tensor.md#t071): Compile a smaller actual response from a larger verified tensor +- [T072 — Exact finite recovery from a polynomial border certificate](volumes/03-tensor.md#t072): Replace a formal leading coefficient by paid exact evaluations +- [T073 — Leading-coefficient recovery by explicit nilpotent arithmetic](volumes/03-tensor.md#t073): Remove the large-field sample requirement with a charged exact construction +- [T074 — Finite tensor-power extraction from a border supplier](volumes/03-tensor.md#t074): Price the complete exact tensor-power algorithm rather than quote an asymptotic rank +- [T075 — Single-parameter encoding of multigraded response labels](volumes/03-tensor.md#t075): Fit an exact multigraded supplier to a univariate controller +- [T076 — Character-filtered coefficient decoder with explicit roots of unity](volumes/03-tensor.md#t076): Use a structured decoder when the scalar contract supplies a full cyclic label set +- [T077 — Laurent-certificate recovery with all pole shifts charged](volumes/03-tensor.md#t077): Convert a Laurent motif to an exact finite provider without evaluating at a pole +- [T078 — Rational-parameter supplier with deterministic pole avoidance](volumes/03-tensor.md#t078): Construct valid sample labels and recover a rational endpoint exactly +- [T079 — Integral top-coefficient recovery by finite differences](volumes/03-tensor.md#t079): Avoid a rational Vandermonde inverse when an integer leading coefficient is the consumer +- [T080 — Division-free extraction of a mixed multilinear response](volumes/03-tensor.md#t080): Recover a selected mixed term over every characteristic with integer decoder weights +- [T081 — One-unknown-mode transporter recovery by a full-rank linear system](volumes/03-tensor.md#t081): Return the missing mode map and verify its invertibility +- [T082 — Two-sided slice transporter recovery through a simultaneous intertwiner](volumes/03-tensor.md#t082): Reduce an actual fixed-slice matching problem to linear equations +- [T083 — Finite nonsingular-point recovery inside a known affine solution space](volumes/03-tensor.md#t083): Construct an invertible transporter from a bounded-dimensional linear family +- [T084 — Constructive determinant correction from actual stabilizer generators](volumes/03-tensor.md#t084): Turn a verified GL transporter into an SL transporter when a finite character path exists +- [T085 — Simultaneous query frames from one simple-spectrum combination](volumes/03-tensor.md#t085): Recover compatible eigenlabels with an actual sufficient spectral certificate +- [T086 — Scalar normalization of an actual transporter with recovered roots](volumes/03-tensor.md#t086): Produce SL maps from explicit field-root certificates, not algebraic-closure existence +- [T087 — Annihilator compression that preserves every allowed input](volumes/03-tensor.md#t087): Remove useless source coordinates by an explicit quotient, not a zero-input assumption +- [T088 — Constructing a complete decoder for fixed query-form templates](volumes/03-tensor.md#t088): Synthesize actual output coefficients by linear algebra +- [T089 — Rational motif recovery guided by a certified modular pivot](volumes/03-tensor.md#t089): Lift a finite-field information set to an exact rational solution +- [T090 — Uniform polynomial transporter certification with an explicit good specialization](volumes/03-tensor.md#t090): Certify a family and return a nonsingular actual parameter choice +- [T091 — A fully labelled seven-child matrix-block provider](volumes/03-tensor.md#t091): Supply an explicit changed block-query contract with all additions paid +- [T092 — Cyclic convolution provider with charged radix-two Fourier maps](volumes/03-tensor.md#t092): Replace quadratic paired queries by a structured exact scalar contract +- [T093 — Ranked subset-convolution query supplier over every commutative ring](volumes/03-tensor.md#t093): Construct a new Boolean-labelled contraction with exact recovery +- [T094 — XOR-convolution supplier with exact Walsh recovery](volumes/03-tensor.md#t094): Price a selected-bit transform and its complete inverse +- [T095 — Sparse-support polynomial multiplication with a support-certified decoder](volumes/03-tensor.md#t095): Use the actual sumset rather than the enclosing degree interval +- [T096 — Symmetric bilinear recovery from an explicit quadratic circuit](volumes/03-tensor.md#t096): Compile a cheaper quadratic response into a priced symmetric query provider +- [T097 — Short-long convolution through overlap-add with all boundary labels](volumes/03-tensor.md#t097): Use a balanced child on unequal operands without a quadratic number of blocks +- [T098 — Exact Montgomery residue child from integer products](volumes/03-tensor.md#t098): Compile odd-modulus multiplication with a complete division-free online contract +- [T099 — Exact fixed-modulus reduction through a bounded reciprocal](volumes/03-tensor.md#t099): Replace repeated divisions by a priced reciprocal multiplier +- [T100 — Complete NTT–CRT–carry contract for an integer multiplication child](volumes/03-tensor.md#t100): Assemble an exact uniform child from explicit modular data, including recovery + +## ANALYTIC: 100 theorems + +- [A001 — A portfolio of charged native substitutions](volumes/04-analytic.md#a001): For independently proved native rewrites, enter every added stage in C_j and add their certified gains; this produces a strict caller-admission margin without summing unrelated κ decimals. +- [A002 — A compensating-operation allowance for a two-child merge](volumes/04-analytic.md#a002): After a native or tensor construction licenses a real merge, this explicit lower bound is a spendable allowance for its corrective consumer; do not count an unpriced merge. +- [A003 — An additive allowance for a merge tree](volumes/04-analytic.md#a003): Price a multi-output fusion against one total allowance and select a merge tree whose actual adapters fit it; the total budget includes every intermediate operation. +- [A004 — A paid width-reduction rule](volumes/04-analytic.md#a004): For a new dirty-helper contract, convert a proved width reduction into a concrete maximum charge for compensation and cleanup. +- [A005 — Transport-paid concentration with a quantitative gap](volumes/04-analytic.md#a005): Use G as a ceiling on the actual movement bill of a proved whole-role redistribution in a changed template; frozen PR #2863 packing alone is not reopened. +- [A006 — Simultaneous shrink-and-enlarge helper accounting](volumes/04-analytic.md#a006): Screen a coupled native redesign that narrows some helpers but widens others; retain the enlarged-helper penalty instead of advertising only the narrowed quartet. +- [A007 — A parent-width redesign threshold including all added work](volumes/04-analytic.md#a007): Before building a changed coverage or source-width contract, solve this threshold with its full adapter cost to specify the width and live-stock target it must actually realize. +- [A008 — Robust admission under an operation-price box](volumes/04-analytic.md#a008): Produce one safe native-rewrite decision valid over unresolved but bounded transport or precision tariffs, without assuming the cheapest endpoint for every unfavorable operation. +- [A009 — Signed profile gains certified on an exponent interval](volumes/04-analytic.md#a009): Validate an entire proposed exponent window from two endpoint evaluations and a complete signed profile, avoiding a floating-point optimum at a single guessed exponent. +- [A010 — A higher-rank decoder pays its own conversion](volumes/04-analytic.md#a010): Target fewer, larger paid children in a genuine changed decoder; the formula gives an explicit budget for the basis conversion and final readout. +- [A011 — A strict paid margin yields an explicit exponent interval](volumes/04-analytic.md#a011): Turn a proved changed-contract margin from A001–A010 into an open admissible exponent interval for the caller. +- [A012 — One margin can finance both exponent gain and an added stage](volumes/04-analytic.md#a012): Reserve a quantified share of a native saving for an unavoidable consumer instead of spending the entire margin on a larger exponent. +- [A013 — A certified neighborhood of a contract parameter](volumes/04-analytic.md#a013): Convert rigorous derivative bounds for precision, scalar tariffs or a parameterized valid caller into a safe search region, rather than recomputing the full bill at every nearby choice. +- [A014 — A finite number of good blocks finances bad boundary blocks](volumes/04-analytic.md#a014): Choose a finite repetition count that absorbs a bounded startup/termination defect around a profitable native/consumer block. +- [A015 — Coupled complex and bit margins give one common gain window](volumes/04-analytic.md#a015): After changing the binding complex supplier, retain a certified common interval with BIT before claiming that an outer transfer can use the new margin. +- [A016 — A curvature-aware advance with a reserved remainder](volumes/04-analytic.md#a016): Use the actual complete profile curvature to choose a safer, often less conservative admissible advance while retaining a quantified unused margin. +- [A017 — Logarithmic rank bins preserve a quantified admission margin](volumes/04-analytic.md#a017): Compress a large changed-contract histogram into a small auditable exponent certificate with a known multiplicative loss. +- [A018 — A derivative-capped one-step admission certificate](volumes/04-analytic.md#a018): Turn a symbolic Newton-style continuation proposal into a rigorous lower advance that can be entered in the outer admission ledger. +- [A019 — A local subtree improvement has an exact caller weight](volumes/04-analytic.md#a019): Prioritize a genuinely improved local consumer by its actual outer occurrence weight and reserve half its benefit for caller integration. +- [A020 — A finite outer ledger survives a quantified joint perturbation](volumes/04-analytic.md#a020): Carry a proved primitive improvement through a fully specified finite outer slack ledger symbolically, without evaluating a new κ or assuming unchanged secondary inequalities. +- [A021 — An explicit batch size absorbs sublinear integration work](volumes/04-analytic.md#a021): Choose a finite replication scale for a changed contract with a proved sublinear boundary bill, rather than treating its boundary as asymptotically free. +- [A022 — A rooted-tree potential accounts for every internal restoration](volumes/04-analytic.md#a022): Prove a uniform recursive amortization invariant that pays a dirty workspace exactly when its final consumer closes it. +- [A023 — Finite-state cycle certificates construct amortized potentials](volumes/04-analytic.md#a023): Convert a finite library of fully priced frame/consumer transitions into an all-length upper bill with a bounded endpoint debt. +- [A024 — Exact two-level fusion with an integration allowance](volumes/04-analytic.md#a024): Use a proved tensor or two-level consumer construction to buy a nonzero restoration/transport allowance from both complete primitive margins. +- [A025 — An acyclic contract library yields an explicit least-cost caller](volumes/04-analytic.md#a025): Assemble a cheaper complete caller from independently proved alternative consumer/frame contracts, with a reconstructible witness rather than a lower-cost relaxation alone. +- [A026 — A recursive integration toll is bounded by a geometric bill](volumes/04-analytic.md#a026): Bound repeated consumer/precision integration work at every recursive node, so a local toll is not mistaken for a one-time setup charge. +- [A027 — Rounding a fractional contract mix gives a finite sufficient design](volumes/04-analytic.md#a027): Realize a promising mix of genuinely different native contracts by finitely many whole modules, with a quantified rounding loss. +- [A028 — Conditional expectation derandomizes a complete finite bill](volumes/04-analytic.md#a028): Turn a rigorously priced randomized contract-mixture argument into a concrete candidate word or caller that can be independently checked. +- [A029 — A pessimistic estimator produces simultaneous resource feasibility](volumes/04-analytic.md#a029): Choose one actual redesign that simultaneously fits paid moment, bank stock and precision reserves, when a rigorous finite estimator is available. +- [A030 — Optimal continuous precision allocation with a bounded integer loss](volumes/04-analytic.md#a030): Allocate precision to expensive versus error-sensitive native stages with an exact optimality proof and a fully priced integer rounding overhead. +- [A031 — A sufficient coverage deficit for any declared minimum rank](volumes/04-analytic.md#a031): Specify a quantitative unpaid-coordinate target for a changed coverage law whose full child ranks are controlled, before synthesizing a new source template. +- [A032 — Adding live families has a fully priced normalization rule](volumes/04-analytic.md#a032): Price live-stock enlargement, including its new recursive work, instead of obtaining an artificial gain by changing the denominator alone. +- [A033 — A block-weight certificate gives a replica-independent precision envelope](volumes/04-analytic.md#a033): Construct a weighted all-prefix magnitude invoice for interleaved tensor replicas without paying a spurious factor from the total number of unrelated blocks. +- [A034 — Per-block grids meet a common propagated error budget](volumes/04-analytic.md#a034): Assign different precisions to blocks according to actual size and downstream amplification, then enter the exact summed storage/rounding charge. +- [A035 — A complete word has explicit suffix-weighted rounding budgets](volumes/04-analytic.md#a035): Derive stage-by-stage grid targets from the actual full native/cleanup word, instead of pricing only its final operator norm. +- [A036 — Exact inverse cancellation still has a nonzero precision price](volumes/04-analytic.md#a036): Price paired encoder/decoder or compute/uncompute stages correctly when exact restoration is used to justify a consumer interface. +- [A037 — Arbitrary dirty scratch gives an explicit intermediate magnitude bill](volumes/04-analytic.md#a037): Use this envelope for the declared block endpoints of a dirty helper. Combine it with the actual matrix-vector evaluator’s prefix bound before choosing the native word’s magnitude field; the operator norm alone does not bound an arbitrary evaluator’s internal accumulators. +- [A038 — Coefficient perturbations of a whole native word have a product bound](volumes/04-analytic.md#a038): Translate bounded coefficient quantization errors into a complete word-level error allowance before choosing the coefficient precision. +- [A039 — Acyclic error propagation is computed by reverse path weights](volumes/04-analytic.md#a039): Compute exact error sensitivities for a shared DAG consumer, where one bank or tensor block feeds several later uses; assign local grids against these weights. +- [A040 — A coupled feedback certificate closes simultaneous error bounds](volumes/04-analytic.md#a040): Close a multi-bank all-cut error ledger with an explicit positive-weight certificate, retaining cross-bank feedback in the required input grid. +- [A041 — A complete supplier moment closes a normalized floor recurrence](volumes/04-analytic.md#a041): Attach a uniform normalized-work recurrence to a changed complete profile and close it with a concrete coefficient K, including its local toll c. +- [A042 — Ceilings and bounded address tails preserve a strict recurrence](volumes/04-analytic.md#a042): Carry a strict profile margin through literal ceiling, alignment and bounded-tail costs in a uniform implementation. +- [A043 — Partitioning inputs has an explicit concave work penalty](volumes/04-analytic.md#a043): Choose the number of decoder panels or tensor partitions without losing a primitive margin to an uncounted fragmentation factor. +- [A044 — A finite remainder algorithm has a uniform priced toll](volumes/04-analytic.md#a044): Keep short-tail multiplication, decoding or source alignment in a finite auditable table and include its maximum cost in the all-size recurrence. +- [A045 — Adaptive valid providers preserve a uniform margin](volumes/04-analytic.md#a045): Use a data- or size-dependent menu of genuinely valid native contracts without requiring a single fixed provider, while preserving one common recursive budget. +- [A046 — An individually expensive level can be paid by a two-level contract](volumes/04-analytic.md#a046): Admit a coupled production/consumer pair whose profitable unit is two levels, rather than rejecting its producer from a one-level bill or ignoring its consumer. +- [A047 — Window contraction bounds a nonperiodic recursion tree](volumes/04-analytic.md#a047): Prove an all-size bill for a nonperiodic sequence of native/consumer modes using bounded-window certificates, without requiring each level to be profitable alone. +- [A048 — Finitely many costly repair levels have a bounded exponent-neutral price](volumes/04-analytic.md#a048): Pay a uniform finite set of exceptional endpoint, field-change or repair levels explicitly while preserving the target recursion exponent. +- [A049 — A normalized logarithmic recurrence implies a bit-time bound](volumes/04-analytic.md#a049): Prove the exact normalized log-scale implementation implication needed to turn a primitive saving into an actual n times log-power time bound, without claiming that the remaining compiler premise is already true. +- [A050 — Fixed synthesis cost is a genuine constant, size-dependent advice is not](volumes/04-analytic.md#a050): Use finite expensive design or certificate search offline only after fixing its resulting program and proving one uniform execution contract. +- [A051 — A positive type vector closes a heterogeneous caller recurrence](volumes/04-analytic.md#a051): Build one exact positive-vector certificate for the actual stateful producer/consumer recursion, rather than pricing each type as an independent successful supplier. +- [A052 — A two-state primitive has an explicit rational type certificate](volumes/04-analytic.md#a052): Certify a coupled two-pass producer/consumer budget by four actual moment entries, paying both cross-couplings instead of comparing diagonal bills alone. +- [A053 — A one-way consumer dependency has an explicitly scaled reserve](volumes/04-analytic.md#a053): Integrate a valid downstream consumer by enlarging the producer’s potential coefficient exactly enough to cover its one-way work. +- [A054 — A cyclic sequence of state transitions has constructive weights](volumes/04-analytic.md#a054): Price a complete cyclic production/consumption protocol by its closed cycle, including expensive intermediate states that are repaid later. +- [A055 — A finite-power row test constructs the type reserve](volumes/04-analytic.md#a055): Convert a bounded-depth multitype cost computation into an explicit all-depth positive-vector proof. +- [A056 — A type certificate has a quantified adapter allowance](volumes/04-analytic.md#a056): Spend a controlled part of a multitype native saving on the exact boundary adapters needed by a new consumer. +- [A057 — A common type potential licenses adaptive switching](volumes/04-analytic.md#a057): Allow a controller to select among profitable native/consumer modes safely, using one shared type certificate. +- [A058 — Eliminating auxiliary state pays its full return coupling](volumes/04-analytic.md#a058): Eliminate a bank, decoder or consumer state from a cost system without silently losing the work that returns to the main state. +- [A059 — Tensor composition preserves typed reserves with a priced interaction](volumes/04-analytic.md#a059): Combine two proved typed tensor contracts while reserving an exact budget for their common-label or physical interaction. +- [A060 — A strict real type certificate can be made rational](volumes/04-analytic.md#a060): Replace floating positive-vector output by exact rational weights and explicit slack before using it in a uniform caller proof. +- [A061 — A tight sufficient active-grid coefficient is explicit](volumes/04-analytic.md#a061): Compute the smallest coefficient supplied by this linear reserve argument for an exact-grid caller, rather than automatically doubling all local charges. +- [A062 — Strict stopping gives an explicit precision-depth invoice](volumes/04-analytic.md#a062): Convert the actual active shrink factor into a finite precision depth and retain a strict stop at exact powers of the shrink ratio. +- [A063 — The complete half-rank precision bill has an exact parity formula](volumes/04-analytic.md#a063): Compute an exact all-field-width precision invoice from the complete current or changed profile, retaining the odd-width tax explicitly. +- [A064 — An even field width buys a prescribed fixed-overhead margin](volumes/04-analytic.md#a064): Choose one finite, parity-correct field width that actually absorbs fixed source/precision setup, instead of taking an unpriced infinite-width limit. +- [A065 — A dyadic computation DAG has a least grid assignment](volumes/04-analytic.md#a065): Construct an exact common-denominator schedule for a shared native/consumer DAG and charge only the maximum incoming exponent at each addition. +- [A066 — A finite bootstrap survives a fully priced per-round loss](volumes/04-analytic.md#a066): Specify a finite number of valid bootstrap rounds and a maximum allowable round loss before expanding an asymptotic transfer campaign. +- [A067 — Ordering fixed bootstrap losses has an optimal constructive rule](volumes/04-analytic.md#a067): When correct bootstrap rounds are interchangeable, spend costly preparation/precision rounds early, where their effect on the final certified saving is discounted most. +- [A068 — Geometrically improving round accuracy has an exact residual bound](volumes/04-analytic.md#a068): Choose a concrete round-precision growth schedule and carry its entire residual loss into a finite bootstrap certificate. +- [A069 — A periodic producer/consumer bootstrap has a priced fixed point](volumes/04-analytic.md#a069): Analyze an alternating production/consumption/field-transfer cycle as a complete finite unit instead of combining its separately advertised gains. +- [A070 — A monotone outer conversion has a spendable gain allowance](volumes/04-analytic.md#a070): Budget the increased compiler/precision/analytic loss that a better primitive may tolerate, using a symbolic strict allowance and no new numerical κ. +- [A071 — A nonlinear rounding invariant closes a quadratic error recurrence](volumes/04-analytic.md#a071): Prove an all-prefix precision invariant for a nonlinear or bilinear consumer with quadratic error feedback, without selecting the small root of a circular inequality unjustifiably. +- [A072 — A weighted quadratic box controls interacting bank errors](volumes/04-analytic.md#a072): Close a simultaneous weighted error ledger for interacting dirty banks using finite inequalities that can be checked exactly. +- [A073 — Local precision estimates remain valid inside a proved domain](volumes/04-analytic.md#a073): Prove that a chosen native/consumer rounding grid actually keeps every prefix inside the magnitude region used to price its error. +- [A074 — A bilinear consumer has an explicit two-input error allowance](volumes/04-analytic.md#a074): Choose explicit input precisions for a source-consuming bilinear decoder or tensor product stage, including its error cross term. +- [A075 — A bilinear computation DAG has constructive error propagation](volumes/04-analytic.md#a075): Generate a complete symbolic precision invoice for a shared nonlinear consumer, rather than extrapolating a linear-word estimate past a bilinear stage. +- [A076 — An iterative linear consumer has a paid exact-integer termination rule](volumes/04-analytic.md#a076): Construct an actual finite approximate-to-exact consumer from a certified contraction, with an explicit iteration and grid budget. +- [A077 — Balanced quantization controls every accumulated prefix](volumes/04-analytic.md#a077): Prepare coarse aggregate records with a length-independent total-error allowance for a consumer that only needs their prefix sums. +- [A078 — A borrowed residual bank can coarsen all but one exact aggregate record](volumes/04-analytic.md#a078): Offer a real dirty-bank aggregate consumer n−1 coarse outputs plus one fully priced fine tail, rather than pretending the lost residual disappears. +- [A079 — Only consumer-visible directions need an accuracy target](volumes/04-analytic.md#a079): Formulate a replacement precision interface in a proved consumer quotient, allowing arbitrary irrelevant dirt while pricing every basis conversion. +- [A080 — A bilinear consumer factors through two priced visible quotients](volumes/04-analytic.md#a080): Prove a source-consuming bilinear boundary that tolerates uncomputed dirt in both inputs, with an explicit precision bill on only the visible quotient coordinates. +- [A081 — Rational trial exponents admit finite algebraic gain certificates](volumes/04-analytic.md#a081): Certify a proposed complete paid-profile improvement at a rational symbolic trial exponent using only exact rational operations, not trusted floating powers. +- [A082 — A nonzero rational-power gain has an explicit separation bound](volumes/04-analytic.md#a082): Choose a finite exact-comparison resolution for a nonzero native gain; the exponential dependence is explicit and is not advertised as an efficient large-instance algorithm. +- [A083 — Affine dirty-endpoint correctness has a complete finite test](volumes/04-analytic.md#a083): Give a complete algebraic endpoint certificate for a proposed arbitrary-dirt native rewrite rather than checking only clean fixtures. +- [A084 — A polynomial contract family has a complete finite parameter certificate](volumes/04-analytic.md#a084): Prove a whole parameterized native identity from a complete exact finite grid, with explicit degree and field-size hypotheses. +- [A085 — A noncommutative parameter family has a sufficient differential certificate](volumes/04-analytic.md#a085): Construct endpoint-preserving parameter deformations of a native word using an exact noncommutative identity, then separately price their frame and compensation changes. +- [A086 — Clipped water filling constructs the full continuous precision optimum](volumes/04-analytic.md#a086): Allocate precision when some stages legitimately need zero fraction bits, instead of applying an interior formula outside its hypotheses. +- [A087 — Unit-price integer precision has an exact greedy construction](volumes/04-analytic.md#a087): Find a minimum-bit discrete precision schedule for equally priced scalar lanes, including the full error target rather than rounding every continuous allocation blindly. +- [A088 — Weighted integer precision has a finite exact dynamic program](volumes/04-analytic.md#a088): Optimize actual block-weighted grid storage exactly when independent integer round-up loses too much of a narrow primitive margin. +- [A089 — Two simultaneous precision obligations admit a finite dual certificate](volumes/04-analytic.md#a089): Certify one precision plan meeting both forward-consumer and restoration/error obligations, instead of optimizing one while ignoring the other. +- [A090 — Shared-field precision constraints can be reduced exactly](volumes/04-analytic.md#a090): Optimize the precisions the physical compiler can really choose, rather than counting a saving from lane-specific grids forbidden by a common field. +- [A091 — A shared error-symbol representation can reduce paid fraction bits](volumes/04-analytic.md#a091): When a native inverse pair or compensated bank reuses a rounded response, combine its signed suffix coefficients first. Choose each fraction field from the resulting row sums; this can lower the paid precision while retaining a deterministic worst-case bound. +- [A092 — Lattice coordinates preserve exact interface constraints during rounding](volumes/04-analytic.md#a092): Round independent kernel coordinates instead of every lane of a constrained helper bank. This preserves the exact conservation equation at every checkpoint, with a stated distortion and a fully priced coordinate adapter. +- [A093 — Bipartite controlled rounding preserves all integer bank margins](volumes/04-analytic.md#a093): Convert a rational bank allocation with integral total ownership on both sides into literal integer lanes without losing either family total. Charge exact flow synthesis and all resulting movement; this theorem does not imply integral packing for unrelated constraints. +- [A094 — Known-denominator output recovery turns a norm budget into an exact endpoint](volumes/04-analytic.md#a094): Where a changed block consumer produces a rational grid output, choose fraction bits from its true output denominator rather than a generic integer-output assumption, and price the reconstruction before claiming a saving. +- [A095 — Nilpotent feedback permits large local error gains without a contraction](volumes/04-analytic.md#a095): For a triangular consumer, use the finite path sum to allocate rounding budgets. Do not pay for a global contraction that the actual acyclic dependency does not need. +- [A096 — Exact scratch scheduling for a two-child out-of-place operation](volumes/04-analytic.md#a096): Compile a tree-shaped recovery or contraction into an explicit low-peak bank schedule before quoting memory or hosting costs. Include the chosen order in its contract certificate. +- [A097 — Sequential shrinking recursion has a geometric live-space certificate](volumes/04-analytic.md#a097): Supply a literal linear-space schedule for a changed recursive consumer. This is useful only when the profile gain survives the extra operations of sequentialization and the declared hosting/tape simulation. +- [A098 — Fixed dyadic words across logarithmic depth have explicit bit growth](volumes/04-analytic.md#a098): For a fixed native word expanded along logarithmic recursion depth, derive its actual B+f+O(log n) coordinate sizes before applying a bit-time or tape theorem. This does not prove that an arbitrary tensor certificate has such an expansion. +- [A099 — Disjoint rewrite selection with resource caps has an exact finite optimizer](volumes/04-analytic.md#a099): Choose the best admitted mixture of proved local rewrites under bank, movement and precision caps, rather than maximizing a scalar ADD saving. This is a finite synthesis theorem, not a claim that current frozen packing has an undiscovered gain. +- [A100 — A complete changed-contract package gives a symbolic all-size admission theorem](volumes/04-analytic.md#a100): Assemble a future native/physical/tensor construction only after its concrete costs form one compatible typed recurrence. A positive symbolic reserve then pays the complete all-size bound. This collection supplies components and admission tools; it does not instantiate a better multiplication exponent. + diff --git a/research/kappa-action-theory/LICENSE b/research/kappa-action-theory/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/kappa-action-theory/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/kappa-action-theory/MANIFEST.json b/research/kappa-action-theory/MANIFEST.json new file mode 100644 index 0000000000..5cfc8956e7 --- /dev/null +++ b/research/kappa-action-theory/MANIFEST.json @@ -0,0 +1,211 @@ +{ + "schema": "sha256-file-manifest-v1", + "scope": "All package files except this self-referential manifest. Mathematical truth is not certified by hashes.", + "files": [ + { + "path": "ACTION-ROUTES.md", + "bytes": 11268, + "sha256": "4b88193b02acc12033be8cfa60c850d5eae5d7a220b5674b27efa2ecbe52c4e4" + }, + { + "path": "BRANCH.txt", + "bytes": 42, + "sha256": "5ba003b18f87acdf365937cb2708493b192fe01e6373a786423559c546178954" + }, + { + "path": "check_collection.py", + "bytes": 3873, + "sha256": "2349711bf84d09155ad1f09aa838210be95c14621ae5cc0df54c18fe04144dc0" + }, + { + "path": "CREDITS.md", + "bytes": 6645, + "sha256": "cace3fb1ed531691d61639274e9bfa49135e916e4744b0a59407d0ba13a25c88" + }, + { + "path": "FRONTIER.md", + "bytes": 9174, + "sha256": "6d9e3cfa97ad3c1af71e69e01649fb157460d223a96f157e2e9388c0c0615b05" + }, + { + "path": "INDEX.md", + "bytes": 95651, + "sha256": "00fca76d2d474df48a158826a40536f55513822f4c3902ab4eb0cf2bf1c6f3e6" + }, + { + "path": "indexes/ANALYTIC.json", + "bytes": 60618, + "sha256": "b5f6948b7b03c251f9e1c0a68b76b8a45445ff0e34d66188c514ea0804345529" + }, + { + "path": "indexes/NATIVE.json", + "bytes": 75134, + "sha256": "d3af26f4922ded56b35a8bea1af6b2f83cd1d0e3767a68f97631abdb6afdb8c3" + }, + { + "path": "indexes/PHYSICAL.json", + "bytes": 77982, + "sha256": "f00df96eb5149c8bc0cc479da081501b3beb4bece1e9ef1b143bf39e0c3bfc06" + }, + { + "path": "indexes/TENSOR.json", + "bytes": 62000, + "sha256": "e096b806b1d9b6a256f3a7265025558eb7f0979f033beebaf4087e1e24992250" + }, + { + "path": "LICENSE", + "bytes": 11357, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "NOTICE", + "bytes": 459, + "sha256": "e1f30864916167fc168893b87f690ce98afbffc32766d8de4fbe469d1f6606f5" + }, + { + "path": "PR-BODY.md", + "bytes": 1484, + "sha256": "919742262007fbf22d4775094c84a794799ffc9ecdc1c42ec97488a0a6b1d794" + }, + { + "path": "PR-TITLE.txt", + "bytes": 63, + "sha256": "5832631f64497ffe7cd0d3da9e874bc59d0c3d11d0f3e17cf85463f09de49d37" + }, + { + "path": "provenance/BOUNDED-CENSUS.json", + "bytes": 70283, + "sha256": "f4c0206cb83a899faaac0af8db3991cbbe43f302ee5eba120c806de8a66a1b72" + }, + { + "path": "provenance/DAG-NOTE-REFRESH.json", + "bytes": 447, + "sha256": "d28be017d2bf7f9a527f79ffde7beb61067c60dec92d097af83ed782cbe72e0a" + }, + { + "path": "provenance/FINAL-CALLER-MAP-PIN.json", + "bytes": 310, + "sha256": "de67258c48c7523ff48874d3de9cf0a5eb33449896e493186bcb10293734bbec" + }, + { + "path": "provenance/FINAL-MAIN-SOURCES.json", + "bytes": 2491, + "sha256": "d28315f0f0ba93c5ae3c0420b81fa19b3e5093c007a784d250b44b1aea95dab2" + }, + { + "path": "provenance/FINAL-REFRESH.json", + "bytes": 782, + "sha256": "280b95dfab9ee8afadd60e86913f13ea3cbe9082a34b1814f5abdc36a57c0853" + }, + { + "path": "provenance/FINAL-SOURCE-PINS.json", + "bytes": 5421, + "sha256": "3c8bf5b9ed254201a5b499e374ee228466bcb92de49f28ebcc64f71cdb8de40b" + }, + { + "path": "provenance/LOCAL-SOURCE-GUARDS.json", + "bytes": 11702, + "sha256": "408df205930b48aa5e4c6cd710130724caaa8b336d46b0a0867cbc005658703c" + }, + { + "path": "provenance/ROOT-LOCAL-PRECEDENTS.json", + "bytes": 5675, + "sha256": "30a11db1f86c54449c11f9c7785b8f02e4a476ab9a894931732097ca238ca14c" + }, + { + "path": "provenance/VOLUME-PINS.json", + "bytes": 1331, + "sha256": "89a73441584fd3979977958c1c5d14b21c0c41465b56a78d9ecb1264d896003e" + }, + { + "path": "README.md", + "bytes": 4036, + "sha256": "369898e6fc0d88f39b931bd41a2ebdce9ae2385eacfe64c2909f1583d6534130" + }, + { + "path": "RELEASE.json", + "bytes": 1388, + "sha256": "99f9cb130f71dc4ef2e64597c5d4412c268915295849a9516612d6ae853365a8" + }, + { + "path": "RESEARCH-PLAN.md", + "bytes": 2639, + "sha256": "99e823826d11c2f7c02aba9d44c00e7ff27f9de9baab0792f399f7a304baca02" + }, + { + "path": "REVIEW.md", + "bytes": 2595, + "sha256": "0762eb40f2602082f2960e8aeb0cc74e7f33037ece1510336a397e8651b362e9" + }, + { + "path": "reviews/ANALYTIC-self-review.md", + "bytes": 14482, + "sha256": "1695d19479c412af5d1ca73e45b8ff533d17f34562d2234ffa624697aeb46095" + }, + { + "path": "reviews/NATIVE-reviews-TENSOR.md", + "bytes": 6794, + "sha256": "6f47f19dbd2dda4705edfec36ec792a020c5eff1d7bb98ae08342b3b03cd11b6" + }, + { + "path": "reviews/NATIVE-self-review.md", + "bytes": 10779, + "sha256": "d748062f5a3d1d600b6b195e5c24498798a4f3f5e3a41c3eacbc1a89351360f3" + }, + { + "path": "reviews/PHYSICAL-reviews-NATIVE.md", + "bytes": 5908, + "sha256": "fc0d9fb12a21c88a6e5e5ae5bb47393b6d5241c9d2f16d0c0f020aa30281017a" + }, + { + "path": "reviews/PHYSICAL-self-review.md", + "bytes": 6045, + "sha256": "6e36816aa657b874334298ea39eab5754c32e53991832dae1fbac6378874406d" + }, + { + "path": "reviews/ROOT-reviews-PHYSICAL.md", + "bytes": 6695, + "sha256": "ea236b80dc53c929c8039916de8339f2bba6e1b9d4dfe611eed21ad2e6cb5326" + }, + { + "path": "reviews/TENSOR-reviews-ANALYTIC.md", + "bytes": 6560, + "sha256": "e03eadbaa392be1fe48878e80be48f3b17352324500efe4134c85f3be6ef24f4" + }, + { + "path": "reviews/TENSOR-self-review.md", + "bytes": 14888, + "sha256": "57cb2514e18d8116febee5066ba4efa2e0e8cae0c0dfb9130fe14d00924a73ef" + }, + { + "path": "THEOREMS.json", + "bytes": 659576, + "sha256": "028436d69e3efdfd31107cb26fe7fca78abe2de04d7cf3c27d528d02d7cfc086" + }, + { + "path": "UPLOAD.md", + "bytes": 1917, + "sha256": "160019567f78bdf2fc9e84a2997318de308218e8a46f74f88909a745e6669642" + }, + { + "path": "volumes/01-native.md", + "bytes": 129988, + "sha256": "7eb298c577ffe0ed705cd964736cf3de0d2cd694d6ba1a7b4f6fa1b6d8e6f0b1" + }, + { + "path": "volumes/02-physical.md", + "bytes": 125241, + "sha256": "09287ede2019b09e823e75ece3f40d2532f64ed1dfe45e5be458d26ee79f8c45" + }, + { + "path": "volumes/03-tensor.md", + "bytes": 114294, + "sha256": "cc694b34411ac9e40548d654a33901e560f65020fc0fb9d4dd2b5e4879026929" + }, + { + "path": "volumes/04-analytic.md", + "bytes": 114983, + "sha256": "b95ce636445ffeb0ad13e6ab66b7dc8c1d2d40a9f3f1d225104e4a2c7db6e45e" + } + ] +} diff --git a/research/kappa-action-theory/NOTICE b/research/kappa-action-theory/NOTICE new file mode 100644 index 0000000000..744c4ae533 --- /dev/null +++ b/research/kappa-action-theory/NOTICE @@ -0,0 +1,7 @@ +400 constructive theorems for changed-contract kappa improvements +Prepared with substantial OpenAI Codex assistance, root and three agents. +New text and structural-checker code: Apache-2.0. +Classical methods and upstream project contributions retain attribution. +See CREDITS.md, FRONTIER.md and the volume source ledgers. +No upstream executable source or proof prose is vendored. +No global novelty, independent human review or new numerical kappa is claimed. diff --git a/research/kappa-action-theory/PR-BODY.md b/research/kappa-action-theory/PR-BODY.md new file mode 100644 index 0000000000..e1e125f5be --- /dev/null +++ b/research/kappa-action-theory/PR-BODY.md @@ -0,0 +1,7 @@ +The current fixed-word/inventory packing optimum is already attained in #2863. This collection develops changed native/helper contracts, complete physical consumers, actual common-label tensor recovery and the charged precision/uniform-transfer interfaces needed for a future improvement. + +Adds four pure-mathematics volumes with exactly 400 unique theorems, each with a full informal proof and concrete action. Includes a 400-entry searchable index, application recipes, immutable source pins, honest overlap/attribution and full author plus separate-agent proof-review records. Main was refreshed through `734ef056148cea45daf9af0bd089a7b5c46fea8f`, including the existing logical-caller/storage, all-size unit-shear and internal-grid successors. + +These are constructive/sufficiency results in explicitly stated models, including classical adaptations. No exact new κ, realized global improvement, 400 novelty claims, Lean formalization or independent human review is asserted. A tensor certificate is not automatically a native linear child, and a finite endpoint identity does not establish all-size physical/H2/outer admission. + +Validation: `python3 -I -B research/kappa-action-theory/check_collection.py` checks counts, fields, anchors, dependencies and SHA-256 package integrity. Informal proof review and resolved corrections are documented separately; the checker does not verify mathematics. No frozen source, selected result, canonical DAG or shared configuration changes. diff --git a/research/kappa-action-theory/PR-TITLE.txt b/research/kappa-action-theory/PR-TITLE.txt new file mode 100644 index 0000000000..386ecf75d8 --- /dev/null +++ b/research/kappa-action-theory/PR-TITLE.txt @@ -0,0 +1 @@ +400 constructive theorems for changed-contract κ improvements diff --git a/research/kappa-action-theory/README.md b/research/kappa-action-theory/README.md new file mode 100644 index 0000000000..495e6b3248 --- /dev/null +++ b/research/kappa-action-theory/README.md @@ -0,0 +1,24 @@ +# 400 constructive theorems for changed-contract κ improvements + +Four volumes give **400 theorems with complete informal proofs and concrete actions**: 100 native/helper constructions, 100 physical consumers and routing results, 100 labelled tensor/recovery/arithmetic constructions, and 100 quantitative admission/precision/uniform-transfer results. The collection is pure mathematics. There are no conjectures in the count, no Lean formalizations and no exact new κ. + +The output is a toolkit of sufficient constructions and charged admission bounds. It does **not** establish 400 realized κ improvements, a new record, 400 globally novel discoveries, or a complete faster integer multiplier. Many results are classical methods reconstructed for explicit dirt, label, cost or source interfaces. Their direct effects are specific: emitted words, recovered maps, complete finite algorithms, smaller certified error/resource bounds, or symbolic conditions under which the resulting complete caller improves. Whether those conditions hold for the current multiplier is stated separately. + +| Volume | IDs | Delivered mathematical objects | +| --- | --- | --- | +| [Native response words](volumes/01-native.md) | N001–N100 | Arbitrary-dirt helper circuits, compensated basis changes, staged insertion formulas, coefficient compilers and exact local assemblies | +| [Physical consumers](volumes/02-physical.md) | P001–P100 | Correct bank/order phases, encoded consumers, paid endpoint adapters, finite routing and explicit physical realizations | +| [Tensor and recovery](volumes/03-tensor.md) | T001–T100 | Common-label query transformations, actual transporter recovery, descent/interpolation and exact bit-priced arithmetic children | +| [Admission and transfer](volumes/04-analytic.md) | A001–A100 | Quantified gain allowances, typed moment margins, error/grid budgets, resource optimizers and proved uniform recurrences | + +Start with [the frontier and overlap assessment](FRONTIER.md), then [the concrete application routes](ACTION-ROUTES.md). [INDEX.md](INDEX.md) links every theorem and action; [THEOREMS.json](THEOREMS.json) contains the same 400 records with full proof text for search. Read each volume's common definitions before applying an entry. A label-space bilinear certificate is not automatically the current native linear C operation, and finite operator equality is not an all-size implementation theorem. + +The frontier refresh inspected main `734ef056148cea45daf9af0bd089a7b5c46fea8f`, recent created/updated PR windows and actual relevant sources. PR #2863 already attains the stated fixed-word/inventory packing optimum. This collection therefore develops changed native/consumer contracts and the implementation bridges that a future improvement needs. Existing logical callers, unit-shear machines, precision certificates and storage proofs retain credit; their narrower results are not described as missing. [Credits](CREDITS.md) and immutable source pins distinguish inspected sources from reported results. + +Every theorem received author readback and a separate Codex-agent proof review. See [REVIEW.md](REVIEW.md) for coverage, corrections and limits. These are informal mathematical reviews, not proof-assistant or independent human verification. The portable command below checks counts, dependencies, required fields and SHA-256 bytes only: + +```sh +python3 -I -B check_collection.py +``` + +All original research drafts are retained outside this publication package. Public manuscripts differ from their reviewed drafts only by stable link anchors; original and public hashes are recorded. Personal host paths in review provenance are replaced by `` without changing source-byte hashes. No upstream source module, live typed DAG, persistent service or configuration was changed. A targeted refresh added the local deliverable pointer to the existing notes catalog; it created no new DAG or checked theorem. This package contains no executable multiplier and publishes nothing by itself. diff --git a/research/kappa-action-theory/RELEASE.json b/research/kappa-action-theory/RELEASE.json new file mode 100644 index 0000000000..faa3ba00ce --- /dev/null +++ b/research/kappa-action-theory/RELEASE.json @@ -0,0 +1,37 @@ +{ + "theorems": 400, + "volumes": 4, + "theorems_per_volume": 100, + "conjectures_counted": 0, + "proof_type": "informal complete proofs, author and separate Codex-agent readback", + "formal_verification": false, + "new_kappa_evaluated": false, + "realized_global_kappa_improvement_claimed": false, + "structural_command": "python3 -I -B research/kappa-action-theory/check_collection.py", + "source_guards": { + "checked": 39, + "matched": 39, + "evidence": "source bytes only" + }, + "review_coverage": { + "N": "all100 by physical agent", + "P": "all100 by root", + "T": "all100 by compiler agent", + "A": "all100 by product agent" + }, + "scope": "Constructive algorithms, local words and sufficient admission bounds under the explicit priced interfaces; no global novelty or full multiplier claim.", + "publication_transforms": "Stable anchors only in N/P/T, personal host prefix normalized in public provenance. Source hashes retained.", + "canonical_workspace": "Existing live typed DAG and Lean source tree unchanged; one targeted notes-catalog pointer refresh succeeded.", + "browser_target": { + "batch_files": 42, + "file_limit_bytes_exclusive": 26214400, + "path_target_characters": 240, + "local_max_files": 80 + }, + "volumes_words": { + "01-native.md": 19020, + "02-physical.md": 18144, + "03-tensor.md": 16415, + "04-analytic.md": 16111 + } +} diff --git a/research/kappa-action-theory/RESEARCH-PLAN.md b/research/kappa-action-theory/RESEARCH-PLAN.md new file mode 100644 index 0000000000..fcf86a7f22 --- /dev/null +++ b/research/kappa-action-theory/RESEARCH-PLAN.md @@ -0,0 +1,11 @@ +# Frozen informal research route + +User target: exactly 400 proved pure-mathematical theorems with direct actionable effects on κ-improvement research; no Lean formalizations and no exact new κ. Four volumes of 100, root plus three Codex agents. No claim that 400 independent improvements or 400 globally new theorems have been found. + +The sufficient assembly is: construct an explicit input/output/dirty-workspace-correct primitive or consumer; calculate its complete paid child profile, movement, restoration and precision charges; place it in a valid caller; then use a proved strict symbolic moment margin and a uniform implementation recurrence to transfer the margin. The collection must close specific mathematical subinterfaces in that chain and distinguish any remaining physical-instantiation premise. A missing gadget or efficient recovery algorithm is never assumed inside a purported proof. + +Compared routes: (i) more fixed-word packing, now closed by PR #2863, so no expansion there; (ii) changed native/consumer and bank contracts, chosen for substantive local constructive results; (iii) exact common-label tensor recovery and uniform precision/recurrence transfer, chosen to stop orbit identities being mistaken for efficient implementations. All four chapters are directed toward complete sufficient constructions or measurable admission budgets rather than necessary-condition-only barriers. + +N001–N100: changed native and helper-response constructions (compiler agent). P001–P100: physical phase/order/bank/routing consumers (physical agent). T001–T100: labelled tensor composition, exact constructive recovery and arithmetic implementation (product agent). A001–A100: quantitative paid-profile admission, normalization, precision, amortization and uniform recursive transfer (root). Each counted statement has a distinct transformation or certificate, explicit hypotheses, a complete proof and an action with a named frontier target. Mere generic background, repeated parameter substitutions and conjectures do not count. + +Review: self-review every statement, independent cross-review by another team member, root scope/source/actionability review, and machine checks only for count, IDs, cross-references, formatting and hashes. Any false or redundant statement is corrected or replaced before counting. A numerical test is not a proof. No Lean processes, Jev calls, daemon starts/stops or global configuration changes. This English route ledger intentionally has no invented Lean root: the user's explicit informal-only scope supersedes the controller's Lean-root workflow. The only live DAG remains on D:. diff --git a/research/kappa-action-theory/REVIEW.md b/research/kappa-action-theory/REVIEW.md new file mode 100644 index 0000000000..27fbb404fb --- /dev/null +++ b/research/kappa-action-theory/REVIEW.md @@ -0,0 +1,16 @@ +# Proof review and evidence scope + +Exactly 400 unique numbered theorems have complete informal proofs, with 100 in each volume and no conjectures in the count. Statements and proofs were read by the author and by a different Codex agent. The coverage is full manuscript review, rather than sampling. This is separate AI-assisted review within the same team, not independent human peer review, a proof-assistant check, or certification of a new integer multiplier. + +| Manuscript | Author | Separate proof reviewer | Detailed record | +| --- | --- | --- | --- | +| N001–N100 | Compiler agent | Physical agent | [Physical review of native](reviews/PHYSICAL-reviews-NATIVE.md) | +| P001–P100 | Physical agent | Root | [Root review of physical](reviews/ROOT-reviews-PHYSICAL.md) | +| T001–T100 | Product agent | Compiler agent | [Native review of tensor](reviews/NATIVE-reviews-TENSOR.md) | +| A001–A100 | Root | Product agent | [Tensor review of analytic](reviews/TENSOR-reviews-ANALYTIC.md) | + +The author ledgers record corrections and source hashes. The cross-reviews record mathematical issues and their resolution. The root also reviewed the collection's interfaces, source scope and action map. Close results with different outputs are identified in ACTION-ROUTES.md and the author reviews; none is counted as an independent global discovery. No source-only DAG entry, numerical fixture or historical kernel receipt is treated as a freshly proved fact. Every manuscript supplies its actual proof in prose. + +Mechanical checks validate exact IDs/counts, Statement/Theorem and Proof fields, concrete index actions, dependency closure/acyclicity, stable anchors and sealed file hashes. They cannot establish correctness, novelty, direct implementation compatibility or an exponent improvement. The reviewed drafts and public manuscripts have separate hashes because stable anchors were inserted in three volumes; mathematical text was not changed by packaging. Local personal host prefixes are normalized in public review provenance only. The release evidence records that transformation explicitly. + +No Lean formalizations or fresh kernel/transitive-axiom checks were attempted, as requested. No Jev requests, GPU/model proof jobs, persistent-service starts/stops, changes to global configuration, or remote GitHub writes were used. Computation is limited to source retrieval and document/provenance checks. The full current global multiplier, physical/H2/outer premises and all prior packages were not replayed. A theorem's explicit interface hypotheses remain part of its conclusion's scope. diff --git a/research/kappa-action-theory/THEOREMS.json b/research/kappa-action-theory/THEOREMS.json new file mode 100644 index 0000000000..6704cea9ce --- /dev/null +++ b/research/kappa-action-theory/THEOREMS.json @@ -0,0 +1,7580 @@ +[ + { + "id": "N001", + "title": "Dirty-middle product echo", + "dependencies": [], + "dependency_description": "shared accounting", + "frontier_target": [ + "A", + "compensation" + ], + "action": "Replace an explicitly factored response product in `A`/`compensation` by this no-clean-middle circuit when its full charge is favorable.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "classical identity, native-contract adaptation.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "ef41a92c9e67b361809eba5dfc5594c57c84e257c305e47cd5f416cda5f5b1eb", + "volume": "volumes/01-native.md", + "anchor": "n001", + "statement": "For dyadic matrices U and V of compatible sizes, the four updates h += Ux; y += Vh; h -= Ux; y -= Vh send (x,h,y) to (x,h,y+VUx). All blocks may start dirty. The scalar charge is 2A(U)+2A(V), with at most one reusable coefficient register.", + "proof": "Name the initial values x₀,h₀,y₀. The first two updates give h=h₀+Ux₀ and y=y₀+Vh₀+VUx₀. The third restores h₀ without reading y. The fourth subtracts precisely Vh₀. Thus the only remaining output increment is VUx₀, and both source blocks are exactly restored. Each displayed matrix addition is a collection of reversible additions between disjoint blocks, so its coefficient-work contract follows from the accounting definition; no dirty middle value is cleared. All four operations are charged, including the second read of Vh.", + "proof_sha256": "802ec1253b4165047ab6e774bcbc6529519516b0ee5e953558fec1ffdce6517b" + }, + { + "id": "N002", + "title": "Correct orientation of transported compensation", + "dependencies": [], + "dependency_description": "accounting", + "frontier_target": [ + "compensation", + "A" + ], + "action": "Generate the exact `compensation` replacement after a changed `A` helper basis, as in the inspected quartet mechanism.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "classical transport, explicit local application.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "9f466cb5fb06b840ce1265eb639caed16ac0eaa9c8494f57790bb1ebc87eb2e6", + "volume": "volumes/01-native.md", + "anchor": "n002", + "statement": "Suppose a linear native word has target increment Dx+Ch, non-target transformation M(x,h), and inverse non-target cleanup. Let S be an explicit helper-only elementary word of charge g. Prepending S and appending S⁻¹ after cleanup changes the helper dirt response to C S, leaves the x contribution D unchanged, and restores the original helper input. Its additional scalar charge is 2g; the new compensation is −C S h, costing A(C S).", + "proof": "The original forward word now receives (x,S h), so linearity gives target increment Dx+C S h. Its non-target outputs are M(x,S h). The old inverse cleanup returns (x,S h), since it inverts M on every input, not merely on zero helpers. The appended S⁻¹ therefore returns h. Subtracting C S h cancels the transformed dirt exactly. A right multiplication by S⁻¹ would instead cancel the response of a different input and is not justified. The two explicit basis words and every new compensation read appear in the stated charge.", + "proof_sha256": "173ec4d64bbf8b56caaf2943ff04dca4a704599726a0713c3bea99b59fb97031" + }, + { + "id": "N003", + "title": "One sparse kernel direction removes a response source", + "dependencies": [ + "N002" + ], + "dependency_description": "N002", + "frontier_target": [ + "A", + "cleanup" + ], + "action": "Turn a verified sparse compensation-kernel vector into an actual `A`/`cleanup` basis word and delete its now-zero compensation source.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "adaptation.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "7be06a29d7346c634b427bc78298089134bac8e4abd151c571f33a05ba720afc", + "volume": "volumes/01-native.md", + "anchor": "n003", + "statement": "Let C=[c₁ … c_n] and let k=(1,k₂,…,k_n) satisfy Ck=0. The word h_j += k_j h₁ for j=2,…,n has matrix S, satisfies C S=[0,c₂,…,c_n], and is inverted by the same additions with negative coefficients. Its forward-plus-inverse charge is 2Σ_(j>1)A(k_j).", + "proof": "This word replaces the first column of the identity by k and leaves every other column unchanged: only h₁ controls updates and h₁ itself never changes. Therefore S e₁=k and S e_j=e_j for j>1. Multiplication by C gives the claimed columns. The inverse subtracts each k_j h₁, restoring every arbitrary dirty helper. Applying N002 makes the first compensation column literally zero; it does not assume the helper was initially zero. No inverse of k_j is required, so dyadic compilation is available for every stated coefficient. Frame costs of the new word remain explicit CHILD charges.", + "proof_sha256": "d97476d419afff9b1aa8e12d2791cb05c8c450047c7cf6fcabff3f45a978ba50" + }, + { + "id": "N004", + "title": "Incrementally absorb a newly dependent helper", + "dependencies": [ + "N002" + ], + "dependency_description": "N002", + "frontier_target": [ + "compensation" + ], + "action": "Extend an established shared-kernel chart to a new dependent `compensation` column.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "constructive adaptation.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "0e63ce0372575a28e2254d8fc16612b9d0b99ccabf5d9f1d7c9e389218c43af9", + "volume": "volumes/01-native.md", + "anchor": "n004", + "statement": "Suppose a response bank already has columns C and one additional column c=C a, with a explicit and dyadic. The helper change h_old -= a z, leaving the new helper z fixed, changes the combined response [C,c] to [C,0]. Forward and inverse changes cost 2A(a).", + "proof": "Substitute h_old−a z for the old helper vector in C h_old+c z. The result is C h_old+(c−C a)z=C h_old. The new source z is not overwritten or cleared. The inverse adds a z back, so all helper inputs are restored after the corresponding inverse native cleanup. Every coefficient of a is used once in the forward change and once in the inverse; there are no hidden solves at runtime. The relation c=C a is a finite matrix equality whose entries can be checked directly before construction. This appends one helper without rebuilding an entire existing basis.", + "proof_sha256": "3848d8c431682ae5e83eed53b82199e34b8fe94fa5508819b059f4cfbf7ddf08" + }, + { + "id": "N005", + "title": "Rank-one response bank with one shared aggregate", + "dependencies": [], + "dependency_description": "accounting", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Share compensation columns with a common target vector across a complete invocation.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "classical factorization with paid local realization.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "c416e6c1cbd27d40592c0c8f5bc28d89415fc1916ac06723d8ec99c6dc16f250", + "volume": "volumes/01-native.md", + "anchor": "n005", + "statement": "If C=u vᵀ with explicit dyadic u,v, then y += Ch can be implemented with one private scalar aggregate t, charge 2A(vᵀ)+A(u)+2 CLEAR, and exact restoration of h and t=0 on release.", + "proof": "Clear t, add vᵀh into it, update y by u t, subtract vᵀh, and clear the already-zero t. During the middle update t equals vᵀh, hence the target increment is u(vᵀh)=Ch. The h registers are read-only. Subtracting the same linear form returns t to zero for every original h, including dirty inputs; the initial clear is legal only because t is declared private. Each coefficient read, inverse read, target fanout and both lifecycle clears is charged. This is a concrete aggregate circuit rather than treating a rank-one matrix as a free primitive.", + "proof_sha256": "7c4332746118973d8c794a20b5a7d703336e7f6c97f182f52a48e1979e3072ab" + }, + { + "id": "N006", + "title": "Collect response reads across a known helper trajectory", + "dependencies": [], + "dependency_description": "accounting", + "frontier_target": [ + "compensation", + "A", + "B" + ], + "action": "Move and share `compensation` reads only after accounting for actual helper prefixes in `A` or `B`.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "adaptation.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "caf1e086eb77236b4645f9b3acb2369fc8b7a664e6c5ba17c4438f07c4309a1b", + "volume": "volumes/01-native.md", + "anchor": "n006", + "statement": "Let explicit helper words J₁,…,J_s act independently of y, and let a read C_i h occur after prefix P_i=J_i…J₁. All those reads can be replaced by the single initial read C_total h, where C_total=Σ_i C_i P_i, without changing final helpers or target. The read charge becomes A(C_total); the helper-word charge is unchanged.", + "proof": "At the i-th read the helper value is P_i h₀, so its contribution is C_i P_i h₀. Additive target updates commute because none of the J_i reads or changes y, and no intervening operation observes y in this contract. Summing their contributions gives C_total h₀. Performing that read at entry therefore yields exactly the same final y and the same product P_s h₀. Each P_i is the displayed finite matrix product, so C_total is computable offline; it is not replaced by Σ_i C_i unless all prefixes are identities. The replacement includes all nonzero entries of the collected matrix.", + "proof_sha256": "e56309ac4f3447d417e3ea6156ed3c08ae5e8d117d3cd19522a564a37c854e86" + }, + { + "id": "N007", + "title": "Explicit quotient consumer erases a dirty response", + "dependencies": [], + "dependency_description": "accounting", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Expose a source-consuming quotient output before paying standalone target compensation.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "classical annihilator applied to SOURCE.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "e4fd54adf8237414d45c0cdc5a2df8bf751bb0f9703c2559c3844639990158a3", + "volume": "volumes/01-native.md", + "anchor": "n007", + "statement": "If a producer returns y=Lx+Ch and a supplied dyadic matrix R satisfies R C=0, a consumer can add R y to an arbitrary output z and obtain z += R Lx with charge A(R), without reading h. Neither y nor h is claimed restored by this consumer.", + "proof": "Matrix distributivity gives R y=R Lx+R C h=R Lx for every h. The stated circuit consists solely of additions from the disjoint y block into z and therefore preserves both source blocks while incrementing z. It is valid for dirty h because the vanished coefficient matrix is identically zero, not because h belongs to a promised subspace. The equality R C=0 is a directly checkable finite certificate. If the global caller needs the original y rather than only this quotient output, that requirement is outside this changed consumer contract and is not silently supplied.", + "proof_sha256": "c284e60e1362f99344d10988c0847eaf86d44efef399581f27817eec56e776da" + }, + { + "id": "N008", + "title": "Fuse a residual correction into a known consumer", + "dependencies": [], + "dependency_description": "accounting", + "frontier_target": [ + "SOURCE" + ], + "action": "Replace separate producer correction and consumer multiplication by the composed `SOURCE` read D C.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "adaptation.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "c520597de5517c7a315c7e814dbeeb7020a431a8c1a13c8a743f177fa65db2d2", + "volume": "volumes/01-native.md", + "anchor": "n008", + "statement": "For a producer y=Lx+Ch and a desired consumer increment D Lx, the two explicit reads z += D y; z -= D C h implement that increment with charge A(D)+A(D C), preserving y and h.", + "proof": "The first read contributes D Lx+D C h. The second subtracts exactly the latter term using the original helper coordinates. No inverse of C or D is used. Thus this works even when C has full column rank or D C is nonzero, unlike an annihilating quotient. Both reads are executed into the same additive target z, so its original value is retained. The circuit offers a finite changed boundary: the consumer accepts the producer's uncorrected y and the still-live h. It cannot be used after h has changed unless the known transformed coordinates are included, as in N010. Its cost explicitly pays the carried correction.", + "proof_sha256": "6baf323969cd9829c705c3e861af4e5f7c3d496c6c412bf2bdb2ff8e530429a2" + }, + { + "id": "N009", + "title": "Disjoint kernel rewrites compose without cross terms", + "dependencies": [ + "N002" + ], + "dependency_description": "N002", + "frontier_target": [ + "compensation", + "cleanup" + ], + "action": "Combine independently proved quartet kernel edits before generating one complete `compensation` and inverse `cleanup`.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "adaptation of direct-sum algebra.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "bb4958fa33622b69f657c24432bcf008d067c401bfea3669170d908a35eb676f", + "volume": "volumes/01-native.md", + "anchor": "n009", + "statement": "Partition h into blocks h^(j). Suppose each explicit S_j acts only within its own block, and the forward helper change is their direct sum S. Then C S is obtained by transforming each column block separately, all S_j commute, and forward/inverse scalar charges are Σ_j 2|S_j|. Any zeroed response columns remain zero in the combined rewrite.", + "proof": "A coordinate in block j is untouched by every S_i with i≠j. Applying two such maps in either order therefore gives identical coordinates, proving commutation. Matrix multiplication by the block-diagonal S multiplies C's j-th column block by S_j and cannot add another block's columns to it. The inverse is block-diagonal with S_j⁻¹; executing all inverse words restores every dirty helper. Scalar charges add because the displayed words have disjoint roles, even if their target response supports overlap. Only the column-bank disjointness is needed; disjoint target supports are a sufficient stronger condition but are not assumed here.", + "proof_sha256": "76c426e3a44f9b8f1559298f6da3a54dfb22ad575a76b05e3b7bebccca56f0a1" + }, + { + "id": "N010", + "title": "Defer correction through a fully known helper change", + "dependencies": [ + "N002" + ], + "dependency_description": "N002", + "frontier_target": [ + "compensation", + "B" + ], + "action": "Retiming `compensation` past a known `B` helper change, with an honest transformed-helper or restored-helper boundary.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "adaptation.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "a8154fee4d08576458816950ced87c3f2129961359c78d52c4985c88e3823cb7", + "volume": "volumes/01-native.md", + "anchor": "n010", + "statement": "Suppose the available helper output is h'=J h for an explicit invertible elementary word J. A dirt response C h can be canceled at that later boundary by subtracting (C J⁻¹)h'. The read costs A(C J⁻¹); returning the original helper ABI costs the explicit inverse word |J| if it has not already been applied.", + "proof": "Since J⁻¹h'=h, the later read equals C h on every original helper vector. Thus it removes exactly the old response even when J mixes several dirty helpers. The inverse entries are available from the displayed inverse word, so no division oracle is assumed. If h' is accepted as the new boundary, no restoration is asserted. If the old helper ABI is required, applying J⁻¹ restores it and is charged. This separates two valid contracts rather than counting a changed basis as a free return to the old one. Any new nonzero entries in C J⁻¹ are included in the read charge.", + "proof_sha256": "1a1704f40b946b035c5dbc6219f3a20ab2c71542edfda51a9bb25ef3096a050d" + }, + { + "id": "N011", + "title": "Nilpotent kernel stabilizer with a paid implementation", + "dependencies": [ + "N005" + ], + "dependency_description": "N005", + "frontier_target": [ + "start_extra", + "compensation" + ], + "action": "Search cheap kernel stabilizers that alter `start_extra` geometry while leaving `compensation` unchanged.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "constructive adaptation.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "74257a10870c09851c5006a6122c732696e4babc02fca08686d497ca522a95fb", + "volume": "volumes/01-native.md", + "anchor": "n011", + "statement": "Let C u=0 and vᵀu=0 for explicit dyadic vectors. Then S=I+u vᵀ is invertible with inverse I−u vᵀ and C S=C. It can be applied to arbitrary dirty h using one cleared aggregate t at charge 2A(vᵀ)+A(u)+2 CLEAR.", + "proof": "The square of u vᵀ is u(vᵀu)vᵀ=0, so multiplying the two displayed matrices gives I in both orders. Also C S=C+(Cu)vᵀ=C. To implement S, compute t=vᵀh, add u t to h, then subtract vᵀh from t. After the update the new aggregate is vᵀh+(vᵀu)t=t, so this subtraction clears t exactly; the lifecycle clear charges are explicit. The helper change can therefore alter internal coordinates without changing the compensation matrix. Its inverse uses −u and the same construction. This supplies an actual sparse stabilizer word rather than inferring physical freeness from invariance.", + "proof_sha256": "0ac5b986ff371f9e1334c386eac0c758ce63a5fc9cc7f99542b27da36a9db85d" + }, + { + "id": "N012", + "title": "One helper chart serving several response banks", + "dependencies": [ + "N002", + "N003" + ], + "dependency_description": "N002–N003", + "frontier_target": [ + "A" + ], + "action": "Build a common `A` chart for several target/centre response ledgers instead of independently incompatible rewrites.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "adaptation.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "144b7daa8915d619fdd1154b9eb653201e25f8d2b6dcbc529fb936d8590de4c9", + "volume": "volumes/01-native.md", + "anchor": "n012", + "statement": "Given dyadic response matrices C₁,…,C_s on the same helpers, a kernel vector of their vertically stacked matrix is a common kernel vector. Applying the explicit N003 word to a unit-pivot stacked kernel removes its pivot source from every bank, at the same helper-word charge, while paying every remaining bank's transformed reads.", + "proof": "Stacking means that the product of the stacked matrix with k is the vertical list of C_i k. It vanishes exactly when every listed product vanishes. N003 constructs a single invertible helper word S from this k. Its pivot column is k, hence every C_i S has zero in that position. The helper word is executed once because all banks see the same changed input h; separate compensation reads then cancel each bank's actual C_i S response. Inverse cleanup executes S⁻¹ once. This avoids charging one basis change per receiver but does not identify their distinct target additions or erase any nonzero residual column.", + "proof_sha256": "ac0feed7a935c8cb8cc281783c342cd839d6c0490c5b94f31e69028f3e717d23" + }, + { + "id": "N013", + "title": "Global response compression with explicitly certified pivots", + "dependencies": [ + "N004" + ], + "dependency_description": "N004", + "frontier_target": [ + "compensation" + ], + "action": "Compress an actual multi-column `compensation` matrix using its checked dyadic column basis.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "constructive Gaussian application.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "ab3bc5bd495089a15f4541a8f43bd84d1e6b77f6ec3551d9c16ad75aeb8ddd8d", + "volume": "volumes/01-native.md", + "anchor": "n013", + "statement": "Let C have independent columns B and suppose every other column is B a_j, with all a_j explicitly dyadic. Form A from these coefficient columns. The single block word h_B -= A h_rest changes C to [B,0]; its complete forward/inverse charge is 2A(A). The coefficients may be obtained by elimination on a supplied unit-pivot row minor of B.", + "proof": "The new response is B(h_B−A h_rest)+B A h_rest=B h_B. Every rest helper is unchanged, so all updates into basis helpers commute; subtracting them is inverted by adding them back. To obtain a_j, restrict c_j=B a_j to the chosen square row minor and solve it by the stated unit pivots. The solution is dyadic because each pivot inverse is dyadic; substitution into all rows verifies the full column equality before the word is accepted. The inverse cleanup therefore restores every source, not only the chosen row minor. This gives a complete executable chart with a finite coefficient certificate.", + "proof_sha256": "f102d67494889e18819c0630ba596aec58898996e4ebfb6fa56a686f510aa719" + }, + { + "id": "N014", + "title": "Kernel extraction that fixes protected helpers pointwise", + "dependencies": [ + "N013" + ], + "dependency_description": "N013", + "frontier_target": [ + "A" + ], + "action": "Apply response compression when some `A` helpers are source partners with a fixed input ABI.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "adaptation.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "9ed1445f701889291d4a1d53b9a703469914105863822a805a8ee3b4d147f44d", + "volume": "volumes/01-native.md", + "anchor": "n014", + "statement": "Split helpers as (p,e), where p must never change. If C=[C_p,C_e] and C_e S_e=[B,0] for an explicit editable-helper word S_e, then diag(I,S_e) yields response [C_p,B,0], fixes p at every intermediate gate, and costs exactly the editable word and its inverse.", + "proof": "Every gate of S_e has both source and target in e, so it cannot modify a protected coordinate at any prefix. Multiplying the block response matrix by diag(I,S_e) gives the displayed response. The inverse word also acts only on e and restores its arbitrary input after native cleanup. Thus protection is stronger than an endpoint coincidence: it holds during the entire change of basis. All p-dependent reads remain in C_p and must still be paid. A full kernel of [C_p,C_e] that mixed p would not establish this contract; the construction uses only a verified kernel chart internal to e.", + "proof_sha256": "e6b369359e15ac05fa7e4e494f6f1e698e59545b408dc9e99bb6c168bb7f1e89" + }, + { + "id": "N015", + "title": "Integer two-column compression without dividing a runtime value", + "dependencies": [], + "dependency_description": "accounting", + "frontier_target": [ + "compensation" + ], + "action": "Compress proportional integer `compensation` columns without introducing an unavailable odd-denominator scale.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "classical Euclid with native charges.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "b16469535f6720ecb55c4026af0f3f3136275dc12496ad4989e7de896e711b36", + "volume": "volumes/01-native.md", + "anchor": "n015", + "statement": "If two response columns are a u and b u for integers a,b not both zero, Euclid's algorithm supplies an integer unimodular helper word taking their response to [g u,0], where g=gcd(a,b)>0. If its quotients are q_i, one implementation uses at most Σ_i(A(q_i)+4)+2 scalar primitives forward; restoring helpers pays the inverse word too.", + "proof": "Replace the larger coefficient by its remainder after subtracting q times the smaller column, then exchange columns. A column operation col_i ← col_i − q col_j is right multiplication by E_(j,i)(−q), so its helper gate is h_j ← h_j − q h_i, with transposed indices. Record the whole right product S of column operations and emit those helper factors in reverse chronological order, so their complete map is S. Column swaps give ordinary helper swaps. A swap is three additions and one negation, so each Euclidean step has the displayed bound. Signs can be normalized with at most two negations. If an initial exchange is needed, record it as a quotient-zero Euclidean step, including its swap charge. The terminating coefficient pair is (g,0); no register is divided by g. Each intermediate operation has determinant ±1 and an explicit integer inverse, so reversing the sequence restores arbitrary dirty helpers. Thus the construction remains in the dyadic compiler even when g is odd.", + "proof_sha256": "c7cc1e80878e0a68e581dea79806fd6f717edf4b5c32d84e16e466d7d9ec4da6" + }, + { + "id": "N016", + "title": "An annihilating polynomial yields a paid Krylov kernel", + "dependencies": [ + "N003" + ], + "dependency_description": "N003's construction with the pivot moved last", + "frontier_target": [ + "A", + "warps" + ], + "action": "Exploit repeated single-warp response orbits in `A`/`warps` with a verified annihilator.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "adaptation.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "29cb448b3d593497c2fb0554a63762d2d8abe65e4b20b7add648f4d95ad7f45f", + "volume": "volumes/01-native.md", + "anchor": "n016", + "statement": "Suppose response columns are c,Tc,…,T^d c and explicit dyadic coefficients satisfy (T^d+Σ_(ji)N_ij h_j, executed for i=n−1 down to 1, realizes (I−N)⁻¹h. Adding that transformed vector to y and reversing the sweep realizes y += (I−N)⁻¹h₀ at charge 2Σ_(ii already has its solved value. Thus the final vector solves h=h₀+Nh coordinate by coordinate. Strict triangularity gives N^n=0, so I+N+…+N^(n−1) is its explicit inverse and the solution is unique. Add the solved values to the target, then reverse every elementary addition; this restores all original dirty helpers while retaining the target increment. The dense sum over all directed paths is therefore produced by one sparse edge sweep, not by separately reading every path product. No unspecified triangular-solve primitive is used.", + "proof_sha256": "e47886fe25ee1abc452436e7c432373fea398e6931fb6b9071f71e158c39f98f" + }, + { + "id": "N041", + "title": "Construct cleanup by reversing only the non-target word", + "dependencies": [], + "dependency_description": "accounting", + "frontier_target": [ + "cleanup", + "A", + "B" + ], + "action": "Regenerate `cleanup` after a changed `A`/`B` word instead of assuming the old cleanup remains correct.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "classical uncomputation, exact native rule.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "a3c7e674ef81fbf639f3c0dce5cc20dbae84f9e4f6c312027f82d7dde175cce6", + "volume": "volumes/01-native.md", + "anchor": "n041", + "statement": "Consider a word whose target gates only add functions of non-target registers into y and never read y. Suppose its non-target gates form an explicit reversible word U of charge g. Appending U⁻¹ preserves the accumulated target output and restores every non-target input, at total non-target charge 2g plus all target reads.", + "proof": "Delete the target gates while following the non-target state: because none reads y, the remaining trajectory is exactly U on the original non-target vector. The target gates have recorded their increments into y but have not affected that trajectory. The appended inverse therefore returns every non-target register to its original value. It never touches y, so all recorded increments remain. Initialization and release clears are outside the reversible word and must be charged by their private-work contract. In particular a destructive CLEAR inside U cannot be inverted by this theorem. The construction applies to arbitrary helper values and yields a concrete inverse cleanup list.", + "proof_sha256": "28286691e4a75d2adfa6580f2d8ccbfd7aaf2d54c164cb95e8399945578be07e" + }, + { + "id": "N042", + "title": "Transpose and inverse-transpose a complete scalar response", + "dependencies": [], + "dependency_description": "accounting", + "frontier_target": [ + "LOCAL" + ], + "action": "Produce an explicit `LOCAL` scalar dual before the native frame/phase audit.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "classical transposition principle with a restricted valid alphabet.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "8c26576ef536c945eaff96816d29e472cb583390af282c135da59fefa8c83da4", + "volume": "volumes/01-native.md", + "anchor": "n042", + "statement": "A work-free scalar word realizing the block shear (x,y)↦(x,y+Cx) yields explicit words for the transpose shear and its inverse transpose. For the transpose, reverse the gate order and transpose each elementary addition. For the inverse transpose, keep the original chronological gate order and inverse-transpose each addition, negating its coefficient. Expanded scalar charges are unchanged.", + "proof": "If the original product is G_s…G₁, its transpose is G₁ᵀ…G_sᵀ. The transpose of an addition with coefficient c from j to i is the addition with c from i to j. Thus the displayed reversed list realizes the transposed matrix, whose off-diagonal block is Cᵀ. The inverse transpose is G_s^(−T)…G₁^(−T), so its chronological order is the original order with each gate replaced by its inverse transpose. Addition coefficients change sign but their compilation charges do not. All other source/target coordinates follow the exact transposed block matrix, so no zero-helper assumption is needed. This theorem is scalar; transporting positive-rank native children requires their separate actual dual interface.", + "proof_sha256": "97c14a87babb5ec244d8fb684b98565b6d948e8784b59abce996e45c97459db6" + }, + { + "id": "N043", + "title": "A dyadic reflection with exact aggregate cleanup", + "dependencies": [ + "N005" + ], + "dependency_description": "N005 accounting", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Build an explicitly paid norm-preserving helper chart for N002 when its entries are dyadic.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "classical reflector with native cleanup detail.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "90b674e90d27b45302424ac8271b47eab375410a8b9ccdcb95ae1a41511f2fc4", + "volume": "volumes/01-native.md", + "anchor": "n043", + "statement": "For an explicit real dyadic vector u with uᵀu=1, the reflection H=I−2u uᵀ is an involution and preserves the Euclidean norm. It has a one-aggregate implementation of charge 2A(uᵀ)+A(−2u)+2 CLEAR, even when h starts dirty.", + "proof": "Multiplication gives H²=I−4u uᵀ+4u(uᵀu)uᵀ=I, and symmetry gives HᵀH=I. For the circuit, compute t=uᵀh and replace h by h−2ut. The new inner product is uᵀh−2t=−t. Therefore adding uᵀh_new into the retained t clears it, unlike the subtract operation used in ordinary factor evaluation. This proves the exact scratch return as well as the endpoint. Norm preservation holds for the whole stated vector bank; it is not claimed for each separate physical family or charged as a rank-zero native warp without another proof.", + "proof_sha256": "489b28a5e4f8a386f030c8280db8e2920bfe75e1d17caffd24672c2259139b2e" + }, + { + "id": "N044", + "title": "Collision-free logical layers for a bipartite read block", + "dependencies": [ + "N033" + ], + "dependency_description": "N033", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Generate noncolliding native read batches for later entrance/retention construction.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "constructive greedy scheduling adaptation.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "89fa5d0ba43062ad80c1ebe8e1ca4a6c43168635b3957015b9ca08b7b35b2f6c", + "volume": "volumes/01-native.md", + "anchor": "n044", + "statement": "A response block with disjoint source and target banks and at most Δ nonzero entries incident to any register, with Δ ≥ 1, can be scheduled in at most 2Δ−1 layers of pairwise disjoint scalar reads, with exactly the original total coefficient charge.", + "proof": "Regard each nonzero read as an edge from its source to its target. Greedily color edges. An edge meets at most Δ−1 previously colored edges at either endpoint, hence at most 2Δ−2 forbidden colors; one of 2Δ−1 colors is available. Each color class has disjoint endpoints. Because targets never serve as sources in this block, all reads commute and retain the same output sum under the new ordering. The coloring therefore supplies an actual legal word partition, not merely a degree lower bound. Each coefficient is emitted once. These are logical layers; physical parallel execution or shared frame conversions require their separately stated interfaces.", + "proof_sha256": "95f6db9912b7af17d79fb6b710b728a0e48d493ca29786e928234def83bd240b" + }, + { + "id": "N045", + "title": "Balanced dirty aggregation with restored inputs", + "dependencies": [], + "dependency_description": "accounting", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Replace a high-fan-in unit-coefficient compensation read by an explicit low-depth aggregate word.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "classical reduction with complete dirty restoration.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "a86fc8ae691d91026ee5fb0a0cbe1065cfa8d290855eada37c1595b4568775bd", + "volume": "volumes/01-native.md", + "anchor": "n045", + "statement": "For d ≥ 1 arbitrary dirty source registers, their sum can be added into y using 2(d−1)+1 unit additions, with every source restored and no aggregate bank. A balanced choice of pairings gives at most 2⌈log₂d⌉+1 logical addition layers.", + "proof": "Pair live partial sums, adding one register of each pair into the other, and retain the receiver as the representative of the union. Unpaired representatives pass to the next round. After at most ⌈log₂d⌉ rounds one representative contains the sum of all original sources; exactly d−1 additions were used, since each addition decreases the number of representatives by one. Add that representative to y. Reverse the recorded additions to restore every original source, including those temporarily overwritten by partial sums. Disjoint pairs form legal layers; the reverse has the same layer count. No source clear or assumed clean initial value occurs.", + "proof_sha256": "080a64b529c1d6d77989060372ad3715093da75163018b0c88b91a9742285128" + }, + { + "id": "N046", + "title": "Retain a helper chart as an explicit consumer boundary", + "dependencies": [ + "N041" + ], + "dependency_description": "N041", + "frontier_target": [ + "SOURCE", + "cleanup" + ], + "action": "Form a source-consuming `SOURCE` candidate instead of silently dropping `cleanup` from the old ABI.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "constructive boundary change.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "1991cf97bce98ffb82564ba94a80747ba3c0a3a304ed4653d1744c91ddf38cfc", + "volume": "volumes/01-native.md", + "anchor": "n046", + "statement": "If a producer computes h'=S h by a known elementary word and adds R h' to y, a consumer accepting h' can omit S⁻¹ with exact endpoint (h',y+RSh) and charge |S|+A(R). A consumer requiring old h must instead pay the inverse |S|.", + "proof": "Applying S to h gives its declared transformed value on every input; the target read adds RSh. There is no further change to h, so h'=Sh is the precise retained state. Omitting the inverse does not somehow restore h; it changes the output contract to expose that state. Since S has an explicit inverse, a later source-preserving consumer may recover h at the stated charge, or a genuinely consuming consumer may operate directly on h'. Both alternatives are complete local endpoints. Thus the construction identifies exactly where a cleanup can be eliminated and exactly which changed boundary must absorb it.", + "proof_sha256": "dfd5c3accaa2c45e970bb4d7ebc9d25ada39d5824e206cc2a5c89cccead395d6" + }, + { + "id": "N047", + "title": "Mutable-source shear with an explicit inverse", + "dependencies": [], + "dependency_description": "accounting", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Build a typed source-consuming preparation/consumer interface with a real inverse word.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "constructive semidirect block action.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "effb6ee1ba9080b3701acce3bf3c2be2964f5f785fb7bf511e7d977304f1bc54", + "volume": "volumes/01-native.md", + "anchor": "n047", + "statement": "Let M be an explicit reversible source word and L an explicit dyadic matrix. The map (x,y)↦(Mx,y+Lx) is implemented by first adding Lx and then running M. Its inverse is x←M⁻¹x followed by y←y−Lx. Alternatively, after running M first, read L M⁻¹x at charge A(L M⁻¹).", + "proof": "In the first implementation the target sees the original x, so its increment is Lx before the source becomes Mx. On inversion, M⁻¹ first returns that original source, allowing the exact negative read. In the second implementation the available source is x'=Mx, and L M⁻¹x'=Lx. Thus both programs realize the same complete mutable-source endpoint, including arbitrary old y. Every source restoration or later read is explicit; no caller is allowed to read Mx as if it were x. The choice compares two known coefficient maps rather than assuming source mutation is harmless.", + "proof_sha256": "0aad5876fbafce05cb586deb6ff3a72cf5b9d3891c3fe2c89e0f4b3c2dffec59" + }, + { + "id": "N048", + "title": "Telescope target corrections across source evolution", + "dependencies": [ + "N047" + ], + "dependency_description": "N047", + "frontier_target": [ + "SOURCE" + ], + "action": "Fuse a chain of explicit correction differences in a mutable `SOURCE` schedule.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "telescoping with a complete execution boundary.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "6fef89d1ff853200ef4f1e3c6e73cbcb2826ea60276fb5a8c67943f0b235237e", + "volume": "volumes/01-native.md", + "anchor": "n048", + "statement": "For a known sequence x₀,…,x_s generated by reversible source words, target increments L(x_i−x_(i−1)) sum to L(x_s−x₀). If no intermediate target value is read, replace the 2s matrix reads by the two reads −Lx₀ and +Lx_s, preserving the complete source trajectory.", + "proof": "Expand the sum as Lx₁−Lx₀+Lx₂−Lx₁ through Lx_s−Lx_(s−1). Every interior term appears with both signs and cancels in the additive target group, leaving the stated endpoints. The source words never read y, so moving the target writes to entry and exit cannot change that trajectory. The old target value is retained throughout. Both remaining reads cost A(L), and every source word is still paid. If an intermediate y is observed or used as a control, the stated hypothesis fails; no schedule move is inferred in that case.", + "proof_sha256": "59467f2673cab732bdaef22678d20f62c43e3670b25039c4db4417c332789511" + }, + { + "id": "N049", + "title": "Omit cleanup only for an explicitly invariant consumer", + "dependencies": [ + "N046" + ], + "dependency_description": "N046", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Match a changed helper chart to a verified final consumer before deleting its cleanup.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "observable-contract adaptation.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "f98e26765f869b709dc798dd34a4e42c671e42847959b2957610b90b12a99466", + "volume": "volumes/01-native.md", + "anchor": "n049", + "statement": "Suppose a producer's completed required data output is already correct, its helper output is S h, and the only remaining use of helpers is an explicit read z += R h with R S=R. The composition may read R(S h) directly and omit S⁻¹, at charge A(R) rather than |S⁻¹|+A(R); the helper bank is then consumed, not returned in the old ABI.", + "proof": "The consumer's required increment is R h. Its actual input is S h, but the finite identity R S=R gives R(S h)=R h for every dirty h. Therefore all observed data and consumer outputs agree with the cleanup-then-read program. The helper coordinates themselves need not agree, which is why they are explicitly discarded after this read and excluded from the returned interface. This is a sufficient composite construction with a specified consumer, not an assertion that arbitrary future uses are unaffected. Its saving is the concrete omitted inverse word, with all remaining reads still charged.", + "proof_sha256": "7fe5a6057cfb77e2be16d6b940456305140c825477d4b9f3723b2c5404a50332" + }, + { + "id": "N050", + "title": "A Schur consumer removes dirt using the returned helper", + "dependencies": [ + "N010", + "N047" + ], + "dependency_description": "N010 and N047", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Compose preparation and consumer so dirty response is canceled at a changed native boundary.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "constructive Schur-complement consumer.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "fda13e0eddb511279636a2bfa666a70384d70aab8b14015ca1e75eeea9c5d646", + "volume": "volumes/01-native.md", + "anchor": "n050", + "statement": "Suppose a producer returns y=y₀+Ax+Bh and h'=Cx+Dh, with explicit dyadic D⁻¹. The consumer y -= B D⁻¹h' gives y=y₀+(A−B D⁻¹C)x. It costs A(BD⁻¹) and retains h'. Returning old h additionally requires h←D⁻¹(h'−Cx), whose actual word and read must be paid.", + "proof": "Substitute h' into the correction: B D⁻¹h'=B D⁻¹Cx+B h. The B h term cancels exactly, leaving the displayed Schur response for arbitrary original h. The producer's source x is still available in this contract. If original helper restoration is requested, subtract Cx from h' and apply the supplied inverse D word, obtaining h. Thus the construction distinguishes a cheaper retained-helper consumer from a fully restored ABI, and computes the changed data map rather than pretending it remains A. Every inverse entry is explicit; no unspecified decoder is assumed.", + "proof_sha256": "4c3ade3d05eb159242ddb6f7a83317cc777d9e4366ec17459d62f252223dd91e" + }, + { + "id": "N051", + "title": "Two-sided response normalization with both charts charged", + "dependencies": [ + "N002", + "N019" + ], + "dependency_description": "N002 and N019", + "frontier_target": [ + "compensation" + ], + "action": "Evaluate a low-complexity normal form without forgetting target-basis restoration in `compensation`.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "paid normal-form construction.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "96e90264ce2412e653985c85ffca337fbde0cb9463f02fa903641627aed9f7cb", + "volume": "volumes/01-native.md", + "anchor": "n051", + "statement": "Suppose explicit elementary words S,T satisfy T C S=D, where D has only a specified small active block. A native response can be evaluated in those coordinates by helper chart S and target chart T, with both forward/inverse chart costs 2|S|+2|T| plus A(D). The original target increment is C h and all original inputs are restored.", + "proof": "Apply S⁻¹ to h, so its value is S⁻¹h₀. Apply T to the dirty target y. Add D(S⁻¹h₀) into that target, then apply T⁻¹. The resulting value is y₀+T⁻¹D S⁻¹h₀=y₀+C h₀. Finally apply S to restore h. Both target charts act on its old dirty value and cancel exactly. The active block need not be called a free rank-r primitive: its actual coefficient reads cost A(D). All four chart directions remain in the invoice. This provides a complete evaluation when sparse certified charts genuinely beat the original dense response.", + "proof_sha256": "a7735c8f64e2f74a7fa047ed1d49b6ad7ac24ef0b34dc02e35c07a67f980b7c7" + }, + { + "id": "N052", + "title": "Full block elimination with a checked Schur block", + "dependencies": [ + "N018" + ], + "dependency_description": "N018", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Jointly redesign preparation and consumer around an actual Schur response rather than pricing each cross block separately.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "classical block elimination with explicit local charges.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "1e847d6445dff5fa37b0af7fb8e583ae22ab7f2a73d7a1827d4585e7bbb5917f", + "volume": "volumes/01-native.md", + "anchor": "n052", + "statement": "Let M=[A,B;C,D] and let an explicit dyadic A⁻¹ be given. Define X=A⁻¹B, Y=CA⁻¹ and S=D−CA⁻¹B. Then L(−Y) M U(−X)=diag(A,S). The two off-diagonal chart words are explicit, costing A(X)+A(Y), and reversing them costs the same.", + "proof": "Right multiplication gives [A, B−AX; C,D−CX]=[A,0;C,S]. Left multiplication subtracts Y times the first block row from the second, giving [A,0;C−YA,S]=[A,0;0,S]. This calculation is valid with noncommuting matrix products in their displayed order. It constructs both charts from finite matrices whose entries can be checked directly. A native implementation must realize M through its known circuit or its entries, plus these chart words; the diagonal factors are not assumed to be free children. The identity supplies a concrete sparse-block boundary that a caller may consume or invert.", + "proof_sha256": "850aabf8f5760116e2d3ed848d4ed834efddfb4043be112f7ec7d1e797c6464c" + }, + { + "id": "N053", + "title": "Low-rank inverse update as a finite response circuit", + "dependencies": [ + "N024" + ], + "dependency_description": "N024", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Compile a changed decoder/helper inverse from a small certified correction problem.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "Woodbury construction with native-language accounting.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "c52da85c075ab48c9aec6173820a3a2858b98d2cdfea70fc16d91cfd987dba26", + "volume": "volumes/01-native.md", + "anchor": "n053", + "statement": "Let A⁻¹ and W=(I+V A⁻¹U)⁻¹ be supplied dyadic matrices. Then (A+UV)⁻¹=A⁻¹−A⁻¹U W V A⁻¹. A source-preserving inverse response uses the shared intermediates A⁻¹x, V A⁻¹x and W V A⁻¹x, at charge 2A(A⁻¹)+2A(V)+2A(W)+A(A⁻¹U)+n+2(n+2r) CLEAR.", + "proof": "Multiply A+UV by the proposed inverse. The extra terms factor as U[I−W−(V A⁻¹U)W]V A⁻¹=0 because (I+V A⁻¹U)W=I. For the other product order the extra term is A⁻¹U[I−W−W(V A⁻¹U)]V, also zero because W(I+V A⁻¹U)=I. Thus both product orders give the identity. For the circuit, compute the three listed private intermediates, add the first to y, subtract A⁻¹U times the third, then reverse all three computations. Their sizes are n,r,r, explaining the lifecycle clears. The n target additions and every factor read are charged. The inverse hypotheses are explicit finite matrices, not unspecified recovery gadgets.", + "proof_sha256": "304d3b2da2f6b8b70fcf0ef16d0dc147180a0aa328a8786a3c58cb37a58bd4ba" + }, + { + "id": "N054", + "title": "A nilpotent inverse without any runtime division", + "dependencies": [ + "N024", + "N040" + ], + "dependency_description": "N024 and N040", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Realize triangular/nilpotent correction inverses by a bounded explicit word.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "finite geometric series application.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "d8a69e4a6c21a0bc2c65b9d97b53b9bfc484c6e81bbcbc87b1b25fbb5b50399b", + "volume": "volumes/01-native.md", + "anchor": "n054", + "statement": "If an explicit dyadic K satisfies K^s=0 for an integer s ≥ 1, then (I−K)⁻¹=Σ_(j=0)^(s−1)K^j. Its additive response has charge 2(s−1)A(K)+s n target additions+2(s−1)n CLEAR, using the retained power chain as private work.", + "proof": "Multiplication of I−K by the finite sum telescopes to I−K^s=I on both sides. To evaluate it, take w₀=x and compute each w_j=K w_(j−1) into a separate cleared n-register block. Add all s vectors into y, then reverse the power-chain computations from j=s−1 down to 1. The source of each inverse computation is still retained at that point, so all private blocks return to zero. This pays two K applications per stored power and every target addition. No inverse coefficient, spectral decomposition or uncharged recursion is introduced.", + "proof_sha256": "e6da0779d6adc27e6fece421b1f8548d6e40f71b60d10612796590a08726ccbb" + }, + { + "id": "N055", + "title": "Idempotent correction with an allowed scalar unit", + "dependencies": [], + "dependency_description": "accounting", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Invert a known projector-like compensation update without a general matrix inversion at runtime.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "classical polynomial inverse with permitted coefficients.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "4597ae2ecf8e3a099905cfa7dd3130730ed90d552dec7c80c6df6616f5f5e637", + "volume": "volumes/01-native.md", + "anchor": "n055", + "statement": "If P²=P and u=1+c is a dyadic unit, then (I+cP)⁻¹=I−(c/u)P. Therefore a supplied response circuit for P immediately gives an inverse response using the explicit coefficient −c/u and the identity read, with all coefficient compilation charged.", + "proof": "Multiply the two expressions. The coefficient of P is c−c/u−c²/u=c−c(1+c)/u=0; the remaining term is I. This proves both product orders because every term is a polynomial in P. The unit assumption makes c/u a dyadic scalar, so the inverse does not request an odd-denominator primitive. For a matrix-entry implementation, add x into y and add −(c/u)P x, costing n+A(−(c/u)P). An existing explicitly factored P circuit may instead be used with its complete scaled coefficient costs. Old x is preserved in either additive response.", + "proof_sha256": "9cddd0f36325472155a28ea42affac51d58da75cdd480a89a7f32e15939e0de0" + }, + { + "id": "N056", + "title": "A square-zero full-bank chart with exact private return", + "dependencies": [ + "N011" + ], + "dependency_description": "N011's aggregate idea", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Build a simultaneous helper gauge from a checked nilpotent response operator.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "constructive matrix application.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "2db8df299c01c27468fbb5c7934c85c7fb7c29d315664b4a56300ea1be0767b0", + "volume": "volumes/01-native.md", + "anchor": "n056", + "statement": "For an explicit dyadic K with K²=0, the invertible helper change h↦h+Kh has inverse I−K. It can be implemented at charge 2A(K)+n unit additions+2n CLEAR using one private n-vector.", + "proof": "Compute t=Kh into cleared work, then add t into h. Since K(h+t)=Kh+K²h=Kh=t, subtracting K times the new h from t clears that work exactly. The helper output is (I+K)h₀, on arbitrary input. The inverse matrix identity (I−K)(I+K)=I follows immediately from K²=0 and gives the opposite-sign construction. This direct implementation is valid even when K has rank greater than one, so it can change an entire response subspace without requiring separate rank-one basis words. It still pays every nonzero coefficient of the explicit K and every lifecycle clear.", + "proof_sha256": "b5bdde4a0f8d3b31faab0a8644b14820403cfe03f9811748ea0ad24c9dcf69f2" + }, + { + "id": "N057", + "title": "Dyadic orbit-mean reflection", + "dependencies": [ + "N043" + ], + "dependency_description": "N043", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Change common-mode receiver coordinates without introducing non-dyadic normalization.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "constructive averaging chart.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "78b23df6031ed485c2c2ea00f7381078c43b0263e27466268a2cdf2208626948", + "volume": "volumes/01-native.md", + "anchor": "n057", + "statement": "For q a power of two, the map on q helpers h_i↦h_i−(2/q)Σ_j h_j is an involution, preserves the real Euclidean norm, and has charge 2q+qA(2/q)+2 CLEAR with one aggregate.", + "proof": "Let t be the sum of the original coordinates, formed by q additions into cleared work. Subtract (2/q)t from every helper. Their new sum is t−2t=−t, so adding that new sum into work clears it in q further additions. The map negates the constant vector direction and fixes every sum-zero vector, which are orthogonal subspaces; hence it is an involution and norm is preserved. The coefficient 2/q is dyadic by hypothesis and its q uses are explicitly charged. This is an ordinary scalar helper-bank reflection, not a claim of family-local native unitarity or a free physical permutation.", + "proof_sha256": "865fa4c6b967e6e49587c1f628dbd32b3b5fdf058b0e60f48c6b8e555581058f" + }, + { + "id": "N058", + "title": "Block-tridiagonal inverse with a sparse retained solve", + "dependencies": [ + "N052", + "N041" + ], + "dependency_description": "N052 and N041", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Compile a banded native response inverse without materializing its dense inverse matrix.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "classical elimination, complete local realization.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "99290848038e83fa8ca82b9ebd3813d0f0ba5a30c650c1961a3e89ac65d6c069", + "volume": "volumes/01-native.md", + "anchor": "n058", + "statement": "For a block-tridiagonal matrix with diagonal A_i, lower L_i and upper U_i, suppose the pivots D₁=A₁, D_i=A_i−L_iD_(i−1)⁻¹U_(i−1) have supplied dyadic inverses. Forward variables z_i=b_i−L_iD_(i−1)⁻¹z_(i−1) and backward variables x_i=D_i⁻¹(z_i−U_i x_(i+1)) solve Mx=b. They yield an additive source-preserving inverse circuit by one retained computation and its inverse.", + "proof": "Eliminating the previous variable from row i subtracts L_iD_(i−1)⁻¹ times the reduced previous row, producing exactly pivot D_i and right side z_i. Induction proves this reduced upper-bidiagonal system. Substituting from the last row upward gives the displayed x_i and satisfies every reduced equation, hence every original equation. Compute all z_i,x_i privately, add x into the target, then reverse the entire computation. With total dimension n and forward charge Γ=n+ΣA(L_iD_(i−1)⁻¹)+ΣA(D_i⁻¹)+ΣA(D_i⁻¹U_i), the full charge is 2Γ+n+4n CLEAR. All pivots are finite supplied matrices, not runtime inverse oracles.", + "proof_sha256": "7f53b0f9b9f9034a0b6828c93f0aa65346d990c0f8fc83242d312aca05217ac2" + }, + { + "id": "N059", + "title": "Arrowhead inverse through one shared aggregate", + "dependencies": [ + "N027", + "N052" + ], + "dependency_description": "N027 and N052", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Replace an arrowhead correction/decoder block by its charged shared response.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "constructive structured inverse.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "ab0ba50039a47ad9fa51efaadbd684507fa30b23ea7646e48099c6783f4e0afd", + "volume": "volumes/01-native.md", + "anchor": "n059", + "statement": "Let M=[D,u;vᵀ,a], with diagonal dyadic-unit D and dyadic-unit s=a−vᵀD⁻¹u. Its inverse is diag(D⁻¹,0)+w s⁻¹zᵀ, where w=(D⁻¹u,−1) and zᵀ=(vᵀD⁻¹,−1). It admits the diagonal-plus-one-aggregate circuit of N027.", + "proof": "The block elimination in N052 leaves the scalar Schur pivot s. Solving gives last coordinate s⁻¹(b_last−vᵀD⁻¹b_top) and top coordinates D⁻¹b_top−D⁻¹u times that last coordinate. Expanding these two formulas gives exactly the stated diagonal matrix plus w s⁻¹zᵀ. All inverses are allowed unit scales and all vectors are explicit dyadic data. The response circuit therefore costs Σ_iA(D_ii⁻¹)+2A(zᵀ)+A(w s⁻¹)+2 CLEAR, with no omitted off-diagonal reads. This implements a dense inverse using one aggregate rather than asserting a rank bound without an executable word.", + "proof_sha256": "7aca2d7e915c9ef7f8bdede2579432ba69b66453868ea9ac3552d00f310baf0d" + }, + { + "id": "N060", + "title": "Change only a split helper image and preserve its kernel", + "dependencies": [ + "N056" + ], + "dependency_description": "N056", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Alter only a chosen response image while preserving protected kernel directions in a helper chart.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "constructive splitting application.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "2edbd0162812d018e2ca81a1aa4eb3468e8700bb5fff12258d2978b7606ea9c4", + "volume": "volumes/01-native.md", + "anchor": "n060", + "statement": "Let A B=I_r and let J=I_r+K be an explicit invertible r-register word. Then G=I+BKA is invertible, acts as J on the B-image, and fixes ker A pointwise. With supplied dyadic J⁻¹A, it has charge A(A)+A(BK)+A(J⁻¹A)+2r CLEAR using r aggregate registers.", + "proof": "Compute t=Ah, add BKt into h, then subtract J⁻¹A times the new h from t. Since A h_new=(I+K)Ah=Jt, the subtraction clears t exactly. If h=Bz, then G h=B(z+Kz)=BJz; if Ah=0, the update is zero. Every h splits as BAh+(h−BAh), and the second summand lies in ker A. Thus the explicit inverse applies J⁻¹ on the first component and identity on the second, namely I+B(J⁻¹−I)A. All source directions and their returned states are specified, and no action on an unobserved complement is left unknown.", + "proof_sha256": "7d18ebfe5ef8ab5d1adc64c1581035926aa7753979e1324032f871c414c95cbb" + }, + { + "id": "N061", + "title": "One common-frame batch with all promotions listed", + "dependencies": [], + "dependency_description": "accounting", + "frontier_target": [ + "A" + ], + "action": "Emit an explicit shared-frame `A` batch and its exact CHILD ledger.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "constructive ledger application.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "e1a00732f6084207c7a58c1e5db71e3596421e94c98999a9d044ba5ed1230b70", + "volume": "volumes/01-native.md", + "anchor": "n061", + "statement": "Given initial frames F_i and a scalar helper word whose operands all accept the common frame J containing every F_i, promote each used register once to J, execute the word, and, if needed, its scalar inverse at J. The ledger charges exactly Σ_i H_(dim J−dim F_i) plus the scalar word charges; its final frames are J.", + "proof": "The inclusions make every listed promotion legal in the ledger model. After promoting all operands, every scalar gate has both of its registers at the declared common frame. Scalar operations do not change these labels, so induction through the gate list proves validity of the whole word and its inverse. The inverse restores logical data but does not demote a frame; the returned labels remain J. Each register is promoted exactly once, giving the displayed multiset of positive-rank charges. This is a sufficient frame schedule with a completely specified larger-frame boundary, not a claim that logical invertibility alone restores a native entrance frame.", + "proof_sha256": "e1b3b9d0d08ddf4eb0b8b13164a387b2bf5dbc9613098315a5d811ce02211e9b" + }, + { + "id": "N062", + "title": "Nested requirements admit a deterministic promotion schedule", + "dependencies": [ + "N061" + ], + "dependency_description": "N061", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Generate a complete staged reader ledger before comparing shared-kernel schedules.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "explicit monotone construction.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "4227a8e87b5fdba91f5fd49b7a353576f600c101788c7350e35f3564c8feba0b", + "volume": "volumes/01-native.md", + "anchor": "n062", + "statement": "Suppose a register's successive required frames form E₁⊆…⊆E_s and its entrance F⊆E₁. Promote it just before each strict increase. The ledger is valid, ends at E_s, and its positive ranks are dim E₁−dim F and dim E_i−dim E_(i−1), with zero differences omitted.", + "proof": "At the first read the initial promotion places the register at E₁. If a later required frame is unchanged, no operation is needed. Otherwise its containment of the preceding frame makes the next promotion legal, after which the corresponding read is aligned. Induction covers every read, with no downward step. Adding the dimension increments telescopes to dim E_s−dim F, while their separate H charges remain separate; equal rank mass is not silently identified with equal paid cost. The algorithm is constructive from a finite list of subspace bases and records every actual promotion.", + "proof_sha256": "60d956d772d2ddfef6fda797f7c67a2b53bdda2147efd98778249cd4bb11ba46" + }, + { + "id": "N063", + "title": "Equal-frame helper mixing adds no recursive promotion", + "dependencies": [ + "N002" + ], + "dependency_description": "N002", + "frontier_target": [ + "A" + ], + "action": "Delay a kernel basis change until its actual helper operands have equal frames, as in staged `A` sharing.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "native ledger adaptation.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "7d9b851f7a8df02321b370aba8f7eea396c8ebfe2ca6942d6ff97ca4d3c3d6ff", + "volume": "volumes/01-native.md", + "anchor": "n063", + "statement": "If every gate of an elementary helper word connects registers in the same current frame class and preserves those labels, the word and its inverse add no positive-rank ledger transition. Their full scalar charge remains 2|S|.", + "proof": "Every gate reads two registers already aligned at its stated frame, so no promotion is required before it. An addition changes logical values, not the common frame label, allowing the argument to continue through the word. The reverse signed word uses the same pairs and labels, hence is valid under the same conditions and restores all dirty helper values. This proves only zero extra promotion cost of this particular mixing word. It does not say the word is scalar-free, unitary on physical families, or compatible with a different initial frame assignment. Each scalar primitive and private coefficient lifecycle is included in |S|.", + "proof_sha256": "aa59ab0343071d905bdbc5842135dc964fd21af3cb0715d1deb482a2a27266d4" + }, + { + "id": "N064", + "title": "A certified common entrance replaces only first climbs", + "dependencies": [ + "N003" + ], + "dependency_description": "N003 or another endpoint constructor, plus the ledger definition", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Turn a proved dirt-entry change into exact first-climb and width edits.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "adaptation.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "207a46ff2a366ecf9d438165cc5ef24177227cc3cd0a57b917d8d8de1071b0f6", + "volume": "volumes/01-native.md", + "anchor": "n064", + "statement": "In an existing monotone ledger, let a helper's first required frame be E. Replacing its entrance 0 by any supplied F⊆E leaves all later ledger steps valid and replaces the first rank dim E by dim E−dim F. Its ordered residual width decreases by dim F when its final frame is unchanged.", + "proof": "The replacement first step is the legal inclusion F⊆E. It reaches exactly the same frame E as the original first step, so the remainder of the unchanged ledger starts from identical labels. Thus all subsequent promotions and reads remain valid. The residual width is final dimension minus entrance dimension, so its change is exactly −dim F. This is a constructive frame statement, not an arbitrary-dirt endpoint proof: pairing it with a verified zero-response kernel or a paid compensation construction is required. Both the replaced CHILD label and the changed helper width are explicit outputs to the caller's complete invoice.", + "proof_sha256": "d0d74c1eb45f16a05f928df89d3e5927193119b590e07fe6c00fdd0511724abc" + }, + { + "id": "N065", + "title": "A row-ordered triangular helper word has a monotone flag schedule", + "dependencies": [ + "N033", + "N062" + ], + "dependency_description": "N033 and N062", + "frontier_target": [ + "A" + ], + "action": "Build a legal staged triangular `A` rewrite without dropping fill-in or inventing demotions.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "constructive flag scheduling.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "561643d887926511c7ce3dbf9471512919931aa52cb4d7be7e130f207d3ddc58", + "volume": "volumes/01-native.md", + "anchor": "n065", + "statement": "Let F₁⊆…⊆F_n. A word that processes target i in increasing i and only reads helpers j0 after the producer. The transformed increments are L_0x+C h in bank 0 and (L_i−L_0)x in every other bank. The chart costs d(m−1) unit subtractions; its inverse has the same charge.", + "proof": "Write each final output as its own initial value plus the stated increment. Subtracting the final y_0 from final y_i changes the initial output basis to y_i^old−y_0^old and subtracts both increments. The common C h cancels exactly, leaving (L_i−L_0)x. Register y_0 is unchanged throughout these subtractions, so all differences use the correct common value. Adding z_0 back to the other banks reverses the chart. Thus no information is discarded and no claim is made that arbitrary initial output dirt vanished. Restoring the old output ABI also restores its old response distribution.", + "proof_sha256": "0f8dd25ee46ad3a1b6b8f4394b9dabb1499b4d505c9128827408cd4ad22ab6e2" + }, + { + "id": "N090", + "title": "Localize separable grid dirt to the boundary", + "dependencies": [ + "N089" + ], + "dependency_description": "N089's output-chart semantics", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Convert a supplied two-dimensional separable dirt pattern into boundary-only dirty channels for an explicitly changed consumer.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "finite-difference response chart.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "f8c27892b81e433c08f0df4b09824a1690dc1f8ae2a9096b1368967268a77ce0", + "volume": "volumes/01-native.md", + "anchor": "n090", + "statement": "Let r,s ≥ 1 and let output banks y_(i,j), 0 ≤ i < r and 0 ≤ j < s, have helper responses C_(i,j). Suppose every interior mixed difference C_(i,j)−C_(i−1,j)−C_(i,j−1)+C_(i−1,j−1) is zero. Successive backward row differences and backward column differences give an invertible output chart whose interior banks have zero helper response. Its charge is d((r−1)s+r(s−1)) unit subtractions for d-dimensional banks; its inverse has the same charge.", + "proof": "First process i from r−1 down to 1, replacing row i by row i minus row i−1. The decreasing order ensures the subtracted row is its original value. Then process j from s−1 down to 1, subtracting column j−1 from column j in every row of the transformed array. An interior response is precisely the displayed mixed difference and hence zero. Top and left boundary responses are retained; they need not vanish. Reverse the column operations and then the row operations to invert the chart. This proves the endpoint including arbitrary old output values, not only its response coefficients. Each edge difference uses d unit subtractions, giving the exact ledger.", + "proof_sha256": "d282d4ace4df30cddf904a11c8f933a310c77f9713b60c6110d1a9c7a9bce80b" + }, + { + "id": "N091", + "title": "Emit the actual four-helper shared-kernel chart", + "dependencies": [ + "N002", + "N063" + ], + "dependency_description": "N002 and N063", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Emit and check the PR #2857 quartet chart without confusing its three-gate boundary form with its separately charged staged implementation.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "explicit source precedent, independently derived; not a new discovery claim.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "9345bb89f822bdfa5693c651b35a3210211ff1ee07c501738fa82352c8faa202", + "volume": "volumes/01-native.md", + "anchor": "n091", + "statement": "Let four equal-frame helpers have compensation columns c_0,c_1,c_2,c_3 with c_0+c_1−c_2−c_3=0. The three updates h_1 += h_0; h_2 -= h_0; h_3 += h_2 emit the matrix S=[[1,0,0,0],[1,1,0,0],[−1,0,1,0],[−1,0,1,1]]. The transported compensation is [0,c_1,c_2+c_3,c_3]. Using this chart and its inverse costs six unit additions and no additional promotion at the equal-frame cut.", + "proof": "Name the original helpers a,b,c,d. The updates give (a,b+a,c−a,d+c−a); the last read uses the already updated third helper. This is the displayed S, whose first column is (1,1,−1,−1). Multiplying C by its four columns gives the stated compensation, including the changed third response c_2+c_3. Reverse the updates by subtracting the updated third helper from the fourth, then adding h_0 back to h_2, then subtracting it from h_1. This returns every original value. All operands share one declared frame, so the scalar chart requires no promotion there. Different-frame staged realizations must instead supply their actual ledger.", + "proof_sha256": "044e236dd234b1a39892c12a77b5f5d2f60f233a3fed0e9341c78061e680f606" + }, + { + "id": "N092", + "title": "Work-free compression of a repeated response column bank", + "dependencies": [ + "N002", + "N063" + ], + "dependency_description": "N002 and N063", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Concentrate repeated dirty responses in one existing helper instead of allocating a private sum bank.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "structured in-place kernel construction.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "1d9fb9429d58044b480a8535d3049ba9ea402c93ff1a5b8767ff40eec7401aa1", + "volume": "volumes/01-native.md", + "anchor": "n092", + "statement": "Suppose n helpers at one common frame have the same response column u. For i=0,…,n−2 in increasing order execute h_i -= h_(i+1). Their chart S changes C=[u,…,u] to C S=[u,0,…,0]. The chart and inverse together cost 2(n−1) unit additions and use no aggregate register.", + "proof": "Increasing order means each h_(i+1) is read before it is changed. Therefore S has 1 on its diagonal, −1 directly above the diagonal and zero elsewhere. Its first column is e_0, and column j>0 is e_j−e_(j−1). Multiplying the repeated-column response by these columns gives u and then zeros. The inverse is obtained by adding h_(i+1) back into h_i in decreasing order, restoring all arbitrary dirty helpers. This is a reversible in-place chart, not an assumption that their sum is initially clean. The equal-frame condition gives a promotion-free placement, while compensation reads and any later native climbs remain separately charged.", + "proof_sha256": "2566e61fb7c449f961e1b3b31047c9d62f26f94ba293f216084872bdde8d73d6" + }, + { + "id": "N093", + "title": "Delete inverse pairs across a certified independent interval", + "dependencies": [ + "N033" + ], + "dependency_description": "N033", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Simplify a newly emitted helper/cleanup word with a replayable cancellation certificate, rather than deleting commuting-looking gates by inspection.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "constructive trace-word reduction.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "eeaae6a92667dff7843e8127cb1a2be252a2189c7b34591ad94832a617b985fc", + "volume": "volumes/01-native.md", + "anchor": "n093", + "statement": "Let a scalar native word contain a reversible gate g, an intervening word V, and g⁻¹. If every gate of V has read/write supports independent of those of g, deleting g and g⁻¹ preserves the complete scalar endpoint and saves exactly their two implementation charges. Repeating this deletion rule terminates and emits an equivalent word with a nonincreasing charge.", + "proof": "N033 allows g to be exchanged successively with each intervening gate: neither gate changes a value read or written by the other. Hence the original substring is equivalent to V followed or preceded by adjacent inverse gates. Their actual maps compose to the identity on all dirty inputs, so deleting them is valid. Each deletion strictly shortens the finite gate list by two, ensuring termination. Record every chosen support test and deleted pair; replaying these finite identities proves equivalence of the final word. This is not an assertion of a unique normal form or globally shortest circuit. If gates include frame changes, their full actual maps and support contracts must satisfy the same independence test.", + "proof_sha256": "9dcc90f705fddbaa8b5ab33df3803acb0d1a95fe77e55e75622037d309c097f0" + }, + { + "id": "N094", + "title": "Compute the exact response of one staged insertion", + "dependencies": [ + "N011", + "N071" + ], + "dependency_description": "N011 aggregate implementation; N071 coefficient compilation.", + "frontier_target": [ + "A", + "B" + ], + "action": "Evaluate a literal dirt-entry insertion at an internal `A`/`B` cut, preserving noncommuting transport instead of treating it as an entrance basis change.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "exact staged sensitivity construction.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "e53b87c96f1bebc83db3e0e1484163e3290fe2c56c74d7da121cf6a77efb7aba", + "volume": "volumes/01-native.md", + "anchor": "n094", + "statement": "Encode a linear program on all live registers by a prefix P and suffix Q. Insert a shear I+a u vᵀ between them, with vᵀu=0 and a dyadic. The complete map changes from QP to QP+a(Qu)(vᵀP). For any declared output projection Π, its response change is the explicitly factored row/column product a(ΠQu)(vᵀP). The insertion and its inverse each have charge 2A(vᵀ)+A(a u)+2 CLEAR charges, using the aggregate construction of N011; a coordinate shear may instead use its one addition macro.", + "proof": "Multiply Q(I+a u vᵀ)P and distribute. The two terms are QP and aQuvᵀP, with the original order of every operator retained. The condition vᵀu=0 gives (uvᵀ)²=0, so the inserted map is invertible with inverse I−a u vᵀ. If u and v select distinct registers, it is one ordinary addition macro; for general finite vectors N011 computes t=vᵀz, adds a u t into z, then subtracts vᵀz_new from t, which clears because vᵀu=0. This gives the displayed charge without attempting an invalid in-place dense matrix addition. The prefix factor vᵀP is the actual value of the control at that cut, including any source signal and dirty response. It cannot be replaced by the original control coordinate unless this equality is checked.", + "proof_sha256": "17ba07e766468c43fe071fdc9a49138b89267d1c5752dad4e8a9b38c54d7b5fe" + }, + { + "id": "N095", + "title": "Retain the cross term of two ordered insertions", + "dependencies": [ + "N094" + ], + "dependency_description": "N094", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Construct or reject paired staged dirt-entry rewrites using their complete interference term.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "ordered rank-one insertion formula.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "e9916ea756856aa21d71eea5f25b01662621f13bb281276950747225a39dede1", + "volume": "volumes/01-native.md", + "anchor": "n095", + "statement": "With prefix P, middle M and suffix Q, insert E_1=I+a u_1v_1ᵀ and E_2=I+b u_2v_2ᵀ in that order, requiring v_1ᵀu_1=v_2ᵀu_2=0 for the reversible insertion contract. Their full map is QMP+aQMu_1v_1ᵀP+bQu_2v_2ᵀMP+abQu_2(v_2ᵀMu_1)v_1ᵀP. In particular the changes add linearly when the explicit transported cross scalar v_2ᵀMu_1 is zero.", + "proof": "Expand Q E_2 M E_1 P first in E_2 and then in E_1. The term selecting neither insertion is QMP; selecting only the first gives aQMu_1v_1ᵀP; selecting only the second gives bQu_2v_2ᵀMP. Selecting both gives the last term with precisely the transported control-response factor v_2ᵀMu_1. These four choices exhaust the product. Applying any output projection preserves the identity. Each insertion is emitted with its actual scalar and frame charges; its individual nilpotence condition supplies an explicit inverse. The vanishing-cross condition is a finite matrix equality, not a guess from disjoint labels before transport.", + "proof_sha256": "a0663fc04b0b2a3d4038841d8438857d538f3ad02f42a2d6c80f884414fdb0e0" + }, + { + "id": "N096", + "title": "Construct paired zero-target-defect insertions", + "dependencies": [ + "N095", + "N100" + ], + "dependency_description": "N095 and N100", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Emit a coordinated two-cut preconditioner that may change entrance geometry without creating an uncharged target correction.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "constructive compensated deformation.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "0afb948f0a477838251bc52695a1f606f25409d2745553620d3741efd06e4886", + "volume": "volumes/01-native.md", + "anchor": "n096", + "statement": "In N095 suppose v_2ᵀMu_1=0. Suppose the first and second projected response terms factor as αD and βD for an explicitly given matrix D and real dyadics α,β. Choosing a=β and b=−α preserves the entire projected target map, while generally changing the non-target path. It costs the two emitted shear words plus their inverse cleanup, with no compensation added for this target defect.", + "proof": "The vanishing transported cross scalar eliminates the term proportional to ab. The remaining projected change is aαD+bβD, which becomes βαD−αβD=0 in the central dyadic ring. This holds as a full input matrix, so it includes dirty-helper and source-signal columns, not just one tested input. The non-target map need not be unchanged; construct its inverse from the new ordered elementary word when restoring the old ABI. Thus the theorem supplies a genuine zero-target-defect deformation, not permission to reuse an obsolete cleanup. It remains meaningful if one coefficient is zero, but a useful two-insertion candidate selects a nonzero pair.", + "proof_sha256": "62294da13cb14f725dfeebfd4717775348edbffaa1fca6044ad0ed47683e7395" + }, + { + "id": "N097", + "title": "Borrow source signal along a dirty-response kernel", + "dependencies": [ + "N002", + "N021" + ], + "dependency_description": "N002 and N021", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Store a controlled source borrow in a compensation-invisible helper direction, with a complete old-ABI restoration path.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "source-entry kernel borrowing.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "1d5aa85bd9cec7e2eb4330a392e76e176ca56c79c775ebe67a3e5e066e216d25", + "volume": "volumes/01-native.md", + "anchor": "n097", + "statement": "Suppose a producer has increment Dx+Ch and source-preserving inverse non-target cleanup. If Cu=0, prepend h += u Vx, run the producer and its cleanup, then subtract u Vx from h. The complete target increment is still Dx+Ch and the original source/helper inputs are restored. The extra charge is 2A(uV), with an optional explicitly paid factor construction instead of dense multiplication.", + "proof": "The forward producer receives h+uVx, giving target increment Dx+Ch+CuVx. The kernel identity makes the last term zero. Its non-target cleanup restores exactly the producer's new input, namely x and h+uVx, after which the final subtraction restores h. No helper had to be initially zero, and the original source x remained available for the last subtraction. The direct implementation adds the supplied matrix uV twice with opposite signs, giving the stated charge. If a factorized implementation is used, its aggregate initialization, two analyses and release are charged by N021 rather than hidden in A(uV).", + "proof_sha256": "8238e35e5785d0d6b6cdfc4bb9d911572cb8fb395295915cd0e05718e108c790" + }, + { + "id": "N098", + "title": "Reversibly dilate a possibly singular response without inverting it", + "dependencies": [ + "N071" + ], + "dependency_description": "N071", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Embed a cheap singular response analysis into a reversible native boundary while retaining the displaced dirt bank for its consumer.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "unimodular linear dilation with fully paid rotation.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "8d40665a1c13c1d16ee737a737c90c98716e7350301fbc3a3d1f0b68de088c76", + "volume": "volumes/01-native.md", + "anchor": "n098", + "statement": "For any real dyadic n×n matrix M, the map J_M(x,h)=(Mx−h,x) is invertible on two arbitrary dirty banks and has an implementation of charge A(M)+3n. Its inverse is J_M⁻¹(u,v)=(v,Mv−u), also explicitly implementable at charge A(M)+3n. No inverse of M is required.", + "proof": "First perform h -= Mx. Rotate each pair (x_i,h_i) to (−h_i,x_i) using the three updates x_i -= h_i; h_i += x_i; x_i -= h_i, with the later updates using the changed values. On a pair initially (a,b), these yield (a−b,a,−b), hence final (−b,a). Applied after the matrix subtraction this gives (Mx−h,x). From output (u,v), the original x is v and h=Mv−u, proving the inverse formula. Reverse the actual emitted word to realize it at the same charge. This is an explicit changed two-bank source-consuming interface, not the source-preserving map x↦Mx when M is singular.", + "proof_sha256": "526eba2ef0c49469a67d60215aa054a15293e6347f38cbd71910d2b6eef94c32" + }, + { + "id": "N099", + "title": "Finite symbolic columns certify arbitrary-dirt endpoints", + "dependencies": [], + "dependency_description": "finite circuit linearity", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Produce a deterministic all-dirt response and restoration certificate for a changed literal word, including every private column restriction.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "exact source-bound verification principle.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "87a994effabacf7973b655bd44f9e2073f0a45ae3d04462532bdd4b02f06a55f", + "volume": "volumes/01-native.md", + "anchor": "n099", + "statement": "A finite linear circuit with specified source, helper, output and private-zero inputs admits an exact symbolic-column certificate: propagate a formal basis vector for every independent live input and zero for each private input. Equality of the resulting columns with a claimed endpoint proves that endpoint for every allowed dirty input. The propagation also constructs the complete response matrix C used by N100. Ordered operator coefficients may instead be retained as finite noncommutative polynomials; exact polynomial equality then holds under every substitution by actual linear operators.", + "proof": "Each gate replaces its affected formal row by exactly the linear combination prescribed by its real gate. Induction therefore identifies each recorded column with the image of that basis input. Every allowed input is a linear combination of those basis inputs, so linearity proves the claimed endpoint once all columns match. A private-zero input contributes no column; clearing an arbitrary live input must still be represented by its actual zeroing map and is not treated as reversible cleanup. In the operator version, distribution concatenates ordered words without commuting letters. Substitution into linear operators respects sums and ordered products, proving the same identity; expression size is finite but is not promised polynomially small.", + "proof_sha256": "71d294036bd0102d3be5448d9f467af9320ef0e0a828bfbcf1b5af326869e87e" + }, + { + "id": "N100", + "title": "Assemble a fully compensated local native invocation from a finite word", + "dependencies": [ + "N071", + "N080", + "N099" + ], + "dependency_description": "N071, N080 and N099", + "frontier_target": [ + "LOCAL scalar/helper contract" + ], + "action": "Turn an explicitly edited shared-kernel word into a complete local old-ABI supplier, recomputing compensation and cleanup instead of assuming the previous supplier's certificates still apply.", + "proof_status": "informal_proved", + "novelty": "classical/adaptation", + "provenance_description": "constructive sufficient local assembly; global compiler, recovery, phase and recurrence admission remain separate explicit interfaces.", + "scope": "local finite construction; no new numerical kappa; physical and global interfaces explicit", + "entry_sha256": "37461fce884eeaec691e8950f95dfb407434663bb96e25cdd85673e540d67be4", + "volume": "volumes/01-native.md", + "anchor": "n100", + "statement": "Let V be an explicit reversible non-target word of charge g, interspersed with additive target reads of total charge r; the target is never a control. Private non-target registers start at zero. Suppose N099 computes total target increment Dx+Ch on the live source/helper inputs. Execute this word, reverse only V, then subtract Ch from the target. The resulting invocation adds exactly Dx, restores all non-target live inputs and returns every private register to zero. Its scalar charge is 2g+r+A(C)+2m CLEAR charges for m private registers. Its child ledger is the full forward and inverse ledger actually implementing V and the reads, plus compensation's actual ledger.", + "proof": "The first pass has the certified target increment Dx+Ch and non-target state Vz, where z includes the zero private inputs. Since no target value controlled that pass, removing target reads does not change V. Reversing V therefore returns z exactly while leaving the accumulated target unchanged. The initial helper h is now available, so the final subtraction removes precisely Ch. The target retains its arbitrary old value plus Dx. The private registers were restored to zero before their release clears, so no input-dependent information is erased. The charge counts every forward non-target operation again in reverse, every original target read once, and the emitted compensation. No rank transition is deleted merely from this scalar proof.", + "proof_sha256": "c95be70165ea200e3ae4bb9e03a501cfbc1aaeb2acb7aaa9dadbf61d165ad0d6" + }, + { + "action": "Normalize an open predecessor boundary instead of calling it restored. The repair adds one S, one T and one explicitly charged data sign mask; the prefix bill is retained. Its control tables and sign table are finite objects computed from the displayed sums.", + "dependencies": [], + "frontier_target": "PR #2850 open P boundary; PR #2859 wrong-order returned phase", + "id": "P001", + "novelty": "Classical reconstruction or constructive frontier adaptation; no global novelty claim.", + "proof_status": "informal_proved", + "provenance": "constructive adaptation of Weyl normal form.", + "title": "A terminating consumer for every finite Pauli prefix", + "volume": "volumes/02-physical.md", + "anchor": "p001", + "statement": "Given a finite prefix with controls A, B and Q from the background formula and any specified target sign F(d), append W(A,B), then D_{F+Q+A·B}. The complete controller is D_F ⊗ I_bank on arbitrary joint input.", + "proof": "The prefix contributes A·c+Q and leaves c+B. The appended W contributes A·(c+B), restores c, and leaves total sign Q+A·B. The final sign adds F+Q+A·B, leaving F because every repeated binary term cancels. The equality holds at every (d,c), so it holds on arbitrary coefficients. No bank initialization is used.", + "proof_sha256": "71074eba4df30ccd5345dcde3b13c55f2d15f37631aef40ddf0b2a1ac59f8ba4" + }, + { + "action": "A target F with the explicitly checked identity F=A·B has a two-copy consumer costing twice every instruction of the prefix and no repair. A different target requires the D_{F+A·B} mask and its bill.", + "dependencies": [], + "frontier_target": "PR #2850 aggregate-parity shortcut", + "id": "P002", + "novelty": "Classical reconstruction or constructive frontier adaptation; no global novelty claim.", + "proof_status": "informal_proved", + "provenance": "source-directed reconstruction with the correct target specified.", + "title": "A doubled prefix closes to its aggregate pairing", + "volume": "volumes/02-physical.md", + "anchor": "p002", + "statement": "Execute the same finite prefix twice with unchanged controls. It returns the entire dirty bank and applies exactly D_{A·B}, independently of its internal phase Q.", + "proof": "The first execution gives sign A·c+Q and shift B. The second gives A·(c+B)+Q and another B. The shifts cancel and the signs sum to A·B. Internal cross terms Q occur twice and cancel, even when Q is nonzero. Thus this is a sufficient consumer for the aggregate pairing, not for an arbitrarily chosen sum of pairings.", + "proof_sha256": "e5c1353696b979374a7a234e7c0694f0bfc330e9cb6ff8454b6299d3541489b2" + }, + { + "action": "Use a reverse consumer when the caller admits that order. It uses 2f W instructions, hence 2f S and 2f T, and no correction mask or bank preparation. Any required caller reordering or movement is an additional bill.", + "dependencies": [], + "frontier_target": "PR #2850 reverse continuation, with arbitrary vector controls", + "id": "P003", + "novelty": "Classical reconstruction or constructive frontier adaptation; no global novelty claim.", + "proof_status": "informal_proved", + "provenance": "credited extension of the predecessor’s reverse schedule, not a new reverse-order discovery.", + "title": "Palindromic consumption with no clean bank", + "volume": "volumes/02-physical.md", + "anchor": "p003", + "statement": "For any f control pairs, run W₁,…,W_f,W_f,…,W₁. The endpoint is D_{Σ_j a_j·b_j} ⊗ I_bank.", + "proof": "The two middle W_f instructions give the scalar D_{a_f·b_f}. Data-only sign masks commute with every bank instruction because all controls read unchanged d. Move that scalar outside the remaining word. The middle pair then becomes W_{f−1}². Repeating this exact deletion leaves the product of all f scalar masks and no bank instruction. For f=0 the empty word is I and the sum is zero.", + "proof_sha256": "da1940aa090a20c6b983b1cf5d08a013f3606e51251b2b133121f96254bee845" + }, + { + "action": "A consumer may request a different local phase from the producer’s self-pairing, provided it executes the displayed mask. The bill is 2f S, 2f T and at most f data masks, with zero masks omitted.", + "dependencies": [ + "P003" + ], + "frontier_target": "changed consumer contract in PR #2850", + "id": "P004", + "novelty": "Classical reconstruction or constructive frontier adaptation; no global novelty claim.", + "proof_status": "informal_proved", + "provenance": "constructive central-phase repair.", + "title": "Reverse consumers with separately prescribed local phases", + "volume": "volumes/02-physical.md", + "anchor": "p004", + "statement": "After W₁,…,W_f, consume in reverse order with D_{q_j+a_j·b_j} followed by W_j. The endpoint is D_{Σ_j q_j} and the bank is identity.", + "proof": "Inverse W_j is D_{a_j·b_j}W_j because W_j²=D_{a_j·b_j}. Consequently the proposed consumer is D_{q_j}W_j⁻¹. Its data mask commutes through all bank words. The noncentral factors cancel in reverse order, while the masks multiply to D_{Σ q_j}. This also proves that arbitrary incoming bank amplitudes survive, rather than just bank addresses returning.", + "proof_sha256": "8a6171239a2a0c7a2f0219a0cdfbac8604e565b703c6d0aa91ddafb2261dfc9e" + }, + { + "action": "Implement a specified bilinear data interaction through an existing quadratic bank gauge. Pay four bank sign masks and four translations; neither the gauge nor either translation is a free resource.", + "dependencies": [], + "frontier_target": "an alternative mixing primitive for PR #2850", + "id": "P005", + "novelty": "Classical reconstruction or constructive frontier adaptation; no global novelty claim.", + "proof_status": "informal_proved", + "provenance": "classical finite-difference identity with a complete returned-bank word.", + "title": "Quadratic bank echoes produce data phase and return both dirt and gauge", + "volume": "volumes/02-physical.md", + "anchor": "p005", + "statement": "Let q:F₂ᵇ→F₂ have degree at most two, and define its polar form B_q(s,t)=q(s+t)+q(s)+q(t)+q(0). For controls s(d),t(d), run the four sign masks q(c), q(c+s), q(c+s+t), q(c+t), using translations around the rectangle and returning c. The resulting data phase is D_{B_q(s,t)}.", + "proof": "Execute D_{q(c)},T_s,D_{q(c)},T_t,D_{q(c)},T_s,D_{q(c)},T_t. The four observed bank values are c,c+s,c+s+t,c+t and the final translations sum to zero. A constant monomial occurs four times, and a linear monomial has zero second difference. For a quadratic monomial c_i c_j, expansion leaves s_i t_j+s_j t_i. Summing proves that all c terms disappear and that the remaining sign is exactly the polar form. This is valid even for correlated controls and dirty bank values.", + "proof_sha256": "eb6ae179dbebc968ab3a7acdfcbbfbf6ad582b509f5615dff4fc69f817fea946" + }, + { + "action": "Keep a caller-required consumer order rather than commuting it for free. The word uses 2f S, 2f T and one charged correction mask. P012–P019 provide smaller explicit circuits for that mask.", + "dependencies": [], + "frontier_target": "PR #2859 exact cross-term contract", + "id": "P006", + "novelty": "Classical reconstruction or constructive frontier adaptation; no global novelty claim.", + "proof_status": "informal_proved", + "provenance": "credited order formula extended to vector controls with a sufficient correction.", + "title": "Arbitrary consumer permutation repaired by its actual crossings", + "volume": "volumes/02-physical.md", + "anchor": "p006", + "statement": "Let producers be W₁,…,W_f and consumers be the same W instructions in any permutation π. Put Ω_ij=a_i·b_j+a_j·b_i. For every i0. This is a constructive upper bound, not a claim that child volume shrinks.", + "dependencies": [ + "P012" + ], + "frontier_target": "general encoded consumers beyond PR #2859’s assigned-bit restriction", + "id": "P013", + "novelty": "Classical reconstruction or constructive frontier adaptation; no global novelty claim.", + "proof_status": "informal_proved", + "provenance": "serialized physical adaptation.", + "title": "Rank corrections serialized through one dirty bank bit", + "volume": "volumes/02-physical.md", + "anchor": "p013", + "statement": "If M=Σ_{k=1}^r a_k b_kᵀ, the product of r scalar-bank words S_{a_k·u},T_{b_k·v},S_{a_k·u},T_{b_k·v} implements D_{uᵀMv} while restoring the same arbitrary bank bit after each factor.", + "proof": "The k-th four-map block gives D_{(a_k·u)(b_k·v)} and bank identity by P012 with one row. The next block therefore receives the original arbitrary bank, even when its coefficients are correlated with the data. The data signs multiply by adding their exponents, giving the displayed matrix sum. No state preparation is inserted between blocks.", + "proof_sha256": "9c0996f4c045039f4e56777fa99d6f3e1cc82e8e5b86c1278d851ee5ee21e1e3" + }, + { + "action": "Choose a concrete bank-width/time tradeoff without invoking a general bank optimum. Aggregate-map count is as stated; elementary control count is the same weighted support sum as P013. Any b-axis basis implementation pays full b-axis children and full operand volume.", + "dependencies": [ + "P012", + "P013" + ], + "frontier_target": "paid bank-width choices for PR #2850 successors", + "id": "P014", + "novelty": "Classical reconstruction or constructive frontier adaptation; no global novelty claim.", + "proof_status": "informal_proved", + "provenance": "constructive batching.", + "title": "Bounded-width factor chunks with returned boundaries", + "volume": "volumes/02-physical.md", + "anchor": "p014", + "statement": "For the factorization in P013 and any integer b≥1, partition the r factors into consecutive groups of at most b. Each group is implementable by four aggregate maps on the same dirty b-bit bank; the concatenation gives D_{uᵀMv}, using 4⌈r/b⌉ maps when r>0.", + "proof": "For a group, put its a_k and b_k as rows of two b-row matrices, padding unused rows with zero. P012 implements that group and is identity on every bank coordinate, including padded ones. Concatenating the returned groups adds their matrix contributions and preserves all bank amplitudes. There are exactly ⌈r/b⌉ nonempty groups; r=0 emits no operation.", + "proof_sha256": "c25c16474a0f3b138b519bc38eaf9c54a17ae3500e0a3cdf8a1a0f88c2aab966" + }, + { + "action": "A rank-r factorization yields 2f W plus the explicit 4r scalar-map correction, or four maps on r bank bits. A repaired schedule need not satisfy the old zero-cross-term criterion because its missing data phase is now executed and charged.", + "dependencies": [ + "P011", + "P012", + "P013" + ], + "frontier_target": "PR #2859’s changed-consumer handoff", + "id": "P015", + "novelty": "Classical reconstruction or constructive frontier adaptation; no global novelty claim.", + "proof_status": "informal_proved", + "provenance": "sufficient corrected continuation, with no new favorable native bill assumed.", + "title": "Every assigned-bit order has a finite corrected consumer", + "volume": "volumes/02-physical.md", + "anchor": "p015", + "statement": "For any f, bank assignment g and consumer permutation π, let E be the f×f binary matrix with E_ij=E_ji=1 exactly on the alternating same-bank pairs and zero diagonal. Append a P012 or P013 implementation of D_{uᵀEv} to the literal schedule. The complete endpoint is the intended dot-product phase with bank identity.", + "proof": "P011 says the actual error is the sum u_i v_j+u_j v_i over those pairs, which equals uᵀEv. The appended controller applies this same phase, is identity on its own arbitrary bank and hence cancels the error. It can reuse the original bank only after its complete return, as P006 guarantees; otherwise a distinct dirty bank is used and returned. No particular order or graph coloring is required.", + "proof_sha256": "d1525d75b14ea18dc941a8f019b1919b8d91bcdea9542e1278129cfbe9f4765b" + }, + { + "action": "Repair exchanging two fully interacting batches without issuing a separate correction per pair. Pay eight aggregate maps, or 4(|A|+|B|) elementary sign/XOR gates in total. This count includes computing each parity by its elementary controls, not a free parity register.", + "dependencies": [ + "P013" + ], + "frontier_target": "batch consumer permutations in PR #2859", + "id": "P016", + "novelty": "Classical reconstruction or constructive frontier adaptation; no global novelty claim.", + "proof_status": "informal_proved", + "provenance": "distributive factorization applied to a paid crossing correction.", + "title": "Complete bipartite crossing blocks need two phase factors", + "volume": "volumes/02-physical.md", + "anchor": "p016", + "statement": "For disjoint index sets A,B, the phase Σ_{i∈A,j∈B}(u_i v_j+u_j v_i) is implementable through one dirty bit by two P013 factor blocks, regardless of |A|·|B|.", + "proof": "Distributivity rewrites the phase as (Σ_A u_i)(Σ_B v_j)+(Σ_B u_j)(Σ_A v_i). Execute the four-map scalar controller for each of these two products. Each restores the bank and contributes precisely its product; their sum is the full bipartite crossing phase, with every edge represented once. Empty A or B gives zero and both blocks may be omitted.", + "proof_sha256": "47386be7fd65b207c948a9b5dfbfee7cec83de8251ba14d36a7ee4a09dc1d202" + }, + { + "action": "A concrete star cover with s nonempty stars costs 8s aggregate maps and 4Σ_k(1+|L_k|) elementary gates. One always obtains such a cover by assigning each graph edge to its lower-numbered endpoint. A smaller supplied cover is checked by edge parity, not assumed.", + "dependencies": [ + "P016" + ], + "frontier_target": "structured cross-term corrections in actual consumer graphs", + "id": "P017", + "novelty": "Classical reconstruction or constructive frontier adaptation; no global novelty claim.", + "proof_status": "informal_proved", + "provenance": "constructive graph decomposition.", + "title": "An edge-parity star cover compiles a crossing correction", + "volume": "volumes/02-physical.md", + "anchor": "p017", + "statement": "Suppose a finite crossing graph is represented as the symmetric difference of stars (a_k,L_k), where a_k∉L_k. Its entire correction phase is obtained by applying P016 to every star’s center and leaves.", + "proof": "For one star, P016 contributes u_a Σ_L v_j+v_a Σ_L u_j, exactly its incident edge monomials. A repeated edge contributes the same two monomials twice and cancels. Because the supplied star list has the graph’s edge parity, the total exponent equals its crossing correction. Every star controller closes its dirty bank before the next.", + "proof_sha256": "1880327ad107666cf0f0613c947b165036d1255be79a994dd5bcffc31b0f54d2" + }, + { + "action": "Pay 4(f+1) aggregate maps and exactly 8f elementary linear-control gates before any cancellation optimization. This replaces a quadratic list of separate edge repairs by a linear-size explicit controller, with no free data phase.", + "dependencies": [ + "P013" + ], + "frontier_target": "same-order shared-bank consumers in PR #2859", + "id": "P018", + "novelty": "Classical reconstruction or constructive frontier adaptation; no global novelty claim.", + "proof_status": "informal_proved", + "provenance": "elementary identity with an executed correction recipe.", + "title": "Clique crossing correction by aggregate parity plus diagonals", + "volume": "volumes/02-physical.md", + "anchor": "p018", + "statement": "For f≥2, the complete-graph crossing phase is (Σ_i u_i)(Σ_i v_i)+Σ_i u_i v_i. It has a one-dirty-bit implementation with f+1 scalar factor blocks.", + "proof": "Expanding the first product lists every ordered pair (i,j). Its diagonal terms are cancelled by the second sum, leaving exactly u_i v_j+u_j v_i for i