diff --git a/research/p104-temporal-query-cut/README.md b/research/p104-temporal-query-cut/README.md new file mode 100644 index 0000000000..90ee687d9f --- /dev/null +++ b/research/p104-temporal-query-cut/README.md @@ -0,0 +1,221 @@ +# A sharp eight-query temporal cut in the native P104 itinerary + +**Scoped obstruction, not a new supplier or exponent.** For the complete frozen +PR1972/PR1991 frame itinerary, even arbitrary additional common-frame linear +mixing at **all 4,059 chronological cuts** cannot raise the source-to-target +transfer rank above **eight arrays**. The original `G/2` channel attains eight. +Thus no zero-new-transport side correction can complete this itinerary to the +104-port identity. The selected result is unchanged. + +This is not a terminal-cut estimate: additions may be inserted anywhere, and +all existing dirty helpers and private-copy lifetimes are included. Conversely, +new or retimed transports, new storage lifetimes and non-common-chart operations +are outside the theorem. In particular, the separately proposed terminal +`+208 H1` corrections are **not** excluded. The missing 96 array directions are +not a claim that 96 native children are necessary. + +## Object and permitted relaxation + +The source is Rohan Arun's [PR1972](https://github.com/CrocSwap/integer-mult-bounds/pull/1972), +head `fd82d172f46933fd253c2c6de4bd5eaff5429cfd`, as retained by Chafik +Boukhalfa's [PR1991](https://github.com/CrocSwap/integer-mult-bounds/pull/1991), +head `6e222517e182e98499239bc9a4009f540e1c5520`. Its exact 4,058-event witness is +SHA256 `0f541bef7f19fdeffd67157684e9f03d785f42c89973632f508fc1a0452b580e`. +There are 104 `X` sources, 104 `Y` targets, 32 `G` gather helpers, 32 `D` delivery +helpers and eight `Q` queries, with 280 arbitrary logical inputs in total. +The owned register `C` has eight separate allocate/copy/descend/discard lifetimes. + +Fix every transport's register, position, old/new frame and native child rank, +and fix these private lifetimes. Permit an arbitrary finite number of linear +role operations among **all currently live registers with the same frame** at +every cut, not just the scalar additions in the witness. They may replace the +recorded additions, clear or mix dirty values and use the existing private +register when live. Restoring initial dirt is not imposed in the upper bound; +relaxing it only makes the exclusion stronger. The original attaining word does +restore all 72 arbitrary dirty helpers. + +A frame is its exact binary subspace, computed by XOR closure, not its dimension, +its displayed basis or its register name. The compressed labels are those in +the witness; the invertible physical isometry in PR1991 preserves equality of +subspaces. No new native compiler or monomial-equivalence theorem is claimed. +Operations between different chart classes, even if someone could implement +one with free native wrappers, are not admitted by this common-chart theorem. + +## Temporal graph certificate + +At each cut make a complete directed graph on each common-frame class, with +register-preservation edges across events. A transport preserves its register's +logical information while changing which class it can join. Creation gives no +incoming information; erasure gives no outgoing information. COPY has a +source-to-destination edge. The reachability checker also preserves the old +COPY destination, a deliberately favorable relaxation of the zero-destination +contract. Arbitrarily many common-frame operations have exactly the same +possible causal edges as saturating each class once. + +Cut `2429` is **after events 0 through 2428 and before event 2429**, the first +`D0` transport. Every original register is live, and `C` is not. Two complete +scans give: + +| Cone at cut 2429 | Registers | +|---|---| +| Reachable from any initial `X` | all 104 `X`, 32 `G`, eight `Q` | +| Can reach any final `Y` | all 104 `Y`, 32 `D`, eight `Q` | +| Intersection | precisely `Q0,...,Q7` | + +At this cut `X/G` are in the full frame, `Y/D` are in the zero frame, and the +queries occupy eight **distinct** rank-eight hyperplanes. The scans do not +infer disconnection merely from those cut frames: they include every earlier +and later class, including full-frame dirty helpers, and all eight private +lifetimes. Removing only the eight query wire crossings at this cut leaves +**no** final `Y` reachable from any initial `X`. Later source information can +reach full-frame `D/Q` registers; the scan retains it and still finds no target +path. + +The verifier traverses all 4,059 cuts and 444 distinct frame subspaces. The +complete-class relaxation contains 106,254,468 directed common-frame edges +counted with their chronological occurrences, without allocating that entire +graph. It records both directional trace digests and the cut-deletion trace in +[RESULT.json](RESULT.json). These are reproducibility receipts, not substitutes +for the general argument below. + +### Why the cut bounds every linear program in the domain + +Fix an address space of finite dimension `d` over a characteristic-zero field. +A register carries one vector in that space; its native **frame dimension** and +the rank of a charged child are different notions. In particular, a rank-eight +query frame still carries **one** `d`-dimensional array, not eight independent +arrays or one scalar. + +Set all initial non-`X` inputs to zero to isolate the `X -> Y` block. Every +causal path from an `X` input to a final `Y` crosses one of the eight query wires +at cut 2429. Therefore that linear block factors through their direct sum: + +`X^(104d) -> (Q0,...,Q7)^(8d) -> Y^(104d)`. + +Its rank is at most `8d`. One way to prove the factorization is to hold those +eight cut values fixed and set the direct source dependencies after the cut to +zero. The difference propagates only along paths avoiding the cut, and the +cut-deletion scan shows it cannot reach `Y`. This also accounts for all initial +dirty values: they affect the affine background but not this source derivative. +The reasoning covers arbitrarily many inserted linear operations; it does not +extrapolate a finite coefficient search. + +The identity completion has source-to-target block `I_104 tensor I_d`, of rank +`104d`, so it is impossible in this domain. The full local bill is granted +before any cost comparison, and even arbitrary extra common-frame scalar work +is granted free. No moment root can repair this information deficit. + +## Exact attainment and residual rank + +The independent checker reconstructs all 120 E8 root lines in doubled integer +coordinates and removes the two pinned eight-line frames. With `R` the resulting +104-by-eight real root matrix and `G = R R^t`, it checks exactly + +`R^t R = 26 I_8`, hence `G^2 = 26 G`. + +It also replays all 280 input columns of the original word using exact rational +arithmetic, obtains `Y <- Y + (G/2) X`, closes every private lifetime and restores +all 72 dirty helper inputs and all source inputs. The source matrix in the +queries at the cut has rank eight. A `G/2` principal minor on port indices +`[0,1,2,3,7,14,22,33]` has determinant **1/256**. Consequently the rank-eight +upper bound is sharp, attained by the original dirty-restored channel, not by a +new construction claimed here. + +The desired residual is not another rank-eight map. The same tight-frame +identity gives the exact inverse + +`(I - G/2)^(-1) = I - G/24`, + +so the standalone residual has full rank 104. The checker also checks all +10,816 entries of `G^2 = 26 G` and this inverse identity. This is an exact +algebraic statement, not a numerical eigenvalue test. + +## Optimistic complete bill and boundary + +The entire unchanged local profile is + +`1074 H1 + 58 H2 + 86 H3 + 104 H4 + 48 H5 + 24 H6 + 8 H7 + 8 H8`, + +with rank mass **2368 = 2312 boundary coverage + COPY56**, 2,624 recorded scalar +additions and eight allocate/copy/discard lifetimes. The tested completion +budget adds **zero** transports, copies or helper lifetimes and grants all +extra common-frame scalar work, hosting, idle remainder and precision cost +free. This deliberately favorable completion fails the exact communication +condition before a recursive moment is relevant. It would be misleading to +quote a root of this incomplete channel's histogram as an admitted supplier. + +No physical lower bound for changed itineraries follows. In particular, the +96 missing directions are **not** converted into 96 child-rank units: a new +transport can change later class membership, which requires a new graph and a +complete invoice. Global ownership, all-size lifting, precision and the outer +multiplication theorem are not proved or replayed here. Native phase identities +are inherited from the pinned PR1991 source, not independently recompiled. + +## Reproduce and evidence + +Standard-library CPython 3.12, read-only by default, no network, no producer or +Clifford-compiler imports: + +```sh +uv run --python 3.12 --no-project python -I -O -B research/p104-temporal-query-cut/verify.py +uv run --python 3.12 --no-project python scripts/research_package.py --package research/p104-temporal-query-cut +``` + +Default execution authenticates every declared live source, regenerates every +proof-relevant result and compares the complete canonical JSON payload with +`RESULT.json`. `--emit` prints the regenerated payload without that comparison. +The registered hook requests the optimized replay so checks cannot rely on +Python assertions. + +Eleven semantic negative controls are exercised: leaving any one of the eight +queries uncut reopens a source-target path; a deliberately prohibited +cross-frame bypass reopens a target path; removing initial dirty-query +compensation or final query cleanup rejects the full endpoint identity. A +positive control reverses query basis order and preserves the exact frame. +The required source-bound baseline command also reported +`PASS_RESEARCH_BASELINE_BINDINGS_ONLY`; that is not a selected cold replay. + +[TASK.json](TASK.json) records the pre-computation scope, budget, priority and +overlap limits. [SELECTION.json](SELECTION.json) preserves the single independent +selection with seed `5e89c7275a4bd70898735aea8ad1e35d`. Scientific base: +`564148b82ae9df72163f22106f15e73efca8aff2`, priority revision 4. The later +`0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2` checkpoint changed only workflow +guidance; the catalogue, selected record and scientific inputs are unchanged. + +## Open next questions + +1. **Change the transport itinerary rather than its scalar coefficients.** A + first step is to identify a priced excursion or interleaving that moves source + information around the eight-query separator. It matters because the zero- + added-transport relaxation is now closed. The blocker is an actual native + identity with restored frames and a complete hosting/precision bill. +2. **Extend the communication model to non-common-chart free native operations.** + First characterize the exact logical operator carried by one proposed + monomial-wrapped cross-chart addition. Its identity must be checked, not + inferred from equal frame dimensions. Such operations may escape this graph; + this package neither implements nor excludes them. + +## Predecessors and attribution + +Rohan Arun's PR1972 supplies the entire scalar/frame channel. Chafik Boukhalfa's +PR1991 supplies its native realization. Adam Gall's PR1940 supplies the +32-chain schedule; Josie Elliston's PR1071 supplies the P104 fixture, and Ali +Romman's PR1125 supplies the fixed-term carrier bound, with their retained +PR968/717/446/595/620 geometry lineage. No schedule, native recipe, geometry, +tight-frame identity or general linear cut lemma is claimed as newly invented. +The contribution is the source-bound sharp temporal cut under **all-cut arbitrary +common-frame mixing**, its exact attaining rank and explicit correction boundary. + +The nearest active alternative at the initial live read was the terminal +`+208 H1` construction in discussion1167 comments +[18931708](https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18931708) +and [18931718](https://github.com/CrocSwap/integer-mult-bounds/discussions/1167#discussioncomment-18931718). +Those proposals change the itinerary and are outside this result. The submission +read also inspected their successor [discussion2080](https://github.com/CrocSwap/integer-mult-bounds/discussions/2080): +it reports an author-checked finite correction, not a hosted supplier. The refreshed +snapshot covers 353 open PRs and 738 discussion/comment/reply records with complete +pagination; an offline query still warns about possible later changes. Cached and +targeted live/local checks are not a novelty or literature-priority guarantee. + +Prepared by Adam Gall with substantial OpenAI Codex assistance. Apache-2.0. +No formal-kernel proof, independent human review or hosted CI pass is claimed. diff --git a/research/p104-temporal-query-cut/RESULT.json b/research/p104-temporal-query-cut/RESULT.json new file mode 100644 index 0000000000..8aac3a4ac2 --- /dev/null +++ b/research/p104-temporal-query-cut/RESULT.json @@ -0,0 +1,166 @@ +{ + "after_cut_deletion_final_reachable": { + "D": 32, + "G": 32, + "Q": 8, + "X": 104 + }, + "all_logical_input_columns": 280, + "allowed_directed_common_frame_edges_over_all_cuts": 106254468, + "backward_trace_sha256": "601c99e6926e0702b695523ccd66c18d480b16b856ba08f6d584d0e95f1d1b4d", + "controls": [ + "omit_Q0_from_separator", + "omit_Q1_from_separator", + "omit_Q2_from_separator", + "omit_Q3_from_separator", + "omit_Q4_from_separator", + "omit_Q5_from_separator", + "omit_Q6_from_separator", + "omit_Q7_from_separator", + "cross_frame_bypass_reopens_cut", + "missing_dirty_compensation", + "missing_query_cleanup", + "reversed_basis_preserves_query_frames" + ], + "cut_convention": "after events0..2428; before event2429 and its following free mixing", + "cut_trace_sha256": "1cb2618ceca90d1e0661dc681beb5b0cbc6e994e28664b5d6aa450f4b8416f56", + "cuts_saturated": 4059, + "distinct_frame_subspaces": 444, + "events": 4058, + "forward_trace_sha256": "7209a6c3518fe4899884a31c8d7be80c713511f057ee1ac57bddca325f8df5dd", + "gram_relation": "G^2=26G", + "identity_rank_in_arrays": 104, + "local_paid_profile": { + "1": 1074, + "2": 58, + "3": 86, + "4": 104, + "5": 48, + "6": 24, + "7": 8, + "8": 8 + }, + "local_paid_rank_mass": 2368, + "missing_source_directions_in_arrays": 96, + "query_frame_bases": { + "Q0": [ + 1, + 2, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "Q1": [ + 1, + 2, + 4, + 8, + 16, + 64, + 128, + 256 + ], + "Q2": [ + 1, + 2, + 4, + 8, + 16, + 32, + 128, + 256 + ], + "Q3": [ + 3, + 4, + 8, + 17, + 32, + 64, + 128, + 256 + ], + "Q4": [ + 1, + 2, + 4, + 8, + 32, + 64, + 128, + 256 + ], + "Q5": [ + 1, + 2, + 8, + 16, + 36, + 64, + 128, + 260 + ], + "Q6": [ + 1, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ], + "Q7": [ + 1, + 2, + 8, + 16, + 32, + 64, + 132, + 260 + ] + }, + "query_source_matrix_sha256": "1132a182ebfba862662c177b0a388c74f20c0581f717b0363129583a63389154", + "rank_eight_channel_minor_determinant": "1/256", + "rank_eight_minor_ports": [ + 0, + 1, + 2, + 3, + 7, + 14, + 22, + 33 + ], + "residual_inverse": "(I-G/2)^-1=I-G/24", + "residual_rank": 104, + "restored_arbitrary_dirty_helpers": 72, + "scope": "Sharp frozen chronological common-chart linear communication capacity, not a native paid-rank lower bound for changed itineraries, a supplier or a kappa claim.", + "separator": [ + "Q0", + "Q1", + "Q2", + "Q3", + "Q4", + "Q5", + "Q6", + "Q7" + ], + "separator_cut": 2429, + "source_reachable_at_cut": { + "G": 32, + "Q": 8, + "X": 104 + }, + "source_target_rank_capacity_in_arrays": 8, + "status": "PASS_P104_TEMPORAL_QUERY_CUT", + "target_coreachable_at_cut": { + "D": 32, + "Q": 8, + "Y": 104 + } +} diff --git a/research/p104-temporal-query-cut/SELECTION.json b/research/p104-temporal-query-cut/SELECTION.json new file mode 100644 index 0000000000..f37541b205 --- /dev/null +++ b/research/p104-temporal-query-cut/SELECTION.json @@ -0,0 +1,145 @@ +{ + "seed": "5e89c7275a4bd70898735aea8ad1e35d", + "track": "complex-mechanisms", + "suggestions": [ + { + "task_id": "complex-rank-shape-decoder", + "scope_key": "02b31ebd160542c86299", + "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": "Find one exact small decoding identity whose frame path climbs in blocks, and price its complete per-call profile.", + "starting_points": [ + "research/complex-local-word-ceiling/README.md", + "research/complex-decoder-field-extension-seed44/README.md", + "research/complex-frame-pair-decoders/README.md", + "research/selected-k8-unrestricted-ends/README.md", + "research/eisenstein-reduction-copy-floor/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.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", + "Searching below C=40 in the #2017 Eisenstein binary scalar-rectangle or fixed-support block-linear additive pairing model; specify a changed premise instead. This bound does not cover every complex decoder." + ], + "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": "p104-side-correction", + "scope_key": "c5367b1a1b7bed20db53", + "question": "Can the native P104 low-rank channel be completed with a legal, fully charged I-G/2 side correction?", + "method": "Construct one side-correction word at an explicit chronological cut with the needed frames still available.", + "starting_points": [ + "research/p104-native-channel/README.md", + "research/p104-native-channel/PROOF.md", + "docs/research/community-efficient1000-review.md" + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the P104 open next questions and its fixed local histogram; inspect why appending I-G/2 after source completion is not justified. #1991 supplies the checked native channel, not the missing correction.", + "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission." + }, + "first_experiment": "Choose one exact side-correction cut and bound its allowed cost from a favorable completed moment at a declared target. Stop or hand off if the necessary source/target access cannot be justified or even the optimistic total misses the target.", + "bottleneck_link": "Completing an already realized changed channel tests a concrete construction opportunity, instead of refining the incumbent packing. A positive local result still needs global and all-size admission.", + "allowed_variations": [ + "One correction factorization, one chronological cut, or one explicit hosting obstruction.", + "A changed correction schedule with an updated full bill and native frame contract." + ], + "scope_change_triggers": [ + "Recompiling the already certified low-rank channel without closing a new obligation.", + "Treating a pending ancestor, local histogram or unpriced side correction as an admitted global supplier." + ], + "overlap_terms": [ + "P104", + "I-G/2", + "side correction", + "native channel", + "1972", + "1991" + ], + "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": "5868e5281a1e63d41a22", + "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?", + "method": "Propose a changed helper inventory and derive an optimistic exact moment.", + "starting_points": [ + "research/complex-local-word-ceiling/README.md", + "research/heterogeneous-owner-assembly/README.md", + "certificates/selected-result.json", + "research/selected-k8-unrestricted-ends/README.md" + ], + "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.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013." + ], + "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": "564148b82ae9df72163f22106f15e73efca8aff2", + "catalog_assessed_on": "2026-10-14", + "priority_revision": 4, + "priority_log": "docs/research/research-priority-log.md", + "catalog_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "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/p104-temporal-query-cut/SOURCES.json b/research/p104-temporal-query-cut/SOURCES.json new file mode 100644 index 0000000000..ef6f9f5e2f --- /dev/null +++ b/research/p104-temporal-query-cut/SOURCES.json @@ -0,0 +1,70 @@ +{ + "schema_version": 1, + "base_commit": "564148b82ae9df72163f22106f15e73efca8aff2", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7" + }, + { + "path": "research/p104-native-channel/PROOF.md", + "usage": "input", + "git_blob": "a69311b74f74a2f8e8f411c1451baacd9bacddce", + "sha256": "5d743145d389ffdfaffc66096fa7e32c7155b18f73d74755403151d0435bb94c" + }, + { + "path": "research/p104-native-channel/README.md", + "usage": "input", + "git_blob": "f187d1ac0b7792d08d2dedf4561380b798e541b5", + "sha256": "ef874f86415c98b553bda9199d5f8f2f7a4dd4f6a23e53712c3c1f7268ec5b23" + }, + { + "path": "research/p104-native-channel/SOURCES.json", + "usage": "input", + "git_blob": "901ad0fb42b62eefedecb467ad45c884f494c163", + "sha256": "2ad02321c659c4ebb75fae1a0265437506e7a1fb5ab5ff17444a8be5692fcf73" + }, + { + "path": "research/p104-native-channel/inputs/LOWRANK-WITNESS.json", + "usage": "input", + "git_blob": "86beaf424e9f0f800ae3a62797d94ec9386b7706", + "sha256": "0f541bef7f19fdeffd67157684e9f03d785f42c89973632f508fc1a0452b580e" + }, + { + "path": "research/p104-native-channel/inputs/P104-FIXTURE.json", + "usage": "input", + "git_blob": "2e16f99b295bb386fd13bd8fbd57b42ef54143a9", + "sha256": "516c06f6ec3cb84be588c546108de897650288576dd5fbf5fe44b9c5546ad8a4" + } + ], + "predecessors": [ + { + "pr": 1972, + "head": "fd82d172f46933fd253c2c6de4bd5eaff5429cfd", + "author": "Rohan Arun", + "role": "Entire scalar/frame G/2 channel and arbitrary-dirty cancellation" + }, + { + "pr": 1991, + "head": "6e222517e182e98499239bc9a4009f540e1c5520", + "author": "Chafik Boukhalfa", + "role": "Native realization and retained source distribution; phases not recompiled here" + }, + { + "pr": 1940, + "head": "a9b7dfe2809092a9a4c90784d12bb60061e995e8", + "author": "Adam Gall", + "role": "32-chain schedule used by the channel" + } + ], + "attribution": "P104 fixture and geometry: Josie Elliston / PR1071. Fixed-term carrier bound: Ali Romman / PR1125. Retain PR968/717/446/595/620 lineage. No predecessor code is imported or newly vendored.", + "disclosure": "Prepared by Adam Gall with substantial OpenAI Codex assistance. Apache-2.0. No proof assistant or independent human review claimed." +} diff --git a/research/p104-temporal-query-cut/TASK.json b/research/p104-temporal-query-cut/TASK.json new file mode 100644 index 0000000000..2527bd1176 --- /dev/null +++ b/research/p104-temporal-query-cut/TASK.json @@ -0,0 +1,93 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "priority_revision": 4, + "base_commit": "564148b82ae9df72163f22106f15e73efca8aff2", + "original_card": { + "id": "p104-side-correction", + "question": "Can the native P104 low-rank channel be completed with a legal, fully charged I-G/2 side correction?", + "starting_points": [ + "research/p104-native-channel/README.md", + "research/p104-native-channel/PROOF.md", + "docs/research/community-efficient1000-review.md" + ], + "methods": [ + "Construct one side-correction word at an explicit chronological cut with the needed frames still available.", + "Derive a lower bound on the side correction and hosting costs that decides whether this channel can beat the selected budget." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the P104 open next questions and its fixed local histogram; inspect why appending I-G/2 after source completion is not justified. #1991 supplies the checked native channel, not the missing correction.", + "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission." + }, + "first_experiment": "Choose one exact side-correction cut and bound its allowed cost from a favorable completed moment at a declared target. Stop or hand off if the necessary source/target access cannot be justified or even the optimistic total misses the target.", + "bottleneck_link": "Completing an already realized changed channel tests a concrete construction opportunity, instead of refining the incumbent packing. A positive local result still needs global and all-size admission.", + "allowed_variations": [ + "One correction factorization, one chronological cut, or one explicit hosting obstruction.", + "A changed correction schedule with an updated full bill and native frame contract." + ], + "scope_change_triggers": [ + "Recompiling the already certified low-rank channel without closing a new obligation.", + "Treating a pending ancestor, local histogram or unpriced side correction as an admitted global supplier." + ], + "overlap_terms": [ + "P104", + "I-G/2", + "side correction", + "native channel", + "1972", + "1991" + ] + }, + "scope_status": "refined", + "actual_scope": "Determine the sharp source-to-target logical rank capacity of the frozen PR1972/PR1991 chronological transport skeleton, permitting arbitrary common-frame role-linear mixing at every cut and retaining every existing private-copy lifetime. Decide whether any zero-new-transport I-G/2 correction can complete the channel.", + "scope_change_reason": "Revision 4 names chronological frame access as a missing interface. Live external claims already add 208 terminal transports. This investigation instead gives a whole-chronology obstruction under an explicitly frozen transport schedule, not another terminal construction or terminal paid lower bound.", + "bottleneck_link": "A low-rank channel's favorable COPY56 bill is irrelevant to identity completion if its actual temporal communication graph cannot carry all 104 source directions. A sharp cut identifies the exact interface that a future correction must change.", + "budget_minutes": 60, + "stop_rule": "Analyze only the pinned 4058-event word and all its cuts. Establish a complete temporal separator and an attaining exact source-target rank, or reject this proposed separator. No larger search, transport synthesis, new supplier or exponent claim.", + "outcome": "negative-result", + "result": "Sharp scoped obstruction: frozen chronological common-chart source-target rank capacity is eight arrays, attained by the original dirty-restored G/2 word; identity and I-G/2 have rank104 and cannot be completed by zero-new-transport mixing.", + "evidence": "RESULT.json: all4059cuts,444exactframe subspaces,106254468implicit directed common-frame edges; forward/backward intersection Q0..Q7 atcut2429; all280endpointcolumns; eight-query source rank8; G/2 principal minor1/256; G^2=26G and (I-G/2)^-1=I-G/24; eleven semantic negative controls and one basis positive control. CPython3.12 mathematical generation passed; final registered replay recorded in the PR.", + "author": "Adam Gall with OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance in research, proof, implementation and writing; no formal kernel or independent human review claimed.", + "seed": "5e89c7275a4bd70898735aea8ad1e35d", + "track": "complex-mechanisms", + "method_domain": { + "source": "PR1972 witness fd82d172f46933fd253c2c6de4bd5eaff5429cfd, retained by PR1991", + "inputs": "104 X sources, 104 Y targets, 32 G gather helpers, 32 D delivery helpers, 8 Q query helpers, all arbitrary dirty", + "allowed": "Any finite role-linear mixing among registers in the same exact canonical frame at every chronological cut, including replacing the original scalar additions; original transports and private zero/copy/erase events fixed.", + "excluded": "New, removed, reordered or retimed transports; new storage lifetimes; non-common-chart native operations; nonlinear/adaptive encoding; global owner or all-size realization.", + "optimistic_complete_bill": "Zero added transport, copy, helper, precision or hosting charges. Retain the full known local profile {1:1074,2:58,3:86,4:104,5:48,6:24,7:8,8:8}, mass2368, all2624 scalar events and8 allocate/copy/discard lifetimes. Grant unlimited additional common-frame scalar work and global idle/hosting free. Reject on exact rank capacity before moment optimization; this is deliberately more favorable than any complete zero-new-transport supplier." + }, + "freshness": { + "upstream_commit": "564148b82ae9df72163f22106f15e73efca8aff2", + "priority_revision": 4, + "submission_checkpoint": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "checkpoint_decision": "Read changed workflow guidance; priority revision4, catalogue, selected record and scientific source bytes unchanged. Retain original scientific base and pins.", + "final_shared_refresh_utc": "2026-10-14T19:02:09Z", + "final_shared_refresh_coverage": "353 open PRs including drafts and738 discussion/comment/reply records; complete pagination, no warnings. Targeted live updates checked separately; no absence-based novelty claim.", + "open_pr_snapshot": "2026-10-14T18:47:54.386068+00:00", + "discussion_snapshot": "2026-10-14T18:49:41.296647+00:00", + "coverage": "350 open PRs including drafts; 729 discussion/comment/reply records; complete pagination. Offline cache plus targeted live discussion1167 and PR1972 reads. No novelty inference from absence." + }, + "nearest_overlap": [ + {"source": "PR1972 / Rohan Arun", "delta": "Original complete scalar/frame G/2 channel, not the all-cut arbitrary-mixing rank obstruction."}, + {"source": "PR1991 / Chafik Boukhalfa", "delta": "Exact native realization and local invoice; explicitly leaves side correction open."}, + {"source": "discussion2080 and discussion1167#discussioncomment-18931708 / #discussioncomment-18931718", "delta": "Live terminal constructions add208rank-one transports, outside the frozen-skeleton domain. Discussion2080 was read at submission; its author-checked finite construction is not reverified here."}, + {"source": "PR1940 / Adam Gall, PR1071 / Josie Elliston, PR1125 / Ali Romman", "delta": "Schedule, P104 fixture and fixed-term carrier bound retain predecessor credit; not a new P104 geometry or delivery schedule."} + ], + "open_questions": [ + { + "question": "Which changed frame itinerary supplies the missing source directions without consuming the favorable P104 budget?", + "why_it_matters": "A zero-added-transport chronological obstruction identifies required new communication rather than rejecting the P104 channel itself.", + "first_step": "Use the explicit separator as a constraint when proposing a priced internal transport or a changed gather/delivery interleaving.", + "blocked_by": "Requires new native frame identities and a fully charged chronological hosting/precision invoice; the frozen-skeleton result does not price such changes." + } + ] +} diff --git a/research/p104-temporal-query-cut/VERIFY.json b/research/p104-temporal-query-cut/VERIFY.json new file mode 100644 index 0000000000..54de779bf6 --- /dev/null +++ b/research/p104-temporal-query-cut/VERIFY.json @@ -0,0 +1,26 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/p104-native-channel/PROOF.md", + "research/p104-native-channel/README.md", + "research/p104-native-channel/SOURCES.json", + "research/p104-native-channel/inputs/LOWRANK-WITNESS.json", + "research/p104-native-channel/inputs/P104-FIXTURE.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Authenticate source pins; saturate every common-frame class at all4059cuts; independently scan forward/backward causal cones; delete the eight-query separator; exact 280-column endpoint replay and rank-eight attaining minor; eleven semantic negative controls and equivalent-basis positive control; compare canonical regenerated RESULT.json." + } + ] +} diff --git a/research/p104-temporal-query-cut/verify.py b/research/p104-temporal-query-cut/verify.py new file mode 100755 index 0000000000..174cc6d2f7 --- /dev/null +++ b/research/p104-temporal-query-cut/verify.py @@ -0,0 +1,386 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact temporal communication cut; no producer/compiler imports. + +A frame class at a cut is a complete directed communication graph. Saturating +that class therefore permits any number of extra common-chart linear gates, +not merely the scalar edges in the source witness. The two scans independently +follow the two directions of time. Native child rank is NOT wire capacity. +""" +import argparse +from collections import Counter, defaultdict +from fractions import Fraction as Q +from hashlib import sha256 +from itertools import combinations, product +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +SOURCE = "research/p104-native-channel/inputs/LOWRANK-WITNESS.json" +FIXTURE = "research/p104-native-channel/inputs/P104-FIXTURE.json" +CUT = 2429 # Before zero-based event 2429, the first D-helper transport. +QUERIES = frozenset("Q" + str(i) for i in range(8)) +PROFILE = {1: 1074, 2: 58, 3: 86, 4: 104, 5: 48, 6: 24, 7: 8, 8: 8} + + +def need(condition, reason): + if not condition: + raise ValueError(reason) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")).encode() + + +def span(vectors): + """Literal XOR closure, independent of basis ordering or elimination.""" + covered = {0} + for vector in vectors: + need(type(vector) is int and 0 < vector < 512, "frame coordinate") + need(vector not in covered, "dependent frame basis") + covered.update(x ^ vector for x in tuple(covered)) + return tuple(sorted(covered)) + + +def classes(frames): + groups = defaultdict(list) + for name, frame in frames.items(): + groups[frame].append(name) + return groups.values() + + +def close(active, frames): + """One closure suffices: equality classes are disjoint complete graphs.""" + for group in classes(frames): + if active.intersection(group): + active.update(group) + + +def family_counts(names): + return dict(sorted(Counter(name.rstrip("0123456789") for name in names).items())) + + +def load_sources(): + manifest = json.loads((HERE / "SOURCES.json").read_text()) + inputs = {} + for pin in manifest["files"]: + if pin["usage"] == "input": + raw = (ROOT / pin["path"]).read_bytes() + need(sha256(raw).hexdigest() == pin["sha256"], "source pin: " + pin["path"]) + inputs[pin["path"]] = raw + return json.loads(inputs[SOURCE]), json.loads(inputs[FIXTURE])["section4_explicit_P104"] + + +def geometry(fixture): + roots = set() + for i, j in combinations(range(8), 2): + for sign in (-1, 1): + row = [0] * 8 + row[i], row[j] = 2, 2 * sign + roots.add(tuple(row)) + for signs in product((-1, 1), repeat=7): + if signs.count(-1) % 2 == 0: + roots.add((1, *signs)) + removed = {tuple(row) for row in fixture["F0"] + fixture["C"]} + need(len(roots) == 120 and len(removed) == 16 and removed <= roots, "P104 root fixture") + ports = sorted(roots - removed) + need(len(ports) == 104, "104 live roots") + # These are doubled real coordinates, so RR^t has a denominator of four. + gram = [[Q(sum(a * b for a, b in zip(x, y)), 4) for y in ports] for x in ports] + coordinate_gram = [[Q(sum(row[i] * row[j] for row in ports), 4) + for j in range(8)] for i in range(8)] + need(coordinate_gram == [[Q(26 * (i == j)) for j in range(8)] for i in range(8)], + "P104 tight-frame identity R^t R = 26 I") + return ports, gram + + +def rank(matrix): + rows = [[Q(value) for value in row] for row in matrix] + pivot = 0 + for column in range(len(rows[0]) if rows else 0): + found = next((i for i in range(pivot, len(rows)) if rows[i][column]), None) + if found is None: + continue + rows[pivot], rows[found] = rows[found], rows[pivot] + value = rows[pivot][column] + rows[pivot] = [entry / value for entry in rows[pivot]] + for i in range(pivot + 1, len(rows)): + if rows[i][column]: + value = rows[i][column] + rows[i] = [a - value * b for a, b in zip(rows[i], rows[pivot])] + pivot += 1 + if pivot == len(rows): + break + return pivot + + +def determinant(matrix): + rows = [[Q(value) for value in row] for row in matrix] + answer = Q(1) + for column in range(len(rows)): + found = next((i for i in range(column, len(rows)) if rows[i][column]), None) + if found is None: + return Q(0) + if found != column: + rows[column], rows[found] = rows[found], rows[column] + answer = -answer + value = rows[column][column] + answer *= value + for i in range(column + 1, len(rows)): + multiplier = rows[i][column] / value + for j in range(column + 1, len(rows)): + rows[i][j] -= multiplier * rows[column][j] + return answer + + +def skeleton(word): + """Validate every wire/lifetime and all recorded common-frame operations.""" + frames = {name: span(frame) for name, frame in word["initial_frames"].items()} + need(family_counts(frames) == {"D": 32, "G": 32, "Q": 8, "X": 104, "Y": 104}, "initial inventory") + paid, operations = Counter(), Counter() + all_frames = set(frames.values()) + cut_frames = None + for i, event in enumerate(word["program"]): + if i == CUT: + cut_frames = dict(frames) + op = event[0] + operations[op] += 1 + if op == "transport": + _, name, old, new, child = event + a, b = span(old), span(new) + need(frames[name] == a, "transport old frame") + need(set(a) <= set(b) or set(b) <= set(a), "nested transport") + need(child == abs(len(old) - len(new)) > 0, "child rank") + paid[child] += 1 + frames[name] = b + all_frames.add(b) + elif op == "zero": + _, name, frame = event + need(name == "C" and name not in frames, "private creation") + frames[name] = span(frame) + elif op == "erase": + _, name, frame = event + need(name == "C" and frames[name] == span(frame), "private erasure") + del frames[name] + elif op in ("copy", "add"): + name, source = event[1:3] + need(name != source and frames[name] == frames[source] == span(event[-1]), "common-frame event") + if op == "add": + Q(event[3]) + else: + raise ValueError("unknown event") + need(frames == {name: span(frame) for name, frame in word["final_frames"].items()}, "final frames") + need(dict(paid) == PROFILE, "complete native boundary profile") + need(len(word["program"]) == 4058 and operations == Counter(add=2624, transport=1410, zero=8, copy=8, erase=8), "complete event inventory") + need(word["program"][CUT][:2] == ["transport", "D0"], "separator anchor") + return cut_frames, len(all_frames) + + +def forward(word, cut_queries=None, extra_edge=None): + """Reachability from all X inputs; optionally delete query wire crossings.""" + frames = {name: span(frame) for name, frame in word["initial_frames"].items()} + active = {name for name in frames if name.startswith("X")} + digest = sha256() + at_cut = None + edge_count = 0 + for i in range(len(word["program"]) + 1): + # The cut is between the preceding event and this cut's free mixing. + if i == CUT: + at_cut = set(active) + if cut_queries is not None: + active.difference_update(cut_queries) + if extra_edge is not None and extra_edge[0] in active: + active.add(extra_edge[1]) + close(active, frames) + edge_count += sum(len(group) * (len(group) - 1) for group in classes(frames)) + digest.update(canonical([i, sorted(active)])) + if i == len(word["program"]): + break + event = word["program"][i] + op = event[0] + if op == "transport": + frames[event[1]] = span(event[3]) + elif op == "zero": + frames[event[1]] = span(event[2]) + active.discard(event[1]) + elif op == "erase": + del frames[event[1]] + active.discard(event[1]) + elif op == "copy" and event[2] in active: + active.add(event[1]) + # Recorded ADD is subsumed by closure. Retaining the old COPY destination + # is a deliberate relaxation of its zero/overwrite contract, never a loss + # of a potential dependency. + return at_cut, active, digest.hexdigest(), edge_count + + +def backward(word): + """Reverse-time dependency cone of all final Y outputs, not an inverse word.""" + frames = {name: span(frame) for name, frame in word["final_frames"].items()} + needed = {name for name in frames if name.startswith("Y")} + digest = sha256() + at_cut = None + for i in range(len(word["program"]), -1, -1): + close(needed, frames) + digest.update(canonical([i, sorted(needed)])) + if i == CUT: + at_cut = set(needed) + if i == 0: + break + event = word["program"][i - 1] + op = event[0] + if op == "transport": + frames[event[1]] = span(event[2]) + elif op == "erase": + frames[event[1]] = span(event[2]) + needed.discard(event[1]) + elif op == "zero": + del frames[event[1]] + needed.discard(event[1]) + elif op == "copy" and event[1] in needed: + needed.add(event[2]) + return at_cut, needed, digest.hexdigest() + + +def scalar_replay(word, gram, fault=None): + """Independent exact logical induction, including every arbitrary dirty input.""" + state = {name: {name: Q(1)} for name in word["initial_frames"]} + query_rows = None + for i, event in enumerate(word["program"]): + if i == CUT: + query_rows = [[state[name].get("X" + str(j), Q(0)) for j in range(104)] + for name in sorted(QUERIES)] + op = event[0] + if op == "zero": + state[event[1]] = {} + elif op == "erase": + del state[event[1]] + elif op == "copy": + need(not state[event[1]], "copy destination zero") + state[event[1]] = dict(state[event[2]]) + elif op == "add": + name, source = event[1:3] + coefficient = Q(event[3]) + if fault == "dirty_compensation" and i == 0: + coefficient = 0 + if fault == "query_cleanup" and i == len(word["program"]) - 1: + coefficient = 0 + for key, value in list(state[source].items()): + result = state[name].get(key, Q(0)) + coefficient * value + if result: + state[name][key] = result + else: + state[name].pop(key, None) + need(set(state) == set(word["initial_frames"]), "all private lifetimes closed") + for name, row in state.items(): + expected = {name: Q(1)} + if name.startswith("Y"): + expected.update({"X" + str(j): value / 2 for j, value in enumerate(gram[int(name[1:])]) if value}) + need(row == expected, "all-column endpoint: " + name) + need(rank(query_rows) == 8, "eight independent gathered source directions") + return query_rows + + +def expect_failure(function, reason): + try: + function() + except ValueError: + return reason + raise ValueError("accepted negative control: " + reason) + + +def result(): + word, fixture = load_sources() + cut_frames, frame_count = skeleton(word) + ports, gram = geometry(fixture) + source_at_cut, final_cone, forward_digest, edge_count = forward(word) + target_at_cut, initial_cone, backward_digest = backward(word) + separator = source_at_cut & target_at_cut + need(separator == QUERIES, "exact temporal intersection is all eight queries") + _, cut_final, cut_digest, _ = forward(word, QUERIES) + need(not any(name.startswith("Y") for name in cut_final), "query cut disconnects every target") + need(all("Y" + str(i) in final_cone for i in range(104)), "uncut graph reaches every target") + need(all("X" + str(i) in initial_cone for i in range(104)), "backward graph reaches every source") + query_rows = scalar_replay(word, gram) + pivots = [] + for i, row in enumerate(ports): + if rank([ports[j] for j in pivots] + [row]) > len(pivots): + pivots.append(i) + need(len(pivots) == 8, "root coordinate rank") + minor = determinant([[gram[i][j] / 2 for j in pivots] for i in pivots]) + need(minor != 0, "rank-eight attaining Gram minor") + # R^t R=26I implies G^2=26G, hence (I-G/2)^-1=I-G/24. + # Check every entry as well: this is not a numerical eigenvalue claim. + for i in range(104): + for j in range(104): + square = sum(gram[i][k] * gram[k][j] for k in range(104)) + need(square == 26 * gram[i][j], "G squared tight-frame identity") + need(-Q(13, 24) * gram[i][j] + square / 48 == 0, "residual exact inverse") + controls = [] + for name in sorted(QUERIES): + _, leak, _, _ = forward(word, QUERIES - {name}) + need(any(target.startswith("Y") for target in leak), "each omitted query must reopen a path") + controls.append("omit_" + name + "_from_separator") + # A deliberately prohibited cross-frame bypass tests the causal conclusion, + # not source hashes. Reopening even one source->target edge defeats the cut. + need(cut_frames["X0"] != cut_frames["Y0"], "bypass is genuinely cross-frame") + _, leak, _, _ = forward(word, QUERIES, ("X0", "Y0")) + need("Y0" in leak, "cross-frame bypass must reopen a target path") + controls.append("cross_frame_bypass_reopens_cut") + controls.append(expect_failure(lambda: scalar_replay(word, gram, "dirty_compensation"), "missing_dirty_compensation")) + controls.append(expect_failure(lambda: scalar_replay(word, gram, "query_cleanup"), "missing_query_cleanup")) + # Same dimension is not same frame: all eight cut query hyperplanes differ. + need(len({cut_frames[name] for name in QUERIES}) == 8 and + all(len(cut_frames[name]) == 256 for name in QUERIES), "distinct rank-eight query frames") + for name in QUERIES: + need(span(list(reversed(word["program"][next(i for i, e in enumerate(word["program"]) + if e[0] == "transport" and e[1] == name)][3]))) == cut_frames[name], "basis-independent frame equality") + controls.append("reversed_basis_preserves_query_frames") + return { + "status": "PASS_P104_TEMPORAL_QUERY_CUT", + "events": 4058, + "cuts_saturated": 4059, + "distinct_frame_subspaces": frame_count, + "allowed_directed_common_frame_edges_over_all_cuts": edge_count, + "separator_cut": CUT, + "cut_convention": "after events0..2428; before event2429 and its following free mixing", + "separator": sorted(separator), + "source_reachable_at_cut": family_counts(source_at_cut), + "target_coreachable_at_cut": family_counts(target_at_cut), + "query_frame_bases": {name: next(e[3] for e in word["program"] if e[0] == "transport" and e[1] == name) for name in sorted(QUERIES)}, + "after_cut_deletion_final_reachable": family_counts(cut_final), + "forward_trace_sha256": forward_digest, + "backward_trace_sha256": backward_digest, + "cut_trace_sha256": cut_digest, + "source_target_rank_capacity_in_arrays": 8, + "identity_rank_in_arrays": 104, + "missing_source_directions_in_arrays": 96, + "rank_eight_minor_ports": pivots, + "rank_eight_channel_minor_determinant": str(minor), + "query_source_matrix_sha256": sha256(canonical([[str(x) for x in row] for row in query_rows])).hexdigest(), + "gram_relation": "G^2=26G", + "residual_inverse": "(I-G/2)^-1=I-G/24", + "residual_rank": 104, + "all_logical_input_columns": 280, + "restored_arbitrary_dirty_helpers": 72, + "local_paid_profile": {str(k): v for k, v in PROFILE.items()}, + "local_paid_rank_mass": sum(k * v for k, v in PROFILE.items()), + "controls": controls, + "scope": "Sharp frozen chronological common-chart linear communication capacity, not a native paid-rank lower bound for changed itineraries, a supplier or a kappa claim." + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--emit", action="store_true", help="emit regenerated mathematical payload without comparing RESULT.json") + args = parser.parse_args() + receipt = result() + if not args.emit: + expected = json.loads((HERE / "RESULT.json").read_text()) + need(canonical(receipt) == canonical(expected), "canonical regenerated result") + print(json.dumps(receipt, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main()