From 0645ec2c14669558861e8e9a1281b59643dce4ed Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Mon, 2 Nov 2026 21:16:48 +0000 Subject: [PATCH] feat(research): compose clean native merge with mixed root --- research/clean-native-mixed-root/PROOF.md | 125 +++++ research/clean-native-mixed-root/README.md | 77 +++ research/clean-native-mixed-root/RESULT.json | 85 +++ research/clean-native-mixed-root/SOURCES.json | 74 +++ research/clean-native-mixed-root/TASK.json | 117 ++++ research/clean-native-mixed-root/VERIFY.json | 34 ++ .../inputs/merge-NOTICE | 312 +++++++++++ .../inputs/merge-proof.md | 79 +++ .../inputs/merge-result.json | 348 ++++++++++++ .../inputs/root-NOTICE | 312 +++++++++++ .../inputs/root-proof.md | 153 ++++++ .../inputs/root-result.json | 498 ++++++++++++++++++ research/clean-native-mixed-root/verify.py | 176 +++++++ 13 files changed, 2390 insertions(+) create mode 100644 research/clean-native-mixed-root/PROOF.md create mode 100644 research/clean-native-mixed-root/README.md create mode 100644 research/clean-native-mixed-root/RESULT.json create mode 100644 research/clean-native-mixed-root/SOURCES.json create mode 100644 research/clean-native-mixed-root/TASK.json create mode 100644 research/clean-native-mixed-root/VERIFY.json create mode 100644 research/clean-native-mixed-root/inputs/merge-NOTICE create mode 100644 research/clean-native-mixed-root/inputs/merge-proof.md create mode 100644 research/clean-native-mixed-root/inputs/merge-result.json create mode 100644 research/clean-native-mixed-root/inputs/root-NOTICE create mode 100644 research/clean-native-mixed-root/inputs/root-proof.md create mode 100644 research/clean-native-mixed-root/inputs/root-result.json create mode 100644 research/clean-native-mixed-root/verify.py diff --git a/research/clean-native-mixed-root/PROOF.md b/research/clean-native-mixed-root/PROOF.md new file mode 100644 index 0000000000..a34d81cd2f --- /dev/null +++ b/research/clean-native-mixed-root/PROOF.md @@ -0,0 +1,125 @@ +# Clean native merge in the mixed root + +This is a scoped accounting proof, conditional on the two exact predecessor +interfaces below. It is not a new whole-algorithm kappa claim, a native replay, +a supplier admission or a complete multiplication theorem. + +## Premises and substitution + +Rohan Arun's PR6399 at `a928a7aa5ab5b21b7cf841d6d960ab2e7efd1041` +supplies an unchanged-input, unchanged-output replacement of the PR6375 +native interface. Its normalized main map and all independent helper targets +are retained. Its one additional scratch lifetime is returned to zero. Those +operator and restoration statements are cited premises here, not independently +verified conclusions of this package. See the exact retained +[source proof](inputs/merge-proof.md). + +Ali Romman's PR6398 at `dee2663ba0918be86993fd9d63c8d64b020f4c83` +supplies a mixed root using eighteen copies of precisely that PR6375 native +interface. Helpers from different calls remain independent, and normalization +acts on the complete field. Its physical embedding, central normalization and +caller identity are also premises. See the retained +[composition proof](inputs/root-proof.md). + +Consequently the new abstract composition replaces each of those eighteen +native copies by PR6399's interface. Every old helper target, caller query, +whole idle and ordinary normalization stays in its original place. The +replacement is private to a native call. Its additional restored scratch +lifetime is not an additional productive target. This substitution is the new +object; neither predecessor was priced with this combination. + +Let P and T denote PR6398's complete paid and productive histograms. Let +P_local and P_clean denote the respective old and new native paid histograms. +The retained receipts give + + P_clean - P_local = -[1] - [4] + [5]. + +The complete new invoice is therefore + + T_new = T, + P_other = P - 18 P_local, + P_new = P_other + 18 P_clean. + +The verifier explicitly constructs the nonnegative histogram P_other. It +does not discard the non-native jobs. It constructs every entry of P_new, +and enumerates 13,652 productive fields and 67,132 paid jobs. The productive +rank mass is 185,740 and the paid rank mass is 184,980, preserving surplus 760. +The count reduction is eighteen jobs, not eighteen rank units. + +## Strict gain and one new funded point + +For 0 < t < 1, define M(T,P;t) = sum_r (T_r-P_r) r^t. The substitution gives + + M(T_new,P_new;t) - M(T,P;t) = 18 (1 + 4^t - 5^t) > 0. + +Strict positivity follows from strict subadditivity of x^t for positive +arguments. For example, integrate its strictly decreasing derivative over +[4,5] and compare with the integral over [0,1]. This proves gain over the +same root for every such tariff. It does not transfer the predecessor's +fixed-source raw optimum to this changed source. + +At the exact saving C = 41085/12500000 = 0.0032868, set t = 1-C. +The new full invoice satisfies + + 0.0130615 < M(T_new,P_new;t) < 0.0130617. + +The old invoice has strictly negative margin at this same C. These signs, +the full histograms and tighter rational outward decimal enclosures are +generated in RESULT.json. The exponent is an exact rational, not a binary +floating-point input. The retained exact interval functions use an atanh +logarithm series and outward-rounded exponential Taylor intervals. This +package calls only their arithmetic functions; it does not run their +historical construction replay. The elementary substitution proof and this +fixed numerical certificate are the claims. No new root search or optimality +claim is needed. + +## Ordinary allowance and remaining obligations + +The replacement's scalar allowance is 130,178, an increase of 508 per call. +Its 44 local owned lifetimes replace 43; its peak owned fields remain 13. +Using the declared PR6398 local routing envelope, including four endpoint +charges per lifetime, gives + + routes = 1000 (3458 + 1124 + 208 + 4*104 + 4*44) = 5,382,000, + scalar + routes = 5,512,178 < 10,000,000. + +Thus the added local scalar work and lifetime charges fit that declared +ordinary envelope. The total increase in this envelope is 3,508 per native +copy: 508 scalar units and 3,000 route units. The latter includes the saving +of one paid job and the cost of the extra lifetime. Across eighteen copies, +the increase is 63,144. This is an allowance calculation, not execution or +independent validation of the physical routing theorem. + +The combined physical native/caller replay, a newly chosen strictification +and compiler grid, combined precision/tape validation, and all outer +inequalities are unrun. No whole-algorithm kappa is asserted at C. In +particular, a passing raw margin is not a free compiler or supplier admission. +The five inherited assumptions remain: native_all_columns, owned_erasure, +compiler, precision_tape and analytic_recovery. + +## Certificate and controls + +The verifier binds exact predecessor receipts, proofs and notices by SHA256 +and Git blob identifiers. These are byte-equal retained snapshots, not +handwritten extracts of predecessor counts. Their source URLs and commits +are in SOURCES.json. They are available without pending-commit Git ancestry. +The generic source-history check covers the main-based manifest pins; it +does not claim to authenticate the external snapshots' publication history. + +Seven enumerated semantic mutations reject changed helper targets, a free +merged query, omitted cleanup allowance, an omitted lifetime, a changed peak, +and either wrong native multiplicity. The arithmetic control checks exact +square-root enclosure inequalities for every integer rank 1 through 145. +Normal and optimized Python run the same explicit checks. These controls do +not establish independent scientific or proof-kernel acceptance. + +## Credit + +This composition and its certificate were produced by Nick Petalas. +The clean native merge and its zero-restored scratch construction are Rohan +Arun's PR6399. The mixed root, complete-field normalization and its original +invoice are Ali Romman's PR6398. DreamingOfClouds supplied the PR6375 +shared-carrier lifts. Cinna Davis supplied the caller interfaces, Jacob Alan +Sussman supplied productive recursion, and zxv supplied the retained exact +interval engine. The unchanged source notices retain the complete +native, helper, geometry, BIT, compiler and analytic lineage. Apache-2.0. diff --git a/research/clean-native-mixed-root/README.md b/research/clean-native-mixed-root/README.md new file mode 100644 index 0000000000..c648505338 --- /dev/null +++ b/research/clean-native-mixed-root/README.md @@ -0,0 +1,77 @@ +# Clean native merge in the mixed root + +The new composition of Rohan Arun's [PR6399 clean native merge](https://github.com/CrocSwap/integer-mult-bounds/pull/6399) +and Ali Romman's [PR6398 mixed root](https://github.com/CrocSwap/integer-mult-bounds/pull/6398) +has a strictly positive complete recursive margin at saving **0.0032868**. +PR6398's original invoice has negative margin at that same saving. + +Claim type: a scoped accounting proof, conditional on the retained native +and caller interfaces, with an exact finite certificate. This is a new +composition, not an audit of either predecessor. It asserts no complete +whole-algorithm kappa or selected-frontier change. + +Eighteen substitutions of `H4 + H1` by `H5` remove eighteen paid jobs while +preserving every productive target and both rank masses. The complete new +invoice has **13,652 productive fields and 67,132 paid jobs**. Its margin at +`t = 1 - 0.0032868` is between `0.0130615` and `0.0130617`. The improvement is +`18 (1 + 4^t - 5^t) > 0` for every `0 < t < 1`. + +The additional scratch lifetime and scalar cleanup are charged. The new local +ordinary allowance is **5,512,178**, below the predecessor's declared +10,000,000 envelope. This allowance comparison does not implement routing, +precision or a compiler. [PROOF.md](PROOF.md) states the composition and all +remaining obligations; [RESULT.json](RESULT.json) is generated by the verifier. + +## Reproduction + +From the repository root, using CPython 3.12: + +```sh +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -W error -B research/clean-native-mixed-root/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -O -W error -B research/clean-native-mixed-root/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/clean-native-mixed-root +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/clean-native-mixed-root --check-source-history --check-modes +``` + +Use an equivalent Python 3.12 path on another machine. The verifier is +standard-library only and writes nothing during ordinary replay. It checks +the complete new histograms, exact interval signs, ordinary allowance, seven +semantic rejection controls and 145 exact square-root enclosure controls. +It regenerates the receipt in memory and compares every field. To regenerate +an explicit receipt, pass `--write-result /absolute/scratch/RESULT.json`. + +The main-based exact arithmetic input is declared in VERIFY.json. Exact +predecessor receipts, proofs and notices are retained under inputs/ with +original URLs, commits, SHA256 and Git blob identifiers in SOURCES.json. +They do not require pending commits in the checkout's Git history. Their +mathematical claims remain premises. The source-history check covers the +ordinary main-based pins, not remote publication ancestry of these snapshots. + +## Limitations + +The combined physical word/caller replay, new completion and compiler +parameters, combined precision/tape contract and outer inequality ledger have +not been run. All five framework assumptions remain. Neither independent +human nor formal proof-kernel acceptance is claimed. The screen saving is +not a certified multiplication exponent. Frozen predecessor artifacts and +the selected result remain unchanged. + +## Open next questions + +Can the concrete replacement pass the complete eighteen-call physical +mixed-root replay and admit a whole bound below this funded raw saving? +Start by binding PR6399's constructor and scratch-zero check to PR6398's +unchanged controller. Then select strict compiler/outer parameters and run +the changed composition's complete ledger. The unresolved physical and +framework premises are blockers. TASK.json records this question in a +structured form. Further optimization of the raw crossing is not needed +before that admission step. + +## Credit + +This result was produced by Nick Petalas. Rohan Arun supplied the native +merge and explicit scratch restoration; Ali Romman supplied the mixed root +and its complete original invoice; DreamingOfClouds supplied the shared +carrier lifts. Cinna Davis, Jacob Alan Sussman and zxv supplied the caller, +productive recursion and exact interval foundations. Both unchanged source +notices retain all predecessor credit. Apache-2.0. diff --git a/research/clean-native-mixed-root/RESULT.json b/research/clean-native-mixed-root/RESULT.json new file mode 100644 index 0000000000..a0177650c8 --- /dev/null +++ b/research/clean-native-mixed-root/RESULT.json @@ -0,0 +1,85 @@ +{ + "claim_type": "scoped accounting proof conditional on retained interfaces", + "combined_margin": { + "lower": "0.013061578546729933727885198969", + "upper": "0.013061578546729933727885198970" + }, + "controls": { + "exact_square_root_controls": 145, + "rejected": [ + "helper target debit", + "unpaid merged query", + "omitted scalar cleanup", + "omitted scratch lifetime", + "larger peak treated as unchanged", + "wrong native multiplicity 17", + "wrong native multiplicity 19" + ] + }, + "native_copies": 18, + "ordinary_allowance": { + "additional_lifetimes": 18, + "local_budget": 10000000, + "local_ordinary_total": 5512178, + "local_routes": 5382000, + "local_scalar": 130178, + "peak_owned_fields": 13 + }, + "paid": { + "1": 42016, + "2": 8154, + "3": 8838, + "4": 1944, + "5": 2736, + "6": 144, + "7": 162, + "8": 18, + "16": 1872, + "24": 416, + "32": 416, + "56": 416 + }, + "paid_job_reduction": 18, + "paid_jobs": 67132, + "paid_rank_mass": 184980, + "predecessor_invoice_margin_at_same_saving": { + "lower": "-0.134452721442009416742639196431", + "upper": "-0.134452721442009416742639196430" + }, + "productive_fields": 13652, + "saving_screen": "8217/2500000", + "signed_gain": { + "lower": "0.147514299988739350470524395399", + "upper": "0.147514299988739350470524395400" + }, + "source_sha256": { + "inputs/merge-NOTICE": "80b7d5fa85b817e9b544be00d3197aeabecfc7aa20e0666b9e4c69fbb4a029b3", + "inputs/merge-proof.md": "c1b32f7b50db99871da529ed8673b31754dde327ccddb1d7d54b6310cc27b193", + "inputs/merge-result.json": "b208fe6b40397ddcc1c88a40fdd050628ad51f5907107867bd32014ddc0208d2", + "inputs/root-NOTICE": "60b778c0bfadff92601e1f158b7e0ca72af9f7c31e58a369d802376ee0adc9e6", + "inputs/root-proof.md": "de410dc656d11e82ee299793c2d9af40e2c83553197ed27eb60c7a60198b8ca7", + "inputs/root-result.json": "621c943f72f94b4fe168a1e1ad10edc637cfe7221690d131b33ecbda4601b53c", + "research/higher-moment-strictification/verify.py": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326" + }, + "status": "PASS_CLEAN_NATIVE_MIXED_ROOT_SIGNED_INVOICE", + "target_rank_mass": 185740, + "targets": { + "1": 356, + "2": 144, + "3": 72, + "4": 1926, + "5": 270, + "6": 54, + "7": 162, + "8": 684, + "9": 6552, + "17": 1872, + "25": 416, + "33": 416, + "57": 416, + "73": 208, + "145": 104 + }, + "verifier_sha256": "e364ac4458869825d29493142dac4aacbdfcf84fbfa4f3934e448b9a096a4c61", + "whole_algorithm_kappa_claimed": false +} diff --git a/research/clean-native-mixed-root/SOURCES.json b/research/clean-native-mixed-root/SOURCES.json new file mode 100644 index 0000000000..cec88e0089 --- /dev/null +++ b/research/clean-native-mixed-root/SOURCES.json @@ -0,0 +1,74 @@ +{ + "schema_version": 1, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a", + "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "research/higher-moment-strictification/verify.py", + "usage": "input", + "git_blob": "4b24a5096154736ce060474eb8c72dc64c303699", + "sha256": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326" + } + ], + "retained_external_snapshots": [ + { + "path": "inputs/root-result.json", + "source_commit": "dee2663ba0918be86993fd9d63c8d64b020f4c83", + "source_path": "research/mixed-root-contact-composition/RESULT.json", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/dee2663ba0918be86993fd9d63c8d64b020f4c83/research/mixed-root-contact-composition/RESULT.json", + "sha256": "621c943f72f94b4fe168a1e1ad10edc637cfe7221690d131b33ecbda4601b53c", + "git_blob": "be12d2101b76b3b81f1fa1be2c73b4aaa6796899" + }, + { + "path": "inputs/merge-result.json", + "source_commit": "a928a7aa5ab5b21b7cf841d6d960ab2e7efd1041", + "source_path": "research/p104-clean-piggyback/RESULT.json", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/a928a7aa5ab5b21b7cf841d6d960ab2e7efd1041/research/p104-clean-piggyback/RESULT.json", + "sha256": "b208fe6b40397ddcc1c88a40fdd050628ad51f5907107867bd32014ddc0208d2", + "git_blob": "5c684a38ed74133917834ddcce3495ef21faa8e8" + }, + { + "path": "inputs/root-proof.md", + "source_commit": "dee2663ba0918be86993fd9d63c8d64b020f4c83", + "source_path": "research/mixed-root-contact-composition/PROOF.md", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/dee2663ba0918be86993fd9d63c8d64b020f4c83/research/mixed-root-contact-composition/PROOF.md", + "sha256": "de410dc656d11e82ee299793c2d9af40e2c83553197ed27eb60c7a60198b8ca7", + "git_blob": "49a3bb14e2a4e533e647d03955d476fcfbc9d10b" + }, + { + "path": "inputs/merge-proof.md", + "source_commit": "a928a7aa5ab5b21b7cf841d6d960ab2e7efd1041", + "source_path": "research/p104-clean-piggyback/PROOF.md", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/a928a7aa5ab5b21b7cf841d6d960ab2e7efd1041/research/p104-clean-piggyback/PROOF.md", + "sha256": "c1b32f7b50db99871da529ed8673b31754dde327ccddb1d7d54b6310cc27b193", + "git_blob": "55e5277159ea693deb8f4f48611df2d23e2a58f9" + }, + { + "path": "inputs/root-NOTICE", + "source_commit": "dee2663ba0918be86993fd9d63c8d64b020f4c83", + "source_path": "research/mixed-root-contact-composition/NOTICE", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/dee2663ba0918be86993fd9d63c8d64b020f4c83/research/mixed-root-contact-composition/NOTICE", + "sha256": "60b778c0bfadff92601e1f158b7e0ca72af9f7c31e58a369d802376ee0adc9e6", + "git_blob": "4e3b429712e9c4a44e80d0b57a8a1030d96740ae" + }, + { + "path": "inputs/merge-NOTICE", + "source_commit": "a928a7aa5ab5b21b7cf841d6d960ab2e7efd1041", + "source_path": "research/p104-clean-piggyback/NOTICE", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/a928a7aa5ab5b21b7cf841d6d960ab2e7efd1041/research/p104-clean-piggyback/NOTICE", + "sha256": "80b7d5fa85b817e9b544be00d3197aeabecfc7aa20e0666b9e4c69fbb4a029b3", + "git_blob": "20ea736c50a04bbc095012e8426644ffb9121978" + } + ] +} diff --git a/research/clean-native-mixed-root/TASK.json b/research/clean-native-mixed-root/TASK.json new file mode 100644 index 0000000000..97f7713b26 --- /dev/null +++ b/research/clean-native-mixed-root/TASK.json @@ -0,0 +1,117 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "priority_revision": 8, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "original_card": { + "id": "p104-side-correction", + "question": "Can joint helper bases and a legal causal split improve the complete P104 productive/paid invoice?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/p104-helper-subspace-splits/README.md", + "research/dyadic-helper-channel-capacity/README.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "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. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Start with the selected #5599 emitted word and review pending #5718 distinct input/output bases plus #5717/#5719 coverage before claiming work. Pick one uncovered source word, helper group and cut region. Prove the arbitrary-input relation and legal entry/exit corrections, then compare full target and paid profiles. Reject if completion, owned lifetimes or consumer costs repay the gain. A static pairing rank alone is not a physical split.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "P104", + "helper basis", + "helper split", + "5718", + "dyadic capacity" + ], + "existing_checks": [ + { + "scope": "PR #4133: literal-slot defect", + "evidence": "research/p104-literal-slot-defect/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4136: uniform commutation gap", + "evidence": "research/p104-uniform-commutation-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4140: uniform encoding gap", + "evidence": "research/p104-uniform-encoding-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance", + "evidence": "research/p104-source-chart-shortcut/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4154: fiber-tag seam mismatch", + "evidence": "research/p104-fiber-tag-seam/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Compose the unchanged-target clean native merge of PR6399 with the eighteen-call mixed root of PR6398; prove its new signed recursive invoice passes saving 0.0032868 and charge the local ordinary allowance.", + "scope_change_reason": "The source word and caller differ from the historical card example. This takes the explicitly unperformed composition in PR6399 and produces a scoped accounting result, not another helper-subspace split or a predecessor audit.", + "bottleneck_link": "The complex recursive moment binds. The new composition lowers the complete paid moment while preserving productive targets; its physical replay, compiler and outer admission remain a separate next step.", + "budget_minutes": 60, + "stop_rule": "Stop at the first strict original invoice improvement and package it. Do not refine its crossing or pursue a new complete kappa.", + "outcome": "completed", + "evidence": "PROOF.md and generated RESULT.json; normal/optimized verification, source-bound receipts, seven semantic rejection controls and 145 square-root controls.", + "author": "Nick Petalas", + "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.", + "open_questions": [ + { + "question": "Does the concrete clean native word pass the complete eighteen-call physical mixed-root replay and compiler/outer ledger at a smaller saving than this raw screen?", + "why_it_matters": "A positive raw recursive invoice does not admit a complete supplier or establish a whole-algorithm kappa.", + "first_step": "Bind PR6399 construct.py and owned_zero.py to the unchanged PR6398 controller, then run its changed native/caller contacts and all newly parameterized compiler and outer checks.", + "blocked_by": "The two predecessor interface theorems and all five framework assumptions remain premises; no combined physical word or admission replay is supplied here." + } + ] +} diff --git a/research/clean-native-mixed-root/VERIFY.json b/research/clean-native-mixed-root/VERIFY.json new file mode 100644 index 0000000000..0dbdaa1903 --- /dev/null +++ b/research/clean-native-mixed-root/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/higher-moment-strictification/verify.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Complete new signed invoice, exact power intervals, charged local ordinary allowance, seven semantic rejections, 145 algebraic enclosure controls and generated source-bound receipt." + }, + { + "argv": [ + "{python}", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "The same scoped certificate and rejection controls with assertions disabled." + } + ] +} diff --git a/research/clean-native-mixed-root/inputs/merge-NOTICE b/research/clean-native-mixed-root/inputs/merge-NOTICE new file mode 100644 index 0000000000..20ea736c50 --- /dev/null +++ b/research/clean-native-mixed-root/inputs/merge-NOTICE @@ -0,0 +1,312 @@ +New contribution: DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. +Apache-2.0. + +The PR6372 word, by Ali Romman with substantial OpenAI Codex assistance, is the +source. Exact head: b556600ffe14be72406b03a47c661f3c7f1aff06. The native +input-lift move class is from PR6349; PR6349 builds on DreamingOfClouds PR6314. +PR6353, PR6348 and their source chains supply the joint basis method, the fixed +binary query-tree caller and the price engine. The word is retained unchanged in +inputs. The complete predecessor notice follows. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +No subagents. Apache-2.0. + +PR6353 supplies the word, joint basis construction and native transpose. +Exact head: db2a20bc50bc7a8a4db931af85ce7f012ae7c3c3. +The source files in inputs are unchanged. The complete predecessor notice follows. + +Joint native output contraction +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author checks. + +PR6349 supplies the exact native input-lift source. PR6348 supplies the fixed +binary query-tree caller and price engine. PR6350, by Ali Romman with OpenAI +Codex assistance, supplies the released composition control and its prior +conditional claim. Its source and caller are recounted here from main; no +pending PR6350 code is imported. Cinna Davis supplies the productive caller, +thin-query interface and exact Laurent factorization. + +The new result is the explicit nine-helper joint output contraction, its +literal forward word and complete conditional price. The input/departure basis +identity is elementary linear algebra. No new general linear algebra theorem, +native duality theorem or caller construction is claimed. + +The exact PR6349 and PR6348 notices follow. Their nested source archive retains +all earlier native, helper, recursion, compiler, BIT and analytic attribution. + +Native helper input lifting +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author checks. + +The direct source is PR6314 at 36533d4d1b4e2dd8672427461b12de3001b85810, +by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. +It compresses the scalar word of PR6167 without a kappa change. +The four native input lifts and their complete conditional price are new here. +The basis identity is elementary linear algebra; no new general theorem +for that identity is claimed. + +The PR6167 source notice follows unchanged. Its nested source archive also +retains the earlier notices. + +Retained-operand descent: Ali Romman, with substantial OpenAI Codex assistance. +Apache-2.0. + +The exact source word and price are from DreamingOfClouds, PR6144 and PR6143, +with Claude Opus 5.5 (Anthropic), via Claude Code. They extend PR6030 and PR5907. +The source reader is adapted from that work. The gzip portability controls +retain Douglas Colkitt and Maxime Fleury credit. + +The pinned PR5827 checker and all earlier source notices are retained below. + +Unread-register path resynthesis +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author-side. + +Mason Hale supplied PR5811, the complete two-block composition and the exact +role92 remapping and fourth accumulation. The earlier elementary accumulation, +retained-copy and second-block work is by Ali Romman. Joel Pulikkan supplied +R22. Dugongue supplied the concurrent baseline composition proof. Their source +notice and proof are retained byte for byte under inputs/pr5811-*. + +The source closure retains flyingviper, Cinna Davis, David Arias, Gareth +Davidson, Jacob Alan Sussman, zxv, Cao Yifan, Pierre-Loic Doulcet, thu-nmrc, +Scratch-net and all native/helper/controller/compiler/geometry/analytic +predecessors. The exact PR5786 source archive and its nested notices remain. +This package does not claim any predecessor construction as new. + +Exact PR5811 vendor/accumulated/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +Accumulated native updates +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. The same assistant made the construction and the author checks. + +Concurrent scope: Discussion5125 now tests retained copies in the transposed +supplier. That route uses the same source/destination duality. This package +claims the three fixed forward-supplier groups and their complete result, +not the elementary accumulation identity or the broader transposed search. + +Exact source: PR5786 at 6b936acd68a7e0f9062037900f0fe9bc4b6fdd25. +The complete predecessor notice follows unchanged. + +Asynchronous helper hubs +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Retained native copies from PR5774 at 7d6ec0cdef31d0c37b7d2563e709979caa0d5eae. +All prior credit follows unchanged. + +Paid intermediate meetings and collective helper splits. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. All checks are author-side calculations. + +The complete PR5718 notice follows unchanged. + +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The same assistant performed the construction and author-side checks. + +Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. +Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. +Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. +DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. +thu-nmrc: PR5551 contact improvements. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained source notices preserve earlier geometry, BIT and analytic credit. + +The elementary rank-one basis identity is not claimed as a new general +linear-algebra theorem. The contribution is its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + +New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices. + +Two-boundary main-assisted helper split and early cleanup: flyingviper with substantial +OpenAI Codex assistance, including independent AI review agents. Apache-2.0. + +Retained native-copy construction +Prepared by Ali Romman with substantial OpenAI Codex assistance. No subagents. +The paid-meeting source is PR5751 by Ali Romman with OpenAI Codex assistance. +The dimension-four span [265,194,164,75] is from Joel Pulikkan / GamingPuzzled +PR5739, with Claude Opus 5.5 assistance. The R22 block edits are not included. +The retained-copy mechanism, exact constructor, source-specific verification, +new price and proof are the contribution of this package. Apache-2.0. + +Exact PR5811 vendor/blocks/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +The second block is PR5796 at4b30391e633ba0c7c674f03586ae97d443e9bc9c, by Ali Romman with substantial OpenAI Codex assistance, following Joel Pulikkan/GamingPuzzled R22. Exact notice, plan, proof and source words are retained in source/SECOND-* unchanged. + +The final immediate source is PR5786 asynchronous helper hubs by Ali Romman with substantial OpenAI Codex assistance. Its three temporal helper splits and complete completion parameters are retained and credited. The earlier PR5774-only composition is a superseded checkpoint, not a separate contribution. + +New complete retained-copy and R22 composition: Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. + +The thirteen retained native conversions and changed helper targets are by Ali Romman with OpenAI Codex assistance in PR5774. The R22 block and rank-four basis are by Joel Pulikkan (GamingPuzzled), with Claude Opus5.5 assistance, in PR5739/5756. The complete source archive and R22 notice remain unchanged. + +The construction retains Ali Romman PR5751 paid intermediate meetings, flyingviper PR5718 boundary splits, Cinna Davis's productive controller, Jacob Alan Sussman's productive recursion, zxv and Cao Yifan's interval/compiler line, and every P104/native/BIT predecessor in the source notices. The source engines are reused under exact byte bindings, not claimed as new implementations. + +Binary query-tree caller + +New construction, proof and code: Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. No subagents. + +Cinna Davis supplies the productive path caller, query thinning and exact Laurent factorization. Ali Romman supplies the all-forward P104 binding in PR5544 and the retained-operand word in PR6167. The native word and interval/compiler lineage remain predecessor work. The new contribution is the four-field query extension, its tree composition, complete invoice and conditional price. + +The authenticated PR6167 notice follows. + +Retained-operand descent: Ali Romman, with substantial OpenAI Codex assistance. +Apache-2.0. + +The exact source word and price are from DreamingOfClouds, PR6144 and PR6143, +with Claude Opus 5.5 (Anthropic), via Claude Code. They extend PR6030 and PR5907. +The source reader is adapted from that work. The gzip portability controls +retain Douglas Colkitt and Maxime Fleury credit. + +The pinned PR5827 checker and all earlier source notices are retained below. + +Unread-register path resynthesis +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author-side. + +Mason Hale supplied PR5811, the complete two-block composition and the exact +role92 remapping and fourth accumulation. The earlier elementary accumulation, +retained-copy and second-block work is by Ali Romman. Joel Pulikkan supplied +R22. Dugongue supplied the concurrent baseline composition proof. Their source +notice and proof are retained byte for byte under inputs/pr5811-*. + +The source closure retains flyingviper, Cinna Davis, David Arias, Gareth +Davidson, Jacob Alan Sussman, zxv, Cao Yifan, Pierre-Loic Doulcet, thu-nmrc, +Scratch-net and all native/helper/controller/compiler/geometry/analytic +predecessors. The exact PR5786 source archive and its nested notices remain. +This package does not claim any predecessor construction as new. + +Exact PR5811 vendor/accumulated/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +Accumulated native updates +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. The same assistant made the construction and the author checks. + +Concurrent scope: Discussion5125 now tests retained copies in the transposed +supplier. That route uses the same source/destination duality. This package +claims the three fixed forward-supplier groups and their complete result, +not the elementary accumulation identity or the broader transposed search. + +Exact source: PR5786 at 6b936acd68a7e0f9062037900f0fe9bc4b6fdd25. +The complete predecessor notice follows unchanged. + +Asynchronous helper hubs +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Retained native copies from PR5774 at 7d6ec0cdef31d0c37b7d2563e709979caa0d5eae. +All prior credit follows unchanged. + +Paid intermediate meetings and collective helper splits. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. All checks are author-side calculations. + +The complete PR5718 notice follows unchanged. + +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The same assistant performed the construction and author-side checks. + +Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. +Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. +Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. +DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. +thu-nmrc: PR5551 contact improvements. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained source notices preserve earlier geometry, BIT and analytic credit. + +The elementary rank-one basis identity is not claimed as a new general +linear-algebra theorem. The contribution is its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + +New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices. + +Two-boundary main-assisted helper split and early cleanup: flyingviper with substantial +OpenAI Codex assistance, including independent AI review agents. Apache-2.0. + +Retained native-copy construction +Prepared by Ali Romman with substantial OpenAI Codex assistance. No subagents. +The paid-meeting source is PR5751 by Ali Romman with OpenAI Codex assistance. +The dimension-four span [265,194,164,75] is from Joel Pulikkan / GamingPuzzled +PR5739, with Claude Opus 5.5 assistance. The R22 block edits are not included. +The retained-copy mechanism, exact constructor, source-specific verification, +new price and proof are the contribution of this package. Apache-2.0. + +Exact PR5811 vendor/blocks/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +The second block is PR5796 at4b30391e633ba0c7c674f03586ae97d443e9bc9c, by Ali Romman with substantial OpenAI Codex assistance, following Joel Pulikkan/GamingPuzzled R22. Exact notice, plan, proof and source words are retained in source/SECOND-* unchanged. + +The final immediate source is PR5786 asynchronous helper hubs by Ali Romman with substantial OpenAI Codex assistance. Its three temporal helper splits and complete completion parameters are retained and credited. The earlier PR5774-only composition is a superseded checkpoint, not a separate contribution. + +New complete retained-copy and R22 composition: Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. + +The thirteen retained native conversions and changed helper targets are by Ali Romman with OpenAI Codex assistance in PR5774. The R22 block and rank-four basis are by Joel Pulikkan (GamingPuzzled), with Claude Opus5.5 assistance, in PR5739/5756. The complete source archive and R22 notice remain unchanged. + +The construction retains Ali Romman PR5751 paid intermediate meetings, flyingviper PR5718 boundary splits, Cinna Davis's productive controller, Jacob Alan Sussman's productive recursion, zxv and Cao Yifan's interval/compiler line, and every P104/native/BIT predecessor in the source notices. The source engines are reused under exact byte bindings, not claimed as new implementations. + +New clean transport merge: Rohan Arun with substantial OpenAI Codex assistance. Apache-2.0. +Independent integer zero-row checker: same-author separately implemented arithmetic; no independent human or formal-kernel acceptance claimed. diff --git a/research/clean-native-mixed-root/inputs/merge-proof.md b/research/clean-native-mixed-root/inputs/merge-proof.md new file mode 100644 index 0000000000..55e5277159 --- /dev/null +++ b/research/clean-native-mixed-root/inputs/merge-proof.md @@ -0,0 +1,79 @@ +# Clean donor transport and complete conditional bound + +## Exact source and interface + +The input is PR6375's shipped word at247b5c319b9f58fe9ee61dbf80697f8a9a429831, +SHA2569e31463a785c18a70f6ae6ef3d04a6560dbb965517109390fe820f9fac3371b3. +Public frame interfaces, all independent inputs and helper targets are retained. +The constructor derives chronological indices from actual instructions rather +than trusting indices of an older source. Field400 moves1090→477 at event8330, +then477→127 at12861; the sole intermediate export is8359. Donor779 returns +477→1090 before injection slot9094. These names denote exact catalogue frames, +not numeric subspace dimensions. Their first two query ranks are4 and1; the +merged query has rank5. The native checker verifies the actual operators and +absolute phases, not just dimension differences. + +## Rank-one exact endpoint repair + +Let S be the original normalized scalar endpoint. It is identity on helpers +and the retained main shear on the main pairs. Let v be field400's sparse input +row immediately before its first climb. The constructor checks that field400 +is not written between its two climbs. Remove the first climb and intermediate +export, inject the source into donor779 when it is in frame1090, and replace +the final climb by1090→127. The modified full normalized endpoint F satisfies + + F = S + u v + +for the explicitly computed output columnu. For every output row, the exact +sparse rational interpreter checks equality with this rank-one expression, +including all public and owned entries; this is not an approximation or a +selected-column check. Let b=vS^-1, computed from the known main shear. All +nonzero rows ofu and all columns ofb lie in full frame127. In this instance +1+bu=1. More generally write d=1+bu and require d nonzero. + +At the end ofF, initialize clean owned role781 in frame127 and compute +c=bF(input)=d v(input). Add -u c/d to the output rows. The result is + + F(input)-u v(input) = S(input). + +Now subtract d b S(input)=d v(input) fromc. It is exactly zero before its +CLEAR. All added ADDs occur in common frame127; no recursive query is used. +The shipped word uses a role/frame exit absent from the inherited source so +that the independent zero obligation binds exactly this new lifetime. +The separate integer-row checker starts from799formal columns, propagates +binary-denominator arithmetic and verifies that actual pre-CLEAR row is zero. +Inherited CLEAR semantics and assumptions remain unchanged. + +## Paid and ordinary bill + +The only recursive change per native call is removing H4+H1 and adding H5. +Strict subadditivity gives4^s+1>5^s for0 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "348599999253/350000000000", + "fixed_halo_explicit_metadata_branch": "26950000001/350000000", + "new_BIT_row_stock_sublinear_in_active_group": "1395799997009/1400000000000", + "new_semantic_group_guard": "3/1400000000" + }, + "margins": { + "boundary_algebraic_matrix": "7721885144484369/2450000000000000000", + "fused_gaussian": "7721885133453107/2450000000000000000", + "global_coordinate_router": "22062529/7000000000", + "group_bit_router": "30887547533812413/9800000000000000000", + "group_scans": "699999999/700000000", + "main_transform": "7721883394484369/2450000000000000000", + "microbox_face_corrections": "26950000001/350000000", + "polynomial_products": "1399999999/1400000000", + "sparse_union_movement": "1003034385144484369/2450000000000000000" + }, + "parameters": { + "a": "22062529/7000000000", + "b": "11031267/3500000000", + "beta": "1399999997/1400000000", + "bit_saving": "17/5000", + "cap_xi": "2228034383394484369/2450000000000000000", + "complex_uniform_saving": "22062539/7000000000", + "d": "1/1400000000", + "epsilon": "1399999999/1400000000", + "kappa": "3151787/1000000000", + "lambda_": "1993696421/2000000000", + "lambda_prime": "1744484369/1750000000", + "layout": "1/1400000000", + "q": "5515631/1750000000", + "r0": "1/14000000000", + "stop": "1/1400000000", + "tested_saving": "196987/62500000" + }, + "strict_checks": { + "actual_bit_above_effective": "1737471/7000000000", + "actual_logarithmic_gamma_guard": "1/1400000000", + "actual_logarithmic_group_guard": "221965619230515631/1225000000000000000", + "alpha_logarithm_absorption": "1/14000000000", + "boundary_algebraic_matrix_above_kappa": "6994484369/2450000000000000000", + "cap_above_band": "1003034383394484369/2450000000000000000", + "cap_below_cell": "221965614855515631/2450000000000000000", + "cap_below_phase_cell_power": "2671965616605515631/2450000000000000000", + "complex_above_effective": "1/1400000000", + "complex_below_one_over_32": "98343733/3500000000", + "complex_endpoint": "1/700000000", + "epsilon_below_one": "1/1400000000", + "epsilon_positive": "1399999999/1400000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "6983453107/2450000000000000000", + "gaussian_above_main": "869484369/1225000000000000000", + "global_coordinate_router_above_kappa": "1/350000000", + "global_gamma_power_slack": "9/14000000000", + "group_below_dimension": "1/700000000", + "group_bit_router_above_kappa": "34933812413/9800000000000000000", + "group_gauge_power_slack": "221965619143015631/1225000000000000000", + "group_key_fits_record": "1/700000000", + "group_positive": "1399999997/1400000000", + "group_scans_above_kappa": "6977937481/7000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "710408290400418148631/500000000000000000000000", + "lambda_above_internal": "1/2800000000", + "lambda_above_sigma": "3/2800000000", + "lambda_above_tau": "1/2800000000", + "lambda_prime_above_lambda": "1/2800000000", + "lambda_prime_above_leaf": "6988968733/4900000000000000000", + "leaf_saving_above_effective": "3488968733/4900000000000000000", + "main_transform_above_kappa": "5244484369/2450000000000000000", + "membership_arithmetic_fits_record": "1/1400000000", + "microbox_face_corrections_above_kappa": "538977937511/7000000000", + "microbox_halo_volume": "110600000003/1400000000", + "new_complex_uniform_saving_above_b": "1/1400000000", + "new_semantic_guard_with_C1_one": "1/1400000000", + "polynomial_products_above_kappa": "3488968743/3500000000", + "positive_layout_slack": "1/1400000000", + "q_below_effective": "1/1400000000", + "q_below_internal": "1/1400000000", + "q_below_leaf": "6988968733/4900000000000000000", + "q_positive": "5515631/1750000000", + "short_record_fallback": "3488968733/3500000000", + "source_axis_superpolynomial": "1/1400000000", + "sparse_union_movement_above_kappa": "995312506994484369/2450000000000000000", + "stop_below_one": "1399999999/1400000000", + "stop_positive": "1/1400000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/1400000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/1400000000", + "union_tag_work_per_visit_fits_record": "3/1400000000" + } + }, + "paid": { + "1": 44148, + "16": 1872, + "2": 8607, + "24": 208, + "3": 9329, + "32": 832, + "4": 2052, + "5": 2888, + "56": 208, + "6": 152, + "64": 208, + "7": 171, + "8": 19 + }, + "paid_calls": 70694, + "previous_pr6375": "3939/1250000", + "productive_fields": 14214, + "rank_mass_surplus": 808, + "raw_headroom": [ + "788707/100000000000000", + "197177/25000000000000" + ], + "raw_root_interval": [ + "315179488707/100000000000000", + "78794872177/25000000000000" + ], + "relative_gain_percent": "587/31512", + "strictification": { + "alpha": { + "lower": "0.999999996317099737147382498752", + "upper": "0.999999996317099737147382498753" + }, + "cutoff": 12, + "delta": { + "lower": "0.918495145345480093164446544793", + "upper": "0.918495145345480093164446544794" + }, + "floor": 13, + "gamma": { + "lower": "0.934679705694549810795392583753", + "upper": "0.934679705694549810795392583754" + }, + "normalized_paid_upper": "1048576000976562501/1048576001073741824", + "power": 1024, + "reserve": "1/1000000000000", + "tail_block": 128, + "tail_decay": "31/32", + "tail_offset": "1/7", + "tested": "196987/62500000" + }, + "targets": { + "1": 266, + "153": 208, + "17": 1872, + "2": 152, + "25": 208, + "3": 76, + "33": 832, + "4": 2033, + "5": 285, + "57": 208, + "6": 57, + "65": 208, + "7": 171, + "8": 722, + "9": 6916 + }, + "thin_queries": 16, + "whole_idle_jobs": 3328 + }, + "controls": { + "missing_thin_query": "All exact Laurent endpoint coefficients", + "missing_translation": "All exact Laurent endpoint coefficients", + "new_uncomputation_removed": "Declared new scratch not exactly zero before erasure at event 17821", + "public_correction_removed": "All public and owned rows", + "unpaid_idle": "All exact Laurent endpoint coefficients", + "wrong_central_orientation": "All exact Laurent endpoint coefficients" + }, + "independent_transpose": { + "arithmetic": "Dense integer rows with binary denominators; reverse chronology", + "coefficients": 638401, + "columns": 799 + }, + "kappa": "0.003151787", + "limits": [ + "Conditional source-bound construction, not an unconditional multiplication theorem.", + "Same-author separate arithmetic checks; no independent human or formal-kernel acceptance.", + "No materialized rounded multiplier; inherited owned erasure remains conditional.", + "The selected frontier is unchanged; the .005 objective remains unmet." + ], + "local": { + "endpoint_coefficients": 638401, + "helpers": { + "1": 14, + "2": 8, + "3": 4, + "4": 107, + "5": 15, + "6": 3, + "7": 9, + "8": 38, + "9": 364 + }, + "owned_fields": 29, + "owned_lifetimes": 44, + "paid": { + "1": 2236, + "2": 453, + "3": 491, + "4": 108, + "5": 152, + "6": 8, + "7": 9, + "8": 1 + }, + "paid_rank_mass": 5926, + "peak_owned_fields": 13, + "public_inputs": 770, + "real_scalar_allowance": 130178 + }, + "module": { + "coefficients": 16, + "identity": "L S A B Idle S^-1 C R = D_A D_B (U(q) direct-sum q direct-sum q^-1)", + "missing_idle_rejected": true, + "variables": [ + "q", + "D_A", + "D_B" + ] + }, + "native": { + "distinct_maps": 2940, + "helper_normalizers": 1124, + "helpers": { + "1": 14, + "2": 8, + "3": 4, + "4": 107, + "5": 15, + "6": 3, + "7": 9, + "8": 38, + "9": 364 + }, + "main_adapters": 208, + "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width", + "recipe_payload_sha256": "a23e12ee3c504eef520021d6e6434ce7eae438b6a26d4c04ec9001087ac4f13f", + "wrong_phase_rejected": true + }, + "new_scratch_zero": { + "all_input_columns": 799, + "method": "Independent dense integer rows with binary exponents", + "obligations": [ + { + "count": 1, + "field": 781, + "frame": 127 + } + ], + "zero_owned_clear_sites": [ + 17822 + ] + }, + "physical": { + "central_square_columns": 53248, + "central_translations": 20, + "full_calls": 19, + "main_targets": { + "153": 208, + "17": 1872, + "25": 208, + "33": 832, + "57": 208, + "65": 208 + }, + "new_paid_jobs": 0, + "physical_contacts": 7904, + "ports": 104, + "route_payload_sha256": "b54aa59d89f556742b7129284c353f88816d02daf71ef327890746d2d19fa81f", + "tensor_rule": "Factorwise native maps; scalar signs stay outside the tensor power.", + "whole_idle_jobs": { + "16": 1872, + "24": 208, + "32": 832, + "56": 208, + "64": 208 + } + }, + "source_head": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "source_word_sha256": "9e31463a785c18a70f6ae6ef3d04a6560dbb965517109390fe820f9fac3371b3", + "status": "PASS_P104_CLEAN_PIGGYBACK_CONDITIONAL_003151787", + "tested": "0.003151792" +} diff --git a/research/clean-native-mixed-root/inputs/root-NOTICE b/research/clean-native-mixed-root/inputs/root-NOTICE new file mode 100644 index 0000000000..4e3b429712 --- /dev/null +++ b/research/clean-native-mixed-root/inputs/root-NOTICE @@ -0,0 +1,312 @@ +The final source additionally consumes PR6375 at +247b5c319b9f58fe9ee61dbf80697f8a9a429831. The shared-carrier input lifts +are by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. +Their exact notice is retained in lift-source.tar. Apache-2.0. + +Mixed root and PR6372 source composition + +New composition and complete checks: Ali Romman with substantial OpenAI +Codex assistance. No subagents. Apache-2.0. The mixed root, prior adapter +and source mechanisms retain their separate credit. + +Exact PR6372 source notice follows. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +No subagents. Apache-2.0. + +PR6353 supplies the word, joint basis construction and native transpose. +Exact head: db2a20bc50bc7a8a4db931af85ce7f012ae7c3c3. +The source files in inputs are unchanged. The complete predecessor notice follows. + +Joint native output contraction +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author checks. + +PR6349 supplies the exact native input-lift source. PR6348 supplies the fixed +binary query-tree caller and price engine. PR6350, by Ali Romman with OpenAI +Codex assistance, supplies the released composition control and its prior +conditional claim. Its source and caller are recounted here from main; no +pending PR6350 code is imported. Cinna Davis supplies the productive caller, +thin-query interface and exact Laurent factorization. + +The new result is the explicit nine-helper joint output contraction, its +literal forward word and complete conditional price. The input/departure basis +identity is elementary linear algebra. No new general linear algebra theorem, +native duality theorem or caller construction is claimed. + +The exact PR6349 and PR6348 notices follow. Their nested source archive retains +all earlier native, helper, recursion, compiler, BIT and analytic attribution. + +Native helper input lifting +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author checks. + +The direct source is PR6314 at 36533d4d1b4e2dd8672427461b12de3001b85810, +by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. +It compresses the scalar word of PR6167 without a kappa change. +The four native input lifts and their complete conditional price are new here. +The basis identity is elementary linear algebra; no new general theorem +for that identity is claimed. + +The PR6167 source notice follows unchanged. Its nested source archive also +retains the earlier notices. + +Retained-operand descent: Ali Romman, with substantial OpenAI Codex assistance. +Apache-2.0. + +The exact source word and price are from DreamingOfClouds, PR6144 and PR6143, +with Claude Opus 5.5 (Anthropic), via Claude Code. They extend PR6030 and PR5907. +The source reader is adapted from that work. The gzip portability controls +retain Douglas Colkitt and Maxime Fleury credit. + +The pinned PR5827 checker and all earlier source notices are retained below. + +Unread-register path resynthesis +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author-side. + +Mason Hale supplied PR5811, the complete two-block composition and the exact +role92 remapping and fourth accumulation. The earlier elementary accumulation, +retained-copy and second-block work is by Ali Romman. Joel Pulikkan supplied +R22. Dugongue supplied the concurrent baseline composition proof. Their source +notice and proof are retained byte for byte under inputs/pr5811-*. + +The source closure retains flyingviper, Cinna Davis, David Arias, Gareth +Davidson, Jacob Alan Sussman, zxv, Cao Yifan, Pierre-Loic Doulcet, thu-nmrc, +Scratch-net and all native/helper/controller/compiler/geometry/analytic +predecessors. The exact PR5786 source archive and its nested notices remain. +This package does not claim any predecessor construction as new. + +Exact PR5811 vendor/accumulated/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +Accumulated native updates +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. The same assistant made the construction and the author checks. + +Concurrent scope: Discussion5125 now tests retained copies in the transposed +supplier. That route uses the same source/destination duality. This package +claims the three fixed forward-supplier groups and their complete result, +not the elementary accumulation identity or the broader transposed search. + +Exact source: PR5786 at 6b936acd68a7e0f9062037900f0fe9bc4b6fdd25. +The complete predecessor notice follows unchanged. + +Asynchronous helper hubs +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Retained native copies from PR5774 at 7d6ec0cdef31d0c37b7d2563e709979caa0d5eae. +All prior credit follows unchanged. + +Paid intermediate meetings and collective helper splits. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. All checks are author-side calculations. + +The complete PR5718 notice follows unchanged. + +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The same assistant performed the construction and author-side checks. + +Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. +Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. +Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. +DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. +thu-nmrc: PR5551 contact improvements. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained source notices preserve earlier geometry, BIT and analytic credit. + +The elementary rank-one basis identity is not claimed as a new general +linear-algebra theorem. The contribution is its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + +New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices. + +Two-boundary main-assisted helper split and early cleanup: flyingviper with substantial +OpenAI Codex assistance, including independent AI review agents. Apache-2.0. + +Retained native-copy construction +Prepared by Ali Romman with substantial OpenAI Codex assistance. No subagents. +The paid-meeting source is PR5751 by Ali Romman with OpenAI Codex assistance. +The dimension-four span [265,194,164,75] is from Joel Pulikkan / GamingPuzzled +PR5739, with Claude Opus 5.5 assistance. The R22 block edits are not included. +The retained-copy mechanism, exact constructor, source-specific verification, +new price and proof are the contribution of this package. Apache-2.0. + +Exact PR5811 vendor/blocks/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +The second block is PR5796 at4b30391e633ba0c7c674f03586ae97d443e9bc9c, by Ali Romman with substantial OpenAI Codex assistance, following Joel Pulikkan/GamingPuzzled R22. Exact notice, plan, proof and source words are retained in source/SECOND-* unchanged. + +The final immediate source is PR5786 asynchronous helper hubs by Ali Romman with substantial OpenAI Codex assistance. Its three temporal helper splits and complete completion parameters are retained and credited. The earlier PR5774-only composition is a superseded checkpoint, not a separate contribution. + +New complete retained-copy and R22 composition: Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. + +The thirteen retained native conversions and changed helper targets are by Ali Romman with OpenAI Codex assistance in PR5774. The R22 block and rank-four basis are by Joel Pulikkan (GamingPuzzled), with Claude Opus5.5 assistance, in PR5739/5756. The complete source archive and R22 notice remain unchanged. + +The construction retains Ali Romman PR5751 paid intermediate meetings, flyingviper PR5718 boundary splits, Cinna Davis's productive controller, Jacob Alan Sussman's productive recursion, zxv and Cao Yifan's interval/compiler line, and every P104/native/BIT predecessor in the source notices. The source engines are reused under exact byte bindings, not claimed as new implementations. + +Binary query-tree caller + +New construction, proof and code: Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. No subagents. + +Cinna Davis supplies the productive path caller, query thinning and exact Laurent factorization. Ali Romman supplies the all-forward P104 binding in PR5544 and the retained-operand word in PR6167. The native word and interval/compiler lineage remain predecessor work. The new contribution is the four-field query extension, its tree composition, complete invoice and conditional price. + +The authenticated PR6167 notice follows. + +Retained-operand descent: Ali Romman, with substantial OpenAI Codex assistance. +Apache-2.0. + +The exact source word and price are from DreamingOfClouds, PR6144 and PR6143, +with Claude Opus 5.5 (Anthropic), via Claude Code. They extend PR6030 and PR5907. +The source reader is adapted from that work. The gzip portability controls +retain Douglas Colkitt and Maxime Fleury credit. + +The pinned PR5827 checker and all earlier source notices are retained below. + +Unread-register path resynthesis +Copyright 2026 Ali Romman. Apache-2.0. + +New construction, code, calculations and prose: Ali Romman with substantial +OpenAI Codex assistance. No subagents. All new checks are author-side. + +Mason Hale supplied PR5811, the complete two-block composition and the exact +role92 remapping and fourth accumulation. The earlier elementary accumulation, +retained-copy and second-block work is by Ali Romman. Joel Pulikkan supplied +R22. Dugongue supplied the concurrent baseline composition proof. Their source +notice and proof are retained byte for byte under inputs/pr5811-*. + +The source closure retains flyingviper, Cinna Davis, David Arias, Gareth +Davidson, Jacob Alan Sussman, zxv, Cao Yifan, Pierre-Loic Doulcet, thu-nmrc, +Scratch-net and all native/helper/controller/compiler/geometry/analytic +predecessors. The exact PR5786 source archive and its nested notices remain. +This package does not claim any predecessor construction as new. + +Exact PR5811 vendor/accumulated/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +Accumulated native updates +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. The same assistant made the construction and the author checks. + +Concurrent scope: Discussion5125 now tests retained copies in the transposed +supplier. That route uses the same source/destination duality. This package +claims the three fixed forward-supplier groups and their complete result, +not the elementary accumulation identity or the broader transposed search. + +Exact source: PR5786 at 6b936acd68a7e0f9062037900f0fe9bc4b6fdd25. +The complete predecessor notice follows unchanged. + +Asynchronous helper hubs +New work: Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Retained native copies from PR5774 at 7d6ec0cdef31d0c37b7d2563e709979caa0d5eae. +All prior credit follows unchanged. + +Paid intermediate meetings and collective helper splits. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. All checks are author-side calculations. + +The complete PR5718 notice follows unchanged. + +Four paid interior public-basis changes. +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No subagents. + +The following exact notice is retained from PR5660. + +New helper-subspace construction, proof and replay: +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +The same assistant performed the construction and author-side checks. + +Retained contributions: +flyingviper: PR5605 shared relay, PR5612 delayed relay, and the PR5608/PR5613 +relay/split compositions. +Scratch-net: PR5606 prepared-helper identities and target debit. +Pierre-Loic Doulcet (hexapode): PR5565 commuting-contact construction, used as the exact source. +Ali Romman: PR5602 fixed boundary relations, PR5601 three-contact frame +change, PR5580 contact step, +and PR5544/5545 complete P104 caller. +Joel Pulikkan (GamingPuzzled): PR5569 priced helper handoff. +DreamingOfClouds: PR5561 free helper endpoints and PR5568 search tools. +thu-nmrc: PR5551 contact improvements. +Gareth Davidson (bitplane): PR2305 source composition. +David Arias: PR2152 coalesced P104 word. +Cinna Davis: PR2219 private reuse and the controller lineage. +Jacob Alan Sussman: productive mixed-target recursion. +zxv and Cao Yifan: exact intervals, compiler and native/pricing lineage. +GamingPuzzled: PR5472 successor handoff, a predecessor to the split concept. +The retained source notices preserve earlier geometry, BIT and analytic credit. + +The elementary rank-one basis identity is not claimed as a new general +linear-algebra theorem. The contribution is its explicit independent-target +use on this P104 word and the complete conditional kappa improvement. + +New contribution: Ali Romman, with substantial OpenAI Codex assistance. +The four-gate source-version rewrite composes zxv PR5643 and Ali Romman PR5644. +The A2 method retains Chris R/Clear1nsight PR3998 and ToikY PR4019 credit. +The compensated triangle method retains Cinna Davis PR4692 credit. +No subagents were used for this contribution. Apache-2.0. + +Concurrent PR5650 by zxv publishes the PR5643/PR5644 composition. PR5651 by +Ali Romman corroborates it. This package credits that released composition +and contributes the further four-gate placement. + +New work: distributed scalar updates on an unobserved public field interval, the exact witness and complete conditional price. Prepared for Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. The source archive retains all predecessor notices. + +Two-boundary main-assisted helper split and early cleanup: flyingviper with substantial +OpenAI Codex assistance, including independent AI review agents. Apache-2.0. + +Retained native-copy construction +Prepared by Ali Romman with substantial OpenAI Codex assistance. No subagents. +The paid-meeting source is PR5751 by Ali Romman with OpenAI Codex assistance. +The dimension-four span [265,194,164,75] is from Joel Pulikkan / GamingPuzzled +PR5739, with Claude Opus 5.5 assistance. The R22 block edits are not included. +The retained-copy mechanism, exact constructor, source-specific verification, +new price and proof are the contribution of this package. Apache-2.0. + +Exact PR5811 vendor/blocks/NOTICE follows. Source head: +33d7760d0a6fea6394aefd014eea68f0af02a92e + +The second block is PR5796 at4b30391e633ba0c7c674f03586ae97d443e9bc9c, by Ali Romman with substantial OpenAI Codex assistance, following Joel Pulikkan/GamingPuzzled R22. Exact notice, plan, proof and source words are retained in source/SECOND-* unchanged. + +The final immediate source is PR5786 asynchronous helper hubs by Ali Romman with substantial OpenAI Codex assistance. Its three temporal helper splits and complete completion parameters are retained and credited. The earlier PR5774-only composition is a superseded checkpoint, not a separate contribution. + +New complete retained-copy and R22 composition: Ali Romman with substantial OpenAI Codex assistance. No subagents. Apache-2.0. + +The thirteen retained native conversions and changed helper targets are by Ali Romman with OpenAI Codex assistance in PR5774. The R22 block and rank-four basis are by Joel Pulikkan (GamingPuzzled), with Claude Opus5.5 assistance, in PR5739/5756. The complete source archive and R22 notice remain unchanged. + +The construction retains Ali Romman PR5751 paid intermediate meetings, flyingviper PR5718 boundary splits, Cinna Davis's productive controller, Jacob Alan Sussman's productive recursion, zxv and Cao Yifan's interval/compiler line, and every P104/native/BIT predecessor in the source notices. The source engines are reused under exact byte bindings, not claimed as new implementations. diff --git a/research/clean-native-mixed-root/inputs/root-proof.md b/research/clean-native-mixed-root/inputs/root-proof.md new file mode 100644 index 0000000000..49a3bb14e2 --- /dev/null +++ b/research/clean-native-mixed-root/inputs/root-proof.md @@ -0,0 +1,153 @@ +# Complete composition with the contact and shared-carrier sources + +The conditional claim is kappa 0.00328621476572836015146308. The final source is PR6375 at +`247b5c319b9f58fe9ee61dbf80697f8a9a429831`. It uses PR6372 at +`b556600ffe14be72406b03a47c661f3c7f1aff06`. The root and all four binary +children remain unchanged. This proof retains the five assumptions +native_all_columns, owned_erasure, compiler, precision_tape and +analytic_recovery. It does not establish an unconditional theorem. + +## Source reconstruction and interface + +The complete retained PR6353 word and basis constructor are byte-equal +to the two inputs retained by PR6372. The new constructor rebuilds the +published PR6372 word and rational witness. The only changed public +output frames are helpers 224 and 227. Both move to frame 245. The main +interface, native frames and caller word stay unchanged. + +Next, the exact shared-carrier constructor and LIFTS.json from PR6375 +rebuild its published word from the authenticated PR6372 input. Only six +initial frames change: helpers 520 and 655 start at frame 106, while +544, 671, 472 and 624 start at frame 105. Their first-destination delivery +and final restoration use three shared carrier rows. The complete final +frames are unchanged. This source construction is by DreamingOfClouds, +with Claude Opus 5.5 assistance. The replay checks every changed input. +No new owned label or lifetime is added by these lifts. + +The source has 770 independent public inputs, 29 owned labels, 43 owned +lifetimes and peak ownership 13. Both lifetimes added by PR6372 are charged. +The replay checks all 799 scalar columns and 638,401 separate reverse +coefficients, absolute native phases and all 7,488 caller contacts. +The 562 independent helpers at each native call remain separate from +every other call and from the caller's main fields. + +The six-field root, whole-field normalization, all paired and individual +idles and every one of the 570 caller events are replayed. No old physical +receipt is substituted for the new source check. The unchanged binary +module is also checked from its exact retained bytes. + +## Signed change and complete bill + +Write H(r)=r^(1-kappa). At one native call, PR6372 changes the paid bill by + +```text +2H4-2H5 +``` + +and the productive helper bill by + +```text +2H8-2H9. +``` + +Their signed margin change is + +```text +2[(H5-H4)-(H9-H8)] > 0 +``` + +for every strictly concave power tariff. The construction and this source +gain belong to PR6372. The present contribution binds them to the mixed +root and checks the complete result. There are exactly 18 copies of both +changes. Omitting either productive debit is rejected. + +The shared-carrier step then changes the per-call paid bill by +6H1-3H3+3H4-3H5 and the productive bill by 6H8-6H9. Both changes +occur at all 18 calls. Unlike the contact contraction, this source change +is not positive for every concave tariff. Its signed gain is zero at +linear cost and negative for some smaller powers. The two interval +engines check the actual exponent used here. All six entrance reversions, +a missing delivery, a missing restoration and a wrong response sign are +rejected. These lifts receive their source credit; they are not a new +root construction. + +The complete caller has 67,150 paid jobs and 13,652 productive fields. +Paid rank mass is 184,980 and productive rank mass is 185,740. Their +difference is 760. All 17 thin queries, 14 paired whole idles, two +individual whole idles and 20 ordinary normalizations remain charged. + +Two rational moment engines check the tested saving +0.003286214765728360151463085 and both endpoints of the strict raw bracket +`(0.00328621476572836015146309, 0.00328621476572836015146310)`. The native word has 17,768 events. +Both earlier sources, PR6353 and PR6372, have a strictly negative +margin with this caller at the new claim. Completion, the compiler integer grid, ordinary work, all 54 +strict and four functional outer conditions are recomputed. The BIT +admission remains 0.0034. `RESULT.json` records the exact crossing and +all completion and compiler parameters. +The source ordinary allowance is 129,670 scalar units plus 5,379,000 +route units. It is below the retained 10^7 local budget. The complete +caller ordinary bound remains 248,152,864, below 10^9. The compiler +logarithm power is 2100. `RESULT.json` gives its exact threshold. These +large constants do not establish a practical speedup. + +The price and ceiling programs are exact declared adaptations of the +preceding composition. `PRICING-EDITS.json` and `CEILING-EDITS.json` list +every permitted edit. All old source bytes are authenticated before use. +No interval inequality or native check is weakened. + +## What is now maximized + +The [exact optimum proof](OPTIMALITY.md) identifies the raw family limit +as the unique zero of the complete signed invoice. All alternative child +size profiles lose at the lower bracket endpoint. All 11 seven-leaf tree +histograms are compared across the bracket. The all-size tail excludes +all larger totals. Thus the 7,2,2,7 profile attains the largest raw crossing +in the stated family, not merely the best point found in a bounded search. + +The complete conditional claim is between 1e-26 and 2e-26 below that +crossing. Completion uses power 1920, reserve 1e-29 and the exact tail +4*(31/32)^1920. The older block bound is too loose at this precision. +The source, caller and signed bill are unchanged. At the raw crossing, +paid and productive moments are equal; this strict funding argument does +not certify equality. More digits are not a new construction gain. + +The separate `mixed-projector-root-headroom` proof shows that every +six-field, seven-query root in its stated class has this same priced +output pattern. The class requires S on all six outputs, scalar bases +independent of S and all stage variables, four independent forward full +stages at distinct sites, and at most two extra whole idles. Its argument +does not depend on the native profile. The recalculated ceiling therefore +applies to that whole family with PR6375 as the fixed source. + +This does not maximize all possible callers or integer-multiplication +algorithms. More idles, changed query counts or field counts, coupled +queries, changed child contracts and changed sources remain outside the +ceiling. Variable-dependent bases and mixed central endpoints are also +outside this classification. The last source composition added +0.00000036, or 0.0109561 percent, +over the preceding local 0.00328584 result. This parameter refinement adds +about 0.000449325 percent over 0.00328620 with the same invoice. The full +mixed-root contribution is about 4.28455 percent above PR6375's published +complete claim. These are different comparisons. + +## Verification and attribution + +The registered replay reconstructs the source, checks its arbitrary +inputs and all phases, replays the caller and both prices, and checks +every compiler and outer condition. It also rejects omitted source +operations, both missing target debits, damaged retained files and +incorrect paid or productive counts. These checks remain active under +optimized Python. The separate headroom package checks the formal caller +again by reverse output functionals at all four central characters. + +All checks are author checks. Independent scientific review, formal-kernel +acceptance and the five framework assumptions remain open. The selected +frontier is unchanged. The separate [PR6376 scalar audit](https://github.com/CrocSwap/integer-mult-bounds/pull/6376) +checks the earlier PR6372 boundary only. Its forward CLEAR rows are +nonzero; neither that audit nor this composition discharges the inherited +owned_erasure premise. + +The root, binary query module, source contractions and native/compiler/BIT +engines retain their predecessor credit. The exact PR6372 and PR6375 notices and all +prior source notices are retained in the two source archives. New composition: Ali Romman with +substantial OpenAI Codex assistance; no subagents. Apache-2.0. diff --git a/research/clean-native-mixed-root/inputs/root-result.json b/research/clean-native-mixed-root/inputs/root-result.json new file mode 100644 index 0000000000..be12d2101b --- /dev/null +++ b/research/clean-native-mixed-root/inputs/root-result.json @@ -0,0 +1,498 @@ +{ + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "binary": { + "coefficients": 16, + "identity": "L S A B Idle S^-1 C R = D_A D_B (U(q) direct-sum q direct-sum q^-1)", + "missing_idle_rejected": true, + "variables": [ + "q", + "D_A", + "D_B" + ] + }, + "caller": { + "coefficients": 1156, + "event_sha256": "be648c29aa09c0f068a3b5b5120d1eb1f782e49f4523b4c6d62843750517bdea", + "events": 570, + "inputs": 34, + "native_stages": 18 + }, + "columns": { + "arithmetic": "Dense integer rows with binary denominators; reverse chronology", + "coefficients": 638401, + "columns": 799 + }, + "contact_source_head": "b556600ffe14be72406b03a47c661f3c7f1aff06", + "controls": { + "damaged_research/p104-contact-block-contraction/BASIS.json": "Exact source SHA256: research/p104-contact-block-contraction/BASIS.json", + "damaged_research/p104-contact-block-contraction/NOTICE": "Exact source SHA256: research/p104-contact-block-contraction/NOTICE", + "damaged_research/p104-contact-block-contraction/PROOF.md": "Exact source SHA256: research/p104-contact-block-contraction/PROOF.md", + "damaged_research/p104-contact-block-contraction/RESULT.json": "Exact source SHA256: research/p104-contact-block-contraction/RESULT.json", + "damaged_research/p104-contact-block-contraction/WORD.json.gz": "Exact source SHA256: research/p104-contact-block-contraction/WORD.json.gz", + "damaged_research/p104-contact-block-contraction/construct.py": "Exact source SHA256: research/p104-contact-block-contraction/construct.py", + "damaged_research/p104-contact-block-contraction/inputs/pr6353-WORD.json.gz": "Exact source SHA256: research/p104-contact-block-contraction/inputs/pr6353-WORD.json.gz", + "damaged_research/p104-contact-block-contraction/inputs/pr6353-construct.py": "Exact source SHA256: research/p104-contact-block-contraction/inputs/pr6353-construct.py", + "damaged_research/p104-shared-carrier-lifts/LIFTS.json": "Exact source SHA256: research/p104-shared-carrier-lifts/LIFTS.json", + "damaged_research/p104-shared-carrier-lifts/NOTICE": "Exact source SHA256: research/p104-shared-carrier-lifts/NOTICE", + "damaged_research/p104-shared-carrier-lifts/PROOF.md": "Exact source SHA256: research/p104-shared-carrier-lifts/PROOF.md", + "damaged_research/p104-shared-carrier-lifts/RESULT.json": "Exact source SHA256: research/p104-shared-carrier-lifts/RESULT.json", + "damaged_research/p104-shared-carrier-lifts/WORD.json.gz": "Exact source SHA256: research/p104-shared-carrier-lifts/WORD.json.gz", + "damaged_research/p104-shared-carrier-lifts/construct.py": "Exact source SHA256: research/p104-shared-carrier-lifts/construct.py", + "damaged_research/p104-shared-carrier-lifts/inputs/pr6372-WORD.json.gz": "Exact source SHA256: research/p104-shared-carrier-lifts/inputs/pr6372-WORD.json.gz", + "first_lift_delivery": "All public and owned rows", + "last_lift_restore": "All public and owned rows", + "lift_response_sign": "All public and owned rows", + "missing_departure_basis": "All public and owned rows", + "missing_departure_inverse": "All public and owned rows", + "missing_idle": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_idle_one": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_input_basis": "All public and owned rows", + "missing_input_correction": "All public and owned rows", + "missing_lambda": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_local": "Every native stage exactly once", + "missing_native_move": "Scalar destination and coefficient", + "missing_output_basis": "All public and owned rows", + "missing_output_correction": "All public and owned rows", + "missing_productive_debit": "All source helper targets have native maps", + "missing_q_power": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_query": "Every Q(i)[Q,D]/(Q^4-1) endpoint coefficient", + "missing_response": "All public and owned rows", + "missing_target_224": "All public and owned exits", + "missing_target_227": "All public and owned exits", + "missing_temporary_clear": "Scalar destination and coefficient", + "old_entrance_472": "Common scalar chart", + "old_entrance_520": "Common scalar chart", + "old_entrance_544": "Common scalar chart", + "old_entrance_624": "Common scalar chart", + "old_entrance_655": "Common scalar chart", + "old_entrance_671": "Common scalar chart", + "unpaid_native_move": "All independent fields and paid calls" + }, + "fixed_root_ceiling": { + "admitted_saving_cap": "17/5000", + "binary_split_checks": 4851, + "ceiling": "32862147657283601514631/10000000000000000000000000", + "finite_margin_upper": "-6527039332418184339015402951951839525/326409290240107399719461050006798653637322483112129794670592", + "finite_pair_checks": 4656, + "first_tail_total": 100, + "native_derivative_lower": "86090083256538702783244087644124346134578003527805299758509044352709856725086450055486661885342093126567137211366659267/2048904322212512919038510085207467917864146442064203226733311257020777532117854951793541845254015613321944655495954432", + "scope": "All positive integer child sizes and all binary tree shapes for this fixed root and PR6375 source.", + "tail_derivative_upper": "-215612333462792056547397343938407895404584315871663362184364306687376197353445352058659/3640381612305997808933701691778949109269500656184000075624611840000000000000000000000000", + "tail_margin_upper": "-302669528663079740144033662430286325431402316858105929255045/163204645120053699859730525003399326818661241556064897335296" + }, + "gain_over_pr6375": "3375369143209003786577/25000000000000000000000000", + "immediate_source_margin_upper": "-259918532464632736108796703442815743985223955544406661797/3138550867693340381917894711603833208051177722232017256448", + "lift_paid_delta": { + "1": 6, + "3": -3, + "4": 3, + "5": -3 + }, + "lift_target_delta": { + "8": 6, + "9": -6 + }, + "local": { + "endpoint_coefficients": 638401, + "helpers": { + "1": 14, + "2": 8, + "3": 4, + "4": 107, + "5": 15, + "6": 3, + "7": 9, + "8": 38, + "9": 364 + }, + "owned_fields": 29, + "owned_lifetimes": 43, + "paid": { + "1": 2237, + "2": 453, + "3": 491, + "4": 109, + "5": 151, + "6": 8, + "7": 9, + "8": 1 + }, + "paid_rank_mass": 5926, + "peak_owned_fields": 13, + "public_inputs": 770, + "real_scalar_allowance": 129670 + }, + "native": { + "distinct_maps": 2941, + "helper_normalizers": 1124, + "helpers": { + "1": 14, + "2": 8, + "3": 4, + "4": 107, + "5": 15, + "6": 3, + "7": 9, + "8": 38, + "9": 364 + }, + "main_adapters": 208, + "proof": "Every signed Pauli image and exact global phase; frame induction at every positive tensor width", + "recipe_payload_sha256": "cc31dd00f0db04d7fdb4f860c264ec534fe4790f7adb8fd02fd93f1a8a2059e0", + "wrong_phase_rejected": true + }, + "native_events": 17768, + "paid_delta": { + "1": 6, + "3": -3, + "4": 5, + "5": -5 + }, + "physical": { + "central_square_columns": 53248, + "central_translations": 16, + "full_calls": 18, + "main_targets": { + "1": 104, + "145": 104, + "17": 1872, + "25": 416, + "33": 416, + "57": 416, + "73": 208 + }, + "new_paid_jobs": 0, + "ordinary_normalizations": 20, + "physical_contacts": 7488, + "ports": 104, + "route_payload_sha256": "79930ec6c09a8e4930556c925c354bb5431203eaf069d9373f056049c061289b", + "tensor_rule": "Factorwise native maps; scalar signs stay outside the tensor power.", + "whole_idle_jobs": { + "16": 1872, + "24": 416, + "32": 416, + "56": 416 + } + }, + "price": { + "compiler": { + "H": 317427600000000000000000000000000, + "N": "2^317427600000000000000000000000000", + "eta": { + "lower": "0.000000000000022979952894151607", + "upper": "0.000000000000022979952894151608" + }, + "gap": "1/1400000000000000000000000000", + "integer_test_exponent": 226734, + "logarithm_power": 2100, + "theta": "63/64", + "uniform_saving": "2300350336009852106024159/700000000000000000000000000", + "word_materialized": false + }, + "derivative_upper": "-177683760993455684326832397037859249221501509146420924227601237/784637716923335095479473677900958302012794430558004314112", + "full_forward_calls": 18, + "gain": "369143209003786577/25000000000000000000000000", + "kappa": "82155369143209003786577/25000000000000000000000000", + "kappa_decimal": "0.00328621476572836015146308", + "margin_at_previous": { + "lower": "0.003392307759472651826068180441", + "upper": "0.003392307759472651826068180442" + }, + "negative_controls": { + "coarse_tail": "The block tail bound cannot fund this near-limit claim.", + "old_BIT": "An outer inequality fails at BIT saving0.0027.", + "old_completion": "Cutoff16 and floor17 give a ratio above one." + }, + "nonrecursive": { + "local_routes": 5379000, + "local_scalar": 129670, + "paid_rank_mass": 184980, + "peak_owned_fields": 13, + "raw_budget": 1000000000, + "raw_scalar_upper": 248152864, + "scalar_growth_bound": "At most 2^(10^9 + R*f), where R is the full paid rank mass." + }, + "ordinary_BIT": { + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "before_cover": "3459/1000000", + "ordinary_saving": "8590884599/2500000000000", + "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "348599999999999999999999999253/350000000000000000000000000000", + "fixed_halo_explicit_metadata_branch": "26950000000000000000000000001/350000000000000000000000000", + "new_BIT_row_stock_sublinear_in_active_group": "1395799999999999999999999997009/1400000000000000000000000000000", + "new_semantic_group_guard": "3/1400000000000000000000000000" + }, + "margins": { + "boundary_algebraic_matrix": "1288196188165517179373528479079859865596059157590337/392000000000000000000000000000000000000000000000000000", + "fused_gaussian": "1288196188165517179373528477239579596788177472771011/392000000000000000000000000000000000000000000000000000", + "global_coordinate_router": "1150175168004926053012079/350000000000000000000000000", + "group_bit_router": "1610245235206896474216910946549474495985221840963763/490000000000000000000000000000000000000000000000000000", + "group_scans": "699999999999999999999999999/700000000000000000000000000", + "main_transform": "1288196188165517179373528199079859865596059157590337/392000000000000000000000000000000000000000000000000000", + "microbox_face_corrections": "26950000000000000000000000001/350000000000000000000000000", + "polynomial_products": "1399999999999999999999999999/1400000000000000000000000000", + "sparse_union_movement": "160538196188165517179373528479079859865596059157590337/392000000000000000000000000000000000000000000000000000" + }, + "parameters": { + "a": "1150175168004926053012079/350000000000000000000000000", + "b": "4600700672019704212048317/1400000000000000000000000000", + "beta": "1399999999999999999999999997/1400000000000000000000000000", + "bit_saving": "17/5000", + "cap_xi": "356538196188165517179373528199079859865596059157590337/392000000000000000000000000000000000000000000000000000", + "complex_uniform_saving": "2300350336009852106024159/700000000000000000000000000", + "d": "1/1400000000000000000000000000", + "epsilon": "1399999999999999999999999999/1400000000000000000000000000", + "kappa": "82155369143209003786577/25000000000000000000000000", + "lambda_": "398685514093708655939414767/400000000000000000000000000", + "lambda_prime": "279079859865596059157590337/280000000000000000000000000", + "layout": "1/1400000000000000000000000000", + "q": "920140134403940842409663/280000000000000000000000000", + "r0": "1/14000000000000000000000000000", + "stop": "1/1400000000000000000000000000", + "tested_saving": "657242953145672030292617/200000000000000000000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "39824831995073946987921/350000000000000000000000000", + "actual_logarithmic_gamma_guard": "1/1400000000000000000000000000", + "actual_logarithmic_group_guard": "35461803811834482820626472220920140134403940842409663/196000000000000000000000000000000000000000000000000000", + "alpha_logarithm_absorption": "1/14000000000000000000000000000", + "boundary_algebraic_matrix_above_kappa": "1119079859865596059157590337/392000000000000000000000000000000000000000000000000000", + "cap_above_band": "160538196188165517179373528199079859865596059157590337/392000000000000000000000000000000000000000000000000000", + "cap_below_cell": "35461803811834482820626471520920140134403940842409663/392000000000000000000000000000000000000000000000000000", + "cap_below_phase_cell_power": "427461803811834482820626471800920140134403940842409663/392000000000000000000000000000000000000000000000000000", + "complex_above_effective": "1/1400000000000000000000000000", + "complex_below_one_over_32": "39149299327980295787951683/1400000000000000000000000000", + "complex_endpoint": "1/700000000000000000000000000", + "epsilon_below_one": "1/1400000000000000000000000000", + "epsilon_positive": "1399999999999999999999999999/1400000000000000000000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "1117239579596788177472771011/392000000000000000000000000000000000000000000000000000", + "gaussian_above_main": "139079859865596059157590337/196000000000000000000000000000000000000000000000000000", + "global_coordinate_router_above_kappa": "1/350000000000000000000000000", + "global_gamma_power_slack": "9/14000000000000000000000000000", + "group_below_dimension": "1/700000000000000000000000000", + "group_bit_router_above_kappa": "1746549474495985221840963763/490000000000000000000000000000000000000000000000000000", + "group_gauge_power_slack": "35461803811834482820626472206920140134403940842409663/196000000000000000000000000000000000000000000000000000", + "group_key_fits_record": "1/700000000000000000000000000", + "group_positive": "1399999999999999999999999997/1400000000000000000000000000", + "group_scans_above_kappa": "697699649663990147893975843/700000000000000000000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "38881108663229911218127/25000000000000000000000000", + "lambda_above_internal": "1/2800000000000000000000000000", + "lambda_above_sigma": "3/2800000000000000000000000000", + "lambda_above_tau": "1/2800000000000000000000000000", + "lambda_prime_above_lambda": "1/2800000000000000000000000000", + "lambda_prime_above_leaf": "2795399299327980295787951683/1960000000000000000000000000000000000000000000000000000", + "leaf_saving_above_effective": "1395399299327980295787951683/1960000000000000000000000000000000000000000000000000000", + "main_transform_above_kappa": "839079859865596059157590337/392000000000000000000000000000000000000000000000000000", + "membership_arithmetic_fits_record": "1/1400000000000000000000000000", + "microbox_face_corrections_above_kappa": "26948849824831995073946987923/350000000000000000000000000", + "microbox_halo_volume": "110600000000000000000000000003/1400000000000000000000000000", + "new_complex_uniform_saving_above_b": "1/1400000000000000000000000000", + "new_semantic_guard_with_C1_one": "1/1400000000000000000000000000", + "polynomial_products_above_kappa": "1395399299327980295787951687/1400000000000000000000000000", + "positive_layout_slack": "1/1400000000000000000000000000", + "q_below_effective": "1/1400000000000000000000000000", + "q_below_internal": "1/1400000000000000000000000000", + "q_below_leaf": "2795399299327980295787951683/1960000000000000000000000000000000000000000000000000000", + "q_positive": "920140134403940842409663/280000000000000000000000000", + "short_record_fallback": "1395399299327980295787951683/1400000000000000000000000000", + "source_axis_superpolynomial": "1/1400000000000000000000000000", + "sparse_union_movement_above_kappa": "159250000000000000000000001119079859865596059157590337/392000000000000000000000000000000000000000000000000000", + "stop_below_one": "1399999999999999999999999999/1400000000000000000000000000", + "stop_positive": "1/1400000000000000000000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/1400000000000000000000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/1400000000000000000000000000", + "union_tag_work_per_visit_fits_record": "3/1400000000000000000000000000" + } + }, + "paid": { + "1": 42034, + "16": 1872, + "2": 8154, + "24": 416, + "3": 8838, + "32": 416, + "4": 1962, + "5": 2718, + "56": 416, + "6": 144, + "7": 162, + "8": 18 + }, + "paid_calls": 67150, + "previous_fixed_root": "16431/5000000", + "productive_fields": 13652, + "rank_mass_surplus": 760, + "raw_endpoint_margins": { + "lower": { + "first": { + "lower": "0.000000000000000000000217785079", + "upper": "0.000000000000000000000217785080" + }, + "second": { + "lower": "0.000000000000000000000217785079", + "upper": "0.000000000000000000000217785080" + } + }, + "upper": { + "first": { + "lower": "-0.000000000000000000002079634713", + "upper": "-0.000000000000000000002079634712" + }, + "second": { + "lower": "-0.000000000000000000002079634713", + "upper": "-0.000000000000000000002079634712" + } + } + }, + "raw_headroom": [ + "1/100000000000000000000000000", + "1/50000000000000000000000000" + ], + "raw_root_interval": [ + "328621476572836015146309/100000000000000000000000000", + "32862147657283601514631/10000000000000000000000000" + ], + "refinement_kind": "Same complete invoice; finer strictification and compiler parameters.", + "relative_gain_percent": "369143209003786577/821550000000000000000", + "strictification": { + "alpha": { + "lower": "0.999999999999999999999999992569", + "upper": "0.999999999999999999999999992570" + }, + "coarse_tail_upper": "1/288230376151711744", + "cutoff": 12, + "delta": { + "lower": "0.957248382250720020032251696120", + "upper": "0.957248382250720020032251696121" + }, + "exact_tail_upper": "25968816751883113995464804882194607929411683780884226645678925307002110843550133104420123760101479474839221201004686329940160027670126004133743828536680673994452725629745611397250341115761363323607003552687034005960488068717359911143395851784415362067355137094922219194655890106807315973377901994681558011665956719293922523423896736235903448997789236780141543787761778864696595800906890151999691226382701024017325569269316595526470733042482962997961321816289689038860231064735268262348181833735526073481800371738520564423855188853455070167523225315015758774805697502433771984614850668873883495604089682521242370834384375582830712704865727861176177048771394427407255002047824069363883041195805737568221434593424664912374095681332409910102117819689183603716909776665801384439952751837667700413070379263323130466094707734337887831258005980440847552037834301818581649745499092009029235117704964733313829410497453470070887466638307413753043426496924817422338541543232280481901189410625113352540990925659205592694157405025696376596135904922863017205099824220302784597597394276398809139342815771451800330237414693097687353116020292427829621137741888194987614319546272900374357630911060621372780363425799229823027419399322430473329066822665185057155378959634917707139348139444417502434894646589809020275954413976196338353104990927739225086991331116260532892993604070852131850799788364871935788080589906984695519250577337599768456831251607249423700889021932369256023863626543373232166438214597277750913930476188423662975734340573982417743812475341013829410134208659166050139798547596876083645842576454904158460099622845601362359202659966547393643799328843973215865146723977900950651432448361170601246192090126412244869008028749978164391847944132606805504798364996996014218459024410664453957811779516913670216928724470380796391020353614030246272618410655142564538377734059025000305119155917226445867387899027040451866939956717377831530119449900953585057952699220008085352148706159738644321313531284032818479141559396247029143750425762501948430437369399481810562584909868262778814839240692102964314788286773148559517247633145270422345099190454145942630831266195509922086728349392801157236390281356642879102356486891062424937470616665957496696759574300833108099958404347149016512657584919622710050001356487455986180867964952023672761039188124022692190974214751766725701356295495524587296011840901864611875504808599874948117351460747134887391055383954183357815228423956967508253485665094444536753140118928942192591489028112227793683148117180821470944630106089051895287977293005179296095836333159834273766684727267011939930469961979884670796085309878886992937168024435902854601180811049624073160626754017381247943964404431354002824473361814782176441811959489344592309505051971888333364522225539320640095711622097910757473509357949732179456944382304691192060425703256673043353601/1931516324011626346020150553929126181823590488535040186824856567180029479223493376445786096950954795100702784533083281033646760271068018983122291972202644881704691011563710483989867650744695251376055025107666230739164093587389628866535770117611912392089755082590080472028477987071289165684289011377905352698232800507758208042820675070709030399021754206793830358905406733535942588887996076001927509337965834979072536427646331464401971792582375342958569384054354332096896759837269698218889565287567707539585095032991822857620010464317015726455734074643321122388044097708028635229432698100703335425310388288440000351711930613276786493722293418289870150700918405798037757934100708219508469592822795997483826085672921016197325327430119841909503482096760772795264133044082205866449934298354644012164798932775556083457809449912592220889802005953323685819720454613153020534455067493961231922206456679179219662713499049824991117775198073492812006682664088284693545727589314279309950009246830913459976142947529615742696134568887882410861948007763929800878314246201090904986140186077798864508547948608132255423035988434446214058699770626557465193128157512845357439793247851632224246499990611115646221003615087011758590423628181610786764420573006921761893949737802418426782447136548014140198447242737897751623530788833864390071832506056728849302290191408954510946220861486311039370054837095614883730158737099345289640173098512240742485291913040000974074836991713791813260339229632451698438087840996110693416312325768841145996367942811788448367825625035192908389092377054549306070546491079416016630873092882144703817485287986047453762937574793229088607594726623087172119290857442922186749727030568744100000419699941602816789656590538128654775884335322288115044042902368007647928447785494309683729219830178145535848830929931533192822883913681010006628877851664234722515418098809600795075237161618710226944692109669822041946629850162941173319519204709693533513108874099949758590208958136931346480022816743599142611017726137114510998217900038246478615246956350952278485410366122587953267937544436255099465307497011848059680873269896755574862120101016159541436240691657472394148008527677335225016052476207952397501417607437147877605303564057067564064530504494183216739444916912001687735183605267399161590281721705618193211199161475332334316832897783160549981482614788840809957569982115145402182575160480094711317055554905021931999461941405791251356057108718863869053217661463840775172788114991998596171377364481496742568202736663003363999728620841731079859176245940071187874843669264882594126717901436208421673886795099603467547525863026278936933835810347290598467230778790873267966902348777280946055188109006665306325326165168038148974262863542508287344559517219458554951908638902157539612839480289421087336446182774503962079866786903470546386259662184092799534574936219344193317288975481261643484673081344", + "floor": 13, + "gamma": { + "lower": "0.924056325562645239412345490543", + "upper": "0.924056325562645239412345490544" + }, + "normalized_paid_upper": "301799425626816616565648528109053583391672575624975869940741583241797183286245900040809945102717848691873044685714521183696004886382003883466377478245092103887149130513292792459855142440109413906745988535460631248884298173458126368768624796293092869362168408912319796533556160583862533407322260438866742613153280686291990643354490224551943523228527424469436028309041589787129548101074311423426114310610596031813033352108087503397245815968572344741673665372616954254810895105816503554164534346982552051911285959875500423372269822385628835948047846968612629126601819504076701291377728006835633485157565813415491483591792647779464628140235411130837708133364924768325881139107648021966692253445739473110504978176401317390484720917763472170087399053284025621752849515588491115354784312114796037285675219539609263405190913495242614266526211760606148610764084636759992186514237315506545921016082951398642312212707669421504838229936571461184333857636630398207131411209275958949082326107455705488444588407064614885594862057760009464516285110015266189625072421731933680573645919460633395409485478933665135896635962123550978028198469956423067761387237891161248504060152572651764417043315553904788275940972822138283460482007536285039454333744430731010515968501887788002878120512905009639562367117756114778018290345960701258650801580441748371168100479507364802657842858038646646132252116044115722627476253140838312498329226086525341379050630911210225440926822289249592206382470693285625307402300632605045915432124015120531477460701485675348813313885703492348411977021656461528309955456511882087030695278147846402385996123408872905124876546080259052247878909372748370715537990123188801158439727097722818570075649321843091996462220691948638857990271688415748735990268957977072732719576542723594407150217919974318537795754697935266273409814901132885468100151160477578371433469178015962157592357715183237537996405238471421253995257942319696663713231624595453865406519280636797623587967147499366372116604250177877350232354938419461919717913462777631887824492739295756328953000703580767618425429227902317519621684672164305220954227395374311394390766662610551662776418938907121788829304328236007254754887896625047228575905877802078036326720030589592784430857735637288740857800323458560625645576814021888519238251618574786255511355740282166374757739907368509692374989841088063538310820616230807172142631730012542741650950755936921860148020466043114790367272167323847793817214080973216016280043001603197094102740357442482718512416184262618729170472760291383183945838246607207075883495104473031191009853310272431836128093864425961960285207680233006875526939005517015421666422110223408105807078082966354186873810127771992121166952364000079535481712545174594176912418033247014664164087923589259194684161501915740939750272298890913108985116073608319238085545414021966707796667664104685841899011057001636482790107033732431277109770019130060803/301799425626816616565648529845974937944815051894051690978762384092651071733791400544223779188675124404964939420652553514371691594462731565362701221596944075970414919923705679731351465542931667718640049642675800787080143751194704833394906298369142073432910831262010426590186861749154179908411574113231672572966372132204254140406788574496687523121773223273561205706060999180253649895240463591521373941884928379468311822602267305210313029808605430276270859464408242137266147600281542509764490866872733814869265755573668184206249253804818806234177022023050318324179069634081698184562226242367189284290653858366844357064995434255662754964109401743584050877377982072823654546813687762053415767991835676908972484411802687249220074862434482317122967669594853039619546516648290956915120619910312259147367432595983533104214763043239332840699813803635175647107983702711177318479661755092806327303820459486955554182679993154524899690033687123749025519139617120077586998371850404134444543025454512996064110265401530200289011406317160469286026604301517738050883833554764477195873806709598811182733331928441223143245966718526066771068605429507569239764916787481398979640090556202007577051695852366563276928487596845559113100630566387530692975990303602409840762006824889598205522650767476422813262662025137933335219106350633039162417083941956249205076012623146660505533557514106674128434601134852410041770420781937212793121697833013827311362730333019447735915507411155709941930926854581553022326664936659984743653896215644952050264571313278922363996191900852720371161029018250204179101614398435883762221838974474583209730126140439193296893107513897909053079037323670095023326462298240771548906364884238837953832138365056531829616142272841702133540377763077289590017667822654200955684311615614595186713542250678596459308883989461551913012219059150603330361742791188416436064097825633679223209974049177769388910527361621178910291594922035887340641001575779165100246781536674763908800750248222145187352840886814240443765559148992592574268974714029190694975869924489993628084805552395236750972076774395957659218156211913892633901746817290549607750444826394738039679332657840364634104956758305703881175381851518145141602176210211784499685874388169629196526524143126819786740960461091777191172088541365869734486582222053658491447353751365842353859719912216320360603661511255069905351959649939313457549798697724744988726137001635158315200062295821547739449719235708303756939013671896447277339750127152765043300038718598211002277466117726369069447824711128691217006380427321985630637562900166643152513235723938573681192594114466746112926181119516469194722248009341745089341619987581379161700287398142484193742945932998500445175051473070287797224491404495415401701871488328989838760586862140667222881833650947961602792334897034684943242447463005821196364958455864860637688972943051516758104801022671940452512748911866926443784930454019244032", + "power": 1920, + "reserve": "1/100000000000000000000000000000", + "tail_decay": "31/32", + "tail_offset": "1/7", + "tested": "657242953145672030292617/200000000000000000000000000" + }, + "targets": { + "1": 356, + "145": 104, + "17": 1872, + "2": 144, + "25": 416, + "3": 72, + "33": 416, + "4": 1926, + "5": 270, + "57": 416, + "6": 54, + "7": 162, + "73": 208, + "8": 684, + "9": 6552 + }, + "thin_queries": 17, + "whole_idle_jobs": 3120 + }, + "prior_source_margin_upper": "-494431738852733860160625375187485047155589466552987117427/3138550867693340381917894711603833208051177722232017256448", + "raw_optimality": { + "certified_kappa_distance_upper": "1/50000000000000000000000000", + "lower_endpoint_tail_derivative_upper": "-2425638751456410636158155864644325160477772930092507518372866628520074812349834450754483/40954293138442475350504144032513177479281882382070000850776883200000000000000000000000000", + "lower_endpoint_tail_margin_upper": "-151334764331539870072005260405846188849785275992960950294577/81602322560026849929865262501699663409330620778032448667648", + "minimum_alternative_tree_cost_gap": "2235851046446919124101317406304064312790521250945764685/1569275433846670190958947355801916604025588861116008628224", + "minimum_size_profile_margin_gap": "14472794033883433065907589746016340854280764262874989079/326409290240107399719461050006798653637322483112129794670592", + "other_nine_leaf_split_margin_upper": "-3618198508470858268108657269608631298324041803724885069/81602322560026849929865262501699663409330620778032448667648", + "other_pair_total_checks": 4655, + "other_pair_total_margin_upper": "-164318042130818734205658871801729589939366105662110267847/163204645120053699859730525003399326818661241556064897335296", + "other_size_profile_margin_upper_on_bracket": "-3618198508470858268108657269608631298324041803724885069/81602322560026849929865262501699663409330620778032448667648", + "raw_limit_interval": [ + "328621476572836015146309/100000000000000000000000000", + "32862147657283601514631/10000000000000000000000000" + ], + "scope": "Fixed PR6375 source; six fields with S on every output, constant scalar bases independent of S and all stage variables, seven square-zero queries, four distinct independent forward full stages and at most two extra whole idles; every positive binary child size and binary tree shape; admitted saving range through .0034.", + "selected_per_port_margin_lower_on_bracket": "-6527039332418184339015402952024551197/326409290240107399719461050006798653637322483112129794670592", + "selected_seven_leaf_histogram": { + "2": 3, + "3": 1, + "4": 1, + "7": 1 + }, + "seven_leaf_histograms": 11, + "signed_invoice": { + "1": -41678, + "145": 104, + "16": -1872, + "17": 1872, + "2": -8010, + "24": -416, + "25": 416, + "3": -8766, + "32": -416, + "33": 416, + "4": -36, + "5": -2448, + "56": -416, + "57": 416, + "6": -90, + "73": 208, + "8": 666, + "9": 6552 + }, + "statement": "The exact family raw-funding supremum is the unique zero of the displayed signed invoice. At that zero the raw paid and productive moments are equal, so the strict compiler does not certify equality.", + "uniform_tail_delta_upper": "3496455225855653296339217460406544001835165903382562806420395660105956858559119475235679158925977644133898554603846238208/3652610221847176533903701006325614864185116251128151092511899219484291710160773591773659726550708062256846427479211745667", + "uniform_tail_gamma_upper": "1591486092595755002849201667864393463931761203231280454401826443528395058882597597535393334282206221959298686689357070336/1722282558508239116681146556917648442459425036100134342894275702295944228202509273793883266552950986504559706837544355757", + "unique_selected_sizes_up_to_pair_exchange": [ + 7, + 2, + 2, + 7 + ] + }, + "relative_gain_over_pr6375_percent": "3375369143209003786577/787800000000000000000", + "root": { + "actual_tensor_gaussian_columns": 14, + "fields": 6, + "full_sites": 4, + "gaussian_characters": 4, + "normalization_growth_per_operation_upper": 2, + "ordinary_normalization_operations_per_pair": 4, + "owned_normalization_fields": 0, + "polynomial_coefficients": 1152, + "stage_ranks": [ + 2, + 3, + 3, + 2 + ], + "tensor_rule": "Normalize the complete field with its global Q squared translation; scalar coefficients stay outside tensor powers.", + "thin_sites": 3, + "wrong_tensor_normalization_rejected": true + }, + "root_source": "52e87e4971a85a8f098fadb967dc75bee9f76c65", + "selected_frontier_changed": false, + "source_head": "247b5c319b9f58fe9ee61dbf80697f8a9a429831", + "status": "PASS_MIXED_ROOT_CONTACT_COMPOSITION_KAPPA_00328621476572836015146308", + "target_delta": { + "8": 8, + "9": -8 + } +} diff --git a/research/clean-native-mixed-root/verify.py b/research/clean-native-mixed-root/verify.py new file mode 100644 index 0000000000..117c11c496 --- /dev/null +++ b/research/clean-native-mixed-root/verify.py @@ -0,0 +1,176 @@ +#!/usr/bin/env python3 +"""A signed invoice conditional on two retained predecessor interfaces. + +Produced by Nick Petalas. Apache-2.0. +The exact interval arithmetic is zxv's retained implementation. Historical +construction claims are premises, not conclusions of this verifier. +""" +import argparse +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +from hashlib import sha1, sha256 +import importlib.util +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +SAVING = Q("0.0032868") +COPIES = 18 + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def histogram(raw): + need(isinstance(raw, dict) and 1 <= len(raw) <= 145, "bounded histogram") + result = Counter() + for rank, count in raw.items(): + need(str(int(rank)) == rank and 1 <= int(rank) <= 145, "canonical rank") + need(type(count) is int and 0 < count <= 100000, "positive bounded count") + result[int(rank)] = count + return result + + +def authenticate(): + sources = json.loads((HERE / "SOURCES.json").read_text()) + live = [row for row in sources["files"] if row["usage"] == "input"] + need(len(live) == 1, "one retained arithmetic input") + snapshots = sources["retained_external_snapshots"] + need(len(snapshots) == 6, "two receipts, two proofs and two notices") + checked = {} + paths = [(live[0], HERE.parents[1] / live[0]["path"])] + paths.extend((row, HERE / row["path"]) for row in snapshots) + for row, path in paths: + data = path.read_bytes() + need(sha256(data).hexdigest() == row["sha256"], "source SHA256: " + str(path)) + blob = b"blob " + str(len(data)).encode() + b"\0" + data + need(sha1(blob).hexdigest() == row["git_blob"], "source Git blob: " + str(path)) + checked[row["path"]] = row["sha256"] + path = HERE.parents[1] / live[0]["path"] + spec = importlib.util.spec_from_file_location("retained_bounds", path) + need(spec is not None and spec.loader is not None, "arithmetic module loader") + bounds = importlib.util.module_from_spec(spec) + spec.loader.exec_module(bounds) + return checked, bounds + + +def compose(root, merge, copies=COPIES): + old, new = root["local"], merge["local"] + need(copies == root["caller"]["native_stages"] == COPIES, "eighteen native copies") + for key in ("public_inputs", "owned_fields", "peak_owned_fields", "helpers"): + need(old[key] == new[key], "preserved local interface: " + key) + need(new["owned_lifetimes"] == old["owned_lifetimes"] + 1, "one charged lifetime") + need(new["real_scalar_allowance"] == old["real_scalar_allowance"] + 508, + "all additional scalar allowance is charged") + old_local, new_local = histogram(old["paid"]), histogram(new["paid"]) + delta = Counter(new_local) + delta.subtract(old_local) + need({r: n for r, n in delta.items() if n} == {1: -1, 4: -1, 5: 1}, + "the complete local recursive substitution") + targets = histogram(root["price"]["targets"]) + remainder = histogram(root["price"]["paid"]) + remainder.subtract({r: copies * n for r, n in old_local.items()}) + need(all(n >= 0 for n in remainder.values()), "all other caller jobs retained") + paid = remainder + Counter({r: copies * n for r, n in new_local.items()}) + need(sum(targets.values()) == 13652 and sum(paid.values()) == 67132, + "complete productive and paid field counts") + target_mass = sum(r * n for r, n in targets.items()) + paid_mass = sum(r * n for r, n in paid.items()) + need((target_mass, paid_mass) == (185740, 184980), "complete unchanged rank masses") + routes = (sum(new_local.values()) + merge["native"]["helper_normalizers"] + + merge["native"]["main_adapters"] + 4 * 104 + 4 * new["owned_lifetimes"]) * 1000 + ordinary = routes + new["real_scalar_allowance"] + need(ordinary == 5512178 and ordinary < 10**7, "charged local ordinary envelope") + return targets, paid, {"local_routes": routes, "local_scalar": new["real_scalar_allowance"], + "local_ordinary_total": ordinary, "local_budget": 10**7, + "additional_lifetimes": copies, "peak_owned_fields": new["peak_owned_fields"]} + + +def margin(bounds, targets, paid): + target = bounds.moment(targets, 1 - SAVING) + cost = bounds.moment(paid, 1 - SAVING) + return target[0] - cost[1], target[1] - cost[0] + + +def controls(root, merge, bounds): + rejected = [] + mutations = [("helper target debit", "helpers", "9", 1), + ("unpaid merged query", "paid", "5", -1), + ("omitted scalar cleanup", "real_scalar_allowance", None, -508), + ("omitted scratch lifetime", "owned_lifetimes", None, -1), + ("larger peak treated as unchanged", "peak_owned_fields", None, 1)] + for label, key, rank, change in mutations: + damaged = deepcopy(merge) + if rank is None: + damaged["local"][key] += change + else: + damaged["local"][key][rank] += change + try: + compose(root, damaged) + except ValueError: + rejected.append(label) + else: + raise ValueError("semantic mutation accepted: " + label) + for copies in (17, 19): + try: + compose(root, merge, copies) + except ValueError: + rejected.append("wrong native multiplicity " + str(copies)) + else: + raise ValueError("wrong native multiplicity accepted") + for rank in range(1, 146): + low, high = bounds.power(rank, Q(1, 2)) + need(0 < low <= high and low * low <= rank <= high * high, + "integer square-root enclosure control") + return {"rejected": rejected, "exact_square_root_controls": 145} + + +def build_result(): + checked, bounds = authenticate() + root = json.loads((HERE / "inputs/root-result.json").read_text()) + merge = json.loads((HERE / "inputs/merge-result.json").read_text()) + targets, paid, ordinary = compose(root, merge) + new_margin = margin(bounds, targets, paid) + old_margin = margin(bounds, targets, histogram(root["price"]["paid"])) + need(Q("0.0130615") < new_margin[0] <= new_margin[1] < Q("0.0130617"), + "strict positive combined raw margin") + need(old_margin[1] < 0, "the old root invoice cannot fund this saving") + one, four, five = [bounds.power(r, 1 - SAVING) for r in (1, 4, 5)] + gain = (COPIES * (one[0] + four[0] - five[1]), + COPIES * (one[1] + four[1] - five[0])) + need(gain[0] > 0 and new_margin[0] - old_margin[1] <= gain[1] + and gain[0] <= new_margin[1] - old_margin[0], "full signed substitution identity") + result = {"status": "PASS_CLEAN_NATIVE_MIXED_ROOT_SIGNED_INVOICE", + "claim_type": "scoped accounting proof conditional on retained interfaces", + "saving_screen": str(SAVING), "whole_algorithm_kappa_claimed": False, + "targets": dict(sorted(targets.items())), "paid": dict(sorted(paid.items())), + "productive_fields": sum(targets.values()), "paid_jobs": sum(paid.values()), + "target_rank_mass": 185740, "paid_rank_mass": 184980, + "native_copies": COPIES, "paid_job_reduction": COPIES, + "combined_margin": bounds.display(new_margin), + "predecessor_invoice_margin_at_same_saving": bounds.display(old_margin), + "signed_gain": bounds.display(gain), "ordinary_allowance": ordinary, + "controls": controls(root, merge, bounds), "source_sha256": checked} + result["verifier_sha256"] = sha256(Path(__file__).read_bytes()).hexdigest() + return result + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write-result", type=Path) + args = parser.parse_args() + result = build_result() + encoded = json.dumps(result, sort_keys=True, indent=2) + "\n" + if args.write_result is not None: + args.write_result.write_text(encoded) + else: + need(json.loads((HERE / "RESULT.json").read_text()) == json.loads(encoded), + "generated receipt matches exact sources and current verifier") + print(encoded, end="") + + +if __name__ == "__main__": + main()