From f0625d20bcc175e0865d1d5cf3f7852fe2287679 Mon Sep 17 00:00:00 2001 From: ross Date: Mon, 19 Oct 2026 22:12:32 +1100 Subject: [PATCH 1/2] Verify R429 FULL-target interface and conditional caller cost --- .../ADAPTATIONS.json | 86 + .../FROZEN-SHA256.json | 21 + .../r429-full-target-interface/ORIGINS.json | 117 + .../PROOF-CALLER.md | 280 +++ research/r429-full-target-interface/PROOF.md | 204 ++ research/r429-full-target-interface/README.md | 45 + .../REVIEW-CALLER.md | 69 + .../REVIEW-NATIVE.md | 105 + .../REVIEW-PORTABILITY.md | 25 + .../r429-full-target-interface/SOURCES.json | 42 + research/r429-full-target-interface/TASK.json | 71 + .../r429-full-target-interface/VERIFY.json | 84 + .../r429-full-target-interface/controls.py | 103 + .../changed/budgets/SEEDED-STAR-PRESSURE.json | 41 + .../changed/budgets/SEEDED-STAR-PRESSURE.md | 44 + .../changed/budgets/seeded_star_pressure.py | 89 + .../frozen/current/EXPECTED-COMPENSATION.json | 2218 +++++++++++++++++ .../BIT-FULL-COMPENSATION-WORD.json.gz | Bin 0 -> 57926 bytes .../bit-endpoint/BIT-FULL-COMPENSATION.json | 2218 +++++++++++++++++ .../bit-endpoint/bit_full_compensation.py | 107 + .../major/bit-endpoint/bit_full_targets.py | 117 + .../BIT-SEEDED-STAR.json | 1687 +++++++++++++ .../shared-helper-algebra/bit_seeded_star.py | 84 + .../old/recursive/bit_cap_copy_local.py | 162 ++ .../frozen/old/recursive/bit_signed_audit.py | 237 ++ .../root-pruned-code/BIT-PRUNED-WORD.json.gz | Bin 0 -> 59514 bytes .../reviews/caller/INDEPENDENT-RESULT.json | 155 ++ .../reviews/caller/independent_check.py | 268 ++ .../frozen/reviews/native/RESULT.json | 329 +++ .../reviews/native/independent_check.py | 269 ++ .../verify_rehost.py | 770 ++++++ .../words/r438-t154.json.gz | Bin 0 -> 42305 bytes research/r429-full-target-interface/verify.py | 173 ++ 33 files changed, 10220 insertions(+) create mode 100644 research/r429-full-target-interface/ADAPTATIONS.json create mode 100644 research/r429-full-target-interface/FROZEN-SHA256.json create mode 100644 research/r429-full-target-interface/ORIGINS.json create mode 100644 research/r429-full-target-interface/PROOF-CALLER.md create mode 100644 research/r429-full-target-interface/PROOF.md create mode 100644 research/r429-full-target-interface/README.md create mode 100644 research/r429-full-target-interface/REVIEW-CALLER.md create mode 100644 research/r429-full-target-interface/REVIEW-NATIVE.md create mode 100644 research/r429-full-target-interface/REVIEW-PORTABILITY.md create mode 100644 research/r429-full-target-interface/SOURCES.json create mode 100644 research/r429-full-target-interface/TASK.json create mode 100644 research/r429-full-target-interface/VERIFY.json create mode 100644 research/r429-full-target-interface/controls.py create mode 100644 research/r429-full-target-interface/frozen/changed/budgets/SEEDED-STAR-PRESSURE.json create mode 100644 research/r429-full-target-interface/frozen/changed/budgets/SEEDED-STAR-PRESSURE.md create mode 100644 research/r429-full-target-interface/frozen/changed/budgets/seeded_star_pressure.py create mode 100644 research/r429-full-target-interface/frozen/current/EXPECTED-COMPENSATION.json create mode 100644 research/r429-full-target-interface/frozen/major/bit-endpoint/BIT-FULL-COMPENSATION-WORD.json.gz create mode 100644 research/r429-full-target-interface/frozen/major/bit-endpoint/BIT-FULL-COMPENSATION.json create mode 100644 research/r429-full-target-interface/frozen/major/bit-endpoint/bit_full_compensation.py create mode 100644 research/r429-full-target-interface/frozen/major/bit-endpoint/bit_full_targets.py create mode 100644 research/r429-full-target-interface/frozen/major/shared-helper-algebra/BIT-SEEDED-STAR.json create mode 100644 research/r429-full-target-interface/frozen/major/shared-helper-algebra/bit_seeded_star.py create mode 100644 research/r429-full-target-interface/frozen/old/recursive/bit_cap_copy_local.py create mode 100644 research/r429-full-target-interface/frozen/old/recursive/bit_signed_audit.py create mode 100644 research/r429-full-target-interface/frozen/old/root-pruned-code/BIT-PRUNED-WORD.json.gz create mode 100644 research/r429-full-target-interface/frozen/reviews/caller/INDEPENDENT-RESULT.json create mode 100644 research/r429-full-target-interface/frozen/reviews/caller/independent_check.py create mode 100644 research/r429-full-target-interface/frozen/reviews/native/RESULT.json create mode 100644 research/r429-full-target-interface/frozen/reviews/native/independent_check.py create mode 100644 research/r429-full-target-interface/frozen/upstream/research/bit-r438-transport-rehost/verify_rehost.py create mode 100644 research/r429-full-target-interface/frozen/upstream/research/bit-r438-transport-rehost/words/r438-t154.json.gz create mode 100644 research/r429-full-target-interface/verify.py diff --git a/research/r429-full-target-interface/ADAPTATIONS.json b/research/r429-full-target-interface/ADAPTATIONS.json new file mode 100644 index 0000000000..7adff601ae --- /dev/null +++ b/research/r429-full-target-interface/ADAPTATIONS.json @@ -0,0 +1,86 @@ +{ + "frozen/major/bit-endpoint/bit_full_targets.py": [ + { + "old": "OLD=Path('/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier')", + "new": "OLD=PORTABLE.root/'frozen/old'" + }, + { + "old": "RAW=Path('/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz')", + "new": "RAW=PORTABLE.root/'frozen/upstream/research/bit-r438-transport-rehost/words/r438-t154.json.gz'" + } + ], + "frozen/major/bit-endpoint/bit_full_compensation.py": [ + { + "old": "path.write_bytes(gzip.compress(body,mtime=0))", + "new": "PORTABLE.word_equal(path,gzip.compress(body,mtime=0))" + }, + { + "old": "(HERE/'BIT-FULL-COMPENSATION.json').write_text(json.dumps(out,indent=2,sort_keys=True)+'\\n')", + "new": "PORTABLE.equal(PORTABLE.root/'frozen/current/EXPECTED-COMPENSATION.json',out)" + }, + { + "old": "'Every scalar ADD is at actual commonZERO or commonFULL; nine pure source-pivot totals are prepared and unprepared atFULL without retained snapshots. Actual native MOVE frames and containment are replayed on651 ordinaryroles. AllSIZE rounded/tape implementation remains a separate obligation.'", + "new": "'Every scalar ADD is at its actual common frame. The NEW nine-total compensation ADDs are at FULL, with source-pivot totals prepared and unprepared without retained snapshots. Inherited internal ADD/MOVE realizations remain a separate native compiler contract. Actual frame labels and containment are replayed on651 ordinary roles. All-size rounded/tape implementation remains a separate obligation.'" + } + ], + "frozen/major/shared-helper-algebra/bit_seeded_star.py": [ + { + "old": "need(json.loads(target_path.read_bytes())==out,'stored seeded star differs')", + "new": "PORTABLE.equal(target_path,out)" + }, + { + "old": "def inverse_event(e):return e # Every declared GF2 primitive here is involutive.", + "new": "def inverse_event(e):return e # Unused historical placeholder; new_F needs new_F_inverse as in main." + } + ], + "frozen/changed/budgets/seeded_star_pressure.py": [ + { + "old": "ROOT = Path('/Users/ross/git/math')", + "new": "ROOT = PORTABLE.root / 'frozen'" + }, + { + "old": "SOURCE = ROOT / 'integer-mult-bounds/research/bit-r438-transport-rehost/verify_rehost.py'", + "new": "SOURCE = ROOT / 'upstream/research/bit-r438-transport-rehost/verify_rehost.py'" + }, + { + "old": "need(json.loads(target.read_text()) == out, 'stored exact receipt mismatch')", + "new": "PORTABLE.equal(target,out)" + } + ], + "frozen/reviews/native/independent_check.py": [ + { + "old": "RUN=ROOT/'.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint'", + "new": "RUN=PORTABLE.root/'frozen/major/bit-endpoint'" + }, + { + "old": "OLD=ROOT/'.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier'", + "new": "OLD=PORTABLE.root/'frozen/old'" + }, + { + "old": "ROOT/'integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz'", + "new": "PORTABLE.root/'frozen/upstream/research/bit-r438-transport-rehost/words/r438-t154.json.gz'" + }, + { + "old": "need(json.loads(path.read_text())==out,'independent complete receipt differs')", + "new": "PORTABLE.equal(path,out)" + } + ], + "frozen/reviews/caller/independent_check.py": [ + { + "old": "RUN = BASE / '.research-automation/runs/kappa-major-20261018T1330Z'", + "new": "RUN = PORTABLE.root / 'frozen/major'" + }, + { + "old": "PRESSURE = BASE / '.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/budgets/SEEDED-STAR-PRESSURE.json'", + "new": "PRESSURE = PORTABLE.root / 'frozen/changed/budgets/SEEDED-STAR-PRESSURE.json'" + }, + { + "old": "SOURCE = BASE / 'integer-mult-bounds/research/bit-r438-transport-rehost/verify_rehost.py'", + "new": "SOURCE = PORTABLE.root / 'frozen/upstream/research/bit-r438-transport-rehost/verify_rehost.py'" + }, + { + "old": "(HERE / 'INDEPENDENT-RESULT.json').write_text(json.dumps(result, sort_keys=True, indent=2) + '\\n')", + "new": "PORTABLE.equal(HERE / 'INDEPENDENT-RESULT.json',result)" + } + ] +} diff --git a/research/r429-full-target-interface/FROZEN-SHA256.json b/research/r429-full-target-interface/FROZEN-SHA256.json new file mode 100644 index 0000000000..dfcd79badc --- /dev/null +++ b/research/r429-full-target-interface/FROZEN-SHA256.json @@ -0,0 +1,21 @@ +{ + "frozen/changed/budgets/SEEDED-STAR-PRESSURE.json": "79c809a3c043695979a3aea75915f4cfd209e44f8b45d003113af0d2711c7595", + "frozen/changed/budgets/SEEDED-STAR-PRESSURE.md": "a9e5e3141b42b8b4e5a7280d75eb19a8efb3432628c6a47219430ffbab76b636", + "frozen/changed/budgets/seeded_star_pressure.py": "4f30a066aca23f05fe989674474c3f754e45a824c2190638f96dd2a3f4aa021b", + "frozen/current/EXPECTED-COMPENSATION.json": "497057b82d14976696f1c48f823fa7e346f44cffec98daace9edfd5ad11cc2db", + "frozen/major/bit-endpoint/BIT-FULL-COMPENSATION-WORD.json.gz": "0f461dbc7e82a02faedb4a5129103963507c9f063a0a3679ba5d20ad94df160e", + "frozen/major/bit-endpoint/BIT-FULL-COMPENSATION.json": "1ee06005d3b82ff592640d9aa4be2021b6de0a0b27fba5723aa06c36a6adbd20", + "frozen/major/bit-endpoint/bit_full_compensation.py": "a7bda83b84ab15a75c418225e3d5c2fda8eded8577a894341225f757e6ea7e20", + "frozen/major/bit-endpoint/bit_full_targets.py": "7446290e462752b76b9461696b7676c8295739aba1b79eea0d77925f5f9a3869", + "frozen/major/shared-helper-algebra/BIT-SEEDED-STAR.json": "e0fc9ea3dd2e74222b5ec0954a85b02960fac402453d69b9147847452d2ad86b", + "frozen/major/shared-helper-algebra/bit_seeded_star.py": "91d3bbebfad36836b48949a2d231afd3eb8dd46f0443d45f7e19ff9779468347", + "frozen/old/recursive/bit_cap_copy_local.py": "6e9ca1eb905d769716c009904f45d6849b225e48cd119f18b50c0379f35313cb", + "frozen/old/recursive/bit_signed_audit.py": "376356696663021693c0e2c9adf37f371675fe8837fb88232b8767a8b90793e8", + "frozen/old/root-pruned-code/BIT-PRUNED-WORD.json.gz": "1a6841fccba51fa922993c77b4b296e659c2c538252e5e06113d0438c5edb870", + "frozen/reviews/caller/INDEPENDENT-RESULT.json": "9f3ebb90bd857aa172955e6034c71be683f444f4408824cf3d20cbce4a0ada81", + "frozen/reviews/caller/independent_check.py": "29e3b5aaf45abb9a7de56971d91fa7355279abbc6303e4ced2ae1c8f62fb0e31", + "frozen/reviews/native/RESULT.json": "82c254f089c5976431b78365c94620076e6aaf60074c7d13b21f45019620bf1b", + "frozen/reviews/native/independent_check.py": "ec504374a6b75aa84633d2a20309b48cbcbb36bd5aa00c11d0c1bc837d489ce7", + "frozen/upstream/research/bit-r438-transport-rehost/verify_rehost.py": "4774841de10a8386204519174c5e56eb14f5852b20058db38a65a1034eeba275", + "frozen/upstream/research/bit-r438-transport-rehost/words/r438-t154.json.gz": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022" +} diff --git a/research/r429-full-target-interface/ORIGINS.json b/research/r429-full-target-interface/ORIGINS.json new file mode 100644 index 0000000000..210cd04460 --- /dev/null +++ b/research/r429-full-target-interface/ORIGINS.json @@ -0,0 +1,117 @@ +[ + { + "original": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/root-pruned-code/BIT-PRUNED-WORD.json.gz", + "retained": "frozen/old/root-pruned-code/BIT-PRUNED-WORD.json.gz", + "sha256": "1a6841fccba51fa922993c77b4b296e659c2c538252e5e06113d0438c5edb870", + "bytes": 59514 + }, + { + "original": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/bit_cap_copy_local.py", + "retained": "frozen/old/recursive/bit_cap_copy_local.py", + "sha256": "6e9ca1eb905d769716c009904f45d6849b225e48cd119f18b50c0379f35313cb", + "bytes": 7588 + }, + { + "original": "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/bit_signed_audit.py", + "retained": "frozen/old/recursive/bit_signed_audit.py", + "sha256": "376356696663021693c0e2c9adf37f371675fe8837fb88232b8767a8b90793e8", + "bytes": 11946 + }, + { + "original": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint/bit_full_compensation.py", + "retained": "frozen/major/bit-endpoint/bit_full_compensation.py", + "sha256": "a7bda83b84ab15a75c418225e3d5c2fda8eded8577a894341225f757e6ea7e20", + "bytes": 8366 + }, + { + "original": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint/bit_full_targets.py", + "retained": "frozen/major/bit-endpoint/bit_full_targets.py", + "sha256": "7446290e462752b76b9461696b7676c8295739aba1b79eea0d77925f5f9a3869", + "bytes": 8762 + }, + { + "original": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint/BIT-FULL-COMPENSATION.json", + "retained": "frozen/major/bit-endpoint/BIT-FULL-COMPENSATION.json", + "sha256": "1ee06005d3b82ff592640d9aa4be2021b6de0a0b27fba5723aa06c36a6adbd20", + "bytes": 49165 + }, + { + "original": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint/BIT-FULL-COMPENSATION-WORD.json.gz", + "retained": "frozen/major/bit-endpoint/BIT-FULL-COMPENSATION-WORD.json.gz", + "sha256": "0f461dbc7e82a02faedb4a5129103963507c9f063a0a3679ba5d20ad94df160e", + "bytes": 57926 + }, + { + "original": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/shared-helper-algebra/bit_seeded_star.py", + "retained": "frozen/major/shared-helper-algebra/bit_seeded_star.py", + "sha256": "91d3bbebfad36836b48949a2d231afd3eb8dd46f0443d45f7e19ff9779468347", + "bytes": 6317 + }, + { + "original": "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/shared-helper-algebra/BIT-SEEDED-STAR.json", + "retained": "frozen/major/shared-helper-algebra/BIT-SEEDED-STAR.json", + "sha256": "e0fc9ea3dd2e74222b5ec0954a85b02960fac402453d69b9147847452d2ad86b", + "bytes": 20344 + }, + { + "original": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/budgets/seeded_star_pressure.py", + "retained": "frozen/changed/budgets/seeded_star_pressure.py", + "sha256": "4f30a066aca23f05fe989674474c3f754e45a824c2190638f96dd2a3f4aa021b", + "bytes": 4774 + }, + { + "original": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/budgets/SEEDED-STAR-PRESSURE.json", + "retained": "frozen/changed/budgets/SEEDED-STAR-PRESSURE.json", + "sha256": "79c809a3c043695979a3aea75915f4cfd209e44f8b45d003113af0d2711c7595", + "bytes": 2143 + }, + { + "original": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/budgets/SEEDED-STAR-PRESSURE.md", + "retained": "frozen/changed/budgets/SEEDED-STAR-PRESSURE.md", + "sha256": "a9e5e3141b42b8b4e5a7280d75eb19a8efb3432628c6a47219430ffbab76b636", + "bytes": 2272 + }, + { + "original": "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz", + "retained": "frozen/upstream/research/bit-r438-transport-rehost/words/r438-t154.json.gz", + "sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022", + "bytes": 42305 + }, + { + "original": "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/verify_rehost.py", + "retained": "frozen/upstream/research/bit-r438-transport-rehost/verify_rehost.py", + "sha256": "4774841de10a8386204519174c5e56eb14f5852b20058db38a65a1034eeba275", + "bytes": 44048 + }, + { + "original": "/Users/ross/git/math/.research-automation/runs/unpublished-contributions-20261019T0916Z/b05-corrections/EXPECTED-COMPENSATION.json", + "retained": "frozen/current/EXPECTED-COMPENSATION.json", + "sha256": "497057b82d14976696f1c48f823fa7e346f44cffec98daace9edfd5ad11cc2db", + "bytes": 49272, + "derivation": "Historical receipt with only allsize_lift prose corrected; verify.py enforces the exact one-field change." + }, + { + "original": "/Users/ross/git/math/.research-automation/runs/unpublished-contributions-20261019T0916Z/b05-native-review/independent_check.py", + "retained": "frozen/reviews/native/independent_check.py", + "sha256": "ec504374a6b75aa84633d2a20309b48cbcbb36bd5aa00c11d0c1bc837d489ce7", + "bytes": 17199 + }, + { + "original": "/Users/ross/git/math/.research-automation/runs/unpublished-contributions-20261019T0916Z/b05-native-review/RESULT.json", + "retained": "frozen/reviews/native/RESULT.json", + "sha256": "82c254f089c5976431b78365c94620076e6aaf60074c7d13b21f45019620bf1b", + "bytes": 21321 + }, + { + "original": "/Users/ross/git/math/.research-automation/runs/unpublished-contributions-20261019T0916Z/b05-caller-review/independent_check.py", + "retained": "frozen/reviews/caller/independent_check.py", + "sha256": "29e3b5aaf45abb9a7de56971d91fa7355279abbc6303e4ced2ae1c8f62fb0e31", + "bytes": 12286 + }, + { + "original": "/Users/ross/git/math/.research-automation/runs/unpublished-contributions-20261019T0916Z/b05-caller-review/INDEPENDENT-RESULT.json", + "retained": "frozen/reviews/caller/INDEPENDENT-RESULT.json", + "sha256": "9f3ebb90bd857aa172955e6034c71be683f444f4408824cf3d20cbce4a0ada81", + "bytes": 4025 + } +] diff --git a/research/r429-full-target-interface/PROOF-CALLER.md b/research/r429-full-target-interface/PROOF-CALLER.md new file mode 100644 index 0000000000..f23f877237 --- /dev/null +++ b/research/r429-full-target-interface/PROOF-CALLER.md @@ -0,0 +1,280 @@ +# FULL-target caller accounting and the fixed three-seed pressure gate + +Scientific pin: `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. +This note separates an exact formal bank identity, conditional caller invoices, +and an all-parameter necessary moment obstruction. It supplies no complete +native supplier, owner allocation, rounded implementation or new κ. + +Write v = 111 for the number of E8 ports and h = 429 for the ordinary helpers +of the changed local word. Reserve N for the common-axis involution; N is not +the number of ports. + +## The direct diagonal topology has zero deficit + +The source-bound FULL-target local word has child histogram + +`{1:1406, 2:1342, 3:79, 4:44, 5:93, 6:11, 7:9}` + +and rank mass `5097 = 15v + 8h`. This includes all v rank-one cap-to-FULL +target lifts. Its physical two-bank block is + +`[[S,0],[S,T]]`, with source progress rank7 and target progress rank8. + +At common FULL, v additional ordinary ADDs cancel the cross term and give +`diag(S,T)`. These ADDs are not included in the emitted 12,932-ADD shear word. +They have no new recursive rank charge in this invoice, but their scalar work, +access, precision effects and physical implementation still have to be paid. +The local native/frame realization is inherited from the source-bound local +proof; this caller calculation does not independently reprove it. + +Assume a direct caller with the following contract: + +- L calls, L public banks, and two distinct active banks per call; +- one common axis and seven disjoint fresh axes per call, so `m = 1+7L`; +- each public bank is a source once and a target once in two distinct calls, + providing its one common-axis N when targeted; thus each bank has exactly + L−2 inactive stages; +- every inactive fresh interval is completed, and the h helpers per call are + legally hosted inside these public idle regions with exact restoration; +- public stock is `W = vL`, with no additional unpriced stock or progress. + +This is a conditional topology for integer L ≥ 2. The existence of legal +hosting is a separate premise; the arithmetic identity does not assert it for +any L. There are L² bank-stage pairs, of which 2L are active. Hence the raw +inactive fresh rank volume is `7v L(L−2)`. A legally hosted width-eight helper +occurrence replaces eight units of this raw idle volume, so the ideal total is + +`Q = L(15v+8h) + 7vL(L−2) − 8hL + = vL + 7vL² + = Wm`. + +Thus `D = Wm−Q = 0` for every L under this contract. Dropping the v target +lifts from each call changes Q to `Wm−vL` and creates the spurious deficit vL. +The apparent saving is exactly the omitted cost. A nonzero number of genuine +sub-parent-rank children gives positive pressure at every primitive exponent +a > 0, so this zero-deficit invoice cannot satisfy a strict supplier moment +test. Further charged work without new admitted progress cannot rescue it. + +The helper subtraction is conditional on legal physical hosting. Even the +aggregate necessary inequality `7vL(L−2) ≥ 8hL` requires L ≥ 7 at these v,h. +That condition is not sufficient for chronological whole-helper ownership. + +### Distinction from the retained full-target schedule + +James Reed's [PR3850](https://github.com/CrocSwap/integer-mult-bounds/pull/3850), +inspected at `8f97d229d208e5fce7b42e6a1f1b8bf3cf522950`, audits the retained +pure recipe of Gonzalo-Mier's PR3772. That recipe has K bank pairs, +`L = 2K+1` calls, and `2K = L−1` public banks. Its per-pair idle ranks sum to +`7L(K−1)`, charged on both members of each pair. Thus its public idle rank +volume per port is `14L(K−1) = 7L(L−3)`. + +For its rank7/rank8 full-target local profile, the deficit per port and replica +is + +`(1+7L)(L−1) − 15L − 7L(L−3) = −1`. + +This gives the reported `−111·32 = −3552`. The direct diagonal topology above +has L public banks and idle volume `7L(L−2)`, giving zero instead. These are +different complete invoices, and neither supports a generic claim that every +FULL-target caller has the same deficit. PR3850's stated execution domain is +K = 1,...,24; this review inspected its pinned source and derives the displayed +accounting identity, but did not replay its producer or Householder charts. + +## Exact seeded bank algebra + +Work over the ring `A = F₂[N]/(N²−1)`. For each ordered bank pair define + +`F(x,y) = (x,y+Nx)`, +`B(x,y) = (x+Ny,y)`, +`F_new(x,y) = (x,x+Ny)`. + +These are interface assumptions about the local calls at matched fresh-prefix +cuts. The identities below hold for arbitrary bank inputs. They do not require +clean data banks or specialize N to the identity. + +Three old calls followed by exchange obey + +`(x,y) ->F (x,y+Nx) ->B (Ny,y+Nx) ->F (Ny,Nx) + ->exchange (Nx,Ny)`. + +The equality uses only characteristic two and N² = 1. With eight arbitrary +initial banks `x_0,...,x_7`, use these three calls on banks0,1, then apply +`F_new` from bank0 to each bank j = 2,...,7. The result is + +`(Nx_0, Nx_1, N(x_0+x_2), ..., N(x_0+x_7))`. + +Six terminal CNOTs from bank0 to banks7,6,...,2 cancel each x_0 term and leave +`N·I_8` on all eight arbitrary inputs. + +F, B, exchange and CNOT are involutions. The new call generally is not: + +`F_new^(-1)(x,y) = (x,N(x+y))`, +`F_new²(x,y) = (x,(1+N)x+y)`. + +The original producer's unused `inverse_event` helper has a stale comment +calling every primitive involutive. Its executed inverse loop correctly +replaces `new_F` by `new_F_inverse`; the checked inverse identity is sound. +The distinction must be retained when implementing or describing this word. + +The independent checker uses the faithful regular representation + +`a+bN -> [[a,b],[b,a]]` over F₂. + +Its injectivity follows directly from the diagonal entry a and off-diagonal +entry b. Therefore equality of the resulting16-by-16 binary matrices proves +the ring identity, including its nontrivial characteristic-two behavior. The +checker constructs elementary matrices independently, compares all16 saved +prefixes, verifies each primitive's actual inverse, and composes the literal +reverse-inverse word back to identity. Omitting the middle seed B or the last +terminal CNOT changes an actual input/output matrix entry; explicit witnesses +are recorded. + +A useful control is + +`CNOT ∘ F_new = diag(I,N)`. + +This leaves the raw source unchanged. It cannot be credited with common-axis N +progress on both arbitrary raw inputs. The seed supplies the encoded source +`Nx_0`; a different caller must supply or pay for its own input normalization. + +## Fresh factors and changed idle windows + +Let `G_0,...,G_8` be invertible fresh factors commuting with one another and +with N. Each active call advances its two banks by its stage G_s. Before a +call at stage s, both participating banks must have the same cumulative fresh +prefix `Gamma_s = product_(u 1, writing z = (x−1)/(x+1), the positive atanh series gives +`ln(x) > 2(z+z³/3)`. At x = 22/7, z = 15/29, so + +`P(a,m) > (15363/500)·2(15/29+(15/29)³/3) + = 21108762/609725 + = 33 + 987837/609725 + > D`. + +This is a strict exact rational lower certificate for every L ≥ 3 and +a ≥ 1/500, not a finite parameter sweep. The complete D ceiling is a premise; +nonnegative omitted pressure alone cannot establish it if a changed caller +adds new stock or progress credit. The exponent is primitive a. No unproved +outer map from a to a final multiplication κ is used by this theorem. + +Dropping one seed, relaxing the seed rank ceiling from7 to8, or raising the +deficit ceiling from33 to35 makes this coarse witness insufficient. The checker +records those exact inequalities. They do not prove that a changed moment +passes, that a changed caller exists, or that any native supplier is admitted. + +## Scope and provenance + +The direct D0 identity is conditional on its direct n=L topology and hosted +invoice. The eight-bank construction is an arbitrary-input formal algebra +identity with explicit fresh-factor cuts. The all-L theorem excludes completed +invoices retaining three unchanged seeds, the declared arity and D≤33. +These results do not exclude changed seed words, shared operations, different +common-axis progress, different complete deficits, or different callers. + +Chronological owner allocation, local-to-caller native binding, arbitrary dirty +restoration in those bindings, rounded error propagation, all-size recursion, +source/coefficient access, physical tape implementation and head return remain +separate obligations. The local integer prefix bound874 is not a rounded +precision theorem. Exact finite replays and this written all-L argument are +not formal-kernel evidence or independent human review. + +Underlying E8/R438 geometry, scalar interface and transported word retain +their original PR555/543/545/510 lineage and Sagar Thakrar's transport credit; +the R429 source deletion retains Ali Romman's credit. The recursive-interface +lane supplied the FULL-target local construction, direct accounting, and +three-old-call seed with new-call fanout. The shared-helper algebra lane +supplied the frozen eight-bank word. The later budget lane supplied the exact +three-seed pressure certificate. This review independently reconstructs the +matrix and fresh-factor algebra and checks the stated invoices. It is prepared +with substantial OpenAI Codex assistance, under Apache-2.0. diff --git a/research/r429-full-target-interface/PROOF.md b/research/r429-full-target-interface/PROOF.md new file mode 100644 index 0000000000..5a4d66e39f --- /dev/null +++ b/research/r429-full-target-interface/PROOF.md @@ -0,0 +1,204 @@ +# The fixed R429 FULL-target compensation word + +The statement concerns the frozen word with canonical SHA256 +`895a359e33a7a9a9cb2c4a68acc9fcf624596d334a52381264ae498e0e55c847`, +at scientific pin `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. +It has 651 ordinary registers in the order + + x_0,...,x_110, y_0,...,y_110, h_0,...,h_428. + +All inputs are independent and arbitrary. The input frame of source `x_p` +is its actual E8 line `P_p`; all targets and helpers enter at ZERO. Every +ordinary register exits at FULL. The word has no private register or +COPY/ERASE record. This does not assert zero scratch inside the inherited +native implementations of its MOVE records. + +The exact signed scalar endpoint is + + (x,y,h) -> (x, y + A x + E h, h), + +where `A` and `E` are completely evaluated integer matrices satisfying +`A = I mod 2` and `E = 0 mod 2`. Thus the binary VALUE endpoint is + + (x,y,h) -> (x, y+x, h). + +The integer target endpoint is not `y+x`. In the actual first target row, +the coefficient of `x_0` is 3 and that of ordinary register226 (helper4) +is 2. Exact source restoration, helper restoration and identity on old +target `y` hold over Z; source-to-target and helper-to-target residuals +vanish only in the indicated parity reduction. + +## Literal construction and scalar identity + +The predecessor is the frozen R429 word with canonical SHA256 +`ebc33ee086f610c1fd540fa56bb99b2b96a768e4aed4a18defcb0e1f507fca89`. +Its gzip container SHA differs from another published container, so source +comparisons must distinguish compressed and canonical bytes. The parent +has identified this canonical predecessor with the word published in +PR3645. The current contribution does not claim that predecessor or the +old cap identities as new. + +Delete the predecessor's source-code phases21–24 and its three private +repair episodes31–33, including their COPY/ERASE records. The resulting +signed bulk restores every source and helper over Z and has target block + + y -> y + B x + E h, + +with `B = I + K R mod 2`. Here `R` is reconstructed by applying the raw +R438 D and A gates to all660 binary input columns and reading the nine +retained source rows; `K` is read from the actual scatter incidence. +All111 rows and all nine reader directions are retained in the check. + +Append one explicit rank-one MOVE from each of the111 target caps to FULL. +At that cut all data sources and targets have the same FULL frame. For each +binary row `R_j`, choose the first supported source coordinate `p_j` and +execute: + +1. Add each other supported source into `x_(p_j)`, with coefficient+1. +2. Add this temporary source total into every target selected by `K[:,j]`. +3. Reverse the preparation order with coefficient−1. + +The total prepared over Z is the positive sum of the original source +coordinates in the support of `R_j`. The pivot includes its own original +coordinate, so no clean temporary assumption is used. Literal unpreparation +restores the pivot over Z before the next reader. In binary arithmetic this +adds exactly `K[:,j] R_j x`; summing all nine readers cancels the bulk's +`KR` defect and leaves `y+x`. + +Over Z let `K_01` and `R_01` denote the zero/one lifts of these incidence +matrices. The exact update is + + A = B + K_01 R_01. + +The independent checker compares every coefficient of this integer identity, +including the whole helper block E and the entire target self-block. It +does not infer the integer identity from a parity check. + +The complete word has12932 signed ADDs:11377 inherited bulk ADDs plus514 +preparation,527 scatter and514 unpreparation ADDs. It has2984 MOVE records, +including all111 new cap-to-FULL lifts. It contains no source code, target +precode, retained snapshot, private compensation field or terminal gauge. + +## All-input verification and literal inverse + +Every scalar operation is linear over Z. A dense651-by651 integer matrix +started at the identity therefore carries all651 independent source, +target and helper columns simultaneously. The independent checker uses +Python arbitrary-precision integer lists, importing no producer module or +producer utility. Every signed ADD is applied to a complete dense row; +every MOVE is handled by the separately checked frame chronology. + +The final matrix is the signed shear above. Its nonidentity block squares +to zero, hence the complete integer inverse is `2I-F` when F denotes the +full forward endpoint matrix. Reversing the literal record order and +negating each ADD coefficient yields exactly that matrix, including every +even coefficient. Applying this literal inverse to the forward matrix +returns the651-by651 identity exactly. + +The maximum row sum of absolute signed coefficients at every ADD prefix +is874 in both orientations. This is an exact bound for this signed scalar +normalization, and also bounds its endpoint rows. It is not the positive +envelope obtained by replacing subtraction with addition. In particular it +does not prove a rounded-child precision contract, suffix-error bound, +native intermediate growth bound or physical execution cost. + +Three executed controls distinguish the required obligations: + +- Omitting one actual compensation scatter changes the binary endpoint. +- Reversing one unpreparation sign breaks integer source restoration while + leaving the entire binary endpoint unchanged. +- Omitting the target111 cap lift causes an actual subsequent ADD to fail + its common-frame requirement. + +The second control is essential evidence that the check sees signed errors +which would be invisible in an F2-only replay. + +## Exact frames and new ADDRESS lift + +All raw frame dimensions are recomputed over Q from their actual E8 roots. +For every MOVE the checker verifies the current frame, literal containment +of the smaller root set in the larger, and the positive exact dimension +increment. For every ADD it verifies both registers have the declared +common frame. The entire forward and inverse frame chronology, including +the final frames of all429 helpers, is checked. + +The current word uses628 distinct ADD frames. Of its12932 ADDs,5758 use +ZERO,4147 use FULL and3027 use intermediate common frames. The historical +receipt's sentence saying every scalar ADD uses ZERO or FULL is false. +The correct statement is that every ADD uses its actual common frame and +all1555 newly added compensation ADDs use FULL. The old internal-frame +compiler remains an inherited contract. + +For the actual norm-four root `q_p`, define the dyadic projector + + P_p = q_p q_p^T / 4, C_p = I-P_p. + +The entrance frame is exactly `im(P_p)` and the old target cap is exactly +`im(C_p)`, with ranks1 and7. For a projector P define the16-by16 ADDRESS map + + D_P = [[I-P, P], [P, I-P]]. + +Exact dyadic multiplication proves, separately for each actual root, + + D_I D_P = D_(I-P), D_P^2 = I, + D_I D_(I-P) = D_P. + +The first two identities are the inherited cap facts:3552 ADDRESS columns +across111 ports. The last is the new cap-to-FULL lift identity:1776 further +columns. The checker reconstructs every projector from the original roots +and compares all entries; it does not substitute rank counts for operator +equalities. In any odd ADDRESS field,4 is invertible, `q_p^T q_p = 4`, +and `q_p` remains nonzero. Therefore P has rank1, its complement has rank7, +and these exact identities survive dyadic reduction. Untouched spectator +coordinates extend them by the identity. + +These ADDRESS matrix identities induce the corresponding permutations of +binary VALUE arrays. ADDRESS linear algebra is not identified with VALUE +addition. The old native realizations of every internal MOVE, their chart +adapters and exceptional/fallback guards remain inherited premises. This +finite check does not execute an independent implementation over every +ADDRESS size or modulus. + +## Physical endpoint and paid diagonalization + +Under the inherited native frame convention, the physical residual on +source port p is `S_p = F8 D_(P_p)`, of native rank7. The physical target +residual is `T = F8`, of rank8. Converting the verified binary logical +shear to those physical frames gives the data VALUE-operator block + + [[S_p, 0], [S_p, T]]. + +This is a block over binary VALUE operators. It is not the full signed +integer endpoint matrix described earlier. The physical helper output is +`F8 h_j` for each ordinary helper, since its frame progresses from ZERO to +FULL. Logical restoration to the same helper symbol is not physical +identity restoration; a caller must account for that helper frame progress. + +One additional common-FULL ADD `y_p <- y_p - x_p` per port diagonalizes +the binary block to `diag(S_p,T)`. All111 such ADDs are paid separately. +They are absent from the12932-ADD emitted shear word; the diagonalized +version has13043 ADDs. Over Z this postcomposition leaves the even residual +`(A-I)x+Eh`; it does not give an integer identity. + +The complete paid child-rank histogram is + + H1=1406, H2=1342, H3=79, H4=44, H5=93, H6=11, H7=9. + +Its mass is5097. Independently, the total frame progress is + + 111*(8-1) + 111*(8-0) + 429*(8-0) = 5097. + +Thus this local interface has zero excess rank mass relative to its actual +source, FULL-target and helper progress. The111 target lifts are already +included and cannot be dropped from a caller invoice. A zero local excess +does not imply a positive complete caller saving or an improved exponent. + +## Scope + +The result is an exact finite signed word, binary endpoint, explicit frame +chronology and local ADDRESS lift certificate. Arbitrary logical helper +inputs and arbitrary old targets are included. Native implementation of +old internal moves remains a named dependency. Global caller topology, +integral chronological helper hosting, complete recursive moments, rounded +precision, coefficient/source access, tape and head-return costs are not +supplied. No new kappa or selected-frontier change follows. diff --git a/research/r429-full-target-interface/README.md b/research/r429-full-target-interface/README.md new file mode 100644 index 0000000000..d8471e4a39 --- /dev/null +++ b/research/r429-full-target-interface/README.md @@ -0,0 +1,45 @@ +# R429 with FULL targets and no private field + +This package replaces the fixed R429 source-code/private-repair boundary by nine source-pivot totals scattered after all 111 targets have been lifted to FULL. The complete local word has 12,932 signed ADDs, 2,984 MOVE queries and no COPY, ERASE or private field. Its full paid histogram is + +`{1:1406,2:1342,3:79,4:44,5:93,6:11,7:9}`, with rank mass 5,097. + +All 651 arbitrary logical integer inputs are covered. Sources and 429 helpers return their original logical values exactly; old target values retain coefficient1, and target update is x modulo2 with even helper leakage. The literal integer inverse returns every input. Helpers start at ZERO and finish at FULL, so their physical outputs are F8*d. The physical binary data block is `[[S,0],[S,T]]`, with source operator S of native rank7 and T=F8 of rank8. An additional 111 common-FULL ADDs diagonalize the data block. Those additional ADDs are explicitly outside the emitted shear word's 12,932 count. + +The target lifts use 111 rank-one queries, all paid. They make local mass equal local native coverage: `111*(7+8)+429*8=5097`. In the stated L-bank diagonal topology the complete rank deficit is zero, conditional on each bank serving once as source and once as target in distinct calls and on legal helper hosting. Aggregate capacity already requires L>=7; this is not a hosting construction. A different three-old-seed/six-new-fanout word closes algebraically on eight independent banks, but its favorable complete-invoice ceiling D<=33 still cannot support primitive exponent a>=1/500. Native admission at its changed cuts is a separate premise. + +## Proof and validation + +[PROOF.md](PROOF.md) gives the local contract and physical interpretation; [PROOF-CALLER.md](PROOF-CALLER.md) gives the exact caller algebra, paid diagonal bill and all-L conditional pressure bound. Separate AI [native](REVIEW-NATIVE.md), [caller](REVIEW-CALLER.md) and [source-integrity](REVIEW-PORTABILITY.md) reviews accompany the package. Independent implementations consume the fixed word and reconstruct the caller in a different representation. + +```sh +python3.12 -B scripts/research_package.py --package research/r429-full-target-interface +``` + +The portable replay uses only Python's standard library. It authenticates all frozen bytes before compiling them, keeps checks active under optimized callers, bypasses matching nested bytecode caches and compares every receipt field. Regeneration compares the complete decompressed word bytes; frozen gzip hashes retain provenance, while regenerated compression headers and zlib choices may differ. No mathematical receipt field is dropped. Original workstation paths are normalized only for relocation, with colliding keys rejected. + +## Corrected historical statement + +The frozen predecessor receipt incorrectly says every scalar ADD is at ZERO or FULL. In fact 3,027 inherited ADDs use 626 other common frames; 5,758 use ZERO and 4,147 use FULL. The correct contract is that every ADD uses its actual common frame, while all NEW nine-total compensation ADDs are at FULL. The declared prose-only adapter corrects this sentence in the current expected receipt; the original source and receipt remain byte-for-byte preserved. The verifier checks that this is the only changed receipt field. No arithmetic, loop domain, cost, frame test or defect control changes. + +An unused historical `inverse_event` helper incorrectly comments that every primitive is involutive. A comment-only adapter states that `new_F` needs `new_F_inverse`; the executed main already uses the correct inverse. + +The historical seeded-star receipt uses six earlier fanouts with private cost 3 and nominal D15. Substituting the later zero-private interface raises that favorable ceiling to D33, conditional on the same native interface being admitted at the changed cuts. The caller proof states this substitution; the earlier receipt is retained for its exact algebra and chronology, not as a current cost invoice. + +## Limits + +The inherited internal MOVE compiler contract is not re-proved over every odd ADDRESS modulus. New cap-to-FULL lift operators are checked exactly over the dyadic rationals; all frame labels and strict containment steps are checked. The 874 forward/reverse row-L1 bound is an integer-prefix bound, not a rounded-child precision theorem. Physical owner allocation, copied-total alternatives, source access, routing, tape, all-size recursive lowering and a favorable complete joint recurrence remain open. No selected-frontier change or new κ is claimed. + +## Open next questions + +A useful next question is whether a changed multi-output native compensation interface can avoid the 111 target lifts without replacing them by unpriced copies or source restoration. First specify its actual source/target cuts and arbitrary-dirt endpoint. A different caller must rederive its complete histogram and coverage before using a moment test. + +## Sources and credit + +Scientific pin: `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. The input R429 word has canonical SHA256 `ebc33ee086f610c1fd540fa56bb99b2b96a768e4aed4a18defcb0e1f507fca89`, exactly the word already published in [PR3645](https://github.com/CrocSwap/integer-mult-bounds/pull/3645). Its helper deletions, three-row minimality and earlier cap-copy audit are prior work. This contribution changes the endpoint and compensates directly with nine FULL source totals. + +Sagar Thakrar supplied the transported R438 word; Ali Romman supplied the construction, boundary-persistence and source-code lineage, with antecedents from DreamingOfClouds and eumemic. Related restored mutable-source query tours include Hanson Sun / bbMisk's PR1522. Detailed canonical pins are in SOURCES.json; ORIGINS.json and FROZEN-SHA256.json retain unpublished-source and review provenance. + +Prepared by Ross Richardson with substantial OpenAI Codex assistance, including separate AI reviews. Original notices retained; Apache-2.0. No independent human or formal-kernel certification is claimed. + +James Reed / [PR3850](https://github.com/CrocSwap/integer-mult-bounds/pull/3850), based on Gonzalo-Mier / PR3772, prices a different retained FULL-target schedule with L-1 public banks and negative deficit. The direct topology here has L banks; PROOF-CALLER.md compares both complete invoices. The fresh overlap snapshot covered735 open PRs and2597 Discussion records; it is search coverage, not a novelty certificate. diff --git a/research/r429-full-target-interface/REVIEW-CALLER.md b/research/r429-full-target-interface/REVIEW-CALLER.md new file mode 100644 index 0000000000..6de14fef65 --- /dev/null +++ b/research/r429-full-target-interface/REVIEW-CALLER.md @@ -0,0 +1,69 @@ +# B05/B06 caller review + +**Verdict: PASS for the exact algebra and conditional accounting statements.** +One stale unused-helper comment needs explicit correction in publication prose; +it does not affect the executed producer's inverse proof. + +## Findings + +1. Direct n=L diagonal topology: the complete local mass5097 includes111 + rank-one target lifts. Conditional legal hosting yields the polynomial + `111L+777L² = Wm` and D0. Dropping lifts creates precisely the false111L + deficit. The v extra diagonalizing ADDs remain paid scalar work outside + the emitted12,932-ADD shear word. +2. The eight-bank formal word is correct on arbitrary inputs. An independent + faithful16-by-16 binary matrix representation matches all16 frozen prefixes + and verifies the literal inverse. Independent Laurent-monomial tracking of + all nine fresh factors checks matched prefixes, actual idle windows, final + `Gamma9 N I8`, and the full fresh-word inverse. +3. Both requested mutations change actual entries: omit the middle old B or + omit one terminal CNOT. Explicit differing input/output coordinates are in + `INDEPENDENT-RESULT.json`. +4. The frozen source's unused `inverse_event` comment says all declared + primitives are involutive. This is false for `new_F`; its square adds + `(1+N)x` to the target. The executed inverse loop is correct and uses + `new_F_inverse`. Preserve frozen provenance; explain this stale comment + rather than reproducing its claim. +5. The actual changed windows give42 width-eight slots per port,4662 total, + versus3888 helper occurrences. This is aggregate capacity only. It does not + establish a chronological owner assignment or reuse of an old owner map. +6. D15 belongs to the historical six private3 fanouts. The later zero-private + local interface removes18 units, yielding optimistic D33. Substitution at + the changed cuts remains a native-interface premise. At L9,n8 the arithmetic + is56799 query mass versus56832 parent mass. +7. The all-L conditional pressure theorem holds: three unchanged old seed + profiles, m=1+7L, L≥3, complete D≤33 and child ranks≤m imply failure at every + a≥1/500, since `P>21108762/609725=33+987837/609725`. +8. The three sensitivity controls only lose this coarse certificate. They + establish no passing moment or changed supplier. New stock/progress credit + cannot be silently excluded by the nonnegative-pressure argument; the + complete D≤33 condition must remain explicit. +9. PR3850 (James Reed), head8f97d229d208e5fce7b42e6a1f1b8bf3cf522950, + audits Gonzalo-Mier's retained PR3772 pure schedule with L=2K+1 and L−1 + public banks. Its idle volume is7L(L−3) per port and its full-target + deficit is−1 per port/replica. This does not conflict with the present + direct L-bank diagonal schedule, idle7L(L−2), D0. Use the precise changed + interface/caller headline, credit PR3850/3772, and avoid generic FULL-target + deficit claims. Pinned README, verifier and source manifest were inspected; + its producer was not executed by this review. +10. The direct proof explicitly uses L≥2, source-once/target-once banks with + two distinct active calls each, nonnegative idle volume, and legal whole + helper hosting. Its aggregate capacity already forces L≥7. Neither that + capacity inequality nor the symbolic polynomial constructs an owner map. + +## Evidence and responsibilities + +`independent_check.py` imports no historical producer. It reads the frozen +receipts as comparison data, constructs its own elementary matrices and fresh +monomials, parses the old literal histogram, and evaluates exact fractions. +`INDEPENDENT-RESULT.json` records source hashes, witnesses, windows and invoices. +`VALIDATION.json` records normal/optimized equality for this independent audit. +`PROOF-CALLER.md` supplies the written derivations and full scope boundaries. + +The parent owns local native-word verification, source-history checks, portable +package integration and publication. The recursive/native specialist owns the +source/target interface at actual changed cuts and arbitrary helper restoration. +Chronological ownership, rounded precision, physical tape and all-size transfer +remain separate. No positive supplier or new κ follows from this review. + +Prepared with substantial OpenAI Codex assistance; Apache-2.0. diff --git a/research/r429-full-target-interface/REVIEW-NATIVE.md b/research/r429-full-target-interface/REVIEW-NATIVE.md new file mode 100644 index 0000000000..a31f852f0a --- /dev/null +++ b/research/r429-full-target-interface/REVIEW-NATIVE.md @@ -0,0 +1,105 @@ +# Independent review of the R429 FULL-target word + +Verdict: **PASS for the exact finite scalar/frame/lift contract, with the +historical prose correction below required in the current publication.** +This is AI-assisted mathematical review, not independent human certification +or a formal-kernel proof. Substantial OpenAI Codex assistance; Apache-2.0. + +Only this external review directory was written. The frozen originals and +publication worktree were not modified. No producer or producer utility +was imported or run by the independent checker. + +## Material corrections and boundaries + +1. The historical `allsize_lift` receipt sentence says every scalar ADD is + at ZERO or FULL. This is false:3027 ADDs use626 intermediate frames. + The full word has628 ADD frames;5758 ADDs are at ZERO and4147 at FULL. + Every ADD does satisfy its actual common-frame condition, and all1555 + new compensation ADDs are at FULL. This is a wording correction, not + a change to the executed word or proof domain. +2. The ordinary helpers are restored exactly **in logical coordinates**. + They enter ZERO and exit FULL, so the physical residual is `F8*h` under + the inherited convention. Physical identity restoration is not claimed. +3. The data block `[[S,0],[S,T]]` is over binary VALUE operators. The exact + signed scalar target is `y+A*x+E*h`. It has nonzero even residuals: + target111 has coefficient3 on source0 and coefficient2 on helper + register226. Therefore neither the word nor its extra111-ADD binary + diagonalization is an integer clean shear/identity on targets. +4. Prefix874 is the exact signed row-L1 envelope of this scalar word. + It is not the historical positive envelope, a native-child error bound, + an all-size rounded precision theorem or a physical-machine bound. +5. The12932 ADD invoice excludes the111 common-FULL diagonalizing ADDs. + The diagonalized interface costs13043 ADDs. Every one of the111 target + rank-one lifts is already included in rank mass5097. + +## Independent implementation and evidence + +Run from this directory: + + python3 -B independent_check.py + python3 -O -B independent_check.py + +The checker consumes the frozen final word and uses dense651-by651 Python +integer matrices rather than the producer's sparse-row implementation. +All arithmetic is exact and unbounded. The normal run generated +`RESULT.json`; the optimized run compares the whole receipt to that file. +No `assert` statement controls mathematical validation. + +It verifies: + +- Exact compressed/canonical word pins, the PR3645 predecessor's canonical + identity, and all raw source/geometry coordinates. +- Literal equality of the final records to the retained bulk,111 cap lifts + and nine prepare/scatter/literal-unprepare blocks. +- All651 arbitrary integer columns in both orientations;111 source and429 + helper identity rows; the full identity old-target block; all even helper + coefficients; and every source-to-target parity coefficient. +- The complete signed identity `A=B+K_01*R_01`, inverse matrix `2I-F`, and + literal inverse roundtrip on every integer column. +- Exact forward/inverse prefix874, with first maximum witnesses recorded. +- Every current frame, ADD common frame, nested MOVE and rational rank + increment; all2984 MOVEs and complete child-rank histogram. +- All111 actual entrance/cap projectors,3552 inherited ADDRESS columns and + 1776 new lift columns. Every checked identity is dyadic; odd-field + persistence follows from denominator4 and the norm-four roots. +- Actual omitted-scatter, wrong-unprepare-sign and omitted-lift controls. + The sign mutation is deliberately invisible modulo two and fails over Z. +- The extra111-ADD binary diagonalization and its surviving even integer + residuals. + +The complete forward signed matrix hash is +`2af146268741fcd566d4f2524ab1fe09805b121a7cdfde6e98aa3d0512b47c90`. +The complete literal inverse signed matrix hash is +`ea1cd1cb80234a743cfe24fd024de2cca6d96b5d1023f7d94e88314f02252cbc`. +The digest format is one comma-delimited dense integer row followed by a +newline, in the declared651-register order. `RESULT.json` also pins the +separate signed source and helper target blocks. + +## Proof and novelty audit + +`PROOF.md` derives the arbitrary-input binary correction from the literal +nine totals and states the separate integer endpoint. The raw R/K matrix +is reconstructed, not accepted from the final receipt. Each pivot is an +actual live source coordinate and includes its own original symbol, so the +construction never assumes a clean source scratch register. Its inverse +preparation is literal and restores that pivot before another total begins. + +The old cap projectors and3552 ADDRESS columns were already published with +the PR3645 predecessor. They are rechecked dependencies. The scoped changed +construction is the direct nine-total compensation with all111 targets +lifted to FULL, zero private compensation fields and its complete local +invoice. It does not repackage the predecessor's cap audit as a new result. + +The new lift proof is `D_I D_(I-P)=D_P` on the actual rank-one projector, +not an assumed change of endpoint width. The source residual has rank7, +targets rank8, and429 ordinary helpers each progress rank8. These sum to +exactly5097, agreeing with the independently replayed rank histogram. + +## Remaining ownership + +The parent owns frozen-source adapters, registered replay, source history, +current README correction, provenance/credit, publication and hosted CI. +The existing internal MOVE compiler and its guards are inherited. This +review does not newly admit all old native implementations, global helper +ownership, a whole caller, strict moments, rounded children, source/tape +costs or a stronger multiplication theorem. There is no new kappa. diff --git a/research/r429-full-target-interface/REVIEW-PORTABILITY.md b/research/r429-full-target-interface/REVIEW-PORTABILITY.md new file mode 100644 index 0000000000..7b681ebccd --- /dev/null +++ b/research/r429-full-target-interface/REVIEW-PORTABILITY.md @@ -0,0 +1,25 @@ +# B05/B06 source-to-replay integrity review + +Scope: portable finite replay and source binding for `research/r429-full-target-interface`. Initial snapshot: 15 frozen files, 10 uniquely matched text adaptations, three scientific stages, one mandatory complete generated word. The mathematical compensation and caller/pressure obligations have separate owners. No heavy mathematical stage was repeated for this review. + +## Findings + +No unresolved source-binding defect in the reviewed snapshot. All 15 original files were independently compared byte-for-byte with ORIGINS, and their lengths and SHA256 matched FROZEN-SHA256. See INTEGRITY.json for exact wrapper/manifest hashes. The canonical package copy has byte-identical verifier, controls, adaptations, frozen manifest, origins and replay manifest to that tested snapshot. + +The historical `allsize_lift` sentence was false. The current receipt changes exactly that one field, independently confirmed and enforced by `check_all`; the corrected receipt itself is hash-bound. The adapter substitutes that exact prose literal, leaving every arithmetic expression, loop, rank/frame check, cost and negative control intact. Every receipt field, including source hashes and the new prose, is compared with canonical JSON scalar types preserved. Provenance paths alone relocate; duplicate keys after relocation are rejected. + +An additional historical comment incorrectly called all declared caller primitives involutions. Its `inverse_event` helper is unused: `new_F=[[1,0],[1,N]]` has square lower-left `1+N`, and the executed inverse correctly selects `new_F_inverse`. The accepted comment-only adapter makes this explicit; no caller arithmetic or receipt was changed. + +`word_equal` authenticates the preserved gzip and requires exact equality of the entire decompressed regenerated byte body. A missing record is rejected. A different gzip header/compression with the same body is accepted deliberately. `word_gzip_sha256` therefore records historical container provenance; `word_canonical_sha256` and full-body equality bind the generated word. The README makes this distinction. Main additionally requires the exact receipt set and exact mandatory word set, preventing an omitted comparison from becoming success. + +## Closure, read-only execution and optimization + +The executed scientific closure is compensation -> full_targets -> old cap/scalar, plus caller and pressure: six Python sources. Pressure parses the seventh frozen Python file, upstream verify_rehost, as AST to recover LOCAL_B, rather than executing it. The two compressed source words and exact expected receipts are retained. Main methods in old imported modules are not invoked; their unused historical file references are not part of this replay dependency closure. + +Frozen SourceFileLoader get_code is intercepted for direct and nested imports; authenticated adapted source is compiled with `dont_inherit=True, optimize=0`. The exact source read for authentication is the source compiled, bypassing timestamp-valid stale bytecode. The controls bootstrap verifier directly from bytes with optimize=0. Outer checks use explicit raises and remain active under -O. Scientific stage arguments are reset to a single program path, so inherited optional --write branches cannot be selected; producer writes are replaced by receipt/body equality, and imported historical mains are not called. No original/frozen source or receipt is written during the supported replay. + +Both normal and -O controls passed via the actual repository `run_python_replay` helper, including its private `-X pycache_prefix`: source-byte and receipt-byte corruption, omitted query, changed R bit, bool-to-int receipt mutation, normalized path collision, truncated complete word, equivalent gzip container, and a demonstrated timestamp/size-valid poisoned cache in the nested cap import. This is meaningful cache rejection because the ordinary loader first admits the poisoned cache. All mutations occur only in the control's disposable copy. + +## Limits + +This source-integrity result preserves the stated finite integer/F2, exact dyadic and conditional pressure checks. It does not discharge the inherited all-modulus native compiler, rounded children, physical owners, tape/source access, changed-cut admission, or a favorable complete recurrence. The historical arbitrary common-frame ADDs cannot be promoted to native ZERO/FULL-only compilation. No new kappa or formal-kernel proof follows. Root owns final registered replay, metadata, publication and CI. Independent mathematical checker additions require a subsequent closure/adapter delta audit. diff --git a/research/r429-full-target-interface/SOURCES.json b/research/r429-full-target-interface/SOURCES.json new file mode 100644 index 0000000000..533cd43edc --- /dev/null +++ b/research/r429-full-target-interface/SOURCES.json @@ -0,0 +1,42 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "files": [ + { + "path": "certificates/selected-result.json", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "usage": "provenance" + }, + { + "path": "docs/research/agent-task-catalog.json", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0", + "usage": "provenance" + }, + { + "path": "research/bit-r438-transport-rehost/words/r438-t154.json.gz", + "git_blob": "e12a566658a4b2c8b6ae0ecc34fd41290f68f5e8", + "sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022", + "usage": "provenance" + }, + { + "path": "research/bit-r438-transport-rehost/verify_rehost.py", + "git_blob": "58c76b9d7b6ed12e4473a4b38b5193f867b2d674", + "sha256": "4774841de10a8386204519174c5e56eb14f5852b20058db38a65a1034eeba275", + "usage": "provenance" + }, + { + "path": "research/bit-r438-transport-rehost/README.md", + "git_blob": "f94092e67129f60b2ec39b9c78ef343a17961e6b", + "sha256": "ca62c113c07282e25230cd22fabdd0affc2bf35a792b3251444e3551dab75474", + "usage": "provenance" + }, + { + "path": "docs/research/research-family-status.md", + "git_blob": "9b7d65650d8fcd6247a758936b24426b40e40efa", + "sha256": "9b98ab42364e90588e90410fd2773f9bc4bf5050f514101bed0a0246881b5b7e", + "usage": "provenance" + } + ] +} diff --git a/research/r429-full-target-interface/TASK.json b/research/r429-full-target-interface/TASK.json new file mode 100644 index 0000000000..e98eaa9e19 --- /dev/null +++ b/research/r429-full-target-interface/TASK.json @@ -0,0 +1,71 @@ +{ + "schema_version": 1, + "task_id": "coverage-law-change", + "original_card": { + "id": "coverage-law-change", + "question": "Can a template or call contract leave two or more unpaid coordinates per live family?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/idle-axis-hosting/PROOF.md", + "certificates/selected-result.json" + ], + "methods": [ + "State a replacement for the coverage identity (mass = 72W + 64N) and the contract change that realizes it, with its implementation cost.", + "Find an obstruction: show which data-endpoint obligation forces exactly one unpaid coordinate in the current template." + ], + "acceptance_gate": "An explicit replacement identity, verified on a small complete instance with dirty inputs, priced with ceiling.ceiling(unpaid=...). 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", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Explain where the single unpaid coordinate per family comes from in the hosted template; propose one change and price it. Ideal budget: two unpaid coordinates per family is 3.77x (levers.py).", + "bottleneck_link": "The deficit is one coordinate per family minus the centre charge; doubling unpaid coordinates per family scales it directly.", + "allowed_variations": [ + "One template change or one endpoint-contract change.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Counting a coordinate as unpaid while leaving it unadvanced in the data endpoint.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "coverage identity", + "unpaid coordinate", + "deficit law", + "W - 64N" + ] + }, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "priority_revision": 6, + "author": "Ross Richardson", + "ai_assistance": "Substantial OpenAI Codex assistance; separate AI proof reviews, no independent human or formal-kernel certification.", + "scope_status": "changed", + "scope_change_reason": "User assigned reviewed publication of preserved unpublished contributions. This item completes one changed endpoint contract and its full paid accounting; it does not construct a positive coverage law.", + "actual_scope": "Exact zero-private R429 FULL-target interface, complete local bill and conditional seeded-caller exclusion.", + "bottleneck_link": "Tests whether removing private repair cost survives the paid target lifts and caller coverage.", + "budget_minutes": 240, + "outcome": "completed", + "evidence": "Written local and caller proofs, independent dense/native and faithful-ring/fresh-path reconstructions, complete source-bound word and receipt replay with defect controls. Source-integrity final integration review and hosted CI recorded separately.", + "stop_rule": "Finish this local interface and its conditional caller invoice; no new supplier search.", + "open_questions": [ + { + "question": "Can a changed native multi-output interface avoid the111 target lifts at lower complete cost?", + "why_it_matters": "The current local word has zero rank deficit despite no private fields.", + "first_step": "Specify actual target/source cuts and arbitrary-dirt restoration, then count every native call, copy and cleanup.", + "blocked_by": "No cheaper admitted varying-cap compensation interface is supplied." + }, + { + "question": "Can a different caller obtain a favorable complete moment with this endpoint?", + "why_it_matters": "The diagonal topology has D0 and the fixed three-seed caller fails a>=1/500 under D<=33.", + "first_step": "Derive independent raw-input endpoints and an entire priced histogram including changed idle/owner windows.", + "blocked_by": "No fully charged positive changed caller is established." + } + ] +} diff --git a/research/r429-full-target-interface/VERIFY.json b/research/r429-full-target-interface/VERIFY.json new file mode 100644 index 0000000000..8144464234 --- /dev/null +++ b/research/r429-full-target-interface/VERIFY.json @@ -0,0 +1,84 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "compensation" + ], + "timeout_seconds": 300, + "checks": "Complete regenerated word; all651 arbitrary integer/F2 columns in both directions, literal inverse,429 logical helper returns, full frame/rank ledger,111 cap lifts and three defects." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "independent-native" + ], + "timeout_seconds": 300, + "checks": "Independent dense651-column Z/F2 operator, signed inverse/roundtrip, exact bulk+K*R construction, all frame events and5328 dyadic ADDRESS columns; physical frame boundary and three actual mutations." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "caller" + ], + "timeout_seconds": 30, + "checks": "Eight-bank exact coefficient-ring word, inverse, fresh idle windows and two word mutations." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "pressure" + ], + "timeout_seconds": 30, + "checks": "All-L conditional pressure exclusion from pinned old seed profile, exact rational logarithm bound and three premise controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py", + "--stage", + "independent-caller" + ], + "timeout_seconds": 60, + "checks": "Independent faithful16x16 binary regular representation, all16 prefixes, nine-variable fresh Laurent monomials and inverse, actual idle windows, full conditional invoices and exact rational pressure controls." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/controls.py" + ], + "timeout_seconds": 30, + "checks": "Frozen source/receipt, full word coverage, scalar type, path collision and nested poisoned bytecode rejection; equivalent gzip containers accepted." + } + ] +} diff --git a/research/r429-full-target-interface/controls.py b/research/r429-full-target-interface/controls.py new file mode 100644 index 0000000000..14e44b858c --- /dev/null +++ b/research/r429-full-target-interface/controls.py @@ -0,0 +1,103 @@ +#!/usr/bin/env python3 +"""Small source-binding and receipt-coverage rejection controls.""" +import copy +import gzip +import importlib.machinery +import importlib.util +import json +import os +from pathlib import Path +import py_compile +import shutil +import tempfile + + +ROOT = Path(__file__).resolve().parent +spec = importlib.util.spec_from_file_location('r429_verify', ROOT / 'verify.py') +verify = importlib.util.module_from_spec(spec) +exec(compile((ROOT / 'verify.py').read_bytes(), str(ROOT / 'verify.py'), + 'exec', dont_inherit=True, optimize=0), verify.__dict__) + + +def reject(action, marker): + try: + action() + except ValueError as error: + verify.need(marker in str(error), 'wrong rejection: ' + str(error)) + else: + raise ValueError('mutation accepted: ' + marker) + + +def main(): + with tempfile.TemporaryDirectory(prefix='r429 controls ') as directory: + root = Path(directory) / 'relocated package' + shutil.copytree(ROOT, root, ignore=shutil.ignore_patterns('__pycache__')) + p = verify.Portable(root) + p.check_all() + source = root / 'frozen/old/recursive/bit_cap_copy_local.py' + saved = source.read_bytes() + source.write_bytes(saved + b'\n# changed source\n') + reject(p.check_all, 'frozen input changed') + source.write_bytes(saved) + receipt = root / 'frozen/current/EXPECTED-COMPENSATION.json' + raw = receipt.read_bytes() + receipt.write_bytes(raw + b' ') + reject(p.check_all, 'frozen input changed') + receipt.write_bytes(raw) + actual = json.loads(raw) + verify.need(p.equal(receipt, actual), 'positive receipt control') + changed = copy.deepcopy(actual) + changed['queries'].pop() + reject(lambda: p.equal(receipt, changed), 'receipt mismatch') + changed = copy.deepcopy(actual) + changed['R'][0] ^= 1 + reject(lambda: p.equal(receipt, changed), 'receipt mismatch') + changed = copy.deepcopy(actual) + changed['no_new_kappa'] = 1 + reject(lambda: p.equal(receipt, changed), 'receipt mismatch') + changed = copy.deepcopy(actual) + old_key = next(iter(changed['sources'])) + mapped_key = p.normalize(old_key) + verify.need(old_key != mapped_key, 'path alias fixture') + original_hash = changed['sources'][old_key] + changed['sources'][old_key] = 'MUTATED_PROVENANCE_HASH' + changed['sources'][mapped_key] = original_hash + reject(lambda: p.equal(receipt, changed), 'normalized key collision') + + word_path = root / 'frozen/major/bit-endpoint/BIT-FULL-COMPENSATION-WORD.json.gz' + body = gzip.decompress(p.authenticate(word_path)) + p.word_equal(word_path, gzip.compress(body, compresslevel=1, mtime=123)) + program = json.loads(body) + program['records'].pop() + reject(lambda: p.word_equal(word_path, gzip.compress(verify.canonical(program).encode())), + 'complete regenerated word mismatch') + # Construct a timestamp/size-valid poisoned cache and first demonstrate + # that Python's ordinary source loader would accept its wrong code. + cache = Path(importlib.util.cache_from_source(str(source))) + cache.parent.mkdir(parents=True, exist_ok=True) + poison = Path(directory) / 'poison.py' + payload = b"raise RuntimeError('POISONED_R429_CACHE')\n#" + verify.need(len(payload) < len(saved), 'cache fixture source size') + poison.write_bytes(payload + b' ' * (len(saved) - len(payload))) + info = source.stat() + os.utime(poison, ns=(info.st_atime_ns, info.st_mtime_ns)) + py_compile.compile(str(poison), cfile=str(cache), doraise=True, + invalidation_mode=py_compile.PycInvalidationMode.TIMESTAMP) + try: + exec(importlib.machinery.SourceFileLoader('cache_probe', str(source)).get_code('cache_probe'), {}) + except RuntimeError as error: + verify.need(str(error) == 'POISONED_R429_CACHE', 'wrong cache fixture failure') + else: + raise ValueError('poisoned cache fixture was not admitted') + p.install() + module = p.load('frozen/major/bit-endpoint/bit_full_compensation.py') + verify.need(module.b.cap.rank([[1, 0], [0, 1], [1, 1]]) == 2, 'authenticated nested source execution') + verify.need('frozen/old/recursive/bit_cap_copy_local.py' in p.executed, + 'nested source was not compiled') + p.check_all() + cache.unlink() + print('PASS_R429_FULL_CONTROLS source receipt coverage scalar_types word_body compression_equivalence path_collisions poisoned_cache nested_imports') + + +if __name__ == '__main__': + main() diff --git a/research/r429-full-target-interface/frozen/changed/budgets/SEEDED-STAR-PRESSURE.json b/research/r429-full-target-interface/frozen/changed/budgets/SEEDED-STAR-PRESSURE.json new file mode 100644 index 0000000000..cea58a57b6 --- /dev/null +++ b/research/r429-full-target-interface/frozen/changed/budgets/SEEDED-STAR-PRESSURE.json @@ -0,0 +1,41 @@ +{ + "assumptions": [ + "Integer L>=3; parent arity m=1+7L; three unchanged R438 seed calls occur.", + "Full candidate invoice has deficit D=mW-sum(c_r*r)<=33 after every cost is included.", + "Every child rank r is at most m, so omitted pressure terms are nonnegative.", + "The desired primitive supplier exponent a is at least1/500." + ], + "deficit_upper": 33, + "necessary_condition": "For normalized moment sum(c_r/W)*(r/m)^(1-a)<1, pressure sum(c_r*r*((m/r)^a-1)) must be less than D.", + "negative_controls": [ + "omit one seed", + "relax max child rank7 to8", + "increase available deficit33 to35" + ], + "not_claimed": [ + "universal BIT upper bound", + "independent replay of R438 native word", + "complete new-star owner allocation", + "new valid kappa" + ], + "one_seed_rank_mass": 5121, + "outer_transfer": "Tests primitive a=.002 directly. It does not assume kappa=a/(1+a) is the only available outer theorem. Both direct-target and retained-transfer routes to kappa>=.002 require a>=.002.", + "pressure_strict_lower": "21108762/609725", + "profile_source": "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/verify_rehost.py", + "profile_source_sha256": "4774841de10a8386204519174c5e56eb14f5852b20058db38a65a1034eeba275", + "proof": "Keep only three seeds. For each r<=7 and m>=22, (m/r)^a-1 >= a*ln(m/r) >= (1/500)*ln(22/7). Use ln(22/7)>2*(15/29+(15/29)^3/3). All inequalities are monotone for a>=1/500.", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "scope": "Any completed invoice retaining these assumptions is rejected, irrespective of native or owner admission. The source-bound ideal D33 comes from N111:2*N-3*63. Added missing costs only strengthen rejection; a different seed, common coverage, rank profile or deficit is outside this theorem.", + "seed_profile": { + "1": 1322, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 18 + }, + "seed_word_sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022", + "status": "PASS_ALL_L_FIXED_THREE_SEED_STAR_REJECTION", + "strict_excess": "987837/609725" +} diff --git a/research/r429-full-target-interface/frozen/changed/budgets/SEEDED-STAR-PRESSURE.md b/research/r429-full-target-interface/frozen/changed/budgets/SEEDED-STAR-PRESSURE.md new file mode 100644 index 0000000000..56e8e465c5 --- /dev/null +++ b/research/r429-full-target-interface/frozen/changed/budgets/SEEDED-STAR-PRESSURE.md @@ -0,0 +1,44 @@ +# Fixed three-seed BIT star cannot reach primitive exponent .002 + +This is an all-parameter necessary-cost obstruction, conditional on the +declared seed profile and ideal deficit. It is not a universal BIT bound. +Scientific pin: `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. + +Let the complete child histogram be `c_r`, parent arity `m`, width `W`, and +deficit `D=mW-sum(r*c_r)`. Its normalized moment at primitive exponent `a` +is below one exactly when + + sum_r r*c_r*((m/r)^a-1) < D. + +The changed seeded star has `L>=3`, `m=1+7L>=22`, and three unchanged R438 +seed calls. The pinned source profile of each seed has rank mass5121 and +maximum child rank7. Grant the remaining new calls, idle queries, owner +completion and padding their most favorable declared deficit `D<=33`. +This upper budget is `2*111-3*63`; the zero-private FULL-target fanout adds +no surplus. Any extra charges reduce the available deficit. A construction +changing this coverage or any seed profile requires a new analysis. + +For every `a>=1/500`, the three seeds alone exert pressure at least + + 15363/500 * ln(22/7) + > 15363/500 * 2*(15/29 + (15/29)^3/3) + = 21108762/609725 + = 33 + 987837/609725 > D. + +Here `exp(t)-1>=t` for `t>=0`, and the strict logarithm bound is the first +two positive terms of `ln(x)=2*atanh((x-1)/(x+1))`. Every omitted term is +nonnegative because all child ranks are at most the parent arity. This +proves rejection for every L, without an asymptotic approximation, finite +parameter sweep or any missing owner cost being treated as free progress. + +The argument tests primitive exponent .002 directly. Earlier handoff +screens evaluated the conservative retained map `a=kappa/(1-kappa)`; +that map is not asserted to be necessary for every newer outer theorem. +The present rejection also applies when the outer exponent approaches a. + +Reproduce with `python3 seeded_star_pressure.py` from this directory. +The producer reads the literal seed profile through Python's AST, pins +the source word hash, and uses exact fractions. Its three sensitivity +controls deliberately invalidate the coarse rejection witness by dropping +one seed, raising the maximum rank, or raising D. These controls do not +establish that any changed construction exists or has a positive bound. diff --git a/research/r429-full-target-interface/frozen/changed/budgets/seeded_star_pressure.py b/research/r429-full-target-interface/frozen/changed/budgets/seeded_star_pressure.py new file mode 100644 index 0000000000..6f03a75647 --- /dev/null +++ b/research/r429-full-target-interface/frozen/changed/budgets/seeded_star_pressure.py @@ -0,0 +1,89 @@ +#!/usr/bin/env python3 +"""Exact necessary pressure bound for the fixed three-seed BIT star. + +This is a conditional rejection, not a complete supplier verification. +Apache-2.0. Substantial OpenAI Codex assistance. +""" +import argparse +import ast +from fractions import Fraction as Q +import hashlib +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = Path('/Users/ross/git/math') +SOURCE = ROOT / 'integer-mult-bounds/research/bit-r438-transport-rehost/verify_rehost.py' +WORD = SOURCE.parent / 'words/r438-t154.json.gz' +PIN = '20ecf2891d80b5acf18d980b2164fb44ea7faa90' +WORD_SHA = 'a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022' + +def need(condition, message): + if not condition: + raise ValueError(message) + +def log_lower(x): + """For x>1, ln(x) > 2(z+z^3/3), z=(x-1)/(x+1).""" + need(x > 1, 'positive atanh expansion argument') + z = (x-1)/(x+1) + return 2*(z+z**3/3) + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--write', action='store_true') + args = ap.parse_args() + source_bytes = SOURCE.read_bytes() + nodes = ast.parse(source_bytes).body + assignments = [n for n in nodes if isinstance(n, ast.Assign) + and any(isinstance(t, ast.Name) and t.id == 'LOCAL_B' for t in n.targets)] + need(len(assignments) == 1, 'unique source profile') + profile = ast.literal_eval(assignments[0].value) + need(profile == {1:1322, 2:1342, 3:79, 4:44, 5:102, 6:11, 7:18}, 'fixed seed profile') + need(hashlib.sha256(WORD.read_bytes()).hexdigest() == WORD_SHA, 'seed word source pin') + mass = sum(r*c for r,c in profile.items()) + need(mass == 5121, 'seed rank mass') + copies, exponent, min_arity, max_rank, deficit = 3, Q(1,500), 22, 7, 33 + lower = copies*mass*exponent*log_lower(Q(min_arity,max_rank)) + need(lower > deficit, 'strict contradiction to available deficit') + # Controls test sensitivity of this specific witness. They are not positive + # supplier claims when the sufficient rejection bound ceases to certify. + need(2*mass*exponent*log_lower(Q(min_arity,max_rank)) < deficit, + 'omitting one charged seed destroys this rejection witness') + need(copies*mass*exponent*log_lower(Q(min_arity,8)) < deficit, + 'relaxing maximum child rank to8 destroys this rejection witness') + need(lower < 35, 'larger D35 is not rejected by this coarse witness') + out = { + 'status':'PASS_ALL_L_FIXED_THREE_SEED_STAR_REJECTION', + 'scientific_pin':PIN, + 'profile_source':str(SOURCE), + 'profile_source_sha256':hashlib.sha256(source_bytes).hexdigest(), + 'seed_word_sha256':WORD_SHA, + 'seed_profile':profile, + 'one_seed_rank_mass':mass, + 'assumptions':[ + 'Integer L>=3; parent arity m=1+7L; three unchanged R438 seed calls occur.', + 'Full candidate invoice has deficit D=mW-sum(c_r*r)<=33 after every cost is included.', + 'Every child rank r is at most m, so omitted pressure terms are nonnegative.', + 'The desired primitive supplier exponent a is at least1/500.' + ], + 'scope':'Any completed invoice retaining these assumptions is rejected, irrespective of native or owner admission. The source-bound ideal D33 comes from N111:2*N-3*63. Added missing costs only strengthen rejection; a different seed, common coverage, rank profile or deficit is outside this theorem.', + 'necessary_condition':'For normalized moment sum(c_r/W)*(r/m)^(1-a)<1, pressure sum(c_r*r*((m/r)^a-1)) must be less than D.', + 'proof':'Keep only three seeds. For each r<=7 and m>=22, (m/r)^a-1 >= a*ln(m/r) >= (1/500)*ln(22/7). Use ln(22/7)>2*(15/29+(15/29)^3/3). All inequalities are monotone for a>=1/500.', + 'pressure_strict_lower':str(lower), + 'deficit_upper':deficit, + 'strict_excess':str(lower-deficit), + 'outer_transfer':'Tests primitive a=.002 directly. It does not assume kappa=a/(1+a) is the only available outer theorem. Both direct-target and retained-transfer routes to kappa>=.002 require a>=.002.', + 'negative_controls':['omit one seed','relax max child rank7 to8','increase available deficit33 to35'], + 'not_claimed':['universal BIT upper bound','independent replay of R438 native word','complete new-star owner allocation','new valid kappa'], + } + out = json.loads(json.dumps(out)) + target = HERE/'SEEDED-STAR-PRESSURE.json' + if args.write: + target.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n') + else: + need(json.loads(target.read_text()) == out, 'stored exact receipt mismatch') + print(out['status']) + print(f'all L>=3, a>=1/500: pressure>{lower}>33; three controls PASS') + +if __name__ == '__main__': + main() diff --git a/research/r429-full-target-interface/frozen/current/EXPECTED-COMPENSATION.json b/research/r429-full-target-interface/frozen/current/EXPECTED-COMPENSATION.json new file mode 100644 index 0000000000..d1c6cffccc --- /dev/null +++ b/research/r429-full-target-interface/frozen/current/EXPECTED-COMPENSATION.json @@ -0,0 +1,2218 @@ +{ + "K": [ + 496, + 22, + 511, + 25, + 21, + 499, + 26, + 508, + 118, + 488, + 415, + 491, + 117, + 412, + 217, + 161, + 174, + 214, + 324, + 316, + 307, + 331, + 295, + 185, + 351, + 193, + 339, + 205, + 299, + 181, + 179, + 290, + 196, + 341, + 199, + 342, + 176, + 289, + 164, + 314, + 309, + 171, + 313, + 167, + 168, + 310, + 493, + 405, + 124, + 112, + 481, + 409, + 398, + 104, + 502, + 385, + 31, + 505, + 103, + 445, + 454, + 91, + 457, + 434, + 84, + 47, + 478, + 55, + 425, + 59, + 421, + 76, + 466, + 265, + 369, + 382, + 262, + 370, + 266, + 261, + 381, + 286, + 358, + 248, + 357, + 251, + 285, + 131, + 138, + 283, + 253, + 364, + 241, + 352, + 134, + 279, + 372, + 234, + 229, + 379, + 271, + 145, + 158, + 475, + 419, + 74, + 50, + 416, + 472, + 49, + 73 + ], + "R": [ + 2589350794613531190557368506174057, + 2592804956806343667382164200032873, + 1038469893558777993237266185156761, + 1557652228689369648595160641472409, + 1042515851693473237291206096564751, + 2442767368115540430947582893869040, + 2441038363121116511671115291243110, + 915714330356837041509315611365683, + 610243267866258280493576590715221 + ], + "actual_address_projectors": [ + "79d8e6274c3681536ac1e15e35681ff31a980f74f647cbcaf34e8a3d4fa945c1", + "e0c1c6acb4c8618e65512ddeac87e4d3f300a531acfeb53aceb81424e7a76a61", + "268bad3f4c5c423253b5ac8c4ce956a7ddcb741725d1b01114d7cbb471d80743", + "182c621e833028d5e99a8e46ee95befc27319f5dcd61ee6f0411936ebe1f5a4f", + "d42b9dc41c4f0bb9b0c0e0faf0d0228c2731a68d1b0910c2ab08c4c39fee7004", + "c824b977113039cbf9e1cb74945571b53132feb85f56ea1679b7a47811470534", + "f969d31a0ad0b1c6ab51955f4a95cf05217a15147850a69985c52f695a4b1955", + "3e74c4801dcebd1dd451fcf69f5df8b03fdf3ff91cd2182b10953c3f22d585d5", + "60f742185837934d2232f5d7386af2c93eea2fee2dc058e749d1bc27ab1e81d0", + "130b0c45f8eba3f978453ab192bf051ac7f5a65e44f3ff3343297c98808d53fe", + "ce38a56da0632d7f6ab08d045c238924b5b104f58664daac6bb5945bfce5bfaf", + "5e1acd2fa47f81c83872e0831ce6ad32677378cbb70daa8dc7ab63a9919dfca0", + "3276f49ef67861c5354367bd84f3e3755ff93fea758ddbc4a9b96214d5ae4692", + "6b37fa580abf6bda33094cba9552abadfc4ac5862c8753bc12fa48096a73bd20", + "7fdd4b677001ee78efe89fb9db7990f628d052ff994aec357f5447173ab9e6c0", + "1132bbbff5ffab0932e35ea857138fec508ad2a67baf9689be120c4305cb2a74", + "776338ba24b624ff307fa64ad43490213c946ad717621accd905f3fbb4df68e8", + "1ef62b2c36129aee4d7512d146cbbe03fee50cbeca1dd7216aeb3cbd429b3d7b", + "614678a30d099fef5bbe57c688a43ab27242dc04cfa797f36d12f0816c40040f", + "247e93d1b21e72e8603721445fed1c45524b7d7424e9923742f561ffb2dce215", + "1554a44f52e9af939ca1a85307a5ba772a2841bd1980122a29aa88b77ab3202d", + "b592f04cf470eebbdd82c0370dd05a75faca7610426f0cab665324d382b9765f", + "79d41f318ec029c99f1893040b1a79b6c01310c1c99e0162ba69989799c06798", + "2d8c1ae941447b161654d3073825ca6fcbe2544580f9e3d687198a1386213757", + "9f61002dd86c2703538de49730359750a5f4215e76820227aae2b35a99a96a41", + "5f03c7f098f701187dd3c4eb2c5a728da0815778a519d74e15c3ec1c7f347164", + "f28c96c2b85a1cee1e32ede983c95b2f483f948a055425dc06aeb7b594e322df", + "ff0c205895f1d3e9efb6d10ce398e9e6efe90ad93bfd4fb201d0d968b0d42093", + "13793d3ddf67ddaa7cb63b101b4a0a7112937ab558aae7e7c36d0c1abd825a88", + "cc4282b1eeebf08c569ab223c5a902e730bcac48f8fdfbca8c8d97e850ddfc46", + "8633230bbdbc9d0272c3e9c58510a73b85f2d019f548e40f78f984defef07714", + "0390fb7131b1ce6b9ee1bd2180f904ab5600a94bdca1016f0f04d11fd4463bf4", + "a5a421ac2b7e17afbaad6f9208ddf0ef88928a25a9f6450fdd8eef19b66f3bd7", + "7cdd3169d9b56bed35daafcc9dc3b4d03b90bef59f987806ad439a7bc622aaf0", + "1d496935fb577681a87916a4fd46a4f5476bdfd39e12eb335756ec4db581bcab", + "ea3a4a0c35cedec7c6fd478f9def71aeb74c63f5a1d1d7fc49503b870ffd2b7f", + "5e79ce8d083d8be71a12f4d5f18aae06e44922f61f6892df7a5fb2c4c8e8eb2f", + "c82143cfd514515000ed6f81e7ba565fc3a415ef16a9c25caebb33f8b0e26334", + "1e155cfc15747e184449173486ace0d5966efc7b13cbdc69fe56c1f35ec3d531", + "511bdfbb1157404031cc3deca8ee4de8b268136020cfd992af0091fbc9605ae6", + "92617ab9d327e78d76674750e0d207c0f4e81579d1741db2e575bbbafd2a5c09", + "8fad0691dbc37dcad677743815cf2ab25669c3dc13f3b462e7ac0b1d3188e8db", + "cbf20d872e563c329334c4a6c00a58bb906590dad8120f64be4c048fe9a523f8", + "68ea647fd24a2eecacdb8f708c72250330c7ac421ca051e2db65b6a956bb0b32", + "8cdf2aad9251af8b0b7b1c43c0b18302e590fd473d7e2029539b801f1dcb9192", + "5d7c996a295c9fcdedd06359595ea704ee838cccdc11b8c9473dc7bdcc5daca1", + "76bb2a5c4c78aa61029e65c6164bd07a2b2012153866f6d2028f243ac77cbfbd", + "97304d0da6646e2dd155f962c50741cc8a69dcd1bc42aea5ba374378f7bf3a1d", + "1609df3dee8d12340e00dc70a0035033535db3329aa6e5153354ebc40723ef5f", + "1bdfba83e8dd5073a52d68d94a6990b0b6b6970bf680fde8a097e787699d512c", + "78e4327fc31716c42e2fed0bf6860d000bc8b38855bd7d9700b142eab1f357ae", + "cfd99f2ae2ebbbb64e943fce3d9584bde1da194230a9bfb291194709795f8e54", + "0db6911e159bcfc022d56ea9944b186861c3251b27f7826a41eb6f437ae2c927", + "66d4a1636b03174963329fded119c129f47d368eb5b11d0007440f684b8863d7", + "7a1d0a5d2df8026fa2925faf5285571b425a327898490504b2fd5f95bbe08f9f", + "848b4cc632ec92305a3d506bee97401ceed3d13c2511784de89a7ba860b7e3a9", + "c600fc6a38f1a91be94d17c012c18274aeaac1df5a8481548c7414c7c633891d", + "bae1ef84ccfa04e563d2533581b6b2119632fbc668e00385eb13762a477856a0", + "60aedbb346a447cbcff161a203fe9eedcd8579c9fe998a7ffffdaa86b973f2e8", + "d2e02e70bf3e53c3cdb892714f49d52fa8ebfe09734f5dfed6ac0a90b07811f8", + "486eba50ae82e1641ddd0b3c356230c55e0f58f9983da33bad17b1a9974a5488", + "194e0e6211add02e1da3807d157a66a52fe52c5044e77a73c31e9d7c12e5444a", + "b892f9bc7f5db1a47c78e6b1996b69e78e97fab68c9739ecfc09ea6ffcbd3258", + "a5c69528a47d7ba328b7602b2f496365c5637d774465408c293eae0cbccdb3e4", + "89b7ed50783e63757e4f1524dc72cadd67ea4e57e7a3593421df31de54d0a3b7", + "69e6ffaf40042c98d031a71a84ee17e95921a042a039e710f7c64452b83491b5", + "83abeccb6975fecf3418123d5bf5f0dbc37f225f017ea9005f6f61c4ddd4c8d0", + "89017fd9d438f351745685c5683a201da2a0aebe4ba06a2a1a6cb42e3dd6970d", + "8364b0e8f8d3d96c3a87530fabad07c02b792eb0831e020f7246e7582be2402a", + "4817739464852754584462aefe370d1f92cf87bd5d3d832d0dfe027577b88be8", + "458682ca42c823ff523c0196b28ce1b342d4bced51a90b1ad4e1d1968db76244", + "b11284986169b612f0c20564539ecdfdfae1a3422fcd238e0d69c221a67cc594", + "57fb7b17e2427f40554761a695fda1df91b5e1a14e58d64a7a8fc53eeebb97ab", + "dbf00a56a6955ccba2015e120cd0b8e3319b401bb491abc702d1d11422db0f7e", + "40758696ebf8f3a089133f3f29e6cb7713cef4b241671989c4c5f4c21c20843e", + "7537e826ba01c0fd95dd0d58821b91d657a767269b8c1ad055206e6de0602063", + "6b625d89bc944642e6d0926c13cbc74c70e2f8b8e62c74d6bfd7da95c662c8e6", + "701fa3310d36197cff63a4843c9ac8bf0aa65fa46735d585cd2a1255dbbc9d72", + "f56f085724b78f0532dc5e4054d0f1ab714d6853e27c204ba8fd82c80636ba23", + "095b7f7c2918a4e60d23c070edbad49027f6ad14beb6f94679bbc87c75060ac3", + "3d6965ca19144cc8fd6f80e3458a23b8143284c574d0c100bd7bac6b00dd42b0", + "c70fce3f2f2b86b1c314c8a7fd27ef17c42ead7d17735d638e5cc8f7154f764c", + "c8e82f94f49ea8328faa9d14c7ee8c2783dfc58f57b6eaa359cdee56c81b3380", + "88ed12254b589ca65ba74352f290020c367804373650cdd7bc1055dc59b0f2ae", + "7b737be117e751ceb2693a15d5b71996f31edacf3cec656a7c0eeee1f0c94a65", + "05d9579b4e0dbfe85be88a381df66fd52aabd3ad4da23cf29ed03117ecd1a3ac", + "f912831c0fd7f335be43791c9f824ccb2bb047e6ad365ae9241a26f47c1fd322", + "9bb0f26c4da16caec308419e9dd5b575ea641d451e06d3ad428f3018af737076", + "3114268fab1737e3b2b77adc78d2b6204a5f87216fffbf12b300db24552b441d", + "3f876da77efbc95e63d799a5d7c7f40f712718cbd09022b6405b9b95b6512485", + "d147ef712b3593c64a24f0df4001f5f6e16e85b4f5c0c86d567aa9afceb33a0b", + "1dfda9c806e9d33cf0a4a4d2a8730387f12ac0b3d9d714d92e76d79676e590f4", + "1140ffa3d16324db5a6e7b388d8d5791bbb5254bab1a38579e62d2544326724f", + "2af169c1046509dd34185e7bd4ecf18035aa00dba72e2c7faba99cb372e6ce55", + "93af14c784d33dec53a79566700b46c59aecf0c567cfa3bdac7c62cdea6101b8", + "6c9a0f033da926027adee0f0bd19f5bef2bb5e3d12387482673b529917cbc8a1", + "3f1adbca94ffed0358f50cef9b92293558548098598c88b3c6a2bb8a6cfbcfe6", + "e5729790d25394e5347b5e43e85e9c8a517d9d0e60fc2745029d972dc9f62275", + "0c9e7bb9fa3c4fc19cf75a174fb9e49f75d5042f4e763833eb991392c8218074", + "4959d3376cfcb9c6a3e03eaae8a04539dd900d6ef6b6c496186c1080f3baefc6", + "ebc14607f7b3123473317f9494d76e1144171127880f5ed3b69051a61203fa24", + "16374d1cf2572f80198e5427ecfe7446768682e7df4d385c878575c39ff6d078", + "4cef63154a7d8958ce1cbc13d47775e01aa78fadc7b6227fcae2725e104a5127", + "25894d983aeba72bf03749347791649105c5b46926cc27570c8532d755a87792", + "4784f9d79a16a988efb37e170b4cc6e358f8670a7d48229d222f282f84e97c99", + "b48a5e9e8df3f59ba3cbc6dc0e0ce8dad78723dac30967dc86f2bc197a43fac6", + "402cb05d88009484a64926b9c773ec817ab2a2cf67b5dd838b966e230613ea1e", + "bdbbcab223d7f0037bafa7707a52bbacacc6377e53791476a40ce8984d978faf", + "713cc26615448c785c23b6125101da48374d876ab9b98e11f2fd56205dd7a1e4", + "7f4cddff0e857be475b3a4073f9742197dec4e90740b3f2d8a6674536339c645", + "07ac05c5098cb58514f5eacfe99132676527bf96de2565ff7564a03789e47181" + ], + "all111_physical_correction_rows": [ + { + "K_mask": 496, + "physical_target": 0, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 22, + "physical_target": 1, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 511, + "physical_target": 2, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 25, + "physical_target": 3, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 21, + "physical_target": 4, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 499, + "physical_target": 5, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 26, + "physical_target": 6, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 508, + "physical_target": 7, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 118, + "physical_target": 8, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 488, + "physical_target": 9, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 415, + "physical_target": 10, + "source_root_span": 8, + "source_support_size": 62 + }, + { + "K_mask": 491, + "physical_target": 11, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 117, + "physical_target": 12, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 412, + "physical_target": 13, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 217, + "physical_target": 14, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 161, + "physical_target": 15, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 174, + "physical_target": 16, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 214, + "physical_target": 17, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 324, + "physical_target": 18, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 316, + "physical_target": 19, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 307, + "physical_target": 20, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 331, + "physical_target": 21, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 295, + "physical_target": 22, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 185, + "physical_target": 23, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 351, + "physical_target": 24, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 193, + "physical_target": 25, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 339, + "physical_target": 26, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 205, + "physical_target": 27, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 299, + "physical_target": 28, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 181, + "physical_target": 29, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 179, + "physical_target": 30, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 290, + "physical_target": 31, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 196, + "physical_target": 32, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 341, + "physical_target": 33, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 199, + "physical_target": 34, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 342, + "physical_target": 35, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 176, + "physical_target": 36, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 289, + "physical_target": 37, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 164, + "physical_target": 38, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 314, + "physical_target": 39, + "source_root_span": 8, + "source_support_size": 56 + }, + { + "K_mask": 309, + "physical_target": 40, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 171, + "physical_target": 41, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 313, + "physical_target": 42, + "source_root_span": 8, + "source_support_size": 62 + }, + { + "K_mask": 167, + "physical_target": 43, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 168, + "physical_target": 44, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 310, + "physical_target": 45, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 493, + "physical_target": 46, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 405, + "physical_target": 47, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 124, + "physical_target": 48, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 112, + "physical_target": 49, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 481, + "physical_target": 50, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 409, + "physical_target": 51, + "source_root_span": 8, + "source_support_size": 62 + }, + { + "K_mask": 398, + "physical_target": 52, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 104, + "physical_target": 53, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 502, + "physical_target": 54, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 385, + "physical_target": 55, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 31, + "physical_target": 56, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 505, + "physical_target": 57, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 103, + "physical_target": 58, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 445, + "physical_target": 59, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 454, + "physical_target": 60, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 91, + "physical_target": 61, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 457, + "physical_target": 62, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 434, + "physical_target": 63, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 84, + "physical_target": 64, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 47, + "physical_target": 65, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 478, + "physical_target": 66, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 55, + "physical_target": 67, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 425, + "physical_target": 68, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 59, + "physical_target": 69, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 421, + "physical_target": 70, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 76, + "physical_target": 71, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 466, + "physical_target": 72, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 265, + "physical_target": 73, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 369, + "physical_target": 74, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 382, + "physical_target": 75, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 262, + "physical_target": 76, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 370, + "physical_target": 77, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 266, + "physical_target": 78, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 261, + "physical_target": 79, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 381, + "physical_target": 80, + "source_root_span": 8, + "source_support_size": 63 + }, + { + "K_mask": 286, + "physical_target": 81, + "source_root_span": 8, + "source_support_size": 62 + }, + { + "K_mask": 358, + "physical_target": 82, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 248, + "physical_target": 83, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 357, + "physical_target": 84, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 251, + "physical_target": 85, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 285, + "physical_target": 86, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 131, + "physical_target": 87, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 138, + "physical_target": 88, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 283, + "physical_target": 89, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 253, + "physical_target": 90, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 364, + "physical_target": 91, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 241, + "physical_target": 92, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 352, + "physical_target": 93, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 134, + "physical_target": 94, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 279, + "physical_target": 95, + "source_root_span": 8, + "source_support_size": 62 + }, + { + "K_mask": 372, + "physical_target": 96, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 234, + "physical_target": 97, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 229, + "physical_target": 98, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 379, + "physical_target": 99, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 271, + "physical_target": 100, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 145, + "physical_target": 101, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 158, + "physical_target": 102, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 475, + "physical_target": 103, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 419, + "physical_target": 104, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 74, + "physical_target": 105, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 50, + "physical_target": 106, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 416, + "physical_target": 107, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 472, + "physical_target": 108, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 49, + "physical_target": 109, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 73, + "physical_target": 110, + "source_root_span": 8, + "source_support_size": 59 + } + ], + "all_arbitrary_integer_columns": 651, + "allsize_lift": "Every scalar ADD is at its actual common frame. The NEW nine-total compensation ADDs are at FULL, with source-pivot totals prepared and unprepared without retained snapshots. Inherited internal ADD/MOVE realizations remain a separate native compiler contract. Actual frame labels and containment are replayed on651 ordinary roles. All-size rounded/tape implementation remains a separate obligation.", + "endpoint": "Source x and429helpers unchanged exactly overZ. Target y unchanged exactly; target updatex modulo2; helper targetleakageeven. Both data banks atFULL. Exact literal integer inverse returns all inputs.", + "exact_ADDRESS_identity_columns": 3552, + "executed_controls": { + "missing_one_actual_scatter_changes_F2_endpoint": true, + "omitted_target_lift_rejected": "native common-frame ADD / immutable snapshot", + "wrong_unprepare_changes_Z_source_but_not_F2": true + }, + "forward": { + "copies": 0, + "prefix_row_l1": 874, + "profile": { + "1": 1406, + "2": 1342, + "3": 79, + "4": 44, + "5": 93, + "6": 11, + "7": 9 + }, + "rank_mass": 5097, + "records": { + "0": 2984, + "1": 12932 + } + }, + "global_accounting": "Direct n=L diagonal-call topology hasD0, not LN. The111 rank1 target lifts percall are counted here and cannot be omitted from an old common-axis invoice.", + "helpers_restored_over_Z": 429, + "literal_inverse": { + "copies": 0, + "prefix_row_l1": 874, + "profile": { + "1": 1406, + "2": 1342, + "3": 79, + "4": 44, + "5": 93, + "6": 11, + "7": 9 + }, + "rank_mass": 5097, + "records": { + "0": 2984, + "1": 12932 + } + }, + "native_progress": 5097, + "new_target_lift_ADDRESS_columns": 1776, + "new_target_lift_ADDRESS_sha256": [ + "d2c32afd4093f34ec86716dee5d659b01a512ad841f240b474b0fa2ea54ae54d", + "7b4fd24f48cdb1e61fccb02b30d0786b1407654074aeb0a7f994248a67eef537", + "7a0091f10e8d96cb299c51c0859346214486ddf454f73d9f5818cd26c5b068c4", + "2347c035967c527ab3beea7001e3b3eec3e94548395281921af8564928c11148", + "02d4462b7a05aedc9dc23ad5e13e7291a78dea07786daf450961571d5496ab23", + "2d1723ba6269642ebc257cbffada8df399465f71b2beea76e43f6e2439d7f235", + "784b4bdf3f514a0fe74b3f77365dca2efb8edcc3dec75163d04f8744bb087864", + "1c98ea5948d5190619da4dfc5c6241d9cb8d9045ff93c248946ae1d1a1787781", + "51190885310d40cd899f495af044800193e6c8638f3bca7455e1ed203ac78a21", + "83e4b90297c4d9bb0e6c54466742a8232d0251f1919bd69e7e2088189f854442", + "bf0b0ca9b132a78458746d79bffc0e1a44619bfa69ddec1ee15bd7b37be80680", + "f001730c7739b3ce5ced7294de592c96ce64787524c1ef6ad01d906840c622f2", + "0c1331775fa461009fbf88fc56a8dff31f6e49845dd7fac50d17823f99a79379", + "18545020eff53d0f97f02966b139b079a0d065d3f611edd108308e37a101cafb", + "aa2ea0f7e098f5b2739b1984ec2b3d0d04b08dc08f25a68e10ee2d9f0b0088de", + "74a737bba14bb4582ce88b7fa254f4d72009411abf88aad5e064356e396ecef6", + "006f4a1c59102f6a25f1316d02684e9ae78cb9d0c744a66d86a8d4dfe6aef052", + "15ca7f215161710f90633e603efeef925303511eaeefb512c7533d467688276a", + "d22141ade915bbe5c0f1b9ab00cf662e011e30e77ee659adda82ca150e44cc4e", + "9e756a4095c7960a1384cb3188d2f70581df2063e12a2ef37b4a7c946a7113ff", + "9e0be765434f77c65166c9d0deb760de2dcf5cd4de5ba33e33b880870fc1a38b", + "ea60769e2d33e5b5c7afce1c19945ad46abeb3971326b1530e8d0e0b7c17e9aa", + "3fa9cff7e89492914355e2bd42b7c5b1dd5e94dfcabd03aeb106b0f24c6e3cc4", + "dca8002e854c096e2d03a6feac5f16f8dc4820915f6381c6fefe0537bf4e5dee", + "779c4966bb2c6641471b6271c3908af7a1a40bb6de95eccff80ab1b26fe434c5", + "7122801bd9d4d19d509241cc245ee1d7cc7b6c23a49372b3682486b5833161fb", + "73a53eed3a9e876ed9f1b8ee69a1df866e370fe31d232843c671640f73adda57", + "0700e4ef8a5d0d7c8c8a215566e5429543bab7c45cbd83ac6699de356085afb2", + "d9e7aad823d2335e4dbf8b099dac0ef00a25a7b6749f996f93af4c99499c61ea", + "8d758df176d6536fb5b396f32e51df91cda21236366f0e05d95a4414534ecbbd", + "9551f613cc099fdfb9d0716b23e4fe006447b2ef11b611cd809ccd8a1e6ff823", + "6b06b1c5a2c01a5e1bdbb1025e891916f5da7a0a37a5119a88fb244c93574fd4", + "6872cb6bb8adfc104ceff20562f0805a4bd5b8360dfd16cce677773dc589c4b1", + "4876f9b455e0b2bbe5e5ba6139bb7c3a445ec732e35ef04a9965331b76195e10", + "620836a500880b73b9cfa35c95c0656b2827bcc227692084bbc7cba1a77f722d", + "0a8174f3bcb35a2ef0f0c6493c36d530b2e5730368e312d052cf5172738637e7", + "c90d2c70d852a278d0a015c76b929a48b6398c82429d13310e07d5d3bff02a51", + "ccecc6231a6a1dd01088467666b4c25770658b4da2eedc82f6c0b93ed83e6d28", + "6b1b14c8b0c2b43c2e08f3206b44c4f6977d1c8bcbc1bc940b838cc3f9888322", + "78f057f2f9cb133c8670fd10aa67c43e0fde98fa31bf67d763984005794355c9", + "c31a2595effa50f963fc7168fa7cdda98c4b58f5f2d31e3a21da64358a610585", + "be24264e7bc1b3862cc864f0d8b8bb917d4580f5abfa51f34af9df6e8556efb5", + "e292e818dc2209295d0efe10b27021148da4e0e00db18c7b41278ebd4f396503", + "4c6e4b31ff207cf71b4c9970415896b9601ddc2795d8cbf5272b64684bd65eed", + "e1237a0e11230edddc8b917db3bff363c5602b387e7e7b8c056588b36cdf43ac", + "0cb532fce722f9270d6097c3b75008cb71d8bdabe25794b3831b8544e05966b9", + "6eeeb291a4c4af8c5e66b149413abc6b4f71b115af4154a86035d3c8e603edd5", + "598bbd423deb4e50551240446ceeae9d68db0e6e7461545000f01ee7cc77c775", + "9023798db010a3d8b5ad598f73fa8272c0542644b04082a6b07d3e686fcd39d6", + "4f6bd242812c1b74781c696d10ce3ce37e2ff74d90bc7cdd3df9d2b326b289db", + "c1d1b897200f24d9a85f2a9566f76dad4b0a67274ab9528a50bada41b9e04b66", + "7d6851ebd6c8f7a92a913f9f138563f50c30eb805a262cc65645804acfb7bcbe", + "0e065676a747821046d9de2bb1c6c20d2152c448b37cdb70a982afebb866693d", + "dcd41ed055360fff40d4b7d26d5a2e20673336f98b78c41795c5cb0b16eee7cc", + "95d103aab0e74957abfbb16f9fb7d7a047f6767724b84624c37d0b3c72c99b75", + "bc9d573badb53e4960f6dde8ee4bade99d05352f901be474e10e692d86eec252", + "a78e1883ef36bdcad6d689fa99b27d75c8af907e7a0b289c57818d87b3263777", + "ea1fc3f5acf7b3344e2904893e1e2741db3aa5339e1bfff030982de325e96ab4", + "92b9675f7ed59b0122c09f8c6e82a5f45a781d6897069e4721658a4fa84f5abf", + "161ef1fb56a069a63a3291d3b5b2f1836db574ff3df18dcfba3383a0c0f7d39f", + "f1475f25a27d60431b45b24531e7692c2a904e5d29c95c6cc8e2e7229fb95a68", + "e7e5b28ab41c9f83d35344118621e3a593d61e5a3133ecdd5890c3c53953e1d4", + "495d83ea2d8bc6dc2d6b002c2b20ae09cdd1906bf64d06d25dc0d34aff60facd", + "84db5053c9fb1748754ffb80b66bad55539144c5167da0b104d2a3fc562f9be8", + "3937ff6b56c95c565d8463a46b6e7248af04f876564a9980d6a2d5fdce7be089", + "854b55c2e1f50e28c6e7897f3e0a543fdb81c5445b97623ef1da7253e6dc027b", + "c09181cb9615624c485f8f48fb6f616cec1e0c83e2366d4e0df943dd11ab7f44", + "48fb071bbdc9e1db13cb67ca4a4af177a6e7e1d9221cd4108838cd7ef09e246f", + "831855872c4d87195803f40fe16c7cbc338350eeb1799da8d5cd8f98d69756e3", + "7ee50e89b93c9841da91ef7404352e9657c85087ce5e48e5ef3ae0db7c716200", + "1a1417196473470b1821347238af48d72e483fc3f07b6529effeece55c1a284c", + "78eaad9a32ebfc82518532a9258f88aedf4a3df87db9d3744534dd0cd8cf2cd0", + "5d72661a73ced4bf321aa080670ededebd23505005a62202027eb1f622cd9aa3", + "12a866a71b0fa00860b5c12f0df473cf4f27618299578e7de5f9ef498030c402", + "572224bc76dc2e8985d1a2207ce0cee87acabc14aab53249794c9df81ccbaade", + "c36ca380e031c8500d9493a7a380958b55ad052cb74705e06459a4e97742ec31", + "a0fb1a5c9184fc94a2a53959e77f95fa96fd8d40fcbf7f108bc2b942ebdb9cc7", + "36783293457f89e7ba42a795bcfafc924687f8ca282ea1be8e4e88ad97e5d174", + "4d97b105d6ba3a7467abb4bc1b75c28863478b85eb72a193a6421525929d8e00", + "1978a27ccbcfbe5c31c91847ebe897122ad6a659ccb588c164114ff4df82e0c3", + "90d506603e00ac5f58b581e97048889b49826c4b362847ad2779818f5012bce4", + "54e481be354034a9a24818708d7dfc4c4e13ec0ff36177a8bbedae06693deea4", + "a988a5ab5c976ac9767c7fcd63b00430848411be0f35a69570300fd831f8e057", + "9f50d37d825e24754828e4db18c1630b79f0339cba82b85dba15b1f4cb82ad56", + "71bdffa30e546226b0a1e5d90f4f25b1c44f2251657ee64801be7ae5fad57859", + "6c47ffdc091a0ff800f373e32f342c9d8f5f551dca0d2f4cd9b681536a3d613f", + "42f341496599f8c839df00d659ed6e95aedde74397651e670c467b9b97ae00e2", + "89ac48ec4c875f4ec34a8deee748c7327f323890d06b56837b62ce04ebeb8aeb", + "6a2c9d309b779b86f7ed220ca72954e25aae2cc2f948fe0d51ef5d63bf3b45c5", + "66d6e459300d9cc4fe89f6e0b0c92d0ff5733c79ec30a1b528e011aef8faa56f", + "d0b0a9e09a903da8f4701116186d4e006f889da7924b9ad2874f25583836b703", + "115cda2dabf08b0108777cf5ebc3371447089b84f846b5ac41aa3dcd4e8e006d", + "4acce20635968f29e8c447ac08b8742afb68366ddf30a0c03690ffdbd9ba45f7", + "19d75b26d926fe78efc696473d74ad5bcd03cc93015a064939358740f2d0b198", + "077a693e5ec46fffc010614764079b92bc3d5859efb5b219fc0020ecc7f31912", + "6e11fa2bc9f0722a6a47fc1457cd2bccfb806c57f316ddfc57be37017f503f04", + "2a26f1d183560f9321c71363943fbd006569c7b3a42d8d9c9106113f38e740a2", + "489a5d2aeaddb2475466ea8bbfcccaf3c94f91ddcd1342bad8379b281c1c1f3d", + "93da13ceda8893197b641799f2407d505fa5aff8ecbcee4c01853a2482ceb4ca", + "7314dd75554a17351f88a476ab2f347ef66c37644c324fc6145c5d8ad0cc5ce2", + "d46a7e19fa282061b311196532c24c4cdecdd43324e5375fa5a12209ee6ccfea", + "55d37292fff7400e84bc368097a4fd9419f48915d3602410e38ee4d5fd5f47d5", + "3c8df638040b70d5b1b15fd0afa3f4a4413df59301727da28faf567268512e8f", + "db0e72300a67a68f09705423da4726b8edcbf882752d379d54a2c511d1ae54db", + "032102e7e72ba6fd6310d854bada48c7bc8836072f13c972928a2e9f85b35e98", + "6d788a240288b4279094e0cf0fdb5596b5622330fb71086ccb7596be6fc62bda", + "37942397d22bb980fe46a3575802b16648c442fd388ef8bcdf7e3cf0b4c6e7c8", + "d541ada7edb22ec6a9f74ba9174758e7d93c847a1eb0aec59b49ea34d603a605", + "a81d5ab706ac22b195a9ecf4350d4b231a039c6c8197d7c06d6b4a380f2ec499", + "d9509a5435b7bc757b23578a6706d0324344a86658ea67cc081ec714e26e4f5b", + "6261b8b01461833d449075ced9969e3b0e473fe3bc1cb54af3b47ea18183cdbe" + ], + "new_target_rank1_lifts": 111, + "no_new_kappa": true, + "partial_target_gate": "All111Krows are nonzero. Every KR row includes its own source and at least one other source, and its actual E8 source-line span has rank8. For this physical-output gather alphabet, no row can be prepared at target cap K_p, which omits own P_p. A FULL pure-query pivot needs one rank1 immutable COPY to a cap target, or a source descent+return costs2. Those bills do not beat the one target lift. A changed multi-output factor/native source-consumption word is not excluded by this census.", + "physical_block": "For arbitrary physical inputs, raw F=[[S,0],[S,T]], S=F8 D_P native7,T=F8 native8. An extra111 commonFULL ADDs diagonalizes toS/T; those ADDs are not included in the emitted shear word.", + "private_excess": 0, + "private_fields": 0, + "queries": [ + { + "R_index": 0, + "pivot": 0, + "source_support": [ + 0, + 3, + 5, + 6, + 9, + 11, + 14, + 15, + 20, + 21, + 23, + 25, + 26, + 28, + 30, + 31, + 36, + 37, + 39, + 41, + 42, + 44, + 49, + 50, + 51, + 53, + 55, + 57, + 61, + 62, + 63, + 68, + 69, + 72, + 73, + 74, + 77, + 78, + 83, + 85, + 87, + 88, + 89, + 92, + 93, + 97, + 99, + 101, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110 + ], + "target_support": [ + 2, + 3, + 4, + 5, + 10, + 11, + 12, + 14, + 15, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 33, + 34, + 37, + 40, + 41, + 42, + 43, + 46, + 47, + 50, + 51, + 55, + 56, + 57, + 58, + 59, + 61, + 62, + 65, + 67, + 68, + 69, + 70, + 73, + 74, + 79, + 80, + 84, + 85, + 86, + 87, + 89, + 90, + 92, + 95, + 98, + 99, + 100, + 101, + 103, + 104, + 109, + 110 + ] + }, + { + "R_index": 1, + "pivot": 0, + "source_support": [ + 0, + 3, + 5, + 6, + 9, + 11, + 16, + 17, + 18, + 19, + 22, + 24, + 27, + 29, + 30, + 31, + 36, + 37, + 39, + 41, + 42, + 44, + 46, + 47, + 48, + 52, + 54, + 56, + 58, + 59, + 60, + 64, + 65, + 66, + 67, + 70, + 71, + 73, + 74, + 77, + 78, + 83, + 85, + 87, + 90, + 91, + 94, + 95, + 96, + 98, + 100, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110 + ], + "target_support": [ + 1, + 2, + 5, + 6, + 8, + 10, + 11, + 16, + 17, + 20, + 21, + 22, + 24, + 26, + 28, + 30, + 31, + 34, + 35, + 39, + 41, + 43, + 45, + 52, + 54, + 56, + 58, + 60, + 61, + 63, + 65, + 66, + 67, + 69, + 72, + 75, + 76, + 77, + 78, + 81, + 82, + 85, + 87, + 88, + 89, + 94, + 95, + 97, + 99, + 100, + 102, + 103, + 104, + 105, + 106 + ] + }, + { + "R_index": 2, + "pivot": 0, + "source_support": [ + 0, + 3, + 4, + 7, + 11, + 12, + 13, + 14, + 16, + 19, + 21, + 22, + 23, + 28, + 29, + 30, + 32, + 35, + 37, + 38, + 39, + 44, + 45, + 46, + 50, + 53, + 54, + 55, + 56, + 61, + 62, + 63, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 75, + 77, + 79, + 81, + 84, + 85, + 88, + 90, + 92, + 94, + 96, + 97, + 100, + 101, + 104, + 105, + 108, + 109 + ], + "target_support": [ + 1, + 2, + 4, + 7, + 8, + 10, + 12, + 13, + 16, + 17, + 18, + 19, + 22, + 24, + 27, + 29, + 32, + 33, + 34, + 35, + 38, + 40, + 43, + 45, + 46, + 47, + 48, + 52, + 54, + 56, + 58, + 59, + 60, + 64, + 65, + 66, + 67, + 70, + 71, + 75, + 76, + 79, + 80, + 81, + 82, + 84, + 86, + 90, + 91, + 94, + 95, + 96, + 98, + 100, + 102 + ] + }, + { + "R_index": 3, + "pivot": 0, + "source_support": [ + 0, + 3, + 4, + 7, + 8, + 9, + 10, + 15, + 17, + 18, + 20, + 22, + 23, + 28, + 29, + 31, + 33, + 34, + 36, + 38, + 39, + 44, + 45, + 46, + 50, + 52, + 57, + 58, + 59, + 60, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 75, + 77, + 79, + 82, + 83, + 86, + 87, + 88, + 90, + 92, + 94, + 98, + 99, + 102, + 103, + 106, + 107, + 110 + ], + "target_support": [ + 2, + 3, + 6, + 7, + 9, + 10, + 11, + 13, + 14, + 16, + 19, + 21, + 23, + 24, + 27, + 28, + 39, + 41, + 42, + 44, + 46, + 48, + 51, + 52, + 53, + 56, + 57, + 59, + 61, + 62, + 65, + 66, + 68, + 69, + 71, + 73, + 75, + 78, + 80, + 81, + 83, + 85, + 86, + 88, + 89, + 90, + 91, + 97, + 99, + 100, + 102, + 103, + 105, + 108, + 110 + ] + }, + { + "R_index": 4, + "pivot": 0, + "source_support": [ + 0, + 1, + 2, + 3, + 9, + 12, + 13, + 15, + 16, + 19, + 20, + 23, + 24, + 27, + 28, + 31, + 32, + 35, + 36, + 39, + 40, + 43, + 44, + 47, + 48, + 50, + 54, + 56, + 57, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 70, + 71, + 74, + 75, + 78, + 79, + 82, + 85, + 86, + 89, + 90, + 93, + 94, + 97, + 98, + 101, + 102, + 104, + 105, + 108, + 109 + ], + "target_support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 10, + 12, + 13, + 14, + 17, + 19, + 20, + 23, + 24, + 26, + 29, + 30, + 33, + 35, + 36, + 39, + 40, + 42, + 45, + 47, + 48, + 49, + 51, + 54, + 56, + 57, + 59, + 61, + 63, + 64, + 66, + 67, + 69, + 72, + 74, + 75, + 77, + 80, + 81, + 83, + 85, + 86, + 89, + 90, + 92, + 95, + 96, + 99, + 101, + 102, + 103, + 106, + 108, + 109 + ] + }, + { + "R_index": 5, + "pivot": 4, + "source_support": [ + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 14, + 15, + 16, + 17, + 26, + 27, + 28, + 29, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 46, + 47, + 48, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 60, + 62, + 65, + 69, + 70, + 71, + 72, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 88, + 89, + 90, + 91, + 100, + 101, + 102, + 107, + 108, + 109, + 110 + ], + "target_support": [ + 0, + 2, + 5, + 7, + 8, + 9, + 11, + 12, + 15, + 16, + 19, + 20, + 22, + 23, + 28, + 29, + 30, + 31, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 48, + 49, + 50, + 53, + 54, + 57, + 58, + 59, + 63, + 65, + 67, + 68, + 69, + 70, + 74, + 75, + 77, + 80, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 96, + 97, + 98, + 99, + 104, + 106, + 107, + 109 + ] + }, + { + "R_index": 6, + "pivot": 1, + "source_support": [ + 1, + 2, + 5, + 6, + 9, + 12, + 13, + 16, + 17, + 20, + 21, + 23, + 25, + 27, + 29, + 32, + 33, + 36, + 37, + 39, + 41, + 43, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 54, + 56, + 58, + 60, + 61, + 63, + 65, + 68, + 70, + 71, + 75, + 76, + 77, + 78, + 83, + 84, + 86, + 90, + 91, + 92, + 93, + 97, + 99, + 100, + 102, + 107, + 108, + 109, + 110 + ], + "target_support": [ + 0, + 2, + 5, + 7, + 8, + 9, + 11, + 12, + 14, + 17, + 18, + 21, + 24, + 25, + 26, + 27, + 32, + 33, + 34, + 35, + 46, + 48, + 49, + 50, + 53, + 54, + 57, + 58, + 60, + 61, + 62, + 64, + 66, + 71, + 72, + 74, + 75, + 77, + 80, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 96, + 97, + 98, + 99, + 103, + 105, + 108, + 110 + ] + }, + { + "R_index": 7, + "pivot": 0, + "source_support": [ + 0, + 1, + 4, + 5, + 8, + 12, + 15, + 17, + 18, + 20, + 22, + 25, + 26, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 40, + 43, + 45, + 47, + 49, + 50, + 54, + 55, + 58, + 60, + 63, + 64, + 67, + 70, + 72, + 74, + 76, + 77, + 79, + 82, + 84, + 87, + 92, + 93, + 94, + 95, + 96, + 98, + 101, + 104, + 106, + 107, + 109 + ], + "target_support": [ + 0, + 2, + 5, + 7, + 9, + 10, + 11, + 13, + 14, + 15, + 16, + 17, + 23, + 25, + 27, + 29, + 30, + 32, + 34, + 36, + 38, + 41, + 43, + 44, + 46, + 47, + 50, + 51, + 52, + 54, + 55, + 57, + 59, + 60, + 62, + 63, + 66, + 68, + 70, + 72, + 83, + 85, + 87, + 88, + 90, + 92, + 94, + 97, + 98, + 101, + 102, + 103, + 104, + 107, + 108 + ] + }, + { + "R_index": 8, + "pivot": 0, + "source_support": [ + 0, + 2, + 4, + 6, + 8, + 11, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 24, + 27, + 29, + 30, + 32, + 35, + 37, + 39, + 40, + 43, + 44, + 46, + 47, + 49, + 52, + 54, + 55, + 57, + 59, + 63, + 65, + 66, + 68, + 69, + 71, + 73, + 74, + 75, + 76, + 83, + 84, + 86, + 89, + 91, + 92, + 94, + 97, + 98, + 100, + 105, + 106, + 107, + 108 + ], + "target_support": [ + 0, + 2, + 5, + 7, + 9, + 10, + 11, + 13, + 18, + 19, + 20, + 21, + 22, + 24, + 26, + 28, + 31, + 33, + 35, + 37, + 39, + 40, + 42, + 45, + 46, + 47, + 50, + 51, + 52, + 54, + 55, + 57, + 59, + 60, + 62, + 63, + 66, + 68, + 70, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 84, + 86, + 89, + 91, + 93, + 95, + 96, + 99, + 100, + 103, + 104, + 107, + 108 + ] + } + ], + "rank_mass": 5097, + "remaining": [ + "Actual changed global caller, chronological owners and complete moment.", + "New rounded precision/suffix-error and physical source/tape bill.", + "No positive kappa or new selected bound." + ], + "scalar_ADDs": 12932, + "source_codes": 0, + "sources": { + "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/bit_cap_copy_local.py": "6e9ca1eb905d769716c009904f45d6849b225e48cd119f18b50c0379f35313cb", + "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/bit_signed_audit.py": "376356696663021693c0e2c9adf37f371675fe8837fb88232b8767a8b90793e8", + "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/root-pruned-code/BIT-PRUNED-WORD.json.gz": "1a6841fccba51fa922993c77b4b296e659c2c538252e5e06113d0438c5edb870", + "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint/bit_full_compensation.py": "a7bda83b84ab15a75c418225e3d5c2fda8eded8577a894341225f757e6ea7e20", + "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint/bit_full_targets.py": "7446290e462752b76b9461696b7676c8295739aba1b79eea0d77925f5f9a3869", + "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022" + }, + "status": "PASS_R429_FULL_NINE_TOTAL_COMPENSATION_NO_SOURCE_CODE_NO_PRIVATE", + "word_canonical_sha256": "895a359e33a7a9a9cb2c4a68acc9fcf624596d334a52381264ae498e0e55c847", + "word_gzip_sha256": "0f461dbc7e82a02faedb4a5129103963507c9f063a0a3679ba5d20ad94df160e" +} diff --git a/research/r429-full-target-interface/frozen/major/bit-endpoint/BIT-FULL-COMPENSATION-WORD.json.gz b/research/r429-full-target-interface/frozen/major/bit-endpoint/BIT-FULL-COMPENSATION-WORD.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..763c88cbdc09a2ba3f86ffa89887e0f72abe07b3 GIT binary patch literal 57926 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 DPzyc> literal 0 HcmV?d00001 diff --git a/research/r429-full-target-interface/frozen/major/bit-endpoint/BIT-FULL-COMPENSATION.json b/research/r429-full-target-interface/frozen/major/bit-endpoint/BIT-FULL-COMPENSATION.json new file mode 100644 index 0000000000..8b23379ee8 --- /dev/null +++ b/research/r429-full-target-interface/frozen/major/bit-endpoint/BIT-FULL-COMPENSATION.json @@ -0,0 +1,2218 @@ +{ + "K": [ + 496, + 22, + 511, + 25, + 21, + 499, + 26, + 508, + 118, + 488, + 415, + 491, + 117, + 412, + 217, + 161, + 174, + 214, + 324, + 316, + 307, + 331, + 295, + 185, + 351, + 193, + 339, + 205, + 299, + 181, + 179, + 290, + 196, + 341, + 199, + 342, + 176, + 289, + 164, + 314, + 309, + 171, + 313, + 167, + 168, + 310, + 493, + 405, + 124, + 112, + 481, + 409, + 398, + 104, + 502, + 385, + 31, + 505, + 103, + 445, + 454, + 91, + 457, + 434, + 84, + 47, + 478, + 55, + 425, + 59, + 421, + 76, + 466, + 265, + 369, + 382, + 262, + 370, + 266, + 261, + 381, + 286, + 358, + 248, + 357, + 251, + 285, + 131, + 138, + 283, + 253, + 364, + 241, + 352, + 134, + 279, + 372, + 234, + 229, + 379, + 271, + 145, + 158, + 475, + 419, + 74, + 50, + 416, + 472, + 49, + 73 + ], + "R": [ + 2589350794613531190557368506174057, + 2592804956806343667382164200032873, + 1038469893558777993237266185156761, + 1557652228689369648595160641472409, + 1042515851693473237291206096564751, + 2442767368115540430947582893869040, + 2441038363121116511671115291243110, + 915714330356837041509315611365683, + 610243267866258280493576590715221 + ], + "actual_address_projectors": [ + "79d8e6274c3681536ac1e15e35681ff31a980f74f647cbcaf34e8a3d4fa945c1", + "e0c1c6acb4c8618e65512ddeac87e4d3f300a531acfeb53aceb81424e7a76a61", + "268bad3f4c5c423253b5ac8c4ce956a7ddcb741725d1b01114d7cbb471d80743", + "182c621e833028d5e99a8e46ee95befc27319f5dcd61ee6f0411936ebe1f5a4f", + "d42b9dc41c4f0bb9b0c0e0faf0d0228c2731a68d1b0910c2ab08c4c39fee7004", + "c824b977113039cbf9e1cb74945571b53132feb85f56ea1679b7a47811470534", + "f969d31a0ad0b1c6ab51955f4a95cf05217a15147850a69985c52f695a4b1955", + "3e74c4801dcebd1dd451fcf69f5df8b03fdf3ff91cd2182b10953c3f22d585d5", + "60f742185837934d2232f5d7386af2c93eea2fee2dc058e749d1bc27ab1e81d0", + "130b0c45f8eba3f978453ab192bf051ac7f5a65e44f3ff3343297c98808d53fe", + "ce38a56da0632d7f6ab08d045c238924b5b104f58664daac6bb5945bfce5bfaf", + "5e1acd2fa47f81c83872e0831ce6ad32677378cbb70daa8dc7ab63a9919dfca0", + "3276f49ef67861c5354367bd84f3e3755ff93fea758ddbc4a9b96214d5ae4692", + "6b37fa580abf6bda33094cba9552abadfc4ac5862c8753bc12fa48096a73bd20", + "7fdd4b677001ee78efe89fb9db7990f628d052ff994aec357f5447173ab9e6c0", + "1132bbbff5ffab0932e35ea857138fec508ad2a67baf9689be120c4305cb2a74", + "776338ba24b624ff307fa64ad43490213c946ad717621accd905f3fbb4df68e8", + "1ef62b2c36129aee4d7512d146cbbe03fee50cbeca1dd7216aeb3cbd429b3d7b", + "614678a30d099fef5bbe57c688a43ab27242dc04cfa797f36d12f0816c40040f", + "247e93d1b21e72e8603721445fed1c45524b7d7424e9923742f561ffb2dce215", + "1554a44f52e9af939ca1a85307a5ba772a2841bd1980122a29aa88b77ab3202d", + "b592f04cf470eebbdd82c0370dd05a75faca7610426f0cab665324d382b9765f", + "79d41f318ec029c99f1893040b1a79b6c01310c1c99e0162ba69989799c06798", + "2d8c1ae941447b161654d3073825ca6fcbe2544580f9e3d687198a1386213757", + "9f61002dd86c2703538de49730359750a5f4215e76820227aae2b35a99a96a41", + "5f03c7f098f701187dd3c4eb2c5a728da0815778a519d74e15c3ec1c7f347164", + "f28c96c2b85a1cee1e32ede983c95b2f483f948a055425dc06aeb7b594e322df", + "ff0c205895f1d3e9efb6d10ce398e9e6efe90ad93bfd4fb201d0d968b0d42093", + "13793d3ddf67ddaa7cb63b101b4a0a7112937ab558aae7e7c36d0c1abd825a88", + "cc4282b1eeebf08c569ab223c5a902e730bcac48f8fdfbca8c8d97e850ddfc46", + "8633230bbdbc9d0272c3e9c58510a73b85f2d019f548e40f78f984defef07714", + "0390fb7131b1ce6b9ee1bd2180f904ab5600a94bdca1016f0f04d11fd4463bf4", + "a5a421ac2b7e17afbaad6f9208ddf0ef88928a25a9f6450fdd8eef19b66f3bd7", + "7cdd3169d9b56bed35daafcc9dc3b4d03b90bef59f987806ad439a7bc622aaf0", + "1d496935fb577681a87916a4fd46a4f5476bdfd39e12eb335756ec4db581bcab", + "ea3a4a0c35cedec7c6fd478f9def71aeb74c63f5a1d1d7fc49503b870ffd2b7f", + "5e79ce8d083d8be71a12f4d5f18aae06e44922f61f6892df7a5fb2c4c8e8eb2f", + "c82143cfd514515000ed6f81e7ba565fc3a415ef16a9c25caebb33f8b0e26334", + "1e155cfc15747e184449173486ace0d5966efc7b13cbdc69fe56c1f35ec3d531", + "511bdfbb1157404031cc3deca8ee4de8b268136020cfd992af0091fbc9605ae6", + "92617ab9d327e78d76674750e0d207c0f4e81579d1741db2e575bbbafd2a5c09", + "8fad0691dbc37dcad677743815cf2ab25669c3dc13f3b462e7ac0b1d3188e8db", + "cbf20d872e563c329334c4a6c00a58bb906590dad8120f64be4c048fe9a523f8", + "68ea647fd24a2eecacdb8f708c72250330c7ac421ca051e2db65b6a956bb0b32", + "8cdf2aad9251af8b0b7b1c43c0b18302e590fd473d7e2029539b801f1dcb9192", + "5d7c996a295c9fcdedd06359595ea704ee838cccdc11b8c9473dc7bdcc5daca1", + "76bb2a5c4c78aa61029e65c6164bd07a2b2012153866f6d2028f243ac77cbfbd", + "97304d0da6646e2dd155f962c50741cc8a69dcd1bc42aea5ba374378f7bf3a1d", + "1609df3dee8d12340e00dc70a0035033535db3329aa6e5153354ebc40723ef5f", + "1bdfba83e8dd5073a52d68d94a6990b0b6b6970bf680fde8a097e787699d512c", + "78e4327fc31716c42e2fed0bf6860d000bc8b38855bd7d9700b142eab1f357ae", + "cfd99f2ae2ebbbb64e943fce3d9584bde1da194230a9bfb291194709795f8e54", + "0db6911e159bcfc022d56ea9944b186861c3251b27f7826a41eb6f437ae2c927", + "66d4a1636b03174963329fded119c129f47d368eb5b11d0007440f684b8863d7", + "7a1d0a5d2df8026fa2925faf5285571b425a327898490504b2fd5f95bbe08f9f", + "848b4cc632ec92305a3d506bee97401ceed3d13c2511784de89a7ba860b7e3a9", + "c600fc6a38f1a91be94d17c012c18274aeaac1df5a8481548c7414c7c633891d", + "bae1ef84ccfa04e563d2533581b6b2119632fbc668e00385eb13762a477856a0", + "60aedbb346a447cbcff161a203fe9eedcd8579c9fe998a7ffffdaa86b973f2e8", + "d2e02e70bf3e53c3cdb892714f49d52fa8ebfe09734f5dfed6ac0a90b07811f8", + "486eba50ae82e1641ddd0b3c356230c55e0f58f9983da33bad17b1a9974a5488", + "194e0e6211add02e1da3807d157a66a52fe52c5044e77a73c31e9d7c12e5444a", + "b892f9bc7f5db1a47c78e6b1996b69e78e97fab68c9739ecfc09ea6ffcbd3258", + "a5c69528a47d7ba328b7602b2f496365c5637d774465408c293eae0cbccdb3e4", + "89b7ed50783e63757e4f1524dc72cadd67ea4e57e7a3593421df31de54d0a3b7", + "69e6ffaf40042c98d031a71a84ee17e95921a042a039e710f7c64452b83491b5", + "83abeccb6975fecf3418123d5bf5f0dbc37f225f017ea9005f6f61c4ddd4c8d0", + "89017fd9d438f351745685c5683a201da2a0aebe4ba06a2a1a6cb42e3dd6970d", + "8364b0e8f8d3d96c3a87530fabad07c02b792eb0831e020f7246e7582be2402a", + "4817739464852754584462aefe370d1f92cf87bd5d3d832d0dfe027577b88be8", + "458682ca42c823ff523c0196b28ce1b342d4bced51a90b1ad4e1d1968db76244", + "b11284986169b612f0c20564539ecdfdfae1a3422fcd238e0d69c221a67cc594", + "57fb7b17e2427f40554761a695fda1df91b5e1a14e58d64a7a8fc53eeebb97ab", + "dbf00a56a6955ccba2015e120cd0b8e3319b401bb491abc702d1d11422db0f7e", + "40758696ebf8f3a089133f3f29e6cb7713cef4b241671989c4c5f4c21c20843e", + "7537e826ba01c0fd95dd0d58821b91d657a767269b8c1ad055206e6de0602063", + "6b625d89bc944642e6d0926c13cbc74c70e2f8b8e62c74d6bfd7da95c662c8e6", + "701fa3310d36197cff63a4843c9ac8bf0aa65fa46735d585cd2a1255dbbc9d72", + "f56f085724b78f0532dc5e4054d0f1ab714d6853e27c204ba8fd82c80636ba23", + "095b7f7c2918a4e60d23c070edbad49027f6ad14beb6f94679bbc87c75060ac3", + "3d6965ca19144cc8fd6f80e3458a23b8143284c574d0c100bd7bac6b00dd42b0", + "c70fce3f2f2b86b1c314c8a7fd27ef17c42ead7d17735d638e5cc8f7154f764c", + "c8e82f94f49ea8328faa9d14c7ee8c2783dfc58f57b6eaa359cdee56c81b3380", + "88ed12254b589ca65ba74352f290020c367804373650cdd7bc1055dc59b0f2ae", + "7b737be117e751ceb2693a15d5b71996f31edacf3cec656a7c0eeee1f0c94a65", + "05d9579b4e0dbfe85be88a381df66fd52aabd3ad4da23cf29ed03117ecd1a3ac", + "f912831c0fd7f335be43791c9f824ccb2bb047e6ad365ae9241a26f47c1fd322", + "9bb0f26c4da16caec308419e9dd5b575ea641d451e06d3ad428f3018af737076", + "3114268fab1737e3b2b77adc78d2b6204a5f87216fffbf12b300db24552b441d", + "3f876da77efbc95e63d799a5d7c7f40f712718cbd09022b6405b9b95b6512485", + "d147ef712b3593c64a24f0df4001f5f6e16e85b4f5c0c86d567aa9afceb33a0b", + "1dfda9c806e9d33cf0a4a4d2a8730387f12ac0b3d9d714d92e76d79676e590f4", + "1140ffa3d16324db5a6e7b388d8d5791bbb5254bab1a38579e62d2544326724f", + "2af169c1046509dd34185e7bd4ecf18035aa00dba72e2c7faba99cb372e6ce55", + "93af14c784d33dec53a79566700b46c59aecf0c567cfa3bdac7c62cdea6101b8", + "6c9a0f033da926027adee0f0bd19f5bef2bb5e3d12387482673b529917cbc8a1", + "3f1adbca94ffed0358f50cef9b92293558548098598c88b3c6a2bb8a6cfbcfe6", + "e5729790d25394e5347b5e43e85e9c8a517d9d0e60fc2745029d972dc9f62275", + "0c9e7bb9fa3c4fc19cf75a174fb9e49f75d5042f4e763833eb991392c8218074", + "4959d3376cfcb9c6a3e03eaae8a04539dd900d6ef6b6c496186c1080f3baefc6", + "ebc14607f7b3123473317f9494d76e1144171127880f5ed3b69051a61203fa24", + "16374d1cf2572f80198e5427ecfe7446768682e7df4d385c878575c39ff6d078", + "4cef63154a7d8958ce1cbc13d47775e01aa78fadc7b6227fcae2725e104a5127", + "25894d983aeba72bf03749347791649105c5b46926cc27570c8532d755a87792", + "4784f9d79a16a988efb37e170b4cc6e358f8670a7d48229d222f282f84e97c99", + "b48a5e9e8df3f59ba3cbc6dc0e0ce8dad78723dac30967dc86f2bc197a43fac6", + "402cb05d88009484a64926b9c773ec817ab2a2cf67b5dd838b966e230613ea1e", + "bdbbcab223d7f0037bafa7707a52bbacacc6377e53791476a40ce8984d978faf", + "713cc26615448c785c23b6125101da48374d876ab9b98e11f2fd56205dd7a1e4", + "7f4cddff0e857be475b3a4073f9742197dec4e90740b3f2d8a6674536339c645", + "07ac05c5098cb58514f5eacfe99132676527bf96de2565ff7564a03789e47181" + ], + "all111_physical_correction_rows": [ + { + "K_mask": 496, + "physical_target": 0, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 22, + "physical_target": 1, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 511, + "physical_target": 2, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 25, + "physical_target": 3, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 21, + "physical_target": 4, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 499, + "physical_target": 5, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 26, + "physical_target": 6, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 508, + "physical_target": 7, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 118, + "physical_target": 8, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 488, + "physical_target": 9, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 415, + "physical_target": 10, + "source_root_span": 8, + "source_support_size": 62 + }, + { + "K_mask": 491, + "physical_target": 11, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 117, + "physical_target": 12, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 412, + "physical_target": 13, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 217, + "physical_target": 14, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 161, + "physical_target": 15, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 174, + "physical_target": 16, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 214, + "physical_target": 17, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 324, + "physical_target": 18, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 316, + "physical_target": 19, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 307, + "physical_target": 20, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 331, + "physical_target": 21, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 295, + "physical_target": 22, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 185, + "physical_target": 23, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 351, + "physical_target": 24, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 193, + "physical_target": 25, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 339, + "physical_target": 26, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 205, + "physical_target": 27, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 299, + "physical_target": 28, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 181, + "physical_target": 29, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 179, + "physical_target": 30, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 290, + "physical_target": 31, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 196, + "physical_target": 32, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 341, + "physical_target": 33, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 199, + "physical_target": 34, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 342, + "physical_target": 35, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 176, + "physical_target": 36, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 289, + "physical_target": 37, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 164, + "physical_target": 38, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 314, + "physical_target": 39, + "source_root_span": 8, + "source_support_size": 56 + }, + { + "K_mask": 309, + "physical_target": 40, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 171, + "physical_target": 41, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 313, + "physical_target": 42, + "source_root_span": 8, + "source_support_size": 62 + }, + { + "K_mask": 167, + "physical_target": 43, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 168, + "physical_target": 44, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 310, + "physical_target": 45, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 493, + "physical_target": 46, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 405, + "physical_target": 47, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 124, + "physical_target": 48, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 112, + "physical_target": 49, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 481, + "physical_target": 50, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 409, + "physical_target": 51, + "source_root_span": 8, + "source_support_size": 62 + }, + { + "K_mask": 398, + "physical_target": 52, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 104, + "physical_target": 53, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 502, + "physical_target": 54, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 385, + "physical_target": 55, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 31, + "physical_target": 56, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 505, + "physical_target": 57, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 103, + "physical_target": 58, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 445, + "physical_target": 59, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 454, + "physical_target": 60, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 91, + "physical_target": 61, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 457, + "physical_target": 62, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 434, + "physical_target": 63, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 84, + "physical_target": 64, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 47, + "physical_target": 65, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 478, + "physical_target": 66, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 55, + "physical_target": 67, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 425, + "physical_target": 68, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 59, + "physical_target": 69, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 421, + "physical_target": 70, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 76, + "physical_target": 71, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 466, + "physical_target": 72, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 265, + "physical_target": 73, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 369, + "physical_target": 74, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 382, + "physical_target": 75, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 262, + "physical_target": 76, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 370, + "physical_target": 77, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 266, + "physical_target": 78, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 261, + "physical_target": 79, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 381, + "physical_target": 80, + "source_root_span": 8, + "source_support_size": 63 + }, + { + "K_mask": 286, + "physical_target": 81, + "source_root_span": 8, + "source_support_size": 62 + }, + { + "K_mask": 358, + "physical_target": 82, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 248, + "physical_target": 83, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 357, + "physical_target": 84, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 251, + "physical_target": 85, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 285, + "physical_target": 86, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 131, + "physical_target": 87, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 138, + "physical_target": 88, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 283, + "physical_target": 89, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 253, + "physical_target": 90, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 364, + "physical_target": 91, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 241, + "physical_target": 92, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 352, + "physical_target": 93, + "source_root_span": 8, + "source_support_size": 60 + }, + { + "K_mask": 134, + "physical_target": 94, + "source_root_span": 8, + "source_support_size": 58 + }, + { + "K_mask": 279, + "physical_target": 95, + "source_root_span": 8, + "source_support_size": 62 + }, + { + "K_mask": 372, + "physical_target": 96, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 234, + "physical_target": 97, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 229, + "physical_target": 98, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 379, + "physical_target": 99, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 271, + "physical_target": 100, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 145, + "physical_target": 101, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 158, + "physical_target": 102, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 475, + "physical_target": 103, + "source_root_span": 8, + "source_support_size": 61 + }, + { + "K_mask": 419, + "physical_target": 104, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 74, + "physical_target": 105, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 50, + "physical_target": 106, + "source_root_span": 8, + "source_support_size": 59 + }, + { + "K_mask": 416, + "physical_target": 107, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 472, + "physical_target": 108, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 49, + "physical_target": 109, + "source_root_span": 8, + "source_support_size": 57 + }, + { + "K_mask": 73, + "physical_target": 110, + "source_root_span": 8, + "source_support_size": 59 + } + ], + "all_arbitrary_integer_columns": 651, + "allsize_lift": "Every scalar ADD is at actual commonZERO or commonFULL; nine pure source-pivot totals are prepared and unprepared atFULL without retained snapshots. Actual native MOVE frames and containment are replayed on651 ordinaryroles. AllSIZE rounded/tape implementation remains a separate obligation.", + "endpoint": "Source x and429helpers unchanged exactly overZ. Target y unchanged exactly; target updatex modulo2; helper targetleakageeven. Both data banks atFULL. Exact literal integer inverse returns all inputs.", + "exact_ADDRESS_identity_columns": 3552, + "executed_controls": { + "missing_one_actual_scatter_changes_F2_endpoint": true, + "omitted_target_lift_rejected": "native common-frame ADD / immutable snapshot", + "wrong_unprepare_changes_Z_source_but_not_F2": true + }, + "forward": { + "copies": 0, + "prefix_row_l1": 874, + "profile": { + "1": 1406, + "2": 1342, + "3": 79, + "4": 44, + "5": 93, + "6": 11, + "7": 9 + }, + "rank_mass": 5097, + "records": { + "0": 2984, + "1": 12932 + } + }, + "global_accounting": "Direct n=L diagonal-call topology hasD0, not LN. The111 rank1 target lifts percall are counted here and cannot be omitted from an old common-axis invoice.", + "helpers_restored_over_Z": 429, + "literal_inverse": { + "copies": 0, + "prefix_row_l1": 874, + "profile": { + "1": 1406, + "2": 1342, + "3": 79, + "4": 44, + "5": 93, + "6": 11, + "7": 9 + }, + "rank_mass": 5097, + "records": { + "0": 2984, + "1": 12932 + } + }, + "native_progress": 5097, + "new_target_lift_ADDRESS_columns": 1776, + "new_target_lift_ADDRESS_sha256": [ + "d2c32afd4093f34ec86716dee5d659b01a512ad841f240b474b0fa2ea54ae54d", + "7b4fd24f48cdb1e61fccb02b30d0786b1407654074aeb0a7f994248a67eef537", + "7a0091f10e8d96cb299c51c0859346214486ddf454f73d9f5818cd26c5b068c4", + "2347c035967c527ab3beea7001e3b3eec3e94548395281921af8564928c11148", + "02d4462b7a05aedc9dc23ad5e13e7291a78dea07786daf450961571d5496ab23", + "2d1723ba6269642ebc257cbffada8df399465f71b2beea76e43f6e2439d7f235", + "784b4bdf3f514a0fe74b3f77365dca2efb8edcc3dec75163d04f8744bb087864", + "1c98ea5948d5190619da4dfc5c6241d9cb8d9045ff93c248946ae1d1a1787781", + "51190885310d40cd899f495af044800193e6c8638f3bca7455e1ed203ac78a21", + "83e4b90297c4d9bb0e6c54466742a8232d0251f1919bd69e7e2088189f854442", + "bf0b0ca9b132a78458746d79bffc0e1a44619bfa69ddec1ee15bd7b37be80680", + "f001730c7739b3ce5ced7294de592c96ce64787524c1ef6ad01d906840c622f2", + "0c1331775fa461009fbf88fc56a8dff31f6e49845dd7fac50d17823f99a79379", + "18545020eff53d0f97f02966b139b079a0d065d3f611edd108308e37a101cafb", + "aa2ea0f7e098f5b2739b1984ec2b3d0d04b08dc08f25a68e10ee2d9f0b0088de", + "74a737bba14bb4582ce88b7fa254f4d72009411abf88aad5e064356e396ecef6", + "006f4a1c59102f6a25f1316d02684e9ae78cb9d0c744a66d86a8d4dfe6aef052", + "15ca7f215161710f90633e603efeef925303511eaeefb512c7533d467688276a", + "d22141ade915bbe5c0f1b9ab00cf662e011e30e77ee659adda82ca150e44cc4e", + "9e756a4095c7960a1384cb3188d2f70581df2063e12a2ef37b4a7c946a7113ff", + "9e0be765434f77c65166c9d0deb760de2dcf5cd4de5ba33e33b880870fc1a38b", + "ea60769e2d33e5b5c7afce1c19945ad46abeb3971326b1530e8d0e0b7c17e9aa", + "3fa9cff7e89492914355e2bd42b7c5b1dd5e94dfcabd03aeb106b0f24c6e3cc4", + "dca8002e854c096e2d03a6feac5f16f8dc4820915f6381c6fefe0537bf4e5dee", + "779c4966bb2c6641471b6271c3908af7a1a40bb6de95eccff80ab1b26fe434c5", + "7122801bd9d4d19d509241cc245ee1d7cc7b6c23a49372b3682486b5833161fb", + "73a53eed3a9e876ed9f1b8ee69a1df866e370fe31d232843c671640f73adda57", + "0700e4ef8a5d0d7c8c8a215566e5429543bab7c45cbd83ac6699de356085afb2", + "d9e7aad823d2335e4dbf8b099dac0ef00a25a7b6749f996f93af4c99499c61ea", + "8d758df176d6536fb5b396f32e51df91cda21236366f0e05d95a4414534ecbbd", + "9551f613cc099fdfb9d0716b23e4fe006447b2ef11b611cd809ccd8a1e6ff823", + "6b06b1c5a2c01a5e1bdbb1025e891916f5da7a0a37a5119a88fb244c93574fd4", + "6872cb6bb8adfc104ceff20562f0805a4bd5b8360dfd16cce677773dc589c4b1", + "4876f9b455e0b2bbe5e5ba6139bb7c3a445ec732e35ef04a9965331b76195e10", + "620836a500880b73b9cfa35c95c0656b2827bcc227692084bbc7cba1a77f722d", + "0a8174f3bcb35a2ef0f0c6493c36d530b2e5730368e312d052cf5172738637e7", + "c90d2c70d852a278d0a015c76b929a48b6398c82429d13310e07d5d3bff02a51", + "ccecc6231a6a1dd01088467666b4c25770658b4da2eedc82f6c0b93ed83e6d28", + "6b1b14c8b0c2b43c2e08f3206b44c4f6977d1c8bcbc1bc940b838cc3f9888322", + "78f057f2f9cb133c8670fd10aa67c43e0fde98fa31bf67d763984005794355c9", + "c31a2595effa50f963fc7168fa7cdda98c4b58f5f2d31e3a21da64358a610585", + "be24264e7bc1b3862cc864f0d8b8bb917d4580f5abfa51f34af9df6e8556efb5", + "e292e818dc2209295d0efe10b27021148da4e0e00db18c7b41278ebd4f396503", + "4c6e4b31ff207cf71b4c9970415896b9601ddc2795d8cbf5272b64684bd65eed", + "e1237a0e11230edddc8b917db3bff363c5602b387e7e7b8c056588b36cdf43ac", + "0cb532fce722f9270d6097c3b75008cb71d8bdabe25794b3831b8544e05966b9", + "6eeeb291a4c4af8c5e66b149413abc6b4f71b115af4154a86035d3c8e603edd5", + "598bbd423deb4e50551240446ceeae9d68db0e6e7461545000f01ee7cc77c775", + "9023798db010a3d8b5ad598f73fa8272c0542644b04082a6b07d3e686fcd39d6", + "4f6bd242812c1b74781c696d10ce3ce37e2ff74d90bc7cdd3df9d2b326b289db", + "c1d1b897200f24d9a85f2a9566f76dad4b0a67274ab9528a50bada41b9e04b66", + "7d6851ebd6c8f7a92a913f9f138563f50c30eb805a262cc65645804acfb7bcbe", + "0e065676a747821046d9de2bb1c6c20d2152c448b37cdb70a982afebb866693d", + "dcd41ed055360fff40d4b7d26d5a2e20673336f98b78c41795c5cb0b16eee7cc", + "95d103aab0e74957abfbb16f9fb7d7a047f6767724b84624c37d0b3c72c99b75", + "bc9d573badb53e4960f6dde8ee4bade99d05352f901be474e10e692d86eec252", + "a78e1883ef36bdcad6d689fa99b27d75c8af907e7a0b289c57818d87b3263777", + "ea1fc3f5acf7b3344e2904893e1e2741db3aa5339e1bfff030982de325e96ab4", + "92b9675f7ed59b0122c09f8c6e82a5f45a781d6897069e4721658a4fa84f5abf", + "161ef1fb56a069a63a3291d3b5b2f1836db574ff3df18dcfba3383a0c0f7d39f", + "f1475f25a27d60431b45b24531e7692c2a904e5d29c95c6cc8e2e7229fb95a68", + "e7e5b28ab41c9f83d35344118621e3a593d61e5a3133ecdd5890c3c53953e1d4", + "495d83ea2d8bc6dc2d6b002c2b20ae09cdd1906bf64d06d25dc0d34aff60facd", + "84db5053c9fb1748754ffb80b66bad55539144c5167da0b104d2a3fc562f9be8", + "3937ff6b56c95c565d8463a46b6e7248af04f876564a9980d6a2d5fdce7be089", + "854b55c2e1f50e28c6e7897f3e0a543fdb81c5445b97623ef1da7253e6dc027b", + "c09181cb9615624c485f8f48fb6f616cec1e0c83e2366d4e0df943dd11ab7f44", + "48fb071bbdc9e1db13cb67ca4a4af177a6e7e1d9221cd4108838cd7ef09e246f", + "831855872c4d87195803f40fe16c7cbc338350eeb1799da8d5cd8f98d69756e3", + "7ee50e89b93c9841da91ef7404352e9657c85087ce5e48e5ef3ae0db7c716200", + "1a1417196473470b1821347238af48d72e483fc3f07b6529effeece55c1a284c", + "78eaad9a32ebfc82518532a9258f88aedf4a3df87db9d3744534dd0cd8cf2cd0", + "5d72661a73ced4bf321aa080670ededebd23505005a62202027eb1f622cd9aa3", + "12a866a71b0fa00860b5c12f0df473cf4f27618299578e7de5f9ef498030c402", + "572224bc76dc2e8985d1a2207ce0cee87acabc14aab53249794c9df81ccbaade", + "c36ca380e031c8500d9493a7a380958b55ad052cb74705e06459a4e97742ec31", + "a0fb1a5c9184fc94a2a53959e77f95fa96fd8d40fcbf7f108bc2b942ebdb9cc7", + "36783293457f89e7ba42a795bcfafc924687f8ca282ea1be8e4e88ad97e5d174", + "4d97b105d6ba3a7467abb4bc1b75c28863478b85eb72a193a6421525929d8e00", + "1978a27ccbcfbe5c31c91847ebe897122ad6a659ccb588c164114ff4df82e0c3", + "90d506603e00ac5f58b581e97048889b49826c4b362847ad2779818f5012bce4", + "54e481be354034a9a24818708d7dfc4c4e13ec0ff36177a8bbedae06693deea4", + "a988a5ab5c976ac9767c7fcd63b00430848411be0f35a69570300fd831f8e057", + "9f50d37d825e24754828e4db18c1630b79f0339cba82b85dba15b1f4cb82ad56", + "71bdffa30e546226b0a1e5d90f4f25b1c44f2251657ee64801be7ae5fad57859", + "6c47ffdc091a0ff800f373e32f342c9d8f5f551dca0d2f4cd9b681536a3d613f", + "42f341496599f8c839df00d659ed6e95aedde74397651e670c467b9b97ae00e2", + "89ac48ec4c875f4ec34a8deee748c7327f323890d06b56837b62ce04ebeb8aeb", + "6a2c9d309b779b86f7ed220ca72954e25aae2cc2f948fe0d51ef5d63bf3b45c5", + "66d6e459300d9cc4fe89f6e0b0c92d0ff5733c79ec30a1b528e011aef8faa56f", + "d0b0a9e09a903da8f4701116186d4e006f889da7924b9ad2874f25583836b703", + "115cda2dabf08b0108777cf5ebc3371447089b84f846b5ac41aa3dcd4e8e006d", + "4acce20635968f29e8c447ac08b8742afb68366ddf30a0c03690ffdbd9ba45f7", + "19d75b26d926fe78efc696473d74ad5bcd03cc93015a064939358740f2d0b198", + "077a693e5ec46fffc010614764079b92bc3d5859efb5b219fc0020ecc7f31912", + "6e11fa2bc9f0722a6a47fc1457cd2bccfb806c57f316ddfc57be37017f503f04", + "2a26f1d183560f9321c71363943fbd006569c7b3a42d8d9c9106113f38e740a2", + "489a5d2aeaddb2475466ea8bbfcccaf3c94f91ddcd1342bad8379b281c1c1f3d", + "93da13ceda8893197b641799f2407d505fa5aff8ecbcee4c01853a2482ceb4ca", + "7314dd75554a17351f88a476ab2f347ef66c37644c324fc6145c5d8ad0cc5ce2", + "d46a7e19fa282061b311196532c24c4cdecdd43324e5375fa5a12209ee6ccfea", + "55d37292fff7400e84bc368097a4fd9419f48915d3602410e38ee4d5fd5f47d5", + "3c8df638040b70d5b1b15fd0afa3f4a4413df59301727da28faf567268512e8f", + "db0e72300a67a68f09705423da4726b8edcbf882752d379d54a2c511d1ae54db", + "032102e7e72ba6fd6310d854bada48c7bc8836072f13c972928a2e9f85b35e98", + "6d788a240288b4279094e0cf0fdb5596b5622330fb71086ccb7596be6fc62bda", + "37942397d22bb980fe46a3575802b16648c442fd388ef8bcdf7e3cf0b4c6e7c8", + "d541ada7edb22ec6a9f74ba9174758e7d93c847a1eb0aec59b49ea34d603a605", + "a81d5ab706ac22b195a9ecf4350d4b231a039c6c8197d7c06d6b4a380f2ec499", + "d9509a5435b7bc757b23578a6706d0324344a86658ea67cc081ec714e26e4f5b", + "6261b8b01461833d449075ced9969e3b0e473fe3bc1cb54af3b47ea18183cdbe" + ], + "new_target_rank1_lifts": 111, + "no_new_kappa": true, + "partial_target_gate": "All111Krows are nonzero. Every KR row includes its own source and at least one other source, and its actual E8 source-line span has rank8. For this physical-output gather alphabet, no row can be prepared at target cap K_p, which omits own P_p. A FULL pure-query pivot needs one rank1 immutable COPY to a cap target, or a source descent+return costs2. Those bills do not beat the one target lift. A changed multi-output factor/native source-consumption word is not excluded by this census.", + "physical_block": "For arbitrary physical inputs, raw F=[[S,0],[S,T]], S=F8 D_P native7,T=F8 native8. An extra111 commonFULL ADDs diagonalizes toS/T; those ADDs are not included in the emitted shear word.", + "private_excess": 0, + "private_fields": 0, + "queries": [ + { + "R_index": 0, + "pivot": 0, + "source_support": [ + 0, + 3, + 5, + 6, + 9, + 11, + 14, + 15, + 20, + 21, + 23, + 25, + 26, + 28, + 30, + 31, + 36, + 37, + 39, + 41, + 42, + 44, + 49, + 50, + 51, + 53, + 55, + 57, + 61, + 62, + 63, + 68, + 69, + 72, + 73, + 74, + 77, + 78, + 83, + 85, + 87, + 88, + 89, + 92, + 93, + 97, + 99, + 101, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110 + ], + "target_support": [ + 2, + 3, + 4, + 5, + 10, + 11, + 12, + 14, + 15, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 33, + 34, + 37, + 40, + 41, + 42, + 43, + 46, + 47, + 50, + 51, + 55, + 56, + 57, + 58, + 59, + 61, + 62, + 65, + 67, + 68, + 69, + 70, + 73, + 74, + 79, + 80, + 84, + 85, + 86, + 87, + 89, + 90, + 92, + 95, + 98, + 99, + 100, + 101, + 103, + 104, + 109, + 110 + ] + }, + { + "R_index": 1, + "pivot": 0, + "source_support": [ + 0, + 3, + 5, + 6, + 9, + 11, + 16, + 17, + 18, + 19, + 22, + 24, + 27, + 29, + 30, + 31, + 36, + 37, + 39, + 41, + 42, + 44, + 46, + 47, + 48, + 52, + 54, + 56, + 58, + 59, + 60, + 64, + 65, + 66, + 67, + 70, + 71, + 73, + 74, + 77, + 78, + 83, + 85, + 87, + 90, + 91, + 94, + 95, + 96, + 98, + 100, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110 + ], + "target_support": [ + 1, + 2, + 5, + 6, + 8, + 10, + 11, + 16, + 17, + 20, + 21, + 22, + 24, + 26, + 28, + 30, + 31, + 34, + 35, + 39, + 41, + 43, + 45, + 52, + 54, + 56, + 58, + 60, + 61, + 63, + 65, + 66, + 67, + 69, + 72, + 75, + 76, + 77, + 78, + 81, + 82, + 85, + 87, + 88, + 89, + 94, + 95, + 97, + 99, + 100, + 102, + 103, + 104, + 105, + 106 + ] + }, + { + "R_index": 2, + "pivot": 0, + "source_support": [ + 0, + 3, + 4, + 7, + 11, + 12, + 13, + 14, + 16, + 19, + 21, + 22, + 23, + 28, + 29, + 30, + 32, + 35, + 37, + 38, + 39, + 44, + 45, + 46, + 50, + 53, + 54, + 55, + 56, + 61, + 62, + 63, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 75, + 77, + 79, + 81, + 84, + 85, + 88, + 90, + 92, + 94, + 96, + 97, + 100, + 101, + 104, + 105, + 108, + 109 + ], + "target_support": [ + 1, + 2, + 4, + 7, + 8, + 10, + 12, + 13, + 16, + 17, + 18, + 19, + 22, + 24, + 27, + 29, + 32, + 33, + 34, + 35, + 38, + 40, + 43, + 45, + 46, + 47, + 48, + 52, + 54, + 56, + 58, + 59, + 60, + 64, + 65, + 66, + 67, + 70, + 71, + 75, + 76, + 79, + 80, + 81, + 82, + 84, + 86, + 90, + 91, + 94, + 95, + 96, + 98, + 100, + 102 + ] + }, + { + "R_index": 3, + "pivot": 0, + "source_support": [ + 0, + 3, + 4, + 7, + 8, + 9, + 10, + 15, + 17, + 18, + 20, + 22, + 23, + 28, + 29, + 31, + 33, + 34, + 36, + 38, + 39, + 44, + 45, + 46, + 50, + 52, + 57, + 58, + 59, + 60, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 75, + 77, + 79, + 82, + 83, + 86, + 87, + 88, + 90, + 92, + 94, + 98, + 99, + 102, + 103, + 106, + 107, + 110 + ], + "target_support": [ + 2, + 3, + 6, + 7, + 9, + 10, + 11, + 13, + 14, + 16, + 19, + 21, + 23, + 24, + 27, + 28, + 39, + 41, + 42, + 44, + 46, + 48, + 51, + 52, + 53, + 56, + 57, + 59, + 61, + 62, + 65, + 66, + 68, + 69, + 71, + 73, + 75, + 78, + 80, + 81, + 83, + 85, + 86, + 88, + 89, + 90, + 91, + 97, + 99, + 100, + 102, + 103, + 105, + 108, + 110 + ] + }, + { + "R_index": 4, + "pivot": 0, + "source_support": [ + 0, + 1, + 2, + 3, + 9, + 12, + 13, + 15, + 16, + 19, + 20, + 23, + 24, + 27, + 28, + 31, + 32, + 35, + 36, + 39, + 40, + 43, + 44, + 47, + 48, + 50, + 54, + 56, + 57, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 70, + 71, + 74, + 75, + 78, + 79, + 82, + 85, + 86, + 89, + 90, + 93, + 94, + 97, + 98, + 101, + 102, + 104, + 105, + 108, + 109 + ], + "target_support": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 10, + 12, + 13, + 14, + 17, + 19, + 20, + 23, + 24, + 26, + 29, + 30, + 33, + 35, + 36, + 39, + 40, + 42, + 45, + 47, + 48, + 49, + 51, + 54, + 56, + 57, + 59, + 61, + 63, + 64, + 66, + 67, + 69, + 72, + 74, + 75, + 77, + 80, + 81, + 83, + 85, + 86, + 89, + 90, + 92, + 95, + 96, + 99, + 101, + 102, + 103, + 106, + 108, + 109 + ] + }, + { + "R_index": 5, + "pivot": 4, + "source_support": [ + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 14, + 15, + 16, + 17, + 26, + 27, + 28, + 29, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 46, + 47, + 48, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 60, + 62, + 65, + 69, + 70, + 71, + 72, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 88, + 89, + 90, + 91, + 100, + 101, + 102, + 107, + 108, + 109, + 110 + ], + "target_support": [ + 0, + 2, + 5, + 7, + 8, + 9, + 11, + 12, + 15, + 16, + 19, + 20, + 22, + 23, + 28, + 29, + 30, + 31, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 48, + 49, + 50, + 53, + 54, + 57, + 58, + 59, + 63, + 65, + 67, + 68, + 69, + 70, + 74, + 75, + 77, + 80, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 96, + 97, + 98, + 99, + 104, + 106, + 107, + 109 + ] + }, + { + "R_index": 6, + "pivot": 1, + "source_support": [ + 1, + 2, + 5, + 6, + 9, + 12, + 13, + 16, + 17, + 20, + 21, + 23, + 25, + 27, + 29, + 32, + 33, + 36, + 37, + 39, + 41, + 43, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 54, + 56, + 58, + 60, + 61, + 63, + 65, + 68, + 70, + 71, + 75, + 76, + 77, + 78, + 83, + 84, + 86, + 90, + 91, + 92, + 93, + 97, + 99, + 100, + 102, + 107, + 108, + 109, + 110 + ], + "target_support": [ + 0, + 2, + 5, + 7, + 8, + 9, + 11, + 12, + 14, + 17, + 18, + 21, + 24, + 25, + 26, + 27, + 32, + 33, + 34, + 35, + 46, + 48, + 49, + 50, + 53, + 54, + 57, + 58, + 60, + 61, + 62, + 64, + 66, + 71, + 72, + 74, + 75, + 77, + 80, + 82, + 83, + 84, + 85, + 90, + 91, + 92, + 93, + 96, + 97, + 98, + 99, + 103, + 105, + 108, + 110 + ] + }, + { + "R_index": 7, + "pivot": 0, + "source_support": [ + 0, + 1, + 4, + 5, + 8, + 12, + 15, + 17, + 18, + 20, + 22, + 25, + 26, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 40, + 43, + 45, + 47, + 49, + 50, + 54, + 55, + 58, + 60, + 63, + 64, + 67, + 70, + 72, + 74, + 76, + 77, + 79, + 82, + 84, + 87, + 92, + 93, + 94, + 95, + 96, + 98, + 101, + 104, + 106, + 107, + 109 + ], + "target_support": [ + 0, + 2, + 5, + 7, + 9, + 10, + 11, + 13, + 14, + 15, + 16, + 17, + 23, + 25, + 27, + 29, + 30, + 32, + 34, + 36, + 38, + 41, + 43, + 44, + 46, + 47, + 50, + 51, + 52, + 54, + 55, + 57, + 59, + 60, + 62, + 63, + 66, + 68, + 70, + 72, + 83, + 85, + 87, + 88, + 90, + 92, + 94, + 97, + 98, + 101, + 102, + 103, + 104, + 107, + 108 + ] + }, + { + "R_index": 8, + "pivot": 0, + "source_support": [ + 0, + 2, + 4, + 6, + 8, + 11, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 24, + 27, + 29, + 30, + 32, + 35, + 37, + 39, + 40, + 43, + 44, + 46, + 47, + 49, + 52, + 54, + 55, + 57, + 59, + 63, + 65, + 66, + 68, + 69, + 71, + 73, + 74, + 75, + 76, + 83, + 84, + 86, + 89, + 91, + 92, + 94, + 97, + 98, + 100, + 105, + 106, + 107, + 108 + ], + "target_support": [ + 0, + 2, + 5, + 7, + 9, + 10, + 11, + 13, + 18, + 19, + 20, + 21, + 22, + 24, + 26, + 28, + 31, + 33, + 35, + 37, + 39, + 40, + 42, + 45, + 46, + 47, + 50, + 51, + 52, + 54, + 55, + 57, + 59, + 60, + 62, + 63, + 66, + 68, + 70, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 84, + 86, + 89, + 91, + 93, + 95, + 96, + 99, + 100, + 103, + 104, + 107, + 108 + ] + } + ], + "rank_mass": 5097, + "remaining": [ + "Actual changed global caller, chronological owners and complete moment.", + "New rounded precision/suffix-error and physical source/tape bill.", + "No positive kappa or new selected bound." + ], + "scalar_ADDs": 12932, + "source_codes": 0, + "sources": { + "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/bit_cap_copy_local.py": "6e9ca1eb905d769716c009904f45d6849b225e48cd119f18b50c0379f35313cb", + "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/bit_signed_audit.py": "376356696663021693c0e2c9adf37f371675fe8837fb88232b8767a8b90793e8", + "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/root-pruned-code/BIT-PRUNED-WORD.json.gz": "1a6841fccba51fa922993c77b4b296e659c2c538252e5e06113d0438c5edb870", + "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint/bit_full_compensation.py": "a7bda83b84ab15a75c418225e3d5c2fda8eded8577a894341225f757e6ea7e20", + "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint/bit_full_targets.py": "7446290e462752b76b9461696b7676c8295739aba1b79eea0d77925f5f9a3869", + "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022" + }, + "status": "PASS_R429_FULL_NINE_TOTAL_COMPENSATION_NO_SOURCE_CODE_NO_PRIVATE", + "word_canonical_sha256": "895a359e33a7a9a9cb2c4a68acc9fcf624596d334a52381264ae498e0e55c847", + "word_gzip_sha256": "0f461dbc7e82a02faedb4a5129103963507c9f063a0a3679ba5d20ad94df160e" +} diff --git a/research/r429-full-target-interface/frozen/major/bit-endpoint/bit_full_compensation.py b/research/r429-full-target-interface/frozen/major/bit-endpoint/bit_full_compensation.py new file mode 100644 index 0000000000..08a59c9ed2 --- /dev/null +++ b/research/r429-full-target-interface/frozen/major/bit-endpoint/bit_full_compensation.py @@ -0,0 +1,107 @@ +#!/usr/bin/env python3 +"""Source-preserving R429 bulk with direct nine-total compensation at FULL. + +No source code, target precode, private field or terminal gauge is retained. +The full111-target lift is explicit and the complete local mass is zero-loss. +""" +from pathlib import Path +from collections import Counter +import gzip +import hashlib +import json +import sys +sys.dont_write_bytecode=True +HERE=Path(__file__).resolve().parent +sys.path.insert(0,str(HERE)) +import bit_full_targets as b +def need(z,m): + if not z:raise ValueError(m) +def bits(z): + while z: + v=z&-z;yield v.bit_length()-1;z^=v +def main(): + packed=b.INPUT.read_bytes();need(hashlib.sha256(packed).hexdigest()=='1a6841fccba51fa922993c77b4b296e659c2c538252e5e06113d0438c5edb870','R429 pin') + base=json.loads(gzip.decompress(packed));raw=json.loads(gzip.decompress(b.RAW.read_bytes())) + address_projectors=b.cap.address_identities(raw) + ident=b.cap.identity(8);full_address=b.cap.exchange(ident);new_lift_hashes=[] + for root in raw['lines']: + P=[[b.cap.Q(x*y,4)for y in root]for x in root] + Q=[[ident[i][j]-P[i][j]for j in range(8)]for i in range(8)] + actual=b.cap.multiply(full_address,b.cap.exchange(Q)) + need(actual==b.cap.exchange(P)and b.cap.rank(P)==1,'actual cap-to-FULL ADDRESS operator is rank1 D_P') + serial=[[[x.numerator,x.denominator]for x in row]for row in actual] + new_lift_hashes.append(hashlib.sha256(b.canonical(serial)).hexdigest()) + rows=[1<>p&1 and z!=(1<>j&1] + correction.extend([1,111+p,pivot,1,1,52]for p in dsts) + correction.extend([1,pivot,s,-1,1,53]for s in reversed(other)) + queries.append({'R_index':j,'pivot':pivot,'source_support':support,'target_support':dsts}) + records=bulk+lifts+correction;adds=sum(r[0]==1 for r in records) + outputs=[];receipts=[] + for back in(False,True): + out,rec=b.replay(raw,base,records,back,private_expected=0,add_count=adds) + for p in range(111):need(out[p]=={p:1},'source exactZ identity') + for p in range(222,651):need(out[p]=={p:1},'all429 arbitrary helper dirt exactZ identity') + expected=[1<

=222 for j in out[p]),'old target y exactZ identity') + need(all(not(c&1)for j,c in out[p].items()if j>=222),'target integer dirty leakage even') + outputs.append(out);receipts.append(rec) + inv,_=b.replay(raw,base,records,True,outputs[0],private_expected=0,add_count=adds) + need(inv==[{i:1}for i in range(651)]+[{}],'literal inverse roundtrip every integer input column') + missing=next(i for i,r in enumerate(records)if r[-1]==52) + corrupted,_=b.replay(raw,base,records[:missing]+records[missing+1:],private_expected=0,add_count=adds-1) + need(b.scalar.parity(corrupted)!=b.scalar.parity(outputs[0]),'missing actual compensation scatter rejected') + bad=[r[:]for r in records];which=next(i for i,r in enumerate(bad)if r[-1]==53);bad[which][3]*=-1 + corrupted,_=b.replay(raw,base,bad,private_expected=0,add_count=adds) + need(corrupted[:111]!=outputs[0][:111]and b.scalar.parity(corrupted)==b.scalar.parity(outputs[0]),'wrong integer unprepare sign rejected while parity unchanged') + which=next(i for i,r in enumerate(records)if r[0]==0 and r[1]==111 and r[-1]==42) + try:b.replay(raw,base,records[:which]+records[which+1:],private_expected=0,add_count=adds) + except ValueError as e:missing_lift=str(e) + else:raise ValueError('missing target-FULL lift escaped native frame checks') + program=dict(base);program['records']=records;program['final']=base['final'][:] + for p in range(111,222):program['final'][p]=1 + program['private_register']=None;program['format']='R429-full-nine-total-compensation-no-source-code-v1' + body=b.canonical(program);path=HERE/'BIT-FULL-COMPENSATION-WORD.json.gz';path.write_bytes(gzip.compress(body,mtime=0)) + out={'status':'PASS_R429_FULL_NINE_TOTAL_COMPENSATION_NO_SOURCE_CODE_NO_PRIVATE', + 'sources':{str(p):hashlib.sha256(p.read_bytes()).hexdigest()for p in(b.INPUT,b.RAW,HERE/'bit_full_targets.py',Path(__file__),b.OLD/'recursive/bit_cap_copy_local.py',b.OLD/'recursive/bit_signed_audit.py')}, + 'word_gzip_sha256':hashlib.sha256(path.read_bytes()).hexdigest(),'word_canonical_sha256':hashlib.sha256(body).hexdigest(), + 'R':R,'K':K,'queries':queries,'forward':receipts[0],'literal_inverse':receipts[1], + 'all111_physical_correction_rows':correction_rows, + 'all_arbitrary_integer_columns':651,'helpers_restored_over_Z':429,'private_fields':0, + 'actual_address_projectors':address_projectors,'exact_ADDRESS_identity_columns':3552, + 'new_target_lift_ADDRESS_sha256':new_lift_hashes,'new_target_lift_ADDRESS_columns':1776, + 'executed_controls':{'missing_one_actual_scatter_changes_F2_endpoint':True,'wrong_unprepare_changes_Z_source_but_not_F2':True,'omitted_target_lift_rejected':missing_lift}, + 'new_target_rank1_lifts':111,'source_codes':0,'scalar_ADDs':adds,'rank_mass':5097,'native_progress':5097,'private_excess':0, + 'endpoint':'Source x and429helpers unchanged exactly overZ. Target y unchanged exactly; target updatex modulo2; helper targetleakageeven. Both data banks atFULL. Exact literal integer inverse returns all inputs.', + 'physical_block':'For arbitrary physical inputs, raw F=[[S,0],[S,T]], S=F8 D_P native7,T=F8 native8. An extra111 commonFULL ADDs diagonalizes toS/T; those ADDs are not included in the emitted shear word.', + 'allsize_lift':'Every scalar ADD is at actual commonZERO or commonFULL; nine pure source-pivot totals are prepared and unprepared atFULL without retained snapshots. Actual native MOVE frames and containment are replayed on651 ordinaryroles. AllSIZE rounded/tape implementation remains a separate obligation.', + 'global_accounting':'Direct n=L diagonal-call topology hasD0, not LN. The111 rank1 target lifts percall are counted here and cannot be omitted from an old common-axis invoice.', + 'partial_target_gate':'All111Krows are nonzero. Every KR row includes its own source and at least one other source, and its actual E8 source-line span has rank8. For this physical-output gather alphabet, no row can be prepared at target cap K_p, which omits own P_p. A FULL pure-query pivot needs one rank1 immutable COPY to a cap target, or a source descent+return costs2. Those bills do not beat the one target lift. A changed multi-output factor/native source-consumption word is not excluded by this census.', + 'remaining':['Actual changed global caller, chronological owners and complete moment.','New rounded precision/suffix-error and physical source/tape bill.','No positive kappa or new selected bound.'], + 'no_new_kappa':True} + (HERE/'BIT-FULL-COMPENSATION.json').write_text(json.dumps(out,indent=2,sort_keys=True)+'\n') + print(out['status']);print('651cols,429helperZ restoration,0private,9totals; ADD',adds,'mass5097') +if __name__=='__main__':main() diff --git a/research/r429-full-target-interface/frozen/major/bit-endpoint/bit_full_targets.py b/research/r429-full-target-interface/frozen/major/bit-endpoint/bit_full_targets.py new file mode 100644 index 0000000000..de3a06469e --- /dev/null +++ b/research/r429-full-target-interface/frozen/major/bit-endpoint/bit_full_targets.py @@ -0,0 +1,117 @@ +#!/usr/bin/env python3 +"""Actual R429 target-precode/full-target/source-decode local construction. + +Exact signed integer and F2 audits of all651 input columns with full native +COPY/ERASE lifecycles. No whole caller or changed idle stock is asserted. +""" +from collections import Counter +import gzip +import hashlib +import importlib.util +import json +from pathlib import Path +import sys +sys.dont_write_bytecode=True +HERE=Path(__file__).resolve().parent +OLD=Path('/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier') +INPUT=OLD/'root-pruned-code/BIT-PRUNED-WORD.json.gz' +RAW=Path('/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz') +sys.path.insert(0,str(OLD/'recursive')) +import bit_cap_copy_local as cap +import bit_signed_audit as scalar +def need(b,m): + if not b:raise ValueError(m) +def canonical(x):return json.dumps(x,sort_keys=True,separators=(',',':')).encode() + +def replay(raw,base,records,back=False,initial=None,private_expected=3,add_count=17720): + n=651;start=base['final'][:]if back else base['start'][:] + if back: + for p in range(111,222):start[p]=1 + frames=start+[None] + rows=[{i:1}for i in range(n)]+[{}]if initial is None else [r.copy()for r in initial] + dims=[cap.rank(raw['lines'][j]for j in f)for f in raw['frames']] + masks=[sum(1<0,'native MOVE frame and exact rank') + frames[d]=new;profile[f]+=1 + elif op==1: + need(d!=s and d=222 for j in rows[p]),'integer target arbitrary old y restored exactly') + need(all(not(z&1)for j,z in rows[p].items()if j>=222),'integer target dirty leakage is even') + outputs.append(rows);receipts.append(receipt) + closed,_=replay(raw,base,records,True,outputs[0]);need(closed==identity,'literal inverse roundtrip all651 integer columns') + # Omit the target precode but retain the inverse target output code. + # An independent scalar propagation of A on y certifies the necessary + # orientation. A^-1 precode would leave A^-2 y rather than y. + arows=[{i:1}for i in range(111)] + for _,d,s,c,_,_ in code:arows[d]=scalar.add(arows[d],arows[s],c) + need(scalar.parity(arows)!=[1<

>1;b0,b1=b&1,b>>1 + return ((a0*b0)^(a1*b1))|(((a0*b1)^(a1*b0))<<1) +def plus(a,b):return [x^y for x,y in zip(a,b)] +def scale(a,q):return[mul(x,q)for x in a] +def ident(n):return[[int(i==j)for j in range(n)]for i in range(n)] +def inverse_event(e):return e # Every declared GF2 primitive here is involutive. +def apply(z,e): + z=[r[:]for r in z];i,j=e['source'],e['target'];k=e['kind'] + if k=='old_F':z[j]=plus(z[j],scale(z[i],2)) + elif k=='old_B':z[i]=plus(z[i],scale(z[j],2)) + elif k=='exchange':z[i],z[j]=z[j],z[i] + elif k=='new_F':z[j]=plus(z[i],scale(z[j],2)) + elif k=='new_F_inverse':z[j]=scale(plus(z[j],z[i]),2) + elif k=='CNOT':z[j]=plus(z[j],z[i]) + else:raise ValueError(k) + return z + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--write',action='store_true');a=ap.parse_args() + word=[{'kind':'old_F','source':0,'target':1,'stage':0},{'kind':'old_B','source':0,'target':1,'stage':1},{'kind':'old_F','source':0,'target':1,'stage':2},{'kind':'exchange','source':0,'target':1,'cut':'afterstage2'}] + for j in range(2,8):word.append({'kind':'new_F','source':0,'target':j,'stage':j+1}) + # The source is unchanged by every fanout; terminal CNOTs cancel those + # entering-source columns, once all eight fronts equal the common parent. + for j in reversed(range(2,8)):word.append({'kind':'CNOT','source':0,'target':j,'cut':'terminal common NGamma'}) + z=ident(8);prefix=[] + for e in word: + z=apply(z,e);prefix.append(z) + target=scale_identity=[[2*int(i==j)for j in range(8)]for i in range(8)] + need(z==target,'all eight independent raw input columns reach common N') + back=z + for e in reversed(word): + inv=dict(e) + if inv['kind']=='new_F':inv['kind']='new_F_inverse' + back=apply(back,inv) + need(back==ident(8),'literal reverse-inverse all raw input columns') + # Defect-sensitive negative controls alter actual words. + bad=ident(8) + for e in word: + if e.get('stage')==1:continue + bad=apply(bad,e) + need(bad!=target,'omitted seed B rejected') + bad=ident(8) + for k,e in enumerate(word): + if k==len(word)-1:continue + bad=apply(bad,e) + need(bad!=target,'omitted terminal CNOT rejected') + # Pure new-F diagonalization cannot create source common-axis progress. + single=apply(apply(ident(2),{'kind':'new_F','source':0,'target':1}),{'kind':'CNOT','source':0,'target':1}) + need(single==[[1,0],[0,2]],'source remains I under postCNOT diagonalization') + windows=[{'bank':0,'active_stages':list(range(9)),'fresh_idle_query_ranks':[]},{'bank':1,'active_stages':[0,1,2],'fresh_idle_query_ranks':[42]}] + for j in range(2,8): + s=j+1;windows.append({'bank':j,'active_stages':[s],'fresh_idle_query_ranks':[x for x in(7*s,7*(8-s))if x]}) + out={'status':'PASS_SEEDED_STAR_EIGHT_RAW_INPUT_COLUMNS','scientific_pin':'20ecf2891d80b5acf18d980b2164fb44ea7faa90', + 'coefficient_ring':'F2[N]/(N^2-1), entry encoded a+2*b for a+bN. Fresh Gs commute mutually and with N; cumulative Gamma is stripped only at matched fresh-prefix cuts.', + 'assumed_local_interfaces':['old_F_N=(x,y+Nx), old_B_N=(x+Ny,y), three clean rank7 stages, ordinary helper restoration as supplied by the old R438 factory.','new_F=(x,x+Ny), six stages, each from the changed R429 full-target factory. Its helpers and target preencoding must be admitted at the actual common-past prefix; this record does not establish that native binding.'], + 'word':word,'prefix_rows':prefix,'endpoint_rows':z,'inverse_endpoint_rows':back, + 'identity':'Three old F_N/B_N/F_N plus SWAP give diag(N,N). Six new F calls from bank0 to banks2..7 yield N(x0,x1,x2+x0,...,x7+x0). Six terminal CNOTs then yield N times I8.', + 'fresh_path':'Every active call advances its two banks by its stage G_s; complete every inactive fresh interval by the listed native idle query. All eight banks must reach Gamma9 before the terminal CNOTs.', + 'public_fresh_idle_windows':windows, + 'conditional_local_invoice':'3 old factories at private63 plus6 changed factories at private3; nominal raw rank deficit2*111-3*63-6*3=15 before padding, changed owner allocation, moments and precision. No unchanged nineteen-event owner witness applies.', + 'pure_newF_control':'PostCNOT * newF = diag(I,N). It leaves arbitrary raw source a unchanged, so it does not alone give common N on both raw inputs. An entrance normalization a=Nx must be paid or supplied by an explicit encoded-input caller contract.', + 'negative_controls':['Omit old seed B: wrong all-input endpoint.','Omit one terminal CNOT: one original x0 term remains.'], + 'all_size_scope':'The written word is a polynomial identity for every involution N over characteristic2 and every commuting fresh Gs. No finite Fourier expansion, one-bit support shortcut or clean data assumption is used.', + 'remaining':['Native source/target pre/post A admission at these changed cuts, all429 helper dirt and return identities require recursive lane producer binding.','New chronological whole-helper owner allocation and full moments, arity, rounding/precision and tape costs are not supplied.','No positive kappa follows from nominal D15.'], + 'attribution':'Recursive lane proposed three-old-call seed and six-new-call fanout; root proposed testing pure newF diagonalization. This lane independently verifies the changed word on all raw columns, inverse and defect controls, and separates the missing source input normalization.'} + out=json.loads(json.dumps(out));target_path=HERE/'BIT-SEEDED-STAR.json' + if a.write:target_path.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n') + else:need(json.loads(target_path.read_bytes())==out,'stored seeded star differs') + print(out['status']);print('8 raw inputs; reverse-inverse;2 controls; changed idle windows PASS') +if __name__=='__main__':main() diff --git a/research/r429-full-target-interface/frozen/old/recursive/bit_cap_copy_local.py b/research/r429-full-target-interface/frozen/old/recursive/bit_cap_copy_local.py new file mode 100644 index 0000000000..679be90ff9 --- /dev/null +++ b/research/r429-full-target-interface/frozen/old/recursive/bit_cap_copy_local.py @@ -0,0 +1,162 @@ +#!/usr/bin/env python3 +"""Local-only exact native cap-copy audit, independent of any controller. + +Inputs are the pinned R438 word and frozen signed six-copy local word. The +16-column ADDRESS identities hold over every odd field where dyadic entries +are interpreted. Scalar integer cleanup and rounded child errors are separate. +Apache-2.0; substantial OpenAI Codex assistance. +""" + +import argparse +from collections import Counter +from fractions import Fraction as Q +import gzip +from hashlib import sha256 +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +RAW = Path('/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz') +RAW_SHA = 'a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022' + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + +def rank(rows): + basis = {} + for row in rows: + row = list(map(Q, row)) + for j, old in sorted(basis.items()): + c = row[j] + row = [x-c*y for x,y in zip(row,old)] + j = next((j for j,x in enumerate(row) if x), None) + if j is not None: + c = row[j] + basis[j] = [x/c for x in row] + return len(basis) + + +def identity(n): + return [[Q(i == j) for j in range(n)] for i in range(n)] + + +def multiply(a, b): + return [[sum(x*y for x,y in zip(row,col)) for col in zip(*b)] for row in a] + + +def exchange(u): + c = [[Q(i == j)-u[i][j] for j in range(8)] for i in range(8)] + return [c[i]+u[i] for i in range(8)]+[u[i]+c[i] for i in range(8)] + + +def address_identities(word): + ident = identity(8) + out = [] + for p, q in enumerate(word['lines']): + need(sum(x*x for x in q) == 4, 'actual E8 root norm') + start = [word['lines'][j] for j in word['frames'][word['start'][p]]] + cap = [word['lines'][j] for j in word['frames'][word['final'][111+p]]] + need(rank(start) == 1 and all(all(4*x == sum(a*b for a,b in zip(row,q))*y + for x,y in zip(row,q)) for row in start), 'actual entrance is not P_p') + need(rank(cap) == 7 and all(sum(x*y for x,y in zip(row,q)) == 0 for row in cap), + 'actual target cap is not K_p') + proj = [[Q(x*y,4) for y in q] for x in q] + complement = [[ident[i][j]-proj[i][j] for j in range(8)] for i in range(8)] + need(multiply(proj,proj) == proj and rank(proj) == 1, 'actual P_p projector') + need(multiply(exchange(ident),exchange(proj)) == exchange(complement), + 'D_I D_P differs from D_K') + need(multiply(exchange(proj),exchange(proj)) == identity(16), 'D_P squared differs from I') + encoded = [[[v.numerator,v.denominator] for v in row] for row in proj] + out.append(sha256(canonical(encoded)).hexdigest()) + need(len(out) == 111, 'actual punctured root count') + return out + + +def frame_replay(word, program, backward=False, fault=None): + dims = [rank(word['lines'][j] for j in f) for f in word['frames']] + masks = [sum(1 << j for j in f) for f in word['frames']] + need(dims[1] == 8, 'named FULL is not full') + frames = (word['final'] if backward else word['start'])[:]+[None] + open_source, copies, erases = None, [], 0 + paid = Counter() + rows = list(reversed(program['records'])) if backward else program['records'] + for raw in rows: + op,x,y,c,f,phase = raw + if op == 0: + old,new = (c,y) if backward else (y,c) + lo,hi = (new,old) if backward else (old,new) + need(frames[x] == old, 'MOVE source frame') + need(not masks[lo] & ~masks[hi] and dims[hi]-dims[lo] == f > 0, 'MOVE rank or containment') + frames[x] = new + paid[f] += 1 + elif op == 1: + need(x < 660 and x != y and frames[x] == frames[y] == f, 'ADD common frame') + need(open_source != x, 'immutable copied source changed') + elif op == (3 if backward else 2): + need(open_source is None and y == 660 and frames[660] is None, 'COPY fresh private field') + if fault == 'copy_to_full': + f = 1 + need(frames[x] == c == 1 and not masks[f] & ~masks[c], 'COPY source FULL and target nested') + need(dims[c]-dims[f] == 1, 'COPY does not use rank-one cap descent') + frames[660],open_source = f,x + copies.append({'source':x,'source_frame':c,'private_frame':f,'rank':1}) + paid[1] += 1 + else: + need(op == (2 if backward else 3), 'unknown native opcode') + need(open_source == x and y == 660 and frames[x] == c and frames[660] == f, + 'ERASE original snapshot source/frame') + frames[660],open_source = None,None + erases += 1 + need(open_source is None and frames[:660] == (word['start'] if backward else word['final']), 'native endpoint') + need(len(copies) == erases == 6, 'six closed immutable snapshots') + return {'copies':copies,'literal_erases':erases,'paid_profile':dict(sorted(paid.items())), + 'maximum_simultaneous_private_snapshots':1} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', action='store_true') + args = parser.parse_args() + raw = RAW.read_bytes() + need(sha256(raw).hexdigest() == RAW_SHA, 'R438 source pin') + word = json.loads(gzip.decompress(raw)) + meta = json.loads((HERE/'BIT-SIGNED-INPUT.json').read_bytes()) + packed = (HERE/'BIT-SIGNED-INPUT-WORD.json.gz').read_bytes() + decoded = gzip.decompress(packed) + need(sha256(packed).hexdigest() == meta['word_gzip_sha256'] and + sha256(decoded).hexdigest() == meta['word_canonical_sha256'], 'frozen signed word pin') + program = json.loads(decoded) + need(program['start'] == word['start'] and program['final'] == word['final'], 'retained native boundaries') + projectors = address_identities(word) + forward,backward = frame_replay(word,program),frame_replay(word,program,True) + try: + frame_replay(word,program,fault='copy_to_full') + except ValueError as error: + negative = str(error) + else: + raise ValueError('rank-zero FULL copy mutation escaped') + receipt = {'status':'PASS_LOCAL_SIX_CAP_COPY_NATIVE_CONTRACT', + 'raw_R438_gzip_sha256':RAW_SHA,'signed_word_canonical_sha256':meta['word_canonical_sha256'], + 'actual_port_count':111,'actual_entrance_and_target_frames':222, + 'projector_sha256':projectors,'address_identity_columns':3552, + 'forward':forward,'literal_inverse':backward,'negative_control':negative, + 'domain':'Exact dyadic projectors and ADDRESS matrices; every odd modulus where their dyadic coefficients are interpreted. VALUE scalar identity and native recursive child errors are separate.', + 'source_role_rule':'COPY may read an actual source field or an arbitrary helper, provided the physical source stays unchanged until ERASE. No helper-only restriction is used.', + 'limits':['local native/frame contract only','no global controller, endpoint decoder, owner allocation, precision theorem, tape bound or kappa claim']} + path = HERE/'BIT-CAP-COPY-LOCAL.json' + if args.write: + path.write_text(json.dumps(receipt,sort_keys=True,indent=2)+'\n') + else: + need(json.loads(path.read_bytes()) == json.loads(canonical(receipt)), 'complete cap-copy receipt differs') + print(receipt['status']) + + +if __name__ == '__main__': + main() diff --git a/research/r429-full-target-interface/frozen/old/recursive/bit_signed_audit.py b/research/r429-full-target-interface/frozen/old/recursive/bit_signed_audit.py new file mode 100644 index 0000000000..b147c4c6e9 --- /dev/null +++ b/research/r429-full-target-interface/frozen/old/recursive/bit_signed_audit.py @@ -0,0 +1,237 @@ +#!/usr/bin/env python3 +"""Independent exact signed local replay and whole added-code growth bound. + +The original-window controller is proved over binary VALUES. The integer +program is its literal signed lift, with no assertion that its global integer +endpoint is the binary identity. Prefix row-norms give a separate bound valid +under isometric owner/address permutations. No endpoint decoder is assumed. +Apache-2.0; substantial OpenAI Codex assistance. +""" + +import argparse +from collections import Counter +import gzip +from hashlib import sha256 +import json +from pathlib import Path + + +HERE = Path(__file__).resolve().parent +N, V = 660, 111 + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + +def identity(n): + return [{i: 1} for i in range(n)] + [{}] + + +def add(a, b, c): + output = a.copy() + for j, value in b.items(): + output[j] = output.get(j, 0) + c * value + if not output[j]: + del output[j] + return output + + +def row_weights(row): + return tuple(sum(abs(c) for j,c in row.items() if low <= j < high) + for low,high in ((0,V),(V,2*V),(2*V,N))) + + +def replay(records, backward=False, initial=None): + rows = [row.copy() for row in (identity(N) if initial is None else initial)] + open_source = None + prefix = 1 + envelope = {(1,0,0),(0,1,0),(0,0,1)} + copies = 0 + for op, dst, src, c, frame, phase in reversed(records) if backward else records: + if op == 1: + need(open_source is None or dst != open_source, 'integer snapshot source mutated') + rows[dst] = add(rows[dst], rows[src], -c if backward else c) + weights = row_weights(rows[dst]) + envelope.add(weights) + prefix = max(prefix, sum(weights)) + elif op == (3 if backward else 2): + need(open_source is None and src == N and not rows[N], 'integer COPY overwrites private') + rows[N] = rows[dst].copy() + open_source = dst + copies += 1 + elif op == (2 if backward else 3): + need(open_source == dst and rows[N] == rows[dst], 'integer ERASE original snapshot') + rows[N], open_source = {}, None + else: + need(op == 0, 'integer record opcode') + need(open_source is None and not rows[N] and copies == 6, 'integer private endpoint') + return rows, prefix, envelope + + +def parity(rows): + return [sum(1 << j for j,c in row.items() if c & 1) for row in rows] + + +def dense_digest(rows, n): + # Producer's documented signed-matrix digest is one comma-delimited row + # per line, distinct from its canonical JSON word digest. + h = sha256() + for row in rows: + h.update((','.join(str(row.get(j,0)) for j in range(n)) + '\n').encode()) + return h.hexdigest() + + +def block_norms(rows): + src = max(sum(abs(c) for c in row.values()) for row in rows[:V]) + target_x = max(row_weights(row)[0] for row in rows[V:2*V]) + target_h = max(row_weights(row)[2] for row in rows[V:2*V]) + return {'source_endpoint_row_norm': src, + 'target_source_block_row_norm': target_x, + 'target_helper_block_row_norm': target_h} + + +def code(records): + records = [r for r in records if r[0] == 1 and 21 <= r[5] <= 24] + output, prefixes = [], [] + for backward in (False, True): + rows = [{i: 1} for i in range(V)] + prefix = 1 + for _, d, s, c, f, phase in reversed(records) if backward else records: + need(d < V and s < V and d != s, 'source code not inplace') + rows[d] = add(rows[d], rows[s], -c if backward else c) + prefix = max(prefix, sum(abs(c) for c in rows[d].values())) + output.append(rows) + prefixes.append(prefix) + rows = [row.copy() for row in output[0]] + for _, d, s, c, f, phase in reversed(records): + rows[d] = add(rows[d], rows[s], -c) + need(rows == [{i: 1} for i in range(V)], 'signed source-code literal inverse') + norms = [max(sum(abs(c) for c in row.values()) for row in a) for a in output] + return records, output, prefixes, norms + + +def global_bound(ordered, local, local_prefix, envelopes, code_prefix, code_norm): + norms = [[1,1] for _ in range(4)] + maximum = 1 + checkpoints = [] + counts = Counter() + for event in ordered: + op = event.get('op') + if op == 'code sweep': + p, side = event['pair'], int(event['side'] == 'Y') + for s in event['stages']: + reverse = s % 2 + counts['inverse_code' if reverse else 'forward_code'] += 1 + maximum = max(maximum, code_prefix[reverse] * norms[p][side]) + norms[p][side] *= code_norm[reverse] + elif op == 'complete local coded call': + p, reverse = event['pair'], int(event['reverse']) + src_side = 1 if reverse else 0 + dst_side = 1 - src_side + x, y = norms[p][src_side], norms[p][dst_side] + # Hosted helpers may live in an already preloaded idle DATA bank. + # Their normalized coefficients are therefore bounded by the + # largest current bank norm, rather than by fresh independent1. + h = max(n for pair in norms for n in pair) + maximum = max(maximum, max(a*x + b*y + c*h for a,b,c in envelopes[reverse])) + endpoint = local[reverse] + norms[p][src_side] = endpoint['source_endpoint_row_norm'] * x + norms[p][dst_side] = y + endpoint['target_source_block_row_norm'] * x + endpoint['target_helper_block_row_norm'] * h + counts['local_inverse' if reverse else 'local_forward'] += 1 + checkpoints.append({'stage': event['stage'], 'prefix_upper_bits': maximum.bit_length()}) + elif event.get('kind') == 'bridge': + d, s = event['dst'], event['src'] + norms[d][0] += norms[s][0] + norms[s][1] += norms[d][1] + maximum = max(maximum, *(n for pair in norms for n in pair)) + counts['scalar_bridge_shears'] += 2 + elif event.get('kind') == 'exchange': + norms = [[y,x] for x,y in norms] + need(counts == Counter(forward_code=35, inverse_code=28, local_forward=5, + local_inverse=4, scalar_bridge_shears=18), 'whole added-code count') + crude = (1 << 18) * local_prefix[0]**5 * local_prefix[1]**4 * code_prefix[0]**35 * code_prefix[1]**28 + need(maximum <= crude, 'weighted global bound exceeds product upper') + # Completing the easy four FULL banks applies the nine inverse G factors + # independently on each bank; the maximum norm multiplies by one such + # sequence, not its fourth power. + completed_decode = code_prefix[0]**4 * code_prefix[1]**5 + return {'ordered_extra_code_counts': dict(counts), + 'all63_code_factors_included': True, + 'encoded_hosted_helper_inputs_bounded': True, + 'weighted_global_prefix_upper': str(maximum), + 'weighted_global_prefix_upper_bits': maximum.bit_length(), + 'charge_rounded_up_to_64_bits': 64*((maximum.bit_length()+63)//64), + 'crude_product_prefix_upper_bits': crude.bit_length(), + 'after_easy_completed_bank_decode_upper_bits': (maximum*completed_decode).bit_length(), + 'local_stage_checkpoints': checkpoints, + 'norm_proof': 'owner/address permutations are isometries; each hosted helper is bounded by the largest current encoded DATA-bank norm. Use exact local block-prefix envelopes, exact source code prefix norm, endpoint block norms and triangle inequalities at actual bridges', + 'limits': 'terminal hole decoder omitted; tape, native child interior defect and all-size rounded-interface theorem remain separate'} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', action='store_true') + args = parser.parse_args() + meta = json.loads((HERE/'BIT-SIGNED-INPUT.json').read_bytes()) + compressed = (HERE/'BIT-SIGNED-INPUT-WORD.json.gz').read_bytes() + raw = gzip.decompress(compressed) + need(sha256(compressed).hexdigest() == meta['word_gzip_sha256'] and + sha256(raw).hexdigest() == meta['word_canonical_sha256'], 'actual signed producer word hashes') + program = json.loads(raw) + frozen = json.loads((HERE/'BIT-THREE-ROW-INPUT.json').read_bytes()) + records, matrices = program['records'], frozen['matrices'] + forward, f, ef = replay(records) + inverse, r, er = replay(records, True) + roundtrip, _, _ = replay(records, True, forward) + need(roundtrip == identity(N), 'full signed inverse roundtrip') + need(f == meta['prefix_F'] and r == meta['prefix_R'], 'independent exact prefix discrepancy') + source_code, source_rows, source_prefix, source_norm = code(records) + for direction, rows in enumerate((forward, inverse)): + for p in range(V): + need(rows[p] == source_rows[direction][p], 'integer source interface has dirt/target dependence') + need(rows[V+p].get(V+p) == 1 and all(j < V or j == V+p or j >= 2*V for j in rows[V+p]), + 'integer target self block') + need(all(not c & 1 for j,c in rows[V+p].items() if j >= 2*V), 'odd helper leakage') + for h in range(2*V,N): + need(rows[h] == {h:1}, 'integer helper not literally restored') + expected = [1 << i for i in range(N)] + [0] + for p in range(V): + expected[p] = matrices['Hinv' if direction else 'H'][p] + expected[V+p] ^= (1 << p) if direction else matrices['H'][p] + need(parity(rows) == expected, 'integer lift is not actual all-column BIT code') + need(dense_digest(source_rows[0],V) == meta['source_integer_matrix_sha256'] and + dense_digest(source_rows[1],V) == meta['source_integer_inverse_sha256'], 'source code digest') + ordered = json.loads((HERE/'BIT-NATIVE-CONTROLLER-WORD.json').read_bytes())['ordered_controller'] + bound = global_bound(ordered, [block_norms(forward),block_norms(inverse)], + [f,r], [ef,er], source_prefix, source_norm) + result = {'status':'PASS_INDEPENDENT_SIGNED_BIT_LIFT_AND_ALL63_CODE_GROWTH_ENDPOINT_OPEN', + 'signed_word_canonical_sha256':meta['word_canonical_sha256'], + 'all_integer_columns_each_orientation':N, 'literal_helpers_restored':438, + 'full_forward_inverse_roundtrip':True, 'local_exact_prefix':[f,r], + 'local_old_formula_bits':[(64*f**3*r**2).bit_length(),((1<<18)*f**5*r**4).bit_length()], + 'source_code_ADDs':len(source_code), 'source_code_exact_prefix':source_prefix, + 'source_code_endpoint_norm':source_norm, + 'local_endpoint_block_norms':[block_norms(forward),block_norms(inverse)], + 'global_controller_growth':bound, + 'integer_scope':'The source is A_Z x, helpers exactly restored, target self identity and even helper leakage. The desired coded target identity is over F2; no integer identity substitution is made.', + 'limits':['exact signed scalar normalization and copied snapshots, not internal native child errors', + 'no global restored endpoint or terminal N E^-1 N implementation', + 'new charged precision theorem, physical source/tape invoice and modern all-size release not supplied', + 'no supplier or conditional kappa claim']} + if args.write: + (HERE/'BIT-SIGNED-AUDIT.json').write_text(json.dumps(result,sort_keys=True,indent=2)+'\n') + else: + need(json.loads((HERE/'BIT-SIGNED-AUDIT.json').read_bytes()) == json.loads(canonical(result)), + 'complete signed/controller growth receipt differs') + print(result['status']) + print('local norms',f,r,'all63 bridge prefix bits',bound['weighted_global_prefix_upper_bits']) + + +if __name__ == '__main__': + main() diff --git a/research/r429-full-target-interface/frozen/old/root-pruned-code/BIT-PRUNED-WORD.json.gz b/research/r429-full-target-interface/frozen/old/root-pruned-code/BIT-PRUNED-WORD.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..672c41534608d0d812b8020e496177d7c41c8527 GIT binary patch literal 59514 zcmZ6y2|QHM8$WC}wrLo+WhqJ4Y!y)m@6qq~`~Tnft@*h3KKGn+&pqck&v~Bj^SuXBAS`?T*mf76j`c^k zqa zSkB6;&ElAiZS&ook18>{+jYCE=DSZ~{_fn_{d00>;lS067sWAK565>lJ{Ir(`Mvvd zd}j%?@lz#c^Y^ozk4`aL-3NA7W4_s3{bo}av$Q!>7ZbSsZlTy=w`=Y4&XCj2kB{GD zHoGq;Ni6LaNgQ}Mp%Sxw-8Z{NISa*(yNjF0YGYQ#yo(pc*B<__nOytU zsnJ72$}OS2Yo}|S0=Kgka_yf@Z5|p@X}S6zQDCpb+L6HC-a~S^h4z8}=Om){+o3zT zg^q#$pA*mAPw$~qKHP!L>@B0Q_DlHMP^7JP#$D-Thrr1!soYPGrn(LtQ*H_9O*?(b z{y(B8Q!|H-skDUmzCL})F>p2OR_-St`g`hR@q$y!&ie(Y)}6J5V*A}+o1R0@0=8SH z7>8_?TLOD?PS@H8PG=p?wQu>4D5CfM=~~CYwXD0jpVm(N+T0%zz3*vTlH)kB?mKPh z_rOBr+<(P4R-Wx{jqh%M-`#n(`@KMSXXPQd0&_Bx?zFo;JHGQ*<=Jno-RbYoc5m!H z+WCEQckTE1)va8O@V_Z|j>gf@b%mdjpXW79 za-4LYQQyRDdl2Cyek&f=4qxNm0gW=2c?$jRnOwYWE7uu(5iGd5pQ2tWfTA$Gn_#6? zLkJGYCU|-!4Pq%n>o)TL1U$h z5SZ`jr-d`t`J2sUex34RQ#7%oz*4=`n>DJxC%}RhnHBVo&?ECK7P*6)x-w{!Q?1XC zqODD=zl;?WD0Ig*Sp>za+VZKOq@nx)dT!ifF;PRwn%wmDLve2=4zKYKS~)qf$5F3B z1|upQMzhz_q(^8fmh7bEo;2x}0Jc`7TgRs;6)((0iC{|`qExU6ULZj*xU{%;yFuny z=u}twr{PQ~?LfCZAvA%Jr}iZH3nYU`i| z%k<56EdxvTbD_09DuxgRzViF0^9Q_g2O(w3Wwp98TpvJo&jWu|70_9 zXyz+!9@Tw3Lw7sE4Iep*^b(C5y}1OcFXZJtU=C8ZxE+-+u<-UcWdbPsHk*m;C=v&mj<= z^1r*=4~=}u@*BWu4vTQvddFXSru%TbWY0W;S2DeIQqz6%Knjn@+YpR*W>vf zwkLf2(sA)W;$U^C7K}?eEgnkIHJAj|2L?6g@Z!Npel3_jVpa}P8>>6?e5wR9GA7r$ zHRU&*!LpfEMvC6K54Es$Jd0Cjoz`E@@Sx`qAe=rqJck4Q(jH5~LydWYgbz_ReQK^< zph{v&V}9Twswku`$NUVB#ce)42TMo@f%)=6oZy!@E zWjPMkQU|{&EXi-1pI}J0=6T8&9R2OMJcl|IM0_XlX^N57nm##u&D98hJWH@@a#b%5YRY$>fFbtU|t!&TVmZQqp*|gWTDB z;t6;{GEWXq8m_Tzg%?-yD}lF_;9@JEcYwWstVOf;OX4T3m~-eke9KToih5zXf1cvi zzaNL4*-%9e=gfAK^XktSYoQKN-eiIcc?}Dv?K3>Owx7S?nDi6@mZi4(OtGUYao+tj z-80=t4w)$;{W-)%CO7d7s)%Q#^i+PvMeEfbt2p-p8t)pT|4#V+>XHB)Rj!`FQxnK` zS92`T5Hjs}e!@DqhyFQlAP;kF{6BXJpZDAhpj#@&jPjbN5fv$<-y>(>K<_(ry|5D$ z;R|hy{JIXoDUwIWb!_O-$|rOjB0TrrRZU- z81-Q+R3z%0`bw8~Z9svq-&A=T2a`vYhNVTv=J~4=FxGbP6$@ZG!baS3$S~|7&dTw&1d#f?Tg|`5>cd7Mw{|Id8E2Y#wi19 zaG0{!33-@Spr^sI|4$B%g{G8lTB7+ahvQHlURgi1-BzgPWj2CD(<&O7SG}RlEB3g< z`ren(SYk^GZ|fYVz4l-bYC{*5)}I&|1E1w}P%Z3mmRu-1 zl^ULJ2M8uTY_!X#?MM1xujK!ZGQR(*knydJ^cY9q>7soa%Xt+%4Jr9`HuKCRX@9TC zY_k}1MLb$}nvV%-hxnNT0ki>q?sL8T)&pSwG{3M8CbKSVafgP8Lev_+rfL8^y%x$E zo#~qHXHs;L&6j1G;V|-0+BH3%(^c&o9LIahsB!?uBn{>xY=4vRVyO>;HFax=j}cTbxZ!u) zrKJQaBgw~6oI_O4d3mV|k;cOvR45M?q`~Am97IjXGc~HIp#oyAR)S$w-xJo7%ADV=vQQU z?Ij$>NDhcAJd%WdrD;*J6Dv5^!%qE6R;20oKvcWU9E$XV=Y^PxUDpI%E@Rc{zHc|L zofA2VcDY6VeaZitD!w<&Fi%E`D^tUK7Z9CE1n76o`efxQ@T0I}*YIZNXO5g*8q}55g z#dcTo54MgSW|#$bOG5o!v3W&IX;Y~x)>K&)orDtVMqsIeGGwA*a!%a4MkPEv;xBvcE9%0+k@uH@Mtw~FqF5vT7!$UXS|JK+`P)kq!LH^T~Xl0X`!mWr@?~U?_Dq` zBQ^=eDJvMtH^T|Bln;Dc8IS^do&Ekj1H7w0@#j^g;N_f_8&{swj$h866wP2`IMBXc zL6)fS$d%le}PelJg{j+EYOx0`rg(?3R(|G{l!};o5cSHe!*b z-|vp2u`h{f$XW?7)lw*?o{o<{{VGHi)!I6PJ^G0Z^T?Ttvvk-Xt zds0H)!`{gtLkmA3KgN|N6`y#w0BVgcU&|Yls`b(8oVg_(0sX0cA?bFK#*P(%swiLf zHo{}fGs)4-`A*k!Ggeg>NA_T|Khl?;k@-o>%i!4MY?7v$gJAfQp)oG_G}s~|DGh2} zZ4MPn(n9IRVkW{saXq#qJ3o^@MNN^OVR9ee(2O0FLOox#H%8UpGx8$9{pCzUJph;tE0xR4ftcusDZ&>Oc>{uN-l7g-@EX ztWlBl7R5@Hvzcy*3)}*wiDvSB(5VNV9k9 z5=aSn;p(h&Y;v>{9|VPXbZWW;pOft7nJjS*z9_k!$At~Xo8%SU1V2JpGVR72MOkN2RSfj%|4ewN!gT=d#Akl~#o}(>&rR&FP?FREDCSY4K zQKkCa^neuiU~-o9w*kF|hEv!}nW^Vx-zrLZ=Rl{~1fWFsb4S4yj+#dMfv}v(hg(B7Eme%7Q>3H?wbTPdaY z;%o5mF7{lBYU4RjaZ}F)%egeF zl@<{RYf7PxqMGh~gI=};SZPV1^=PbzR*8xwY5c6yh}=A>!s;SL3uRY4Ru1KXOWr%6 zH0j*Iv(`}n6V(p7C+%Yl$&v9x=ld>Y2z?zAy=gHlLVarE?Sr=Y9ale6w9g<^2Qjj- z<2L&$oz=p2)Ph4#hO6RjDGoWR;oV8u>}&L=2NQVdgy>MR78AtM?xyZTl|=6XzGO~G ztKEuWxaCOm$cD0q+{Rm4+?&{CN7yYClIa6&5+=#0vo!DqDXGQ?x9Zx48m!0p>q8ah zPq)#J8Jp5=ZSFVnuBt^s8*G|s=#|sxA{x8)Bu8i)Wkf=_UX9J!)9+*wm(UFSjhUjm zoXA_+efqa3f*Mjhw(3co!~{u(>0ND^Yr!B5&NWY+;OcZWm*H3|vQAb$7qHcfvM~!) z=judARcM7w=ij(|IW%!ADA_~!0gpls4BnW@_v}Him5WaF++K@T_kU>5$f<8d#O#MD z${jG&q#nKfG~n~Pe3CS2hahm3CF$*Qc{cC2jJL_3dZgsObs0U5RT`9vieir6xHP3W_oj+GlS;B@`uPSlraP^w!{^E?WaQGt6fzyp;%SRPU-)1K$w3 zgGSVp$7GceTMk1U-$9abGrH7v=~n;u?Vi@!qKw|xu0?)!8Z3B4K7Z(X<2Ebn6@*=gI849O9iEu?lzS++=fA=*(CKm zOAM3HjJ!AUTH|gZ^bTg!R|znw_>SA?>xz^l%ei#nT2lm}A%`>WK(_gPE^6C@K(a-x z=^wqj#BlM0V@<2qY?4-d&WC5wG{r)^V2ryLr-g_CUq^bo`62qwVWr0(IBWLy`)3t3 z$gmTpok?Gss*5huL)&PQq(ib4lK!KU;`bV}iQiySXFPAs)u`0S{qea=jMwLv?TjFV zBWaKy2v~>_iejF!MhQGYvp3hIQ0&a*zqV^K2hjDmF|~5yE^ld1&Q86$zxN2&jwhVQ z?6-pD>)wi+y`}XcfJG=QC&tgqA^i@Bn_)}z zA(db89dqHB#}cW&EL_)v4S7+chnN*6UiV++`Ip$J30A9hloL5aCm@}82mfTw4#DKu zJ1|%Ux|+1ntQLYo-nYJ2e|lrE-VzB`n10n0OL1Av42%ScyBxTd)0}^v#~ZT_LgK4_ znDYnj=Xzsin6MZnuele0kXU(81*1Q4ScmFW>91zzJn-xpAp~{TtFg|up7*{|JTjDY zbuQpB8t*C)KJ_|5Wm;v{p*qfs88BBjwwSo6zGais1d&SKR_jV9Zc0JVC;7dtuUM2X zGuB^?m4?P1W6=EOJEbO}U_&>K9(@1IP@&{_FlNqO?%iA3qBJ_GaTPbw|1e&fkwb)f z%<{c}Y6wHLc~|yJyEZiRe)-tGw+-h_I;XQYkJ>re-NHaU@I8WjnZ3HP=5TI~R;`b= zo?9KG?q8p-km-*319_7rRqUKXHwB>s*F3wm$5G2s!J0_*z#1*|XYqXyo(Yx^=%HYR zR&5(;`1hPw+{B~|n{Ombm8c}U9$K*BGkl-w>l;vsAoUq96V1HIKL=l8(cOudm5Pkg zZ={Qq3^#NDG904~vx&q*95JNr1gLdMla^#}POA3Plm@R;VNz!gnF zpwjtMFNyei9kruuahm`sp=>fz1(JRdlX=oYUz&;U}8t>Mf3n{4t& zp0m%B-wGr7^S_Z+Tp{^4p%P1yd+vNYLeA9mw6DS!S4f$c7E_XDmdvAF@wV|DN|10r z#X7G=9L%#@M>|`Cjg+s(fjb-kT{$W!gkvX|P7!kfCSqCrHd$Y0R7^qAr3mKJ+|;%* za!t6fNYe^L4@j4oz9-P6DI&yU?>PL9!YLG**SFwLFX7E08l+!A<+wq^OQ9YP<>|og zI0g0{&SPX&bv%>IV8xDl^aYT%OKOcA!v9ul2J_6NP=PZxqPhS~yo+sR0(Ut%)snsV zLBnwPs!TbJ*PCuRaaZImN!oQf_-JLn>nvOp6{3!`3SKYNQnzp-EF@IUz(te1s)xmr zAA5=ElNo{~aSHok*NgJMLN%h!y`Hq4OiZv)mu6gS4j?%@zb4al-rNvK7f4z`mjwVD ztt!U#fgeNxDcJf-V%oe^+8lM>shrfc$RYr6B}?OlvkCdh`$=+o4%wFQ`GzEK1grQD zwGuOkzWb#Jyw#gGncHY+h~%L6iG}@Jv@REVY`bzQt0b&OEL6t@L^7V9)x-|Oh)JW` zdsOIM#OH&^Ifn8OnFMEiPd;Kfi(%qsG7=SK^SFMUGG^teSWzx{XGDmr%5at(U{Ocq z?DIz`7Qq7jlw?A+qB!ggF(N`H34WGIsq;y|IJYCt!iQgE0Jq>azqSF~(jb9pkwn4q zzHe%4oV7BP7Wt2aSMow-geFt|)R~0W#|}*FMGz{Y?m+S<7LHt-giHdvB|e*z@vd$l=U_=1WL#W~Yo9>!W4i?Z zO6(On2K>Hw;*Eg-E-pt|-Z!yKQOV?c5yv}H&PubHc!>;Qq8=b>ggJhtlASr$rP;a? ziR&niGY#Ki%i5GJDC-Fsr11HXw)(wm>KFhxdY6P7k0#WZy8L-fZZkB+8_P7B>yBjR zNS__a6d4+4ixb?~yp^%6P#(#}(Yi8GLkwTK>s+KQOLdLb_#h^_kM~1MhMXiUEzd;r zEF8|$aGPX*7T#!-Kszq2mw7Lu(%P3Q`=` za1!fYN%X@FTZr3xTxB_!E0yiWlUBz{8$dG0dP zgXwYqvsW%{S@pTF-&N|w4%K3d`d4LotA~NV3ZiZq=1*yDUk!ub!97%903OttV61iW z7h$)q)rUcrghq3|w`!|rVj@)$iuAcfoB%`s*}cmvFJXZTwt`CMoaWbO36{4tOE6bQ z8mFni-kVEit}mZ!AV8BX6D-$=z+FLEP89na${(UK_%ay@hSQoBI5VqsxX9@RvR#Sp z8vDi4hUL`@7Kd#yZWVJ~re=+Zz+P!4z<8Q5Of>;`$6(I zeiu2=nhpm8aJk8A)~9t+e2~T^Bl#+MV-Qs>RxQT#aWi$UT`Kg|o*nI1XbQTz_=z57 zmR}@Y2~G#%cjJuy#uLu3<+e zR_ivg#YWCNq-`*gT64EpV?ciw|nK(n^j!fR#q{A|!xK6P6pZ^G9 z{0M}-Q%Z;!qQ;XVv?D1#A$cB-)}}Q2`7;i4u`$++S^$UUSnrF^GVn8lJ-|Hto z25^OgE^bv}ukkyD8{&~i0Q$=#6-Y@r_pQ|CF@2-_9(KI|c#R56mZ9z*28k)7z^_N# zTA4VXwDQHwEDbwQ0Df8c$$^quy%Gx{FXmkH%!`M{W@%YR%J@esQwJ)im;jbn#i|l+ zVF|a0#;w8!1XjypAKZ2S%%OKiE~v0aH9LUXcZ)3lay>z$F(AR@su{k1KQSpl)Pr*L zkViL-=ZxwQw7)rCCr|f4-R%J}v%J~G;pKEzSn|YY#-Z=%q0PJA>95#m< z`vM_J1;8IFf%8u}w|CtAJF+S`s`iSz!R_Emv)Tu8C+=iR=L^eubgF`1QkNKruPQC^ z^vIfMBS*_bjx#IyY^8!}mTB|a@0&zIZPXucm8*r6UY6Q0VYMc3(cwb##^ZxMo>;EB zK>3TaX)aX=MJM2P$G_zO`E8bYt8wpKm}|r8xqk5~MvqmX*VWjP!wdXci{%l^o)K9ynLjCOxZMb(~Uxn%yYNr2G1}$@TtdLkUw|HN@s|3qc z7?}J42r~WM%Y`_tSf_XF>brss>8GnsR~^2mnzndwlD(v>-U|9!1r|J=L(hzNj~Z1g zG5#;e{@89X{HY}DeG{+R!{_4h4BksdTolBrpU0GdgwvLKVoYH25xHy%;_HyU0eV{w z$<%Wc;o$s_xlD?<(;OL6FuZ?I3cB zZcwEseT(%)ZxA_gGbAO}_T;FhL0UR?=6xA)le4tS*x~x)Hyq(I4c&%aJRmog&W;PU zL7}}HucX#RbAb$&!GpRdi|SmVyvdb~8=+TG{JbLV@KmM!ZY8DURIs@or$VQX4t}8p z%O4{rHnou3WXl}@&^VAVQr#}?9feRs3TsD-q}ADKG5JuVIj&h8dTYiCKo@W4WSfs6 zfJ16yrW3*kdAaOoGV*&aBPy2eNdF8Gn8`b)R5Teq>v}gnO=RzV-ezY0Y|)e9d}*l5 z0||Ax{C)zDNo?l<=Dc*SP+m*!djGY!pFyeMS3@O(93jXO*4Y{N6(}-)RcO_=R;&@+Hr6*K~hTMtn+;5}mlB^63R6ns>@o`~X6|QHiZ|^ON=; zE*cNCDeaAr7E=o~m8@E@4=U*-7Hp_Pk$>qrOLUWY)$xZ~@^cLDmYheXUu9!(4?uIw zdLS0Iz7%>&PJFw=Trq4@j`C5m-Mi_h%QLdG-USjT#g*@{mKxo}|NbH=R?zs&>R=<- zhJy~f|HvgPmVC<0>4#LP#r?)h9>8`Hv#wN8@2<&vi^q4k0hK=u-z7@|NuG_$?`dWd2=b{{q#hHF9CWX46dSZ~o z8$4a6l%!Q7cC{PPJ4gdzPN3C;xv0m}AWh19CPzTc$sGIQ+s&UYCzArdBeOeuWI?z3yvCyEd!A{L!@g(S^B>BFej6tU%M78a! z7;G`lc2JW|e2hP;@r~hEOxv5;j0rxPOm?Rr%p^hk?OeJ#;(|6)3Z?G!>tfmW!QqE# zZ3h24x{ag5UiLTy$Ul7F-u628H(RMPjk?D5#K{*<-w?w1f{F5lhZ>)2|}C zSdQsyr2yke#VH1<8&5Brfh&-w$h%&~g|$z8vnXMt(sgVtwOmZ*+e^a;)wU zgfhVzo>X*sm$=hsHA}a>a>XNRE6xb)Jk|=@ugx_CcYh^5g4KVJnt8-6D)mjzP1Qz^ zR6hwf`T?2PF7fT|o+=(XJGS}_^aS>DDlpO+Fi$!6&ze@efYH(J^ERMsb~m*>A(bjE zJ31|uSIoW{}dJxy)S+xjb7HK779WuR6Q|@nZ$S=Ik=g4rq~w%F`!NO%E2yC z(DP&o1fe1Xd6JHHfMFW|8{TfV7l`)-SZ?dZu3*PdA8gkjf!*|5O<_NycmG4(ED{LC z67xsKK&uhLM*~-!xxz8fic8a^b80y1LfdnZ@$| zv-v4pd zxKGFb3_@VheKO%MEdwxD`{|mB(y6I%l3XX{9$)})wMyQtZ$M+rtopsDnEd)(67H|~ zyPohsEW?i+69;K-fUCJqJG0$Iuo|XGly`AZfLlSrv00_F$PVxW%R(0{t?i;1uW>CT z9MLK^6wvPqpqB)$Tw^-BBa*b>GcVbl^n>P7tab=dt4c^tssT%53fIV~c&md+fHO3s znU87l(2pOA$naP1QI>QU!*we5{XPJ)n#`PMZj(KF(6>nLUKFsX#IzT%eB=20vPtL# zUxID=K^Tk~_TfY#EfL_$3Mi(cK0Gjk3ujpNV&W?>>iZ?`urZ{&0Gp~$wdfoFN*df8L9w0AWTGbJH{x76ys+9#IMsR0t+g15_+3_JXq6{&vJxM z3I-RoD}GuJ!q}#m_dp-?StcOJPdR)Bdq;aRpZFrwbiM$?W_D_J?%N2RH8{R~FvTK4DH| zkw7A>QCTiB8e*X+y{bulR`xZodoL~C$`w>d#>mTy?K7Tj3Y;TBrLVIWlId+41UjN7 zLqrfQElH153Kro$6o11HX9cmga`9xJ^JB^TA#&pds=&m%0+*&guN)g z*&o0p*keNN!}#aRAkkLF3ipmxAD|Y{30EF)4gHRv?EC`3JWquHNNk>OEV{mRAK)Jx zjKry<4*gBz6WN|XoBWDk6%jI>l$wq%#lG?Z z-Fa)g(g0b|Zp9pH)KenqPU7T{(OTg9m}C^#J7sY^+=kWSDTanIaEnE!<;iE%r)pj= zK7Rcfaveph+8A+65)S3j=3kf2-b&{IfQ=F`jeSdn2mG+;cs(4|rYHOR7gMflyvexA zoDNwPkmD-^c~zM`r~g$FAPiL3F>?%gpld1sB9lRDl~YnH&&g2~`|hk})5_7sO+m>o z`x}%HK70PBEpImK9WeO;rNb+_A~WZa*(#rK%)ENq@P=zLv4dg*p)IdAI?>3e;+=(h;VJE#TMWVY75H`+lN3!=wby04k4_x<)*vJNaLS;JPVG) zHcd{-0I%H+gnBGUX=4vig5)300cPlz>L5e<;TVIrpV8izv-fpy0?r1yP-(Kf%KMBc zjOiA7`NwC|tV!T6e2CU*zr{Z=4O`gX6gjD>yFNN46##8$Yb0LA(mzba`?J!9^B5b* zLL%FOHXo(xNdN~jaw)D6u8g#DS$~Bqr(&y*88>V&C{{Y{d=L+-2M7-lpFqwx{cW%9 zT(gh28SNjJ^;SVvzZrY_LgkpzC~zv_KV7rB#bAMbpIdvwexOILg7ujL%yk3S;Db-- zoT(6tG-FZ`7n{xTocsgV`0;WUi#Y66URZtx4)nf8^ zEF|y=PBdbJuU&&$3qznB zI$g&$`W*4{M?YO_zbRuz<7!K$NAgZ}GB58)>RhLec|^Ui=8j{!2)*`@KO02-~hD0z^lT-!P}h zcE}1rV+FT{Zn5MK=EkPy-aLLICXJRzW2L1QT@=|u?WHqPmi?TH(iEIr{OQj(qlV{T zkp%+~mpYNF-QXf)ur}6}PpYNylv|$#;;0rgA9LP3YjWyt5_DQ28+gbRo;5yo7K!(> z*K!)>5t5WZ89A50EDX*lp|G4_wz6L?{6_Y~0{X>}DL8j~5B^FEF~vThyW&qz1|~e| zCjS`3hI?mCiNmg^HJP+|YW7AJ%Hqs)9K}JlR83M&A}u?$t2a3m+He^1Or{?zG1U+F zBNPYSKM9oAVg_0I#q^(sS-Q(J&SAiCx~p@kvqW0}w2>+#ndzyMg#an-!^g<&0dY^d zjj|?XRRIf=^LKYio!dZz?xrii-*A#a>Qq7L5!Ae^sq?t%qwnI!Kg;&+ku_CRah*qF zCttTOFQ@8DszP290Ie|vnw_ejB#Ba>{E!ZSXkGdGEmi*z#~HP9bAn zOMz#*xLc25xdf!R20J29o~ywVvIsOV{;36$lEyxi=P(Vgk3 z2F`K6;2!yx0MZc#y}oK`>!@bBei17v?J6?ko0@&&gqCdm{_b05aJ`PG_yO8FC!rz1 z$#596TG2t4UwdfE@q*tf1GdR<@qyOWBZjO``Gf~rqdDE3kTZWSIq|usfA4fl*&{M z+|t>3-dV?T@|3Whflp&f%+|&r?X_L!PL0g*(Qz4}vuMg#U=?fp?Gofj3A z-oM%Ll@?e*YO$o_=r(wLuY)d+bsr&(t>=W+p|q;JAG$bxuaaS`6c`7;yLRkXempgX zgnBEJCbOOe^p0y5s4H)r|7@?4{5Vx#Jgvuicz8@Ij5Y05T$fIzm>W^xyu1R2^o0A=kVwQT4ZtH38JFof6NpI;1a7NP1iKF-{SMRssxZ$VvPg?se7>Nfd>uPX}}# zjWUNCf)ZZ@bXIzRvbKE&Vhz}-ii;wlAvR`WXm|EGxCZL}X96;`NBF?8`Ji5g57clV`&S@A z<@<1%Km)p`#6e1VZo3zLp5@oQ+CR6>`o-7OBF=yA#r$d)zD0GQkJk|v*olgJd#5B{ z4{iYZlUMl$4OI(gRNx85;5dRmE7INbqcc+RytbB8pNM}_v>6zgZJ9s4uWJg`n zI}q@bp1Rce0|dI4;P9cEEj>A?*8uaHO8GP(Qj5ISJA1c)Z>szRClxMf0G~|ncvOag zV!BMZhOhFKIxr~uYh9EsN;Z!iFGV^bpu*W+R6Lin%OiGB+8dmXW$KTY1&}aMUVVeT zqw@Y#ZQin5?TQJg{ti%PHY3pv+ zb@8vjTp8BXl;;l(+vnXwSwT@07ma1O%BR>BT*l%rVTLogzj4LCifh++jszb*$Y^`l z!Q&k4z*i4|yv3RAOYYTpKDDSb0up3`=&i}VWAUP3pV~t@&J}&)G+Aatf8)yj6xZvh zJ>o0(n>Sl8&gfvftgmxm9j3)L&z{|+mK81c*XUCFR8~x5t9c+FI*c_tIDStM%MmA{ zoNQTB*UxCTcrlgk8fc)}QkFNRV6q~N-Y1I==gmHzV061f_KbJd9Za~sYVVmm+!X>o z$5LcI0IAx3LEarD+6V(547@em4@{D=LXcJU0T9LOm^yQ+%qSZ|bZvE_|62%9`ed|B zMVNZ;RA6w)G>mZrFZ}Qo-5i+D!D1cZf>K2 zRH4!;?-Le=PW*rg!1GS=UPhZZOy~j^0j1iIk!NRUq6G1Nghc!GHJmY~rxeSq=JUFu zlp)r`c6ak%!(a;_-T(A@!mpQvT30;N8l?8GryW;O1@NVNmYeRCPO^_2U>Yp2_2KR7*>{qgmV!=-Az z&uO0_srtG8F32N)T)`*;{c{yC>ED|>-@NQbg!e<9&Fr)viq41qlCXhVmN zZ16Rnp*BFBvY$Js=Y+3-Rg)Frjj0>ueJGGbT_d!vY=pK;J!Q3?_xUrLhy9s#85qe@ zc^I15-jGLZh8b(n7QGp_D+_0+MdmF7fZ{W)e&IjK0>B-H zO?>MC3eXU;as4Wm_4~~ZO}2e_o~SZaA<|jRm+Y~Kg|sWzlnHQbkbg9*fw^28BM+CJ z0_SP}&bcbk<$&_HuKrp-BVdNK#b%0c5rM8RwYQy^>yj*F7+LcfLck}85Vu%RluzA7 z%;sbKSTwoyD~T98@Q}Oc4OF%JQxCU!?Fk!cS}dE3_lZa8`wJg(&n~rxNB)@d{4v%2 z4X|aNM{LNWh7;bee|d7^(db?Q+mG?9>tB2#{j>HLmUGK}Yd4A*cz67Yj(QNKmlM#Y zjLbu)dee`OWXj2X>otl9%)0$c&2%##y={_xwbJP1yQ#O5mnXQGk|=6J!|>dV?CpR! zK$NIhxqi8E$n5cLw1ate?VaA1(7@WFLSMPr(fsj8{DyfM8iR7dF11C!&YJc&XY1Sr z1>SmU;D*dLYtYd)K#K;e~uI=56NnG#EjT>y5WLm#&kCMGW z{h^L!$Kf%))<~By75_R;cM5$W#i2I^aIO?hHRg@?|Jcjvwlfz`2LVdIZnPs=dyncc zw+zq=XVztq!66k(dy1Hka&=-a7=+^GLn}QsJJ~#(3W)Kc0>Xw~KI>#|jJNd_D4sJlr;QI+iQgW2l9gVA%}QYRfR6T-y|Ej!60QePMUk^82%gzkc7` z`CK=?^ruxSK%;s)%qS-JSJ=~?&o`d=PJQ@2eq?*>?RfWE7;Z=B;IWaI;&0zqw}1Oa zUJ*w$NEouL4t?pU)Uk90oExVV# zeZRS*Q>uz!lW7c6+&-e()M+9#w%~uSI9Jc?mTr#f$HkTH;=z-ymc;D z=^*UqsJubYYTNwC&9N_!Jp|(onZ1K^QHm>3uP%i~U&zcqCF?Wo6%jalK6ElW>lCkE zsbf0V9J|M_hB1y)jmdb~`Dw4jHvjb7kEBZNL{*dZo+8o)?;zehT%3_tOX*W8wNNq0 zW@?W&N>$ucvP23^ei&4YJ~F-WVN9vnBa=(8ZY<*d=>yFt#ve;n8jA`hUs?K4=HiH- zIv@7J>ea!2_tpFOlA{(b55_P_?t-z&LzlEAX9oV=-h0t2OAkQphLwx0 zF6sHFE{Ntkwk~<)t@b}$O2nNORrvSp3&%~qA8d8$zj;bhuQc>VqQslQ$32(w&g_lb zUdMm#+)7zY#2rZy|9AV_jfYp-E*|T{HT9SrGz(pO{ae(#SbO~FL&M&KoCh6Sw}X;F z_jdg<_u6|B8i~`}WIW70a`3DkQpmSEB6*JSaOjBZ*-qrw=8qpySev$|7s32p5LEzG zz4PvU+E{NpW&E#eImGhXsMh~9R2sSl`*wJ|_PpM|ZVf>N9X3Kg9{kUMO~ND&kGDx( z$Up0TAycwBQoS!?_G8$KnnNkVU<4S07+;4C#-+T5r{UMsldnAO8N}SJjq*6wH+=tz zo>EF@8!zm}3_54XB>aZMcpgM3I!^1{2Ey2V6^kIA{oy0W3J z1~2^FruPcid_9D1GF&_~<(0SHZyWj|^>ycIFylbs@}B;C$md4G_~hR*ILQm&4?B$r zsIAMY2*w&Rmj^Me|LH{b6Fq(~ZV~EzIyP;Or7kQQIf8lbysdX5Q6cPqg1wQAP&cVM z>@+5D=A5WE>}SManalOss1WcP|5^Yl{DRuB@_r2CX1*ene^z!~7F2k;`dj<1= z<%gWQM?DEkH8E&orztJh%=_)pQn z{11Z?V1gYNz4F9h8>3)&Z(X?t(R=cKWDui*TxkaVIQCO$PX$N+-vZFFP*A*%ba>`ZV$(X{lOpzeQU55H~$!dT#=4W`M2cO4kj5oZ9qp3W}V_V zXrZ#F(qVI=4N9(Hh#QFRHBm|b(dcXUI_zIuSEqrgvY#w2^Kk63H-NW#cWv~ZH(St}C0~yrjKXz=z;t=_CCpDt-O%Nm0#B8Ed3yJ;GO~zf`FG`I@4h@~{Kh0<} zJT-RUPGCEAt0t&rtaRvF|LMJk=MhOk?R1AbL0ea9>w=1MLI14BZzH%r-!9z$k^Vw@ z;`vAEK{u(8D?ErRkvyAPqd3{AkOyN!E&UdO{76iF;D?pMcUIO7s+ndN+s@`tnIf5lex z@AUK-RBQA zZ~gq@u_!33ABBguqSY{WY4{v;d|Ja~PUQuE<0ACWg)>SKWduYz(a)sGT75(k`{NmdWF`?^hlQ#PQoLyrG7!>2*FsFS`KGqcSw{p_-?)eCtn|Zt*d?jIf9T~=8{X!x|&Ir72aqN}{Vvn!)fA67QmTR$}gR)=@=kCx+Tq^yf07otnXUj2X@ z`HXWY*n6hR+!>w8iTyktTeQkg4^o@GpblxWI@6bEj;kzcq3mjYcqn{_SaNjITCmWM zO=+}yM9uwCE@$C)g=+pmz6MMsJsebteQJ-4xk-P=MRNGFP2+Fk?7(n)rw_qj^9^$TKbeEhP@d*%>XQeS)u8@k^% zTm8<|BFZYod2^Vr6-!0s%0zjhc;##-3cB$~cUtx40g z*}*@_sNVB)1be+F0(tcHD$7`c)B5BU1;HTQpP%7RJC(g%R*n&v9bS!Cou7-D62vIl z&gD|ddX_`1uj2e6)6HY>*&=bZ{n4&+FGmbB=@4tG3vHNH88hSrBcnprB?7>BU$dJ6 zf){EVzC_$l_>@^jMol>qDwZ)y9=C~fcb${oj;0d3StnaK_qjaytEjNk_vj?0d$L5Q z1rv~9iMhN4`|)O70G}C+wI&zht;ZC&fG=!s!U{e%btN{*T|;4Z$_kny8?W@LUePZ`4Y{hHFleJ4_~htx&kwufb+QKJNh{P#**~1C9cb4wJDh45T#R}A z74J^Y+tnCPlCtEOq(|nt=g8YhQ>P72(JH6fxSo%%$+jf4d!8ywsz@Em$v_0`PM7N4 zbDOtpkLM%?zF>@CXiWyTlAP(5%Hn=gK&FtXX)CJczt*c?F-D}HJKi!{u1rhFSObJE znILNPodf(>p2TR7LFmH0`80mty{h_fv&OYvnAScshR_JQf|ErdLWAU+bCGF2j*OxZeX}tH!MVHMt;#|!sqU<5#&)Rx?56^6l2V+`7oX`n#GJ%=THYW~@ zI>5)7TKl%UnyJO7Gt z*Y>K4>SLPn6FFL|AGT8OM?4;VRO$KbS+QqMPZ&_ncGcv2>*6-Fz{rk=Bo0|;LNcGD;NovtW?-d`B-NcBQr2&{V@=)XJzf~BTl+>uwk?R4u$Sb#YOd{e|FggY$Wcl% z>}-VBsTy%Rk()e=zHKQI?~<&&(IE4s&%b(GWW22p;Y^JC-<3CGVr4V-HQz?;Gn zzIM%Jz*t@;O~$d`5+t6uwo04f89oTf6qw*k9o_z#{APh6FbjmOxjK=&wUm zGyF!Q*3Or=u{zZ&CZw9nn`JN0m2%DQA&<%ir5-irPrZdH_DO5W|8i5!R%c$|l*v(= zGNg4)9ziC0);j^4Jk3`8RVhyA(bxLF#vSyaF7rnm`uZ10PmM_>HRjJoEX2l=rQJQP zXtOI4hsn(%xLaUNu_=vhzpua!`nG%>a&x7JO~0_3!B&6d=jN30^vlnVll$^f5$K60 z>?P*ETL}G6U+Y3g7}fL;dMGG_H5)Zyx5~XX!%1JhuR1G{@>u>dKR5I4-3VD-G1m9n zkx9VpWS{VPzk(p`tri-Lb?jsYpS;m1`VttA{TaX_qbqmJ>lUkHJlvY&DskIkVU(HR z>F3TW>_p5dx4LjW)NiZuVbkjT;bx){ODM!i$0@-KsTS0DlX58k%bg_!^^&7@g{@z= zejhDxG2V@Xd!6&;@sHhb)tvQ7t`v?U({a(Xyttoq8hQ{QZx>kuZAtXcFw$Iv{0 zW}gAZyRSCIUYy@ef#rs=$Os{RQ}T*{94e0L`eR+NeLEEk+sA5bB|l%Sw`A>gd$kHCeR)#6P{)#Ofvqpt&ZBXkMnn?`j$L0n)Z$?#VhT-ZSFl+(qor=L!0SU@Ds=* z(N_7_#WL!H(TdWUNoBHH^?f7gA0`=`J0;w^;0$E6;rk}G=1a6yyTC90RK!!$p~t3C zR)^JYKt|t!ASeILZ~aj_ETi`fll~A!4d;{I8Q>y)qS&|3%s}h>GnU;4Etb>w_Fe}C zxPFnSW~-H~eom2z<=W-A~h;;5582|ZaJ2o zwzC#uV@|C6-kBXReK}*YKaF0uYAb;8uvsm6>L~@a=h|_dT~m;?#zE=2KGVP5Y`(eF zWZwFy|EOz-N5v1FY_M~htfrjYJCfG_V|^iNl_?$nCGYo0AX_*yzq*KRAW&C-^N6V~ z?ZE-l1djX9B4@)7AN9`(R_7feNw0rLhWMpDzz+Qt9*#0Xb2R9?n$m}_^!9i8zKWD? zdVC{U4U}AS}DIjBHt(b~~Kbwrt9Osb&kfvJtK?3(a&RJL6hTgeT~ z@1Z_TIS8XeYrb@O@UQ}jxo=efUWYOdamh8C6jyVJ2`x`VTRAhRI}NwykKrCZDI;#L9A z{>M2W%Zh7zoc|bF?$((y1v};{Z$?i-vKch~$STuFd`36uh_0gv0>cdY6fCcOHbTa< z#D6fsd&*h#8daqS@XDW&De3P|Os{Xja_J`{3@vg<3uAVC6Zy8u4}3?COggeVj0AG* z-Cshmt7{va7N*~WAEAAMPw6@W>&M1e=lA0GsTKl|hmtXp4#rNh`Y?`qhk)aS-W#VZ zGF~Zwf<;bx#!qjg4gccQ^a74rxTbZ#c{OG7z8#owhVsAYQyl`Q91{|b^4t0gzXu~> z+u4FJNL40p&%lHubkl8iL}EJ(s3x6>pw;dBTuxf9VJ=I@@yd&lxzevAJKwk9?C!XJ zm7lDCt7mbmzo}j*qHfmn-Y1*N@u$F8&ypEPlg>i@OrZ1Cp(C_a$m5_{EX zuT;0^SIbT5yX7gqah9wG@fB>(W36YF(W!P%*dk4#`XJrM>uDlivEi?;4yx&N4RmQ_NJQpO-An zRZ;?{wKyLM4 z8c)hSANL2hZ)%mzI9nE7rz>JRR0ArYIaXawkrBs7ELS!~I@-HC%V+Ol*KD`!C|>XY zulveHohnxVp5kp8FNQ;T$A~Ro?-pP6)P6yzyTUP}*oKakk<+4kv#T9odan&Nrjdg8 zylQ9SS(2VnB41cS8LA!JVj);^o4OPo&^)Db7Lq$N>yuSgFrcH(Jhj?w9yJ;7 z48v{Jx8X^YPaLwdy~K}{N*c@YAG!*A@nzf3MOc(gw?gnat=+V&cqn0=6tMj` zT5mevlfM)smU}(7h%G}AxMe6PJKQ4%b_PLV zmK7wq(6MT~Xbq{mdV@hG$Fm9|vuJu8-&`q?Lm4_2Pgo>ZQSlVVyoMyx&HAf`dz7=x z3!aGw9=&uj&-@=wEBL4=>9n3pA8yrWf5&&z{r0NX1sH7opF6I}0ud_=u{t4! zEXTdYFm#kq$E=rh-;ZOp;i*T{)4}cQ1GnPOlus*mnicB=@kIDR-cb8PwzBS)uRaf_ zgMG)3SvJe?M-b!SERsq$EBC%nrVS>#vTPRQkae9q_h0`+!+XxpY0vfLb(!=A;4Ve zg5|E`0JJL}-Y>Ff+SD~$Nj44nS3^P$c~7C~E1!Zqv+cQ4Ko3m`1+&P6& zAX~4gsmkb(0@#I?)hqZBwss5@>Lh33UVb?15$2lR9=#l2XZD_$6jL8whmwJX%I z$uu>^Nf$mgSA~TypnOfX)&ZreQK#vkB6<4%dMEto=A`euf|or!UwZj^yqA$;CuUY( zyjgv=WK+J=-Ma0^fwEFgKk?wvEKTrzzoY$Il=Fx_t9t`4(-a6f-y|nfXqR)pncO=) z`F2AVkYH_XVCEWNDDem@OEH;qYbMxsO*x&wMZcH&C+k)~3%<1K=+_Tz5Imb|cg0llA!&qm(fsn4m?#|~A_ zos&24QnXbtmkwCXRWfr8BDipckp$uVwEdiVvu|#@ zi4LL@9}}XRGRCIxLZ?}QW^3p9&X|x zd?;-HCFLB(Z#LN|_|eY}xu}iwJZ~@0R76oui=#}(up7PyyI4A9u)u|FN@U`qqJYG8 zvqOV~gO5G|6HUhTMgnK{+mn)i92VRp@UR*^w&RMc=Rwd!zg3v^CzB46n`>M3D%Q_x zUUoLTUhJFLzKvm$V#mgmAkibBqRb1~V8Py*k6s!1xue12KQ{L(R`f&WXI$`T((22> z=6fyFL;R@+oZOCql+6tWet))FD$WxQMh@Za%u|AMyclM`)xCSOt@q$=L?!i(0UuWD zVK}Tc9PFeNA86I=6tl_5hq}8b9il&~D3>%f=GE*3KS_Z6sppLu@MWvV(`y=u_tGp^ zsa6223Axb{fX-)4U$Vk8?uEb2T`*)|C$1Tm%43X1n=ZTQw~Ac{V-Yhyo4CY}h6upz z=mvcxx6^3#Q>zaTS7m!@`LiewqXmh5;?SdB29jkYhx7CdFW&9d8|!aseWv0GE7$kr z$7xcnck{4{;|NdHOK$R}a(~XI^8%)dRWSQfT4o86YCryhfcoK0p2t*lf~p`~GB(z@ z>#)BhU8tl7M-}GZu~8>T#6`-I@&rN79+n2#vv5^VFO#8JD^74b)&DWJwrsi=fzBpg z^GXxf+c8JL7A*H>f(<(CSq-+=>{*CN!;gw)euJS#Wk}W0nkJ~%qZk!j=1#1!pG74v zyqC4)3FAWFlXWJ-U~0Ydhrq5Bl)zwNtz-(k@z1r>HR)x)N3r|8Df=b@^LIT%rQMLL zt0o*bkF@%H+=clOE2;>Rp&1mUAt5s~D6aw%{>Vjfo)cHm>%Wo-XREq*00+wMU6J`b&ZN)|vH(nxGT2?Hi6}hYfLv&^42gPzVdsgA%-382qPIIa{2+^KA zH=!#PV=L;tN9%F!IA=^m?_T37w=A%D!5bdR4}WpmMSPNS5M4jeq-Yk$!7ZGUubBNe z44QbP6jhnJ5CQ+$-YiX(@PG=6xx!NOkR+2mV*w2cdxr!alzcf_G1pn%Piz*L6V_HPtpb5di#U_LZ4@x$o@_^B_F zZ(Uz_jg(+?E&2o>5mNn0&zo@G z>wCe_c`AB8ZQe=r$*VIRGZK?Lgl~2`ToR@v`Q9{S>3Kb@8Z>}lqFua zz;Am%f7i<-&i79cl7qsHz~u!Te&^HEAj7TC`cZNFLctDsp~SxL((a~?#pMaQDWh(! z8h+0BYYI;3Aj9(C$Fm&+O6@A6!sPeS6dGICNUiYAh=7+6i*;hvZFtb{gq&*NK&scAYPNx1GYH|>I}Det zRE3ypq^f;W9+deddc^AEhPu{hVH^;KlJkpSJu!z`HL@g9Ei-$5J$XreBdw8&?KVGb zUX3DA_}NY@1jCMRKV|FiXrkgv;(|iB#SvNZK3tq_S!l_?n=0XAzf#uxQ57sVfP$~| z7Hs-2HH*U@v0X!dF-e3(KRh0+geTpIL~|nU!&O?Es>hSLww~MIcN!Nf`v<0Z=VEJ- zAkswTd4)4mk@KZQvGR+ua;Qy1xkX1GPZHOd)MA+X3uOO&@q&J|oo!StPxyYP*yNEU z9YADL0`QZ1%eg-vHdSKzDh65Ml5S;3r>2B#c=2w7T@hw!#=wB&VnFG4zLMTkisGoa zJO#Nu1*uT0piP?&uSp43w)KiutBpnmfbbU-lI&wPP5XCZGEch;WVKE8TVvfAaVbf1&BB;{d3{En*vd`;}m<$HSXvb%>OSg|mC<+}5! z0ID{r@b{hdPFK^Q=7q&Q(zOSVMZTx1VMFY#0Eja5MkkH6-|Zn%V&cJkVm0=Qy`x*iP!pSM(ej89R|}+_`J`RQxiZXLF-h!`3UinV zAsWUfgvS6tfNtB2>*E8<6pM@Bky|#E_CU0at!ITpRX+cN}+MYfP;>q_G^5#?}uX)ivn+Mh1 zAC6+Dz&(o*9K$hyhZ+@;UkYQtqKCBQMv(aU5m~UEt7z+o@2CS?{f&Q-S~J)8xH$lX z<3VMW@nz`=kjypjEpp$PyF0vvRqw|9Gc+ktz~@H`1B!^fo`~>=~(5 zPPk&s>3&@Yie$<(Q+~}4^bV!OtYx-&T1tEFhoOSu`~Jb+{p%r7n4*vZkJ|;dMP82) zTngGT)!vVN8j$f{iE~S7+WR(5&pa~T`&d;bAo{_-bBkG2mxoZ%e0TxROm=-IulZ0h z{Zz|Glv)6P3^sbt_K7)?QM&4oBHW{dj4hOWt+7h<`KUo{8aCrlFch;imn$2hk6er+YvXWtqgduj4yJrgGt?bx>5Y9A(R}5Wn9QX6hoi`4CaL9{GeKMmt+ciILGePQ( zNmVX3D7cbru180=32O>rQ8fF~3t?nH>Jy=sl<#om0ljep1!*Rx6Nz_(-YQ3AN{7#Q zB{z7~t%HvB<{hbV4Jy#EkI;$&_-M5~@PYLJ!`RA?mmgHmw8CKzeJ%@jSIpe7Q3AfD z?)=k$XH(a_c}v+6=={XaZr)~x7GRq>QbQZ1hSXQc&|>e=ubSP89O(0?E^qL7) zNlu!*e<=LESB=r3Z#cK_xU0)dlWt2to#byTUPxrZQnhw*OG-3%>Cfu`P>7WoV$FL2 zVu%=eem(DNL*aqG+0LYuYq_q$CRMf`QDj?;dP>Zkn=p_0FHgy_vsI=@3vJ)tDtkZZ z>`QBA`VhQ2?qMX*Vxm`K@)h#tHT6Tw8l!8y{Q?y@+Xkz=ISx7vC@cM9P9ihPCNR*V z1|1qIc0%nyxn@&y6{^-;GYa_h>7&{E>=Y;lR?gb&*i6#fmUT4PpiGqr7(s-0nb+32 z7QAuzCTm^8Pcbc0eD6_^dEA`l+l{%;Q=;`XTUOuuI4s4FCnAauAdwlk@s_^?tLpi! z!(6N5XZVLO1wJv@6Z7yS=gqEPMMsTP*v)V>?K{#H0A5v9k2&lkbM-xH-}hRG>I=BK zP!xvQ%%}kkTuVmF3V$D6>_*j{m%UTft0Eu0BfLLcxl!BAxHZRdW`myd0f_Xm0mj`C zZu9X`2Xo&ReoAJyvOXD5{L8>VRN!k=fFHC+EiO6ji1kh45knZEyUL3Khmu`{i*`Bb+>@t?l5Ns zV!q6n*%X@8=Mt9g2yI_{Wi9BL-Uj~Nnvr{(Y$OX(>ks^>m8Du=B6YrRI={Mn$Qdn@ z=NnH|=O~I)UIy@!Ht(%bC8{VrL|@K=QYxqEfpPIisnwUR(FH zXY``a{&^Apf{fR{rbm$@a>Tn~-|{kM$L-#{oAGFkW)*+Umj6S>CC`YXeD|7e+x*7F z@KFWBPVvl$ex~MKqlgq_bVI<0VjCv_+Wa{DzYKiDfL*aNvB_N}8qa-zET)}DTYRA2 zOAAtg{i;Ww8vi5u@=Ex>!b5J$(J)))>ba&Ut6rfB<9xCQAxOYy>9zPoTj6{uS{Ypb z!t3b(OHZZrMCJbEMr|4A+_!oMHjVnag7I-V%Nju{D!c$+z5MCZ-f{tcM=>VFUgS^V z&1?%~$7LUqht)qSGV|T34Qn9HPt)ipx{9%L8~36|qJv(SZLNA=;6B|$KW3!RbeaGa zJj4$>j&Bp+BolurrUc9p%x5`ZGI^{C@&3>ras{XxI2S7RqqQ(?rqJf=R}(yoUN6$Q z_`Hs|Q@aYBcay1_@k|yiM~@XjetnOs8$rFroSzoFytbe#SQK*FKep;}g*Roi48oag zZ+Dqa6b)&ngn=&0L27pJLqCzC-$u_as+rqO{x>D9Tp|xC+{EVgRP9rPGDz6h%z0z| zZI-~^p`SHE*QpX^jhOYIVJcAQ0_0b~yb6qom)}wUnd8CMWkv(F*mOM|Bs2(2F6 zbUs8vSP6iwLK?v2YThFjCxXitzQ^>}D9$6T9zcG51(gU=8EV7gwd!9~Nu4QKre@pE z4w(4PSAfSnfLSg^h!+tT+E{yY_{NO+^MW8Y`*Hw>UE@PDa5b&|^1E!W zvuA*SBv!ehqsI_2Q7HjthtbiFskn~@Z3%hKoN+Pwv5U*y#;tIgn(w2d(kO^g4g_3I z>%fk$1eeQ#v$N>VL&O*uwm2E!$ojD_B~;Fb{JhT4u`gpBI3*MIjz&jhqq+NG#EGS9I5b~ zza20XW1_*!sf61A$dF4ljTnfG%HJRNSx98)gH?}TZ+Jmp=f;SbW#T!4s}t=A(9vo!m_cmq~k0v-&1u7J+&$M>9C-DEevs8-epxKdzW|%3$e5T~zf1y&NEI6oAB= z^>f!7m=E1pVG5xk@XG1AZL6%DxweiKfJP+*g`>XSl`fuHNpL8V{qD*NVV&}0=JeIB`oLcWfk($P zVHU_Y7Za)e$GsOZ5Z%h4u`=8BvpTA2Q&kk)FLc zdiuq6+x6746^vrv(hEL{-Q}C6V7z?H+mS^X-7f&Zz|D1^`RM69liWVIO+Oafihi~B zFjcID!lF$kMHIGYY-0tZni3FfYS3_w9{Hh-nXKeAOMdWoe`b`)&n0 z@(Rp1nYs91Vee&;dmG`IeBM1hy46xW6ks+d2-vJ6S52ZgAWZLXmRoYK`&pOAJAA}s zrBgCmY-{zv%@FGMyl>VF_ zs<&3GpF8b|A~ST65KWHj9FA}D@fdTu*Ze>3fy-^d4YSWj&F(yT{1Tkq&Ab1G zmhAlpQ`!kr4B{7l4b0MG#y6^DwFd@O9Hj zOc0{8Bjq@dw@oP-s~DY;H&R)v_G2;&B?)dQj#=WIXJlJ?6gNgY|LyUY-by~cm*fF@Z`-d`84yA&GUk+(7dfB)ep&bFSJ0gwiU#rFs#w*INj_kv}lHSsy$i6k%e zk_z3NHus%q308{pr}^#QcG`zwqEDvqgtspmWPUN4Z2Km&-c)c9*NTOhD>yf?D!z+lEy&q{03-2`l{>;uFN2R; zEmJ2jbE%=B5XPtE6;`N$zSH?{!ombR z9tf;j-K1j_gL>;8BJx6NBc<>UE0g3gH~lV|2LyQ?1X=~w(kYdO|h zzmUnnTU5#KK7l-MP62+*?6thIbCPl@QFQ@LFaO-{R5xQ~RDKFS>tryH1ygQ4-8uPE zU1s&&dyvkrTIun~h&B4~+V2dm#95BcCuZ z@NAwG$xE`4yn^2JQoijp6aB$P;6oV)7kKreJ|EtA_$PhJrY_!J`i-P7&y~w)k#2oX zL-JLM;A+CNm&4=zh|GO%#Fw?T54n~Lohd`yV+8!2TYT|zYj@XCT3$||HeXpT#T=u_ zhmIzG!8ELh1O}VRlGy7WjxZ}3XHeUg4u=$z5~8H*st50;IeG(R$`45o<_~4bBKYlx zR0~q9(5BvB&82M|Fg!)=%xi*HnlR_SN>|Q<`30PbUBn3lpRrj>x?a(l1@?^>Hd!<1 z1)@Z+c{mBUWL# zJM&)o*P@4$3&kQ-PZhq;yByrYL~IKcdBs0^xS?(p1X*&y(w|thbf+CDj56c^Y_4_0 zFRjr_oQHL%-BPHf$pH{PO}`EZ6lHXN|L#T3_~mg<$MZO!&EaUu%hQzkKMrnHu*Kec z)Bh0QZ!bDq9;{j76nX}Fa3cG_(kPrnQ&bqYa&2A?_Uv-SH*axZVX*$WaaF;EGoOb zn|X!9&BrJ8jJluWE2dQYPaRAF_PjhcTaP4r@B{T(IJz~dc&yc`OkHvWhcHRfwls2x z)M$;YO^@7qSvL$qE3uvn_`^;!rM%`6@lr}p>x_;q!EW;vPuBJhO5LFW?(cxB^IId^ zrdP0Y*tHo|*1WAAL#g&brZWDwlS`J5F1K^j_GkFF6_*MWVOzKar6x754}Lj9UbsLZ z-|v!Nz-;!d=W`01H(ezhl)9NpI$x_|)W4I&Z@J1-lre8T?XJD`7JGv!XPCC2M64@dQEyuyz zRDMrnWczLGIwKnNzKIsRT7vynemDXuTw_t_3-5`Z5vDzQ7yWyS>5{zu$eb=v59kcr z+SuZgx`Va;9nEVt{d*~u_x`mXS;c(X9c@xUg73|Qlx%%%K9n=Z?3P*y&an0+j_h}^ zbd?phnG|baKRT8#_XetVfRG0``vzHifTo*2CO5m<4#A$J>_~{3+-TJA;N*6S*sh{u6@JZy^)A1`* zuL>hzs&(Rk1d;m8r!i(puD?%Tx*jYrV=`5{#Q@j08x!9|O%D$?*zJs*;6bu#O|!j+ z81?VZ^KK79{TAs4Bfo2`;Mn~%03{)D&qaD70UrC8h&pY=y)LoTmOg#L+GOvKyi}IH zH22c|hDG5}nsi-Pi$&yJuHg+ZNR4p!d zAVo8{iBH~TbtOTBUYnQK7CT?2ONqp@e>s7&yosUfGi_icnJ`v)9@JpS=LylQsDBm) zIRlxkj{j=iUrj0`zILBzwe8=SXynwvPDX%a6+9E>OPZB6x0D!@Zr@s33*5CxXaw2D zY94)G%EI@c)GC=rdQlc!8El+TMU$Nk*Ba)Ww{F6QI$ho@eco4i9P964wY}S&1Q3*G z@87>jUy8}xipTdvJ?f2pnZFKDR%lwY5*en!|T$WfaeKbv1lwm6!x{*8i{P~u726CAYX70v%&3T6Jn&kpVqhn4*%P{o8A~0 z9NodW1I~8tt!Tu9!^3+K(aTnUPi{MpVnC2qPWyh$;->b$KZZq41iS-b$xwYnncgRv z`BM}>=@N!w9V`y86{!E7kp(hnF_GnJ643lnH#W%2)x;X;m-|Y~{o-gbZ4%wufws(X zu?6>IOgGoTqnJf@Q%12JFwpeD+J_2t{KA=U1u0x zU65vH+DY?`y~0=OHts=22diNpQ^!&}$@Al-CMgy*sw19J42_2DB5Gx*UDYIiroZ=E zy!rm^B#RSWi9i5OD%&fNa-`qh>Gw=F>66bst@!!A(i1P_Kh=-U=xFmIeoQ}TN@qQQ8Da%$uV9l8 znykE>{bbg`;jG)A44Jde(Ct2CgTylmvGyUDX6KMA1#Wn0vM5@=s(S5ZVC)nFO4qR} zAN*@);S@zj=lBviLaN%jd)X0%S=1BLbiaW3yRKn{Yw|2BmiZ76D4q4Cu1^Q(>ntFDC*W1jv@B$$q5zW2HC$V zJ);jtF|sa@?gO?!zoM#k$w1O2NhdER_c|u#@i%cTjhOi3rr3sK$Um2W-ZHOC|2*;} z$D@wi$tZOon{mCy>)8PNvN&vBc&#Bir`Lfbv<_ys$#f-K62}ydZtTcZ zpx1@`tc~`&{x51LLG^g>4s9Zk?4A`z8^`j4CNJFWYLHVPX~18@*;~YRt6z-V!>Kkk z2!#Q;KUfE?gPY9X`RiqNv_%R2u8USgz!0~|{}D?1y>^Cooy6@5m zB1d07K`1-613Ky%xPF%BS;4%B0j<+s9Az)tOINRv+ka?kyD^mrD0d(mJD>#(>s}W} zwcF?451KejlXkpFD0zR-Ki|c^lPV>TV52SBu%1CV>mP8|`p_R3D@Pk}xyzY^s$mZM zRElci+;NtQg4wR!spq~^gE}K;Uc8FR)W6v)^G{{Xa!Faq%3ZL9A4mV^VbS$(0#{S1 zdu7$bWM{~o+X9`J8qe{KUVZ+Miz7`2it2+VMr%1MQ*vIYza05DZl7{1Q zy=2EsvSP&eUnD|lrGMp-u7<7iKO4ppOT=6JGWJ3rH#Rj(h?n=82LG%t1T3`&|4i-4 z@Q1-a_ZZ^N@Q?mLW%?H6ZxuEkFRZj0XJ>Xm?@zKd&SF;l>qGEgLSj7CT`!J47o7YN z3Q!sFnIzk1di7tzcFraJr)_2>S=)Spjvoh2O*}n zolgtv!?^wTLVwAL2wlJbPkXn6#{5(p%q1i7qHMinJE{M^^CO1>`_qE7K^1}gn@eeiK9%7!Yg9UdOzoOSXS|1(BY-OFZ z2rJE7{Au~|<@pv0Bm3~&7d>TaR|!L(qCOs<8U0xSB+VhdY@g%5B3IBPRCMeES9uxM zw#KkJYp)APY zyBvwRuP2i!@$IHb?e-Zyuwng68mCytWsymSuu&)ag?F0}u#H?YHUG8nZ>Yrt#@0yo z{qkHXl;1-WrTtRz19o;Ow&YRwMbO&{#<1<@VfV7l`AzhhS1H#}$^&sjX`UA~!&4k% zaRDA+dPdy#zOO})=(R(Z;jM>^lVD{)5TD@3q;F=cUCRf7`czhy!f*OMWMrKi^5^F! zWVwuqrw4&Q@#XN$K28e_3m?Ln%FX^6W}1C@(!IbV7#w{g!m)K4Hk)wKe z$8sV|UntRMCjDF8wAScVTVM`Lq~$vHQP}gBqj{XwlYc8_mvcqH)KJax#hHe^ZqNzw zZcyRAB|yePomJ%}+T`yy6O$Fcg2D&ibLVDK_uiV_&G3cPrN%7OL*q={jG3A+2VCy)bbU{*L1c%z$pGI=X|bX7e26Ql+)n~Wr@Yzyh;>wf_{<-8@&-W`m8aa z?6O}%_ua0p{X?rRUM0L~rPr}r8_dp60MBOGy_nxQHKs#sCQI4)$@R@d0eLHqW zrheU%#4ESCFHtq$`mL!Vtk($=aShlmMxVJRvdXa}J>eHySpMq;9UDpj$ck6D+Vl-I zw8@=38y{msGcX+qhSN7{(siQ8k_fG`mF>T$aVy!m9(L{203#f!BG!$B+oAImP02x+ z3Jkril<}hZDg0boBl~#oW_o5_ol^EE#?kx0CXGPtW_Gh=bja^BU5&rg-Lu;nf<~)d zzjs_dTP(?X{e-lO8G7{Kwq=ZsP8HS{^bvs?_dUUex zWz8fhnvNoPDs#_$-JG6f%sh|;Hb^5RNOeg4Z|UpmOyV~(z4+`h4z$W-j-S7Ot}%Qn z(UD(oUoz^`CldZ^nDEn8@+@g=kGJE#V~t|gF=LPOn_rk+ZKSyIMV7xcn9XX`?k6s&hEqE@% zf1~13W@fc;mCU#E_pvHFC3Dyw9k%Wtf4#MQq9DP@dZ=K}J>Wtdi_N`D^7SB#T3KPH zgKLaNcVbLZY>i zU($9kfq<4?7Sm20n$*IHE~MAA?&UA;xSB~Xy>95~80&>xcr=fOMniL!ymzS{)8dyN zUGU>Z_d>JRiJds&THRte?VTkG?;CeMmrlY%TF(^=t;-BT=kb}QYFuCTwl)RotA z=zK(zCC`1?Q3qV8tB$;BGFL50&HMWNN#>+_P|wc1RrKX{>Nqt(&TN4EWxoe$-7}j5 zr=s;s)qU0i0^|L&L71}cIDczix;0It`=qVuuRA9h-B%pbldcEN&qmXWUuJ^`uIwEL ziceA3*ol<$r*{MfxAfPXGPCmduUmciyC)elVQrnCJtz`eVKZ_XMYvvxQyS!Zv4P^F z7&R|x*W$eN`sD(4V<#}?%bP=N!x09O{_c>u{{yi=PQO5(PIDMc7pY+gydMUBMi@-D zmBf3*5S0B|TKc#0Tt6c_Q&Kdy?4Ml2+-=^<7FcVq9V1L#_eC@WUNHkdBg|jtZ#IM) z$7w%a!;rfRDQHo=m@E6eGz_`(wnJ0|Kf1JsykY*jPzys4@o(T~gdu?!iBHl_P$?Uo9MV3@;?N@kp?cKjv;rU*M?Af{47o#^Vh{&U=xdR8oN&&^VbD) z8G;R~fu9ja+`Sfys7G^Yzm|>>_fKbG{HWii#9&Sf;P82I(jd=dEioCR^%U=Fvc+Wn@z-?6(r zFqH0|+7KL<4g8GiKd$!2$o544xZr>kIdbOz0@|r)OEN0 zhJcL2z|Y90ZXd25JH7vdAOAD4u^x{zF%o)v_|qGXwELCta7C%{W%O{_bw+;(9A5^0 zMm9oEJB|GTa85k?wLUgJqdF4{0=E9_dHrCby}qgb4}LcTKO-BT;fBxx3v49L(*4+@ zclX}ytO{4%e(w(+-TAFD^gjOagRzWWJi1@F-!-4|S-4-Wk?yyTo6~<>b3P+Xv&YwD z;g|o|?q}5gt-S1Q)c%1k!@$o7)1!H#@elD>27X5PGAG|Biw6HklD5x?UuNH@zm<)P z*69;ICVnBcf5UF!ETj`FoAbXKf+K=~pAp8%MeP`ZB)fbj$>g`hbsQ-i{}yM-GQ!W% z9mK&Cgc;dRpD>uoH)rGx=+kMAE1R#$ychpC$v-2kZ0>5<5O}N%{ERT-{>#k!5jwa& zBaXORBP}ozlkVMX6}cdXKV)(zFt-uL+-Ls(A(LB}{dgH;?ym>zbb@g@UBZx0 z-=)7H$2iT?C5(9Y71^~uhM=FSFw0#ASi!-O5AfMw#9hQn!O`j8`f)8IjCl4&e;cNM z?Ax*_7;m>kbL=y)&j!QYy^S5NuwUw*m3;|Hig)i1HWNK)KmJ=`7o1^0_Otp z)uYLEsc$AN*jOlpn#@?siye`+^lJZN_w0M~YQ;@#UTj+Q$z#p7VHp=9t%olE9kTw# z66ThXTHk-YT!;eF?zqZ~_*RHCZCgrB1?)WuashYSk0Q1a`7Z6-3Sz<*!bct0&Z`Ea zzrE4Z!u9{3%~OI+k^lj0=t4`_JBi7Ny{R~qhk%NL-Ajmy_&0phyo%X@2M($ilmaql z91S2+_o(qff!sDyF+EEGkPiMKT5rDU%~G$62HAjAThzo7H7=7_=(!3#SD|_XQcKQS zOV(k?_b^N?gg19Xv7#DH5>75q4fiw)*wS{NT{^kd?fbh`xiu3b?9Psn9n|1b4MsS= z9iv7kfi{`iiG8y3^U6)~Mm-qe%h|%HOgephxj(BJyJ_2! z`lwNf4{ZLmISRCuu!z`GJIal>dPSSdmioxx}Vrt=R%0ry}_pL$T?~rP~Moiim&IA zdj5*M*Z7Ey4YXD?hFTRFj|4}}L%Efc#sC*V_iPEvbJ#rAswenPdlERkzMfWquA*bGF3hmjc3;Gj>zzO zic!g0cX&9qmO@4F8jPVe(V5`d8*qJUd$D$Nv}HxYpk#Xv>81IoV?BSJmQi|>^ay3( z`U}WxmrYhghQ!*Is>@w?R_*o7Ct{`fTQLY>G&io~$+&r;v3-q%8zQ2Bcs0K%7jG zdA$#PimT5}Y!V!t?+hWYb{qM&5J388HNP0p^}BiCixi{r1S7kvdS5lFZ!j{y*?ZMg zq&Xbae8??$&Vx;dYeQ^$w6RMlQ<;j5J-*x79#xt*rzB!~PBCyLhhml`9+CPg^4HS) zD3UKkN?F{m6f-Ei5<+2Y7ZmI2NvrBfd(cySlei{&FGNcHHS}IcDLNu*^J+cg8l!QI zQNC>c2IGyh&*D!LmFm8!o#~3}?l#Rl*Ic4L|Cn7% zXjb8RRI3_{%q5*JqZ(^6H+dRr)Qa@#fv5fI)f3DhUVV)fWA{(53LNCxtJt93w=dbh zeUMAMd;N@n#2#cD@-U!4;@}agii9Ty68fF3UbPul`_@!#7j&7`%c@>aSG5Orn@|*y zQh($4Rz;*Oi(ilRSVKvXM@Re7stx*KrQ;3kE~(Elwfc5HOZ$Ob&DFb~?H44E{0ue1 z3%+NQPQo|-?Cch#P^NS*B5?0_7v+Kr4eGakKe3gqAVy3mbY=`Mxy)j1c70NkT9p=! z=Hl6nMl%>axKI$ACzwEseyYu!((!@2j;rG%_NgPrM*GyIt{2xdS6y%H*UKPb>6bUc z&3Fbm;0e=vptMA5fea%dFkdyrAdqgFIc= z2LBK(HU8xrNjD}P01cmxlLA?X_6EYQXF+1s?qSO}lrAU&3DK5_f_C(J1vhQo2Z>2~8{195` zrd{2-k}WaJ^D75L`emW2aGix>PYuP41LsjB3@DH=Fn@o>whV~RVKHyoltsxVMQT>$ zy@1#h8p`Ry+6_tNfSwDIr?vMc)xYBxBn`g#Hp-XLZF3FEZS(vxl83VglVTRv6p?lh zUA_9)k{DSC3KMcq1kOZW4ds{i7a1#oi)#CW20RmON3~7vQ9Xy)oJ(ZWz%O!!?K$#F ze8?#(w0F-vuzg`qM!D0rV+6;Fig1Z1M(4DIO;7LyjZTyc6AUOMw%S{d=Qh|N4`hzh z_Cnxn^!iL~q?QtFA4vt9b9_joDWV)*`xZ{T02gdmIYuOg-2plrD#sP}g2IJ@MBBxH zetGqPxdg8b+zSR$weW-_iS`Hr&AmU|yYGSrOTPOvl}haE@8?p5ab8vy+;W)*|4;l0kPq7mefI zm($F}tqzd8kz{gTV{tUxm<>n^QT$>%^*Fa(Hgo}b6~Xp>Lov6#-d0%xr_6chT~0UphzZ^y{H$0kc`#7bU~l<1{iR2+K{HBM5zz4c-5-OV_&gGrRTy}Z3dek==l=RQ68OEtbCmw;f&HoY#{ zsJ(Gxn{F&VN#eHS-s`(Y%)Re-Wgynq1^RHrJX0wCope~+^UD6a)syth1b1K^)49)^ zgy3IaLYd#Tc3HWHq|g&3B6lPoQ@K539C9)#KeF#{F<_2UvXe}MS>!wHf^TyA=!LfO zq+K*q7i|ZlVCDPHdrp6>NiIJR5nZGY*$H~j*E6^JGcK07@Lz-=>+<1%m4a&L3(;4< zd|nbH99H)I$KJ%MnvZ-e9Eo}oK~^fW3xj{KmQzAz$2M~8J)<$G3n*E!FSGfC?z`JS zaY9jy9jL)%aaUJIk4VeWzK~$1cDq&Q!55eEe>=pMR&K5iWI|J%aEI?Q{oCE2zxeho zf|M^*j-%??{UA_5`j&Ichw*Zpw3NxA^v%96q?KoXM-DZqOxnle#F23Qda#!x75|Qx z<}-Q)3gk8~&V!HkjaFXU3bcF_7T6&Wd_!(+YM?Hp1jvpDb!lai}#)3SfACTSAhXhIZ4WQOe0rTw*quX+>jsQ z+>h~NQX$Ed{rnUg-xUyd>b=0Y?1j_7DTauhveV{JQVb=?x+g|H-CL-n{xb5|84Q$7kvLt=2w~93%?)&CJFG47h?ZUlP~2kDRJ30wHSxYZH)$LKo|4c z=K$qi@;v7xVK+&*x96EwZqN3@(?a^e?Qx}*Pbvm6H{0HRU|RV+H_)?_ntg{vbHqI3 zHN>?jto25ip>mwRLP1J4T|;9<+K z5ryoH!zTSB2O`A<-3Yym-E3JeBx1{HKO7SVZ(*L(6MH*PS|`i&`COnWHoTi9Rkv*M5ZmC}Y(&LXU=E49ng* zcNszQ9X^IV9_?A&o4y-YryybcISn&{fMeNj2)1sZC zI|-`v^$^HdZiu}*2NjS}zYZfQ3B6Ih?l?Uo;4K$a82(U`qc6dLnm1`Rkybw(Y0aeL z$zygu4-%Z}*-;*5#MB)TU>_1@F9d9nj-KS`yl%1WT(&O^@sp{C0LK^zjepQ%Q2FS? zVWd~#v+o;9TYwqN7BF%Ze%MOON2_)B!_FG^d8mhB2lV822y+-Iy_3V3(7#4}U;pH} zmfVO{raGNNB@z~GbM@?3-`8|F6h6k1gcsA?%W7mIsxE=Pq~+7>_4u*B?4$sZZLyyN zR$*eXsm}CsXJZ~l3elu3KxN;WfF&*%2P5eMJ=1kBq9w17m0-L*Iv+52T}+X9?7Yj) z#k`&+)JU~$6>$)RWzB0+N1()^hq~9jgqAOLF+huvxDLmjgBzskmerBhBzfEX{m z>@*E|a<{BvtH2@IYiOy9rZQp-a5@L+vI6AH4YJ4NdpTzrwVi@>)xIRJXR;db^%>ucNkz zGDId|W;2omn*254?|#TgBc+xAjg#)@zb5Xry# zp$)KG1>}>S)fJ95^UO52mR71vc+8yKcEmr}qQc^*r0vxdEUeFkt=Nu3Q)DYH>N_i} zo%hYv+Wd0*VE6Aacr|RXY@SkTQ3dt3*Hil}{lFGEaVw6W2~i&Htg&W>L2+xWeJ$S++)xO8_8jde2h7LZLg{IBf^Uq z53v0ZB7vWJLica?1v*=8X#u9q(+elF!zQ`X4@4R>-UIc%7gcM5+4uotAk-lYve$|h z&N^Et+}*odW*^?wcno6JNON(^Y+cMBy`MN*YJn@p<9hGeajGG&u)BS%@yWbt@%er# z7Zq+Dk0H0CIf#U8i&DJrCDp##jQEosZn0>Qf|;9ZK|X{*)QR>)&ZZ0KBPHc8hCe30yu}?HSkRASxp4_J z<>|f;o(=o&-reRk(P`?jMj@W=DZ5%(_kF$Z6&0dA`N9}%ei)GKR>Yjn-R);PZapcf zowoF;ky{6BQqJ^Xi_4F{&%LIa8-}~Ii1Ewlc>NkPp1Rx5R@|)e?mBJpW{50$Y>6)) zY*AQo)c2a&J{P%Q%suR$7Z8~l{j9Tg8O%XBYbsT$t*w_myxZC@M@e-h)Pz&oVUd35u!831Dc2xK2!N%P~h)OBL zVT)~$zu0lYQNQf@04+%pN8?DoC}Zc}Gj>n`m5lvqE9;uq%416`_dsOh;-j`B}c3|F%-eR`;a;W;^Mam6yY zbL=IxFQ(N9k&(ZjixQ;57btX}9pqY2+=^<>C=8v$Y^z{*Q^T#YHcp(2hq2oI6YH3yM4Z^gnqdr7qqF7J&4#%#ZH;n_jP`Q&}( zv9J%&gFk0MwL_{MR2*cH5tNm8Ypfm7=;eC$g8GN?kQyKcR`e%3c2$suJ!g&0jA!Xj zaSvY+BN8wZWVH|FzQCmHGJ?-xbG7*f#WR47Wl3wj`K3NM5Mpv8zwo@pVzNTl3pLJuul)WT8KMJso+mTLg&F z9eqb48Nn?WAfB_tnrktCSFE28y@E>LV~}F78~MjG&z42y^X$dcZb7(>3s~WS=NXPy z7hH6YcgyxQJDubQqGEEu>^o#_9Bi@jl7Qve%PAtZ(uFaSs6UUR?*-r0bCy^;wsWF5 z$Lx|3aggoxEtKV8U#bdg4&8A`xSVhRz zLCCbh;J5zl)zliGrzv37A>`-;FUgzSZ+>>!^{oQM+ zHPJ7KVL$ya{@V9faBia4~(or+~kk*R8K(E*+cxo}8z-A{`^fv(8%`J2W<)uk#bwXU!JV*EwJN z`rSATfV8#NQN&w&xMc>s%^D-`a0?EjeI=%76#T zsEo0h{oQNnLrF8mxZoWA-lw1+x-N6>WI_JY)NNpoQr(4A6 z!8mmD#=vbqk;g3~_R&bdPEQIxBpz#wZ#)qByeoHV?_Nfc>{Bj`(G@#R3OwJ|!0S5l z4T)PtAsaLUW?KvUy1s8<4XNA|rjUZ~GQrjD)a%x==UG|p&Gb*i z?0YkfGt*%e0dU!2d9jB5BiJ^?K;Vc`8mgb*sF(L{eY%~io%zgTKHbihA-Ep0h**n< zJs63>sCw1sUPa%fArK)3)b`mN!#zDt-F04J+dBnOmTf#cfnRuN~deTiZ zomf-lA=p7k>ou?6bgL^^&+u`XdnL6OQ!l8jrR0QA_J52*`$oieQ0Cv9-Ul$~p_qQT zrGnYPNQY1F^W4j*T`bds7O%WxWj$uwMdZi1#r6I2 zlSbMLsVUdtav);ZE{>B*WAVdjAc67hji}Seq{g&W6U~9-F{Hnme=NE6)jp}%2#vHC z)0elriZOS09DM>L`!iT|`?4B*^1KlH7TpQ2r^ie?&TfMbMx_WGi$~h4>HDseN5m*S zH;y!q1+xx@8tvm}hYykALupIin~%n06*8IKVU(kI`K*UmV6L>Fh*4B;?9k>sN&P>P zTVWsOQH|u5(+9r10HwBGk6U49S~*uE?d5c?jCX;OH={NNwn^!%u(*rE!=B~T&hY68 zkj2Y4JcL_eXI>Y9BkkpMl7?5HvgS^A0vzU7vYX@Me|>OBa+j0&g`qxj%RUgyIu1V?i2frcBsk=%lcMW6(%&9r{WZk2_f7A@=rb$;9a zh_&^Df1H>|!DM{hx0sh}Os4&QJ})kpJZ7m6=7K-ik|J57ve(r4IT|9y#O>h-bvutg z$=!3=9WquLzpOrRw|eYJYp%GJ78jNLvFv3P4vpu+p5!13qZr?u-5u|_!rR5+G!;KV zU5{BV2nHp)mDaw@=t$m+sFjg0~ejc2}2@&wTyt7P$w4J>=xSj$-UQp;i?Mk{BC)C3Rpv?%Yi6EL!s-D_p%D6qjqB+qFfCf?Cz#3 zGc|j7c}s>^c*t@?Dmr&oT1Xq?eU02UcL_-=1!8K+$jxcu6r@_Xy{v_;**V3FYEA@g zc?g^U=x}#E$tz2KRk&9(Uxk&f1hUh2@|N`XJiJW5t|w2nK#!PZl@x$j@%IuDpbZ z6*ve-ew>7mrEuULXU|wt2@Eeiniy2*G04DT%D%2EZP5-G+KwnudM}LWT^~lJBJ)NX zk;Q&Ljq!6NxA+d^ya4u?9TRL6@^oG4E4FPM`uNnBq(qP8pw?0JFh zR$l}adZ;|iO+DCB07D4fIOMu%2~tLgGQZAP5X^jJi&CXKRs==kA0Jd0m27pdsJVgSFe2sg7zMy= zk2`#N7Zxy`KH6D1IH)bt7-nu zClRB3`>4gq#o+m8 z&Pkp_qOvRUO-P^H)?Ht}{AX9hhTm1nj9&)y=a^XSp9UG($(KUrRt;motZn~9X{}v8 zA20TArG&de&sunW-fMTYe7WYX2tNJKzZgHyK+znN*!?rT>!as05txOLV}86Z)YdoK z2c^>wm1F9?e@pM$a`=z#2t&TI`dy)!){e=C#K)EvVSpd-@$nY;vn9`!S=b1C2h-ZK z`uq^)hU7?f;5+#3%zefWvqf@bQSgPv`i%Oo{s_N|MbHpt-@A@HKI4knR$15|TrnJM zp70y|GRShImhe;QJBIr7nK%@SwZi|VzEiYMh>An82r*otTEmNB_66NkIdX0ImfG@H z_#>eon@!^pX2s`(@p0+g^=9D+@w1{XkCBg3W`uH%1SI}leU337jL$&)9Jx*WPd=?r zr1$vJ+nXb8if<{Wwe9g9H{bZ-WbuR1mdDg*P%s!ZN5Ypd13x#gPk>;iLl!m}|6Dyh z1!G1T8=50kjh`3Ka=H6JTL#(Y$b#eF)puhMVwOkv5|CiWcdxAr51+yir^Vv#2}AMG zRr-qp-{V6J+6EX z$9wpfu&La9p)WhghavchwOQhPp}b<^e1s{ZOLHWk^S`Gjyh?`b_&2w??R-n`3P|*E z;EVy!kv7k_)WffbQA+-GZ$>^pBi4Rvp-&0*t=suj% z&yh_B8NR&Xxp@ugtJzGGe$Y#J{|xx`uWplA`j=b6%FQct|DoIbnEp-W@QqC?UnCr) zNWJM>`iMP!7>ED(Y*tVIOmFxwGXsS#)*J~#!w2+B-^ni3Gwwh>Hd5c#4BzvW2ogSP zi|W)*q#U}#%lr7PUM#BqQ~j*$FCQ`CHwv4e)pu`%ts%2U;|6JQzxp>7-wRJtao@LS zWqnIe*aD=L))#gyWUTcAF;?cIzsB~v$4!RoyH~?*h&gnAXg1HTFVw?!mkFA_?M>n9 z3zaZdyxH}e@68VEr|bx`hM!Zv$=bxje)f%(wCtV2@hrMHjl-0!;poYXdZx)|Ax!pz z{)F=kZz}xpbh9!0*;m8Kog@$R0q02c?2nZ_^oD+Te^B2X(&4FQIPdc!z@O9)LA7tI zh4Ua;Tu9B5Bm1>~SKrN;ziITR(@m`HTgu_V=}DKvGEKr$rEv5l;|*DCvJis%wm#C3 z?C!3k<6yCk`*#&j;iQovHB62~=DwwP2q$}nADqpR9-b__$NP1uF4`jR(jU=r#jqJaFXm!h^6tzLJYa8g;qbkAccw|v7V)Dq=*8~g~=ZTb#G(tJ<6iYqmwul@ zLy=h(X$stJ#UI?iA_nO~)P_oo9-vyIB1w_3Zt0(~O6p36Za{ld5NVbSjJ{RNk&J(9 zwUEmcl8rx56SEZ#3B^lzJ~u%C>kxH z?})^vsTUrB%Oc;Cr3v!LVtjW_o`~A%5r{omLhTW0S|&a*#pJaTHHn?2;=Ps$D^)R< zjDMO(0P}Y$5H0E}7Ni06C#teyg4?<1E^)3^Z8mAMNh~_<3nP#fh(!=3TQB5QWEMqY zJ(lfT1;}b~4N@$UwGN|qRUi)1UyaWrKu-b;1+F^c^I8$DRG!})yTQWp$wE)nq5z9P zv_Q^a7@%>$m0!w5vfCf*p)v(hD4w5OcZd0`T{+u~Ku{szvN7@5FlE#s+Cl+sQus51SpRHv5r3=*3lmUMzpYms1?uO zjxRNbB9=$?2yit!A9IE0yT|DQ#3Ds4idwX+ zJ=JC{imwU~El5HTfmrF2ZXnk2AYn5CZxKN1=yyM29W6^8Mrx=d*0Q{YXi<|?T9Z`z z_fj5x*|E}$EU5^@F*S?0{Ar~IBmv~%v{~b)sRC53LuTQ>A$ulc+7cj|Sn`W_?hK1S zRfAYXl@dl~7hZL_{+1ew)*vN@mPk?{X^jTOzef?^Q9$}2&poPCS+&ZlRZg{-|8my% zk**hXzcPKxu~v&b6(Gsq&sCxdARV(?pD@>k0{V9oV5-3@0HiMz7z)I2CWtbgkE*dJ zgaVdhB!6osT677;3jTh`G7Qn&fLNf2g#l`ze|If0)u1V$e_x%5(bIM#93r(rY8wzs zh>daCAfgILfpA~AFYj5xKES&YLbV}P5fCVKgwQ|G$K{yKQ3U}HV~G8$??=vhg1=rx zHs#vM2etD@jKF*Zf$U6(orI=Gh}O2;eL+&vus29Dhqws~$;t78bjZbDX=%yBocEfWF9`v$6_J*4ENwjqp_X6|53#`@ca1^t;Fp$=;uwT1;01x1+?4CW$7li{UO5dnJ0*=vrdPDFm2PYz@rCA*}Z$pK&mHB$33H z=$LQ;hR!UZ-ZOk{mfm-K1K?u|QHJLeyqKMonxDX+d$j^GLQ+#ji5D zzc*EZmzeQknHe@U%lA`5Bh88K)9Es8;xDK4rooYxwpHSHpaBi9Tcab}(#r9#djbuK zG);o}umhBxK!2{t#z&u|Gb%6)K-M6|(IlW0HY2t+tHhx~L$-zCHb$%%Fjrp9wL=Pj z$U1~g36JjQUw8d}S+DYBf;p^2K7ei~v=!D1ToPsue9X25tPBos2u zahgI%P9hqoZ1ccHBJ&N&^f6bsOZ*>gB-Fo13|fU4X57@-%|h5P+J3dk?kHyoKpe=V z4j=2xbnx)edn5t7ZxX8W8GL|-^{s0{bx%?ZHa*4GUJ0ZuxbPOEDsi2*%`fp62QAYO zHwYn>65s9s8d8;#T*BG+EZ$lfQslP4pcs8(P?aNgCh?>|O&o3Z6MPiW1`U!17Y(UE zEnikm{89#qUv7{zSE2WUTD*+|Bu9?%i1QtK@3EMjBp*e}yr33?epu60RU5a}kh-$? zSind&6)7=71-q+$L-9J%pr)gzJ~1Fukt(Aw($(JJVK|I%4W5`p;ke+NvExd-dP72x zA|(zc4mr`K&vQ>vsEv9<66uk&dO+ecZb@4N)GnwE*{&9OWGfTr0Wxb8x%xEk4orPy zKoZ4kuIf>4sK%sFa_?H`+_&g52{@!N4p5*TBV>5Rl!jsJ8P2U`A9Whga6+O;(=oDa z=O*FymWzWu>@k`^!&kOKVaFNe7idVFWwncFa#9W zb3;>r&d-Bc4c67@lq}HSN<}0~(&Lft6B*N-?@6k_sCwH%q(kGT1+ zYMj2Ue60M(XaWs=N{bDBH)r<>RXUzQTIr3*g%pg+V!Yo^SIArxo-Qv|?OoHuZDW{p zB+~O8FF?Z(3@}7`qY5-kx&oFy-*Gy%!t||+Hve>d0u3D>*zY-`N=~!TTwe<5yE#yd z#uF|i!^0d;gsVfudJ$z>DCOrXIiFNN~6U`(Ll>A2@|PiJSI=vRXv z%m}LrcsXP{-xfdLX^vOL6F|bQNgmI5k}T`b4iz zFe>;+_@^Tps16={T>SJU|3&z=^rcRJzAdDd4qpT+3;S6xfQF?fFR9@@PBt&1R{`=k zJ*+CWGmm={2>kW1s@Tqa#6B5kKp$Z~QEo5zbrM+5T*o`n;Ok0D_Ug=n2WY5iE{&IC zG=PSVm&M$=pRQA$GH_k=Ma+J_E#z_v%VEL#?+3F34c}l=!TTYoK!dlfE!l$I+(SZ+ zknuk8Bl16~4m5o49*nPR&i41p`txZ>o~J8717Stwk;T=NfrdkKT|}PeclQDfP7+c` zyXKI8DL;gPdFYHF5+x4D4E0yn9Hg0KW=<@nZe}*RMT1|Ki-!NTOrT*t^`%yRj9#F@ znKp6Y^hOnEn7$uF>zSDiXdoluy5?T+Lsi0HRB7*WS9{G^`6Zn~Q@qbe(1TRQdo-A$(O2bT+(w%sf+ zr~VXLgo5pYpP3VAm`~i)I3trhi8m;L4qu>Q(xpWVdiqp>hK_d}Kzwr)xCuY0 zPf_j6%ok{&eabk4`Sqy*4acOu)N;=BZ9v19lV5cIZ7D#*x1}%D*JD(HhQVx0@^n9) z5rlLhgsNbp^?Ma&yN69y292#>=?c&=1fP2H?vv%)4Vjs9=@p(iK7fWHC^)EjqX%gC z-L<8ba`q|@&@g=;d;eYV;iXfUeyZMf#lZJdRg=3OcRXB~flh7r#= zWc$^ZUh>fKcj>dAUkmlrLKF(scKpm7K*OrSbb93{O&A7AbdF=YT1XqN?ID4XBS<7h9O8xf^OGj3?MR?H7|vabGRXS zK`@X|;1|{kGBhD4OS&L#mgB zA15E!8+D*zFx%3cKFc9}rQy;nFNNsyDSLp1ng+V*7yAcjcsgpf`KN0@!*WQ~OyBVg zG+ZprCEI+?<^^czcwc&sr%w%NSfUf80R5?~0}XS$;gsTQ%0Pp!r^7|U01yy2z2I>DUc$eIU%)bZ@isYkQ8ih+;=ZX>N3SP2~@XxvLBG- zn7mhu=F-uEPrV9)Wa}y@UA1m%L4%|q4nikvxh}r4Zi3=J(p?pC-GDBb_n_+O&-P7` zcz!`e7MQ74fW)fE1=fP3U>R4z`oz#OLR!$EyI-T;P|R|+K8Y0|vBD+nb3s3>Vpl=t zFZs;~FncaY>MGY`8>DraOtNH4zY=Chm%3O1604HqP2GZ|V98g(+M;;JQjL+i>fMRj zesy(}tPeCI=>_6Fe?U@jT>a|f>X&su>q4qYzMy$%pI=T#RJi!Q4^gd<=^KTqC~+6sx) zVgOdC-d07nJ|l*GFR0H8x?3EQk~ea^+*l7ZWI;|>!J4juHC+YEU9j8*%g=&368(+7 zvIWVn1H_|oa4b_r(moBUx0MvEIa2K|sNPn0i{tL<4@mmeYrd>%jyEQReiZDQOnKK; z?z+ldSGnr~_o<}8UJxX`h5G{p?5}S?+3-z7a^D9g6_J8@G*=LFAi6~hWu*# zRS+T@H>3sYU9jE-YrJz@kUX~WtrXc$q^L!+AhE*h=ochbEk(Vk1?8krpO=+Z-+p#t zw4_}XsL%2flHcPj+OH1&8rku+pODm5+ErI+`iyoz+2#9)3}4v;s2scy*H>!^14BC@a!q3{xO=bzx{%Gx**x; zn)gj@{uAZ)fJzWLw-dkPc?y5p>{|V(+A$g#F_scq()|Wrqx@%OI(% z=a`zv(4MX?#B^Cfy)0jlY~~G$1);6^whMaF1qpAMW>K>GQLA?K2h^33Dr<|q-gVV> z6|C(lxCBE5(t-xv1$Dgau1@N*yLIK`m_M!5WpNjL?t;%%&?2?_GcRb|P%jr$>jmBY z8dWwT^%o?a05on$p3&SzQkOZXq%LH{-jF;{N>RIGLBfJ)2@PUpkXTt*q*$p42@8%$ z-EA!nAyJ%3tpNS7O7eZISHWJdg1!DKD827@R{=>~2BoWD7kVSxrO8JcWE$dW?h09q zd)NI$xvcC{E>;Ff^=-zu>jh=ux=FWH`eoIH1}eW-L4%}VmiR4dZge@rn3rE53qVm8 zsTzZh79{?Aq}s?_%~}vpdoSqj#E?!rEvDM9-b=sk>aA+63k(ePf~2nWTq9v_W%2PD zl;j{)VwUuR)X`Y9Af#@~xFE60Jw|jdNPOD{NnMC4xmq0ZF&w|4RP?dcsaoxu8@Pl4k^8fz-89$`z8j(!A<=Mfzw#a#+NB92X>3aIohKl7a?F zL3lA%Cb#;_SA83fn!X%)6KvJ+>{p#)NSI_CHE2pcjrL!xL*0plZ6_Rt> z=$Dm2Vm0r&=2h1yDT+5QNccfZ(z*cMEe>(twx5u+2x!R4G_QgdryvE(yb9)g70mf6 znDeiKU7`kBjqz*L`TPaR9>5qDp67zHI9!Ta0g}3mj;CEvpK`2uFDu)*-&Wc$)0&oo zw*QiX*rnAAiX&kWWIYXqn(*7N^mBp43ba#cD5O?BMJg&nwI_wNuDf5TzNf2SKcIF! z_7AAa-LIw1$)VpM-7}3}1@(d6t6zX*BrKv$_$UpM2Qsg9yx%sc#@~+T>Ezt{WRjZYyv52oWWwq)l|FV+a1CsG7 z>2C2yzmnDkNSyVSArbu(mb=-6>D=5!HzWm_6H*lFHzWlu0lURRnL#z*R?6#Mw0cC_Q3(~qQ!6DWKE8Xb!7%!ZWwbf&InL%QOtgN_kGe`;= zqy@$gn5TfyfJ;0 zkXTtdeT!c!&^L*MnOO;GO@1P!6CtS!Rx>Lk)uZ6u`x+fC2p_&7>4ZVj32RLXT5CTb zsSAPgBG>^w9ho^TCJ$t!R#jOPEC(yDU$Bzzqjgo*FN1zmFGFa*+DAkKl3F3&`iGTx zbS*hRk4RVbu(}J%Ga}bQx@wR-BNAw@f<0clBFib>ZyVH9cCf0IL1JYYay3_lntU?H z)Vg3Lbs<4EDWnC>>h46DS62nHs((Skdi0d5E`x3>dF=XJy|->^iw4EIkZ2;TSjf1Q zec^-H`5>cJA^|6%DnDd{q@d;dOF^i1JQoxTf@>sAg`^;$yTzKW-j^=&rBkg8`e9Yx zqJyLTvYatF1^hu$7a*ytUe9Qx15K2HOy*GtrRHS?YN6II=to`e)nXN4LL~G}g??B` zi4=eX)XcP$7=sxOkT zOsL6}vy>|7gh6*FT6ETf$|OS8%^#3-0#@l79EG5$-W1Zh%<3*E<7L^DRk+72*Gl$G zman5$uUZx4(GG>g$~az1&kEINTu{HDA1yZFxU+uUkhEy6{eY^->GpBe)$fA+XF+|S z_v)8HIuf>Ne%>3Bu}{cqQ%JObEtkICP_zPNQoLd_sKyIuK( zT56dVv}`jeXjxQuK^>fWccR{%sCOp-iB*s3iiFxDBhl2#Ah815T8x7+sMdZ#q4Oa+FfSBrkd8WLR!$EEXU@gR)Fs6tNcV;RtQ<( zH`H>wAnEE=T?JGd-}1&C3c=l>v=F>#3&GtfP$alh+}(>dkW$vZPk@NCPb0Ve%q=_ ze=I$X-6J7wvSazRH~?!%shdQP{6|}!{|u&YiW*d8FWVa6I3$$Gr87vJ8leE2*IR0H z>^XbQgX5@~xs~BjD+6!KstqBh&haw(axqmo?nO9G_Ajx zPE(dbcbk+eQ>`{AzG8!x8u3w#7n5fjj7P(UnH0X2_Nf@ut`x_s0AEui^bPfA3;3v;et!yD?7Cl|l=!&j=k!#RIk}I%`h#@bR(O)>ez)K_^qe+)E6S^(6C=Ihv&2+d*~|u3iI{qK{x$&l zJMWjy+DvrRtcF6PQSWTmQ0<()&a=Eq!cX>WY#;|s>j!(3WHpK4_E~?BCcL2iR;M=PJ}irS z(A(^_pTa5ApOIk-Yttn}ZN!=Mm+f}&O=Z<~)n^~V

q_V!^G2pb`8%%8O#)sms+W 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 literal 0 HcmV?d00001 diff --git a/research/r429-full-target-interface/frozen/reviews/caller/INDEPENDENT-RESULT.json b/research/r429-full-target-interface/frozen/reviews/caller/INDEPENDENT-RESULT.json new file mode 100644 index 0000000000..edf257fda8 --- /dev/null +++ b/research/r429-full-target-interface/frozen/reviews/caller/INDEPENDENT-RESULT.json @@ -0,0 +1,155 @@ +{ + "aggregate_capacity_is_not_owner_allocation": true, + "aggregate_slots": 4662, + "defect_witnesses": { + "missing_seed_B": { + "difference_row_mask": 6, + "input_binary_coordinate": 1, + "output_binary_coordinate": 0 + }, + "missing_terminal_CNOT": { + "difference_row_mask": 2, + "input_binary_coordinate": 1, + "output_binary_coordinate": 4 + } + }, + "direct_deficit": 0, + "direct_mass_polynomial_in_L": { + "1": 111, + "2": 777 + }, + "eight_bank_ideal_complete_mass": 56799, + "eight_bank_parent_mass": 56832, + "events": 16, + "expanded_events": 46, + "false_deficit_if_target_lifts_omitted": "111*L", + "formal_endpoint": "Gamma9*N*I8", + "formal_literal_inverse": true, + "fresh_method": "Laurent monomials in9 independent commuting invertible Gs, N exponent modulo2", + "helper_occurrences": 3888, + "limits": [ + "Native interfaces at changed cuts remain premises.", + "No chronological owner allocation or rounded/physical compiler.", + "No positive supplier or new kappa.", + "Sensitivity controls do not prove a changed model passes." + ], + "matrix_prefixes_matched": 16, + "new_full_mass": 5097, + "new_zero_private_ideal_deficit": 33, + "old_private3_ideal_deficit": 15, + "old_seed_mass": 5121, + "old_seed_profile": { + "1": 1322, + "2": 1342, + "3": 79, + "4": 44, + "5": 102, + "6": 11, + "7": 18 + }, + "pressure_excess_over33": "987837/609725", + "pressure_lower": "21108762/609725", + "public_fresh_idle_windows": [ + { + "active_stages": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "bank": 0, + "fresh_idle_query_ranks": [] + }, + { + "active_stages": [ + 0, + 1, + 2 + ], + "bank": 1, + "fresh_idle_query_ranks": [ + 42 + ] + }, + { + "active_stages": [ + 3 + ], + "bank": 2, + "fresh_idle_query_ranks": [ + 21, + 35 + ] + }, + { + "active_stages": [ + 4 + ], + "bank": 3, + "fresh_idle_query_ranks": [ + 28, + 28 + ] + }, + { + "active_stages": [ + 5 + ], + "bank": 4, + "fresh_idle_query_ranks": [ + 35, + 21 + ] + }, + { + "active_stages": [ + 6 + ], + "bank": 5, + "fresh_idle_query_ranks": [ + 42, + 14 + ] + }, + { + "active_stages": [ + 7 + ], + "bank": 6, + "fresh_idle_query_ranks": [ + 49, + 7 + ] + }, + { + "active_stages": [ + 8 + ], + "bank": 7, + "fresh_idle_query_ranks": [ + 56 + ] + } + ], + "ring_method": "Faithful regular representation N=2x2 swap;16x16 binary matrices", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "sensitivity_witnesses": { + "D35_lower": "21108762/609725", + "max_rank8_lower": "1441846/46875", + "two_seeds_lower": "14072508/609725" + }, + "source_sha256": { + "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/budgets/SEEDED-STAR-PRESSURE.json": "79c809a3c043695979a3aea75915f4cfd209e44f8b45d003113af0d2711c7595", + "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint/BIT-FULL-COMPENSATION.json": "1ee06005d3b82ff592640d9aa4be2021b6de0a0b27fba5723aa06c36a6adbd20", + "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/shared-helper-algebra/BIT-SEEDED-STAR.json": "e0fc9ea3dd2e74222b5ec0954a85b02960fac402453d69b9147847452d2ad86b", + "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/verify_rehost.py": "4774841de10a8386204519174c5e56eb14f5852b20058db38a65a1034eeba275", + "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022" + }, + "status": "PASS_INDEPENDENT_B05_CALLER_ALGEBRA_AND_CONDITIONAL_PRESSURE", + "width8_slots_per_port": 42 +} diff --git a/research/r429-full-target-interface/frozen/reviews/caller/independent_check.py b/research/r429-full-target-interface/frozen/reviews/caller/independent_check.py new file mode 100644 index 0000000000..f0e631dde0 --- /dev/null +++ b/research/r429-full-target-interface/frozen/reviews/caller/independent_check.py @@ -0,0 +1,268 @@ +#!/usr/bin/env python3 +"""Independent matrix, fresh-factor and cost audit of the fixed BIT callers. + +No historical producer imports. Apache-2.0; substantial OpenAI Codex assistance. +""" +import ast +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +BASE = Path('/Users/ross/git/math') +RUN = BASE / '.research-automation/runs/kappa-major-20261018T1330Z' +STAR = RUN / 'shared-helper-algebra/BIT-SEEDED-STAR.json' +FULL = RUN / 'bit-endpoint/BIT-FULL-COMPENSATION.json' +PRESSURE = BASE / '.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/budgets/SEEDED-STAR-PRESSURE.json' +SOURCE = BASE / 'integer-mult-bounds/research/bit-r438-transport-rehost/verify_rehost.py' +WORD = SOURCE.parent / 'words/r438-t154.json.gz' + + +def need(condition, reason): + if not condition: + raise ValueError(reason) + + +def identity(n=16): + return [1 << i for i in range(n)] + + +def mm(a, b): + result = [] + for row in a: + value = 0 + for j, brow in enumerate(b): + if row >> j & 1: + value ^= brow + result.append(value) + return result + + +def event_matrix(kind, i, j): + # Faithful regular representation: 1 -> I2, N -> [[0,1],[1,0]]. + a = identity() + if kind in ('old_F', 'old_B', 'CNOT'): + src, dst = (j, i) if kind == 'old_B' else (i, j) + shift = 0 if kind == 'CNOT' else 1 + for bit in range(2): + a[2 * dst + bit] ^= 1 << (2 * src + (bit ^ shift)) + elif kind == 'exchange': + for bit in range(2): + a[2 * i + bit], a[2 * j + bit] = a[2 * j + bit], a[2 * i + bit] + elif kind in ('new_F', 'new_F_inverse'): + for bit in range(2): + source_bit = bit ^ (kind == 'new_F_inverse') + a[2 * j + bit] = (1 << (2 * j + (bit ^ 1))) ^ (1 << (2 * i + source_bit)) + else: + raise ValueError(kind) + return a + + +def inverse_kind(kind): + return {'new_F': 'new_F_inverse', 'new_F_inverse': 'new_F'}.get(kind, kind) + + +def expand_ring_rows(rows): + # The frozen receipt encodes a+bN as a+2*b. Convert only for comparison. + out = [0] * 16 + for i, row in enumerate(rows): + for j, coefficient in enumerate(row): + need(coefficient in range(4), 'ring coefficient range') + for bit in range(2): + if coefficient & 1: + out[2 * i + bit] ^= 1 << (2 * j + bit) + if coefficient & 2: + out[2 * i + bit] ^= 1 << (2 * j + (bit ^ 1)) + return out + + +def difference_witness(a, b): + for i, (x, y) in enumerate(zip(a, b)): + delta = x ^ y + if delta: + return {'output_binary_coordinate': i, + 'input_binary_coordinate': (delta & -delta).bit_length() - 1, + 'difference_row_mask': delta} + raise ValueError('missing defect') + + +ZERO = (0,) * 9 + + +def nscale(row): + return {(bank, n ^ 1, powers) for bank, n, powers in row} + + +def gscale(row, stages, sign=1): + out = set() + for bank, n, powers in row: + powers = list(powers) + for s in stages: + powers[s] += sign + out.add((bank, n, tuple(powers))) + return out + + +def polynomial_event(rows, kind, i, j): + rows = [set(row) for row in rows] + if kind == 'old_F': + rows[j] ^= nscale(rows[i]) + elif kind == 'old_B': + rows[i] ^= nscale(rows[j]) + elif kind == 'CNOT': + rows[j] ^= rows[i] + elif kind == 'exchange': + rows[i], rows[j] = rows[j], rows[i] + elif kind == 'new_F': + rows[j] = rows[i] ^ nscale(rows[j]) + elif kind == 'new_F_inverse': + rows[j] = nscale(rows[i] ^ rows[j]) + else: + raise ValueError(kind) + return rows + + +def lower_log(x): + z = (x - 1) / (x + 1) + return 2 * z * (1 + z * z / 3) + + +def main(): + saved = json.loads(STAR.read_bytes()) + full = json.loads(FULL.read_bytes()) + pressure = json.loads(PRESSURE.read_bytes()) + hashes = {str(p): sha256(p.read_bytes()).hexdigest() + for p in (STAR, FULL, PRESSURE, SOURCE, WORD)} + need(hashes[str(FULL)] == '1ee06005d3b82ff592640d9aa4be2021b6de0a0b27fba5723aa06c36a6adbd20', 'full source pin') + need(hashes[str(SOURCE)] == pressure['profile_source_sha256'] == '4774841de10a8386204519174c5e56eb14f5852b20058db38a65a1034eeba275', 'seed profile source pin') + need(hashes[str(WORD)] == pressure['seed_word_sha256'] == 'a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022', 'seed word pin') + sequence = [('old_F', 0, 1), ('old_B', 0, 1), ('old_F', 0, 1), ('exchange', 0, 1)] + sequence += [('new_F', 0, j) for j in range(2, 8)] + sequence += [('CNOT', 0, j) for j in range(7, 1, -1)] + need(sequence == [(e['kind'], e['source'], e['target']) for e in saved['word']], 'literal sequence') + total = identity() + prefixes = [] + for kind, i, j in sequence: + op = event_matrix(kind, i, j) + inv = event_matrix(inverse_kind(kind), i, j) + need(mm(inv, op) == mm(op, inv) == identity(), 'each exact event inverse') + total = mm(op, total) + prefixes.append(total) + target = [1 << (i ^ 1) for i in range(16)] + need(total == target, 'faithful 16 by 16 ring representation endpoint') + need(prefixes == [expand_ring_rows(p) for p in saved['prefix_rows']], 'all saved prefixes') + for kind, i, j in reversed(sequence): + total = mm(event_matrix(inverse_kind(kind), i, j), total) + need(total == identity(), 'literal reverse inverse') + defects = {} + for name, omitted in [('missing_seed_B', 1), ('missing_terminal_CNOT', len(sequence) - 1)]: + bad = identity() + for k, (kind, i, j) in enumerate(sequence): + if k != omitted: + bad = mm(event_matrix(kind, i, j), bad) + defects[name] = difference_witness(bad, target) + single = mm(event_matrix('CNOT', 0, 1), event_matrix('new_F', 0, 1)) + need(single[:4] == [1, 2, 8, 4], 'pure new F leaves raw source unchanged') + + # Explicit Laurent monomials in nine independent commuting Gs and N^2=1. + rows = [{(i, 0, ZERO)} for i in range(8)] + cursors = [0] * 8 + expanded = [] + idle_windows = [[] for _ in range(8)] + active = [[] for _ in range(8)] + stage = 0 + def fresh(bank, stages, idle): + nonlocal rows + if stages: + rows[bank] = gscale(rows[bank], stages) + expanded.append(('G', bank, tuple(stages))) + if idle: + idle_windows[bank].append(7 * len(stages)) + completed = False + for kind, i, j in sequence: + if kind in ('old_F', 'old_B', 'new_F'): + for bank in (i, j): + fresh(bank, tuple(range(cursors[bank], stage)), True) + expected_powers = (1,) * stage + (0,) * (9 - stage) + need(all(p == expected_powers for _, _, p in rows[bank]), 'matched fresh prefixes') + active[bank].append(stage) + rows = polynomial_event(rows, kind, i, j) + expanded.append(('local', kind, i, j)) + for bank in (i, j): + fresh(bank, (stage,), False) + cursors[bank] = stage + 1 + stage += 1 + else: + if kind == 'CNOT' and not completed: + for bank in range(8): + fresh(bank, tuple(range(cursors[bank], 9)), True) + completed = True + rows = polynomial_event(rows, kind, i, j) + expanded.append(('local', kind, i, j)) + need(rows == [{(i, 1, (1,) * 9)} for i in range(8)], 'full fresh-factor endpoint Gamma9 N I8') + windows = [{'bank': i, 'active_stages': active[i], 'fresh_idle_query_ranks': idle_windows[i]} + for i in range(8)] + need(windows == saved['public_fresh_idle_windows'], 'actual changed idle windows') + for event in reversed(expanded): + if event[0] == 'G': + rows[event[1]] = gscale(rows[event[1]], event[2], -1) + else: + _, kind, i, j = event + rows = polynomial_event(rows, inverse_kind(kind), i, j) + need(rows == [{(i, 0, ZERO)} for i in range(8)], 'full Laurent-word reverse inverse') + + nodes = ast.parse(SOURCE.read_bytes()).body + candidates = [ast.literal_eval(n.value) for n in nodes if isinstance(n, ast.Assign) + and any(isinstance(t, ast.Name) and t.id == 'LOCAL_B' for t in n.targets)] + need(len(candidates) == 1, 'one literal old seed profile') + seed = candidates[0] + need(seed == {1:1322, 2:1342, 3:79, 4:44, 5:102, 6:11, 7:18}, 'old seed profile') + mass = sum(r * c for r, c in seed.items()) + need(mass == 5121 and max(seed) == 7, 'old seed complete mass and maximum rank') + new_mass = sum(int(r) * c for r, c in full['forward']['profile'].items()) + need(new_mass == 5097 == 15 * 111 + 8 * 429, 'new full-target mass') + need(full['new_target_rank1_lifts'] == 111 and full['private_excess'] == 0, 'all target lifts and zero private excess') + # Polynomial coefficients in L: local + untouched fresh - hosted helper mass. + coefficients = {1: new_mass - 14 * 111 - 8 * 429, 2: 7 * 111} + need(coefficients == {1: 111, 2: 777}, 'all-L direct polynomial equals111 L(1+7L)') + width8_slots_per_port = sum(r // 8 for row in idle_windows for r in row) + idle_mass = 111 * sum(r for row in idle_windows for r in row) + helpers = 3 * 438 + 6 * 429 + complete_mass = 3 * mass + 6 * new_mass + idle_mass - 8 * helpers + need(width8_slots_per_port == 42 and helpers == 3888, 'aggregate changed capacity') + need(8 * 111 * 64 - complete_mass == 33, 'eight-bank optimistic D33 arithmetic') + need(8 * 111 * 64 - (complete_mass + 6 * 3) == 15, 'historical private3 D15 arithmetic') + lower = Q(3 * mass, 500) * lower_log(Q(22, 7)) + need(lower == Q(21108762, 609725) == Q(pressure['pressure_strict_lower']) > 33, 'exact all-L pressure witness') + controls = {'two_seeds_lower': str(Q(2 * mass, 500) * lower_log(Q(22, 7))), + 'max_rank8_lower': str(Q(3 * mass, 500) * lower_log(Q(22, 8))), + 'D35_lower': str(lower)} + need(Q(controls['two_seeds_lower']) < 33 and Q(controls['max_rank8_lower']) < 33 and lower < 35, + 'sensitivity controls lose this coarse certificate only') + result = {'status': 'PASS_INDEPENDENT_B05_CALLER_ALGEBRA_AND_CONDITIONAL_PRESSURE', + 'scientific_pin': '20ecf2891d80b5acf18d980b2164fb44ea7faa90', 'source_sha256': hashes, + 'ring_method': 'Faithful regular representation N=2x2 swap;16x16 binary matrices', + 'events': len(sequence), 'matrix_prefixes_matched': len(prefixes), + 'formal_endpoint': 'Gamma9*N*I8', 'formal_literal_inverse': True, + 'fresh_method': 'Laurent monomials in9 independent commuting invertible Gs, N exponent modulo2', + 'expanded_events': len(expanded), 'defect_witnesses': defects, + 'public_fresh_idle_windows': windows, 'width8_slots_per_port': width8_slots_per_port, + 'aggregate_slots': 111 * width8_slots_per_port, 'helper_occurrences': helpers, + 'aggregate_capacity_is_not_owner_allocation': True, + 'old_seed_profile': seed, 'old_seed_mass': mass, 'new_full_mass': new_mass, + 'direct_mass_polynomial_in_L': coefficients, 'direct_deficit': 0, + 'false_deficit_if_target_lifts_omitted': '111*L', + 'eight_bank_ideal_complete_mass': complete_mass, 'eight_bank_parent_mass': 8 * 111 * 64, + 'old_private3_ideal_deficit': 15, 'new_zero_private_ideal_deficit': 33, + 'pressure_lower': str(lower), 'pressure_excess_over33': str(lower - 33), + 'sensitivity_witnesses': controls, + 'limits': ['Native interfaces at changed cuts remain premises.', 'No chronological owner allocation or rounded/physical compiler.', 'No positive supplier or new kappa.', 'Sensitivity controls do not prove a changed model passes.']} + (HERE / 'INDEPENDENT-RESULT.json').write_text(json.dumps(result, sort_keys=True, indent=2) + '\n') + print(result['status']) + print('16 exact prefixes; fresh Gamma9 N endpoint and inverse;2 word defects; directD0; historicalD15/currentD33; pressure21108762/609725>33') + + +if __name__ == '__main__': + main() diff --git a/research/r429-full-target-interface/frozen/reviews/native/RESULT.json b/research/r429-full-target-interface/frozen/reviews/native/RESULT.json new file mode 100644 index 0000000000..09069e9183 --- /dev/null +++ b/research/r429-full-target-interface/frozen/reviews/native/RESULT.json @@ -0,0 +1,329 @@ +{ + "ADD_count": 12932, + "ADD_frame_counts": { + "FULL": 4147, + "ZERO": 5758, + "distinct_frames": 628, + "other": 3027 + }, + "COPY_ERASE_records": 0, + "MOVE_count": 2984, + "all111_exact_projector_hashes": [ + "79d8e6274c3681536ac1e15e35681ff31a980f74f647cbcaf34e8a3d4fa945c1", + "e0c1c6acb4c8618e65512ddeac87e4d3f300a531acfeb53aceb81424e7a76a61", + "268bad3f4c5c423253b5ac8c4ce956a7ddcb741725d1b01114d7cbb471d80743", + "182c621e833028d5e99a8e46ee95befc27319f5dcd61ee6f0411936ebe1f5a4f", + "d42b9dc41c4f0bb9b0c0e0faf0d0228c2731a68d1b0910c2ab08c4c39fee7004", + "c824b977113039cbf9e1cb74945571b53132feb85f56ea1679b7a47811470534", + "f969d31a0ad0b1c6ab51955f4a95cf05217a15147850a69985c52f695a4b1955", + "3e74c4801dcebd1dd451fcf69f5df8b03fdf3ff91cd2182b10953c3f22d585d5", + "60f742185837934d2232f5d7386af2c93eea2fee2dc058e749d1bc27ab1e81d0", + "130b0c45f8eba3f978453ab192bf051ac7f5a65e44f3ff3343297c98808d53fe", + "ce38a56da0632d7f6ab08d045c238924b5b104f58664daac6bb5945bfce5bfaf", + "5e1acd2fa47f81c83872e0831ce6ad32677378cbb70daa8dc7ab63a9919dfca0", + "3276f49ef67861c5354367bd84f3e3755ff93fea758ddbc4a9b96214d5ae4692", + "6b37fa580abf6bda33094cba9552abadfc4ac5862c8753bc12fa48096a73bd20", + "7fdd4b677001ee78efe89fb9db7990f628d052ff994aec357f5447173ab9e6c0", + "1132bbbff5ffab0932e35ea857138fec508ad2a67baf9689be120c4305cb2a74", + "776338ba24b624ff307fa64ad43490213c946ad717621accd905f3fbb4df68e8", + "1ef62b2c36129aee4d7512d146cbbe03fee50cbeca1dd7216aeb3cbd429b3d7b", + "614678a30d099fef5bbe57c688a43ab27242dc04cfa797f36d12f0816c40040f", + "247e93d1b21e72e8603721445fed1c45524b7d7424e9923742f561ffb2dce215", + "1554a44f52e9af939ca1a85307a5ba772a2841bd1980122a29aa88b77ab3202d", + "b592f04cf470eebbdd82c0370dd05a75faca7610426f0cab665324d382b9765f", + "79d41f318ec029c99f1893040b1a79b6c01310c1c99e0162ba69989799c06798", + "2d8c1ae941447b161654d3073825ca6fcbe2544580f9e3d687198a1386213757", + "9f61002dd86c2703538de49730359750a5f4215e76820227aae2b35a99a96a41", + "5f03c7f098f701187dd3c4eb2c5a728da0815778a519d74e15c3ec1c7f347164", + "f28c96c2b85a1cee1e32ede983c95b2f483f948a055425dc06aeb7b594e322df", + "ff0c205895f1d3e9efb6d10ce398e9e6efe90ad93bfd4fb201d0d968b0d42093", + "13793d3ddf67ddaa7cb63b101b4a0a7112937ab558aae7e7c36d0c1abd825a88", + "cc4282b1eeebf08c569ab223c5a902e730bcac48f8fdfbca8c8d97e850ddfc46", + "8633230bbdbc9d0272c3e9c58510a73b85f2d019f548e40f78f984defef07714", + "0390fb7131b1ce6b9ee1bd2180f904ab5600a94bdca1016f0f04d11fd4463bf4", + "a5a421ac2b7e17afbaad6f9208ddf0ef88928a25a9f6450fdd8eef19b66f3bd7", + "7cdd3169d9b56bed35daafcc9dc3b4d03b90bef59f987806ad439a7bc622aaf0", + "1d496935fb577681a87916a4fd46a4f5476bdfd39e12eb335756ec4db581bcab", + "ea3a4a0c35cedec7c6fd478f9def71aeb74c63f5a1d1d7fc49503b870ffd2b7f", + "5e79ce8d083d8be71a12f4d5f18aae06e44922f61f6892df7a5fb2c4c8e8eb2f", + "c82143cfd514515000ed6f81e7ba565fc3a415ef16a9c25caebb33f8b0e26334", + "1e155cfc15747e184449173486ace0d5966efc7b13cbdc69fe56c1f35ec3d531", + "511bdfbb1157404031cc3deca8ee4de8b268136020cfd992af0091fbc9605ae6", + "92617ab9d327e78d76674750e0d207c0f4e81579d1741db2e575bbbafd2a5c09", + "8fad0691dbc37dcad677743815cf2ab25669c3dc13f3b462e7ac0b1d3188e8db", + "cbf20d872e563c329334c4a6c00a58bb906590dad8120f64be4c048fe9a523f8", + "68ea647fd24a2eecacdb8f708c72250330c7ac421ca051e2db65b6a956bb0b32", + "8cdf2aad9251af8b0b7b1c43c0b18302e590fd473d7e2029539b801f1dcb9192", + "5d7c996a295c9fcdedd06359595ea704ee838cccdc11b8c9473dc7bdcc5daca1", + "76bb2a5c4c78aa61029e65c6164bd07a2b2012153866f6d2028f243ac77cbfbd", + "97304d0da6646e2dd155f962c50741cc8a69dcd1bc42aea5ba374378f7bf3a1d", + "1609df3dee8d12340e00dc70a0035033535db3329aa6e5153354ebc40723ef5f", + "1bdfba83e8dd5073a52d68d94a6990b0b6b6970bf680fde8a097e787699d512c", + "78e4327fc31716c42e2fed0bf6860d000bc8b38855bd7d9700b142eab1f357ae", + "cfd99f2ae2ebbbb64e943fce3d9584bde1da194230a9bfb291194709795f8e54", + "0db6911e159bcfc022d56ea9944b186861c3251b27f7826a41eb6f437ae2c927", + "66d4a1636b03174963329fded119c129f47d368eb5b11d0007440f684b8863d7", + "7a1d0a5d2df8026fa2925faf5285571b425a327898490504b2fd5f95bbe08f9f", + "848b4cc632ec92305a3d506bee97401ceed3d13c2511784de89a7ba860b7e3a9", + "c600fc6a38f1a91be94d17c012c18274aeaac1df5a8481548c7414c7c633891d", + "bae1ef84ccfa04e563d2533581b6b2119632fbc668e00385eb13762a477856a0", + "60aedbb346a447cbcff161a203fe9eedcd8579c9fe998a7ffffdaa86b973f2e8", + "d2e02e70bf3e53c3cdb892714f49d52fa8ebfe09734f5dfed6ac0a90b07811f8", + "486eba50ae82e1641ddd0b3c356230c55e0f58f9983da33bad17b1a9974a5488", + "194e0e6211add02e1da3807d157a66a52fe52c5044e77a73c31e9d7c12e5444a", + "b892f9bc7f5db1a47c78e6b1996b69e78e97fab68c9739ecfc09ea6ffcbd3258", + "a5c69528a47d7ba328b7602b2f496365c5637d774465408c293eae0cbccdb3e4", + "89b7ed50783e63757e4f1524dc72cadd67ea4e57e7a3593421df31de54d0a3b7", + "69e6ffaf40042c98d031a71a84ee17e95921a042a039e710f7c64452b83491b5", + "83abeccb6975fecf3418123d5bf5f0dbc37f225f017ea9005f6f61c4ddd4c8d0", + "89017fd9d438f351745685c5683a201da2a0aebe4ba06a2a1a6cb42e3dd6970d", + "8364b0e8f8d3d96c3a87530fabad07c02b792eb0831e020f7246e7582be2402a", + "4817739464852754584462aefe370d1f92cf87bd5d3d832d0dfe027577b88be8", + "458682ca42c823ff523c0196b28ce1b342d4bced51a90b1ad4e1d1968db76244", + "b11284986169b612f0c20564539ecdfdfae1a3422fcd238e0d69c221a67cc594", + "57fb7b17e2427f40554761a695fda1df91b5e1a14e58d64a7a8fc53eeebb97ab", + "dbf00a56a6955ccba2015e120cd0b8e3319b401bb491abc702d1d11422db0f7e", + "40758696ebf8f3a089133f3f29e6cb7713cef4b241671989c4c5f4c21c20843e", + "7537e826ba01c0fd95dd0d58821b91d657a767269b8c1ad055206e6de0602063", + "6b625d89bc944642e6d0926c13cbc74c70e2f8b8e62c74d6bfd7da95c662c8e6", + "701fa3310d36197cff63a4843c9ac8bf0aa65fa46735d585cd2a1255dbbc9d72", + "f56f085724b78f0532dc5e4054d0f1ab714d6853e27c204ba8fd82c80636ba23", + "095b7f7c2918a4e60d23c070edbad49027f6ad14beb6f94679bbc87c75060ac3", + "3d6965ca19144cc8fd6f80e3458a23b8143284c574d0c100bd7bac6b00dd42b0", + "c70fce3f2f2b86b1c314c8a7fd27ef17c42ead7d17735d638e5cc8f7154f764c", + "c8e82f94f49ea8328faa9d14c7ee8c2783dfc58f57b6eaa359cdee56c81b3380", + "88ed12254b589ca65ba74352f290020c367804373650cdd7bc1055dc59b0f2ae", + "7b737be117e751ceb2693a15d5b71996f31edacf3cec656a7c0eeee1f0c94a65", + "05d9579b4e0dbfe85be88a381df66fd52aabd3ad4da23cf29ed03117ecd1a3ac", + "f912831c0fd7f335be43791c9f824ccb2bb047e6ad365ae9241a26f47c1fd322", + "9bb0f26c4da16caec308419e9dd5b575ea641d451e06d3ad428f3018af737076", + "3114268fab1737e3b2b77adc78d2b6204a5f87216fffbf12b300db24552b441d", + "3f876da77efbc95e63d799a5d7c7f40f712718cbd09022b6405b9b95b6512485", + "d147ef712b3593c64a24f0df4001f5f6e16e85b4f5c0c86d567aa9afceb33a0b", + "1dfda9c806e9d33cf0a4a4d2a8730387f12ac0b3d9d714d92e76d79676e590f4", + "1140ffa3d16324db5a6e7b388d8d5791bbb5254bab1a38579e62d2544326724f", + "2af169c1046509dd34185e7bd4ecf18035aa00dba72e2c7faba99cb372e6ce55", + "93af14c784d33dec53a79566700b46c59aecf0c567cfa3bdac7c62cdea6101b8", + "6c9a0f033da926027adee0f0bd19f5bef2bb5e3d12387482673b529917cbc8a1", + "3f1adbca94ffed0358f50cef9b92293558548098598c88b3c6a2bb8a6cfbcfe6", + "e5729790d25394e5347b5e43e85e9c8a517d9d0e60fc2745029d972dc9f62275", + "0c9e7bb9fa3c4fc19cf75a174fb9e49f75d5042f4e763833eb991392c8218074", + "4959d3376cfcb9c6a3e03eaae8a04539dd900d6ef6b6c496186c1080f3baefc6", + "ebc14607f7b3123473317f9494d76e1144171127880f5ed3b69051a61203fa24", + "16374d1cf2572f80198e5427ecfe7446768682e7df4d385c878575c39ff6d078", + "4cef63154a7d8958ce1cbc13d47775e01aa78fadc7b6227fcae2725e104a5127", + "25894d983aeba72bf03749347791649105c5b46926cc27570c8532d755a87792", + "4784f9d79a16a988efb37e170b4cc6e358f8670a7d48229d222f282f84e97c99", + "b48a5e9e8df3f59ba3cbc6dc0e0ce8dad78723dac30967dc86f2bc197a43fac6", + "402cb05d88009484a64926b9c773ec817ab2a2cf67b5dd838b966e230613ea1e", + "bdbbcab223d7f0037bafa7707a52bbacacc6377e53791476a40ce8984d978faf", + "713cc26615448c785c23b6125101da48374d876ab9b98e11f2fd56205dd7a1e4", + "7f4cddff0e857be475b3a4073f9742197dec4e90740b3f2d8a6674536339c645", + "07ac05c5098cb58514f5eacfe99132676527bf96de2565ff7564a03789e47181" + ], + "all111_lift_hashes": [ + "d2c32afd4093f34ec86716dee5d659b01a512ad841f240b474b0fa2ea54ae54d", + "7b4fd24f48cdb1e61fccb02b30d0786b1407654074aeb0a7f994248a67eef537", + "7a0091f10e8d96cb299c51c0859346214486ddf454f73d9f5818cd26c5b068c4", + "2347c035967c527ab3beea7001e3b3eec3e94548395281921af8564928c11148", + "02d4462b7a05aedc9dc23ad5e13e7291a78dea07786daf450961571d5496ab23", + "2d1723ba6269642ebc257cbffada8df399465f71b2beea76e43f6e2439d7f235", + "784b4bdf3f514a0fe74b3f77365dca2efb8edcc3dec75163d04f8744bb087864", + "1c98ea5948d5190619da4dfc5c6241d9cb8d9045ff93c248946ae1d1a1787781", + "51190885310d40cd899f495af044800193e6c8638f3bca7455e1ed203ac78a21", + "83e4b90297c4d9bb0e6c54466742a8232d0251f1919bd69e7e2088189f854442", + "bf0b0ca9b132a78458746d79bffc0e1a44619bfa69ddec1ee15bd7b37be80680", + "f001730c7739b3ce5ced7294de592c96ce64787524c1ef6ad01d906840c622f2", + "0c1331775fa461009fbf88fc56a8dff31f6e49845dd7fac50d17823f99a79379", + "18545020eff53d0f97f02966b139b079a0d065d3f611edd108308e37a101cafb", + "aa2ea0f7e098f5b2739b1984ec2b3d0d04b08dc08f25a68e10ee2d9f0b0088de", + "74a737bba14bb4582ce88b7fa254f4d72009411abf88aad5e064356e396ecef6", + "006f4a1c59102f6a25f1316d02684e9ae78cb9d0c744a66d86a8d4dfe6aef052", + "15ca7f215161710f90633e603efeef925303511eaeefb512c7533d467688276a", + "d22141ade915bbe5c0f1b9ab00cf662e011e30e77ee659adda82ca150e44cc4e", + "9e756a4095c7960a1384cb3188d2f70581df2063e12a2ef37b4a7c946a7113ff", + "9e0be765434f77c65166c9d0deb760de2dcf5cd4de5ba33e33b880870fc1a38b", + "ea60769e2d33e5b5c7afce1c19945ad46abeb3971326b1530e8d0e0b7c17e9aa", + "3fa9cff7e89492914355e2bd42b7c5b1dd5e94dfcabd03aeb106b0f24c6e3cc4", + "dca8002e854c096e2d03a6feac5f16f8dc4820915f6381c6fefe0537bf4e5dee", + "779c4966bb2c6641471b6271c3908af7a1a40bb6de95eccff80ab1b26fe434c5", + "7122801bd9d4d19d509241cc245ee1d7cc7b6c23a49372b3682486b5833161fb", + "73a53eed3a9e876ed9f1b8ee69a1df866e370fe31d232843c671640f73adda57", + "0700e4ef8a5d0d7c8c8a215566e5429543bab7c45cbd83ac6699de356085afb2", + "d9e7aad823d2335e4dbf8b099dac0ef00a25a7b6749f996f93af4c99499c61ea", + "8d758df176d6536fb5b396f32e51df91cda21236366f0e05d95a4414534ecbbd", + "9551f613cc099fdfb9d0716b23e4fe006447b2ef11b611cd809ccd8a1e6ff823", + "6b06b1c5a2c01a5e1bdbb1025e891916f5da7a0a37a5119a88fb244c93574fd4", + "6872cb6bb8adfc104ceff20562f0805a4bd5b8360dfd16cce677773dc589c4b1", + "4876f9b455e0b2bbe5e5ba6139bb7c3a445ec732e35ef04a9965331b76195e10", + "620836a500880b73b9cfa35c95c0656b2827bcc227692084bbc7cba1a77f722d", + "0a8174f3bcb35a2ef0f0c6493c36d530b2e5730368e312d052cf5172738637e7", + "c90d2c70d852a278d0a015c76b929a48b6398c82429d13310e07d5d3bff02a51", + "ccecc6231a6a1dd01088467666b4c25770658b4da2eedc82f6c0b93ed83e6d28", + "6b1b14c8b0c2b43c2e08f3206b44c4f6977d1c8bcbc1bc940b838cc3f9888322", + "78f057f2f9cb133c8670fd10aa67c43e0fde98fa31bf67d763984005794355c9", + "c31a2595effa50f963fc7168fa7cdda98c4b58f5f2d31e3a21da64358a610585", + "be24264e7bc1b3862cc864f0d8b8bb917d4580f5abfa51f34af9df6e8556efb5", + "e292e818dc2209295d0efe10b27021148da4e0e00db18c7b41278ebd4f396503", + "4c6e4b31ff207cf71b4c9970415896b9601ddc2795d8cbf5272b64684bd65eed", + "e1237a0e11230edddc8b917db3bff363c5602b387e7e7b8c056588b36cdf43ac", + "0cb532fce722f9270d6097c3b75008cb71d8bdabe25794b3831b8544e05966b9", + "6eeeb291a4c4af8c5e66b149413abc6b4f71b115af4154a86035d3c8e603edd5", + "598bbd423deb4e50551240446ceeae9d68db0e6e7461545000f01ee7cc77c775", + "9023798db010a3d8b5ad598f73fa8272c0542644b04082a6b07d3e686fcd39d6", + "4f6bd242812c1b74781c696d10ce3ce37e2ff74d90bc7cdd3df9d2b326b289db", + "c1d1b897200f24d9a85f2a9566f76dad4b0a67274ab9528a50bada41b9e04b66", + "7d6851ebd6c8f7a92a913f9f138563f50c30eb805a262cc65645804acfb7bcbe", + "0e065676a747821046d9de2bb1c6c20d2152c448b37cdb70a982afebb866693d", + "dcd41ed055360fff40d4b7d26d5a2e20673336f98b78c41795c5cb0b16eee7cc", + "95d103aab0e74957abfbb16f9fb7d7a047f6767724b84624c37d0b3c72c99b75", + "bc9d573badb53e4960f6dde8ee4bade99d05352f901be474e10e692d86eec252", + "a78e1883ef36bdcad6d689fa99b27d75c8af907e7a0b289c57818d87b3263777", + "ea1fc3f5acf7b3344e2904893e1e2741db3aa5339e1bfff030982de325e96ab4", + "92b9675f7ed59b0122c09f8c6e82a5f45a781d6897069e4721658a4fa84f5abf", + "161ef1fb56a069a63a3291d3b5b2f1836db574ff3df18dcfba3383a0c0f7d39f", + "f1475f25a27d60431b45b24531e7692c2a904e5d29c95c6cc8e2e7229fb95a68", + "e7e5b28ab41c9f83d35344118621e3a593d61e5a3133ecdd5890c3c53953e1d4", + "495d83ea2d8bc6dc2d6b002c2b20ae09cdd1906bf64d06d25dc0d34aff60facd", + "84db5053c9fb1748754ffb80b66bad55539144c5167da0b104d2a3fc562f9be8", + "3937ff6b56c95c565d8463a46b6e7248af04f876564a9980d6a2d5fdce7be089", + "854b55c2e1f50e28c6e7897f3e0a543fdb81c5445b97623ef1da7253e6dc027b", + "c09181cb9615624c485f8f48fb6f616cec1e0c83e2366d4e0df943dd11ab7f44", + "48fb071bbdc9e1db13cb67ca4a4af177a6e7e1d9221cd4108838cd7ef09e246f", + "831855872c4d87195803f40fe16c7cbc338350eeb1799da8d5cd8f98d69756e3", + "7ee50e89b93c9841da91ef7404352e9657c85087ce5e48e5ef3ae0db7c716200", + "1a1417196473470b1821347238af48d72e483fc3f07b6529effeece55c1a284c", + "78eaad9a32ebfc82518532a9258f88aedf4a3df87db9d3744534dd0cd8cf2cd0", + "5d72661a73ced4bf321aa080670ededebd23505005a62202027eb1f622cd9aa3", + "12a866a71b0fa00860b5c12f0df473cf4f27618299578e7de5f9ef498030c402", + "572224bc76dc2e8985d1a2207ce0cee87acabc14aab53249794c9df81ccbaade", + "c36ca380e031c8500d9493a7a380958b55ad052cb74705e06459a4e97742ec31", + "a0fb1a5c9184fc94a2a53959e77f95fa96fd8d40fcbf7f108bc2b942ebdb9cc7", + "36783293457f89e7ba42a795bcfafc924687f8ca282ea1be8e4e88ad97e5d174", + "4d97b105d6ba3a7467abb4bc1b75c28863478b85eb72a193a6421525929d8e00", + "1978a27ccbcfbe5c31c91847ebe897122ad6a659ccb588c164114ff4df82e0c3", + "90d506603e00ac5f58b581e97048889b49826c4b362847ad2779818f5012bce4", + "54e481be354034a9a24818708d7dfc4c4e13ec0ff36177a8bbedae06693deea4", + "a988a5ab5c976ac9767c7fcd63b00430848411be0f35a69570300fd831f8e057", + "9f50d37d825e24754828e4db18c1630b79f0339cba82b85dba15b1f4cb82ad56", + "71bdffa30e546226b0a1e5d90f4f25b1c44f2251657ee64801be7ae5fad57859", + "6c47ffdc091a0ff800f373e32f342c9d8f5f551dca0d2f4cd9b681536a3d613f", + "42f341496599f8c839df00d659ed6e95aedde74397651e670c467b9b97ae00e2", + "89ac48ec4c875f4ec34a8deee748c7327f323890d06b56837b62ce04ebeb8aeb", + "6a2c9d309b779b86f7ed220ca72954e25aae2cc2f948fe0d51ef5d63bf3b45c5", + "66d6e459300d9cc4fe89f6e0b0c92d0ff5733c79ec30a1b528e011aef8faa56f", + "d0b0a9e09a903da8f4701116186d4e006f889da7924b9ad2874f25583836b703", + "115cda2dabf08b0108777cf5ebc3371447089b84f846b5ac41aa3dcd4e8e006d", + "4acce20635968f29e8c447ac08b8742afb68366ddf30a0c03690ffdbd9ba45f7", + "19d75b26d926fe78efc696473d74ad5bcd03cc93015a064939358740f2d0b198", + "077a693e5ec46fffc010614764079b92bc3d5859efb5b219fc0020ecc7f31912", + "6e11fa2bc9f0722a6a47fc1457cd2bccfb806c57f316ddfc57be37017f503f04", + "2a26f1d183560f9321c71363943fbd006569c7b3a42d8d9c9106113f38e740a2", + "489a5d2aeaddb2475466ea8bbfcccaf3c94f91ddcd1342bad8379b281c1c1f3d", + "93da13ceda8893197b641799f2407d505fa5aff8ecbcee4c01853a2482ceb4ca", + "7314dd75554a17351f88a476ab2f347ef66c37644c324fc6145c5d8ad0cc5ce2", + "d46a7e19fa282061b311196532c24c4cdecdd43324e5375fa5a12209ee6ccfea", + "55d37292fff7400e84bc368097a4fd9419f48915d3602410e38ee4d5fd5f47d5", + "3c8df638040b70d5b1b15fd0afa3f4a4413df59301727da28faf567268512e8f", + "db0e72300a67a68f09705423da4726b8edcbf882752d379d54a2c511d1ae54db", + "032102e7e72ba6fd6310d854bada48c7bc8836072f13c972928a2e9f85b35e98", + "6d788a240288b4279094e0cf0fdb5596b5622330fb71086ccb7596be6fc62bda", + "37942397d22bb980fe46a3575802b16648c442fd388ef8bcdf7e3cf0b4c6e7c8", + "d541ada7edb22ec6a9f74ba9174758e7d93c847a1eb0aec59b49ea34d603a605", + "a81d5ab706ac22b195a9ecf4350d4b231a039c6c8197d7c06d6b4a380f2ec499", + "d9509a5435b7bc757b23578a6706d0324344a86658ea67cc081ec714e26e4f5b", + "6261b8b01461833d449075ced9969e3b0e473fe3bc1cb54af3b47ea18183cdbe" + ], + "arbitrary_integer_columns": 651, + "bulk_target_source_integer_B_sha256": "f84dd0dd4ee6d2c873e113278077a5b184d903d2b3e8b904c0ad801c74227157", + "controls": { + "omitted_lift": "ADD actual common frame", + "omitted_scatter_binary_failure": true, + "wrong_unprepare_integer_failure_parity_unchanged": true + }, + "diagonalized_binary_endpoint": true, + "even_residual_samples": { + "target_helper": [ + 0, + 226, + 2 + ], + "target_source": [ + 0, + 0, + 2 + ] + }, + "exact_signed_prefix_row_L1": [ + 874, + 874 + ], + "first_maximum_witnesses": [ + { + "destination": 113, + "phase": 52, + "record": 15796 + }, + { + "destination": 113, + "phase": 10, + "record": 89 + } + ], + "forward_dense_integer_sha256": "2af146268741fcd566d4f2524ab1fe09805b121a7cdfde6e98aa3d0512b47c90", + "frame_chronology_sha256": [ + "ab3fec2617749f898068d74c1ba8e0ad080bc32b3eaf6f09508d27ef3890c379", + "e8a3279556d3950339189db6c170aa7bed1344277c34c6cc0df42741a4ddfb6f" + ], + "helpers_restored_in_logical_coordinates_over_Z": 429, + "historical_receipt_correction": "Its allsize_lift sentence saying every scalar ADD is atZERO/FULL is false. Every ADD is at its actual common frame; only all newly added nine-total compensation ADDs are atFULL.", + "integer_endpoint": "(x,y,h) -> (x,y+A*x+E*h,h), A=I mod2, E=0 mod2; A and E are fully computed, nontrivial signed integer matrices.", + "integer_identity_after_diagonalization": false, + "literal_inverse_all_integer_columns": true, + "literal_inverse_dense_integer_sha256": "ea1cd1cb80234a743cfe24fd024de2cca6d96b5d1023f7d94e88314f02252cbc", + "native_progress": 5097, + "new_compensation_ADDs": 1555, + "new_compensation_frame": "FULL", + "new_lift_ADDRESS_columns": 1776, + "new_target_lifts": 111, + "no_new_kappa": true, + "old_projector_ADDRESS_columns": 3552, + "paid_diagonalization_ADDs": 111, + "paid_diagonalized_total_ADDs": 13043, + "physical_boundary": "Under inherited native MOVE/frame realization over binary VALUES, source S=F8*D_P, target T=F8, data block [[S,0],[S,T]], helpers F8*d. Logical integer helper identity is not physical identity.", + "predecessor_canonical_sha256": "ebc33ee086f610c1fd540fa56bb99b2b96a768e4aed4a18defcb0e1f507fca89", + "private_fields": 0, + "profile": { + "1": 1406, + "2": 1342, + "3": 79, + "4": 44, + "5": 93, + "6": 11, + "7": 9 + }, + "rank_mass": 5097, + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "scope": [ + "The frozen final word is consumed directly; no producer or producer utility is imported.", + "Old internal native MOVE implementations and compiler guards remain inherited premises; their all-modulus implementation is not independently replayed.", + "Dyadic ADDRESS equalities hold in every odd field; VALUE additions and integer scalar normalization are distinct layers.", + "Prefix874 is a signed scalar bound, not a rounded precision or child-defect theorem.", + "No global caller, owner chronology, physical source access, tape realization or stronger multiplication theorem is admitted." + ], + "source_restored_over_Z": 111, + "sources": { + "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/bit_cap_copy_local.py": "6e9ca1eb905d769716c009904f45d6849b225e48cd119f18b50c0379f35313cb", + "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/recursive/bit_signed_audit.py": "376356696663021693c0e2c9adf37f371675fe8837fb88232b8767a8b90793e8", + "/Users/ross/git/math/.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/root-pruned-code/BIT-PRUNED-WORD.json.gz": "1a6841fccba51fa922993c77b4b296e659c2c538252e5e06113d0438c5edb870", + "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint/BIT-FULL-COMPENSATION-WORD.json.gz": "0f461dbc7e82a02faedb4a5129103963507c9f063a0a3679ba5d20ad94df160e", + "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint/BIT-FULL-COMPENSATION.json": "1ee06005d3b82ff592640d9aa4be2021b6de0a0b27fba5723aa06c36a6adbd20", + "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint/bit_full_compensation.py": "a7bda83b84ab15a75c418225e3d5c2fda8eded8577a894341225f757e6ea7e20", + "/Users/ross/git/math/.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint/bit_full_targets.py": "7446290e462752b76b9461696b7676c8295739aba1b79eea0d77925f5f9a3869", + "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022" + }, + "status": "PASS_INDEPENDENT_R429_FULL_TARGET_WORD", + "target_helper_integer_E_sha256": "529435b47500e7fd999aea0dfc5cca840eb0e2991ed680067b3da81b016ca08a", + "target_source_integer_A_sha256": "348437821fd83499d246aad8e2de50bc2ec10579c7a0a46f43c9bf4947a81a8e", + "word_canonical_sha256": "895a359e33a7a9a9cb2c4a68acc9fcf624596d334a52381264ae498e0e55c847" +} diff --git a/research/r429-full-target-interface/frozen/reviews/native/independent_check.py b/research/r429-full-target-interface/frozen/reviews/native/independent_check.py new file mode 100644 index 0000000000..5c2df81264 --- /dev/null +++ b/research/r429-full-target-interface/frozen/reviews/native/independent_check.py @@ -0,0 +1,269 @@ +#!/usr/bin/env python3 +"""Dense exact replay of the frozen R429 FULL-target word, without producer imports. + +All integer coefficients are Python arbitrary-precision integers. Standard +library only. Substantial OpenAI Codex assistance; Apache-2.0. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse +import gzip +import json + +ROOT=Path('/Users/ross/git/math') +RUN=ROOT/'.research-automation/runs/kappa-major-20261018T1330Z/bit-endpoint' +OLD=ROOT/'.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier' +HERE=Path(__file__).resolve().parent +N=651 +V=111 + +def need(ok,message): + if not ok:raise ValueError(message) + +def canonical(value): + return json.dumps(value,sort_keys=True,separators=(',',':')).encode() + +def digest(rows): + h=sha256() + for row in rows:h.update((','.join(map(str,row))+'\n').encode()) + return h.hexdigest() + +def ident(n): + return [[int(i==j) for j in range(n)] for i in range(n)] + +def bits(n): + return [i for i in range(n.bit_length()) if n>>i&1] + +def qrank(rows): + a=[list(map(Q,row)) for row in rows] + if not a:return 0 + p=0 + for col in range(len(a[0])): + k=next((k for k in range(p,len(a)) if a[k][col]),None) + if k is None:continue + a[p],a[k]=a[k],a[p];v=a[p][col] + a[p]=[x/v for x in a[p]] + for k in range(p+1,len(a)): + v=a[k][col] + if v:a[k]=[x-v*y for x,y in zip(a[k],a[p])] + p+=1 + if p==len(a[0]):break + return p + +def multiply(a,b): + return [[sum(x*y for x,y in zip(row,col)) for col in zip(*b)] for row in a] + +def exchange(p): + # ADDRESS map (u,v) -> ((I-P)u+Pv, Pu+(I-P)v). + c=[[Q(i==j)-p[i][j] for j in range(8)] for i in range(8)] + return [c[i]+p[i] for i in range(8)]+[p[i]+c[i] for i in range(8)] + +def dyadic_hash(a): + return sha256(canonical([[[Q(x).numerator,Q(x).denominator] for x in row] for row in a])).hexdigest() + +def replay(records,backward=False,initial=None): + a=ident(N) if initial is None else [row[:] for row in initial] + maximum=max(sum(map(abs,row)) for row in a);first=None + counts=Counter() + ordered=list(enumerate(records)) + if backward:ordered.reverse() + for index,(op,d,s,c,f,phase) in ordered: + counts[op]+=1 + need(op in (0,1),'no COPY/ERASE/private opcode') + if op!=1:continue + need(0<=dmaximum:maximum=norm;first={'record':index,'destination':d,'phase':phase} + return a,maximum,first,counts + +def parity(rows): + return [sum((x%2)<0,'MOVE exact rational dimension increment') + current[d]=new;hist[f]+=1;moves.append([index,d,old,new,f]) + elif op==1: + need(0<=s>j&1] + correction += [[1,pivot,p,-1,1,53] for p in reversed(other)] + need(records==bulk+lifts+correction,'complete literal bulk/lifts/nine-total word equality') + need(len(correction)==1555 and len(lifts)==111,'new literal code counts') + forward,pf,wf,counts=replay(records) + backward,pb,wb,back_counts=replay(records,True) + validate_signed_endpoint(forward);validate_signed_endpoint(backward) + need(counts==back_counts==Counter({0:2984,1:12932}),'complete word opcode counts') + need(pf==pb==874,'exact forward and inverse signed row-L1 prefix874') + # The endpoint is a single signed shear, hence its complete integer inverse + # negates every off-diagonal coefficient, including all even residuals. + need(backward==[[2*int(i==j)-x for j,x in enumerate(row)] for i,row in enumerate(forward)],'full signed inverse matrix, not merely parity') + roundtrip,_,_,_=replay(records,True,forward) + need(roundtrip==ident(N),'literal inverse roundtrip on all651 integer columns') + bulk_matrix,_,_,_=replay(bulk) + need(all(bulk_matrix[p]==forward[p] for p in list(range(V))+list(range(2*V,N))),'bulk restores all source/helper integer rows') + for p in range(V): + target=bulk_matrix[V+p][:] + for j,k in enumerate(K[p]>>j&1 for j in range(9)): + if k: + for q in bits(R[j]):target[q]+=1 + need(target==forward[V+p],'complete signed target matrix equals bulk plus positive nine-total correction') + A=[row[:V] for row in forward[V:2*V]] + E=[row[2*V:] for row in forward[V:2*V]] + B=[row[:V] for row in bulk_matrix[V:2*V]] + need(any(x!=int(i==j) for i,row in enumerate(A) for j,x in enumerate(row)),'signed target update is not asserted equal to x overZ') + need(any(x for row in E for x in row),'nonzero even dirt witness retained') + print('PASS independent dense651-column signed endpoint, inverse, bulk identity and prefix874',flush=True) + dims=[qrank([roots[i] for i in f]) for f in geometry['frames']] + need(dims[0]==0 and dims[1]==8,'ZERO/FULL frame dimensions') + hist,add_frames,fh=native_frames(records,program,geometry,dims) + rhist,radd_frames,bh=native_frames(records,program,geometry,dims,True) + expected=Counter({1:1406,2:1342,3:79,4:44,5:93,6:11,7:9}) + need(hist==rhist==expected and add_frames==radd_frames,'complete forward/inverse frame invoice') + need(sum(k*v for k,v in hist.items())==5097==sum(dims[f] for f in program['final'])-sum(dims[f] for f in program['start']),'rank mass equals chronological frame progress') + need(add_frames[0]==5758 and add_frames[1]==4147 and sum(v for f,v in add_frames.items() if f not in (0,1))==3027,'correct old intermediate-frame ADD scope') + need(all(r[4]==1 for r in correction),'all new compensation atFULL') + ident8=ident(8);ident16=ident(16);DI=exchange(ident8) + projectors=[];lift_hashes=[];native_rows=[] + for p,q in enumerate(roots): + need(sum(x*x for x in q)==4,'actual root norm4') + P=[[Q(x*y,4) for y in q] for x in q] + C=[[Q(i==j)-P[i][j] for j in range(8)] for i in range(8)] + start=geometry['frames'][program['start'][p]] + cap=geometry['frames'][base['final'][V+p]] + need(qrank([roots[i] for i in start])==1 and all(multiply(P,[[x] for x in roots[i]])==[[Q(x)] for x in roots[i]] for i in start),'actual source entrance line projector') + need(qrank([roots[i] for i in cap])==7 and all(sum(x*y for x,y in zip(q,roots[i]))==0 for i in cap),'actual target cap projector') + need(multiply(P,P)==P and qrank(P)==1 and qrank(C)==7,'dyadic complementary projectors') + DP,DC=exchange(P),exchange(C) + need(multiply(DI,DP)==DC and multiply(DP,DP)==ident16,'inherited cap ADDRESS identities') + need(multiply(DI,DC)==DP,'new rank1 cap-to-FULL ADDRESS identity') + projectors.append(dyadic_hash(P));lift_hashes.append(dyadic_hash(DP)) + # q has coordinates 0,+/-1,+/-2 and norm4, so P is nonzero rank1 + # in every odd characteristic. The factor q/4 times q^T has trace1. + need(all(abs(x)<=2 for x in q) and any(x for x in q),'odd-characteristic rank1 factor') + native_rows.append({'port':p,'source_rank':7,'target_rank':8,'lift_rank':1}) + need(projectors==receipt['actual_address_projectors'] and lift_hashes==receipt['new_target_lift_ADDRESS_sha256'],'all111 projector and1776 new ADDRESS-column hashes') + need(V*(7+8)+429*8==5097,'complete local native progress; zero excess') + print('PASS independent exact frame chronology and5328 dyadic ADDRESS columns',flush=True) + # Semantic controls: mutate the executed word, then check actual consequences. + scatter=next(i for i,r in enumerate(records) if r[5]==52) + bad_scatter,_,_,_=replay(records[:scatter]+records[scatter+1:]) + need(parity(bad_scatter)!=parity(forward),'omitted scatter changes binary endpoint') + unprepare=next(i for i,r in enumerate(records) if r[5]==53) + bad=[r[:] for r in records];bad[unprepare][3]*=-1 + wrong_sign,_,_,_=replay(bad) + need(wrong_sign[:V]!=forward[:V] and parity(wrong_sign)==parity(forward),'wrong unprepare breaks signed source restoration despite identical parity') + lift=next(i for i,r in enumerate(records) if r[0]==0 and r[1]==V and r[5]==42) + try:native_frames(records[:lift]+records[lift+1:],program,geometry,dims) + except ValueError as error:lift_rejection=str(error) + else:raise ValueError('missing target lift escaped') + need(lift_rejection=='ADD actual common frame','missing lift fails at a real native ADD') + # Postcompose y <- y-x. Over F2 this diagonalizes the physical block; + # overZ it intentionally retains the even residual rather than hiding it. + diagonalized=[row[:] for row in forward] + for p in range(V):diagonalized[V+p]=[x-y for x,y in zip(diagonalized[V+p],diagonalized[p])] + need(parity(diagonalized)==[1< (x,y+A*x+E*h,h), A=I mod2, E=0 mod2; A and E are fully computed, nontrivial signed integer matrices.', + 'even_residual_samples':residue_samples,'source_restored_over_Z':111,'helpers_restored_in_logical_coordinates_over_Z':429, + 'literal_inverse_all_integer_columns':True,'exact_signed_prefix_row_L1':[pf,pb],'first_maximum_witnesses':[wf,wb], + 'ADD_count':12932,'MOVE_count':2984,'new_compensation_ADDs':1555,'new_target_lifts':111, + 'profile':dict(hist),'rank_mass':5097,'frame_chronology_sha256':[fh,bh], + 'ADD_frame_counts':{'ZERO':5758,'FULL':4147,'other':3027,'distinct_frames':len(add_frames)}, + 'new_compensation_frame':'FULL','private_fields':0,'COPY_ERASE_records':0, + 'old_projector_ADDRESS_columns':3552,'new_lift_ADDRESS_columns':1776,'all111_exact_projector_hashes':projectors,'all111_lift_hashes':lift_hashes, + 'controls':{'omitted_scatter_binary_failure':True,'wrong_unprepare_integer_failure_parity_unchanged':True,'omitted_lift':lift_rejection}, + 'physical_boundary':'Under inherited native MOVE/frame realization over binary VALUES, source S=F8*D_P, target T=F8, data block [[S,0],[S,T]], helpers F8*d. Logical integer helper identity is not physical identity.', + 'paid_diagonalization_ADDs':111,'paid_diagonalized_total_ADDs':13043,'diagonalized_binary_endpoint':True,'integer_identity_after_diagonalization':False, + 'native_progress':V*15+429*8,'no_new_kappa':True, + 'scope':['The frozen final word is consumed directly; no producer or producer utility is imported.', + 'Old internal native MOVE implementations and compiler guards remain inherited premises; their all-modulus implementation is not independently replayed.', + 'Dyadic ADDRESS equalities hold in every odd field; VALUE additions and integer scalar normalization are distinct layers.', + 'Prefix874 is a signed scalar bound, not a rounded precision or child-defect theorem.', + 'No global caller, owner chronology, physical source access, tape realization or stronger multiplication theorem is admitted.'], + 'historical_receipt_correction':'Its allsize_lift sentence saying every scalar ADD is atZERO/FULL is false. Every ADD is at its actual common frame; only all newly added nine-total compensation ADDs are atFULL.'} + out=json.loads(json.dumps(out)) + path=HERE/'RESULT.json' + if args.write:path.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n') + else:need(json.loads(path.read_text())==out,'independent complete receipt differs') + print(out['status']) + +if __name__=='__main__':main() diff --git a/research/r429-full-target-interface/frozen/upstream/research/bit-r438-transport-rehost/verify_rehost.py b/research/r429-full-target-interface/frozen/upstream/research/bit-r438-transport-rehost/verify_rehost.py new file mode 100644 index 0000000000..58c76b9d7b --- /dev/null +++ b/research/r429-full-target-interface/frozen/upstream/research/bit-r438-transport-rehost/verify_rehost.py @@ -0,0 +1,770 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Window-respecting optimal re-hosting of the R438 bit hosting slack (bit headroom only; no new kappa). + +PR1043 (aliromman) removes helper470 from the PR589 R439 bit word. Its hosting_change folds the nine freed width-8 +slots back into their own hosts in every replica and runs no hosting search. With 438 helpers the PR1023 slot model +has 3996 - 9*438 = 54 width-8 units of slack per replica instead of 45. This script: + + 1. DP. Proves the unique moment-minimising no-bank slot layout for S = 54 at the certified grid point. It uses an + exact top-3 interval DP over (capacity, unused units) built on PR1023's g_interval. An independent branch-and-bound + enumeration over all 10,556,685 layouts (sorted lists, provably skipped tails) cross-checks it, and the runner-up gap is reported as a certified interval. + S = 45 (R439) is a positive control: it reproduces the PR589 selection and PR1023's own width8_optimality. + 2. Windows. Checks every stage-window-feasible split of the optimum's slack over children 4 and 6 with seed72's + maxflow_assign and an independent all-subsets Hall test. + 3. Placement. Builds an explicit placement of all 9*438 helper occurrences per replica with seed14's allocate + (R = 438). It must equal PR442's deterministic expander, and it is audited by seed14's placement_audit and by an + independent audit. All 32 replica owner maps are also checked. + 4. Endpoints. Certifies bit endpoints with PR1023's packing.endpoint, using both pinned engines and the inherited + surcharge. The idle profile is combined with (a) PR1043's R438 local profile and (b) the transported-word profile + (declared input). PR589's c and PR1043's own c, with its own hosting, are reproduced as positive controls. +Negative controls (mutations that must be rejected) are run for every part. + +Usage: python3 -I -B verify_rehost.py [--repo ROOT] [--out RECEIPT.json] [--check RECEIPT.json] +The last line printed is PASS_R438_WINDOW_REHOST ... or FAIL_R438_WINDOW_REHOST ... +Standard-library CPython only. Inputs come from the repository working tree (sha256 and git-blob pinned) and from +vendor/pr1043 (byte copy, sha256 and git-blob pinned). +""" +import argparse +import hashlib +import json +import os +import sys +import time +import types +from collections import Counter +from fractions import Fraction as Q + +TAG = 'R438_WINDOW_REHOST' +HERE = os.path.dirname(os.path.abspath(__file__)) +DEFAULT_REPO = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +# Main-tree inputs, read from --repo and pinned by sha256 and git blob id. The blob ids are those at canonical main +# 0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2 (the research base of this script). +PINS = { + 'research/bit589-width-packing/packing.py': + ('2bb5515807714807961289e4ee6958c3ad7e0c27bbec4d9212b138c662a6cc7b', 'a6079ee0dd4d8037be477a3c4497f472348bde07'), + 'research/bit589-width-packing/SOURCES.json': + ('53fe98c8f01de7e32e3110e591d62e60292abb38cc11ecde4839f2eebd3b5fbc', 'f6a97de32691a1d426ac4819aad24c0c8414d97e'), + 'research/e8-bit-p111-tuned/tune/EXPECTED.json': + ('b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4', 'e293ddc557742637f9f679f083a1a282d87b1b13'), + 'research/e8-bit-p111-tuned/data/selection9-p111.json': + ('4ab1ed4529683cd184987f8bc3031fb7408b9cd22c25ab9cf541a8aaf896eaf1', 'e69ea66a3add357f570fc5552ab6368b3c8f9bb2'), + 'research/native-complex-moment552/engines/moment.py': + ('81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482', '7d697cb45203fe72d97037403d6da41f71f3b7fd'), + 'research/native-complex-moment552/engines/base_two_moment.py': + ('aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098', '14a90fa0e788217856f070382c9e61bd7c603c61'), + 'research/native-complex-moment552/engines/outer.py': + ('c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c', '43007488ad2c43187c77cc6798beff8b1cd76ad2'), + 'research/bit589-width7-windows-seed72/verify.py': + ('a5341ed222af84b51cd18645dd6b23e4613c0275cbf2663c94b07a9f916e9e60', '7f79a47146b150c9446e5f45e401d70b5cd12427'), + 'research/bit589-width7-windows-seed72/wopt.py': + ('a72daf1c7cff422543371a220fd391fe3b33552ac6ed52763f50b0c2f93d9532', '4e0bd3704d1a2be460ed25b363e95918119e8d42'), + 'research/bit589-width7-windows-seed72/windows.py': + ('a24295a51333b168ab73215f8a4bbb5bf831be829f572d1cde15fc322049c635', '4bb4f075ad5c1a49b4af310094bde6b2a4ea0c2e'), + 'research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/idle-axis-hosting/hosting_core.py': + ('d8b90cd5d152df3c7c351230863d9e61816ad5e1f21d69bea1a86a5daad559a3', '68b536daa9e6546c0aa046934bf840aaa3c3fde3'), + 'research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/audit_hosted_k.py': + ('57e558c80a2fea6e291587b04afd76dfaee3550729997798b61f33daf90b8ec9', '8864ca9b942a3507171edca0cf6cbaaf10fcf434'), + 'research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py': + ('6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8', '3df12bd632f1fdba825ced57110a1fee82eb2857'), + 'research/bit-helper470-window-placement-seed14/verify.py': + ('9cceeb610eccd6171585b056020ab6c44d7428de403a9ed035be1df9ae63f55b', 'c716a44e3b920f91918903d3480560e3882fbe80'), +} +# Vendored byte copies (see vendor/pr1043/NOTICE.md). +VENDOR = { + 'vendor/pr1043/CERTIFICATE.json': dict( + sha256='32c6cd6103006d627909cabdaf5083238c661a6582016a8b21075bd01c892eff', + git_blob='56400920050c523e6e399f2455137b36c35cf528', + origin='PR1043 (Ali Romman, @aliromman) head e309e17f83f5759b1ea1fa24a76f24838784cb4d, ' + 'research/bit-boundary-persistence/CERTIFICATE.json'), +} + +T, STAGES, M, V = 32, 9, 64, 111 +COPIES = 2 * V +GRID = Q(1, 10 ** 24) +C0_DECIMAL = '0.001733427039589844234749' # PR589 R439 selected bit endpoint +PR1043_DECIMAL = '0.001734176288479865766692' # PR1043's claimed R438 endpoint (own in-place hosting) +SCOUT_A = '0.001734802047828389852783' # predicted endpoint (a); checked, not assumed +SCOUT_B = '0.001734846264120199151475' # predicted endpoint (b); checked, not assumed +# (b) is a declared input here: the paid local profile of the R438 word after one A-transport (op 2027 -> slot 154 at +# frame 79, a PR1345 transport-atlas move on PR1043's word). verify_transport.py in this package rebuilds and replays +# that word and recounts this profile; this script only checks its rank mass and child count. +LOCAL_B = {1: 1322, 2: 1342, 3: 79, 4: 44, 5: 102, 6: 11, 7: 18} +# Number of layouts = coefficient of x^S in 1/(1-x) * 1/((1-x)(1-x^2)(1-x^3)) * 1/((1-x)...(1-x^5)) (classes 14/28/42). +EXPECTED_LAYOUTS = {45: 3160688, 54: 10556685} + + +class Fail(Exception): + pass + + +def require(ok, message): + if not ok: + raise Fail(message) + + +def git_blob(raw): + return hashlib.sha1(b'blob %d\0' % len(raw) + raw).hexdigest() + + +def check_pin(raw, sha, blob, label): + require(hashlib.sha256(raw).hexdigest() == sha, 'sha256 pin: ' + label) + require(git_blob(raw) == blob, 'git blob pin: ' + label) + + +def read_pinned(base, rel, sha, blob): + path = os.path.join(base, *rel.split('/')) + with open(path, 'rb') as handle: + raw = handle.read() + check_pin(raw, sha, blob, rel) + return path, raw + + +def load_module(name, path, raw): + """Execute the already pinned bytes as a module (no second read of the file).""" + module = types.ModuleType(name) + module.__file__ = path + sys.modules[name] = module + exec(compile(raw, path, 'exec'), module.__dict__) + return module + + +def grid_decimal(c): + n = c * 10 ** 24 + require(n.denominator == 1 and n.numerator > 0, 'value on the 1e-24 grid') + s = str(n.numerator).rjust(25, '0') + return s[:-24] + '.' + s[-24:] + + +def fixed(k, n): + sign = '-' if k < 0 else '' + s = str(abs(k)).rjust(n + 1, '0') + return sign + s[:-n] + '.' + s[-n:] + + +def dfloor(x, n=36): + return fixed((x.numerator * 10 ** n) // x.denominator, n) + + +def dceil(x, n=36): + return fixed(-((-x.numerator * 10 ** n) // x.denominator), n) + + +def keyed(hist): + return {str(r): n for r, n in sorted(hist.items()) if n} + + +def unkeyed(hist): + return {int(r): n for r, n in hist.items()} + + +def expect_reject(controls, name, fn, needle, exc=(Exception,)): + """A negative control: fn must raise, with `needle` in the message.""" + try: + fn() + except exc as e: # noqa: PERF203 + message = '%s: %s' % (type(e).__name__, e) + require(needle in str(e), 'control %s rejected for the wrong reason: %s' % (name, message)) + controls.append(dict(name=name, rejected=True, reason=message)) + return + raise Fail('negative control %s was accepted' % name) + + +# --------------------------------------------------------------------------------------------------------------------- +# 1. Slot layouts: exact interval DP and independent exhaustive enumeration. + +def layout_terms(P, slots, c): + """Moves (capacity, u): one slot of that capacity keeps u unused width-8 places. Every capacity has a positive + remainder mod 8, so each slot has exactly one idle child whatever it hosts and the per-child surcharge is the same + for all layouts. The idle cost of a layout is then sum_slots g(remainder), g(r) = r (64/r)^c. Returns the moves, + certified lower and upper bounds of each move's cost change, and the g intervals.""" + rmin = {cap: cap % 8 for cap in slots} + require(all(rmin[cap] > 0 for cap in slots), 'some capacity is divisible by 8') + G = {} + caps = sorted(cap for cap in slots if cap // 8) + for cap in sorted(slots): + for u in range(cap // 8 + 1): + r = rmin[cap] + 8 * u + if r not in G: + G[r] = P.g_interval(r, c) + require(G[r][0] <= G[r][1], 'g interval order') + moves = [(cap, u) for cap in caps for u in range(1, cap // 8 + 1)] + lo = {mv: G[rmin[mv[0]] + 8 * mv[1]][0] - G[rmin[mv[0]]][1] for mv in moves} + hi = {mv: G[rmin[mv[0]] + 8 * mv[1]][1] - G[rmin[mv[0]]][0] for mv in moves} + return moves, lo, hi, G, rmin + + +def topk_dp(moves, lo, S, K): + """Top-K coin-change DP over move types in a fixed order. Each count vector arises on exactly one path, and the + top-K of a union of shifted top-K lists is exact, so this returns the K smallest layout lower bounds exactly.""" + best = [[(Q(0), ())]] + [[] for _ in range(S)] + for mv in moves: + u = mv[1] + new = [list(b) for b in best] + for s in range(u, S + 1): + for k in range(1, s // u + 1): + for v, lay in best[s - k * u]: + new[s].append((v + k * lo[mv], lay + ((mv, k),))) + best = [sorted(b)[:K] for b in new] + return [(v, tuple(sorted(lay))) for v, lay in best[S]] + + +def exhaustive_topk(moves, lo, S, K, dyad): + """Independent check: enumerate every layout as one multiset of unused counts per capacity class, with exact + integer costs (all bounds are multiples of 1/dyad). Branch-and-bound on per-class lists sorted by cost. + Returns the K smallest and the number of layouts covered.""" + ilo = {} + for mv in moves: + x = lo[mv] * dyad + require(x.denominator == 1, 'dyadic bound') + ilo[mv] = x.numerator + caps = sorted({cap for cap, _ in moves}) + tables = {} + for cap in caps: + umax = max(u for c, u in moves if c == cap) + table = {U: [] for U in range(S + 1)} + + def parts(rem, largest, acc, cost, cap=cap, table=table): + if rem == 0: + return + for u in range(min(largest, rem), 0, -1): + for k in range(1, rem // u + 1): + acc2 = acc + (((cap, u), k),) + cost2 = cost + k * ilo[(cap, u)] + used = sum(uu * kk for (_, uu), kk in acc2) + table[used].append((cost2, tuple(sorted(acc2)))) + parts(rem - k * u, u - 1, acc2, cost2) + table[0].append((0, ())) + parts(S, umax, (), 0) + for U in table: + table[U].sort() + tables[cap] = table + top = [] # sorted list of (cost, layout), at most K + covered = 0 + + def walk(i, rem, base, lay): + nonlocal covered + if i == len(caps) - 1: + lst = tables[caps[i]][rem] + covered += len(lst) + for cost, sub in lst: + v = base + cost + if len(top) == K and v > top[-1][0]: + break + top.append((v, tuple(sorted(lay + sub)))) + top.sort() + del top[K:] + return + for U in range(rem + 1): + for cost, sub in tables[caps[i]][U]: + walk(i + 1, rem - U, base + cost, lay + sub) + walk(0, S, 0, ()) + return [(Q(v, dyad), lay) for v, lay in top], covered + + +def idle_of(slots, rmin, layout): + h = Counter() + for cap, n in slots.items(): + h[rmin[cap]] += n + for (cap, u), k in layout: + h[rmin[cap]] -= k + h[rmin[cap] + 8 * u] += k + require(h[rmin[cap]] >= 0, 'more modified slots than slots') + return Counter({r: n for r, n in h.items() if n}) + + +def gap_interval(G, worse, better): + """Certified interval of sum g(worse) - sum g(better) for two idle histograms.""" + d = Counter(worse) + d.subtract(better) + lo = hi = Q(0) + for r, n in d.items(): + if n > 0: + lo += n * G[r][0] + hi += n * G[r][1] + elif n < 0: + lo += n * G[r][1] + hi += n * G[r][0] + return lo, hi + + +def layout_name(layout): + return ' + '.join('%dx(%d,%d)' % (k, cap, u) for (cap, u), k in sorted(layout, key=lambda t: (-t[1], t[0]))) + + +def certify_optimum(P, slots, S, c_star, W, check_exhaustive, dp_drop=()): + moves, lo, hi, G, rmin = layout_terms(P, slots, c_star) + require(S <= min(n for cap, n in slots.items() if cap // 8), 'slot-count limits are not vacuous') + top = topk_dp([mv for mv in moves if mv not in dp_drop], lo, S, 3) # dp_drop: negative control only + require(len(top) == 3, 'fewer than three layouts') + covered = None + if check_exhaustive: + top2, covered = exhaustive_topk(moves, lo, S, 3, P.MOMENT.DYAD) + require([v for v, _ in top2] == [v for v, _ in top], 'exhaustive enumeration disagrees with the DP (values)') + require([lay for _, lay in top2[:2]] == [lay for _, lay in top[:2]], + 'exhaustive enumeration disagrees with the DP (layouts)') + (l_opt, opt), (l_run, run), (l_third, third) = top + + def upper(lay): + return sum((k * hi[mv] for mv, k in lay), Q(0)) + require(l_run > upper(opt), 'optimum is not certified unique') + require(l_third > upper(run), 'runner-up is not certified') + idle_opt, idle_run = idle_of(slots, rmin, opt), idle_of(slots, rmin, run) + g_lo, g_hi = gap_interval(G, idle_run, idle_opt) + require(g_lo > 0, 'runner-up gap not positive') + return dict(c_star=c_star, opt=opt, run=run, third=third, opt_lo=l_opt, run_lo=l_run, idle_opt=idle_opt, + idle_run=idle_run, G=G, rmin=rmin, lo=lo, hi=hi, gap=(g_lo, g_hi), covered=covered, + receipt=dict(c_star=grid_decimal(c_star), slack_units=S, optimum=layout_name(opt), + optimum_idle_per_replica=keyed(idle_opt), runner_up=layout_name(run), + runner_up_idle_per_replica=keyed(idle_run), third=layout_name(third), + runner_up_gap_sum_g_per_replica=[dfloor(g_lo), dceil(g_hi)], + runner_up_gap_moment=[dfloor(T * g_lo / (M * W), 40), dceil(T * g_hi / (M * W), 40)], + exhaustive_layouts_covered=covered)) + + +def claim_is_optimal(cert, claimed): + """True iff `claimed` is certified strictly cheaper than every other layout (uses the certified top-3).""" + upper = sum((k * cert['hi'][mv] for mv, k in claimed), Q(0)) + others = [v for v, lay in ((cert['opt_lo'], cert['opt']), (cert['run_lo'], cert['run'])) if lay != claimed] + return all(v > upper for v in others) + + +# --------------------------------------------------------------------------------------------------------------------- +# 2. Stage windows. + +def hall_check(supply, demand, allowed): + """All-subsets Hall test for the stage -> child transport (independent of max-flow).""" + kids = [i for i in sorted(demand) if demand[i]] + if sum(supply.values()) != sum(demand.values()): + return False, 'totals differ' + for mask in range(1, 1 << len(kids)): + C = [kids[j] for j in range(len(kids)) if mask >> j & 1] + nbr = set() + for i in C: + nbr |= set(allowed[i]) + if sum(demand[i] for i in C) > sum(supply.get(s, 0) for s in nbr): + return False, 'children %s' % C + return True, None + + +def demand_for(config): + """config = (idle copies of child 4, child holding the one-residual copy); the other 10 - x4 idle copies are in + child 6. Children 0, 2, 7, 8 stay full; children 1, 3, 5 (capacity 7) host nothing.""" + x4, partial = config + d = {0: COPIES * 1, 1: 0, 2: COPIES * 3, 3: 0, 5: 0, 7: COPIES * 3, 8: COPIES * 1} + for child, idle in ((4, x4), (6, 10 - x4)): + part = 1 if partial == child else 0 + d[child] = 5 * (COPIES - idle - part) + part + return d + + +# --------------------------------------------------------------------------------------------------------------------- +# 3. Independent placement audit (mirrors the slot rules of audit_hosted_k, written without its code). + +def audit_slots(slots, hosting, active, R): + cells, seen = {}, set() + for i, cp, off, w, s, h in slots: + require(i in hosting, 'unknown host child') + pair, cap, stages = hosting[i] + require(s in stages, 'stage outside window') + require(pair != active[s], 'host pair active at stage') + require(0 <= cp < COPIES and 0 <= h < R and 0 <= s < STAGES, 'index domain') + require(w == 8, 'residual width') + require(0 <= off and off + w <= cap, 'slot extent') + occ = cells.setdefault((i, cp), set()) + new = set(range(off, off + w)) + require(not occ & new, 'cell collision') + occ |= new + require((s, h) not in seen, 'duplicate (stage, helper)') + seen.add((s, h)) + require(seen == {(s, h) for s in range(STAGES) for h in range(R)}, 'missing (stage, helper)') + rem = Counter() + for i, (pair, cap, stages) in hosting.items(): + for cp in range(COPIES): + r = cap - len(cells.get((i, cp), ())) + if r: + rem[r] += 1 + return rem + + +def main(args): + t0 = time.time() + repo = os.path.abspath(args.repo) + raw = {} + for rel, (sha, blob) in PINS.items(): + raw[rel] = read_pinned(repo, rel, sha, blob) + vend = {} + for rel, pin in VENDOR.items(): + vend[rel] = read_pinned(HERE, rel, pin['sha256'], pin['git_blob'])[1] + P = load_module('r438_packing', *raw['research/bit589-width-packing/packing.py']) + S72 = load_module('r438_seed72_verify', *raw['research/bit589-width7-windows-seed72/verify.py']) + S14 = load_module('r438_seed14_verify', *raw['research/bit-helper470-window-placement-seed14/verify.py']) + HC = load_module('r438_pr442_hosting_core', *raw['research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/' + 'vendor/idle-axis-hosting/hosting_core.py']) + cert = json.loads(vend['vendor/pr1043/CERTIFICATE.json']) + controls = [] + pin = VENDOR['vendor/pr1043/CERTIFICATE.json'] + tampered = vend['vendor/pr1043/CERTIFICATE.json'].replace(b'"1": 1321', b'"1": 1320', 1) + require(tampered != vend['vendor/pr1043/CERTIFICATE.json'], 'tamper control setup') + expect_reject(controls, 'vendored_pr1043_certificate_tampered', + lambda: check_pin(tampered, pin['sha256'], pin['git_blob'], 'vendor/pr1043/CERTIFICATE.json'), + 'sha256 pin') + out = dict(status='PASS_' + TAG, scope='bit headroom only; no new kappa; the selected record is complex-bound; every R438 row is conditional on PR1043 (open, not admitted); row (b) also on the transported word of verify_transport.py', + inputs=dict(main_tree={rel: dict(sha256=s, git_blob=b) for rel, (s, b) in sorted(PINS.items())}, + vendored={rel: dict(sha256=p['sha256'], git_blob=p['git_blob'], origin=p['origin']) + for rel, p in VENDOR.items()})) + + # -- 0. Baseline binding: PR589 record, PR1023 slot model, PR1043 certificate. ------------------------------------ + record = P.pinned_json('bit_record') + selection = P.pinned_json('selection') + model = P.slot_model(record, selection) + W = record['nine']['bit']['live'] + require((model['R'], model['v'], W, model['calls']) == (439, V, 28416, STAGES * T), 'PR589 record dimensions') + c0 = Q(record['nine']['bit_lower']) + require(grid_decimal(c0) == C0_DECIMAL, 'PR589 bit endpoint') + local439 = Counter(model['local']) + require(unkeyed(cert['local']['baseline']['profile']) == dict(local439), 'PR1043 baseline local = PR589 record') + require(unkeyed(cert['hosted']['baseline']['invoice']['bit_profile']) == dict(model['H']), + 'PR1043 baseline hosted profile = PR589 record') + require(Q(cert['hosted']['baseline']['invoice']['bit_lower']) == c0, 'PR1043 baseline c = PR589 c') + local_a = Counter(unkeyed(cert['local']['candidate']['profile'])) + require(cert['local']['candidate']['helpers'] == 438 and cert['hosted']['candidate']['invoice']['R'] == 438, 'R438') + d = Counter(local_a) + d.subtract(local439) + require(+d == Counter({2: 2}) and -d == Counter({1: 2, 3: 1, 7: 1}), 'PR1043 local delta {1:-2,2:+2,3:-1,7:-1}') + for name, loc in (('a', local_a), ('b', Counter(LOCAL_B))): + require(sum(r * n for r, n in loc.items()) == 8 * 438 + 63 + 14 * V == 5121, 'local rank mass (%s)' % name) + require(sum(loc.values()) == 2918, 'local child count (%s)' % name) + + # -- 1. Windows and slots. --------------------------------------------------------------------------------------- + WIN72 = S72.WIN # global_k anchor + three window predicates (seed72 windows.py) + win14 = S14.windows(S14.schedule()) # seed14's independent transcription: {idx: (pair, rank, stages)} + require(set(WIN72) == {i for i, (p, r, st) in win14.items() if r and st}, 'hosting children agree') + require(all(win14[i][1:] == (WIN72[i][0], tuple(WIN72[i][1])) for i in WIN72), 'seed72 and seed14 windows agree') + require({i: c for i, (c, st) in WIN72.items()} == model['caps'], 'window capacities = PR1023 slot capacities') + hosting = {i: (win14[i][0], WIN72[i][0], tuple(WIN72[i][1])) for i in sorted(WIN72)} + sched72 = S72.wopt.windows.schedule() + active = {e['stage']: e['pair'] for e in sched72 if e['kind'] == 'local_cover_sweep'} + require(sorted(active) == list(range(STAGES)), 'one local sweep per stage') + slots = Counter() + for i, (c, st) in WIN72.items(): + slots[c] += COPIES + require(slots == model['slots'] == Counter({7: 666, 14: 444, 28: 444, 42: 444}), 'slots per replica') + units = sum((c // 8) * n for c, n in slots.items()) + S439, S438 = units - STAGES * 439, units - STAGES * 438 + require((units, S439, S438) == (3996, 45, 54), 'width-8 slack per replica') + out['windows'] = {str(i): dict(pair=p, capacity=c, stages=list(st)) for i, (p, c, st) in hosting.items()} + out['slots_per_replica'] = keyed(slots) + out['width8_units_per_replica'] = dict(capacity=units, slack_R439=S439, slack_R438=S438) + + # -- 4a. Endpoint positive controls (needed for the DP grid points). --------------------------------------------- + def profile(local, idle): + H = Counter({r: n * STAGES * T for r, n in local.items()}) + for r, n in idle.items(): + H[r] += n * T + require(all(n > 0 for n in H.values()), 'positive profile entries') + return dict(sorted(H.items())) + + def price(local, idle, label): + H = profile(local, idle) + require(sum(r * n for r, n in H.items()) == 1808352, 'hosted rank mass (%s)' % label) + require(M * M > 2 * max(H) ** 2, 'halving guard (%s)' % label) + return P.endpoint(H, W), H + + c_pr589, H_pr589 = price(local439, model['idle_rep'], 'pr589') + require(c_pr589 == c0 and H_pr589 == dict(model['H']), 'positive control: PR589 endpoint reproduced') + # PR1043's own hosting_change, re-derived from the frozen selection with seed14's allocate (R = 439). + alloc439 = S14.allocate(selection['bit']) + removed = [list(x) for x in alloc439 if x[5] == 470 - 2 * V] + require(removed == cert['hosting_change']['removed_slots'], 'PR1043 removed slots re-derived') + rem439, _ = S14.placement_audit(alloc439, win14, frozenset()) + rem_inplace = Counter(rem439) + for i, cp, off, w, s, h in removed: + rem_inplace[(i, cp)] += w + idle_pr1043 = Counter(r for r in rem_inplace.values() if r) + require(dict(idle_pr1043) == unkeyed(cert['hosting_change']['new_remainders']), 'PR1043 in-place remainders') + require(Counter(r for r in rem439.values() if r) == model['idle_rep'], 'PR589 remainders from seed14 allocate') + c_pr1043, H_pr1043 = price(local_a, idle_pr1043, 'pr1043') + require(H_pr1043 == unkeyed(cert['hosted']['candidate']['invoice']['bit_profile']), 'PR1043 hosted profile') + require(c_pr1043 == Q(cert['hosted']['candidate']['invoice']['bit_lower']), 'PR1043 endpoint (certificate)') + require(grid_decimal(c_pr1043) == PR1043_DECIMAL, 'positive control: PR1043 endpoint reproduced') + + # -- 1. Exact DP. S = 45 positive control, then S = 54. -------------------------------------------------------- + c0_star = c0 + GRID + cert45 = certify_optimum(P, slots, S439, c0_star, W, check_exhaustive=True) + require(cert45['covered'] == EXPECTED_LAYOUTS[45], 'exhaustive enumeration covered every S = 45 layout') + require(cert45['opt'] == (((42, 5), 9),), 'S = 45 optimum is nine fully idle 42-slots') + require(cert45['idle_opt'] == model['idle_rep'], 'S = 45 optimum = PR589 selected remainders') + pr1023 = P.width8_optimality(model, c0_star) # PR1023's own per-unit certificate (hard-coded slack 45) + require(pr1023['runner_up'] == 'capacity 42, u = 4' and pr1023['slack_units_per_replica'] == 45, 'PR1023 replay') + + # The PR1023 per-unit argument cannot be reused at R438: its hard-coded slack 45 rejects the R438 model. + model438 = dict(model, R=438, idle_rep=Counter({2: 433, 4: 444, 6: 444, 7: 666, 42: 10, 34: 1})) + expect_reject(controls, 'pr1023_width8_optimality_hardcoded_45_rejects_R438', + lambda: P.width8_optimality(model438, c0_star), 'slack per replica') + + # Endpoint candidates (a) and (b): the DP optimum is computed at each one's own next grid point. + rows = {} + certs = {} + # Candidate layout: the S = 54 DP optimum at c0 + 1e-24. It is priced with each local profile, and the DP is then + # re-certified at that profile's own next grid point, where it must return the same layout. + candidate = certify_optimum(P, slots, S438, c0_star, W, check_exhaustive=False)['idle_opt'] + for name, local, scout in (('a', local_a, SCOUT_A), ('b', Counter(LOCAL_B), SCOUT_B)): + idle = candidate + c, H = price(local, idle, name) + cs = certify_optimum(P, slots, S438, c + GRID, W, check_exhaustive=True) + require(cs['covered'] == EXPECTED_LAYOUTS[54], 'exhaustive enumeration covered every S = 54 layout (%s)' % name) + require(cs['idle_opt'] == idle, 'DP optimum at c + 1e-24 is the priced layout (%s)' % name) + require(grid_decimal(c) == scout, 'scouting endpoint (%s) reproduced' % name) + certs[name] = cs + rows['r438_window_optimum_local_' + name] = dict(endpoint=grid_decimal(c), endpoint_fraction=str(c), + profile=keyed(H), children=sum(H.values()), + rank_mass=sum(r * n for r, n in H.items())) + rows['r438_window_optimum_local_' + name]['_c'] = c + ca = rows['r438_window_optimum_local_a'].pop('_c') + cb = rows['r438_window_optimum_local_b'].pop('_c') + require(certs['a']['opt'] == (((42, 4), 1), ((42, 5), 10)), 'R438 optimum = 10 fully idle 42-slots + one (42,4)') + require(certs['a']['run'] == (((14, 1), 1), ((28, 3), 1), ((42, 5), 10)), 'R438 runner-up') + require(dict(certs['a']['idle_opt']) == {2: 433, 4: 444, 6: 444, 7: 666, 42: 10, 34: 1}, 'R438 idle profile') + c_b_inplace, _ = price(Counter(LOCAL_B), idle_pr1043, 'b_inplace') + c_run_a, _ = price(local_a, certs['a']['idle_run'], 'runner_up_a') + require(c_pr1043 < c_run_a < ca, 'runner-up layout endpoint lies between PR1043 and the optimum') + rows['r438_runner_up_layout_local_a'] = dict(endpoint=grid_decimal(c_run_a), layout=layout_name(certs['a']['run'])) + rows['pr589_r439_selected'] = dict(endpoint=grid_decimal(c0), profile=keyed(H_pr589)) + rows['pr1043_r438_inplace_local_a'] = dict(endpoint=grid_decimal(c_pr1043), profile=keyed(H_pr1043), + children=sum(H_pr1043.values())) + rows['pr1043_r438_inplace_local_b'] = dict(endpoint=grid_decimal(c_b_inplace)) + for key, c in (('r438_window_optimum_local_a', ca), ('r438_window_optimum_local_b', cb), + ('pr1043_r438_inplace_local_b', c_b_inplace), ('r438_runner_up_layout_local_a', c_run_a)): + rows[key]['gain_vs_pr1043_percent'] = dfloor(100 * (c - c_pr1043) / c_pr1043, 8) + rows[key]['gain_vs_pr589_percent'] = dfloor(100 * (c - c0) / c0, 8) + + # PR1043's in-place layout, as a layout: certified strictly worse than the optimum at c_a + 1e-24. + ca_cert = certs['a'] + lay1043 = (((14, 1), 1), ((28, 1), 3), ((42, 1), 5), ((42, 5), 9)) + require(idle_of(slots, ca_cert['rmin'], lay1043) == idle_pr1043, 'PR1043 layout = its in-place remainders') + g1043 = gap_interval(ca_cert['G'], idle_pr1043, ca_cert['idle_opt']) + require(g1043[0] > 0, 'PR1043 in-place layout is strictly worse than the optimum') + require(claim_is_optimal(ca_cert, ca_cert['opt']), 'the optimum certifies') + expect_reject(controls, 'dp_with_move_42_4_dropped_vs_exhaustive', + lambda: certify_optimum(P, slots, S438, ca + GRID, W, check_exhaustive=True, dp_drop=((42, 4),)), + 'exhaustive enumeration disagrees with the DP') + expect_reject(controls, 'runner_up_claimed_optimal', + lambda: require(claim_is_optimal(ca_cert, ca_cert['run']), 'claimed optimum not certified'), + 'claimed optimum not certified') + expect_reject(controls, 'pr1043_inplace_layout_claimed_optimal', + lambda: require(claim_is_optimal(ca_cert, lay1043), 'claimed optimum not certified'), + 'claimed optimum not certified') + bad_idle = Counter(ca_cert['idle_opt']) + bad_idle[34] -= 1 + bad_idle[2] += 1 # silently host the four missing residuals: mass must change + expect_reject(controls, 'optimum_profile_with_partial_slot_dropped', lambda: price(local_a, +bad_idle, 'bad'), + 'hosted rank mass') + for name, c in (('a', ca), ('b', cb)): + H = profile(local_a if name == 'a' else Counter(LOCAL_B), certs[name]['idle_opt']) + + def accept_next(H=H, c=c): + lo, hi = P.MOMENT.moment(H, M, W, c + GRID, True) + require(hi < 1, 'moment at c + 1e-24 is not below one') + expect_reject(controls, 'endpoint_plus_1e-24_accepted_%s' % name, accept_next, 'not below one') + + out['dp'] = dict(S45_positive_control=dict(cert45['receipt'], pr1023_width8_optimality=dict( + runner_up_per_unit=pr1023['runner_up'], margin_lower_bound=pr1023['margin_lower_bound'])), + S54_at_c_a_next=certs['a']['receipt'], S54_at_c_b_next=certs['b']['receipt'], + pr1043_inplace_layout=dict(layout=layout_name(lay1043), idle_per_replica=keyed(idle_pr1043), + gap_sum_g_per_replica_at_c_a_next=[dfloor(g1043[0]), dceil(g1043[1])], + gap_moment_at_c_a_next=[dfloor(T * g1043[0] / (M * W), 40), + dceil(T * g1043[1] / (M * W), 40)])) + + # -- 2. Stage-window feasibility (seed72 max-flow, independent Hall test). ---------------------------------------- + supply = {s: 438 for s in range(STAGES)} + allowed = {i: set(st) for i, (p, c, st) in hosting.items()} + configs = [(x4, part) for x4 in range(11) for part in (4, 6)] + feasible = [] + flows = {} + for cfg in configs: + dem = demand_for(cfg) + require(sum(dem.values()) == STAGES * 438, 'demand total') + x = S72.maxflow_assign(supply, dem, allowed) + ok, _ = hall_check(supply, dem, allowed) + require((x is not None) == ok, 'max-flow and Hall disagree at %s' % (cfg,)) + if x is not None: + require(all(s in allowed[i] and n > 0 for (s, i), n in x.items()), 'flow inside windows') + require(all(sum(n for (s, i), n in x.items() if i == j) == dem[j] for j in dem), 'flow meets demand') + require(all(sum(n for (s, i), n in x.items() if s == t) == 438 for t in range(STAGES)), 'flow uses supply') + feasible.append(cfg) + flows[cfg] = x + require(len(feasible) == len(configs), 'every split of the optimum over children 4/6 is window-feasible') + + def tightened(child, stages): + def run(): + al = dict(allowed) + al[child] = set(stages) + dem = demand_for((0, 6)) + ok, why = hall_check(supply, dem, al) + x = S72.maxflow_assign(supply, dem, al) + require((x is None) == (not ok), 'max-flow and Hall disagree on the tightened window') + require(x is not None, 'infeasible: Hall violated by %s' % why) + return run + expect_reject(controls, 'window_child4_tightened_to_stages_0_1', tightened(4, (0, 1)), 'Hall violated') + expect_reject(controls, 'window_child6_tightened_to_stages_7_8', tightened(6, (7, 8)), 'Hall violated') + + def r439_supply(): + x = S72.maxflow_assign({s: 439 for s in range(STAGES)}, demand_for((0, 6)), allowed) + require(x is not None, 'infeasible: 439 helpers per stage do not fit the R438 optimum') + expect_reject(controls, 'r439_supply_into_r438_optimum', r439_supply, 'do not fit') + out['windows_feasibility'] = dict(configs_checked=len(configs), feasible=len(feasible), + note='x4 idle 42-copies in child 4, 10-x4 in child 6, one-residual copy in ' + 'child 4 or 6; children 0,2,7,8 full; capacity-7 children host nothing') + + # -- 3. Explicit placement of all helper occurrences. ------------------------------------------------------------- + chosen = (0, 6) + x = flows[chosen] + patterns = [[0, [8], COPIES], [1, [], COPIES], [2, [8] * 3, COPIES], [3, [], COPIES], [4, [8] * 5, COPIES], + [5, [], COPIES], [6, [], 10], [6, [8], 1], [6, [8] * 5, COPIES - 11], [7, [8] * 3, COPIES], + [8, [8], COPIES]] + sel438 = dict(patterns=patterns, stages=sorted([i, 8, s, n] for (s, i), n in x.items())) + require(S14.R == 439 and S14.V == V and S14.T == T, 'seed14 constants') + S14.R = 438 # adapt seed14's allocator/audit to R = 438 (module instance only) + try: + alloc = S14.allocate(sel438) + rem438, _ = S14.placement_audit(alloc, win14, frozenset()) + owners = S14.owners_for_replicas(alloc, win14) + finally: + S14.R = 439 + require(len(alloc) == STAGES * 438, 'occurrences per replica') + win_hc = {i: (p, c, frozenset(st)) for i, (p, c, st) in hosting.items()} + ys = {(i, tuple(pat)): n for i, pat, n in patterns} + zs = {(i, w, s): n for i, w, s, n in sel438['stages']} + slots_hc, rem_hc = HC.expand(win_hc, ys, zs, {s: [(h, 8) for h in range(438)] for s in range(STAGES)}, COPIES) + require(slots_hc == alloc, 'seed14 allocate = PR442 expand (slot for slot)') + idle_seed14 = Counter(r for r in rem438.values() if r) + idle_hc = Counter(r for r in rem_hc.values() if r) + idle_mine = audit_slots(alloc, hosting, active, 438) + require(idle_seed14 == idle_hc == idle_mine == ca_cert['idle_opt'], 'placement remainders = DP optimum') + seen = set() + for stage, rep, h, fam, child, off, w in owners: + r_, rest = divmod(fam, 8 * V) + pair2, port = divmod(rest, V) + require(r_ == rep and pair2 // 2 == hosting[child][0] != active[stage], 'owner family pair') + require((stage, rep, h) not in seen, 'owner once') + seen.add((stage, rep, h)) + require(len(seen) == STAGES * T * 438 == 126144, 'all hosted residual roles') + canon = json.dumps([list(t) for t in alloc], separators=(',', ':')).encode() + out['placement'] = dict(split='all 10 idle 42-copies and the one-residual copy in child 6', selection=sel438, + occurrences_per_replica=len(alloc), hosted_residual_roles=len(seen), + idle_per_replica=keyed(idle_seed14), slot_list_sha256=hashlib.sha256(canon).hexdigest(), + builders_agree='seed14 allocate == PR442 hosting_core.expand', + audits='seed14 placement_audit, independent audit_slots, seed14 owners_for_replicas') + + def mutated(fn): + lst = [list(t) for t in alloc] + fn(lst) + return [tuple(t) for t in lst] + + def first(pred, lst): + return next(k for k, t in enumerate(lst) if pred(t)) + + def m_window(lst): + k = first(lambda t: t[0] == 4, lst) + lst[k][4] = 6 # child 4 admits stages 0-5 + def m_collision(lst): + k = first(lambda t: t[0] == 4 and t[2] == 8, lst) + lst[k][2] = 0 + def m_duplicate(lst): + k = first(lambda t: t[0] == 2 and t[2] == 8, lst) + j = first(lambda t: t[4] == lst[k][4] and t[5] != lst[k][5], lst) + lst[k][5] = lst[j][5] + def m_missing(lst): + del lst[-1] + def m_extent(lst): + k = first(lambda t: t[0] == 6 and t[1] == COPIES - 11, lst) + lst[k][2] = 36 # 36 + 8 > 42 + def m_domain(lst): + lst[-1][5] = 438 + def m_width(lst): + lst[0][3] = 7 + mutations = [('placement_stage_outside_window', m_window, 'outside untouched window', 'stage outside window'), + ('placement_cell_collision', m_collision, 'coordinate collision', 'cell collision'), + ('placement_duplicate_helper', m_duplicate, 'duplicate helper', 'duplicate (stage, helper)'), + ('placement_missing_helper', m_missing, 'missing helper', 'missing (stage, helper)'), + ('placement_slot_extent', m_extent, 'slot extent', 'slot extent'), + ('placement_helper_out_of_domain', m_domain, 'owner domain', 'index domain'), + ('placement_width7_residual', m_width, 'helper residual width', 'residual width')] + + def seed14_audit(lst, win, R=438): + S14.R = R + try: + S14.placement_audit(lst, win, frozenset()) + finally: + S14.R = 439 + for name, fn, n14, mine in mutations: + lst = mutated(fn) + expect_reject(controls, name + '/seed14', lambda lst=lst: seed14_audit(lst, win14), n14) + expect_reject(controls, name + '/independent', lambda lst=lst: audit_slots(lst, hosting, active, 438), mine) + # Owner activity: swap the (stage, helper) of the first child-6 role with the first stage-1 role (child j), and + # widen the windows so that both moved roles are inside them: child 6 gets stage 1 (its pair 0 is the active pair + # there) and child j gets the child-6 role's stage (where child j's pair is not active). The occurrence set, + # widths and cells are unchanged; only the active-data (owner inactivity) rule can reject. + lst = [list(t) for t in alloc] + k6 = first(lambda t: t[0] == 6, lst) + kj = first(lambda t: t[4] == 1, lst) + j, s6 = lst[kj][0], lst[k6][4] + require(hosting[6][0] == active[1] and hosting[j][0] != active[s6], 'active-pair control setup') + (lst[kj][4], lst[kj][5]), (lst[k6][4], lst[k6][5]) = (lst[k6][4], lst[k6][5]), (lst[kj][4], lst[kj][5]) + lst = [tuple(t) for t in lst] + win14_mut, hosting_mut = dict(win14), dict(hosting) + for child, extra in ((6, 1), (j, s6)): + win14_mut[child] = win14[child][:2] + (tuple(sorted(set(win14[child][2]) | {extra})),) + hosting_mut[child] = hosting[child][:2] + (tuple(sorted(set(hosting[child][2]) | {extra})),) + expect_reject(controls, 'placement_host_pair_active/seed14', lambda: seed14_audit(lst, win14_mut), + 'host is active data') + expect_reject(controls, 'placement_host_pair_active/independent', + lambda: audit_slots(lst, hosting_mut, active, 438), 'host pair active at stage') + expect_reject(controls, 'placement_audited_as_R439/seed14', lambda: seed14_audit(alloc, win14, R=439), + 'missing helper') + expect_reject(controls, 'placement_audited_as_R439/independent', lambda: audit_slots(alloc, hosting, active, 439), + 'missing (stage, helper)') + + # -- 4. Endpoint summary. ---------------------------------------------------------------------------------------- + out['endpoints'] = rows + out['claims'] = dict( + optimum_idle_per_replica=keyed(ca_cert['idle_opt']), + c_window_optimum_local_a=grid_decimal(ca), c_window_optimum_local_b=grid_decimal(cb), + c_pr1043_inplace=grid_decimal(c_pr1043), c_pr589=grid_decimal(c0), + certificate='moment(opt, c+1e-24) > 1 by both engines; every other no-bank R438 slot layout has a certified ' + 'larger idle sum at c+1e-24 with the same child count and local profile, hence a larger moment; ' + 'so no layout in the slot model reaches c+1e-24', + kappa='unchanged; the bit side does not bind') + out['negative_controls'] = controls + elapsed = time.time() - t0 + return out, elapsed, ca, cb, c_pr1043 + + +if __name__ == '__main__': + ap = argparse.ArgumentParser(description=__doc__.split('\n\n')[0]) + ap.add_argument('--repo', default=DEFAULT_REPO, + help='repository root (default: the parent of the research/ directory holding this script)') + ap.add_argument('--out', help='write the JSON receipt here (e.g. RECEIPT.json next to this script)') + ap.add_argument('--check', help='require the regenerated receipt to equal this file byte for byte') + a = ap.parse_args() + if sys.flags.optimize or not __debug__: + print('FAIL_%s refusing to run under python -O (assert-based checks in pinned modules would be skipped)' % TAG) + sys.exit(2) + try: + receipt, elapsed, ca, cb, c1043 = main(a) + text = json.dumps(receipt, indent=1, sort_keys=True) + '\n' + if a.check: + with open(a.check) as handle: + require(handle.read() == text, 'receipt differs from ' + a.check) + if a.out: + with open(a.out, 'w') as handle: + handle.write(text) + except (Exception, SystemExit) as e: # seed72's need() raises SystemExit + print('FAIL_%s %s: %s' % (TAG, type(e).__name__, e)) + sys.exit(1) + print('python %s; %.1f s' % (sys.version.split()[0], elapsed)) + print('PASS_%s S=54 opt=10x(42,5)+1x(42,4) idle={2:433,4:444,6:444,7:666,34:1,42:10} c_a=%s c_b=%s ' + 'pr1043_inplace=%s window_splits=22/22 controls=%d no_new_kappa' + % (TAG, grid_decimal(ca), grid_decimal(cb), grid_decimal(c1043), len(receipt['negative_controls']))) diff --git a/research/r429-full-target-interface/frozen/upstream/research/bit-r438-transport-rehost/words/r438-t154.json.gz b/research/r429-full-target-interface/frozen/upstream/research/bit-r438-transport-rehost/words/r438-t154.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..e12a566658a4b2c8b6ae0ecc34fd41290f68f5e8 GIT binary patch literal 42305 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%0D#o{m4v0S^lXMc!B^5s|rQj}G= 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 literal 0 HcmV?d00001 diff --git a/research/r429-full-target-interface/verify.py b/research/r429-full-target-interface/verify.py new file mode 100644 index 0000000000..2a4a1b4766 --- /dev/null +++ b/research/r429-full-target-interface/verify.py @@ -0,0 +1,173 @@ +#!/usr/bin/env python3 +"""Replay exact frozen proofs with explicit path and receipt adapters only.""" +import argparse +import hashlib +import gzip +import importlib.machinery +import importlib.util +import json +from pathlib import Path +import sys + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=False) + + +class Portable: + def __init__(self, root): + self.root = Path(root).resolve() + self.hashes = json.loads((self.root / 'FROZEN-SHA256.json').read_text()) + self.patches = json.loads((self.root / 'ADAPTATIONS.json').read_text()) + self.executed = set() + self.compared = set() + self.words_compared = set() + old = '/Users/ross/git/math/' + self.prefixes = { + old + 'integer-mult-bounds/': self.root / 'frozen/upstream', + old + '.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/': self.root / 'frozen/changed', + old + '.research-automation/runs/kappa-major-20261018T1330Z/': self.root / 'frozen/major', + old + '.research-automation/runs/kappa-3605-successor-20261018T0940Z/major-frontier/': self.root / 'frozen/old', + } + + def authenticate(self, path): + path = Path(path).resolve() + name = path.relative_to(self.root).as_posix() + need(name in self.hashes, 'unregistered frozen input: ' + name) + raw = path.read_bytes() + need(hashlib.sha256(raw).hexdigest() == self.hashes[name], 'frozen input changed: ' + name) + return raw + + def adapted(self, path): + name = Path(path).resolve().relative_to(self.root).as_posix() + source = self.authenticate(path).decode() + for edit in self.patches.get(name, []): + need(source.count(edit['old']) == 1, 'adaptation no longer unique: ' + name) + source = source.replace(edit['old'], edit['new']) + return source + + def check_all(self): + need(set(self.patches) <= set(self.hashes), 'unbound adaptation') + for name in self.hashes: + self.authenticate(self.root / name) + for name in self.patches: + self.adapted(self.root / name) + legacy = json.loads(self.authenticate(self.root / 'frozen/major/bit-endpoint/BIT-FULL-COMPENSATION.json')) + current = json.loads(self.authenticate(self.root / 'frozen/current/EXPECTED-COMPENSATION.json')) + need(legacy.pop('allsize_lift') != current.pop('allsize_lift'), 'missing prose correction') + need(canonical(legacy) == canonical(current), 'correction changed a scientific receipt field') + + def code(self, path): + path = Path(path).resolve() + source = self.adapted(path) + self.executed.add(path.relative_to(self.root).as_posix()) + return compile(source, str(path), 'exec', dont_inherit=True, optimize=0) + + def normalize(self, value): + if isinstance(value, str): + for prefix, target in self.prefixes.items(): + if value.startswith(prefix): + return str(target / value[len(prefix):]) + return value + if isinstance(value, dict): + result = {} + for key, item in value.items(): + normalized_key = self.normalize(key) + need(normalized_key not in result, 'normalized key collision') + result[normalized_key] = self.normalize(item) + return result + if isinstance(value, list): + return [self.normalize(v) for v in value] + return value + + def word_equal(self, path, compressed): + path = Path(path).resolve() + expected = gzip.decompress(self.authenticate(path)) + actual = gzip.decompress(compressed) + need(actual == expected, 'complete regenerated word mismatch') + # Container bytes are frozen provenance. Regenerated zlib headers or + # compression choices are not a semantic acceptance criterion. + self.words_compared.add(path.relative_to(self.root).as_posix()) + return len(compressed) + + def equal(self, path, value): + path = Path(path).resolve() + expected = json.loads(self.authenticate(path)) + actual = json.loads(json.dumps(value)) + # Compare every field, preserving JSON scalar types. Only original + # absolute provenance paths are mapped into this relocated package. + need(canonical(self.normalize(actual)) == canonical(self.normalize(expected)), + 'receipt mismatch: ' + path.name) + self.compared.add(path.relative_to(self.root).as_posix()) + return True + + def install(self): + portable = self + original_code = importlib.machinery.SourceFileLoader.get_code + original_exec = importlib.machinery.SourceFileLoader.exec_module + + def frozen(loader): + return Path(loader.path).resolve().is_relative_to(portable.root / 'frozen') + + def get_code(loader, fullname): + if frozen(loader): + return portable.code(loader.path) + return original_code(loader, fullname) + + def exec_module(loader, module): + if frozen(loader): + module.PORTABLE = portable + return original_exec(loader, module) + + importlib.machinery.SourceFileLoader.get_code = get_code + importlib.machinery.SourceFileLoader.exec_module = exec_module + sys.path.insert(0, str(self.root / 'frozen/major/bit-endpoint')) + + def load(self, path): + spec = importlib.util.spec_from_file_location('portable_stage', self.root / path) + module = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = module + spec.loader.exec_module(module) + return module + + +STAGES = { + 'independent-caller': ('frozen/reviews/caller/independent_check.py', 'frozen/reviews/caller/INDEPENDENT-RESULT.json'), + 'independent-native': ('frozen/reviews/native/independent_check.py', 'frozen/reviews/native/RESULT.json'), + 'compensation': ('frozen/major/bit-endpoint/bit_full_compensation.py', 'frozen/current/EXPECTED-COMPENSATION.json'), + 'caller': ('frozen/major/shared-helper-algebra/bit_seeded_star.py', 'frozen/major/shared-helper-algebra/BIT-SEEDED-STAR.json'), + 'pressure': ('frozen/changed/budgets/seeded_star_pressure.py', 'frozen/changed/budgets/SEEDED-STAR-PRESSURE.json'), +} +INDEPENDENT = {} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--stage', choices=STAGES, required=True) + args = parser.parse_args() + portable = Portable(Path(__file__).resolve().parent) + portable.check_all() + portable.install() + source, receipt = STAGES[args.stage] + stages = [(source, receipt)] + if args.stage in INDEPENDENT: + stages.append(INDEPENDENT[args.stage]) + for source, _ in stages: + sys.argv = [str(portable.root / source)] + portable.load(source).main() + need(portable.compared == {receipt for _, receipt in stages}, 'incomplete receipt coverage') + required_words = {'frozen/major/bit-endpoint/BIT-FULL-COMPENSATION-WORD.json.gz'} if args.stage == 'compensation' else set() + need(portable.words_compared == required_words, 'incomplete regenerated word coverage') + portable.check_all() + print(canonical({'status': 'PASS_R429_FULL_TARGET_INTERFACE', 'stage': args.stage, + 'receipts': sorted(portable.compared), 'sources': sorted(portable.executed), + 'no_new_kappa': True})) + + +if __name__ == '__main__': + main() From b1204d8ae309eba8b2808a3f3e2d1ce9de3a2c71 Mon Sep 17 00:00:00 2001 From: ross Date: Mon, 19 Oct 2026 22:14:39 +1100 Subject: [PATCH 2/2] Record final source-integrity review and full replay --- research/r429-full-target-interface/README.md | 2 +- .../REVIEW-PORTABILITY.md | 18 ++++++++++++++---- .../r429-full-target-interface/VALIDATION.md | 13 +++++++++++++ 3 files changed, 28 insertions(+), 5 deletions(-) create mode 100644 research/r429-full-target-interface/VALIDATION.md diff --git a/research/r429-full-target-interface/README.md b/research/r429-full-target-interface/README.md index d8471e4a39..d54eea80e4 100644 --- a/research/r429-full-target-interface/README.md +++ b/research/r429-full-target-interface/README.md @@ -16,7 +16,7 @@ The target lifts use 111 rank-one queries, all paid. They make local mass equal python3.12 -B scripts/research_package.py --package research/r429-full-target-interface ``` -The portable replay uses only Python's standard library. It authenticates all frozen bytes before compiling them, keeps checks active under optimized callers, bypasses matching nested bytecode caches and compares every receipt field. Regeneration compares the complete decompressed word bytes; frozen gzip hashes retain provenance, while regenerated compression headers and zlib choices may differ. No mathematical receipt field is dropped. Original workstation paths are normalized only for relocation, with colliding keys rejected. +See [VALIDATION.md](VALIDATION.md) for the exact local replay evidence. The portable replay uses only Python's standard library. It authenticates all frozen bytes before compiling them, keeps checks active under optimized callers, bypasses matching nested bytecode caches and compares every receipt field. Regeneration compares the complete decompressed word bytes; frozen gzip hashes retain provenance, while regenerated compression headers and zlib choices may differ. No mathematical receipt field is dropped. Original workstation paths are normalized only for relocation, with colliding keys rejected. ## Corrected historical statement diff --git a/research/r429-full-target-interface/REVIEW-PORTABILITY.md b/research/r429-full-target-interface/REVIEW-PORTABILITY.md index 7b681ebccd..c385136236 100644 --- a/research/r429-full-target-interface/REVIEW-PORTABILITY.md +++ b/research/r429-full-target-interface/REVIEW-PORTABILITY.md @@ -1,10 +1,10 @@ # B05/B06 source-to-replay integrity review -Scope: portable finite replay and source binding for `research/r429-full-target-interface`. Initial snapshot: 15 frozen files, 10 uniquely matched text adaptations, three scientific stages, one mandatory complete generated word. The mathematical compensation and caller/pressure obligations have separate owners. No heavy mathematical stage was repeated for this review. +Scope: portable finite replay and source binding for `research/r429-full-target-interface`. Final snapshot: 19 frozen files, 18 uniquely matched text adaptations, five scientific stages, one mandatory complete generated word. The initial 15-file snapshot was followed by the independent-checker delta described below. The mathematical compensation and caller/pressure obligations have separate owners. No heavy mathematical stage was repeated for this review. ## Findings -No unresolved source-binding defect in the reviewed snapshot. All 15 original files were independently compared byte-for-byte with ORIGINS, and their lengths and SHA256 matched FROZEN-SHA256. See INTEGRITY.json for exact wrapper/manifest hashes. The canonical package copy has byte-identical verifier, controls, adaptations, frozen manifest, origins and replay manifest to that tested snapshot. +No unresolved source-binding defect in the final reviewed snapshot. All 19 original files were independently compared byte-for-byte with ORIGINS, and their lengths and SHA256 matched FROZEN-SHA256. See FINAL-INTEGRITY.json for the exact final wrapper/manifest hashes, source closure and registered stages; INTEGRITY.json preserves the initial controlled snapshot. The historical `allsize_lift` sentence was false. The current receipt changes exactly that one field, independently confirmed and enforced by `check_all`; the corrected receipt itself is hash-bound. The adapter substitutes that exact prose literal, leaving every arithmetic expression, loop, rank/frame check, cost and negative control intact. Every receipt field, including source hashes and the new prose, is compared with canonical JSON scalar types preserved. Provenance paths alone relocate; duplicate keys after relocation are rejected. @@ -14,7 +14,7 @@ An additional historical comment incorrectly called all declared caller primitiv ## Closure, read-only execution and optimization -The executed scientific closure is compensation -> full_targets -> old cap/scalar, plus caller and pressure: six Python sources. Pressure parses the seventh frozen Python file, upstream verify_rehost, as AST to recover LOCAL_B, rather than executing it. The two compressed source words and exact expected receipts are retained. Main methods in old imported modules are not invoked; their unused historical file references are not part of this replay dependency closure. +The executed scientific closure is compensation -> full_targets -> old cap/scalar, plus caller, pressure and the two independent checkers: eight Python sources. Pressure and the independent caller parse the ninth frozen Python file, upstream verify_rehost, as AST to recover LOCAL_B, rather than executing it. The two compressed source words and exact expected receipts are retained. Main methods in old imported modules are not invoked; their unused historical file references are not part of this replay dependency closure. Frozen SourceFileLoader get_code is intercepted for direct and nested imports; authenticated adapted source is compiled with `dont_inherit=True, optimize=0`. The exact source read for authentication is the source compiled, bypassing timestamp-valid stale bytecode. The controls bootstrap verifier directly from bytes with optimize=0. Outer checks use explicit raises and remain active under -O. Scientific stage arguments are reset to a single program path, so inherited optional --write branches cannot be selected; producer writes are replaced by receipt/body equality, and imported historical mains are not called. No original/frozen source or receipt is written during the supported replay. @@ -22,4 +22,14 @@ Both normal and -O controls passed via the actual repository `run_python_replay` ## Limits -This source-integrity result preserves the stated finite integer/F2, exact dyadic and conditional pressure checks. It does not discharge the inherited all-modulus native compiler, rounded children, physical owners, tape/source access, changed-cut admission, or a favorable complete recurrence. The historical arbitrary common-frame ADDs cannot be promoted to native ZERO/FULL-only compilation. No new kappa or formal-kernel proof follows. Root owns final registered replay, metadata, publication and CI. Independent mathematical checker additions require a subsequent closure/adapter delta audit. +This source-integrity result preserves the stated finite integer/F2, exact dyadic and conditional pressure checks. It does not discharge the inherited all-modulus native compiler, rounded children, physical owners, tape/source access, changed-cut admission, or a favorable complete recurrence. The historical arbitrary common-frame ADDs cannot be promoted to native ZERO/FULL-only compilation. No new kappa or formal-kernel proof follows. Root owns final registered replay, metadata, publication and CI. This review does not claim that the complete final registered suite or hosted CI passed; those are separate evidence gates. + +## Final independent-checker delta + +Both new scripts and complete receipts match their independent review originals byte-for-byte. The eight added adapters are six input-root/path redirects and two read-only receipt equality redirects, with no mathematical edit. Both import only standard-library modules, have no producer/utility imports, and all of their consumed nonstandard files are present in the authenticated 19-file closure. + +The native checker reads the entire preserved word and independently reconstructs bulk/lifts/nine-total equality, signed matrices, frame chronology and dyadic ADDRESS operators. Its producer/utility reads are hashes only. The caller checker reads the literal saved caller, original compensation and pressure receipts, upstream AST and compressed source word; it does not execute upstream code. Reading the original compensation receipt does not reinstate the corrected false sentence: native explicitly reports that historical error, and caller consumes the unchanged mathematical profile/count fields. + +Each new STAGES entry has exactly one required complete receipt; both are separately registered. The manifest registers every one of the five scientific stages exactly once plus controls, with total timeout 750 seconds. Both new receipts passed a lightweight complete-field positive comparison and rejected a missing status field. Native's optional --write is disabled by the existing argument reset; caller's unconditional output write is replaced by PORTABLE.equal. No mathematical main was executed in this delta audit. + +All verifier function/class ASTs and the controls bytes are unchanged from the actual-launcher normal/-O controlled snapshot; the verifier change only adds the two stage declarations. The authenticated optimize=0 loader, exact expected-set gate, collision protection and bytecode controls therefore retain their reviewed implementation. The delta was imported under isolated optimized Python, with all consumed paths authenticated. This completes the requested portability/source-integrity review for the hashes in FINAL-INTEGRITY.json. diff --git a/research/r429-full-target-interface/VALIDATION.md b/research/r429-full-target-interface/VALIDATION.md new file mode 100644 index 0000000000..0464ec0aac --- /dev/null +++ b/research/r429-full-target-interface/VALIDATION.md @@ -0,0 +1,13 @@ +# Validation + +Complete registered replay passed on Python3.12.14 at `f0625d20bcc175e0865d1d5cf3f7852fe2287679` on2026-10-19: the full producer reconstruction, independent dense/native replay, seeded word, pressure proof, independent ring/fresh-path reconstruction, and controls. The later publication commit adds the final integrity review and this record; scientific code, adapters, frozen inputs and registration remain unchanged. + +```sh +python3.12 -B scripts/research_package.py --package research/r429-full-target-interface +``` + +The retained full log SHA256 is `664412ad94dfda752def14082f78c0ee3a0f5c2b5e9eb5ad9bfabd4be96b4da0`. Every field of all five scientific receipts and every regenerated word byte is compared. The historical gzip container hash is preserved provenance; regenerated compression differences are accepted only when decompressed bytes match exactly. + +Independent native and caller checkers also passed normal and optimized standalone runs. Source controls passed both modes through the actual repository launcher's private cache prefix, including nested poisoned-cache rejection. Nineteen input/origin bindings and the complete stdlib import closure were independently reviewed. The two historical prose/comment corrections are explicit and do not change mathematics. + +This finite replay and the written conditional all-L caller proof are separate from source-history availability, exported-byte controls and automatic hosted CI. The PR records exact-head CI when available. No human peer review, formal-kernel proof or full native supplier admission is claimed.