diff --git a/research/pr7636-independent-recount/.gitattributes b/research/pr7636-independent-recount/.gitattributes new file mode 100644 index 0000000000..b13bbf03d0 --- /dev/null +++ b/research/pr7636-independent-recount/.gitattributes @@ -0,0 +1 @@ +inputs/** -text \ No newline at end of file diff --git a/research/pr7636-independent-recount/README.md b/research/pr7636-independent-recount/README.md new file mode 100644 index 0000000000..9cf74b5637 --- /dev/null +++ b/research/pr7636-independent-recount/README.md @@ -0,0 +1,127 @@ +# Independent recount of the PR #7636 word and invoices + +**No new κ. No frontier change. No supplier admission.** This package is an +independent finite audit of the open candidate +[PR #7636](https://github.com/CrocSwap/integer-mult-bounds/pull/7636) by +DreamingOfClouds at exact head `7e68d8dd62d9a38c0f3c942262a7a85ca7125b75` +(conditional κ = 0.0036807241001, 22 swap-then-delete composites on the #7630 +word). It applies the method of +[PR #7628](https://github.com/CrocSwap/integer-mult-bounds/pull/7628), +[PR #7635](https://github.com/CrocSwap/integer-mult-bounds/pull/7635) and +[PR #7638](https://github.com/CrocSwap/integer-mult-bounds/pull/7638). + +## Why this check adds coverage + +#7636 ships a complete paid and target invoice for its word. The invoice is the +#7630 invoice plus a declared change. This package binds that change to the word +bytes with separate counts that run in about two seconds. `verify.py` imports no +constructor, application or pricing engine from #7636. No audit of #7636 was +found among the open PRs on 2026-11-17. + +## Result + +All statements are about the four pinned files in `inputs/pr7636/`. Their bytes +equal the blobs at the PR head (see [SOURCES.json](SOURCES.json)). The base word +and base invoice equal the #7630 word and invoice, byte for byte. + +1. **Header.** The two words are equal except `program`. No initial chart + changes. +2. **Chart chronology.** Each field is followed through the complete program of + both words (208,738 and 202,668 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. +3. **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 and #7633 + recounts. The native MOVE change per call is + `{2:-18, 3:-6, 4:-20, 6:+20, 7:+2}`. The MOVE count goes from 6,250 to 6,228 + and the total rank of the change is zero. Paid positions go from 110,026 to + 109,652, which is 17 · 22 fewer. +4. **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. +5. **Moment signs.** A separate 256-bit integer interval engine evaluates + `M(κ) = Σ (T_r - P_r) r^(1-κ)`. Its signs agree with the PR at ten points. + The #7636 invoice is positive at the claim `0.0036807241001`, at the #7633 + value `0.003667193194322`, at the #7630 claim `0.0036667343458` and at the + #7627 value `0.003665731276`. It is negative at the upper bracket + `0.0036807241002`. It is positive at `c - 10^-30` and negative at + `c + 10^-30`, with `c = 0.00368072410014727862067955898005` the crossing + that the PR states. The #7630 invoice is positive at its own claim, negative + just above it and negative at the #7636 claim. The ratio of the claim to + the #7633 value is 1.00368972. The upper bounds of `dM/dκ` on + `[0, 0.00376669]` are negative for both invoices (`-379386.789…` and + `-377942.182…`), so each crossing is unique there. +6. **Tent test.** The change in the moment is zero or positive for every tariff + `min(r, a)` and positive for some a. So #7636 is no worse than #7630 for + every increasing concave tariff with `f(0) = 0`. +7. **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 bracket. + +## What this does not establish + +- `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 22 composites in `data/edits.json` are not applied to the #7630 word. This + audit binds the finished word to the invoice. It does not check each edit + against the swap law of #7634. +- The exact rational replay of the hub re-settle, the 180 CLEAR certificates + (151 change) and the affected-pair census (1,023 pairs) are not recounted. +- The ordinary bill is not recounted. #7636 states 859,783,396 (from + 867,014,040 for #7630), below 10^9. About 140 million of the allowance remain. +- The native, physical, signed, compiler, precision, tape and outer checks are + not replayed. +- The five framework assumptions and the premises that #7636 inherits from #7630 + and #7620 remain as stated. 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/pr7636-independent-recount --check-only +python3 scripts/research_package.py --package research/pr7636-independent-recount +python3 -I -B research/pr7636-independent-recount/verify.py +``` + +Environment of the recorded run: CPython 3.13.9, Windows 11, about 2 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 with the formula the PR names. Blocker: that + formula lives in repository scripts that this audit did not read. +2. Apply the 22 edits of `data/edits.json` to the #7630 word and compare with the + #7636 word. Blocker: the coordinate convention needs a careful read. +3. Replay the 180 CLEAR certificates and the census on a Python 3.12 runner. + +## Credit + +The audited construction, word, invoices and claim are by DreamingOfClouds +(#7636, #7630, #7623), on the swap device of SYLforge (#7616, #7620) and the P104 +lineage of Clear1nsight, Ali Romman, Hao Yan, ToikY, Rohan Arun and their +predecessors. The recursive invoice schema and the pricing tools belong to their +authors. 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/pr7636-independent-recount/SOURCES.json b/research/pr7636-independent-recount/SOURCES.json new file mode 100644 index 0000000000..fc9bd8fc79 --- /dev/null +++ b/research/pr7636-independent-recount/SOURCES.json @@ -0,0 +1,66 @@ +{ + "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/pr7636-independent-recount/inputs/pr7636/base-7630-word.json.gz", + "usage": "input", + "git_blob": "d652af4f8a2ef41d996b59251c036c77fef74aaa", + "sha256": "fa1a8dad12d28e6e5ced5a6989d49074efe15d6647ffc122cb28fcd666f366c2", + "origin": { + "pull_request": 7636, + "commit": "7e68d8dd62d9a38c0f3c942262a7a85ca7125b75", + "path": "research/p104-swap-composites-on7630/data/base-7630-word.json.gz" + }, + "pin": "head:f4626875c6beb8ccde35e7db22be99f99c9ac24f:research/pr7636-independent-recount/inputs/pr7636/base-7630-word.json.gz" + }, + { + "path": "research/pr7636-independent-recount/inputs/pr7636/word-7636.json.gz", + "usage": "input", + "git_blob": "e53c2271bf0bbcfdcfbc1834bc12ceeb54d52d4b", + "sha256": "1b4e33c3e3b69d1f1b42d019a2e372ac612fa28494bd8da18a734618f9bda659", + "origin": { + "pull_request": 7636, + "commit": "7e68d8dd62d9a38c0f3c942262a7a85ca7125b75", + "path": "research/p104-swap-composites-on7630/data/word.json.gz" + }, + "pin": "head:f4626875c6beb8ccde35e7db22be99f99c9ac24f:research/pr7636-independent-recount/inputs/pr7636/word-7636.json.gz" + }, + { + "path": "research/pr7636-independent-recount/inputs/pr7636/invoice-7630.json", + "usage": "input", + "git_blob": "8b5bd00eaf6e147af61b3088c5a2d6733249b40e", + "sha256": "887128e79be28ded1a8a62fc6311ccaa975e5bcf9b7868dbcc5c8bdceaa6e9d4", + "origin": { + "pull_request": 7636, + "commit": "7e68d8dd62d9a38c0f3c942262a7a85ca7125b75", + "path": "research/p104-swap-composites-on7630/data/invoice-7630.json" + }, + "pin": "head:f4626875c6beb8ccde35e7db22be99f99c9ac24f:research/pr7636-independent-recount/inputs/pr7636/invoice-7630.json" + }, + { + "path": "research/pr7636-independent-recount/inputs/pr7636/invoice-7636.json", + "usage": "input", + "git_blob": "93129ac5c420dee957ca4fa0d89505edc99d2d49", + "sha256": "18adee673515c4ece7208b53c7cc17a2e121843d55f62067d2e43e341872f0d5", + "origin": { + "pull_request": 7636, + "commit": "7e68d8dd62d9a38c0f3c942262a7a85ca7125b75", + "path": "research/p104-swap-composites-on7630/data/invoice-new.json" + }, + "pin": "head:f4626875c6beb8ccde35e7db22be99f99c9ac24f:research/pr7636-independent-recount/inputs/pr7636/invoice-7636.json" + } + ] +} diff --git a/research/pr7636-independent-recount/TASK.json b/research/pr7636-independent-recount/TASK.json new file mode 100644 index 0000000000..be6def16d2 --- /dev/null +++ b/research/pr7636-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 #7636 head 7e68d8dd62d9a38c0f3c942262a7a85ca7125b75, of (1) the header and initial-chart equality with the #7630 word, (2) the chart chronology of both complete words, (3) the MOVE rank histogram of both words and its relation to the declared 17-call paid invoices, (4) the helper target ranks of both words and their relation to the declared target invoices, and (5) the signs of the declared complete moments at the claim, at the stated crossing, at the upper bracket and at the #7633, #7630 and #7627 values. No constructor, application or pricing engine of the PR is imported.", + "scope_change_reason": "The first experiment of the card is applied to a newer exact head. No audit of #7636 was found among the open PRs on 2026-11-17. #7636 changes 22 composites of the #7630 word and re-derives the hub events jointly. The recount shows that the paid MOVE ranks change and the helper targets and initial charts do not.", + "bottleneck_link": "The complex supplier binds. #7636 changes the paid MOVE rank histogram of the P104 word. Its invoice is the #7630 invoice plus a declared per-call delta. This audit binds that delta 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 or outer stages.", + "outcome": "completed", + "evidence": "verify.py passes on CPython 3.13.9 (Windows) in about 2 s: paid = 17 x (MOVE rank histogram of the word) + one fixed caller histogram, equal for #7630 and #7636 and equal to the one of the #7612, #7630, #7631 and #7633 recounts; targets = 17 x (helper target histogram) + one fixed caller target histogram; the native delta {2:-18,3:-6,4:-20,6:+20,7:+2} is recounted from the words and has total rank zero; the helper delta and the initial-chart delta are empty; both words have a legal chart chronology; ten moment signs agree with the PR, including both sides of the stated crossing at 10^-30; 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. #7636 states 859,783,396 (from 867,014,040 for #7630), below 10^9.", + "why_it_matters": "The moment does not depend on it, but the 10^9 allowance does. About 140 million remain.", + "first_step": "Count the route, scalar and odd-division items of the word with the formula the PR names and compare with the stated total.", + "blocked_by": "The formula lives in repository scripts that this audit did not read." + }, + { + "question": "Check the 22 swap-then-delete composites in data/edits.json against the #7630 word and the swap law of #7634.", + "why_it_matters": "This audit binds the result of the edits to the invoice. It does not check that each edit is a legal rewrite of the #7630 word.", + "first_step": "Apply the 22 edits to the #7630 word and compare the interior sequence with the #7636 word.", + "blocked_by": "The coordinate convention of edits.json needs a careful read." + }, + { + "question": "Replay the 180 CLEAR certificates and the affected-pair census (1,023 pairs) under the rule of #7620.", + "why_it_matters": "151 CLEAR contents change with the re-derived hub content. A count audit does not cover them.", + "first_step": "Run the PR check.py on a Python 3.12 runner and compare its output with the pinned hashes.", + "blocked_by": "This machine has no Python 3.12." + } + ] +} diff --git a/research/pr7636-independent-recount/VERIFY.json b/research/pr7636-independent-recount/VERIFY.json new file mode 100644 index 0000000000..91c0e03305 --- /dev/null +++ b/research/pr7636-independent-recount/VERIFY.json @@ -0,0 +1,26 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/pr7636-independent-recount/inputs/pr7636/base-7630-word.json.gz", + "research/pr7636-independent-recount/inputs/pr7636/word-7636.json.gz", + "research/pr7636-independent-recount/inputs/pr7636/invoice-7630.json", + "research/pr7636-independent-recount/inputs/pr7636/invoice-7636.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "-W", + "error", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Input pins; complete chart chronology of both words; GF(2) MOVE rank recount and 17-call paid split; helper target recount and 17-call target split; ten moment signs including the stated crossing, strict monotonicity and a tent-tariff test with an independent 256-bit interval engine; ten rejecting controls." + } + ] +} diff --git a/research/pr7636-independent-recount/inputs/pr7636/base-7630-word.json.gz b/research/pr7636-independent-recount/inputs/pr7636/base-7630-word.json.gz new file mode 100644 index 0000000000..d652af4f8a Binary files /dev/null and b/research/pr7636-independent-recount/inputs/pr7636/base-7630-word.json.gz differ diff --git a/research/pr7636-independent-recount/inputs/pr7636/invoice-7630.json b/research/pr7636-independent-recount/inputs/pr7636/invoice-7630.json new file mode 100644 index 0000000000..8b5bd00eaf --- /dev/null +++ b/research/pr7636-independent-recount/inputs/pr7636/invoice-7630.json @@ -0,0 +1 @@ +{"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": 68095, "2": 15895, "3": 10948, "4": 4964, "5": 6018, "6": 425, "7": 187, "8": 758, "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": 765, "7": 323, "8": 544, "9": 10854, "17": 416, "25": 416, "33": 416, "41": 416, "49": 416, "57": 416, "65": 416, "73": 208, "137": 208}} \ No newline at end of file diff --git a/research/pr7636-independent-recount/inputs/pr7636/invoice-7636.json b/research/pr7636-independent-recount/inputs/pr7636/invoice-7636.json new file mode 100644 index 0000000000..93129ac5c4 --- /dev/null +++ b/research/pr7636-independent-recount/inputs/pr7636/invoice-7636.json @@ -0,0 +1 @@ +{"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": 68095, "2": 15589, "3": 10846, "4": 4624, "5": 6018, "6": 765, "7": 221, "8": 758, "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": 765, "7": 323, "8": 544, "9": 10854, "17": 416, "25": 416, "33": 416, "41": 416, "49": 416, "57": 416, "65": 416, "73": 208, "137": 208}} \ No newline at end of file diff --git a/research/pr7636-independent-recount/inputs/pr7636/word-7636.json.gz b/research/pr7636-independent-recount/inputs/pr7636/word-7636.json.gz new file mode 100644 index 0000000000..e53c2271bf Binary files /dev/null and b/research/pr7636-independent-recount/inputs/pr7636/word-7636.json.gz differ diff --git a/research/pr7636-independent-recount/verify.py b/research/pr7636-independent-recount/verify.py new file mode 100644 index 0000000000..47e6a533a1 --- /dev/null +++ b/research/pr7636-independent-recount/verify.py @@ -0,0 +1,479 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Independent recount of the PR #7636 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' / 'pr7636' +PR_HEAD = '7e68d8dd62d9a38c0f3c942262a7a85ca7125b75' +# SHA256 of the vendored bytes. They must equal the PR head blobs. +PINS = { + 'base-7630-word.json.gz': + 'fa1a8dad12d28e6e5ced5a6989d49074efe15d6647ffc122cb28fcd666f366c2', + 'word-7636.json.gz': + '1b4e33c3e3b69d1f1b42d019a2e372ac612fa28494bd8da18a734618f9bda659', + 'invoice-7630.json': + '887128e79be28ded1a8a62fc6311ccaa975e5bcf9b7868dbcc5c8bdceaa6e9d4', + 'invoice-7636.json': + '18adee673515c4ece7208b53c7cc17a2e121843d55f62067d2e43e341872f0d5', +} +CALLS = 17 +CLAIM = Q('0.0036807241001') +UPPER = Q('0.0036807241002') +# Exact crossing that the PR states, to 32 digits. +CROSSING = Q('0.00368072410014727862067955898005') +CROSS_EPS = Q(1, 10 ** 30) +CLAIM_7630 = Q('0.0036667343458') +ABOVE_7630 = Q('0.0036667343459') +KAPPA_7633 = Q('0.003667193194322') +KAPPA_7627 = Q('0.003665731276') +BIT_CAP = Q('0.00376669') +# Native MOVE rank change per call that the PR reports. This audit measures it. +NATIVE_DELTA = {2: -18, 3: -6, 4: -20, 6: 20, 7: 2} +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 = [('#7636 at claim', new, CLAIM, 1), + ('#7636 at upper bracket', new, UPPER, -1), + ('#7636 below crossing', new, CROSSING - CROSS_EPS, 1), + ('#7636 above crossing', new, CROSSING + CROSS_EPS, -1), + ('#7636 at #7633 value', new, KAPPA_7633, 1), + ('#7636 at #7630 claim', new, CLAIM_7630, 1), + ('#7636 at #7627 value', new, KAPPA_7627, 1), + ('#7630 at its claim', old, CLAIM_7630, 1), + ('#7630 above its claim', old, ABOVE_7630, -1), + ('#7630 at #7636 claim', old, CLAIM, -1)] + for label, profile, kappa, sign in wanted: + require(sign_at(profile, kappa, logs) == sign, label + ': sign') + require(KAPPA_7627 < CLAIM_7630 < ABOVE_7630 < KAPPA_7633 < CLAIM + < CROSSING < UPPER < BIT_CAP, 'point order') + ratio = float(CLAIM / KAPPA_7633) + require(round(ratio, 8) == 1.00368972, 'ratio over #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_7630': float(slopes[0]), + 'derivative_upper_7636': 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 #7630 invoice does not support the #7636 claim. + control('#7630 invoice at claim', + sign_at(signed_profile(old_inv), CLAIM, logs) == -1) + # 10. A point above the stated bracket is not positive. + higher = UPPER + Q(1, 10 ** 12) + control('#7636 above bracket', + sign_at(signed_profile(new_inv), higher, logs) == -1) + return seen + + +# ---------------------------------------------------------------------- main + +def audit(raw): + for name, pin in PINS.items(): + require(sha(raw[name]) == pin, 'input pin ' + name) + old = load_word(raw['base-7630-word.json.gz']) + new = load_word(raw['word-7636.json.gz']) + old_inv = json.loads(raw['invoice-7630.json']) + new_inv = json.loads(raw['invoice-7636.json']) + + 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') + report = {'chronology': {'7630': chronology(old), '7636': 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())) == (6250, 6228), + '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 == [110026, 109652] and targets[0] == targets[1], + 'invoice position counts') + require(paid[0] - paid[1] == CALLS * (6250 - 6228), 'paid saving') + report['recount'] = { + 'law': 'rank(a->b) = dim(A+B) - dim(A meet B) over GF(2); all nested', + 'moves_7630': dict(sorted(h_old.items())), + 'moves_7636': 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_PR7636_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)