diff --git a/docs/research/handoffs/ali-romman-20261025/EXPERIMENTS.md b/docs/research/handoffs/ali-romman-20261025/EXPERIMENTS.md new file mode 100644 index 0000000000..dcb93a45f7 --- /dev/null +++ b/docs/research/handoffs/ali-romman-20261025/EXPERIMENTS.md @@ -0,0 +1,58 @@ +# Stopped families and evidence limits + +This table is a continuation guide. Each negative result applies only to +its stated model. The full local record is retained in the project archive. +Names in the last column refer to files in that record. They are not new +public verification claims. + +| Family | Result and stop rule | Evidence | +| --- | --- | --- | +| Original clean-word snapshot caches | Equal-frame, monomial, and bounded operator-unit reuse gave no paid saving. Do not repeat the same cache class. | [Finding #5355](https://github.com/CrocSwap/integer-mult-bounds/discussions/5355); `snapshot_discovery.py`, `span_discovery.py`, `all_anchor_discovery.py`, `module_discovery.py`, `unit_module_discovery.py`. | +| Changed permutation codes and triple DAGs | The declared complete optimistic bills lose. This is not a theorem about all codes or DAGs. | [Finding #5381](https://github.com/CrocSwap/integer-mult-bounds/discussions/5381). | +| Private-helper ownership cuts | The single-helper and group-cut tests gave no profitable candidate. Later owned-subset tests repeat this family. | [Released finding](https://github.com/CrocSwap/integer-mult-bounds/discussions/5125#discussioncomment-19154948); `ownership_cut_screen.py`, `owned_subset_ssa.py`. | +| Native scalar and map cancellation | A useful circuit reduction is in PR #5403. Retiming the paid paths gave no paid gain. | [Package](https://github.com/CrocSwap/integer-mult-bounds/pull/5403); [retiming result](https://github.com/CrocSwap/integer-mult-bounds/discussions/5125#discussioncomment-19155692). | +| Repeated two- and three-pair controllers | The 266,584-case bounded test and exact cost checks gave no improvement. | [Finding](https://github.com/CrocSwap/integer-mult-bounds/discussions/4611#discussioncomment-19156205); `repeated_stage_screen.py`, `repeated_stage_verify.py`. | +| Coupled native inverse | Both inverse compositions are constructed without extra Gaussian calls. Ordinary inverse-child costs remain charged. | [PR #5411](https://github.com/CrocSwap/integer-mult-bounds/pull/5411). | +| Small coupled bridge grammars | Shared banks, full bridges, three observations, uncoded middle calls, and mode transport gave no complete funded caller. | [Released caller record](https://github.com/CrocSwap/integer-mult-bounds/discussions/4930#discussioncomment-19156336); `coupled_*bridge.py`, `coupled_*transport.py`, `coupled_four_bank.py`, `coupled_three_observations.py`. | +| One completed-Q catalyst | The declared 188-state binary graph retains the 5/3 bound. This does not cover more general callers. | `retained_q_catalyst.py/json`. | +| Static native-history completion | Scalar and finite-field chart spans gave no funded repair. Cheaper floating candidates failed exact consistency. | `native_history_completion.py`, `native_history_joint_rank.py`, `native_history_repair_*`. | +| Later native continuation | Tests at 2,469 cuts, including one- and two-readout choices, gave no funded correction. Scalar specialization is a strict scope limit. | `native_one_query.py`, `native_two_readouts.py`, `native_temporal_injection.py`, `native_temporal_query_tree.py`. | +| Fixed-source guard cut | Rank-below-nine additive insertions cannot change the eight terminal modes while all original zero guards stay zero. | `NATIVE-GUARD-CUT.md`, `native_guard_cut.py/json`; [public scope](https://github.com/CrocSwap/integer-mult-bounds/discussions/4930#discussioncomment-19156336). | +| Conditional query ports | Eight paid H1 jobs can expose eight H1 responses. The isolated bill is neutral. A complete caller is absent. | `native_guard_query_ports.py/json`. | +| Fixed-source full-chart observations | Eight exact zero-address witnesses make all 5,897 allowed observations vanish but retain the desired modes. Lower charts and changed sources are outside the statement. | `native_full_chart_kernel.py/json`, `native_zero_anchor.py/json`. | +| Mode observer and encoded query variants | The specified five-call, changed-encoder and feedback tests did not produce a caller. They do not exclude arbitrary observation schemes. | `caller_mode_observability.py`, `caller_changed_query_encoder.py`, `caller_query_feedback.py`, `five_word_handoff.py`. | +| Projection swaps and mode exchanges | 8,640 projection-swap cases and 3,840 rational mode-exchange cases gave no endpoint. | `projection_swap_caller.py/json`, `general_mode_exchange.py/json`. | +| Three-call code transport | Two 27,648-schedule tests, one with 55,296 target-parity cases, gave no endpoint. Stop this grammar. | `code_transport_caller_q4.json`, `code_transport_queries.py/json`. | +| E8 plane probes | A candidate Gram product has forbidden nonzero entries. The shifted alternatives do not give a useful tariff. | `e8_plane_screen.py`, `e8_plane_products.py`, `e8_alternating_plane_screen.py`. | +| Direct-sum product planes | Two exact factors give tariffs 15,232 and 15,552. Neither is claimed optimal. Rank does not imply a tariff floor. | [Finding](https://github.com/CrocSwap/integer-mult-bounds/discussions/1587#discussioncomment-19161781); [separate reproduction](https://github.com/CrocSwap/integer-mult-bounds/discussions/1587#discussioncomment-19168830). | +| Odd E8 direct sums | The decoder and its declining tariff are constructive. Separated complete-helper lifts fail the declared cost gate. Joint producers are outside that obstruction. | [PR #5439](https://github.com/CrocSwap/integer-mult-bounds/pull/5439). | +| Synchronized tensor callers | The favorable physical-wire cost screen still loses. It is a floating planning test, not an all-schedule theorem. The unbound earlier receipt is superseded. | `tensor_fusion_screen.py/json`; `tensor-fusion-screen-before-source-binding.json` is historical only. | +| Fixed P112 query support | The inherited parity-projector proof gives block rank exactly 9r, also for the stated eight-port puncture. Changing block size does not escape that support constraint. | [Attributed finding and certificate](https://github.com/CrocSwap/integer-mult-bounds/discussions/1587#discussioncomment-19167039). | +| F4 Hermitian labels | Dimensions 7–9 exhaust in the author's finite search; a dimension-10 positive control passes. No independent UNSAT certificate was produced. | `f4-gate/ROUND.json`, `f4-gate/search_hermitian.py`; source geometry, field skeleton and certificate code remain credited inputs. | +| Ternary labels | Several bounded searches exhaust; one dimension-nine search times out. No new ternary positive control or independent UNSAT certificate was run. | `f4-gate/search_ternary.py`, `f4-gate/search_ternary_asymmetric.py`. | +| Coxeter–Todd geometry | The direct masks lose their copy-mass gate. Dimension-15 and dimension-16 fitting searches time out. A timeout gives no impossibility result. | `coxeter_todd_gate.py/json`, `coxeter_binary_fit.py`, `geometry_ideal_gate.json`. | +| Unchanged p19 invoice | The native letter and caller letter differ. The omitted 4,256 H1 jobs make the repaired bill lose. Existing reviews already record this defect. | [PR #5440](https://github.com/CrocSwap/integer-mult-bounds/pull/5440); no duplicate audit claim. | +| Small E retained-history fixture | Exact rational spans miss the two negative targets after all retained returns and all 76 one-axis queries. The spectral control passes. The actual large caller is outside this model. | [Preserved code and receipt](e-history/README.md). | + +## File and status decisions + +The local archive keeps superseded receipts as history. In particular, do +not use the earlier tensor bill before source binding, the rejected floating +repair candidates, or timed-out geometry searches as positive evidence. +The native-gauge and odd-E8 package drafts are superseded by their merged +PRs. Export-check scripts and publication drafts are verification records, +not new mathematical contributions. + +The primitive rank proof in the P112 support finding is inherited. The +new check binds its certificate to the literal source and the stated +puncture. Do not claim a new general parity-projector method. + +Border-product, spectral-renormalization, lattice-extension, bit-only +outer, and other unbuilt ideas were considered but not implemented. +They are not completed experiments. A future task must state a changed +premise and a complete cost test before expanding one of these routes. + +All scopes are released. No publication or packaging task is left open by +this record. The complete negative E decoder, caller pricing, and all-size +admission remain research obligations. Their absence is not evidence of a +universal obstruction. diff --git a/docs/research/handoffs/ali-romman-20261025/README.md b/docs/research/handoffs/ali-romman-20261025/README.md new file mode 100644 index 0000000000..fa2bee6685 --- /dev/null +++ b/docs/research/handoffs/ali-romman-20261025/README.md @@ -0,0 +1,139 @@ +# October 23–25 contribution handoff + +This record closes the publication work for two research sequences and the +later native-history and odd-E8 investigation. It preserves the result +links, stop decisions, and the last small retained-history test. + +No complete kappa increase was obtained in this investigation. At canonical +main `5e0052ca0aa3036a3afa8b0438927377c8d97d53`, the +[selected record](https://github.com/CrocSwap/integer-mult-bounds/blob/5e0052ca0aa3036a3afa8b0438927377c8d97d53/certificates/selected-result.json) +is `605457647/200000000000 = 0.003027288235`. Its five framework assumptions +remain. This handoff does not change that record or claim a new supplier. + +## Delivered results + +The [first sequence](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19148608) +contains ten results: one PR and nine self-contained Discussion proofs and +checks. The +[second sequence](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19151557) +contains ten results, six of which have focused PRs. Those indexes keep the +scope, proof, source credit, and verification limits of each result. A later +publication of the same result is not counted as another result. + +Three later PRs supply native-map cancellation, a same-paid native inverse, +and an odd-E8 decoder with a scoped lift obstruction. The following ten PRs +were merged by maintainers before this handoff. All ten final-head hosted +runs report success. No unresolved inline review thread was present at the +closeout check. + +| PR | Result | Exact package | Hosted check | +| --- | --- | --- | --- | +| [#5255](https://github.com/CrocSwap/integer-mult-bounds/pull/5255) | Sharp graph-support inverse norm | [Source](https://github.com/aliromman/integer-mult-bounds/tree/d63d8848442acc0bdc7b62578e12726c530af3fa/research/sharp-banded-resolvent) | [Success](https://github.com/CrocSwap/integer-mult-bounds/actions/runs/39968325269) | +| [#5321](https://github.com/CrocSwap/integer-mult-bounds/pull/5321) | Lower local inverse-code tape bound | [Source](https://github.com/aliromman/integer-mult-bounds/tree/85b70f45078dfa9dc1f865b0fd0c4e8055ddd540/research/factored-code-tape) | [Success](https://github.com/CrocSwap/integer-mult-bounds/actions/runs/39993985934) | +| [#5322](https://github.com/CrocSwap/integer-mult-bounds/pull/5322) | Inverse-pair error cancellation | [Source](https://github.com/aliromman/integer-mult-bounds/tree/38065821a76108dc512391b124ffb7b64feed93b/research/physical-pair-error-transfer) | [Success](https://github.com/CrocSwap/integer-mult-bounds/actions/runs/39998296588) | +| [#5323](https://github.com/CrocSwap/integer-mult-bounds/pull/5323) | Exact rounded-code recovery state | [Source](https://github.com/aliromman/integer-mult-bounds/tree/f9c722011c61779b1b79e9e38c0aa749b933000d/research/inverse-code-recovery-tags) | [Success](https://github.com/CrocSwap/integer-mult-bounds/actions/runs/39998305100) | +| [#5325](https://github.com/CrocSwap/integer-mult-bounds/pull/5325) | Restored Tensor error join | [Source](https://github.com/aliromman/integer-mult-bounds/tree/bea42af24ee9850949a4b48d329a7dc85de72b11/research/tensor-restored-error-join) | [Success](https://github.com/CrocSwap/integer-mult-bounds/actions/runs/39994953330) | +| [#5333](https://github.com/CrocSwap/integer-mult-bounds/pull/5333) | Full local residual budget | [Source](https://github.com/aliromman/integer-mult-bounds/tree/720b7ecc76b605e4a3f9b90826f2544c6ba9e59e/research/physical-pair-full-residuals) | [Success](https://github.com/CrocSwap/integer-mult-bounds/actions/runs/39996148971) | +| [#5341](https://github.com/CrocSwap/integer-mult-bounds/pull/5341) | Single crossing for fixed p16 partitions | [Source](https://github.com/aliromman/integer-mult-bounds/tree/b0edd31a04fe4705846df7673b4a0ec2442260d0/research/fragmentation-single-crossing) | [Success](https://github.com/CrocSwap/integer-mult-bounds/actions/runs/39997680141) | +| [#5403](https://github.com/CrocSwap/integer-mult-bounds/pull/5403) | Native-map and scalar cancellation | [Source](https://github.com/aliromman/integer-mult-bounds/tree/ff78b33a8c5327199af63325b0d4ee80c65b429d/research/native-gauge-cancellation) | [Success](https://github.com/CrocSwap/integer-mult-bounds/actions/runs/40034681556) | +| [#5411](https://github.com/CrocSwap/integer-mult-bounds/pull/5411) | Same-paid coupled native inverse | [Source](https://github.com/aliromman/integer-mult-bounds/tree/123ffa6aa7c1866ac60c67739841f71d95b3edf7/research/native-coupled-inverse) | [Success](https://github.com/CrocSwap/integer-mult-bounds/actions/runs/40044877623) | +| [#5439](https://github.com/CrocSwap/integer-mult-bounds/pull/5439) | Odd-E8 decoder and separated-lift bound | [Source](https://github.com/aliromman/integer-mult-bounds/tree/e6d50e7ebd0bb1fd4f388930df78df696e56b404/research/odd-e8-direct-sum) | [Success](https://github.com/CrocSwap/integer-mult-bounds/actions/runs/40105392037) | + +[RETENTION.json](RETENTION.json) records the exact heads, hosted run IDs, +and the 77 package files. Every file has the same Git blob at its submitted +head and at the canonical main commit above. The main ledger still marks +these packages as partially reviewed. Archive intake and CI success do not +establish scientific acceptance or a complete multiplication theorem. + +The separate [review of PR #5341](https://github.com/CrocSwap/integer-mult-bounds/pull/5341#issuecomment-6371583032) +reports an exact reproduction and proof check by James Reed, with Claude +Code assistance. Its scope clarification is now explicit in the PR body: +helper targets stay fixed; only their paid increments are partitioned. +No new validation claim is made by that wording change. + +## Research that stopped + +[EXPERIMENTS.md](EXPERIMENTS.md) records each tested family and the reason +to stop it. The broad negative screens remain exploratory. A time limit is +not an impossibility proof, and an abstract operator test is not a physical +lower bound. Public findings retain those distinctions. + +The last new test is retained in [e-history](e-history/README.md). It uses +the small four-input, four-axis fixture of the original 112-root E adapter. +It does not test the actual 112-cubed or 120-cubed caller. Exact rational +elimination rejects the two missing targets even after all 76 one-axis +queries on the retained values are granted together. A changed spectral +control recovers all four targets. These scripts and source bytes are +preserved to make that finite test inspectable; they do not justify a +separate supplier or kappa claim. + +At closeout, the exact history check and the spectral control were replayed +in normal and optimized CPython 3.12.13. All four runs passed. The scientific fields +match the saved receipt; elapsed time is excluded from that comparison. +No large caller, selected cold replay, compiler, outer admission, or formal +kernel was run for this handoff. No independent review of the last test is +claimed. [REPLAY.json](REPLAY.json) records the commands and results. + +## Current continuation point + +The original producer gap has advanced in related work. The merged +[PR #5464](https://github.com/CrocSwap/integer-mult-bounds/pull/5464), at +`d4b9151a160014370faeb7d080f87a06d88a1acb`, now contains full120 native K +and source-consuming E adapters as well as the retained112 construction. +Its +[current proof](https://github.com/thu-nmrc/integer-mult-bounds/blob/d4b9151a160014370faeb7d080f87a06d88a1acb/research/full120-e8-lowrank-e-native/author/PROOF.md) +and explicit invoice are the source for a new caller task. That work is +credited to THU New Media Research Center and its retained source authors; +it is not a result of this handoff. Its new package was not replayed here. + +The negative bank still has the coded endpoint +`Q^-1 E3 E2^-1 E1 D123`. Decoding only the positive bank does not supply +the missing negative Gaussian outputs. The merged +[PR #5508](https://github.com/CrocSwap/integer-mult-bounds/pull/5508), at +`7e6824d560337e2b2e49da8b98727183491f6ecf`, excludes the actual112-root +postdecoder from its stated columnwise ordinary algebra. Paid decoders, +correlated histories, and changed targets are outside that obstruction. +The retained small fixture does not extend it to the full caller. + +## Open next questions + +1. Construct a paid negative decoder, or change the caller and its target + inventory. Use the current full120 source and retain its exact order of + Q and E. First state the full optimistic bill. Continue only if the bill + can exceed the selected result. Then check every original return, + helper, adapter, idle, COPY/CLEAR, route, precision, and storage cost. +2. If using the old coupled provider, change the source or the caller + premise. The fixed-source guard and history tests below give specific + stop rules. They do not exclude all other protocols. +3. For a proof review of a delivered package, use its exact head and its + recorded open obligations. Do not treat an archival merge as an audit + of the full theorem. + +All reservations made by this investigation are released. Original claim +posts were updated as well as their completion replies. Dillon's +[answer to the control-definition request](https://github.com/CrocSwap/integer-mult-bounds/discussions/4930#discussioncomment-19161071) +is recorded as answered. No answer or reserved work is owed to this run. +These are continuation questions, not tasks assigned to another contributor. + +## Evidence retention and credit + +The complete local record contains the three original work directories, +their checkpoint notes, source inputs, scripts, receipts, failed attempts, +and publication checks. A file inventory and a verified archive preserve +them. A second pass through this run's tool history checked for missed +temporary inputs and claim posts. The local record is broader than this +public handoff. It does not certify every exploratory script or claim that +every search was rerun at closeout. + +Credit remains with the source authors named by each linked package and +finding. In particular, retain Cao Yifan's native word; Dillon's provider, +normalizers and clarification; Dugongue's geometry; the compiler and +precision lineage; the THU New Media Research Center E adapters; and the +attributed parity-projector result used in the fixed-pattern finding. +Mark's [separate product-plane reproduction](https://github.com/CrocSwap/integer-mult-bounds/discussions/1587#discussioncomment-19168830) +confirms the two factor tariffs. It also explains why rank alone gives no +tariff floor. Neither factor is claimed optimal. + +Prepared by Ali Romman with substantial OpenAI Codex assistance. No +subagents were used in this closeout. Apache-2.0. No other contributor's +PR was edited, merged, or closed by this closeout. diff --git a/docs/research/handoffs/ali-romman-20261025/REPLAY.json b/docs/research/handoffs/ali-romman-20261025/REPLAY.json new file mode 100644 index 0000000000..9dc38f4822 --- /dev/null +++ b/docs/research/handoffs/ali-romman-20261025/REPLAY.json @@ -0,0 +1,317 @@ +{ + "replay_python": "Python 3.12.13", + "runs": [ + { + "command": [ + "python3.12", + "-B", + "history_module.py", + "--exact" + ], + "exit_code": 0, + "scientific_result": { + "status": "EXACT_RATIONAL_HISTORY_SCREEN", + "prime": null, + "source_pr": 5464, + "source_head": "56ba6d7d609124d71c067d6a380caed573963f8f", + "source_program_sha256": "00470b4fc8804e944e6a6117e70bedff651ae61eb7db46539f156f38f47940c9", + "saved_rows": 19, + "max_row_terms": 12, + "results": [ + { + "translation_character_weight": 0, + "projected_rank": 456, + "target_in_span": [ + false, + false, + true, + true + ], + "residual_term_counts": [ + 1, + 1, + 0, + 0 + ], + "full_Gaussian_control_rank": 504, + "all_one_axis_query_rank": 1368, + "one_axis_plus_target_rank": 1416, + "one_axis_query_target_in_span": [ + false, + false, + true, + true + ] + }, + { + "translation_character_weight": 1, + "projected_rank": 456, + "target_in_span": [ + false, + false, + true, + true + ], + "residual_term_counts": [ + 1, + 1, + 0, + 0 + ], + "full_Gaussian_control_rank": 504, + "all_one_axis_query_rank": 1368, + "one_axis_plus_target_rank": 1416, + "one_axis_query_target_in_span": [ + false, + false, + true, + true + ] + }, + { + "translation_character_weight": 2, + "projected_rank": 456, + "target_in_span": [ + false, + false, + true, + true + ], + "residual_term_counts": [ + 1, + 1, + 0, + 0 + ], + "full_Gaussian_control_rank": 504, + "all_one_axis_query_rank": 1368, + "one_axis_plus_target_rank": 1416, + "one_axis_query_target_in_span": [ + false, + false, + true, + true + ] + }, + { + "translation_character_weight": 3, + "projected_rank": 456, + "target_in_span": [ + false, + false, + true, + true + ], + "residual_term_counts": [ + 1, + 1, + 0, + 0 + ], + "full_Gaussian_control_rank": 504, + "all_one_axis_query_rank": 1368, + "one_axis_plus_target_rank": 1416, + "one_axis_query_target_in_span": [ + false, + false, + true, + true + ] + }, + { + "translation_character_weight": 4, + "projected_rank": 456, + "target_in_span": [ + false, + false, + true, + true + ], + "residual_term_counts": [ + 1, + 1, + 0, + 0 + ], + "full_Gaussian_control_rank": 504, + "all_one_axis_query_rank": 1368, + "one_axis_plus_target_rank": 1416, + "one_axis_query_target_in_span": [ + false, + false, + true, + true + ] + } + ], + "scope": "Small four-axis, four-input fixture in the specified group algebra. Every paid result and original input is retained. The left ordinary alphabet is translations and axis permutations. No actual large E8 caller, general physical lower bound, paid improvement, or kappa claim." + } + }, + { + "command": [ + "python3.12", + "-B", + "verify_control.py" + ], + "exit_code": 0 + }, + { + "command": [ + "python3.12", + "-B", + "-O", + "history_module.py", + "--exact" + ], + "exit_code": 0, + "scientific_result": { + "status": "EXACT_RATIONAL_HISTORY_SCREEN", + "prime": null, + "source_pr": 5464, + "source_head": "56ba6d7d609124d71c067d6a380caed573963f8f", + "source_program_sha256": "00470b4fc8804e944e6a6117e70bedff651ae61eb7db46539f156f38f47940c9", + "saved_rows": 19, + "max_row_terms": 12, + "results": [ + { + "translation_character_weight": 0, + "projected_rank": 456, + "target_in_span": [ + false, + false, + true, + true + ], + "residual_term_counts": [ + 1, + 1, + 0, + 0 + ], + "full_Gaussian_control_rank": 504, + "all_one_axis_query_rank": 1368, + "one_axis_plus_target_rank": 1416, + "one_axis_query_target_in_span": [ + false, + false, + true, + true + ] + }, + { + "translation_character_weight": 1, + "projected_rank": 456, + "target_in_span": [ + false, + false, + true, + true + ], + "residual_term_counts": [ + 1, + 1, + 0, + 0 + ], + "full_Gaussian_control_rank": 504, + "all_one_axis_query_rank": 1368, + "one_axis_plus_target_rank": 1416, + "one_axis_query_target_in_span": [ + false, + false, + true, + true + ] + }, + { + "translation_character_weight": 2, + "projected_rank": 456, + "target_in_span": [ + false, + false, + true, + true + ], + "residual_term_counts": [ + 1, + 1, + 0, + 0 + ], + "full_Gaussian_control_rank": 504, + "all_one_axis_query_rank": 1368, + "one_axis_plus_target_rank": 1416, + "one_axis_query_target_in_span": [ + false, + false, + true, + true + ] + }, + { + "translation_character_weight": 3, + "projected_rank": 456, + "target_in_span": [ + false, + false, + true, + true + ], + "residual_term_counts": [ + 1, + 1, + 0, + 0 + ], + "full_Gaussian_control_rank": 504, + "all_one_axis_query_rank": 1368, + "one_axis_plus_target_rank": 1416, + "one_axis_query_target_in_span": [ + false, + false, + true, + true + ] + }, + { + "translation_character_weight": 4, + "projected_rank": 456, + "target_in_span": [ + false, + false, + true, + true + ], + "residual_term_counts": [ + 1, + 1, + 0, + 0 + ], + "full_Gaussian_control_rank": 504, + "all_one_axis_query_rank": 1368, + "one_axis_plus_target_rank": 1416, + "one_axis_query_target_in_span": [ + false, + false, + true, + true + ] + } + ], + "scope": "Small four-axis, four-input fixture in the specified group algebra. Every paid result and original input is retained. The left ordinary alphabet is translations and axis permutations. No actual large E8 caller, general physical lower bound, paid improvement, or kappa claim." + } + }, + { + "command": [ + "python3.12", + "-B", + "-O", + "verify_control.py" + ], + "exit_code": 0 + } + ], + "same_scientific_result": true, + "scope": "Exact finite group-algebra fixture only. No full physical caller or kappa claim." +} diff --git a/docs/research/handoffs/ali-romman-20261025/RETENTION.json b/docs/research/handoffs/ali-romman-20261025/RETENTION.json new file mode 100644 index 0000000000..dd1c220b4f --- /dev/null +++ b/docs/research/handoffs/ali-romman-20261025/RETENTION.json @@ -0,0 +1,678 @@ +{ + "canonical_main": "5e0052ca0aa3036a3afa8b0438927377c8d97d53", + "prs": [ + { + "pr": 5255, + "head": "d63d8848442acc0bdc7b62578e12726c530af3fa", + "files": [ + { + "path": "research/sharp-banded-resolvent/README.md", + "head_blob": "d68fc9625e7c74e7aacc8e684b5188be3300dd9e", + "main_blob": "d68fc9625e7c74e7aacc8e684b5188be3300dd9e", + "identical": true + }, + { + "path": "research/sharp-banded-resolvent/SOURCES.json", + "head_blob": "aaf6ad6c53ceb13c7e4ba528419fc0b4c030ff1f", + "main_blob": "aaf6ad6c53ceb13c7e4ba528419fc0b4c030ff1f", + "identical": true + }, + { + "path": "research/sharp-banded-resolvent/TASK.json", + "head_blob": "610798b702b4030476d3e02470f46381851e6197", + "main_blob": "610798b702b4030476d3e02470f46381851e6197", + "identical": true + }, + { + "path": "research/sharp-banded-resolvent/VERIFY.json", + "head_blob": "8f7973cbf94bc2a2eab66f931b982d92174f25ba", + "main_blob": "8f7973cbf94bc2a2eab66f931b982d92174f25ba", + "identical": true + }, + { + "path": "research/sharp-banded-resolvent/verify.py", + "head_blob": "44427db4065232757eac4d2498194aba5f085bd0", + "main_blob": "44427db4065232757eac4d2498194aba5f085bd0", + "identical": true + } + ], + "all_files_identical": true, + "state": "MERGED", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5255", + "title": "Prove the sharp graph-support inverse norm envelope", + "ci": { + "id": 39968325269, + "name": "Registered research packages", + "status": "completed", + "conclusion": "success", + "run_number": 4891, + "jobs_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/actions/runs/39968325269/jobs", + "logs_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/actions/runs/39968325269/logs", + "workflow_id": 383631011 + }, + "ledger_status": "partially reviewed" + }, + { + "pr": 5321, + "head": "85b70f45078dfa9dc1f865b0fd0c4e8055ddd540", + "files": [ + { + "path": "research/factored-code-tape/PROOF.md", + "head_blob": "79a66772cce2102223a46b688176b2f027c1d5d3", + "main_blob": "79a66772cce2102223a46b688176b2f027c1d5d3", + "identical": true + }, + { + "path": "research/factored-code-tape/README.md", + "head_blob": "88236f0065f97b2a6c87f73180f9fbe04611ff83", + "main_blob": "88236f0065f97b2a6c87f73180f9fbe04611ff83", + "identical": true + }, + { + "path": "research/factored-code-tape/RESULT.json", + "head_blob": "f68e178203711f11515a0b9a03af1624613f4b0c", + "main_blob": "f68e178203711f11515a0b9a03af1624613f4b0c", + "identical": true + }, + { + "path": "research/factored-code-tape/SOURCES.json", + "head_blob": "cc3f26413451d8c2ad6406d8becf28a83203636c", + "main_blob": "cc3f26413451d8c2ad6406d8becf28a83203636c", + "identical": true + }, + { + "path": "research/factored-code-tape/TASK.json", + "head_blob": "740ddce86dd931f6856ff89af6d7a19478558b43", + "main_blob": "740ddce86dd931f6856ff89af6d7a19478558b43", + "identical": true + }, + { + "path": "research/factored-code-tape/VERIFY.json", + "head_blob": "f6256936ef66e293731251d426ab15599c77b194", + "main_blob": "f6256936ef66e293731251d426ab15599c77b194", + "identical": true + }, + { + "path": "research/factored-code-tape/kernel.py", + "head_blob": "b88165f8bee88b8060e933bf6f4c70ffe8d7e7ba", + "main_blob": "b88165f8bee88b8060e933bf6f4c70ffe8d7e7ba", + "identical": true + }, + { + "path": "research/factored-code-tape/verify.py", + "head_blob": "84ad7d11d5cd8c26bb17b68e5937ad2a4e234a33", + "main_blob": "84ad7d11d5cd8c26bb17b68e5937ad2a4e234a33", + "identical": true + } + ], + "all_files_identical": true, + "state": "MERGED", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5321", + "title": "Lower inverse-code arithmetic to a smaller complete local tape bound", + "ci": { + "id": 39993985934, + "name": "Registered research packages", + "status": "completed", + "conclusion": "success", + "run_number": 4942, + "jobs_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/actions/runs/39993985934/jobs", + "logs_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/actions/runs/39993985934/logs", + "workflow_id": 383631011 + }, + "ledger_status": "partially reviewed" + }, + { + "pr": 5322, + "head": "38065821a76108dc512391b124ffb7b64feed93b", + "files": [ + { + "path": "research/physical-pair-error-transfer/PROOF.md", + "head_blob": "43d860fb44c3a53a39aa4360f93da018e891ba2b", + "main_blob": "43d860fb44c3a53a39aa4360f93da018e891ba2b", + "identical": true + }, + { + "path": "research/physical-pair-error-transfer/README.md", + "head_blob": "3edb3e5d0727aec2842ad07970d45fed985ee3ed", + "main_blob": "3edb3e5d0727aec2842ad07970d45fed985ee3ed", + "identical": true + }, + { + "path": "research/physical-pair-error-transfer/RESULT.json", + "head_blob": "30e6f3d5d2c470e45a94201750b0e152a92757d4", + "main_blob": "30e6f3d5d2c470e45a94201750b0e152a92757d4", + "identical": true + }, + { + "path": "research/physical-pair-error-transfer/SOURCES.json", + "head_blob": "b2d8227fe8efe6b326425407a1dc8a5e4a8cf3f9", + "main_blob": "b2d8227fe8efe6b326425407a1dc8a5e4a8cf3f9", + "identical": true + }, + { + "path": "research/physical-pair-error-transfer/TASK.json", + "head_blob": "ca37f2ba97eca13ba2a350d4d1e53fc94940e91e", + "main_blob": "ca37f2ba97eca13ba2a350d4d1e53fc94940e91e", + "identical": true + }, + { + "path": "research/physical-pair-error-transfer/VERIFY.json", + "head_blob": "f931f5e30bf8f5a2bb72d846592c590b188b6100", + "main_blob": "f931f5e30bf8f5a2bb72d846592c590b188b6100", + "identical": true + }, + { + "path": "research/physical-pair-error-transfer/verify.py", + "head_blob": "d0b287e9ff03f55b0abe2e74899473f88c92ffd1", + "main_blob": "d0b287e9ff03f55b0abe2e74899473f88c92ffd1", + "identical": true + } + ], + "all_files_identical": true, + "state": "MERGED", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5322", + "title": "Prove local inverse-pair error cancellation and a sharper precision guard", + "ci": { + "id": 39998296588, + "name": "Registered research packages", + "status": "completed", + "conclusion": "success", + "run_number": 4958, + "jobs_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/actions/runs/39998296588/jobs", + "logs_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/actions/runs/39998296588/logs", + "workflow_id": 383631011 + }, + "ledger_status": "partially reviewed" + }, + { + "pr": 5323, + "head": "f9c722011c61779b1b79e9e38c0aa749b933000d", + "files": [ + { + "path": "research/inverse-code-recovery-tags/PROOF.md", + "head_blob": "94dcc7307656ec1fee672187f5c97e4fbe9821dd", + "main_blob": "94dcc7307656ec1fee672187f5c97e4fbe9821dd", + "identical": true + }, + { + "path": "research/inverse-code-recovery-tags/README.md", + "head_blob": "a1f30694dd490009b60e1b0ad681f469594a4642", + "main_blob": "a1f30694dd490009b60e1b0ad681f469594a4642", + "identical": true + }, + { + "path": "research/inverse-code-recovery-tags/RESULT.json", + "head_blob": "d5b9f72aacc545b715043421d72d984a76b15ea8", + "main_blob": "d5b9f72aacc545b715043421d72d984a76b15ea8", + "identical": true + }, + { + "path": "research/inverse-code-recovery-tags/SOURCES.json", + "head_blob": "85c7845e4bbffa9b5bd44b03328cb39a584872cf", + "main_blob": "85c7845e4bbffa9b5bd44b03328cb39a584872cf", + "identical": true + }, + { + "path": "research/inverse-code-recovery-tags/TASK.json", + "head_blob": "ccebdb9564738592d9478212cdf6116627b1eecc", + "main_blob": "ccebdb9564738592d9478212cdf6116627b1eecc", + "identical": true + }, + { + "path": "research/inverse-code-recovery-tags/VERIFY.json", + "head_blob": "f21685796439126dfb1dcaf497b0757e218fe6f7", + "main_blob": "f21685796439126dfb1dcaf497b0757e218fe6f7", + "identical": true + }, + { + "path": "research/inverse-code-recovery-tags/verify.py", + "head_blob": "ee22e0bda75aafe475061f766a2d2e692eea43d3", + "main_blob": "ee22e0bda75aafe475061f766a2d2e692eea43d3", + "identical": true + } + ], + "all_files_identical": true, + "state": "MERGED", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5323", + "title": "Give the rounded inverse code exact recovery with a sharp state bound", + "ci": { + "id": 39998305100, + "name": "Registered research packages", + "status": "completed", + "conclusion": "success", + "run_number": 4959, + "jobs_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/actions/runs/39998305100/jobs", + "logs_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/actions/runs/39998305100/logs", + "workflow_id": 383631011 + }, + "ledger_status": "partially reviewed" + }, + { + "pr": 5325, + "head": "bea42af24ee9850949a4b48d329a7dc85de72b11", + "files": [ + { + "path": "research/tensor-restored-error-join/PROOF.md", + "head_blob": "ec7f5ab0c0ae7577faf6047d1791e7224822e99c", + "main_blob": "ec7f5ab0c0ae7577faf6047d1791e7224822e99c", + "identical": true + }, + { + "path": "research/tensor-restored-error-join/README.md", + "head_blob": "724e676a12344c37e229a2f52f993b9f6490ed5f", + "main_blob": "724e676a12344c37e229a2f52f993b9f6490ed5f", + "identical": true + }, + { + "path": "research/tensor-restored-error-join/RESULT.json", + "head_blob": "265af00e655d7fdf5753b9a42b713a6fc3af43f0", + "main_blob": "265af00e655d7fdf5753b9a42b713a6fc3af43f0", + "identical": true + }, + { + "path": "research/tensor-restored-error-join/SOURCES.json", + "head_blob": "5d533c0c5086131be6e7e20f4a0d4dfc7e67ee2b", + "main_blob": "5d533c0c5086131be6e7e20f4a0d4dfc7e67ee2b", + "identical": true + }, + { + "path": "research/tensor-restored-error-join/TASK.json", + "head_blob": "415b0d21ee7826710a32726541a80618ce387e25", + "main_blob": "415b0d21ee7826710a32726541a80618ce387e25", + "identical": true + }, + { + "path": "research/tensor-restored-error-join/VERIFY.json", + "head_blob": "1b4a7743a10d8d9f92eb8edf957a8f4f8b5d6a4c", + "main_blob": "1b4a7743a10d8d9f92eb8edf957a8f4f8b5d6a4c", + "identical": true + }, + { + "path": "research/tensor-restored-error-join/verify.py", + "head_blob": "98aeef42a3b57cc826da4d6fab8aab9aed28a5d0", + "main_blob": "98aeef42a3b57cc826da4d6fab8aab9aed28a5d0", + "identical": true + } + ], + "all_files_identical": true, + "state": "MERGED", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5325", + "title": "Join Tensor error bounds through compression and final restoration", + "ci": { + "id": 39994953330, + "name": "Registered research packages", + "status": "completed", + "conclusion": "success", + "run_number": 4946, + "jobs_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/actions/runs/39994953330/jobs", + "logs_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/actions/runs/39994953330/logs", + "workflow_id": 383631011 + }, + "ledger_status": "partially reviewed" + }, + { + "pr": 5333, + "head": "720b7ecc76b605e4a3f9b90826f2544c6ba9e59e", + "files": [ + { + "path": "research/physical-pair-full-residuals/PROOF.md", + "head_blob": "c53522e8d9867575e6a4b7735cb5dc182df1e0b5", + "main_blob": "c53522e8d9867575e6a4b7735cb5dc182df1e0b5", + "identical": true + }, + { + "path": "research/physical-pair-full-residuals/README.md", + "head_blob": "ac21b3115d54b7d3bd7e7c3171e26ba493590c7e", + "main_blob": "ac21b3115d54b7d3bd7e7c3171e26ba493590c7e", + "identical": true + }, + { + "path": "research/physical-pair-full-residuals/RESULT.json", + "head_blob": "3d51ca4c2ffeeef13161b3db774f8d1ef08398f8", + "main_blob": "3d51ca4c2ffeeef13161b3db774f8d1ef08398f8", + "identical": true + }, + { + "path": "research/physical-pair-full-residuals/SOURCES.json", + "head_blob": "220641f6daef85687d60a840c1da148ae67144f0", + "main_blob": "220641f6daef85687d60a840c1da148ae67144f0", + "identical": true + }, + { + "path": "research/physical-pair-full-residuals/TASK.json", + "head_blob": "143b04ba1c3c7ee59535b8065b248aef42792dfb", + "main_blob": "143b04ba1c3c7ee59535b8065b248aef42792dfb", + "identical": true + }, + { + "path": "research/physical-pair-full-residuals/VERIFY.json", + "head_blob": "214d7f0c73be9702d3a1a34a6f4c60ce9da12e57", + "main_blob": "214d7f0c73be9702d3a1a34a6f4c60ce9da12e57", + "identical": true + }, + { + "path": "research/physical-pair-full-residuals/verify.py", + "head_blob": "3eec4692da7b481b5d96a2ad911b9b3db1f70b3d", + "main_blob": "3eec4692da7b481b5d96a2ad911b9b3db1f70b3d", + "identical": true + } + ], + "all_files_identical": true, + "state": "MERGED", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5333", + "title": "Prove a complete local residual budget for the physical inverse pair", + "ci": { + "id": 39996148971, + "name": "Registered research packages", + "status": "completed", + "conclusion": "success", + "run_number": 4954, + "jobs_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/actions/runs/39996148971/jobs", + "logs_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/actions/runs/39996148971/logs", + "workflow_id": 383631011 + }, + "ledger_status": "partially reviewed" + }, + { + "pr": 5341, + "head": "b0edd31a04fe4705846df7673b4a0ec2442260d0", + "files": [ + { + "path": "research/fragmentation-single-crossing/PROOF.md", + "head_blob": "66a94145f59054f1367c7dba12fe8f2451a69ab3", + "main_blob": "66a94145f59054f1367c7dba12fe8f2451a69ab3", + "identical": true + }, + { + "path": "research/fragmentation-single-crossing/README.md", + "head_blob": "14fd108df4ff228d99d49554887ea6c51688b0e9", + "main_blob": "14fd108df4ff228d99d49554887ea6c51688b0e9", + "identical": true + }, + { + "path": "research/fragmentation-single-crossing/RESULT.json", + "head_blob": "ef0bd7e2a662557b36cbbb51e5b4ba2e58f153e5", + "main_blob": "ef0bd7e2a662557b36cbbb51e5b4ba2e58f153e5", + "identical": true + }, + { + "path": "research/fragmentation-single-crossing/SOURCES.json", + "head_blob": "356f733c18b58fec12761403297f46ddad1ce711", + "main_blob": "356f733c18b58fec12761403297f46ddad1ce711", + "identical": true + }, + { + "path": "research/fragmentation-single-crossing/TASK.json", + "head_blob": "09c7d17bf0b23be3a1bbbbe40367e9409152719f", + "main_blob": "09c7d17bf0b23be3a1bbbbe40367e9409152719f", + "identical": true + }, + { + "path": "research/fragmentation-single-crossing/VERIFY.json", + "head_blob": "1ef501481920ec7afc4c5ca72a6c210f69aa9dd4", + "main_blob": "1ef501481920ec7afc4c5ca72a6c210f69aa9dd4", + "identical": true + }, + { + "path": "research/fragmentation-single-crossing/verify.py", + "head_blob": "00dfd3fda94bf6873c58bbb66f9cdf4a2ff640fc", + "main_blob": "00dfd3fda94bf6873c58bbb66f9cdf4a2ff640fc", + "identical": true + } + ], + "all_files_identical": true, + "state": "MERGED", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5341", + "title": "Prove single crossing for every fixed p16 fragmentation invoice", + "ci": { + "id": 39997680141, + "name": "Registered research packages", + "status": "completed", + "conclusion": "success", + "run_number": 4957, + "jobs_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/actions/runs/39997680141/jobs", + "logs_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/actions/runs/39997680141/logs", + "workflow_id": 383631011 + }, + "ledger_status": "partially reviewed" + }, + { + "pr": 5403, + "head": "ff78b33a8c5327199af63325b0d4ee80c65b429d", + "files": [ + { + "path": "research/native-gauge-cancellation/PROOF.md", + "head_blob": "d4f84bb36cfc88a1383f0737aff3cf62a8f5ed23", + "main_blob": "d4f84bb36cfc88a1383f0737aff3cf62a8f5ed23", + "identical": true + }, + { + "path": "research/native-gauge-cancellation/README.md", + "head_blob": "476ca36f8bb55ca7bf87ab07292e0cf5a6f2a48f", + "main_blob": "476ca36f8bb55ca7bf87ab07292e0cf5a6f2a48f", + "identical": true + }, + { + "path": "research/native-gauge-cancellation/RESULT.json", + "head_blob": "e706000f908d8d3c10b1b12aae302cc8e9180724", + "main_blob": "e706000f908d8d3c10b1b12aae302cc8e9180724", + "identical": true + }, + { + "path": "research/native-gauge-cancellation/SOURCES.json", + "head_blob": "c88e24aef73b6f76db7b4b5d8e2ee3ed558f9511", + "main_blob": "c88e24aef73b6f76db7b4b5d8e2ee3ed558f9511", + "identical": true + }, + { + "path": "research/native-gauge-cancellation/TASK.json", + "head_blob": "90cfd4af1b8f9a25c7a51aec1028e89e7d700f06", + "main_blob": "90cfd4af1b8f9a25c7a51aec1028e89e7d700f06", + "identical": true + }, + { + "path": "research/native-gauge-cancellation/VALIDATION.md", + "head_blob": "0d6671ea6b2a1086b262905d65910fc329828a66", + "main_blob": "0d6671ea6b2a1086b262905d65910fc329828a66", + "identical": true + }, + { + "path": "research/native-gauge-cancellation/VERIFY.json", + "head_blob": "bd08601fbe603a9f6909162c1b59158c4e10652f", + "main_blob": "bd08601fbe603a9f6909162c1b59158c4e10652f", + "identical": true + }, + { + "path": "research/native-gauge-cancellation/construct.py", + "head_blob": "22cdf982b891e8b14c94b1d57d0089e9575f9ad0", + "main_blob": "22cdf982b891e8b14c94b1d57d0089e9575f9ad0", + "identical": true + }, + { + "path": "research/native-gauge-cancellation/verify.py", + "head_blob": "7e3b7be0f6bffe53d062a1bb580065495e216ca4", + "main_blob": "7e3b7be0f6bffe53d062a1bb580065495e216ca4", + "identical": true + } + ], + "all_files_identical": true, + "state": "MERGED", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5403", + "title": "Remove 60 native maps and 42 more ADDs after PR5350; kappa unchanged", + "ci": { + "id": 40034681556, + "name": "Registered research packages", + "status": "completed", + "conclusion": "success", + "run_number": 5029, + "jobs_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/actions/runs/40034681556/jobs", + "logs_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/actions/runs/40034681556/logs", + "workflow_id": 383631011 + }, + "ledger_status": "partially reviewed" + }, + { + "pr": 5411, + "head": "123ffa6aa7c1866ac60c67739841f71d95b3edf7", + "files": [ + { + "path": "research/native-coupled-inverse/ORIGINS.json", + "head_blob": "781095ae203a707cef737289850746ea7de8bc19", + "main_blob": "781095ae203a707cef737289850746ea7de8bc19", + "identical": true + }, + { + "path": "research/native-coupled-inverse/PROOF.md", + "head_blob": "1d524fb69dc8f254b8a1b6bec528a083470d2623", + "main_blob": "1d524fb69dc8f254b8a1b6bec528a083470d2623", + "identical": true + }, + { + "path": "research/native-coupled-inverse/README.md", + "head_blob": "ea6786053b7c0d6e0d8ea2f272f4a41bade19fb1", + "main_blob": "ea6786053b7c0d6e0d8ea2f272f4a41bade19fb1", + "identical": true + }, + { + "path": "research/native-coupled-inverse/RESULT.json", + "head_blob": "97da48b6626a8631c034eeacf37de4dfaeebe531", + "main_blob": "97da48b6626a8631c034eeacf37de4dfaeebe531", + "identical": true + }, + { + "path": "research/native-coupled-inverse/SOURCE.zip", + "head_blob": "3b54e49e0bbc988179363cfa63d5505705f5caed", + "main_blob": "3b54e49e0bbc988179363cfa63d5505705f5caed", + "identical": true + }, + { + "path": "research/native-coupled-inverse/SOURCES.json", + "head_blob": "dd77397ca519f0c15799b4f90a489af3d6a2cb0f", + "main_blob": "dd77397ca519f0c15799b4f90a489af3d6a2cb0f", + "identical": true + }, + { + "path": "research/native-coupled-inverse/TASK.json", + "head_blob": "46f72864eab579cb3ea5e0bc111f57f8ec7c84b1", + "main_blob": "46f72864eab579cb3ea5e0bc111f57f8ec7c84b1", + "identical": true + }, + { + "path": "research/native-coupled-inverse/VALIDATION.md", + "head_blob": "8eeb8158f54a3f9085a100c865b2035c7304d55c", + "main_blob": "8eeb8158f54a3f9085a100c865b2035c7304d55c", + "identical": true + }, + { + "path": "research/native-coupled-inverse/VERIFY.json", + "head_blob": "71d3718333172bc356c36ce0678c4e7fbda0713b", + "main_blob": "71d3718333172bc356c36ce0678c4e7fbda0713b", + "identical": true + }, + { + "path": "research/native-coupled-inverse/verify.py", + "head_blob": "8ffb2870daaeec5781b29c70f61c0d6e1e0c42ed", + "main_blob": "8ffb2870daaeec5781b29c70f61c0d6e1e0c42ed", + "identical": true + } + ], + "all_files_identical": true, + "state": "MERGED", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5411", + "title": "Construct the coupled native inverse without extra Gaussian calls", + "ci": { + "id": 40044877623, + "name": "Registered research packages", + "status": "completed", + "conclusion": "success", + "run_number": 5039, + "jobs_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/actions/runs/40044877623/jobs", + "logs_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/actions/runs/40044877623/logs", + "workflow_id": 383631011 + }, + "ledger_status": "partially reviewed" + }, + { + "pr": 5439, + "head": "e6d50e7ebd0bb1fd4f388930df78df696e56b404", + "files": [ + { + "path": "research/odd-e8-direct-sum/NATIVE-LIFT.json", + "head_blob": "b8d655ef235ddd5e502528d7c3a2a91dce998385", + "main_blob": "b8d655ef235ddd5e502528d7c3a2a91dce998385", + "identical": true + }, + { + "path": "research/odd-e8-direct-sum/NATIVE-LIFT.md", + "head_blob": "25a4b954c8e63bdee29a415667a47a45cf75412e", + "main_blob": "25a4b954c8e63bdee29a415667a47a45cf75412e", + "identical": true + }, + { + "path": "research/odd-e8-direct-sum/PROOF.md", + "head_blob": "041b6d365d34afb236a593966d90568651fb86c4", + "main_blob": "041b6d365d34afb236a593966d90568651fb86c4", + "identical": true + }, + { + "path": "research/odd-e8-direct-sum/README.md", + "head_blob": "aa81067fb72c6a6586b3f63b5577dfa0f6f5b5fd", + "main_blob": "aa81067fb72c6a6586b3f63b5577dfa0f6f5b5fd", + "identical": true + }, + { + "path": "research/odd-e8-direct-sum/RESULT.json", + "head_blob": "57d1807575c8d70cc9741ba41cf7bfc530b6df60", + "main_blob": "57d1807575c8d70cc9741ba41cf7bfc530b6df60", + "identical": true + }, + { + "path": "research/odd-e8-direct-sum/SOURCES.json", + "head_blob": "86da2378cf5c03b8c1a4d0eb179090a462a7db9a", + "main_blob": "86da2378cf5c03b8c1a4d0eb179090a462a7db9a", + "identical": true + }, + { + "path": "research/odd-e8-direct-sum/TASK.json", + "head_blob": "5ea937c660e88a7e726e0f664df7e4bab48efaf1", + "main_blob": "5ea937c660e88a7e726e0f664df7e4bab48efaf1", + "identical": true + }, + { + "path": "research/odd-e8-direct-sum/VERIFY.json", + "head_blob": "c45e3053511494710602c5b88180948f16d88a1a", + "main_blob": "c45e3053511494710602c5b88180948f16d88a1a", + "identical": true + }, + { + "path": "research/odd-e8-direct-sum/native_lift.py", + "head_blob": "a3eef985b5cf7753060df7b0232a2934beab129c", + "main_blob": "a3eef985b5cf7753060df7b0232a2934beab129c", + "identical": true + }, + { + "path": "research/odd-e8-direct-sum/verify.py", + "head_blob": "6033dd14834416ac80eb9260332abfd50810b155", + "main_blob": "6033dd14834416ac80eb9260332abfd50810b155", + "identical": true + } + ], + "all_files_identical": true, + "state": "MERGED", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/5439", + "title": "Construct an odd E8 decoder and bound separated native lifts (no new \u03ba)", + "ci": { + "id": 40105392037, + "name": "Registered research packages", + "status": "completed", + "conclusion": "success", + "run_number": 5083, + "jobs_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/actions/runs/40105392037/jobs", + "logs_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/actions/runs/40105392037/logs", + "workflow_id": 383631011 + }, + "ledger_status": "partially reviewed" + } + ], + "all_files_identical": true +} diff --git a/docs/research/handoffs/ali-romman-20261025/e-history/N3-PROGRAM.json b/docs/research/handoffs/ali-romman-20261025/e-history/N3-PROGRAM.json new file mode 100644 index 0000000000..757fe38c7d --- /dev/null +++ b/docs/research/handoffs/ali-romman-20261025/e-history/N3-PROGRAM.json @@ -0,0 +1,986 @@ +[ + [ + "MONO", + "X0", + "X1_1" + ], + [ + "MONO", + "X1", + "X1_1" + ], + [ + "OWN_ZERO", + "s1_cache1" + ], + [ + "OWN_ZERO", + "s1_cache0" + ], + [ + "MONO", + "X1", + "X1_1" + ], + [ + "MONO", + "X0", + "X1_1" + ], + [ + "ADD", + "s1_cache0", + "X1", + 1, + 1, + "P1" + ], + [ + "ADD", + "s1_cache1", + "X0", + 1, + 1, + "P1" + ], + [ + "PAID", + "X1", + "C11", + 1 + ], + [ + "PAID", + "X0", + "C11", + 1 + ], + [ + "MONO", + "X1", + "X3_1" + ], + [ + "MONO", + "X0", + "X3_1" + ], + [ + "OWN_ZERO", + "s1_inverse_mode_g" + ], + [ + "ADD", + "s1_inverse_mode_g", + "X1", + -49, + 1, + "P1" + ], + [ + "ADD", + "s1_inverse_mode_g", + "X0", + 49, + 1, + "I1" + ], + [ + "PAID", + "s1_inverse_mode_g", + "R1", + 2 + ], + [ + "ADD", + "Y1", + "s1_inverse_mode_g", + -1, + 1, + "P1" + ], + [ + "ADD", + "Y0", + "s1_inverse_mode_g", + 1, + 1, + "I1" + ], + [ + "CLEAR", + "s1_inverse_mode_g" + ], + [ + "OWN_ZERO", + "s1_iyb" + ], + [ + "OWN_ZERO", + "s1_iya" + ], + [ + "ADD", + "s1_iya", + "Y1", + 48, + 97, + "P1" + ], + [ + "ADD", + "s1_iyb", + "Y0", + 48, + 97, + "P1" + ], + [ + "SCALE", + "Y1", + 49, + 97 + ], + [ + "SCALE", + "Y0", + 49, + 97 + ], + [ + "ADD", + "Y1", + "s1_iyb", + 1, + 1, + "I1" + ], + [ + "CLEAR", + "s1_iyb" + ], + [ + "ADD", + "Y0", + "s1_iya", + 1, + 1, + "I1" + ], + [ + "CLEAR", + "s1_iya" + ], + [ + "PAID", + "Y1", + "C11", + 1 + ], + [ + "PAID", + "Y0", + "C11", + 1 + ], + [ + "ADD", + "Y1", + "s1_cache1", + 1, + 1, + "I1" + ], + [ + "CLEAR", + "s1_cache1" + ], + [ + "ADD", + "Y0", + "s1_cache0", + 1, + 1, + "I1" + ], + [ + "CLEAR", + "s1_cache0" + ], + [ + "MONO", + "Y1", + "X2_1" + ], + [ + "MONO", + "Y0", + "X2_1" + ], + [ + "OWN_ZERO", + "s1_ixb" + ], + [ + "OWN_ZERO", + "s1_ixa" + ], + [ + "ADD", + "s1_ixa", + "X1", + 48, + 97, + "P1" + ], + [ + "ADD", + "s1_ixb", + "X0", + 48, + 97, + "P1" + ], + [ + "SCALE", + "X1", + 49, + 97 + ], + [ + "SCALE", + "X0", + 49, + 97 + ], + [ + "ADD", + "X1", + "s1_ixb", + 1, + 1, + "I1" + ], + [ + "CLEAR", + "s1_ixb" + ], + [ + "ADD", + "X0", + "s1_ixa", + 1, + 1, + "I1" + ], + [ + "CLEAR", + "s1_ixa" + ], + [ + "MONO", + "X0", + "X3_1" + ], + [ + "MONO", + "X1", + "X3_1" + ], + [ + "MONO", + "Y0", + "X2_1" + ], + [ + "MONO", + "Y1", + "X2_1" + ], + [ + "OWN_ZERO", + "s2_back_mode_g" + ], + [ + "ADD", + "s2_back_mode_g", + "Y0", + 1, + 1, + "I2" + ], + [ + "ADD", + "s2_back_mode_g", + "Y1", + -1, + 1, + "P2" + ], + [ + "PAID", + "s2_back_mode_g", + "R2", + 2 + ], + [ + "COPY", + "s2_bya", + "Y0" + ], + [ + "COPY", + "s2_byb", + "Y1" + ], + [ + "SCALE", + "Y0", + 49, + 1 + ], + [ + "SCALE", + "Y1", + 49, + 1 + ], + [ + "ADD", + "Y0", + "s2_byb", + -48, + 1, + "P2" + ], + [ + "ADD", + "Y1", + "s2_bya", + -48, + 1, + "P2" + ], + [ + "CLEAR", + "s2_bya" + ], + [ + "CLEAR", + "s2_byb" + ], + [ + "MONO", + "X0", + "X1_2" + ], + [ + "MONO", + "X1", + "X1_2" + ], + [ + "PAID", + "Y0", + "C12", + 1 + ], + [ + "MONO", + "Y0", + "X2_2" + ], + [ + "PAID", + "Y1", + "C12", + 1 + ], + [ + "MONO", + "Y1", + "X2_2" + ], + [ + "ADD", + "X0", + "Y1", + -1, + 1, + "P2" + ], + [ + "ADD", + "X1", + "Y0", + -1, + 1, + "P2" + ], + [ + "PAID", + "X0", + "C12", + 1 + ], + [ + "MONO", + "X0", + "X2_2" + ], + [ + "PAID", + "X1", + "C12", + 1 + ], + [ + "MONO", + "X1", + "X2_2" + ], + [ + "MONO", + "X0", + "X3_2" + ], + [ + "MONO", + "X1", + "X3_2" + ], + [ + "MONO", + "Y0", + "X2_2" + ], + [ + "MONO", + "Y1", + "X2_2" + ], + [ + "ADD", + "X0", + "s2_back_mode_g", + -49, + 1, + "I2" + ], + [ + "ADD", + "X1", + "s2_back_mode_g", + 49, + 1, + "P2" + ], + [ + "COPY", + "s2_bxa", + "X0" + ], + [ + "COPY", + "s2_bxb", + "X1" + ], + [ + "SCALE", + "X0", + 49, + 1 + ], + [ + "SCALE", + "X1", + 49, + 1 + ], + [ + "ADD", + "X0", + "s2_bxb", + -48, + 1, + "P2" + ], + [ + "ADD", + "X1", + "s2_bxa", + -48, + 1, + "P2" + ], + [ + "CLEAR", + "s2_bxa" + ], + [ + "CLEAR", + "s2_bxb" + ], + [ + "CLEAR", + "s2_back_mode_g" + ], + [ + "MONO", + "X0", + "X1_3" + ], + [ + "MONO", + "X1", + "X1_3" + ], + [ + "OWN_ZERO", + "s3_cache1" + ], + [ + "OWN_ZERO", + "s3_cache0" + ], + [ + "MONO", + "X1", + "X1_3" + ], + [ + "MONO", + "X0", + "X1_3" + ], + [ + "ADD", + "s3_cache0", + "X1", + 1, + 1, + "P3" + ], + [ + "ADD", + "s3_cache1", + "X0", + 1, + 1, + "P3" + ], + [ + "PAID", + "X1", + "C13", + 1 + ], + [ + "PAID", + "X0", + "C13", + 1 + ], + [ + "MONO", + "X1", + "X3_3" + ], + [ + "MONO", + "X0", + "X3_3" + ], + [ + "OWN_ZERO", + "s3_inverse_mode_g" + ], + [ + "ADD", + "s3_inverse_mode_g", + "X1", + -49, + 1, + "P3" + ], + [ + "ADD", + "s3_inverse_mode_g", + "X0", + 49, + 1, + "I3" + ], + [ + "PAID", + "s3_inverse_mode_g", + "R3", + 2 + ], + [ + "ADD", + "Y1", + "s3_inverse_mode_g", + -1, + 1, + "P3" + ], + [ + "ADD", + "Y0", + "s3_inverse_mode_g", + 1, + 1, + "I3" + ], + [ + "CLEAR", + "s3_inverse_mode_g" + ], + [ + "OWN_ZERO", + "s3_iyb" + ], + [ + "OWN_ZERO", + "s3_iya" + ], + [ + "ADD", + "s3_iya", + "Y1", + 48, + 97, + "P3" + ], + [ + "ADD", + "s3_iyb", + "Y0", + 48, + 97, + "P3" + ], + [ + "SCALE", + "Y1", + 49, + 97 + ], + [ + "SCALE", + "Y0", + 49, + 97 + ], + [ + "ADD", + "Y1", + "s3_iyb", + 1, + 1, + "I3" + ], + [ + "CLEAR", + "s3_iyb" + ], + [ + "ADD", + "Y0", + "s3_iya", + 1, + 1, + "I3" + ], + [ + "CLEAR", + "s3_iya" + ], + [ + "PAID", + "Y1", + "C13", + 1 + ], + [ + "PAID", + "Y0", + "C13", + 1 + ], + [ + "ADD", + "Y1", + "s3_cache1", + 1, + 1, + "I3" + ], + [ + "CLEAR", + "s3_cache1" + ], + [ + "ADD", + "Y0", + "s3_cache0", + 1, + 1, + "I3" + ], + [ + "CLEAR", + "s3_cache0" + ], + [ + "MONO", + "Y1", + "X2_3" + ], + [ + "MONO", + "Y0", + "X2_3" + ], + [ + "OWN_ZERO", + "s3_ixb" + ], + [ + "OWN_ZERO", + "s3_ixa" + ], + [ + "ADD", + "s3_ixa", + "X1", + 48, + 97, + "P3" + ], + [ + "ADD", + "s3_ixb", + "X0", + 48, + 97, + "P3" + ], + [ + "SCALE", + "X1", + 49, + 97 + ], + [ + "SCALE", + "X0", + 49, + 97 + ], + [ + "ADD", + "X1", + "s3_ixb", + 1, + 1, + "I3" + ], + [ + "CLEAR", + "s3_ixb" + ], + [ + "ADD", + "X0", + "s3_ixa", + 1, + 1, + "I3" + ], + [ + "CLEAR", + "s3_ixa" + ], + [ + "MONO", + "X0", + "X3_3" + ], + [ + "MONO", + "X1", + "X3_3" + ], + [ + "MONO", + "Y0", + "X2_3" + ], + [ + "MONO", + "Y1", + "X2_3" + ], + [ + "SWAP", + "X0", + "Y0" + ], + [ + "SWAP", + "X1", + "Y1" + ], + [ + "SCALE", + "Y0", + -1, + 1 + ], + [ + "SCALE", + "Y1", + -1, + 1 + ], + [ + "COPY", + "exit3_exita", + "Y0" + ], + [ + "COPY", + "exit3_exitb", + "Y1" + ], + [ + "SCALE", + "Y0", + 49, + 1 + ], + [ + "SCALE", + "Y1", + 49, + 1 + ], + [ + "ADD", + "Y0", + "exit3_exitb", + -48, + 1, + "P3" + ], + [ + "ADD", + "Y1", + "exit3_exita", + -48, + 1, + "P3" + ], + [ + "CLEAR", + "exit3_exita" + ], + [ + "CLEAR", + "exit3_exitb" + ], + [ + "COPY", + "exit2_exita", + "Y0" + ], + [ + "COPY", + "exit2_exitb", + "Y1" + ], + [ + "SCALE", + "Y0", + 49, + 97 + ], + [ + "SCALE", + "Y1", + 49, + 97 + ], + [ + "ADD", + "Y0", + "exit2_exitb", + 48, + 97, + "P2" + ], + [ + "ADD", + "Y1", + "exit2_exita", + 48, + 97, + "P2" + ], + [ + "CLEAR", + "exit2_exita" + ], + [ + "CLEAR", + "exit2_exitb" + ], + [ + "COPY", + "exit1_exita", + "Y0" + ], + [ + "COPY", + "exit1_exitb", + "Y1" + ], + [ + "SCALE", + "Y0", + 49, + 1 + ], + [ + "SCALE", + "Y1", + 49, + 1 + ], + [ + "ADD", + "Y0", + "exit1_exitb", + -48, + 1, + "P1" + ], + [ + "ADD", + "Y1", + "exit1_exita", + -48, + 1, + "P1" + ], + [ + "CLEAR", + "exit1_exita" + ], + [ + "CLEAR", + "exit1_exitb" + ] +] diff --git a/docs/research/handoffs/ali-romman-20261025/e-history/README.md b/docs/research/handoffs/ali-romman-20261025/e-history/README.md new file mode 100644 index 0000000000..4af9b20062 --- /dev/null +++ b/docs/research/handoffs/ali-romman-20261025/e-history/README.md @@ -0,0 +1,84 @@ +# Retained-value test for the small odd-E8 E caller + +This archived investigation did not produce a supplier or a kappa increase. +It tests the four-input, four-axis fixture from THU New Media Research +Center's [PR #5464](https://github.com/CrocSwap/integer-mult-bounds/pull/5464). +The actual 1,404,928-port caller is outside this test. + +The input is the unchanged +[N3 program](https://github.com/thu-nmrc/integer-mult-bounds/blob/56ba6d7d609124d71c067d6a380caed573963f8f/research/odd-e8-lowrank-e-native/N3-PROGRAM.json). +Its Git blob is `757fe38c7de18c137be95e0d8e4f7c53e0b5d443`. +Its SHA256 is +`00470b4fc8804e944e6a6117e70bedff651ae61eb7db46539f156f38f47940c9`. +Retain the source's Apache-2.0 license and attribution. The new local +scripts were prepared by Ali Romman with substantial OpenAI Codex assistance. + +## Question and result + +Can retained paid values complete the missing negative output bank? +The experiment retains all four original inputs and all fifteen paid +results. It allows arbitrary rational linear combinations of their +ordinary translations and axis permutations. + +Use the exact group algebra of `(Z/4Z)^4 semidirect S4`. A group element +has the form `C^e P`, where each coordinate Gaussian has order four. +The ordinary subgroup is `(2Z/4Z)^4 semidirect S4`. Each stored row has +four independent original-input columns. Projection onto a translation +character gives a necessary span test. We check five fixed characters: +the first zero, one, two, three or four coordinate bits are set. Failure +at any one character suffices to reject membership in the full module. +We do not need to assert that these five tests cover every character. +No one-column numerical relation between Gaussian operators is used. + +Exact rational elimination gives the same ranks in all five cases: + +| Allowed values | Rank | Rank after adding both missing target orbits | +| --- | ---: | ---: | +| All retained inputs and paid returns | 456 | 504 | +| These values and every one-axis query on them | 1368 | 1416 | + +Both already decoded positive targets belong to each retained span. +Neither negative target belongs to either span. The second test grants +all 76 source/coordinate query choices at once. It is more permissive +than selecting one or two such queries. + +A separate modular screen at prime 65521 checks all 76 individual query +choices and all 2,850 distinct pairs. None gives the missing targets. +The exact rational span test is the stronger evidence for this alphabet. + +The control sets the small fixture's spectral parameter to two. Then +`C=2P_minus` and `E=I`, and all four Gaussian targets are recovered. +The literal source blob is checked before this control. In the actual +large construction, the nonzero C modes do not fill the K-minus +eigenspace. The control therefore does not give a large-caller repair. + +## Reproduce + +Run from this directory with Python 3.12 or later: + +```sh +python3 -B history_module.py --exact +python3 -O -B history_module.py --exact +python3 -B paid_return_screen.py +python3 -B verify_control.py +``` + +The first two commands write `history_module_exact.json`. The third writes +`paid_return_screen.json`. The control checks `control-lambda2.json` without +changing it. Normal and optimized exact runs have the same scientific +fields; elapsed time can differ. + +## Limits and next decision + +This is an exact result in the stated finite group algebra for the small +published fixture. It is not a general physical lower bound, an audit of +the complete source package, or a proof about all native query alphabets. +It does not exclude nonlinear use of history, changed native words, +other paid services, or a different caller. A full tensor-width separation +proof was not added. The selected supplier, compiler and outer admission +were not rerun. + +Stop this fixed-fixture, one-layer, coordinate-query search. A further +construction must change that premise and state its complete cost. The +current selected kappa remains `0.003027288235`. This local test alone does not justify a new supplier claim. The present +handoff preserves its source and limits. diff --git a/docs/research/handoffs/ali-romman-20261025/e-history/control-lambda2.json b/docs/research/handoffs/ali-romman-20261025/e-history/control-lambda2.json new file mode 100644 index 0000000000..218c5260c4 --- /dev/null +++ b/docs/research/handoffs/ali-romman-20261025/e-history/control-lambda2.json @@ -0,0 +1,58 @@ +{ + "status": "PASS_EXACT_CONTROL_AT_LAMBDA_2", + "coefficient_changes": 42, + "reason": "In this small fixture C=2P_minus and E=K(I-C)^-1=I.", + "cases": [ + { + "weight": 0, + "rank": 456, + "targets": [ + true, + true, + true, + true + ] + }, + { + "weight": 1, + "rank": 456, + "targets": [ + true, + true, + true, + true + ] + }, + { + "weight": 2, + "rank": 456, + "targets": [ + true, + true, + true, + true + ] + }, + { + "weight": 3, + "rank": 456, + "targets": [ + true, + true, + true, + true + ] + }, + { + "weight": 4, + "rank": 456, + "targets": [ + true, + true, + true, + true + ] + } + ], + "scope": "Control only. The actual global C modes do not cover the full K-minus eigenspace, so this is not a global repair." +} diff --git a/docs/research/handoffs/ali-romman-20261025/e-history/history_module.py b/docs/research/handoffs/ali-romman-20261025/e-history/history_module.py new file mode 100644 index 0000000000..63f6c4f3d6 --- /dev/null +++ b/docs/research/handoffs/ali-romman-20261025/e-history/history_module.py @@ -0,0 +1,219 @@ +"""Screen retained paid values in the published small E caller. + +This uses the group algebra of four coordinate Gaussians and axis +permutations. It does not replace the actual 112^3-owner native word. +""" +import hashlib +import argparse +import itertools +import json +import time +from fractions import Fraction +from pathlib import Path + +HERE = Path(__file__).resolve().parent +MOD = 65521 +PERMS = list(itertools.permutations(range(4))) +PID = {p: i for i, p in enumerate(PERMS)} +ID = PID[(0, 1, 2, 3)] +COMPOSE = [[PID[tuple(a[b[k]] for k in range(4))] for b in PERMS] + for a in PERMS] + + +def scalar(num, den=1): + return num*pow(den, -1, MOD) % MOD if MOD else Fraction(num, den) + + +def norm(value): + return value % MOD if MOD else value + + +def move(e, p): + out = 0 + for i in range(4): + out |= ((e >> (2*i)) & 3) << (2*p[i]) + return out + + +MOVED = [[move(e, p) for e in range(256)] for p in PERMS] + + +def plus_exp(a, b): + return sum((((a >> (2*i)) + (b >> (2*i))) & 3) << (2*i) + for i in range(4)) + + +def atom(src, e, p): + return (src*256+e)*24+p + + +def unpack(k): + q, p = divmod(k, 24) + src, e = divmod(q, 256) + return src, e, p + + +def left(row, e, p): + out = {} + for k, c in row.items(): + src, f, q = unpack(k) + z = atom(src, plus_exp(e, MOVED[p][f]), COMPOSE[p][q]) + out[z] = norm(out.get(z, 0)+c) + return {k: c for k, c in out.items() if c} + + +def linear(a, b, c): + out = dict(a) + for k, v in b.items(): + out[k] = norm(out.get(k, 0)+c*v) + if not out[k]: + del out[k] + return out + + +def operator(name): + if name.startswith('X'): + q, s = map(int, name[1:].split('_')) + return 2*((q & 1) | ((q >> 1) << (2*s))), ID + if name.startswith('P'): + s = int(name[1:]); p = list(range(4)); p[0], p[s] = p[s], p[0] + return 0, PID[tuple(p)] + if name.startswith('C0'): + return 1, ID + if name.startswith('C1'): + return 1 << (2*int(name[2:])), ID + if name.startswith('R'): + return 1+(1 << (2*int(name[1:]))), ID + if name.startswith('I'): + return 0, ID + raise ValueError(name) + + +def source(program=None): + data = (HERE/'N3-PROGRAM.json').read_bytes() if program is None else json.dumps(program).encode() + program = json.loads(data) + fields = ['X0', 'X1', 'Y0', 'Y1'] + vals = {f: {atom(i, 0, ID): 1} for i, f in enumerate(fields)} + history = [('input_'+f, vals[f]) for f in fields] + for j, e in enumerate(program): + op = e[0] + if op == 'OWN_ZERO': + vals[e[1]] = {} + elif op == 'COPY': + vals[e[1]] = dict(vals[e[2]]) + elif op == 'CLEAR': + vals[e[1]] = {} + elif op == 'SWAP': + vals[e[1]], vals[e[2]] = vals[e[2]], vals[e[1]] + elif op == 'SCALE': + c = scalar(e[2], e[3]) + vals[e[1]] = {k: norm(v*c) for k, v in vals[e[1]].items() if norm(v*c)} + elif op == 'ADD': + c = scalar(e[3], e[4]) + vals[e[1]] = linear(vals[e[1]], left(vals[e[2]], *operator(e[5])), c) + else: + assert op in ('PAID', 'MONO') + vals[e[1]] = left(vals[e[1]], *operator(e[2])) + if op == 'PAID': + history.append((f'paid_{j}_{e[1]}_{e[2]}', dict(vals[e[1]]))) + targets = [{atom(src, 85, ID): 1} for src in range(4)] + for src, f in enumerate(fields[2:], start=2): + if vals[f] != targets[src]: + raise ValueError('The positive endpoint does not replay in the group algebra') + return history, targets, hashlib.sha256(data).hexdigest() + + +def project(row, chi, perm): + out = {} + for k, v in row.items(): + src, e, p = unpack(k) + e = MOVED[perm][e] + r = sum(((e >> (2*i)) & 1) << i for i in range(4)) + t = sum(((e >> (2*i+1)) & 1) << i for i in range(4)) + z = (src*16+r)*24+COMPOSE[perm][p] + if (chi & t).bit_count() % 2: + v = -v + out[z] = norm(out.get(z, 0)+v) + return {k: v for k, v in out.items() if v} + + +def insert(row, pivots): + row = dict(row) + while row: + k = min(row) + if k not in pivots: + inv = pow(row[k], -1, MOD) if MOD else Fraction(1)/row[k] + pivots[k] = {j: norm(v*inv) for j, v in row.items()} + return True + row = linear(row, pivots[k], -row[k]) + return False + + +def residue(row, pivots): + row = dict(row) + while row: + k = min(row) + if k not in pivots: + break + row = linear(row, pivots[k], -row[k]) + return row + + +def main(): + global MOD + ap = argparse.ArgumentParser() + ap.add_argument('--exact', action='store_true') + args = ap.parse_args() + if args.exact: + MOD = None + start = time.monotonic() + history, targets, sha = source() + results = [] + for weight in range(5): + chi = (1 << weight)-1 + pivots = {} + for name, row in history: + for p in range(24): + insert(project(row, chi, p), pivots) + residuals = [residue(project(t, chi, ID), pivots) for t in targets] + if any(residuals[2:]): + raise ValueError('The already decoded positive targets must be in the history module') + control = dict(pivots) + for t in targets[:2]: + for p in range(24): + insert(project(t, chi, p), control) + if any(residue(project(t, chi, ID), control) for t in targets): + raise ValueError('The added full-Gaussian positive control failed') + one_axis = dict(pivots) + for name, row in history: + for axis in range(4): + query = left(row, 1 << (2*axis), ID) + for p in range(24): + insert(project(query, chi, p), one_axis) + one_axis_targets = dict(one_axis) + for t in targets[:2]: + for p in range(24): + insert(project(t, chi, p), one_axis_targets) + rec = {'translation_character_weight': weight, 'projected_rank': len(pivots), + 'target_in_span': [not r for r in residuals], + 'residual_term_counts': list(map(len, residuals)), + 'full_Gaussian_control_rank': len(control), + 'all_one_axis_query_rank': len(one_axis), + 'one_axis_plus_target_rank': len(one_axis_targets), + 'one_axis_query_target_in_span': [not residue(project(t, chi, ID), one_axis) + for t in targets]} + results.append(rec) + print(json.dumps(rec), flush=True) + result = {'status': 'EXACT_RATIONAL_HISTORY_SCREEN' if args.exact else 'MODULAR_HISTORY_SCREEN', 'prime': MOD, + 'source_pr': 5464, 'source_head': '56ba6d7d609124d71c067d6a380caed573963f8f', + 'source_program_sha256': sha, 'saved_rows': len(history), + 'max_row_terms': max(map(lambda x: len(x[1]), history)), + 'results': results, 'seconds': time.monotonic()-start, + 'scope': 'Small four-axis, four-input fixture in the specified group algebra. Every paid result and original input is retained. The left ordinary alphabet is translations and axis permutations. No actual large E8 caller, general physical lower bound, paid improvement, or kappa claim.'} + name = 'history_module_exact.json' if args.exact else 'history_module.json' + (HERE/name).write_text(json.dumps(result, indent=2)+'\n') + print(json.dumps({k: v for k, v in result.items() if k != 'results'}), flush=True) + + +if __name__ == '__main__': + main() diff --git a/docs/research/handoffs/ali-romman-20261025/e-history/history_module_exact.json b/docs/research/handoffs/ali-romman-20261025/e-history/history_module_exact.json new file mode 100644 index 0000000000..f3613b4227 --- /dev/null +++ b/docs/research/handoffs/ali-romman-20261025/e-history/history_module_exact.json @@ -0,0 +1,138 @@ +{ + "status": "EXACT_RATIONAL_HISTORY_SCREEN", + "prime": null, + "source_pr": 5464, + "source_head": "56ba6d7d609124d71c067d6a380caed573963f8f", + "source_program_sha256": "00470b4fc8804e944e6a6117e70bedff651ae61eb7db46539f156f38f47940c9", + "saved_rows": 19, + "max_row_terms": 12, + "results": [ + { + "translation_character_weight": 0, + "projected_rank": 456, + "target_in_span": [ + false, + false, + true, + true + ], + "residual_term_counts": [ + 1, + 1, + 0, + 0 + ], + "full_Gaussian_control_rank": 504, + "all_one_axis_query_rank": 1368, + "one_axis_plus_target_rank": 1416, + "one_axis_query_target_in_span": [ + false, + false, + true, + true + ] + }, + { + "translation_character_weight": 1, + "projected_rank": 456, + "target_in_span": [ + false, + false, + true, + true + ], + "residual_term_counts": [ + 1, + 1, + 0, + 0 + ], + "full_Gaussian_control_rank": 504, + "all_one_axis_query_rank": 1368, + "one_axis_plus_target_rank": 1416, + "one_axis_query_target_in_span": [ + false, + false, + true, + true + ] + }, + { + "translation_character_weight": 2, + "projected_rank": 456, + "target_in_span": [ + false, + false, + true, + true + ], + "residual_term_counts": [ + 1, + 1, + 0, + 0 + ], + "full_Gaussian_control_rank": 504, + "all_one_axis_query_rank": 1368, + "one_axis_plus_target_rank": 1416, + "one_axis_query_target_in_span": [ + false, + false, + true, + true + ] + }, + { + "translation_character_weight": 3, + "projected_rank": 456, + "target_in_span": [ + false, + false, + true, + true + ], + "residual_term_counts": [ + 1, + 1, + 0, + 0 + ], + "full_Gaussian_control_rank": 504, + "all_one_axis_query_rank": 1368, + "one_axis_plus_target_rank": 1416, + "one_axis_query_target_in_span": [ + false, + false, + true, + true + ] + }, + { + "translation_character_weight": 4, + "projected_rank": 456, + "target_in_span": [ + false, + false, + true, + true + ], + "residual_term_counts": [ + 1, + 1, + 0, + 0 + ], + "full_Gaussian_control_rank": 504, + "all_one_axis_query_rank": 1368, + "one_axis_plus_target_rank": 1416, + "one_axis_query_target_in_span": [ + false, + false, + true, + true + ] + } + ], + "seconds": 0.28178254200611264, + "scope": "Small four-axis, four-input fixture in the specified group algebra. Every paid result and original input is retained. The left ordinary alphabet is translations and axis permutations. No actual large E8 caller, general physical lower bound, paid improvement, or kappa claim." +} diff --git a/docs/research/handoffs/ali-romman-20261025/e-history/paid_return_screen.json b/docs/research/handoffs/ali-romman-20261025/e-history/paid_return_screen.json new file mode 100644 index 0000000000..83b4bdec88 --- /dev/null +++ b/docs/research/handoffs/ali-romman-20261025/e-history/paid_return_screen.json @@ -0,0 +1,11 @@ +{ + "status": "MODULAR_ONE_AXIS_RETAINED_QUERY_SCREEN", + "source_program_sha256": "00470b4fc8804e944e6a6117e70bedff651ae61eb7db46539f156f38f47940c9", + "prime": 65521, + "one_query_candidates": 76, + "single_target_hits": [], + "two_query_cases": 2850, + "two_query_both_target_hits": [], + "seconds": 0.20867304201237857, + "scope": "Small published four-axis fixture; positive widths through a finite group algebra model. Queries use one coordinate axis and one saved paid return or original input. No actual odd-E8 implementation or rational infeasibility proof." +} diff --git a/docs/research/handoffs/ali-romman-20261025/e-history/paid_return_screen.py b/docs/research/handoffs/ali-romman-20261025/e-history/paid_return_screen.py new file mode 100644 index 0000000000..2e06267c4e --- /dev/null +++ b/docs/research/handoffs/ali-romman-20261025/e-history/paid_return_screen.py @@ -0,0 +1,67 @@ +"""Test one-axis queries on retained small E caller values.""" +from pathlib import Path +import itertools +import json +import time +import history_module as h + + +def run(): + started = time.monotonic() + history, targets, sha = h.source() + candidates = [] + for i, (name, row) in enumerate(history): + for axis in range(4): + candidates.append((name, axis, h.left(row, 1 << (2*axis), h.ID))) + bases = {} + queries = {} + wanted = {} + for weight in range(5): + chi = (1 << weight)-1 + basis = {} + for name, row in history: + for p in range(24): + h.insert(h.project(row, chi, p), basis) + bases[weight] = basis + wanted[weight] = [h.residue(h.project(t, chi, h.ID), basis) for t in targets[:2]] + queries[weight] = [[h.residue(h.project(row, chi, p), basis) + for p in range(24)] for name, axis, row in candidates] + hits = [] + singles = [] + for i in range(len(candidates)): + cover = [] + for target in range(2): + good = True + for weight in range(5): + b = {} + for row in queries[weight][i]: + h.insert(row, b) + if h.residue(wanted[weight][target], b): + good = False + break + cover.append(good) + if any(cover): + singles.append({'query': candidates[i][:2], 'targets': cover}) + for i, j in itertools.combinations(range(len(candidates)), 2): + good = True + for weight in range(5): + b = {} + for row in queries[weight][i]+queries[weight][j]: + h.insert(row, b) + if any(h.residue(t, b) for t in wanted[weight]): + good = False + break + if good: + hits.append([candidates[i][:2], candidates[j][:2]]) + result = {'status': 'MODULAR_ONE_AXIS_RETAINED_QUERY_SCREEN', + 'source_program_sha256': sha, 'prime': h.MOD, + 'one_query_candidates': len(candidates), 'single_target_hits': singles, + 'two_query_cases': len(candidates)*(len(candidates)-1)//2, + 'two_query_both_target_hits': hits, 'seconds': time.monotonic()-started, + 'scope': 'Small published four-axis fixture; positive widths through a finite group algebra model. Queries use one coordinate axis and one saved paid return or original input. No actual odd-E8 implementation or rational infeasibility proof.'} + Path(__file__).with_suffix('.json').write_text(json.dumps(result, indent=2)+'\n') + print(json.dumps(result), flush=True) + + +if __name__ == '__main__': + run() diff --git a/docs/research/handoffs/ali-romman-20261025/e-history/verify_control.py b/docs/research/handoffs/ali-romman-20261025/e-history/verify_control.py new file mode 100644 index 0000000000..25c29e85b4 --- /dev/null +++ b/docs/research/handoffs/ali-romman-20261025/e-history/verify_control.py @@ -0,0 +1,58 @@ +"""Check the source blob and an exactly decodable spectral control.""" +from fractions import Fraction as Q +import hashlib +import json +from pathlib import Path + +import history_module as h + +HERE = Path(__file__).resolve().parent + + +def main(): + h.MOD = None + data = (HERE/'N3-PROGRAM.json').read_bytes() + blob = hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest() + if blob != '757fe38c7de18c137be95e0d8e4f7c53e0b5d443': + raise ValueError('The source program does not match its pinned Git blob') + program = json.loads(data) + # At lambda=2, the fixture has C=2P_minus and E=I. These four + # coefficient families are lambda/2, 1-lambda/2, and the two + # inverse-code coefficients lambda/(2(lambda-1)) and + # (lambda-2)/(2(lambda-1)). Include their exterior signs. + replace = {Q(49): Q(1), Q(-49): Q(-1), Q(-48): Q(0), Q(48): Q(0), + Q(49, 97): Q(1), Q(-49, 97): Q(-1), + Q(48, 97): Q(0), Q(-48, 97): Q(0)} + changes = 0 + for e in program: + if e[0] in ('ADD', 'SCALE'): + i = 3 if e[0] == 'ADD' else 2 + c = Q(e[i], e[i+1]) + if c in replace: + new = replace[c] + e[i:i+2] = [new.numerator, new.denominator] + changes += 1 + history, targets, _ = h.source(program) + records = [] + for weight in range(5): + chi = (1 << weight)-1 + basis = {} + for name, row in history: + for p in range(24): + h.insert(h.project(row, chi, p), basis) + hits = [not h.residue(h.project(t, chi, h.ID), basis) for t in targets] + if not all(hits): + raise ValueError('The spectral control must recover all four targets') + records.append({'weight': weight, 'rank': len(basis), 'targets': hits}) + result = {'status': 'PASS_EXACT_CONTROL_AT_LAMBDA_2', + 'coefficient_changes': changes, + 'reason': 'In this small fixture C=2P_minus and E=K(I-C)^-1=I.', + 'cases': records, + 'scope': 'Control only. The actual global C modes do not cover the full K-minus eigenspace, so this is not a global repair.'} + if result != json.loads((HERE/'control-lambda2.json').read_bytes()): + raise ValueError('The saved control receipt differs') + print(json.dumps(result), flush=True) + + +if __name__ == '__main__': + main()