From ebb1c1f39228da5e56acd663394d8582b88bd0bb Mon Sep 17 00:00:00 2001 From: Adam Gall Date: Wed, 14 Oct 2026 10:29:06 -0400 Subject: [PATCH 1/2] Prove COPY84 floor for low-rank matched P112 support frames --- .../CERTIFICATE.json | 226 +++++++++++ .../p112-matched-frame-copy-floor/README.md | 278 ++++++++++++++ .../SELECTION.json | 98 +++++ .../SOURCES.json | 36 ++ .../p112-matched-frame-copy-floor/TASK.json | 75 ++++ .../p112-matched-frame-copy-floor/VERIFY.json | 24 ++ .../p112-matched-frame-copy-floor/verify.py | 362 ++++++++++++++++++ 7 files changed, 1099 insertions(+) create mode 100644 research/p112-matched-frame-copy-floor/CERTIFICATE.json create mode 100644 research/p112-matched-frame-copy-floor/README.md create mode 100644 research/p112-matched-frame-copy-floor/SELECTION.json create mode 100644 research/p112-matched-frame-copy-floor/SOURCES.json create mode 100644 research/p112-matched-frame-copy-floor/TASK.json create mode 100644 research/p112-matched-frame-copy-floor/VERIFY.json create mode 100755 research/p112-matched-frame-copy-floor/verify.py diff --git a/research/p112-matched-frame-copy-floor/CERTIFICATE.json b/research/p112-matched-frame-copy-floor/CERTIFICATE.json new file mode 100644 index 0000000000..1a184ad4ee --- /dev/null +++ b/research/p112-matched-frame-copy-floor/CERTIFICATE.json @@ -0,0 +1,226 @@ +{ + "capacity": { + "1": 1, + "2": 2, + "3": 4, + "4": 5 + }, + "claim": "matched-span COPY ranks one through four force COPY at least84", + "controls": { + "baseline_copy_ranks": [ + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "diagonal_copy_bill": 112, + "free_pair": [ + 0, + 2 + ], + "hypothesis_counterexamples": 2, + "semantic_rejections": 4 + }, + "fixtures": { + "1": { + "copy_rank": 1, + "label_span_dimension": 1, + "left": [ + 41 + ], + "lift_rank": 1, + "right": [ + 41 + ] + }, + "2": { + "copy_rank": 2, + "label_span_dimension": 2, + "left": [ + 20, + 99 + ], + "lift_rank": 2, + "right": [ + 20, + 99 + ] + }, + "3": { + "copy_rank": 3, + "label_span_dimension": 4, + "left": [ + 18, + 25, + 31, + 105 + ], + "lift_rank": 4, + "right": [ + 18, + 25, + 31, + 105 + ] + }, + "4": { + "copy_rank": 4, + "label_span_dimension": 5, + "left": [ + 3, + 7, + 9, + 22, + 63, + 65, + 66, + 72 + ], + "lift_rank": 5, + "right": [ + 3, + 7, + 9, + 22, + 63, + 65, + 66, + 72 + ] + }, + "different_supports": { + "copy_rank": 4, + "left": [ + 3, + 7, + 9, + 22, + 63 + ], + "lift_rank": 5, + "right": [ + 3, + 7, + 9, + 22, + 63, + 65, + 66, + 72 + ] + }, + "rank_five_control": { + "copy_rank": 5, + "left": [ + 8, + 10, + 24, + 33, + 50, + 51, + 74, + 75, + 88, + 97 + ], + "lift_rank": 10, + "right": [ + 8, + 10, + 24, + 33, + 50, + 51, + 74, + 75, + 88, + 97 + ] + }, + "unmatched_control": { + "copy_rank": 2, + "left": [ + 0, + 1, + 2 + ], + "lift_rank": 3, + "right": [ + 0, + 72, + 56 + ] + } + }, + "geometry": { + "binary_rank": 9, + "checked_entries": 12544, + "constrained_entries": 6720, + "ports": 112 + }, + "invoice": { + "attainment": "rank relaxation only; no COPY84 decoder", + "minimum_copy_bill": 84, + "optimizers_n1_n2_n3_n4": [ + [ + 0, + 0, + 28, + 0 + ] + ], + "universal_copy_moment_ratio_lower": "21/16" + }, + "quotient_census": { + "1": { + "forms": 1, + "lift_rank_counts": { + "1": 1 + } + }, + "2": { + "forms": 3, + "lift_rank_counts": { + "2": 3 + } + }, + "3": { + "forms": 28, + "lift_rank_counts": { + "4": 28 + } + }, + "4": { + "forms": 420, + "lift_rank_counts": { + "5": 420 + } + } + }, + "schema_version": 1, + "screen": { + "additional_physical_charges": "waived for rejection only", + "baseline_a_bracket": [ + "52814190909/31250000000000", + "1690054109089/1000000000000000" + ], + "centre_charge": 84, + "five_percent_target": "35491136290869/20000000000000000", + "idle_mass": 1646, + "optimistic_a_bracket": [ + "147248934149/200000000000000", + "368122335373/500000000000000" + ], + "optimistic_local_profile": { + "1": 2412, + "2": 418, + "3": 460, + "4": 142, + "5": 82 + } + } +} diff --git a/research/p112-matched-frame-copy-floor/README.md b/research/p112-matched-frame-copy-floor/README.md new file mode 100644 index 0000000000..52805c3a5d --- /dev/null +++ b/research/p112-matched-frame-copy-floor/README.md @@ -0,0 +1,278 @@ +# P112 matched support frames of COPY rank at most four cost at least 84 + +**Scoped obstruction. No new decoder, supplier, kappa or selected-frontier change.** + +For the fixed P112 binary label model, consider any finite masked decoder +`sum_k d_k t_k^T = 2G` on the constrained even entries. Coefficients may be +arbitrary complex numbers; transpose is ordinary, not conjugate transpose. +For each **paid** term, require that its actual nonzero source and target +supports span the **same F2 label subspace**, and that its pairing-rank COPY +charge is at most four. Supports need not be identical, local to a tetrad, +root-linear, disjoint, or restricted to eight terms. Arbitrary cost-zero +corrections and cancellations are allowed. + +Then, writing `n_r` for the number of paid rank-r terms, + +``` +n_1 + 2 n_2 + 4 n_3 + 5 n_4 >= 112, +COPY = n_1 + 2 n_2 + 3 n_3 + 4 n_4 >= 84. +``` + +The integer **rank relaxation**, not the decoder problem, attains 84 uniquely +at 28 rank-three terms. The incumbent uses eight rank-eight copies, total 64. +For every exponent `q=1-a` with `0 <= a < 1`, the candidate COPY moment is at +least `21/16` times the incumbent's, under the same width, multiplicity and +role normalization. Thus this candidate alphabet cannot deliver a COPY saving, +even before any extra preparation, frames, precision, restoration or hosting. + +## Why this question is distinct and useful + +A masked decoder can trade a few broad copies for many cheaper support-rank +copies. Equality of the two support **spans** is a natural algebraic relaxation +of matched reader/source frames; it is not an assertion of physical frame +legality. The result closes COPY ranks one through four in that alphabet, +without imposing the eight-term/all-pairs restriction. A competitive matched +span design must use at least one paid term of rank five or greater, or change +the copy accounting. Unmatched span designs are not excluded. + +PR1909's COPY112 theorem instead requires one actual support to lie within a +single canonical tetrad, with an arbitrary opposite support. This proof uses +no locality restriction and does not extend that theorem merely by enlarging +a tetrad. PR1923 examines a bounded Householder orbit of one symmetric +witness; PR1633 gives all-pairs outside-root-code budgets. Neither establishes +the present characteristic-lift rank inequality, and none is a proof input. + +## Proof + +### 1. The binary mask turns masked exactness into an identity matrix + +Let the live roots have norm two, `G_ij=`, and let + +``` +B_ij = (G_ij + 1) mod 2. +``` + +The symmetric binary label pairing is `B`. Its diagonal and orthogonal-root +entries are one; odd-inner-product entries are zero. On P112, the required +masked target therefore satisfies + +``` +B Hadamard (2G) = 4 I_112. +``` + +For a term with actual supports `S,T`, its COPY charge is +`beta = rank_F2 B[S,T]`. The masked term over C is +`diag(d|S) B[S,T] diag(t|T)`, embedded in the full matrix. The two diagonal +scalings are invertible because these are **actual nonzero supports**. Its +complex rank equals the rational rank of the zero-one matrix `B[S,T]`. +No coefficient is reduced modulo two. A beta-zero term has `B[S,T]=0`, so its +masked contribution is zero, whatever its coefficients or opposite spans. + +### 2. Common spans give a nonalternating quotient + +Suppose the two label spans equal `W`. Because S and T both span W, beta is +exactly the rank of the symmetric pairing restricted to W. Divide W by the +radical of that restricted form. The quotient V has dimension beta and a +nondegenerate symmetric form b. + +Every live label u has `b(u,u)=1`. This remains true in the quotient: radical +vectors pair to zero with every vector in W, including themselves. Consequently +V is nonalternating, and every actual row or column type belongs to + +``` +O = {v in V : b(v,v)=1}. +``` + +In characteristic two, `v -> b(v,v)` is a nonzero linear functional, so +`|O|=2^(beta-1)`. The support matrix is a submatrix of the zero-one Gram matrix +`H_O=(b(u,v))_(u,v in O)`, possibly with repeated row or column types. Taking +submatrices and repeating rows/columns cannot raise its characteristic-zero +rank. This argument does not require S=T. A nonempty matched-span term cannot +have beta zero, since W would contain a label with self-pairing one. + +### 3. The even-rank complement improvement + +Nondegeneracy gives a unique characteristic vector c satisfying +`b(v,c)=b(v,v)` for all v. It is nonzero, and `b(c,c)=dim(V) mod 2`. +For completeness, split off a norm-one vector and its orthogonal complement +repeatedly until the remaining form is alternating. The alternating remainder +has even dimension. In the resulting orthogonal decomposition c is the sum of +the norm-one basis vectors, so its norm is their number modulo two, equal to +the dimension modulo two. This argument does not assume positive definiteness. + +When beta is even, c has norm zero. Translation `u -> u+c` pairs the elements +of O without fixed points, stays in O, and for every v in O gives + +``` +b(u+c,v) = b(u,v)+1 over F2. +``` + +As **integer zero-one rows**, the paired rows sum to the all-ones row. Thus +`rank_Q H_O <= 1 + |O|/2 = 1 + 2^(beta-2)`. For odd beta, the cardinality bound +`rank_Q H_O <= 2^(beta-1)` suffices. In particular: + +| COPY rank beta | 1 | 2 | 3 | 4 | +|---|---:|---:|---:|---:| +| Maximum lifted rank used in the proof | 1 | 2 | 4 | 5 | + +All four capacities are attained by explicit P112 support matrices in the +certificate. For rank four, eight distinct quotient row types have rational +rank **five**, not eight. The complete finite census also checks all 452 +nonalternating nonsingular symmetric binary forms of dimensions one through +four, not just one convenient coordinate form. The proof is quantified linear +algebra; the census checks its exact premises and implementation. + +### 4. Rank demand, COPY bill and moment + +Sum all masked terms. Their sum is `4I_112`, of complex rank 112. Rank +subadditivity and the capacities give the displayed inequality. Since each +capacity is at most `4r/3`, the COPY bill is at least 84. Equality in this +relaxation requires only rank-three terms, hence exactly 28 of them. This +neither supplies coefficients nor proves that a COPY84 decoder exists. + +For `q=1-a`, `0 <= a < 1`, and r at most four, + +``` +sum n_r r^(1-a) >= 4^(-a) sum n_r r >= 84 * 4^(-a). +``` + +The incumbent COPY moment before common normalization is +`8 * 8^(1-a) = 64 * 8^(-a)`. Their ratio is at least +`(21/16) * 2^a >= 21/16`. Extra charges cannot repair that comparison when all +other work and the interface are retained. Changes elsewhere, shared copies, +role counts, or the coverage law are outside this comparison. + +## Fully charged optimistic fixed-template screen + +The card's required first working example was run on CPython 3.12: + +``` +uv run --python 3.12 --no-project python -I -B research/complex-local-word-ceiling/verify.py +PASS_COMPLEX_LOCAL_WORD_CEILING a_ceiling 0.00169005410908900006 kappa<= 0.0016872026453254019 +``` + +For the stronger fixed-template rejection, retain the selected non-COPY work, +width 73, 896 families, nine stages, idle-rank cap 51 and its coverage law. +Grant every *additional* implementation charge zero, only as a favorable +relaxation. For `0 <= a <= 1/5`, the smallest COPY cost per unit of rank demand +is rank three, so every admissible profile pays at least `28*(3/73)^(1-a)`. +For rank four, the needed comparison follows already at `1-a=4/5` from the +integer inequality `4^9 > 3^4 * 5^5`; ranks one and two are immediate. The +comparison persists as `1-a` increases to one. + +Accordingly replace eight rank-eight children by 28 rank-three children, and +raise the centre charge from 64 to **84 at the same time**: + +``` +optimistic local profile = {1:2412, 2:418, 3:460, 4:142, 5:82} +local paid mass = 5606; total paid mass = 7252; idle mass = 1646. +``` + +The changed local COPY mass and changed centre charge cancel in the idle +remainder. Keeping centre=64 would incorrectly spend 20 units of idle mass +instead of paying the extra copies; a control makes that error visible. +The pinned exact-rational interval engine gives: + +| Quantity | Certified interval or value | +|---|---| +| Selected fixed-word a ceiling | `[0.001690054109088, 0.001690054109089]` | +| Optimistic alphabet a ceiling | `[0.000736244670745, 0.000736244670746]` | +| Original five-percent gate | `0.00177455681454345` | + +This is a rejection even with favorable physical charges, not a new admitted +profile. The original positive construction gate is **not met** and is not +silently lowered. No selected cold replay or new kappa calculation is needed +or claimed for this scoped rejection. + +## Exact evidence and reproduction + +The verifier reconstructs the 120 Euclidean root lines independently, binds +all 112 live roots and all 12,544 label/coordinate entries to the pinned +geometry, and checks the masked target `4I`. Fraction elimination and a +separate odd-prime column algorithm corroborate the finite ranks. The four +capacity witnesses, a nonidentical-support common-span witness, and all +quotient-form census counts are committed in `CERTIFICATE.json`. + +Controls include the incumbent eight-copy identity; a valid COPY112 diagonal +decoder; an arbitrary cost-zero odd correction; omitted/wrong diagonal terms; +a wrong mask; and the centre-undercharge error. Two explicit **hypothesis +counterexamples**, not decoder constructions, show the boundary is real: + +- unmatched supports can have COPY rank two but lifted rank three; +- a matched-span rank-five P112 support has lifted rank ten, violating the + low-rank inequality `lift_rank <= 4*COPY/3`. + +The sharp per-term witnesses were proposed by a bounded deterministic +support-span search (20,011 sampled closures, proposal RNG seed 7). Discovery +is not exhaustive or needed by replay: every saved witness is rechecked +exactly, and the proof covers arbitrary supports under the stated hypotheses. +The chooser was run independently **once**, with OS seed +`5cee555544503585ad60b2631e790c0c`, track `complex-mechanisms`; its entire output +is in `SELECTION.json`. The proposal seed does not establish novelty. + +From the repository root, standard library only: + +```sh +uv run --python 3.12 --no-project python -I -O -B research/p112-matched-frame-copy-floor/verify.py +uv run --python 3.12 --no-project python -B scripts/research_package.py --package research/p112-matched-frame-copy-floor +``` + +The expected final marker is +`PASS_P112_MATCHED_FRAME_COPY_FLOOR forms=452 entries=12544 capacities=1,2,4,5 COPY>=84 moment_ratio>=21/16 controls=7 no_new_kappa`. + +Local verification on **CPython 3.12.12**, Darwin arm64, 2026-10-14: normal +`-I -B --write` certificate generation, isolated optimized `-I -O -B` replay, +and the registered Python 3.12 replay all passed. The wrapper additionally +printed `PASS_REGISTERED_RESEARCH_PACKAGE research/p112-matched-frame-copy-floor outcome=negative-result`. +An initial metadata-only failure used an unsupported outcome spelling; it +was corrected to `negative-result`, after which the registered replay passed. +No native, hosted-CI, selected cold-replay or proof-assistant result is claimed. + +`verify.py --write` regenerates the deterministic certificate. The verifier +uses explicit exceptions rather than removable assertions. Neither a proof +assistant nor independent human verification of the quantified proof is +claimed; the two finite rank methods belong to this same assisted contribution. + +## Open next questions + +- **Can unmatched spans achieve a useful full decoder?** The rank-two + counterexample identifies where the proof fails. First formulate the exact + coefficient equations for a collection of such rectangles, on every masked + entry. A rectangle with a high lifted rank is not itself a decoder; coefficient + compatibility and all physical charges block admission. +- **Can rank-five matched terms help?** The supplied ten-line rank-five fixture + escapes the low-rank ratio. A first step is an exact covering/linear-algebra + screen using those supports and every diagonal/orthogonality constraint. + No coefficient solution, complete moment bill, source-access contract, + restoration schedule or hosting assignment is supplied. +- Arbitrary unmatched spans, COPY rank at least five, shared/nonseparate COPY + pricing, other punctures and changed coverage/role interfaces remain open. + Existing eight-term and locality theorems retain their own distinct scopes. + +## Sources, overlap, credit and disclosure + +Base: `0b1cccf86e2f5132ed286a26ef0a681a495740ea`. Exact live inputs and +historical catalogue/selected-record pins are in `SOURCES.json`; all inputs, +selected results and predecessor packages are unchanged. The geometry is +Mihir Srivastava's AI-assisted independent implementation of DreamingOfClouds' +PR717 P112 model. Credit DreamingOfClouds for the masked decoder and separate +COPY-rank convention, themilkman216 for the frame-pair decoder floor, +Douglas Colkitt for the selected-word ceiling engine and its Claude-assisted +implementation, and the selected supplier's credited predecessor chain. +PR1909, PR1923 and PR1633 are acknowledged as adjacent work, not dependencies. + +The shared cached overlap snapshot covered 579 open PRs including drafts +and 547 discussion records, complete pagination, fetched on 2026-10-14 at +14:10:13Z and 14:11:43Z. Targeted terms included matched/support frames, +characteristic lifts, tetrad locality, rank shape, binary rank and symmetric +factors. This does not search every code diff or establish literature priority. +The final cached search used the subsequently available 584-PR snapshot +(14:27:47Z) and the same discussion snapshot. Targeted live reads confirmed +that PR1909, PR1923 and PR1633 remained open at the exact heads in TASK.json. +No matched-span obstruction appeared in those bounded searches; that absence +is not a novelty certificate. +Coordination: +https://github.com/CrocSwap/integer-mult-bounds/discussions/1929#discussioncomment-18925923. + +Prepared for Adam Gall with substantial OpenAI Codex (GPT-6 Astra) assistance +in research, proof, implementation, experiments and writing. Apache-2.0. diff --git a/research/p112-matched-frame-copy-floor/SELECTION.json b/research/p112-matched-frame-copy-floor/SELECTION.json new file mode 100644 index 0000000000..0258ef940f --- /dev/null +++ b/research/p112-matched-frame-copy-floor/SELECTION.json @@ -0,0 +1,98 @@ +{ + "seed": "5cee555544503585ad60b2631e790c0c", + "track": "complex-mechanisms", + "suggestions": [ + { + "task_id": "complex-rank-shape-decoder", + "scope_key": "cad3ba853d7f324f16fa", + "question": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?", + "method": "Bound the best effective child rank achievable for one fixed support alphabet, including copies, frames and restoration.", + "starting_points": [ + "research/complex-local-word-ceiling/README.md", + "research/complex-decoder-field-extension-seed44/README.md", + "research/complex-frame-pair-decoders/README.md" + ], + "acceptance_gate": "A per-call local profile, with all copied information, frames and restoration counted, whose ceiling exceeds the selected word's by at least 5%; masked or overcomplete supports must change an assumption of the eight-term all-pairs bound.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin. Ideal budget: rank-16 delivery is 2.31x (levers.py).", + "bottleneck_link": "Rank-1 children are about half of recursive cost; the selected word's effective child rank is about 3.9. Larger-rank delivery lowers recursive cost per unit of paid mass.", + "allowed_variations": [ + "One masked, overcomplete or block decoder family with exact labels and supports.", + "A scoped lower bound on effective rank for one alphabet.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Repacking idle remainders of an unchanged word (covered by the packing ceiling).", + "Repeating the eight-term all-pairs search inside its proved scope." + ], + "overlap_terms": [ + "rank shape", + "block climb", + "masked decoder", + "overcomplete", + "effective rank" + ], + "scope_rule": "If you change the card's premise, record scope_status=changed and explain why. A package metadata check cannot establish mathematical relevance." + }, + { + "task_id": "complex-new-helper-inventory", + "scope_key": "f3b0895a4f9f1cc62e75", + "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?", + "method": "Design a small completed instance and independently verify its endpoint and rank bill.", + "starting_points": [ + "research/complex-local-word-ceiling/README.md", + "research/heterogeneous-owner-assembly/README.md", + "certificates/selected-result.json" + ], + "acceptance_gate": "A new physically realizable contract outside the frozen catalogue whose per-call profile, screened with ceiling.ceiling(), beats the selected word's packing ceiling; a lower cap does not establish identical circuitry or order attainable optima, and is insufficient to pass the stronger-budget target under this model.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin.", + "bottleneck_link": "Packing of the selected word is capped at +0.87% (ceiling model); only a lower local excess spend or a changed coverage law raises the cap.", + "allowed_variations": [ + "Narrow to one changed boundary or helper type with explicit counts.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Mixing only providers already inside the pinned catalogue." + ], + "overlap_terms": [ + "helper inventory", + "heterogeneous-owner", + "mutable leaver" + ], + "scope_rule": "If you change the card's premise, record scope_status=changed and explain why. A package metadata check cannot establish mathematical relevance." + } + ], + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "catalog_assessed_on": "2026-10-13", + "priority_revision": 3, + "priority_log": "docs/research/research-priority-log.md", + "catalog_sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "selected": { + "kappa": "836330098538459/500000000000000000", + "review": "docs/research/community-batch1099-review.md", + "source_manifest": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "reproduce": "make frontier1094-verify" + }, + "status": "SUGGESTIONS_ONLY_NOT_RESERVED", + "next_step": "Check live overlap, refine one question's object and domain, and record a bounded task card. A different seed or scope key is not evidence of novelty." +} diff --git a/research/p112-matched-frame-copy-floor/SOURCES.json b/research/p112-matched-frame-copy-floor/SOURCES.json new file mode 100644 index 0000000000..83876bbbf5 --- /dev/null +++ b/research/p112-matched-frame-copy-floor/SOURCES.json @@ -0,0 +1,36 @@ +{ + "schema_version": 1, + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1", + "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075" + }, + { + "path": "research/complex-local-word-ceiling/RESULT.json", + "usage": "input", + "git_blob": "77f55043a679dd722330f1e2499863e36376d9f9", + "sha256": "d91d6c46509875abf1f61de67c2609656d3dc685451299f83caa6f922493692d" + }, + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "usage": "input", + "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + }, + { + "path": "research/p112-single-lift/geometry.py", + "usage": "input", + "git_blob": "34c1abf059d7be5fe5e5044cf01a09b843071c68", + "sha256": "3857c11ec731a602b8059d85d58fbb3b641bab687bb33016a0e54f7567752c8a" + } + ] +} diff --git a/research/p112-matched-frame-copy-floor/TASK.json b/research/p112-matched-frame-copy-floor/TASK.json new file mode 100644 index 0000000000..8718af636a --- /dev/null +++ b/research/p112-matched-frame-copy-floor/TASK.json @@ -0,0 +1,75 @@ +{ + "schema_version": 1, + "task_id": "complex-rank-shape-decoder", + "priority_revision": 3, + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "original_card": { + "id": "complex-rank-shape-decoder", + "question": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?", + "starting_points": [ + "research/complex-local-word-ceiling/README.md", + "research/complex-decoder-field-extension-seed44/README.md", + "research/complex-frame-pair-decoders/README.md" + ], + "methods": [ + "Find one exact small decoding identity whose frame path climbs in blocks, and price its complete per-call profile.", + "Bound the best effective child rank achievable for one fixed support alphabet, including copies, frames and restoration." + ], + "acceptance_gate": "A per-call local profile, with all copied information, frames and restoration counted, whose ceiling exceeds the selected word's by at least 5%; masked or overcomplete supports must change an assumption of the eight-term all-pairs bound.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin. Ideal budget: rank-16 delivery is 2.31x (levers.py).", + "bottleneck_link": "Rank-1 children are about half of recursive cost; the selected word's effective child rank is about 3.9. Larger-rank delivery lowers recursive cost per unit of paid mass.", + "allowed_variations": [ + "One masked, overcomplete or block decoder family with exact labels and supports.", + "A scoped lower bound on effective rank for one alphabet.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Repacking idle remainders of an unchanged word (covered by the packing ceiling).", + "Repeating the eight-term all-pairs search inside its proved scope." + ], + "overlap_terms": [ + "rank shape", + "block climb", + "masked decoder", + "overcomplete", + "effective rank" + ] + }, + "scope_status": "refined", + "actual_scope": "Masked P112 rank-one decoder terms with equal source/target F2 label spans and individual COPY rank at most four; arbitrary finite term count, complex coefficients, support sets and zero-cost corrections. Prove a complete COPY-rank and moment obstruction using the characteristic-zero lift of the binary mask.", + "scope_change_reason": "This is the card's allowed scoped support-alphabet lower bound, not its positive construction gate. Matched support frames differ from the eight-term/all-pairs hypothesis and from PR1909's one-tetrad locality. The proof generalizes equal supports to equal label spans and tests the rank-four boundary explicitly.", + "bottleneck_link": "A candidate can trade eight rank-eight centre copies for many low-rank masked copies. The proposed quotient bound tests whether matched-frame ranks one through four can lower the complete COPY moment before any helper or frame synthesis; all additional physical charges are optimistically waived, never declared free in an admitted supplier.", + "budget_minutes": 120, + "stop_rule": "Stop construction if the exact characteristic-lift lower bound already dominates the incumbent COPY moment. Retain one proof/checker package only if the quantified proof, P112-specific sharp per-term witnesses and boundary controls pass; do not infer an exact decoder from the rank relaxation.", + "outcome": "negative-result", + "evidence": "README.md proves the quantified common-span lift bound. CERTIFICATE.json records all 452 quotient forms, all 12544 P112 entries, sharp per-term capacity witnesses, matched unequal-support and hypothesis counterexamples, exact integer COPY84 relaxation, and the certified optimistic ceiling interval. verify.py supplies optimized-safe semantic controls.", + "author": "Adam Gall", + "ai_assistance": "Substantial OpenAI Codex (GPT-6 Astra) assistance in research, proof, implementation, experiments and documentation.", + "open_questions": [ + { + "question": "Can unmatched support spans or rank-five matched terms realize a masked COPY profile below the incumbent after physical charges?", + "why_it_matters": "The proposed obstruction closes only matched support frames of COPY rank at most four, leaving the nearest changed interfaces explicit.", + "first_step": "Use exact support witnesses escaping the lift bound to formulate a small coefficient system on all constrained P112 entries, then screen its full cost before synthesis.", + "blocked_by": "A high-rank mask fixture is not a masked decoder; all coefficient equations and physical source, frame, restoration and hosting contracts remain." + } + ], + "selection_seed": "5cee555544503585ad60b2631e790c0c", + "selection_track": "complex-mechanisms", + "scope_key": "p112-matched-label-spans-copy-ranks-1-through-4", + "optimistic_budget": "Retain the selected non-COPY work and coverage assumptions; compare the candidate COPY moment with eight rank-eight copies, granting all new non-COPY charges zero. Target remains a ceiling at least 1.05 times the selected fixed-word ceiling. An obstruction is not achievement of that positive target.", + "nearest_work": [ + {"pr": 1909, "head": "64922f413dc6cb3ae3d843cd53b4aa7d985b55d0", "difference": "One-tetrad support locality with arbitrary opposite support; the present common-span alphabet permits nonlocal supports and uses characteristic lift."}, + {"pr": 1923, "head": "0d33d6020aa50d383067510df78dcc0515bba4f4", "difference": "One ten-term symmetric witness under bounded Householder gauges; the present proof permits arbitrary term count and coefficients."}, + {"pr": 1633, "head": "652264fa1f70820139b2730363a0056b7fadc689", "difference": "All-pairs outside-root-code rank budget; no assumption that the present masked terms lie in the root code."} + ] +} diff --git a/research/p112-matched-frame-copy-floor/VERIFY.json b/research/p112-matched-frame-copy-floor/VERIFY.json new file mode 100644 index 0000000000..76fc26cae2 --- /dev/null +++ b/research/p112-matched-frame-copy-floor/VERIFY.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/complex-local-word-ceiling/RESULT.json", + "research/complex-local-word-ceiling/ceiling.py", + "research/p112-single-lift/geometry.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "All 12544 geometry/identity entries; all 452 nonalternating quotient forms; exact P112 lift-capacity witnesses and unequal-span/rank-five counterexamples; full masked positive and mutation controls; integer COPY84 relaxation; certified complete optimistic screen with centre charge84." + } + ] +} diff --git a/research/p112-matched-frame-copy-floor/verify.py b/research/p112-matched-frame-copy-floor/verify.py new file mode 100755 index 0000000000..f6a5232c52 --- /dev/null +++ b/research/p112-matched-frame-copy-floor/verify.py @@ -0,0 +1,362 @@ +#!/usr/bin/env python3 +"""Exact premises and controls for the matched-frame COPY obstruction. + +Apache-2.0. Adam Gall, with substantial OpenAI Codex assistance. +Finite checks support the quantified proof in README.md, not a full theorem audit. +""" +import argparse +from collections import Counter +from fractions import Fraction as Q +import hashlib +import importlib.util +from itertools import combinations, product +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +INPUTS = { + "research/p112-single-lift/geometry.py", + "research/complex-local-word-ceiling/ceiling.py", + "research/complex-local-word-ceiling/RESULT.json", +} +CAPACITY = {1: 1, 2: 2, 3: 4, 4: 5} +SUPPORTS = { + 1: [41], + 2: [20, 99], + 3: [18, 25, 31, 105], + 4: [3, 7, 9, 22, 63, 65, 66, 72], +} + + +def require(ok, why): + if not ok: + raise ValueError(why) + + +def load(relative, name): + spec = importlib.util.spec_from_file_location(name, ROOT / relative) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def rank2(rows): + pivots = {} + for value in rows: + while value: + bit = value.bit_length() - 1 + if bit in pivots: + value ^= pivots[bit] + else: + pivots[bit] = value + break + return len(pivots) + + +def bits(row): + return sum(int(value) << j for j, value in enumerate(row)) + + +def rankq(matrix): + """Fraction row elimination; never use a floating-point rank tolerance.""" + if not matrix: + return 0 + rows = [list(map(Q, row)) for row in matrix] + pivot = 0 + for col in range(len(rows[0])): + found = next((i for i in range(pivot, len(rows)) if rows[i][col]), None) + if found is None: + continue + rows[pivot], rows[found] = rows[found], rows[pivot] + divisor = rows[pivot][col] + rows[pivot] = [value / divisor for value in rows[pivot]] + for i in range(pivot + 1, len(rows)): + factor = rows[i][col] + if factor: + rows[i] = [a - factor * b for a, b in zip(rows[i], rows[pivot])] + pivot += 1 + if pivot == len(rows): + break + return pivot + + +def rankmod(matrix, prime=101): + """Independent column-oriented odd-prime elimination: a lower rank bound over Q.""" + if not matrix: + return 0 + basis = {} + for col in zip(*matrix): + vector = [int(x) % prime for x in col] + for pos, old in sorted(basis.items()): + factor = vector[pos] + vector = [(a - factor * b) % prime for a, b in zip(vector, old)] + pos = next((i for i, x in enumerate(vector) if x), None) + if pos is not None: + inv = pow(vector[pos], -1, prime) + basis[pos] = [x * inv % prime for x in vector] + return len(basis) + + +def span(vectors): + values = {0} + for vector in vectors: + values.update(value ^ vector for value in tuple(values)) + return values + + +def submatrix(matrix, left, right): + return [[matrix[i][j] for j in right] for i in left] + + +def ranks(matrix): + return rank2(map(bits, matrix)), rankq(matrix) + + +def check_sources(): + source = json.loads((HERE / "SOURCES.json").read_text()) + rows = [row for row in source["files"] if row["usage"] == "input"] + require(len(rows) == len(INPUTS) and {row["path"] for row in rows} == INPUTS, + "complete live input inventory") + for row in rows: + require(hashlib.sha256((ROOT / row["path"]).read_bytes()).hexdigest() + == row["sha256"], "source digest: " + row["path"]) + + +def geometry(): + source = load("research/p112-single-lift/geometry.py", "pinned_geometry") + data = source.build() + roots, labels, duals, x = (data[k] for k in ("roots", "labels", "duals", "X")) + # Independently construct all Euclidean lines, then bind every live root. + lines = set() + for i, j in combinations(range(8), 2): + for si, sj in product((-2, 2), repeat=2): + row = [0] * 8 + row[i], row[j] = si, sj + lines.add(max(tuple(row), tuple(-v for v in row))) + for row in product((-1, 1), repeat=8): + if row.count(-1) % 2 == 0: + lines.add(max(row, tuple(-v for v in row))) + frame = [] + for j in range(4): + for sign in (1, -1): + row = [0] * 8 + row[2 * j], row[2 * j + 1] = 2, 2 * sign + frame.append(tuple(row)) + canonical = {max(tuple(r), tuple(-v for v in r)) for r in roots} + require(len(lines) == 120 and len(roots) == len(canonical) == 112, + "root-line cardinalities") + require(canonical == lines - set(frame), "independent P112 root set") + dot = lambda a, b: sum(u * v for u, v in zip(a, b)) + b = [] + for i, ri in enumerate(roots): + require(x[i] == [dot(ri, f) // 4 for f in frame], "coordinate binding") + row = [] + for j, rj in enumerate(roots): + require(dot(ri, rj) % 4 == 0, "integral root Gram") + gram = dot(ri, rj) // 4 + binary = (1 + gram) % 2 + require(binary == ((duals[i] & labels[j]).bit_count() & 1), + "binary label pairing binding") + require(dot(x[i], x[j]) == 2 * gram, "full coordinate decoder identity") + require(not binary or 2 * gram == 4 * (i == j), "masked target is 4I") + row.append(binary) + b.append(row) + require(all(b[i][i] == 1 for i in range(112)), "all live labels have self-pairing one") + require(rank2(map(bits, b)) == rank2(labels) == 9, "ambient binary rank nine") + return data, b + + +def quotient_census(): + """All nonalternating nonsingular symmetric forms in dimensions one through four.""" + summary = {} + for r in range(1, 5): + positions = [(i, j) for i in range(r) for j in range(i, r)] + counts = Counter() + for encoding in range(1 << len(positions)): + h = [[0] * r for _ in range(r)] + for k, (i, j) in enumerate(positions): + h[i][j] = h[j][i] = (encoding >> k) & 1 + hb = list(map(bits, h)) + if rank2(hb) != r or not any(h[i][i] for i in range(r)): + continue + def pairing(u, v): + return sum(((u >> i) & 1) * ((hb[i] & v).bit_count() & 1) + for i in range(r)) % 2 + odd = [u for u in range(1 << r) if pairing(u, u)] + diagonal = sum(h[i][i] << i for i in range(r)) + characteristic = [c for c in range(1 << r) + if all(pairing(1 << i, c) == (diagonal >> i & 1) + for i in range(r))] + require(len(characteristic) == 1, "unique characteristic vector") + c = characteristic[0] + require(c != 0 and pairing(c, c) == r % 2, "characteristic parity") + require(len(odd) == 1 << (r - 1), "odd affine hyperplane cardinality") + lifted = [[pairing(u, v) for v in odd] for u in odd] + require(ranks(lifted) == (r, CAPACITY[r]), "sharp quotient lift capacity") + require(rankmod(lifted) == CAPACITY[r], "odd-prime capacity corroboration") + if r % 2 == 0: + require(all(u ^ c in odd and u ^ c != u for u in odd), + "fixed-point-free characteristic pairing") + require(all(pairing(u, v) + pairing(u ^ c, v) == 1 + for u in odd for v in odd), "complementary lifted rows") + counts[rankq(lifted)] += 1 + summary[str(r)] = {"forms": sum(counts.values()), + "lift_rank_counts": {str(k): v for k, v in sorted(counts.items())}} + require([summary[str(r)]["forms"] for r in range(1, 5)] == [1, 3, 28, 420], + "complete symmetric-form census") + return summary + + +def fixtures(data, b): + labels = data["labels"] + rows = {} + for r, ids in SUPPORTS.items(): + matrix = submatrix(b, ids, ids) + require(ranks(matrix) == (r, CAPACITY[r]), "P112 attaining capacity fixture") + require(rankmod(matrix) == CAPACITY[r], "P112 odd-prime rank corroboration") + scaled = [[(i + 1) * value * (-2 * j - 1) for j, value in enumerate(row)] + for i, row in enumerate(matrix)] + require(rankq(scaled) == CAPACITY[r], "nonzero coefficient scaling preserves lift rank") + rows[str(r)] = {"left": ids, "right": ids, "copy_rank": r, + "lift_rank": CAPACITY[r], "label_span_dimension": rank2(labels[i] for i in ids)} + left, right = [3, 7, 9, 22, 63], SUPPORTS[4] + require(left != right and span(labels[i] for i in left) == span(labels[i] for i in right), + "different actual supports with equal label spans") + require(ranks(submatrix(b, left, right)) == (4, 5), "nonidentical-support matched fixture") + rows["different_supports"] = {"left": left, "right": right, "copy_rank": 4, "lift_rank": 5} + # These are counterexamples to *dropping* hypotheses, not rejected decoder candidates. + left, right = [0, 1, 2], [0, 72, 56] + require(span(labels[i] for i in left) != span(labels[i] for i in right), "unmatched boundary") + require(ranks(submatrix(b, left, right)) == (2, 3), "unmatched spans defeat rank-two cap") + rows["unmatched_control"] = {"left": left, "right": right, "copy_rank": 2, "lift_rank": 3} + ids = [8, 10, 24, 33, 50, 51, 74, 75, 88, 97] + require(ranks(submatrix(b, ids, ids)) == (5, 10), "rank-five capacity exceeds four-thirds rank") + require(rankmod(submatrix(b, ids, ids)) == 10, "rank-five odd-prime corroboration") + rows["rank_five_control"] = {"left": ids, "right": ids, "copy_rank": 5, "lift_rank": 10} + return rows + + +def masked_errors(b, terms): + total = [[Q(0) for _ in b] for _ in b] + for left, right in terms: + for i, di in left.items(): + for j, tj in right.items(): + total[i][j] += di * tj + return sum(bool(b[i][j] and total[i][j] != 4 * (i == j)) + for i in range(len(b)) for j in range(len(b))) + + +def decoder_controls(data, b): + x = data["X"] + coordinate = [({i: row[k] for i, row in enumerate(x) if row[k]}, + {i: row[k] for i, row in enumerate(x) if row[k]}) for k in range(8)] + require(masked_errors(b, coordinate) == 0, "incumbent masked positive control") + require([ranks(submatrix(b, list(d), list(t)))[0] for d, t in coordinate] == [8] * 8, + "incumbent eight rank-eight COPY charges") + diagonal = [({i: 2}, {i: 2}) for i in range(112)] + require(masked_errors(b, diagonal) == 0, "admissible COPY112 diagonal positive control") + odd = next((i, j) for i in range(112) for j in range(112) if not b[i][j]) + free = ({odd[0]: 7}, {odd[1]: -3}) + require(ranks(submatrix(b, list(free[0]), list(free[1])))[0] == 0, "zero-cost odd correction") + require(masked_errors(b, diagonal + [free]) == 0, "arbitrary free correction is invisible to mask") + require(masked_errors(b, diagonal[:-1]) == 1, "omitted diagonal term fails exactness") + require(masked_errors(b, diagonal + [({0: 1}, {0: 1})]) == 1, "false free diagonal correction fails") + changed_mask = [row[:] for row in b] + changed_mask[odd[0]][odd[1]] = 1 + require(masked_errors(changed_mask, diagonal + [free]) == 1, "wrong mask exposes free term") + wrong = [{i: 2} for i in range(112)] + wrong[0] = {0: 3} + require(masked_errors(b, list(zip(wrong, [t for _, t in diagonal]))) == 1, + "wrong coefficient fails exact diagonal") + return {"baseline_copy_ranks": [8] * 8, "diagonal_copy_bill": 112, + "free_pair": list(odd), "semantic_rejections": 4, + "hypothesis_counterexamples": 2} + + +def invoice(): + # Unbounded integer relaxation; overshoot by more than max capacity-1 is unnecessary. + upper = 112 + max(CAPACITY.values()) + best = [None] * upper + best[0] = (0, {(0, 0, 0, 0)}) + for capacity in range(1, upper): + for r, contribution in CAPACITY.items(): + if capacity < contribution or best[capacity - contribution] is None: + continue + cost, profiles = best[capacity - contribution] + cost += r + candidates = set() + for profile in profiles: + profile = list(profile) + profile[r - 1] += 1 + candidates.add(tuple(profile)) + if best[capacity] is None or cost < best[capacity][0]: + best[capacity] = (cost, candidates) + elif cost == best[capacity][0]: + best[capacity][1].update(candidates) + minimum = min(best[k][0] for k in range(112, upper)) + optimizers = sorted({p for k in range(112, upper) if best[k][0] == minimum for p in best[k][1]}) + require(minimum == 84 and optimizers == [(0, 0, 28, 0)], "integer relaxation optimum") + require(all(Q(c, r) <= Q(4, 3) for r, c in CAPACITY.items()), "four-thirds capacity bound") + # For 0<=a<=1/5, q=1-a>=4/5; rank-three cost/capacity is smallest. + require(4 ** 4 * 4 ** 5 > 3 ** 4 * 5 ** 5, "exact rank-four versus rank-three moment inequality") + return {"minimum_copy_bill": minimum, "optimizers_n1_n2_n3_n4": [list(p) for p in optimizers], + "universal_copy_moment_ratio_lower": "21/16", "attainment": "rank relaxation only; no COPY84 decoder"} + + +def screen(): + c = load("research/complex-local-word-ceiling/ceiling.py", "pinned_ceiling") + pinned = json.loads((ROOT / "research/complex-local-word-ceiling/RESULT.json").read_text()) + local = {int(r): n for r, n in pinned["selected"]["local_profile_per_call"].items()} + require(local == {1: 2412, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8}, + "selected per-call profile binding") + baseline = c.ceiling(local, 73, 896, 9, 64) + optimistic = dict(local) + optimistic.pop(8) + optimistic[3] += 28 + obstruction = c.ceiling(optimistic, 73, 896, 9, 84) + target = baseline[1] * Q(21, 20) + require(obstruction[1] < baseline[0] < target < Q(1, 5), "fails unchanged five-percent target") + require(c.model(local, 73, 896, 9, 64)["idle_mass"] == + c.model(optimistic, 73, 896, 9, 84)["idle_mass"] == 1646, + "centre charge and local COPY mass changed together") + require(c.relax(optimistic, 73, 896, 9, 84, obstruction[0])[1] < 1 and + c.relax(optimistic, 73, 896, 9, 84, obstruction[1])[0] > 1, + "certified obstruction bracket") + # A bogus centre=64 calculation would hide twenty units of added paid mass. + require(c.model(optimistic, 73, 896, 9, 64)["idle_mass"] == 1626, + "undercharged-centre negative control") + return {"baseline_a_bracket": list(map(str, baseline)), + "optimistic_a_bracket": list(map(str, obstruction)), + "five_percent_target": str(target), "centre_charge": 84, + "optimistic_local_profile": {str(r): n for r, n in sorted(optimistic.items())}, + "idle_mass": 1646, "additional_physical_charges": "waived for rejection only"} + + +def result(): + check_sources() + data, b = geometry() + return {"schema_version": 1, "claim": "matched-span COPY ranks one through four force COPY at least84", + "geometry": {"ports": 112, "checked_entries": 12544, "binary_rank": 9, + "constrained_entries": sum(map(sum, b))}, + "capacity": {str(r): value for r, value in CAPACITY.items()}, + "quotient_census": quotient_census(), "fixtures": fixtures(data, b), + "controls": decoder_controls(data, b), "invoice": invoice(), "screen": screen()} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write", action="store_true", help="regenerate the deterministic certificate") + args = parser.parse_args() + evidence = result() + path = HERE / "CERTIFICATE.json" + if args.write: + path.write_text(json.dumps(evidence, indent=2, sort_keys=True) + "\n") + else: + require(json.loads(path.read_text()) == evidence, "committed certificate reproduces exactly") + print("PASS_P112_MATCHED_FRAME_COPY_FLOOR forms=452 entries=12544 capacities=1,2,4,5 " + "COPY>=84 moment_ratio>=21/16 controls=7 no_new_kappa") + + +if __name__ == "__main__": + main() From 57b3cfd1f0762a736da55d6b3175a024a743b99a Mon Sep 17 00:00:00 2001 From: Adam Gall Date: Wed, 14 Oct 2026 10:30:25 -0400 Subject: [PATCH 2/2] Record final local and live overlap distinctions --- research/p112-matched-frame-copy-floor/README.md | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/research/p112-matched-frame-copy-floor/README.md b/research/p112-matched-frame-copy-floor/README.md index 52805c3a5d..3a69c7f32d 100644 --- a/research/p112-matched-frame-copy-floor/README.md +++ b/research/p112-matched-frame-copy-floor/README.md @@ -266,11 +266,17 @@ and 547 discussion records, complete pagination, fetched on 2026-10-14 at 14:10:13Z and 14:11:43Z. Targeted terms included matched/support frames, characteristic lifts, tetrad locality, rank shape, binary rank and symmetric factors. This does not search every code diff or establish literature priority. -The final cached search used the subsequently available 584-PR snapshot -(14:27:47Z) and the same discussion snapshot. Targeted live reads confirmed -that PR1909, PR1923 and PR1633 remained open at the exact heads in TASK.json. -No matched-span obstruction appeared in those bounded searches; that absence -is not a novelty certificate. +The final cached search covered 584 PRs (14:27:47Z) and 565 discussion records +(14:29:09Z), including this claim. Targeted live reads confirmed that PR1909, +PR1923 and PR1633 remained open at the exact heads in TASK.json. +The local `complex-parity-frames-seed35` and `parity-edge-compatibility-seed46` +notes were also read: their characteristic-vector/common-span obstructions +concern legal separating frames and nested DAG edges, not the P112 masked +COPY invoice. PR1558's form census verifies Z4 Gauss-kernel normalization, +not characteristic-zero rank of the odd-vector pairing mask. The underlying +characteristic-vector linear algebra is standard and is not claimed as new. +No matched-span COPY obstruction appeared in these bounded searches; that +absence is not a novelty certificate. Coordination: https://github.com/CrocSwap/integer-mult-bounds/discussions/1929#discussioncomment-18925923.