diff --git a/research/pr7637-independent-recount/.gitattributes b/research/pr7637-independent-recount/.gitattributes new file mode 100644 index 0000000000..b13bbf03d0 --- /dev/null +++ b/research/pr7637-independent-recount/.gitattributes @@ -0,0 +1 @@ +inputs/** -text \ No newline at end of file diff --git a/research/pr7637-independent-recount/README.md b/research/pr7637-independent-recount/README.md new file mode 100644 index 0000000000..5883867d95 --- /dev/null +++ b/research/pr7637-independent-recount/README.md @@ -0,0 +1,141 @@ +# Independent recount of the PR #7637 word and invoices + +**No new κ. No frontier change. No supplier admission.** This package is an +independent finite audit of the open candidate +[PR #7637](https://github.com/CrocSwap/integer-mult-bounds/pull/7637) by +SYLforge at exact head `32e3853b2250f1971932919cbbc01348cd8245be` +(conditional κ ≥ 0.0037, the portable 233-CLEAR composition). It compares the +#7637 word and invoice with the open +[PR #7633](https://github.com/CrocSwap/integer-mult-bounds/pull/7633) word and +invoice at head `8b885be4a553dea375303808fdfff52ed0d71019`. It applies the +method of [PR #7628](https://github.com/CrocSwap/integer-mult-bounds/pull/7628), +[#7635](https://github.com/CrocSwap/integer-mult-bounds/pull/7635), +[#7638](https://github.com/CrocSwap/integer-mult-bounds/pull/7638) and +[#7639](https://github.com/CrocSwap/integer-mult-bounds/pull/7639). + +## Why this check adds coverage + +#7637 ships its word and its complete invoice only inside the packed data +archive `data/inputs.tar.gz`, and its checks reuse earlier author receipts. This +package takes the two objects out of the archive, binds the paid and target +invoice of the claim to the word bytes, and checks the moment signs with a +separate engine. It runs in about one second. `verify.py` imports no +constructor, application or pricing engine from #7637. No audit of #7637 was +found among the open PRs on 2026-11-17. + +## Result + +All statements are about the four pinned files in `inputs/pr7637/`. The #7633 +files equal the blobs at the #7633 head. The #7637 files are objects of the +archive at the #7637 head, and their SHA-256 equal the manifest entries (see +[SOURCES.json](SOURCES.json)). + +1. **Digests and census.** The canonical JSON digest of the #7637 word equals + the one that its README states (`8ab3d9db…`). So does the digest of the #7633 + word (`4961e5e9…`). The #7637 word has 78,596 events: 68,049 ADD, 3,890 + SCALE, 6,191 MOVE, 233 INIT and 233 CLEAR. At most 50 owned fields are live + at one time, and 52 owned labels are used. +2. **Header.** The two words are equal except `program`. No initial chart + changes, and `initial[457]` is 281 in both. +3. **Chart chronology.** Each field is followed through the complete program of + both words (77,598 and 78,596 events). Each MOVE starts at the current chart + of its field. Each ADD, COPY and SCALE acts at the chart where its operands + are. Each INIT creates a dead owned field and each CLEAR removes a live owned + field at its current chart. The public fields end at the `final` charts. +4. **Paid recount.** Rank law: `rank(a->b) = dim(A+B) - dim(A∩B)` over GF(2). + In both words each MOVE joins two nested frames and has a positive rank. With + `H(word)` the MOVE rank histogram, exactly `paid(invoice) = 17 · H(word) + K` + with the same `K = {1:384, 8:656, 9:32, 16:416, 24:416, 32:416, 40:416, 48:416, 56:416, 64:208}` + for both words. This `K` equals the one of the #7612, #7630, #7631, #7633 and + #7636 recounts. The native MOVE change per call is + `{1:-13, 2:-46, 3:-7, 4:-40, 5:+4, 6:+43, 8:+1}`. The MOVE count goes from + 6,249 to 6,191 and the total rank of the change is zero. Paid positions go + from 110,009 to 109,023, which is 17 · 58 fewer. +5. **Target recount.** For each helper field (every public field that is not a + main, with the main set as #7630 defines it) the target rank is + `rank(final frame) - rank(initial frame)`. Exactly + `targets(invoice) = 17 · T(word) + K_T`, with the same + `K_T = {9:416, 17:416, 25:416, 33:416, 41:416, 49:416, 57:416, 65:416, 73:208, 137:208}` + for both words. The helper change per call is empty. Target positions stay + 22,461 and the rank surplus stays 1,424. +6. **Moment signs.** A separate 256-bit integer interval engine evaluates + `M(κ) = Σ (T_r - P_r) r^(1-κ)`. The #7637 invoice is positive at the claim + `0.0037`, at the #7636 claim `0.0036807241001` and at the #7633 value + `0.003667193194322`. It is negative at the bit cap `0.00376669`. The PR does + not state a crossing. This audit measures one between `0.00370007` (positive) + and `0.00370008` (negative), so the claim is about `7.7 · 10^-8` below it. + The #7633 invoice is positive at its tested point `0.00366719319432207` and + negative at `0.0036672` and at the #7637 claim. The upper bounds of `dM/dκ` + on `[0, 0.00376669]` are negative for both invoices. For #7633 it is + `-379338.0672489424`, equal to the value of the #7633 recount. For #7637 it + is `-375918.531…`. So each crossing is unique on the interval. +7. **Tent test.** The change in the moment is zero or positive for every tariff + `min(r, a)` and positive for some a. So #7637 is no worse than #7633 for every + increasing concave tariff with `f(0) = 0`. +8. **Controls.** Ten semantic mutations reject: a growth-only rank law, one more + paid unit, the old word with the new invoice, a dropped MOVE, a changed + initial chart, an ADD at the wrong chart, a MOVE to another chart, a changed + frame, the old invoice at the new claim and a point above the crossing. + +## What this does not establish + +- #7637 states that no admitted common supplier exists and that its changed + entrance, whole-extent reset, residual domain and cost obligations are open. + This audit does not touch them. +- `K` and `K_T` are measured from the invoices. They are not derived from the + #7113 caller. +- The main set is the definition of #7630. It is not derived from the physical + caller. +- The ordinary bill and the PR tariff (4,000 ordinary units per lifetime pair, + 32 scalar services per INIT or CLEAR, coefficient 2^20 per service) are not + recounted. The 10^9 allowance is not checked. +- The 233 recoverability certificates, the scalar audit, the exact rational + replay, the native route, the signed route, the precision and tape checks and + the external #7334 archive are not replayed. +- The recount compares the #7637 word with the #7633 word, because they share + headers and initial charts. It does not check the construction that the PR + describes (the H5B base and the E1 and E4 edits). +- The five framework assumptions remain as #7637 states them. A correct count is + not a supplier admission. + +## Reproduce + +From the repository root, Python 3.10 or later, standard library only: + +```sh +python3 scripts/research_package.py --package research/pr7637-independent-recount --check-only +python3 scripts/research_package.py --package research/pr7637-independent-recount +python3 -I -B research/pr7637-independent-recount/verify.py +``` + +Environment of the recorded run: CPython 3.13.9, Windows 11, about 1 s, with +the registered argv run directly. The package runner requires Python 3.12 for +the replay step, and this machine has no Python 3.12. **The Python 3.12 runner +replay is not run.** Canonical main at the start and before submission: +`e54523517d0f03e58352e647c403a5af3e525a57`, priority revision 8, checked +2026-11-17 UTC. + +## Open next questions + +The structured list is in [TASK.json](TASK.json). + +1. Recount the ordinary bill and the PR tariff with the formula that #7633 + names. Blocker: that formula lives in repository scripts that this audit did + not read. +2. Show that a common supplier covers all 233 lifetimes and the changed + entrance. Blocker: it needs the #7113 caller and is outside a count audit. +3. Replay the reconstruction, native and signed routes on a Python 3.12 runner + with the pinned #7334 archive. + +## Credit + +The audited construction, word, invoice and claim are by SYLforge (#7637), on +the work of SYLforge (H5B, #7616, #7620), DreamingOfClouds (#7630, #7636), +Clear1nsight (#7631, #7633, #7626), Ali Romman (#7605), Rohan Arun (#7113, +#7334), Hao Yan, ToikY and their predecessors. The vendored files keep their +Apache-2.0 license. The task card `independent-moment` and the package tooling +are by Douglas Colkitt. + +This audit was prepared by fluorine with substantial Anthropic Claude +(Claude Code) assistance. New work is Apache-2.0. No independent human review +of this audit exists yet. diff --git a/research/pr7637-independent-recount/SOURCES.json b/research/pr7637-independent-recount/SOURCES.json new file mode 100644 index 0000000000..005d9d23f7 --- /dev/null +++ b/research/pr7637-independent-recount/SOURCES.json @@ -0,0 +1,72 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "research/pr7637-independent-recount/inputs/pr7637/base-7633-word.json.gz", + "usage": "input", + "git_blob": "c51b08bf0f7949996f2ce1696f3d0168c333185d", + "sha256": "49bd1b5527e5c0de1ba22101a167a66d0d7ab0fd6665569a2cb1648e71ed5ff0", + "origin": { + "pull_request": 7633, + "commit": "8b885be4a553dea375303808fdfff52ed0d71019", + "path": "research/p104-e1-role457-on7631/words/candidate.json.gz" + }, + "pin": "head:253670b3349666971d667c131a30f48d568a160c:research/pr7637-independent-recount/inputs/pr7637/base-7633-word.json.gz" + }, + { + "path": "research/pr7637-independent-recount/inputs/pr7637/word-7637.json.gz", + "usage": "input", + "git_blob": "e26b6c3d8999c8e16399f901eb25ece1b549b2c0", + "sha256": "d7eb204bb24b2e1b5a3e4ebc282d346a4706ddd738004929d1e9ac345085a79a", + "origin": { + "pull_request": 7637, + "commit": "32e3853b2250f1971932919cbbc01348cd8245be", + "path": "research/final233-portable-conditional/data/inputs.tar.gz", + "archive_blob": "af9c6bb123bfe797166de15f97eb897734aba0a3", + "archive_member": "objects/d7eb204bb24b2e1b5a3e4ebc282d346a4706ddd738004929d1e9ac345085a79a", + "manifest_path": "evidence/candidate/word-joint-final.json.gz" + }, + "pin": "head:253670b3349666971d667c131a30f48d568a160c:research/pr7637-independent-recount/inputs/pr7637/word-7637.json.gz" + }, + { + "path": "research/pr7637-independent-recount/inputs/pr7637/invoice-7633.json", + "usage": "input", + "git_blob": "c17c558206dad21d30fdba8462fd54f8a3edb70d", + "sha256": "f0c0fb377df557197b391a80a918da1e37d2a2ed707d1b4971d881c2c441bc3b", + "origin": { + "pull_request": 7633, + "commit": "8b885be4a553dea375303808fdfff52ed0d71019", + "path": "research/p104-e1-role457-on7631/invoices/candidate.json" + }, + "pin": "head:253670b3349666971d667c131a30f48d568a160c:research/pr7637-independent-recount/inputs/pr7637/invoice-7633.json" + }, + { + "path": "research/pr7637-independent-recount/inputs/pr7637/invoice-7637.json", + "usage": "input", + "git_blob": "014fcc9fd089bdda558787f8e56ee57c35f90dd2", + "sha256": "c35c9d04c8b237b9cf384b3e8b759b67b3736d238e1cb695b462a95b7091997b", + "origin": { + "pull_request": 7637, + "commit": "32e3853b2250f1971932919cbbc01348cd8245be", + "path": "research/final233-portable-conditional/data/inputs.tar.gz", + "archive_blob": "af9c6bb123bfe797166de15f97eb897734aba0a3", + "archive_member": "objects/c35c9d04c8b237b9cf384b3e8b759b67b3736d238e1cb695b462a95b7091997b", + "manifest_path": "evidence/candidate/invoice-joint-final.json" + }, + "pin": "head:253670b3349666971d667c131a30f48d568a160c:research/pr7637-independent-recount/inputs/pr7637/invoice-7637.json" + } + ] +} diff --git a/research/pr7637-independent-recount/TASK.json b/research/pr7637-independent-recount/TASK.json new file mode 100644 index 0000000000..daf1b940a4 --- /dev/null +++ b/research/pr7637-independent-recount/TASK.json @@ -0,0 +1,111 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "independent-moment", + "question": "Does a changed construction's serialized target/paid invoice independently support its claimed improvement?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "docs/research/recursive-invoice-preflight.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Independently recount one changed emitted word and its complete caller, importing no constructor or pricing engine. Include target losses, owned lifetimes, native orientation and extra charges. Check existing #5633/#5708/#5717/#5719 coverage to avoid duplicate audits and preserve its exact head. Stop after the chosen missing implication; a correct root alone is not supplier admission.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "invoice", + "signed moment", + "productive target", + "independent recount" + ], + "existing_checks": [ + { + "scope": "PR #4088: mixed local/owner/phase ledger and moment reported.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Independent binding of changed construction to paid histogram, distinct from full admission.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4091: sharp pooled ceiling proposed for fixed THREE/FOUR words and inventory.", + "evidence": "research/staged-fourth-mixture-ceiling/README.md", + "remaining": "Validate dual, exhaustive pattern scope and exact source equivalence before applying to newer fills.", + "status": "author-checked", + "source_commit": "a29bdd8f56cd18b805917775cdec09ff935eddc4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4067: paid (2,2) to (1,3) exchange and fixed OQ4 host reported.", + "evidence": "research/r437-two-window-carrier/README.md", + "remaining": "Independent full cost delta; remaining caller/precision/stock obligations are separate.", + "status": "author-checked", + "source_commit": "a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "refined", + "actual_scope": "Independent recount, at the exact open PR heads #7637 32e3853b2250f1971932919cbbc01348cd8245be and #7633 8b885be4a553dea375303808fdfff52ed0d71019, of the step from the #7633 word to the #7637 word: (1) header and initial-chart equality, (2) the canonical digests that the PRs state, the opcode census and the ownership census, (3) the chart chronology of both complete words, (4) the MOVE rank histograms and their relation to the declared 17-call paid invoices, (5) the helper target ranks and their relation to the declared target invoices, and (6) the signs of the declared complete moments at the claim 37/10000 and around a crossing that this audit measures. No constructor, application or pricing engine of the PRs is imported.", + "scope_change_reason": "The first experiment of the card is applied to a newer exact head. No audit of #7637 was found among the open PRs on 2026-11-17. #7637 is the first candidate of this series that ships its word and invoice inside a packed data archive and that uses the H5B construction. The #7637 invoice is a complete invoice of the word and has the same fixed caller histograms as the P104 chain, so the same recount applies.", + "bottleneck_link": "The complex supplier binds. #7637 changes the paid MOVE rank histogram of the P104 word with total rank zero and adds no helper target change. This audit binds the invoice of the claim to the emitted word bytes.", + "budget_minutes": 60, + "stop_rule": "Stop after the word-to-invoice binding and the moment signs are resolved or one exact mismatch is found. Do not replay the native, signed, physical, ordinary, CLEAR certificate, common-U or outer stages.", + "outcome": "completed", + "evidence": "verify.py passes on CPython 3.13.9 (Windows) in about 1 s: the canonical digests equal the two stated ones; the #7637 word has 78,596 events, 233 INIT and 233 CLEAR events, peak 50 owned fields and 52 labels; paid = 17 x (MOVE rank histogram of the word) + one fixed caller histogram, equal for #7633 and #7637 and equal to the one of the #7612, #7630, #7631, #7633 and #7636 recounts; targets = 17 x (helper target histogram) + one fixed caller target histogram; the native delta {1:-13,2:-46,3:-7,4:-40,5:+4,6:+43,8:+1} is recounted from the words and has total rank zero; the helper delta is empty; both words have a legal chart chronology; nine moment signs hold, with a measured crossing between 0.00370007 and 0.00370008; the derivative bounds are negative; and ten controls reject.", + "author": "fluorine", + "ai_assistance": "Prepared with substantial Anthropic Claude (Claude Code) assistance: task selection, verifier code, runs and text. No independent human review of the mathematics.", + "open_questions": [ + { + "question": "Recount the ordinary bill of the #7637 word, and the PR tariff of 4,000 ordinary units per lifetime pair, 32 scalar services per INIT or CLEAR and coefficient 2^20 per service.", + "why_it_matters": "The moment does not depend on them, but the 10^9 allowance does.", + "first_step": "Count the route, scalar and odd-division items of the word with the formula that #7633 names and compare with the PR figures.", + "blocked_by": "The formula lives in repository scripts that this audit did not read." + }, + { + "question": "Show that a common whole-private-extent supplier covers all 233 lifetimes and the changed entrance initial[457] = 281.", + "why_it_matters": "#7637 states that no admitted supplier exists. The claim is conditional on one.", + "first_step": "Start with the obligations in CONDITIONS.md of #7637.", + "blocked_by": "This is outside a count audit and needs the #7113 caller." + }, + { + "question": "Replay the reconstruction, the native route and the signed route of #7637 on a Python 3.12 runner with the external #7334 archive.", + "why_it_matters": "This audit does not run any application stage. The PR reuses earlier author receipts.", + "first_step": "Download the pinned archive, check its hash and run the reconstruct command of the PR README.", + "blocked_by": "This machine has no Python 3.12." + } + ] +} diff --git a/research/pr7637-independent-recount/VERIFY.json b/research/pr7637-independent-recount/VERIFY.json new file mode 100644 index 0000000000..52997ba346 --- /dev/null +++ b/research/pr7637-independent-recount/VERIFY.json @@ -0,0 +1,26 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/pr7637-independent-recount/inputs/pr7637/base-7633-word.json.gz", + "research/pr7637-independent-recount/inputs/pr7637/word-7637.json.gz", + "research/pr7637-independent-recount/inputs/pr7637/invoice-7633.json", + "research/pr7637-independent-recount/inputs/pr7637/invoice-7637.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "-W", + "error", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Input pins and the canonical word digests stated by #7633 and #7637; opcode and ownership census of the #7637 word; complete chart chronology of both words; GF(2) MOVE rank recount and 17-call paid split; helper target recount and 17-call target split; nine moment signs, strict monotonicity and a tent-tariff test with an independent 256-bit interval engine; ten rejecting controls." + } + ] +} diff --git a/research/pr7637-independent-recount/inputs/pr7637/base-7633-word.json.gz b/research/pr7637-independent-recount/inputs/pr7637/base-7633-word.json.gz new file mode 100644 index 0000000000..c51b08bf0f Binary files /dev/null and b/research/pr7637-independent-recount/inputs/pr7637/base-7633-word.json.gz differ diff --git a/research/pr7637-independent-recount/inputs/pr7637/invoice-7633.json b/research/pr7637-independent-recount/inputs/pr7637/invoice-7633.json new file mode 100644 index 0000000000..c17c558206 --- /dev/null +++ b/research/pr7637-independent-recount/inputs/pr7637/invoice-7633.json @@ -0,0 +1,47 @@ +{ + "contract": { + "ambient_rank": 145, + "boundary": "complete signed #7113 caller application with 17 native calls", + "model": "mixed-target-unnormalized-power-v1", + "rank_semantics": "H_r costs r^(1-C); debit surrendered productive fields" + }, + "paid": { + "1": 68027, + "16": 416, + "2": 16184, + "24": 416, + "3": 10489, + "32": 416, + "4": 5168, + "40": 416, + "48": 416, + "5": 6018, + "56": 416, + "6": 442, + "64": 208, + "7": 187, + "8": 758, + "9": 32 + }, + "schema": "integer-mult-recursive-invoice/v1", + "targets": { + "1": 306, + "137": 208, + "17": 416, + "2": 357, + "25": 416, + "3": 799, + "33": 416, + "4": 3825, + "41": 416, + "49": 416, + "5": 1360, + "57": 416, + "6": 748, + "65": 416, + "7": 323, + "73": 208, + "8": 544, + "9": 10871 + } +} diff --git a/research/pr7637-independent-recount/inputs/pr7637/invoice-7637.json b/research/pr7637-independent-recount/inputs/pr7637/invoice-7637.json new file mode 100644 index 0000000000..014fcc9fd0 --- /dev/null +++ b/research/pr7637-independent-recount/inputs/pr7637/invoice-7637.json @@ -0,0 +1,47 @@ +{ + "schema": "integer-mult-recursive-invoice/v1", + "contract": { + "model": "mixed-target-unnormalized-power-v1", + "rank_semantics": "H_r costs r^(1-C); debit surrendered productive fields", + "ambient_rank": 145, + "boundary": "complete signed #7113 caller application with 17 native calls" + }, + "paid": { + "1": 67806, + "2": 15402, + "3": 10370, + "4": 4488, + "5": 6086, + "6": 1173, + "7": 187, + "8": 775, + "9": 32, + "16": 416, + "24": 416, + "32": 416, + "40": 416, + "48": 416, + "56": 416, + "64": 208 + }, + "targets": { + "1": 306, + "2": 357, + "3": 799, + "4": 3825, + "5": 1360, + "6": 748, + "7": 323, + "8": 544, + "9": 10871, + "17": 416, + "25": 416, + "33": 416, + "41": 416, + "49": 416, + "57": 416, + "65": 416, + "73": 208, + "137": 208 + } +} diff --git a/research/pr7637-independent-recount/inputs/pr7637/word-7637.json.gz b/research/pr7637-independent-recount/inputs/pr7637/word-7637.json.gz new file mode 100644 index 0000000000..e26b6c3d89 Binary files /dev/null and b/research/pr7637-independent-recount/inputs/pr7637/word-7637.json.gz differ diff --git a/research/pr7637-independent-recount/verify.py b/research/pr7637-independent-recount/verify.py new file mode 100644 index 0000000000..b172103185 --- /dev/null +++ b/research/pr7637-independent-recount/verify.py @@ -0,0 +1,512 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Independent recount of the PR #7637 word, paid and target invoices. + +Imports no constructor, application or pricing engine from the audited PR. +Scope: finite checks on pinned bytes. Not a supplier admission. +""" +import argparse +import collections +import copy +import gzip +import hashlib +import json +import sys +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).absolute().parent +INPUTS = HERE / 'inputs' / 'pr7637' +PR_HEAD = '32e3853b2250f1971932919cbbc01348cd8245be' +# SHA256 of the vendored bytes. They must equal the PR head blobs. +PINS = { + 'base-7633-word.json.gz': + '49bd1b5527e5c0de1ba22101a167a66d0d7ab0fd6665569a2cb1648e71ed5ff0', + 'word-7637.json.gz': + 'd7eb204bb24b2e1b5a3e4ebc282d346a4706ddd738004929d1e9ac345085a79a', + 'invoice-7633.json': + 'f0c0fb377df557197b391a80a918da1e37d2a2ed707d1b4971d881c2c441bc3b', + 'invoice-7637.json': + 'c35c9d04c8b237b9cf384b3e8b759b67b3736d238e1cb695b462a95b7091997b', +} +# Canonical JSON digests that the READMEs of #7633 and #7637 state. +STATED = { + 'base-7633-word.json.gz': + '4961e5e9351fa532a51eb8ff2b534bab6acd50cfd35972027cc483810cf635c3', + 'word-7637.json.gz': + '8ab3d9dbe2e2e24202ac96c6122b010b3e7980912f935cc0cc2db2e9d85f83aa', +} +CENSUS = {'INIT': 233, 'ADD': 68049, 'SCALE': 3890, 'MOVE': 6191, + 'CLEAR': 233} +PEAK_OWNED = 50 +OWNED_LABELS = 52 +CALLS = 17 +CLAIM = Q(37, 10000) +# The crossing of this audit is measured. The PR states only the claim. +CROSS_LO = Q('0.00370007') +CROSS_HI = Q('0.00370008') +TESTED_7633 = Q('0.00366719319432207') +KAPPA_7633 = Q('0.003667193194322') +ABOVE_7633 = Q('0.0036672') +CLAIM_7636 = Q('0.0036807241001') +BIT_CAP = Q('0.00376669') +# Native MOVE rank change per call that the PR reports. This audit measures it. +NATIVE_DELTA = {1: -13, 2: -46, 3: -7, 4: -40, 5: 4, 6: 43, 8: 1} +HELPER_DELTA = {} +RANK_SURPLUS = 1424 + + +class Reject(Exception): + pass + + +def require(ok, message): + if not ok: + raise Reject(message) + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def load_word(raw): + return json.loads(gzip.decompress(raw)) + + +# ---------------------------------------------------------------- GF(2) ranks + +def gf2_rank(vectors): + basis = {} + for v in vectors: + while v: + top = v.bit_length() - 1 + if top not in basis: + basis[top] = v + break + v ^= basis[top] + return len(basis) + + +def move_rank(frames, a, b): + """Rank dim(A+B) - dim(A meet B), and whether the two frames are nested.""" + ra, rb = gf2_rank(frames[a]), gf2_rank(frames[b]) + ru = gf2_rank(frames[a] + frames[b]) + return 2 * ru - ra - rb, ru == max(ra, rb) + + +def move_histogram(word): + frames = word['frames'] + hist = collections.Counter() + for e in word['program']: + if e[0] == 'MOVE': + r, nested = move_rank(frames, e[2], e[3]) + require(nested, 'a MOVE joins two frames that are not nested') + require(r > 0, 'a MOVE has rank zero') + hist[r] += 1 + return hist + + +def growth_only_histogram(word): + # Wrong law for the negative control: charge only dim(A+B) - dim(A). + frames = word['frames'] + hist = collections.Counter() + for e in word['program']: + if e[0] == 'MOVE': + r = gf2_rank(frames[e[2]] + frames[e[3]]) - gf2_rank(frames[e[2]]) + if r: + hist[r] += 1 + return hist + + +def caller_part(word_hist, invoice): + paid = {int(r): n for r, n in invoice['paid'].items()} + rest = collections.Counter(paid) + for r, n in word_hist.items(): + rest[r] -= CALLS * n + require(all(n >= 0 for n in rest.values()), 'paid is below the word count') + return {r: n for r, n in sorted(rest.items()) if n} + + +# ------------------------------------------------------- chart chronology + +def chronology(word): + """Follow the chart of each field through the complete program.""" + require(len(word['initial']) == word['public'] == len(word['final']), + 'public field header') + chart = dict(enumerate(word['initial'])) + owned = set() + nframes = len(word['frames']) + for i, e in enumerate(word['program']): + op = e[0] + where = '%s at event %d' % (op, i) + if op == 'MOVE': + require(len(e) == 5 and e[2] != e[3] and 0 <= e[3] < nframes, where) + require(chart.get(e[1]) == e[2], where + ': source chart') + require(e[4] is (e[1] in owned), where + ': owner flag') + chart[e[1]] = e[3] + elif op in ('ADD', 'COPY'): + require(len(e) == 5 and e[1] != e[2], where) + require(chart.get(e[1]) == e[4] == chart.get(e[2]), + where + ': operands are not at the stated chart') + elif op == 'SCALE': + require(len(e) == 4 and chart.get(e[1]) == e[3], where + ': chart') + elif op == 'INIT': + require(len(e) == 3 and e[1] not in chart, where + ': live field') + require(e[1] >= word['public'], where + ': public field') + chart[e[1]] = e[2] + owned.add(e[1]) + elif op == 'CLEAR': + require(len(e) == 3 and e[1] in owned, where + ': not owned') + require(chart[e[1]] == e[2], where + ': chart') + del chart[e[1]] + owned.remove(e[1]) + else: + raise Reject(where + ': unknown opcode') + require(not owned, 'an owned field stays live at the end') + require([chart[f] for f in range(word['public'])] == word['final'], + 'final charts') + return {'events': len(word['program']), 'fields': len(chart)} + + +# ------------------------------------------- exact interval moment engine + +BITS = 256 +ONE = 1 << BITS + + +def _atanh_inv(q): + """Integer bounds of atanh(1/q) * 2^BITS for an integer q >= 3.""" + lo = hi = 0 + j = 0 + while True: + den = (2 * j + 1) * q ** (2 * j + 1) + lo += ONE // den + hi += -(-ONE // den) + j += 1 + if den > ONE: + break + # Tail < next_term / (1 - q^-2) <= 2 * next_term, and next_term < 1 ulp. + return lo, hi + 2 + + +def log_table(top): + """ln(n) bounds from ln(n) = ln(n-1) + 2 atanh(1/(2n-1)).""" + table = {1: (0, 0)} + for n in range(2, top + 1): + a, b = _atanh_inv(2 * n - 1) + table[n] = (table[n - 1][0] + 2 * a, table[n - 1][1] + 2 * b) + return table + + +def _exp_bounds(y_lo, y_hi): + """Bounds of exp(y) * 2^BITS for 0 <= y < 8, y scaled by 2^BITS.""" + require(0 <= y_lo <= y_hi < 8 * ONE, 'exp domain') + lo, term = ONE, ONE + n = 0 + while term: + n += 1 + term = term * y_lo // (n * ONE) + lo += term + hi, term = ONE, ONE + n = 0 + while n < 32 or term > 1: + n += 1 + term = -(-term * y_hi // (n * ONE)) + hi += term + # n >= 32 > 2 * y_hi, so the tail is below the last term, which is <= 1. + return lo, hi + 2 + + +def moment_bounds(signed, kappa, logs): + """Bounds of sum_r signed[r] * r^(1-kappa), as exact rationals.""" + p = 1 - kappa + require(0 < p <= 1, 'exponent domain') + lo = hi = 0 + for r, s in signed.items(): + l_lo, l_hi = logs[r] + y_lo = l_lo * p.numerator // p.denominator + y_hi = -(-l_hi * p.numerator // p.denominator) + e_lo, e_hi = _exp_bounds(y_lo, y_hi) + lo += s * (e_lo if s > 0 else e_hi) + hi += s * (e_hi if s > 0 else e_lo) + return Q(lo, ONE), Q(hi, ONE) + + +def derivative_upper(signed, cap, logs): + """Upper bound of d/dkappa of the moment on the interval [0, cap].""" + total = 0 + for r, s in signed.items(): + if r == 1 or s == 0: + continue + l_lo, l_hi = logs[r] + if s > 0: + # -s ln(r) r^(1-kappa) is largest at kappa = cap. + e_lo = moment_bounds({r: 1}, cap, logs)[0] + total -= s * Q(l_lo, ONE) * e_lo + else: + # |s| ln(r) r^(1-kappa) is largest at kappa = 0. + total += -s * Q(l_hi, ONE) * r + return total + + +def signed_profile(invoice): + out = collections.Counter() + for r, n in invoice['targets'].items(): + out[int(r)] += n + for r, n in invoice['paid'].items(): + out[int(r)] -= n + return {r: s for r, s in out.items() if s} + + +def sign_at(signed, kappa, logs): + lo, hi = moment_bounds(signed, kappa, logs) + require(lo > 0 or hi < 0, 'moment sign is not resolved') + return 1 if lo > 0 else -1 + + + + +# ------------------------------------------------------------- recounts + +def diff(a, b): + d = collections.Counter(b) + d.subtract(a) + return {k: v for k, v in sorted(d.items()) if v} + + +def mains(word): + """Main fields as the PR defines them. Other public fields are helpers.""" + live = set(word['live']) + hosted = word['hosted'] + shifted = {r + 112 for r in live} + return live | shifted | set(hosted['X2']) | set(hosted['Y2']) + + +def helper_targets(word): + """Per call: rank(final frame) - rank(initial frame), for each helper.""" + ranks = [gf2_rank(f) for f in word['frames']] + main = mains(word) + out = collections.Counter() + for r in range(word['public']): + if r not in main: + d = ranks[word['final'][r]] - ranks[word['initial'][r]] + require(d > 0, 'helper %d has no productive rank' % r) + out[d] += 1 + return out + + +def target_rest(helpers, invoice): + """Targets left after the helpers of all calls. Word-independent.""" + rest = collections.Counter( + {int(r): n for r, n in invoice['targets'].items()}) + for r, n in helpers.items(): + rest[r] -= CALLS * n + require(all(n >= 0 for n in rest.values()), 'targets are below the count') + return {r: n for r, n in sorted(rest.items()) if n} + + +def uniform_gain(old_s, new_s): + """Smallest and largest gain over the tents min(r, a), a = 1 .. max rank.""" + d = collections.Counter(new_s) + d.subtract(old_s) + top = max(max(old_s), max(new_s)) + gains = [sum(s * min(r, a) for r, s in d.items()) + for a in range(1, top + 1)] + return min(gains), max(gains) + + +def check_moments(old_inv, new_inv): + for inv in (old_inv, new_inv): + model = inv['contract']['model'] + require(model == 'mixed-target-unnormalized-power-v1', 'invoice model') + old, new = signed_profile(old_inv), signed_profile(new_inv) + logs = log_table(max(max(old), max(new))) + for profile in (old, new): + lo, hi = moment_bounds(profile, Q(0), logs) + exact = sum(r * s for r, s in profile.items()) + tight = hi - lo < Q(1, 1 << 200) + require(lo <= exact <= hi and tight, 'engine self-test') + require(exact == RANK_SURPLUS, 'rank surplus') + wanted = [('#7637 at claim', new, CLAIM, 1), + ('#7637 below measured crossing', new, CROSS_LO, 1), + ('#7637 above measured crossing', new, CROSS_HI, -1), + ('#7637 at #7636 claim', new, CLAIM_7636, 1), + ('#7637 at #7633 value', new, KAPPA_7633, 1), + ('#7637 at bit cap', new, BIT_CAP, -1), + ('#7633 at tested point', old, TESTED_7633, 1), + ('#7633 above its value', old, ABOVE_7633, -1), + ('#7633 at #7637 claim', old, CLAIM, -1)] + for label, profile, kappa, sign in wanted: + require(sign_at(profile, kappa, logs) == sign, label + ': sign') + require(TESTED_7633 < ABOVE_7633 < CLAIM_7636 < CLAIM < CROSS_LO + < CROSS_HI < BIT_CAP, 'point order') + ratio = float(CLAIM / KAPPA_7633) + slopes = [derivative_upper(x, BIT_CAP, logs) for x in (old, new)] + require(all(s < 0 for s in slopes), 'moment is not strictly decreasing') + low, high = uniform_gain(old, new) + require(low >= 0 and high > 0, 'not better for every tent tariff') + return {'points': [label for label, _, _, _ in wanted], + 'derivative_upper_7633': float(slopes[0]), + 'derivative_upper_7637': float(slopes[1]), + 'tent_gain_min_max': [low, high], + 'ratio_over_7633': ratio, 'interval': ['0', str(BIT_CAP)], + 'engine_bits': BITS}, logs + + +# ------------------------------------------------------------------ controls + +def rejects(fn, *args): + try: + fn(*args) + except Reject: + return True + return False + + +def controls(old, new, old_inv, new_inv, logs): + seen = [] + + def control(name, ok): + require(ok, 'control did not reject: ' + name) + seen.append(name) + + h_old, h_new = move_histogram(old), move_histogram(new) + k_old, k_new = caller_part(h_old, old_inv), caller_part(h_new, new_inv) + # 1. A rank law that charges only frame growth does not fit the invoice. + wrong = growth_only_histogram(new) + control('growth-only rank law', + rejects(caller_part, wrong, new_inv) + or caller_part(wrong, new_inv) != k_new) + # 2. One more paid unit in the invoice. + bad = copy.deepcopy(new_inv) + bad['paid']['1'] += 1 + control('invoice paid unit', caller_part(h_new, bad) != k_new) + # 3. The new invoice with the old word. + control('old word with new invoice', + rejects(caller_part, h_old, new_inv) + or caller_part(h_old, new_inv) != k_old) + # 4. A dropped MOVE breaks the chart chronology. + index = next(i for i, e in enumerate(new['program']) if e[0] == 'MOVE') + bad = copy.deepcopy(new) + del bad['program'][index] + control('dropped MOVE', rejects(chronology, bad)) + # 5. A changed initial chart breaks the chart chronology. + bad = copy.deepcopy(new) + bad['initial'][457] += 1 + control('changed initial chart', rejects(chronology, bad)) + # 6. An ADD at the wrong chart. + index = next(i for i, e in enumerate(new['program']) if e[0] == 'ADD') + bad = copy.deepcopy(new) + bad['program'][index][4] += 1 + control('ADD at the wrong chart', rejects(chronology, bad)) + # 7. A MOVE that lands on another chart. + index = next(i for i, e in enumerate(new['program']) if e[0] == 'MOVE') + bad = copy.deepcopy(new) + event = bad['program'][index] + event[3] = (event[3] + 1) % len(bad['frames']) + control('MOVE to another chart', rejects(chronology, bad)) + # 8. A frame vector change breaks nestedness or the paid count. + move = next(e for e in new['program'] if e[0] == 'MOVE') + bad = copy.deepcopy(new) + bad['frames'][move[3]] = bad['frames'][move[3]] + [1 << 20] + control('changed frame', + rejects(move_histogram, bad) + or caller_part(move_histogram(bad), new_inv) != k_new) + # 9. The #7633 invoice does not support the #7637 claim. + control('#7633 invoice at claim', + sign_at(signed_profile(old_inv), CLAIM, logs) == -1) + # 10. A point above the stated bracket is not positive. + higher = CROSS_HI + Q(1, 10 ** 12) + control('#7637 above crossing', + sign_at(signed_profile(new_inv), higher, logs) == -1) + return seen + + +# ---------------------------------------------------------------------- main + +def census(word): + ops = collections.Counter(e[0] for e in word['program']) + live, peak, labels = set(), 0, set() + for e in word['program']: + if e[0] == 'INIT': + live.add(e[1]) + labels.add(e[1]) + peak = max(peak, len(live)) + elif e[0] == 'CLEAR': + live.discard(e[1]) + return dict(sorted(ops.items())), peak, len(labels) + + +def audit(raw): + for name, pin in PINS.items(): + require(sha(raw[name]) == pin, 'input pin ' + name) + old = load_word(raw['base-7633-word.json.gz']) + new = load_word(raw['word-7637.json.gz']) + old_inv = json.loads(raw['invoice-7633.json']) + new_inv = json.loads(raw['invoice-7637.json']) + canon = {} + for name, word in (('base-7633-word.json.gz', old), + ('word-7637.json.gz', new)): + canon[name] = sha(json.dumps(word, sort_keys=True, + separators=(',', ':')).encode()) + require(canon[name] == STATED[name], 'canonical digest ' + name) + + same = [k for k in old if k not in ('program', 'initial')] + require(old.keys() == new.keys() and all(old[k] == new[k] for k in same), + 'word headers differ beyond initial charts') + require(old['initial'] == new['initial'], 'initial charts changed') + require(new['initial'][457] == 281, 'entrance of field 457') + ops, peak, labels = census(new) + require(ops == CENSUS and len(new['program']) == 78596, 'opcode census') + require((peak, labels) == (PEAK_OWNED, OWNED_LABELS), 'owned census') + report = {'canonical_word_digests': canon, 'census': ops, + 'peak_owned': peak, 'owned_labels_used': labels, + 'chronology': {'7633': chronology(old), '7637': chronology(new)}} + + h_old, h_new = move_histogram(old), move_histogram(new) + delta = diff(h_old, h_new) + require(delta == NATIVE_DELTA, 'native MOVE rank delta') + require((sum(h_old.values()), sum(h_new.values())) == (6249, 6191), + 'native MOVE count') + require(sum(r * n for r, n in delta.items()) == 0, 'total MOVE rank') + k_old, k_new = caller_part(h_old, old_inv), caller_part(h_new, new_inv) + require(k_old == k_new, 'caller part of the paid profile changed') + ht_old, ht_new = helper_targets(old), helper_targets(new) + hdelta = diff(ht_old, ht_new) + require(hdelta == HELPER_DELTA, 'helper target delta') + tk_old, tk_new = target_rest(ht_old, old_inv), target_rest(ht_new, new_inv) + require(tk_old == tk_new, 'caller part of the target profile changed') + paid = [sum(x['paid'].values()) for x in (old_inv, new_inv)] + targets = [sum(x['targets'].values()) for x in (old_inv, new_inv)] + require(paid == [110009, 109023] and targets[0] == targets[1], + 'invoice position counts') + require(paid[0] - paid[1] == CALLS * (6249 - 6191), 'paid saving') + report['recount'] = { + 'law': 'rank(a->b) = dim(A+B) - dim(A meet B) over GF(2); all nested', + 'moves_7633': dict(sorted(h_old.items())), + 'moves_7637': dict(sorted(h_new.items())), + 'native_delta_per_call': delta, 'helper_delta_per_call': hdelta, + 'calls': CALLS, 'caller_paid_part': k_new, + 'caller_target_part': tk_new, 'paid_positions': paid, + 'target_positions': targets} + report['moments'], logs = check_moments(old_inv, new_inv) + report['controls'] = controls(old, new, old_inv, new_inv, logs) + return report + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.parse_args() + raw = {name: (INPUTS / name).read_bytes() for name in PINS} + report = audit(raw) + report['status'] = 'PASS_INDEPENDENT_RECOUNT_PR7637_DECLARED_SCOPE' + report['scope'] = ('Finite recount of pinned bytes at PR head ' + PR_HEAD + + '. Not a native, physical, compiler or outer admission.') + print(json.dumps(report, indent=1, sort_keys=True)) + + +if __name__ == '__main__': + try: + main() + except Reject as error: + sys.exit('REJECT: %s' % error)