From 0cbd427c2ff023b063b705fc6e503ad8dc83ba60 Mon Sep 17 00:00:00 2001 From: Sagar Thakrar Date: Sun, 18 Oct 2026 20:40:55 +0530 Subject: [PATCH 1/2] Independently verify PR3633's T488 allocation, ceiling and endpoint (no kappa) Standard-library audit of hexapode's PR #3633 (head 72c268f1) that never imports or runs PR3633, PR3630 or PR3605 code: - all 1,791,936 literal owner roles (journal bound to PR3633's payload pin); - an own fixed-inventory LP with a rigorous dual: the profile is 488 x the unique LP minimum, so within the fixed model no allocation for any T does better; - both staged supplier words through the PR3053 word lineage; - the endpoint in two enclosures with exact gains, and PR3653's endpoint on the same journal with the dual re-certified there; - a proof that the five reject() controls kept in PR3605's adapted owner auditor cannot fail (15 copies across eight PR heads). 212/212 negative controls; 45/45 checker mutations killed; RESULT.json reproduced under CPython 3.14.4 and 3.12.15. Co-Authored-By: Claude Opus 5.5 --- research/t488-independent-audit/README.md | 279 +++ research/t488-independent-audit/RESULT.json | 2066 +++++++++++++++++ research/t488-independent-audit/SOURCES.json | 690 ++++++ research/t488-independent-audit/TASK.json | 100 + research/t488-independent-audit/VERIFY.json | 20 + .../t488-independent-audit/audit_ceiling.py | 873 +++++++ .../t488-independent-audit/audit_endpoint.py | 232 ++ .../audit_inherited_controls.py | 938 ++++++++ .../t488-independent-audit/audit_owners.py | 559 +++++ .../audit_staged_words.py | 506 ++++ .../data/FILL-columns.xz | Bin 0 -> 769472 bytes .../evidence/GATE-DISABLE-DEMO.json | 126 + .../evidence/NATIVE-REPRODUCTION.json | 582 +++++ .../tools/encode_journal.py | 34 + .../tools/gate_disable_demo.py | 72 + .../t488-independent-audit/vendor/NOTICE.md | 34 + .../vendor/pr3053/audit_common.py | 216 ++ .../vendor/pr3053/audit_kappa.py | 202 ++ .../vendor/pr3053/audit_lib.py | 396 ++++ .../vendor/pr3053/audit_words.py | 128 + .../vendor/pr3053/check_accounting.py | 638 +++++ .../vendor/pr3053/check_words.py | 1017 ++++++++ .../vendor/pr3053/fill_check80.py | 1285 ++++++++++ .../vendor/pr3053/words_check.py | 1294 +++++++++++ research/t488-independent-audit/verify.py | 512 ++++ 25 files changed, 12799 insertions(+) create mode 100644 research/t488-independent-audit/README.md create mode 100644 research/t488-independent-audit/RESULT.json create mode 100644 research/t488-independent-audit/SOURCES.json create mode 100644 research/t488-independent-audit/TASK.json create mode 100644 research/t488-independent-audit/VERIFY.json create mode 100644 research/t488-independent-audit/audit_ceiling.py create mode 100644 research/t488-independent-audit/audit_endpoint.py create mode 100644 research/t488-independent-audit/audit_inherited_controls.py create mode 100644 research/t488-independent-audit/audit_owners.py create mode 100644 research/t488-independent-audit/audit_staged_words.py create mode 100644 research/t488-independent-audit/data/FILL-columns.xz create mode 100644 research/t488-independent-audit/evidence/GATE-DISABLE-DEMO.json create mode 100644 research/t488-independent-audit/evidence/NATIVE-REPRODUCTION.json create mode 100644 research/t488-independent-audit/tools/encode_journal.py create mode 100644 research/t488-independent-audit/tools/gate_disable_demo.py create mode 100644 research/t488-independent-audit/vendor/NOTICE.md create mode 100644 research/t488-independent-audit/vendor/pr3053/audit_common.py create mode 100644 research/t488-independent-audit/vendor/pr3053/audit_kappa.py create mode 100644 research/t488-independent-audit/vendor/pr3053/audit_lib.py create mode 100644 research/t488-independent-audit/vendor/pr3053/audit_words.py create mode 100644 research/t488-independent-audit/vendor/pr3053/check_accounting.py create mode 100644 research/t488-independent-audit/vendor/pr3053/check_words.py create mode 100644 research/t488-independent-audit/vendor/pr3053/fill_check80.py create mode 100644 research/t488-independent-audit/vendor/pr3053/words_check.py create mode 100644 research/t488-independent-audit/verify.py diff --git a/research/t488-independent-audit/README.md b/research/t488-independent-audit/README.md new file mode 100644 index 0000000000..83a2d26402 --- /dev/null +++ b/research/t488-independent-audit/README.md @@ -0,0 +1,279 @@ +# Independent verification of PR #3633 (T488): literal owners, fixed-inventory ceiling, staged words (no κ) + +**Object.** Open [PR #3633](https://github.com/CrocSwap/integer-mult-bounds/pull/3633) (hexapode, Pierre-Loic +Doulcet; head `72c268f113368ea0387d188225e3f81ba6d6ef73`, package `research/staged-width-t488`). It combines three +chronologies (T37 from Ross Richardson's PR #3605; T8 from hexapode's PR #3485/#3494; T16 from Nick Petalas's +PR #3413, via hexapode's PR #3457/#3465) as 8 copies of 61 base replicas (T = 488). It uses the unchanged staged +644/660 supplier words of [PR #3605](https://github.com/CrocSwap/integer-mult-bounds/pull/3605) (Ross Richardson), +and claims: +- 1,791,936 literal owner roles; +- the complete profile `{1:10826280, 2:3188592, 3:1015650, 4:447984, 5:94794, 8:35136, 48:186782}`; +- physical stock 437,757; +- an aggregate that attains the fractional packing optimum of its fixed inventory; +- κ = 0.001730096363528623534230 − 10⁻⁴⁶ − 10⁻⁷⁰. + +Ross Richardson's [PR #3630](https://github.com/CrocSwap/integer-mult-bounds/pull/3630) independently bounds that +fixed inventory below .001730096363528623534231. + +```text +Status / UTC update / priority revision: DONE (audit) · 2026-10-18 16:20 UTC · priority revision 6 · base main 20ecf289 +Concrete question: are PR #3633's allocation, complete invoice, ceiling attainment and endpoint correct when checked + by code that does not run PR3633, PR3630 or PR3605? +Result (independently checked, AI-assisted; no human review): no correctness defect in PR3633's finite claims in + the checked scope. All 1,791,936 roles pass a separate audit and the recount equals the claim. An own dual + certificate shows that no allocation, for any T, in the fixed-inventory model has a larger 24-digit endpoint, + and PR3633's profile is exactly 488 x the unique LP minimum, so it attains that ceiling. κ reproduces in two + rational enclosures. Two process defects are reported: tautological inherited controls, and platform-dependent + native pins. +Artifact: {{PR_LINK}}. Replay: python3 -I -B research/t488-independent-audit/verify.py --fetch (212/212 controls) +Claim: released (advisory claim at discussions/1166#discussioncomment-19017329) +``` + +## What was checked + +`verify.py` and the `audit_*.py` modules import and execute nothing of PR3633, PR3630 or PR3605: their files are +read as pinned git data. The scope-C2 analyser parses copies of PR3605's auditor with `ast` as the object it +studies. The local-only `tools/` scripts run PR3633 code as the object under study, and their outputs are labelled +as local-only. + +| Scope | Check | Result | Negative controls | +| --- | --- | --- | --- | +| B `audit_owners.py` | the complete literal journal | all 1,791,936 roles pass; invoice = claim | 24 | +| A `audit_ceiling.py` | fixed-inventory LP, own simplex and dual certificate | profile = 488 × unique LP minimum | 52 | +| C1 `audit_staged_words.py` | both staged supplier words | exact forward and dual; widths = PR3633 providers | 50 | +| D `audit_endpoint.py` | endpoint, gains, PR3653 downstream | C = 0.001730096363528623534230 | 13 | +| C2 `audit_inherited_controls.py` | the five `reject()` controls of PR3605's auditor | tautological in all 15 copies | 65 | +| vendor | byte pins of this contributor's earlier modules | 8 files | 8 | +| | | **total** | **212/212** | + +- **B, the literal journal.** The journal ships as `data/FILL-columns.xz` (0.77 MB: owner, child, port and offset + columns; time and helper are implicit). The decoded rows re-serialise byte-identically to PR3633's pinned payload + (`owners/EXPECTED.json`, sha256 `20662cc6…`), so the encoding cannot change the audited object. ORDER, DISPATCH and + PROFILE are rebuilt from PR3633's base-chronology files, with each base call followed by its 8 copies (copy index + innermost), and must equal PR3633's literal-file pins. The audit covers: + - **Windows.** Each (replica, child) window is derived twice from the frozen template on main + (`rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz`), once from its level annotations and once by + replaying its event schedule. The two derivations must agree, and children of one family class have disjoint + windows. + - **Roles.** Every role must satisfy: + - `lo < t ≤ hi`; + - the active-local-pair exclusion of PR3630's checker, checked per role and also as a template lemma over 18,544 + triples, which shows the windows imply it; + - same-call physical families; + - capacity, with the widths recounted in C1; + - chronological compact offsets. + - **Invoice.** All 983,808 bins are charged, empty ones included: idle `{1:114192, 3:31842, 5:6954, 48:186782}`. + With 4,392 local bills this gives exactly the claimed profile. + - **Aggregate and stock.** The journal realises the aggregate's 11 capacity-patterns. The stock is + 896T + 408 + 8 + 91 + 2 = 437,757, with each component read from the word or the template. + - **Controls.** Controls include PR3133's widths (helpers 389/397 at 8), which do not host the journal. +- **A, the ceiling.** The model is fixed: per-call widths {4:26, 5:2, 6:18, 7:52, 8:97, 9:213}, the local bill + 2439H1+726H2+224H3+102H4+20H5+8H8, nine calls per replica, bins (672, 448, 448, 448) of capacities (8, 16, 32, 48), + live 896 per replica, and H_r(a) = r^(1−a). + - **Certificate.** Over this model, 2,551 patterns (7 + 38 + 399 + 2,107) go into an own exact simplex. Its dual + is certified rigorously: 12 reduced costs are identically zero and 2,539 are positive on [a_lo, a_hi]. + - **LP minimum.** The unique LP-minimum profile is 22185H1 + 6534H2 + (8325/4)H3 + 918H4 + (777/4)H5 + 72H8 + + (1531/4)H48 per replica, and PR3633's aggregate attains it. + - **What the ceiling covers.** It holds for every T within this model, and it relaxes windows, families, + chronology and integrality. + - **Cross-checks.** It cross-checks PR3633's `CEILING.json` (model, field hash, basis, dual, value and root + polynomial) and PR3630's model constants, basis, dual and published dual digest `11c3cade…`. + - **Independence.** A first draft mirrored PR3633's enumeration and column code. It was rewritten after review (see + the module docstring). +- **C1, the words.** These are this contributor's PR3053 word pipeline, run on the two words that are byte-identical + in PR3633 and PR3605: forward and dual replay of 632 inputs through cleanup and the target endpoint, the tracker, + the cleanup re-derivation and the 91 buffers. The helper widths equal PR3633's `PROVIDERS.json`, and they differ + from main's PR3133 providers only at helpers 389/397 (registers 644/660, 8 → 7). The change from the parent words + on main is localised: + - 8 helper→target writes are deleted, and 4 donor releases are inserted, with their 4 inverses in cleanup; + - restore 210 changes its frame only; + - the 72 warps move position only; + - `start_extra` changes. + + This contributor's parallel session audits the same two words independently, with a different code lineage, in + [PR #3687](https://github.com/CrocSwap/integer-mult-bounds/pull/3687) (14:46 UTC, same account). That audit and C1 + agree on the width inventory (8:97, 7:52) and the local bill. C1 is here to supply scope B's per-helper widths and + to bind them to PR3633's providers. +- **D, the endpoint.** Two independent enclosures accept C and reject C + 10⁻²⁴: atanh/Taylor series (PR3053) and + 640-bit fixed point (PR2804). κ = C − 10⁻⁴⁶ − 10⁻⁷⁰. The exact gains are 2.449882e-8 over PR3626, 4.881144e-8 over + PR3624, 8.967322e-8 over PR3630 and 8.981399e-8 over PR3605, and each predecessor's profile is rejected at C. + C is below PR3605's recorded BIT endpoint, which is compared, not re-derived. +- **D, downstream.** rohanarun's [PR #3653](https://github.com/CrocSwap/integer-mult-bounds/pull/3653) (head + `607a09ff`) puts roger-sato's [PR #3642](https://github.com/CrocSwap/integer-mult-bounds/pull/3642) retimed words + on this journal. Both words recount to PR3633's helper widths, with local bill {1:2437, 2:724, 3:226, …} (jwr404's + PR #3677 checks the same bill change). The profile is derived here, not read from PR3653: PR3633's audited profile + plus 4,392 × the bill change. That profile has endpoint 0.001730418899766071163804 = PR3653's κ + 10⁻⁴⁶ + 10⁻⁷⁰. + + The LP's reduced costs do not involve the local bill, and b·y = c·x holds symbolically, so only dual feasibility at + the new endpoint needed re-certifying. The scope-A dual, re-certified on that endpoint's 24-digit step (12 tight, + 2,539 positive), puts PR3633's allocation at the fixed-inventory ceiling for the retimed bill. + + This assumes PR3653 uses PR3633's journal unchanged; PR3653 pins the same `EXPECTED.json` (blob `415eac1a`), which + is not compared beyond that pin. The retimed words' exactness is not checked here; roger-sato's PR #3693 audits it. +- **C2, the inherited controls.** See finding 1. + +## Findings (non-blocking) + +1. **The literal-owner audit's five `reject()` controls cannot fail.** PR3633's `owners/independent_literal.py` + adapts PR3605's auditor: it adds input-authentication gates for artifact, source and native pins, the FILL payload + and exact ORDER/DISPATCH, and keeps its predicates and its five controls unchanged. `reject(name, test)` runs + `need(not test())`, but no `test` feeds changed data to a gate: + - three predicates are unsatisfiable: a shifted column compared with the tile, `lo < lo`, and `len({f, f}) == 2`; + - two test a +1 perturbation of an equality that the preceding gate has just asserted. + + **Where the same controls appear.** A scan of every `.py` blob in main and eight PR heads finds the same five + controls in 15 files. Static analysis (syntactic name tracking, with the remaining aliasing exclusions checked by + inspection) shows they are tautological in each: + - PR3633's own file; + - PR3605's file and its `provenance/` copies; + - PR3624's and PR3626's `independent_literal.py`, and PR3630's `independent_owners.py`; + - zxv's PR3638 (adapted); + - roger-sato's PR3642 (one adapted, two byte copies); + - rohanarun's PR3653 (one adapted, two byte copies). + + **Demonstration.** `evidence/GATE-DISABLE-DEMO.json` is local-only (Linux, CPython 3.14.4, numpy 2.5.4). In it, + PR3633's auditor ran unmodified, then with each of the five gates the controls are named after replaced by + `need(True, …)`, then with all five replaced. Every variant printed PASS and listed the same five controls. + + **What this is and is not.** It is a control-coverage defect, not a correctness defect: the gates are real checks + and pass on the real data, and scope B re-checks each one with controls that do feed violations. PR3633's other + guard tests (aggregate, stored-receipt and ceiling corruptions) do feed changed data to their checkers. Its + admission `owners` stage, which passed here, also re-checks windows, families and prefixes. + + **Lineage.** PR3605's file describes itself as an adapted copy of a parent audit (SHA256 `1001cb1c…`). No `.py` + blob in main or these heads has that hash (10,239 blobs scanned; archives not searched), so where the controls + were first written is not determined. The earlier checker of this lineage on main, + `research/rank7-joint-endframes/allocation/vendor/independent_owners.py`, credits its chronology/mask method to + Tekalign's PR2751. It reruns its `check()` on mutated inputs (a role outside its window, a same-call family + collision, a prefix hole, a changed profile, and T, role-count and dispatch corruptions) and requires the exact + rejection reason. + + **Suggested fix.** Factor the gates into a `check()` function and rerun it on each mutated journal, requiring the + expected message. +2. **Rebuilt native files fail only on the gzip header byte.** Here, PR3633's replay rebuilt both changed native + providers with PASS (Linux, CPython 3.14.4). The rebuilt `CANONICAL-WORD`, `FULL-WORD` and `LOCAL-PROGRAMS` + `.json.gz` files differ from the pinned files only in byte 9, the gzip OS field: + - FULL-WORD was compared byte by byte, because its pinned bytes ship as `supplier3605/STAGED644-660-*.json.gz`; + - the other four were compared by sha256 after setting byte 9. + + The payloads are identical. The pinned files carry 0x13; on this machine CPython 3.14.4 writes 0xff and CPython + 3.12.15 writes 0x03. + + **What the lineage already handles.** PR3605's `staged_pair.py` already restores this byte for the supplier words, + and PR3633 pins FILL by payload. `replay.py`'s native stage compares FULL-WORD by payload, which is why it passed + unpatched. + + **The remaining gap.** The case not covered is the `native_canonical` pin in `independent_literal.py` (PR3653's + adapted auditor has the same pin). It compares the rebuilt CANONICAL-WORD file hash, so a correct rebuild on + another platform fails it. The gate-disable demo fed it rebuilt files with byte 9 set to 0x13. Pinning payload + hashes would remove the gap (`evidence/NATIVE-REPRODUCTION.json`). + +## Overlap and timing + +- **Before the claim.** Overlap checks ran at 12:04 UTC (`find_overlap.py`, open PRs and discussions), and the + advisory claim was posted at 12:07 UTC (comment 19017329). + zxv's [PR #3638](https://github.com/CrocSwap/integer-mult-bounds/pull/3638) + (11:58 UTC) predates the claim and was missed by that check. It reaches the same endpoint with a different T360 + allocation and its own dual replay. It is not a check of PR3633's journal, and this package did not audit it. +- **After the claim.** Later PRs on this line: + - PR3653 (13:08 UTC, ready for review since 13:46 UTC); + - jwr404's PR3677 (the retimed bill keeps rank mass 5,135 and lowers the moment) and PR3680 (T360 role count); + - this account's PR3687 (an independent audit of PR3605's words; see C1); + - roger-sato's PR3693 (an audit of the retimed and delayed words, reusing PR3687's interpreter); + - roger-sato's PR3681 (a full replay of PR3605's wrapper, Ross Richardson's handoff); + - zxv's PR3682 (retimed releases at T360). + + None is an independent check of PR3633's journal or ceiling. The final recheck was at 2026-10-18 16:19 UTC. It + found roger-sato's PR3693 (15:33 UTC), which audits the retimed and delayed supplier words by reusing PR3687's + interpreter, and nothing on PR3633's journal or ceiling. + +## Scope limits + +- **Native lowering.** It is not checked. C1 replays the words in the lineage's free-operator model. +- **Release stages.** The precision, the prefix receipt and the physical invoice beyond the stock count are not + checked, nor the modern joint outer transfer, the bootstrap or the BIT side, which is only compared. +- **All-size hypotheses.** The inherited all-size dispatcher/compiler, uniform-cost, hosting, mutable-source, + rounding, tape, recovery and analytic hypotheses are not checked. +- **Written arguments.** PR3633's written call-copy and owner-copy (Hall) arguments are not checked; only their + output, the journal, is. +- **Model premises.** These are taken as given: the physical-family model (owner, 2·pair + side, port), as used by + the main-lineage checker, and the base-chronology files. Their equality to main's retained chronologies is not + checked, and legality does not depend on it. +- **Full replay.** PR3633's full fresh `replay.py`, which its author disclosed as not run, was attempted four times + here on 7.9 GB RAM with no swap. Fresh native passed every time. Owners passed in runs 2–4; parent-lift was + OOM-killed in run 2 and passed in runs 3–4; rebind and discovery `bind` passed in runs 3–4. Discovery `emit` was + OOM-killed in runs 1, 3 and 4, at 5.14 GB in run 4, which had no other job. So the release stage was never reached + (`evidence/NATIVE-REPRODUCTION.json`, local-only). +- **Frontier.** No selected-frontier change is proposed. κ is unchanged by this audit. + +## Reproduce + +```sh +python3 -I -B research/t488-independent-audit/verify.py --fetch # compares RESULT.json +python3 -I -B research/t488-independent-audit/verify.py --fetch --mutations --jobs 2 +python3.12 scripts/research_package.py --package research/t488-independent-audit # registered replay +``` + +`--fetch` needs git ≥ 2.29 and network access, and writes only the eight PR heads to `refs/audit/prN`. The replay +needs those heads to remain fetchable and a clone containing main `20ecf289`. The registered replay passed here with +CPython 3.12.15 (`PASS_REGISTERED_RESEARCH_PACKAGE`). RESULT.json was written with CPython 3.14.4; the +default run under CPython 3.12.15 (the CI interpreter) reproduces it exactly. Runtime is about 3 minutes on 4 cores, +with peak memory about 1.5 GB (local measurement). + +The mutation sweep runs an unmutated baseline first. It then applies each of the 45 checker mutations in a +subprocess, and each must load the mutated module and end in an audit rejection. Result: 45/45 killed, 0 survived +(`PASS_MUTATIONS`), after a passing unmutated baseline, with CPython 3.14.4 and 2 jobs, 2026-10-18 15:34–16:19 UTC, on +the final code bytes (log local-only). + +Local-only tools (not run by `verify.py` or CI): +- `tools/encode_journal.py` re-encodes the journal from PR3633's `owners/portable_expand.py` output. That output + reproduced PR3633's pinned FILL byte for byte here. +- `tools/gate_disable_demo.py` regenerates `evidence/GATE-DISABLE-DEMO.json`; it was run twice, with identical + results. + +## Open next questions + +1. **Does a width change, or a local-bill change beyond PR3642's retiming, raise the ceiling above + 0.001730418899766071163804?** That is the retimed ceiling certified here for PR3633's allocation. + - *Why it matters:* within scope A's model, packing is closed for every T. PR3633 attains the ceiling (checked + here) and PR3638 reports the same endpoint. PR3653 shows that a local-bill change with unchanged widths moves + the endpoint, with PR3633's allocation at the re-certified ceiling. + - *First step:* use `audit_ceiling.py`'s LP to price single-helper width changes and local-bill changes before + building any word. + - *Blocked by:* a width change needs a new exact word, as PR3605 built. +2. **Make the owner-audit controls test the gates.** + - *Why it matters:* finding 1 affects 15 copies of the same five controls. + - *First step:* rerun a `check()` function on mutated journals (as the main-lineage checker does), or reuse + `audit_owners.controls`. + - *Blocked by:* nothing. +3. **Make the native pins platform-independent.** + - *Why it matters:* finding 2. + - *First step:* pin the decompressed payloads of `CANONICAL-WORD` (and `FULL-WORD` and `LOCAL-PROGRAMS`) in + `independent_literal.py`'s `native_canonical` and in the receipts. + - *Blocked by:* nothing. +4. **Complete PR3633's fresh end-to-end replay.** + - *Why it matters:* its author did not run it, and here it stopped in discovery `emit` for lack of memory. + - *First step:* rerun `replay.py` with ≥ 12 GB RAM or swap. roger-sato's PR3681 reports a full PR3605-wrapper + replay, which may show a working configuration. + - *Blocked by:* memory on this machine. + +## Credits + +- **The object and its sources.** hexapode (Pierre-Loic Doulcet): the T488 composition and aggregate (PR3633), T450 + (PR3624), T530 (PR3626), the T8 chronology (PR3485/PR3494) and the T16 provider composition (PR3457/PR3465). Nick + Petalas: the T16 chronology (PR3413). Ross Richardson: the staged 644/660 supplier, the T37 lineage and the + allocation machinery (PR3605), and the all-T ceiling and dual (PR3630). +- **Downstream and concurrent work.** roger-sato: the retimed words (PR3642). rohanarun: their composition with T488 + (PR3653). zxv: the concurrent T360 allocation (PR3638). +- **Earlier work.** + - Marius-Paul Dumitrean (PR2979): the frozen template and plan of the rank7-joint-endframes package (windows, + family convention). + - dcharb78 (PR3133): the parent words and providers. + - Jeremy Diviney (PR3148, coupled-carrier-cap740): the capacity model and the finite-pattern primal/dual approach. + - The owner-checker lineage those packages name, including Tekalign's PR2751 independent owner checker. + - Clear1nsight's handoff suggested this audit. +- **Vendored code.** This contributor's own merged checkers (PR #3053 and predecessors). Their predecessors are + credited in `vendor/NOTICE.md`: Jeremy Kothe, Cinna Davis, Dugongue, Rohan Arun, mdumitrean, Vlado Vojdanovski, + Hao Yan, Josie Elliston, and icekylinx and Zhihao Chen (jacklightChen) as two contributors. +- **Author.** Sagar Thakrar (thakrarsagar), with substantial AI assistance (Claude Code, Anthropic: subagents built + two scopes and ran adversarial reviews). No independent human review is claimed. diff --git a/research/t488-independent-audit/RESULT.json b/research/t488-independent-audit/RESULT.json new file mode 100644 index 0000000000..81cb798153 --- /dev/null +++ b/research/t488-independent-audit/RESULT.json @@ -0,0 +1,2066 @@ +{ + "ceiling": { + "attainment": { + "S": 8, + "T": 488, + "base_T": 61, + "bins_per_capacity": { + "16": 218624, + "32": 218624, + "48": 218624, + "8": 327936 + }, + "equals_488_times_LP_minimum": true, + "full_profile": { + "1": 10826280, + "2": 3188592, + "3": 1015650, + "4": 447984, + "48": 186782, + "5": 94794, + "8": 35136 + }, + "groups": 549, + "idle_profile": { + "1": 114192, + "3": 31842, + "48": 186782, + "5": 6954 + }, + "nonbasic_tight_used": [ + [ + 16, + [ + 0, + 0, + 0, + 0, + 2, + 0 + ] + ] + ], + "roles_per_width": { + "4": 114192, + "5": 8784, + "6": 79056, + "7": 228384, + "8": 426024, + "9": 935496 + }, + "tight_patterns_used": 11, + "x_entries": 730, + "z_entries": 4217 + }, + "inputs": { + "budget3630": { + "commit": "bcac7fe04b9b7f7f5d3c27d620561f96c4ae5608", + "path": "research/staged-644-660-owner-successor/check_budget.py", + "sha256": "639820c9ccf72b88ae16768055ec5500a66004784f57a2fa5f218bf4d2e4ee05" + }, + "candidate": { + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "path": "research/staged-width-t488/owners/CANDIDATE.json", + "sha256": "fbdda845beac5bba9baa4b1b8c8f596e98f70b59e1d60ebf4f4d3e8758631bfd" + }, + "ceiling3633": { + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "path": "research/staged-width-t488/ceiling/CEILING.json", + "sha256": "a26bf26118222a5bcb6bf9f698d6b8b86003ff7b1479fd68b31f67c74945e460" + }, + "claim": { + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "path": "research/staged-width-t488/CLAIM.json", + "sha256": "3332fb6f6d5ae81da8ead667973491ebefa1803d6d96a06790386ac16243f332" + }, + "expected": { + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "path": "research/staged-width-t488/owners/EXPECTED.json", + "sha256": "924493b6bbeade055af4916ac7bd6d7d7ec0600719f5c39636dc3f16d7ec14ea" + }, + "readme3630": { + "commit": "bcac7fe04b9b7f7f5d3c27d620561f96c4ae5608", + "path": "research/staged-644-660-owner-successor/README.md", + "sha256": "79cf49cd2274364888830d63a664f514c7b1a51d3ac54e57dc4117d432078e31" + }, + "validation3630": { + "commit": "bcac7fe04b9b7f7f5d3c27d620561f96c4ae5608", + "path": "research/staged-644-660-owner-successor/VALIDATION.json", + "sha256": "1d85df49a5e4b9d1262cfaffa9725e03bfe660f395bc6c08d594a0b0551fc24e" + } + }, + "lp": { + "a_hi": "1730096363528623534231/1000000000000000000000000", + "basis": [ + { + "capacity": 8, + "idle": 0, + "pattern": [ + 0, + 0, + 0, + 0, + 1, + 0 + ], + "x": "672" + }, + { + "capacity": 16, + "idle": 0, + "pattern": [ + 0, + 0, + 0, + 1, + 0, + 1 + ], + "x": "448" + }, + { + "capacity": 32, + "idle": 5, + "pattern": [ + 0, + 0, + 0, + 0, + 0, + 3 + ], + "x": "57/4" + }, + { + "capacity": 32, + "idle": 0, + "pattern": [ + 0, + 0, + 0, + 1, + 2, + 1 + ], + "x": "39/2" + }, + { + "capacity": 32, + "idle": 0, + "pattern": [ + 0, + 0, + 0, + 2, + 0, + 2 + ], + "x": "1/4" + }, + { + "capacity": 32, + "idle": 0, + "pattern": [ + 0, + 0, + 1, + 0, + 1, + 2 + ], + "x": "162" + }, + { + "capacity": 32, + "idle": 0, + "pattern": [ + 0, + 1, + 0, + 0, + 0, + 3 + ], + "x": "18" + }, + { + "capacity": 32, + "idle": 1, + "pattern": [ + 1, + 0, + 0, + 0, + 0, + 3 + ], + "x": "234" + }, + { + "capacity": 48, + "idle": 48, + "pattern": [ + 0, + 0, + 0, + 0, + 0, + 0 + ], + "x": "1531/4" + }, + { + "capacity": 48, + "idle": 3, + "pattern": [ + 0, + 0, + 0, + 0, + 0, + 5 + ], + "x": "261/4" + } + ], + "dual": [ + { + "3": "-3/20", + "48": "3/20", + "5": "1/4" + }, + { + "3": "-3/10", + "48": "3/10", + "5": "1/2" + }, + { + "3": "-3/5", + "48": "3/5", + "5": "1" + }, + { + "48": "1" + }, + { + "1": "1", + "5": "-1" + }, + { + "5": "-1" + }, + { + "3": "1/20", + "48": "-1/20", + "5": "-3/4" + }, + { + "3": "1/10", + "48": "-1/10", + "5": "-1/2" + }, + { + "3": "3/20", + "48": "-3/20", + "5": "-1/4" + }, + { + "3": "1/5", + "48": "-1/5" + } + ], + "dual_uniform_on_bracket": [ + "173009636352862353423/100000000000000000000000", + "1730096363528623534231/1000000000000000000000000" + ], + "idle_per_replica": { + "1": "234", + "3": "261/4", + "48": "1531/4", + "5": "57/4" + }, + "min_strict_lower_scaled_by_73a": "4.083668e-03", + "minimum_profile_per_replica": { + "1": "22185", + "2": "6534", + "3": "8325/4", + "4": "918", + "48": "1531/4", + "5": "777/4", + "8": "72" + }, + "strictly_positive": 2539, + "symbolically_zero": 12, + "tight_patterns": [ + [ + 8, + [ + 0, + 0, + 0, + 0, + 1, + 0 + ] + ], + [ + 16, + [ + 0, + 0, + 0, + 0, + 2, + 0 + ] + ], + [ + 16, + [ + 0, + 0, + 0, + 1, + 0, + 1 + ] + ], + [ + 32, + [ + 0, + 0, + 0, + 0, + 0, + 3 + ] + ], + [ + 32, + [ + 0, + 0, + 0, + 0, + 4, + 0 + ] + ], + [ + 32, + [ + 0, + 0, + 0, + 1, + 2, + 1 + ] + ], + [ + 32, + [ + 0, + 0, + 0, + 2, + 0, + 2 + ] + ], + [ + 32, + [ + 0, + 0, + 1, + 0, + 1, + 2 + ] + ], + [ + 32, + [ + 0, + 1, + 0, + 0, + 0, + 3 + ] + ], + [ + 32, + [ + 1, + 0, + 0, + 0, + 0, + 3 + ] + ], + [ + 48, + [ + 0, + 0, + 0, + 0, + 0, + 0 + ] + ], + [ + 48, + [ + 0, + 0, + 0, + 0, + 0, + 5 + ] + ] + ] + }, + "patterns": { + "per_capacity": { + "16": 38, + "32": 399, + "48": 2107, + "8": 7 + }, + "total": 2551 + }, + "root": { + "candidate_endpoint_equals_kappa": true, + "ceiling": "for every positive integer T every complete allocation of this fixed model has M_T(a_hi) > 1, so its 24-digit endpoint is <= 0.001730096363528623534230; PR3633 attains it", + "endpoint": "0.001730096363528623534230", + "kappa": "17300963635286235342299999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "live": 437248, + "lp_minimum_per_replica_rejected_at_a_hi": true, + "lp_minimum_x488": { + "C_enclosure_width": "2.00e-60", + "C_moment_minus_1": [ + "-1.298238816e-24", + "-1.298238816e-24" + ], + "C_plus_1e24_moment_minus_1": [ + "1.538663693e-24", + "1.538663693e-24" + ] + }, + "pr3633_claimed": { + "C_enclosure_width": "2.00e-60", + "C_moment_minus_1": [ + "-1.298238816e-24", + "-1.298238816e-24" + ], + "C_plus_1e24_moment_minus_1": [ + "1.538663693e-24", + "1.538663693e-24" + ] + } + }, + "scope": "Fixed staged 644/660 supplier (widths, inventory, local bill), capacities/bin counts, nine-call normalization and live 896T; windows, families, chronology and integrality relaxed. Dual certified at a_hi and uniformly on [a_lo, a_hi] only. No literal-owner, native, outer or multiplication-theorem claim.", + "simplex_iterations": [ + 33, + 4 + ], + "status": "PASS_FIXED_MODEL_LP_CEILING_ATTAINED_BY_PR3633", + "x3630": { + "amounts_equal": true, + "basis_equal": true, + "bound_confirmed": true, + "coefficient_sha256": "11c3cadeeda1d3db40eb479af6835131f5e61bf26f63f2a62ec54de41a9f5c3a", + "digest_matches_validation": true, + "dual_equal_to_own": true, + "model_T": 740, + "model_equal": true, + "model_live": 663040, + "stated_bound": "0.001730096363528623534231", + "uniform_on_bracket": true, + "value_equal": true, + "zero_strict": [ + 12, + 2539 + ] + }, + "x3633": { + "amounts_equal": true, + "basis_equal": true, + "dual_equal": true, + "exponent": "1994665302554255138531/1152921504606846976000000", + "exponent_denominator_is_2p60_10p6": true, + "exponent_minus_a_hi": "-2.965376e-25", + "field_list_pinned": true, + "note": "their dual is certified at a rational exponent e = their root-interval upper end, with a_lo < e <= a_hi; by monotonicity rejection at e implies rejection at a_hi; their root interval is not the decimal bracket but brackets the same unique root", + "root_interval": [ + "199466530255425513853/115292150460684697600000", + "1994665302554255138531/1152921504606846976000000" + ], + "root_lower_minus_a_lo": "-1.638994e-25", + "root_polynomial_scale": 4, + "value_equal": true, + "zero_strict": { + "at_a_hi": [ + 12, + 2539 + ], + "at_their_exponent": [ + 12, + 2539 + ] + } + } + }, + "controls": { + "attempted": 212, + "by_scope": { + "ceiling": 52, + "endpoint": 13, + "inherited": 65, + "owners": 24, + "vendor": 8, + "words": 50 + }, + "distinct": 212, + "rejected_as_expected": 212, + "rules": [ + "VendorPinMismatch", + "ceiling.attain_bins", + "ceiling.attain_format", + "ceiling.attain_model", + "ceiling.attain_pattern", + "ceiling.attain_profile", + "ceiling.attain_roles", + "ceiling.attain_tight", + "ceiling.attain_window", + "ceiling.attain_zbalance", + "ceiling.attain_zcalls", + "ceiling.attain_zdegree", + "ceiling.claim_fields", + "ceiling.claim_interval", + "ceiling.claimed_profile", + "ceiling.dual_feasible", + "ceiling.dual_uniform", + "ceiling.endpoint_format", + "ceiling.enum_complete", + "ceiling.enum_distinct", + "ceiling.enum_valid", + "ceiling.input_format", + "ceiling.kappa", + "ceiling.primal_rows", + "ceiling.primal_sign", + "ceiling.root_accept", + "ceiling.root_ceiling", + "ceiling.root_reject", + "ceiling.strong_duality", + "ceiling.x3630_basis", + "ceiling.x3630_bound", + "ceiling.x3630_digest", + "ceiling.x3630_dual", + "ceiling.x3630_model", + "ceiling.x3630_value", + "ceiling.x3633_basis", + "ceiling.x3633_binding", + "ceiling.x3633_dual", + "ceiling.x3633_dual_value", + "ceiling.x3633_fields", + "ceiling.x3633_model", + "ceiling.x3633_root", + "ceiling.x3633_rootpoly", + "ceiling.x3633_value", + "controls.bindings", + "controls.data_identity", + "controls.data_mass", + "controls.data_pin", + "controls.data_prefix", + "controls.data_rows", + "controls.data_window", + "controls.gate_purity", + "controls.inventory", + "controls.need_def", + "controls.pattern", + "controls.pin", + "controls.reject_def", + "controls.tautology", + "downstream.ceiling", + "downstream.dual", + "downstream.kappa", + "downstream.widths", + "endpoint.accept", + "endpoint.bit", + "endpoint.gain", + "endpoint.improvement", + "endpoint.kappa", + "endpoint.profile", + "endpoint.reject", + "endpoint.two_impl", + "owners.active_pair", + "owners.aggregate", + "owners.binding", + "owners.bounds", + "owners.capacity", + "owners.dispatch", + "owners.family", + "owners.histogram", + "owners.identity", + "owners.literal_files", + "owners.order", + "owners.prefix", + "owners.schema", + "owners.shape", + "owners.stock", + "owners.window", + "owners.windows", + "owners.windows_agree", + "owners.windows_disjoint", + "staged.parent_diff.cleanup_pairs", + "staged.parent_diff.deleted", + "staged.parent_diff.inserted", + "staged.parent_diff.keys", + "staged.parent_diff.replace", + "staged.parent_diff.restore", + "staged.parent_diff.sections", + "staged.parent_diff.start_extra", + "staged.parent_diff.warp_alignment", + "staged.parent_diff.warp_record", + "staged.parent_diff.warps", + "staged.pin", + "staged.pr3133_widths", + "staged.providers", + "staged.providers_paid", + "staged.registers", + "wc.replay", + "words.cleanup", + "words.counts", + "words.declared" + ] + }, + "downstream_pr3653": { + "delta_per_call": { + "1": -2, + "2": -2, + "3": 2 + }, + "dual_certificate_at_retimed_endpoint": { + "interval": [ + "0.001730418899766071163804", + "0.001730418899766071163805" + ], + "strictly_positive_uniform": 2539, + "tight": 12 + }, + "endpoint": { + "C": "0.001730418899766071163804", + "M_C_minus_1": [ + "-2.0582e-24", + "-2.0582e-24" + ], + "M_next_minus_1": [ + "7.7817e-25", + "7.7817e-25" + ], + "vendored_agrees": true + }, + "kappa": "17304188997660711638039999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "profile": { + "1": 10817496, + "2": 3179808, + "3": 1024434, + "4": 447984, + "48": 186782, + "5": 94794, + "8": 35136 + }, + "profile_equals_488_retimed_lp_minimum": true, + "retimed_local_bill": { + "1": 2437, + "2": 724, + "3": 226, + "4": 102, + "5": 20, + "8": 8 + }, + "widths_equal_staged": true + }, + "endpoint": { + "bit": { + "complex_binds": true, + "source": "PR3605 CLAIM.json (recorded, not re-derived)", + "unchanged_bit_endpoint": "0.001733427039589844234749" + }, + "endpoint": { + "C": "0.001730096363528623534230", + "M_C_minus_1": [ + "-1.2982e-24", + "-1.2982e-24" + ], + "M_next_minus_1": [ + "1.5387e-24", + "1.5387e-24" + ], + "vendored_agrees": true + }, + "gains": { + "PR3605": { + "gain": "3592559591267489/40000000000000000000000", + "gain_float": "8.981399e-08", + "kappa": "17300065495388418470049999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "predecessor_M_at_C_minus_1": "2.548e-07", + "replicas": 740 + }, + "PR3624": { + "gain": "24405717639687323/500000000000000000000000", + "gain_float": "4.881144e-08", + "kappa": "17300475520933441595839999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "predecessor_M_at_C_minus_1": "1.385e-07", + "replicas": 450 + }, + "PR3626": { + "gain": "2449882284365169/100000000000000000000000", + "gain_float": "2.449882e-08", + "kappa": "17300718647057798825399999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "predecessor_M_at_C_minus_1": "6.950e-08", + "replicas": 530 + }, + "PR3630": { + "gain": "5604576079666369/62500000000000000000000", + "gain_float": "8.967322e-08", + "kappa": "17300066903113488723259999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "predecessor_M_at_C_minus_1": "2.544e-07", + "replicas": 740 + } + }, + "kappa": "17300963635286235342299999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000" + }, + "inherited_controls": { + "controls_attempted": 65, + "controls_killed": 65, + "copies": { + "PR3605": { + "all_tautological": true, + "commit": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "gates_before_controls": 26, + "gates_missing_here_vs_PR3633": [ + "'frozen audit artifact ' + rel", + "'retained source pin ' + rel", + "actual native canonical pin", + "exactmixedsourceclock", + "exactsourceproviderdispatch", + "freshT488payload" + ], + "gates_only_here_vs_PR3633": [], + "git_blob": "5d1a7b4fd635070522e78656ccedf9bcf4bf13db", + "original_sha256_claimed": "1001cb1c8b4ee1f93c23b58b094565ec1b3931eee0ea091a23504696e380be9e", + "path": "research/staged-644-660-conditional-release/owners/independent_literal.py", + "patterns": [ + "shifted_column", + "irreflexive", + "duplicate_set", + "gate_offset", + "gate_bump" + ], + "sha256": "da897bd5cef36943b3f5b1422fe81716b4eaa6230b056d31f8c2310cf62f8580" + }, + "PR3624": { + "all_tautological": true, + "commit": "515a7c4490aa32ac3ca5014feb6f7da0d6952863", + "gates_before_controls": 32, + "gates_missing_here_vs_PR3633": [ + "freshT488payload" + ], + "gates_only_here_vs_PR3633": [ + "freshT450payload" + ], + "git_blob": "d9c2450e03d9dcde39ae96f0edc835d1a67d9fe5", + "original_sha256_claimed": "1001cb1c8b4ee1f93c23b58b094565ec1b3931eee0ea091a23504696e380be9e", + "path": "research/staged-width-t450/owners/independent_literal.py", + "patterns": [ + "shifted_column", + "irreflexive", + "duplicate_set", + "gate_offset", + "gate_bump" + ], + "sha256": "68684584d3866b2ab76c254dd6d5be3a49d276a6e5f6353183dee4d8d84de4d4" + }, + "PR3624-provenance": { + "all_tautological": true, + "commit": "515a7c4490aa32ac3ca5014feb6f7da0d6952863", + "gates_before_controls": 26, + "gates_missing_here_vs_PR3633": [ + "'frozen audit artifact ' + rel", + "'retained source pin ' + rel", + "actual native canonical pin", + "exactmixedsourceclock", + "exactsourceproviderdispatch", + "freshT488payload" + ], + "gates_only_here_vs_PR3633": [], + "git_blob": "5d1a7b4fd635070522e78656ccedf9bcf4bf13db", + "original_sha256_claimed": "1001cb1c8b4ee1f93c23b58b094565ec1b3931eee0ea091a23504696e380be9e", + "path": "research/staged-width-t450/provenance/pr3605/owners/independent_literal.py", + "patterns": [ + "shifted_column", + "irreflexive", + "duplicate_set", + "gate_offset", + "gate_bump" + ], + "sha256": "da897bd5cef36943b3f5b1422fe81716b4eaa6230b056d31f8c2310cf62f8580" + }, + "PR3626": { + "all_tautological": true, + "commit": "659fd5e7064d9466b668d7188cbb013b333a415a", + "gates_before_controls": 32, + "gates_missing_here_vs_PR3633": [ + "freshT488payload" + ], + "gates_only_here_vs_PR3633": [ + "freshT530payload" + ], + "git_blob": "32755776c15660b939c92cb8835c71ec87c8c1d6", + "original_sha256_claimed": "1001cb1c8b4ee1f93c23b58b094565ec1b3931eee0ea091a23504696e380be9e", + "path": "research/staged-width-t530/owners/independent_literal.py", + "patterns": [ + "shifted_column", + "irreflexive", + "duplicate_set", + "gate_offset", + "gate_bump" + ], + "sha256": "36d7f4e3a611fd6b5983222887beb9a37a18bfac0d999ac5c00e3e191d1c5cc4" + }, + "PR3626-provenance": { + "all_tautological": true, + "commit": "659fd5e7064d9466b668d7188cbb013b333a415a", + "gates_before_controls": 26, + "gates_missing_here_vs_PR3633": [ + "'frozen audit artifact ' + rel", + "'retained source pin ' + rel", + "actual native canonical pin", + "exactmixedsourceclock", + "exactsourceproviderdispatch", + "freshT488payload" + ], + "gates_only_here_vs_PR3633": [], + "git_blob": "5d1a7b4fd635070522e78656ccedf9bcf4bf13db", + "original_sha256_claimed": "1001cb1c8b4ee1f93c23b58b094565ec1b3931eee0ea091a23504696e380be9e", + "path": "research/staged-width-t530/provenance/pr3605/owners/independent_literal.py", + "patterns": [ + "shifted_column", + "irreflexive", + "duplicate_set", + "gate_offset", + "gate_bump" + ], + "sha256": "da897bd5cef36943b3f5b1422fe81716b4eaa6230b056d31f8c2310cf62f8580" + }, + "PR3630": { + "all_tautological": true, + "commit": "bcac7fe04b9b7f7f5d3c27d620561f96c4ae5608", + "gates_before_controls": 27, + "gates_missing_here_vs_PR3633": [ + "'frozen audit artifact ' + rel", + "'retained source pin ' + rel", + "actual native canonical pin", + "exactmixedsourceclock", + "exactsourceproviderdispatch", + "freshT488payload" + ], + "gates_only_here_vs_PR3633": [ + "'unchanged ' + n", + "24 total changed literal rows", + "active local pair excluded from helper owners", + "all call/helper identities unchanged", + "complete predecessor literal payload", + "exact five changed owners", + "independently derived whole histogram delta", + "literal destination binding" + ], + "git_blob": "f116cc0142b4f6d674abf6e4c844142c00fb0297", + "original_sha256_claimed": null, + "path": "research/staged-644-660-owner-successor/independent_owners.py", + "patterns": [ + "shifted_column", + "irreflexive", + "duplicate_set", + "gate_offset", + "gate_bump" + ], + "sha256": "8d02dff267938cdb373aa617a411d8e67700e130609d2714e98ccf814e32eaef" + }, + "PR3633": { + "all_tautological": true, + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "gates_before_controls": 32, + "gates_missing_here_vs_PR3633": [], + "gates_only_here_vs_PR3633": [], + "git_blob": "e2a226950ed30e88f6c386669716b9a463dd873d", + "original_sha256_claimed": "1001cb1c8b4ee1f93c23b58b094565ec1b3931eee0ea091a23504696e380be9e", + "path": "research/staged-width-t488/owners/independent_literal.py", + "patterns": [ + "shifted_column", + "irreflexive", + "duplicate_set", + "gate_offset", + "gate_bump" + ], + "sha256": "8517c0d6c7cbe73438885135ac7fd9781dd5120113c9721002346dca603f5ed9" + }, + "PR3633-provenance": { + "all_tautological": true, + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "gates_before_controls": 26, + "gates_missing_here_vs_PR3633": [ + "'frozen audit artifact ' + rel", + "'retained source pin ' + rel", + "actual native canonical pin", + "exactmixedsourceclock", + "exactsourceproviderdispatch", + "freshT488payload" + ], + "gates_only_here_vs_PR3633": [], + "git_blob": "5d1a7b4fd635070522e78656ccedf9bcf4bf13db", + "original_sha256_claimed": "1001cb1c8b4ee1f93c23b58b094565ec1b3931eee0ea091a23504696e380be9e", + "path": "research/staged-width-t488/provenance/pr3605/owners/independent_literal.py", + "patterns": [ + "shifted_column", + "irreflexive", + "duplicate_set", + "gate_offset", + "gate_bump" + ], + "sha256": "da897bd5cef36943b3f5b1422fe81716b4eaa6230b056d31f8c2310cf62f8580" + }, + "PR3638": { + "all_tautological": true, + "commit": "d62e1acd7518a231440383f0d0dddf54d6edf8c1", + "gates_before_controls": 32, + "gates_missing_here_vs_PR3633": [ + "freshT488payload" + ], + "gates_only_here_vs_PR3633": [ + "freshT360payload" + ], + "git_blob": "4028493716bfcf3e73831067599518c055fcd2b0", + "original_sha256_claimed": "1001cb1c8b4ee1f93c23b58b094565ec1b3931eee0ea091a23504696e380be9e", + "path": "research/three-kappa-leads/independent_literal.py", + "patterns": [ + "shifted_column", + "irreflexive", + "duplicate_set", + "gate_offset", + "gate_bump" + ], + "sha256": "89c27f61ae3e6d2bdd4c469ac5b99d4f955a443c5e04c74e568c12093510efbe" + }, + "PR3642": { + "all_tautological": true, + "commit": "044d24f12e74f228dd462c07ae2d7f3ea35e2be9", + "gates_before_controls": 32, + "gates_missing_here_vs_PR3633": [ + "freshT488payload", + "new local bill" + ], + "gates_only_here_vs_PR3633": [ + "freshT530payload", + "two commuting release swaps local bill" + ], + "git_blob": "86dc50768ff3fda8e265c08aa9314fe072e0c396", + "original_sha256_claimed": "1001cb1c8b4ee1f93c23b58b094565ec1b3931eee0ea091a23504696e380be9e", + "path": "research/staged-release-retiming-t530/owner-audit/independent_literal.py", + "patterns": [ + "shifted_column", + "irreflexive", + "duplicate_set", + "gate_offset", + "gate_bump" + ], + "sha256": "b51c36ad1ae0999547edc4726d698df369fef60daaaac4f5bbea471648c9f628" + }, + "PR3642-upstream": { + "all_tautological": true, + "commit": "044d24f12e74f228dd462c07ae2d7f3ea35e2be9", + "gates_before_controls": 32, + "gates_missing_here_vs_PR3633": [ + "freshT488payload" + ], + "gates_only_here_vs_PR3633": [ + "freshT530payload" + ], + "git_blob": "32755776c15660b939c92cb8835c71ec87c8c1d6", + "original_sha256_claimed": "1001cb1c8b4ee1f93c23b58b094565ec1b3931eee0ea091a23504696e380be9e", + "path": "research/staged-release-retiming-t530/owner-audit/upstream/independent_literal.py", + "patterns": [ + "shifted_column", + "irreflexive", + "duplicate_set", + "gate_offset", + "gate_bump" + ], + "sha256": "36d7f4e3a611fd6b5983222887beb9a37a18bfac0d999ac5c00e3e191d1c5cc4" + }, + "PR3642-vendor": { + "all_tautological": true, + "commit": "044d24f12e74f228dd462c07ae2d7f3ea35e2be9", + "gates_before_controls": 32, + "gates_missing_here_vs_PR3633": [ + "freshT488payload" + ], + "gates_only_here_vs_PR3633": [ + "freshT530payload" + ], + "git_blob": "32755776c15660b939c92cb8835c71ec87c8c1d6", + "original_sha256_claimed": "1001cb1c8b4ee1f93c23b58b094565ec1b3931eee0ea091a23504696e380be9e", + "path": "research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/independent_literal.py", + "patterns": [ + "shifted_column", + "irreflexive", + "duplicate_set", + "gate_offset", + "gate_bump" + ], + "sha256": "36d7f4e3a611fd6b5983222887beb9a37a18bfac0d999ac5c00e3e191d1c5cc4" + }, + "PR3653": { + "all_tautological": true, + "commit": "607a09ff441c79b215a8127a81f4cc70021d0d9b", + "gates_before_controls": 32, + "gates_missing_here_vs_PR3633": [], + "gates_only_here_vs_PR3633": [], + "git_blob": "403a9cd104c7e68a5bd2431bb442d701f30828f5", + "original_sha256_claimed": "1001cb1c8b4ee1f93c23b58b094565ec1b3931eee0ea091a23504696e380be9e", + "path": "research/retimed-t488-composition/owners/independent_literal.py", + "patterns": [ + "shifted_column", + "irreflexive", + "duplicate_set", + "gate_offset", + "gate_bump" + ], + "sha256": "caa5eb4fff4908c0891c3ee41e7e6d71bf19bb710d1d7781164f10ce84bce769" + }, + "PR3653-upstream": { + "all_tautological": true, + "commit": "607a09ff441c79b215a8127a81f4cc70021d0d9b", + "gates_before_controls": 32, + "gates_missing_here_vs_PR3633": [], + "gates_only_here_vs_PR3633": [], + "git_blob": "e2a226950ed30e88f6c386669716b9a463dd873d", + "original_sha256_claimed": "1001cb1c8b4ee1f93c23b58b094565ec1b3931eee0ea091a23504696e380be9e", + "path": "research/retimed-t488-composition/owners/upstream/independent_literal.py", + "patterns": [ + "shifted_column", + "irreflexive", + "duplicate_set", + "gate_offset", + "gate_bump" + ], + "sha256": "8517c0d6c7cbe73438885135ac7fd9781dd5120113c9721002346dca603f5ed9" + }, + "PR3653-vendor": { + "all_tautological": true, + "commit": "607a09ff441c79b215a8127a81f4cc70021d0d9b", + "gates_before_controls": 32, + "gates_missing_here_vs_PR3633": [ + "freshT488payload" + ], + "gates_only_here_vs_PR3633": [ + "freshT530payload" + ], + "git_blob": "32755776c15660b939c92cb8835c71ec87c8c1d6", + "original_sha256_claimed": "1001cb1c8b4ee1f93c23b58b094565ec1b3931eee0ea091a23504696e380be9e", + "path": "research/retimed-t488-composition/full-replay/vendor/pr3642/vendor/staged-width-t530/owners/independent_literal.py", + "patterns": [ + "shifted_column", + "irreflexive", + "duplicate_set", + "gate_offset", + "gate_bump" + ], + "sha256": "36d7f4e3a611fd6b5983222887beb9a37a18bfac0d999ac5c00e3e191d1c5cc4" + } + }, + "fairness": "The gates themselves are real checks evaluated on the real T488 data, and the premises the two gate-based proofs use hold on that data; this is a control-coverage defect, not a correctness defect of the owner journal or of its gates.", + "finding": "All five reject() controls of PR3633 owners/independent_literal.py (and of its 14 located copies) are tautological: three are unsatisfiable for every input (irreflexive a7 change)", + "staged.pr3133_widths", + true + ], + [ + "[base] declared changed registers (645, 660) instead of PR3605's (644, 660)", + "staged.registers", + true + ], + [ + "[base] parent word with an extra top-level key", + "staged.parent_diff.keys", + true + ], + [ + "[base] parent cleanup[0] replaced by two unmatched items (2-for-1 replace block)", + "staged.parent_diff.replace", + true + ], + [ + "[base] parent with its last warp record removed", + "staged.parent_diff.warps", + true + ], + [ + "[base] parent word with one A gate frame changed", + "staged.parent_diff.sections", + true + ], + [ + "[base] parent word already carrying the staged restore 210", + "staged.parent_diff.sections", + true + ], + [ + "[base] parent without deleted write B[184] (warps re-attached): 7 deletions", + "staged.parent_diff.sections", + true + ], + [ + "[base] parent deleted write B[184] with source 644 -> 645", + "staged.parent_diff.deleted", + true + ], + [ + "[base] parent B[599] replaced by the first inserted release: an ordinary item among the insertions", + "staged.parent_diff.inserted", + true + ], + [ + "[base] parent cleanup[1009] replaced by the first cleanup insert: one insert pair altered", + "staged.parent_diff.cleanup_pairs", + true + ], + [ + "[base] parent restore 210 coefficient changed (non-frame field)", + "staged.parent_diff.restore", + true + ], + [ + "[base] parent start_extra[644] = [31]", + "staged.parent_diff.start_extra", + true + ], + [ + "[base] parent warps[0] lender changed", + "staged.parent_diff.warp_record", + true + ], + [ + "[base] parent warps[0] B position shifted by one", + "staged.parent_diff.warp_alignment", + true + ], + [ + "[extra] one byte of the gzip stream flipped, pin kept", + "staged.pin", + true + ], + [ + "[extra] coefficient of the first donor release B[591] flipped", + "wc.replay", + true + ], + [ + "[extra] first cleanup item deleted, expected cleanup count lowered to match", + "wc.replay", + true + ], + [ + "[extra] commuting cleanup items 7/8 swapped (both replays and the tracker accept)", + "words.cleanup", + true + ], + [ + "[extra] helper_final frame of 226 raised to FULL, report forged", + "words.declared", + true + ], + [ + "[extra] cleanup prepended with helper 224 += zero buffer (forward-neutral), cleanup count raised", + "wc.replay", + true + ], + [ + "[extra] declared profile/inventory of the PR3133 parent", + "words.declared", + true + ], + [ + "[extra] expected helper count 409", + "words.counts", + true + ], + [ + "[extra] PROVIDERS.json[extra] width of helper 644 (index 389) back to 8", + "staged.providers", + true + ], + [ + "[extra] PROVIDERS.json[extra] actual_paid_profile rank-1 count +1, widths kept", + "staged.providers_paid", + true + ], + [ + "[extra] PR3133-PROVIDERS[extra] replaced by the staged widths (no 8->7 change)", + "staged.pr3133_widths", + true + ], + [ + "[extra] declared changed registers (645, 660) instead of PR3605's (644, 660)", + "staged.registers", + true + ], + [ + "[extra] parent word with an extra top-level key", + "staged.parent_diff.keys", + true + ], + [ + "[extra] parent cleanup[0] replaced by two unmatched items (2-for-1 replace block)", + "staged.parent_diff.replace", + true + ], + [ + "[extra] parent with its last warp record removed", + "staged.parent_diff.warps", + true + ], + [ + "[extra] parent word with one A gate frame changed", + "staged.parent_diff.sections", + true + ], + [ + "[extra] parent word already carrying the staged restore 210", + "staged.parent_diff.sections", + true + ], + [ + "[extra] parent without deleted write B[184] (warps re-attached): 7 deletions", + "staged.parent_diff.sections", + true + ], + [ + "[extra] parent deleted write B[184] with source 644 -> 645", + "staged.parent_diff.deleted", + true + ], + [ + "[extra] parent B[599] replaced by the first inserted release: an ordinary item among the insertions", + "staged.parent_diff.inserted", + true + ], + [ + "[extra] parent cleanup[1009] replaced by the first cleanup insert: one insert pair altered", + "staged.parent_diff.cleanup_pairs", + true + ], + [ + "[extra] parent restore 210 coefficient changed (non-frame field)", + "staged.parent_diff.restore", + true + ], + [ + "[extra] parent start_extra[644] = [31]", + "staged.parent_diff.start_extra", + true + ], + [ + "[extra] parent warps[0] lender changed", + "staged.parent_diff.warp_record", + true + ], + [ + "[extra] parent warps[0] B position shifted by one", + "staged.parent_diff.warp_alignment", + true + ] + ], + "extra": { + "buffers": { + "offset": 704, + "private_buffers": 91 + }, + "changed_registers": [ + 644, + 660 + ], + "cleanup": { + "all_at_full": true, + "items": 5222, + "literal_equal": true + }, + "counts": { + "a_prelude_events": 84, + "buffers": 91, + "corrections": 36, + "helpers": 408, + "live": 632, + "sections": { + "A": 4079, + "B": 1868, + "cleanup": 5222, + "compensation": 5736, + "cut": 176, + "precondition": 192, + "restore": 212 + }, + "warps": 72 + }, + "independent_inputs": 632, + "inventory": { + "4": 26, + "5": 2, + "6": 18, + "7": 52, + "8": 97, + "9": 213 + }, + "localisation": { + "B": { + "deleted": 8, + "inserted": 4, + "replaced": 0 + }, + "cleanup": { + "deleted": 0, + "inserted": 4, + "replaced": 0 + }, + "report": { + "keys": [ + "local_profile", + "width_inventory" + ] + }, + "restore": { + "deleted": 0, + "inserted": 0, + "replaced": 1 + }, + "start_extra": { + "keys": [ + "644", + "660" + ] + }, + "warps": { + "position_only": 72 + } + }, + "pr3133_width_changes": [ + [ + 389, + 8, + 7 + ], + [ + 397, + 8, + 7 + ] + ], + "profile": { + "1": 2439, + "2": 726, + "3": 224, + "4": 102, + "5": 20, + "8": 8 + }, + "sha256": "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f", + "tracker_final": true, + "unchanged_sections": [ + "A", + "base", + "center_frames", + "centers", + "compensation", + "cut", + "helper_final", + "initial_corrections", + "kind", + "ports", + "precondition", + "prelude_events", + "removed", + "target_levels" + ] + }, + "parents": { + "base": { + "also_at": "research/coupled-carrier-cap740/words/base.json.gz", + "counts": { + "a_prelude_events": 84, + "buffers": 91, + "corrections": 36, + "helpers": 408, + "live": 632, + "sections": { + "A": 4079, + "B": 1872, + "cleanup": 5218, + "compensation": 5736, + "cut": 176, + "precondition": 192, + "restore": 212 + }, + "warps": 72 + }, + "inventory": { + "4": 26, + "5": 2, + "6": 18, + "7": 50, + "8": 99, + "9": 213 + }, + "path": "research/rank7-coupled-586-588-carrier-fold/edits/FINAL-WORD-base.json.gz", + "profile": { + "1": 2433, + "2": 724, + "3": 228, + "4": 102, + "5": 20, + "8": 8 + }, + "provider": "gauge44", + "sha256": "300a9b8ad1d554f0e6f84f43f3f5fd870a5b4e5f81ad856900b6e8999684892e", + "widths_equal_pr3133_providers": true + }, + "extra": { + "also_at": "research/coupled-carrier-cap740/words/extra.json.gz", + "counts": { + "a_prelude_events": 84, + "buffers": 91, + "corrections": 36, + "helpers": 408, + "live": 632, + "sections": { + "A": 4079, + "B": 1872, + "cleanup": 5218, + "compensation": 5736, + "cut": 176, + "precondition": 192, + "restore": 212 + }, + "warps": 72 + }, + "inventory": { + "4": 26, + "5": 2, + "6": 18, + "7": 50, + "8": 99, + "9": 213 + }, + "path": "research/rank7-coupled-586-588-carrier-fold/edits/FINAL-WORD-extra.json.gz", + "profile": { + "1": 2433, + "2": 724, + "3": 228, + "4": 102, + "5": 20, + "8": 8 + }, + "provider": "extra", + "sha256": "495d030f1e03b90e954dad3043994f03293d41b9ed220a3beaef849df435d3f0", + "widths_equal_pr3133_providers": true + } + }, + "pr3605_identity": { + "base": { + "identical_bytes": true, + "pr3605": { + "commit": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "git_blob": "dc6d321b1e8e2a837a1ff7bb60e8f8f78d043db5", + "path": "research/staged-644-660-width-reduction/STAGED644-660-base.json.gz" + }, + "pr3633": { + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "git_blob": "dc6d321b1e8e2a837a1ff7bb60e8f8f78d043db5", + "path": "research/staged-width-t488/supplier3605/STAGED644-660-base.json.gz" + }, + "sha256": "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653" + }, + "extra": { + "identical_bytes": true, + "pr3605": { + "commit": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "git_blob": "78e7b2bb0653c8dcc0133980a19dd9d97ebdb67e", + "path": "research/staged-644-660-width-reduction/STAGED644-660-extra.json.gz" + }, + "pr3633": { + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "git_blob": "78e7b2bb0653c8dcc0133980a19dd9d97ebdb67e", + "path": "research/staged-width-t488/supplier3605/STAGED644-660-extra.json.gz" + }, + "sha256": "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f" + } + } + } +} diff --git a/research/t488-independent-audit/SOURCES.json b/research/t488-independent-audit/SOURCES.json new file mode 100644 index 0000000000..f71ef08d1c --- /dev/null +++ b/research/t488-independent-audit/SOURCES.json @@ -0,0 +1,690 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "research/coupled-carrier-cap740/vendor/PR3133-PROVIDERS.json", + "usage": "provenance", + "git_blob": "0b2343675099d0a9fe90da6e1f1e53f50235567e", + "sha256": "52eb0d85caa7b2d4a93acdf5011f52b793f61ddca86235fb03cd9a09397ad4cd" + }, + { + "path": "research/coupled-carrier-cap740/words/base.json.gz", + "usage": "provenance", + "git_blob": "cb4cc24a4545944627ad595c0c5080196952b9f0", + "sha256": "300a9b8ad1d554f0e6f84f43f3f5fd870a5b4e5f81ad856900b6e8999684892e" + }, + { + "path": "research/coupled-carrier-cap740/words/extra.json.gz", + "usage": "provenance", + "git_blob": "decc8f26d8aab108baf75f0d8b2d1012eb06d076", + "sha256": "495d030f1e03b90e954dad3043994f03293d41b9ed220a3beaef849df435d3f0" + }, + { + "path": "research/rank7-coupled-586-588-carrier-fold/edits/FINAL-WORD-base.json.gz", + "usage": "provenance", + "git_blob": "cb4cc24a4545944627ad595c0c5080196952b9f0", + "sha256": "300a9b8ad1d554f0e6f84f43f3f5fd870a5b4e5f81ad856900b6e8999684892e" + }, + { + "path": "research/rank7-coupled-586-588-carrier-fold/edits/FINAL-WORD-extra.json.gz", + "usage": "provenance", + "git_blob": "decc8f26d8aab108baf75f0d8b2d1012eb06d076", + "sha256": "495d030f1e03b90e954dad3043994f03293d41b9ed220a3beaef849df435d3f0" + }, + { + "path": "research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz", + "usage": "provenance", + "git_blob": "7a1db55a4d53ee99280be4f3ab7d29f7b2033adf", + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e" + }, + { + "path": "research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz", + "usage": "provenance", + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e" + } + ], + "remote_sources": [ + { + "key": "outer_claim.json", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3653, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3653", + "commit": "607a09ff441c79b215a8127a81f4cc70021d0d9b", + "path": "research/retimed-t488-composition/evidence/recorded-admission/outer_claim.json", + "git_blob": "6f05d13347e650467b561f1861e6266ffc9ef15c", + "sha256": "c7455323c62a5b1d5c9ceef07a305a5758df6971ac8f88e2be5223eb5f4c7553", + "read_by": [ + "verify.INPUTS:outer3653" + ] + }, + { + "key": "independent_literal.py", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3653, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3653", + "commit": "607a09ff441c79b215a8127a81f4cc70021d0d9b", + "path": "research/retimed-t488-composition/full-replay/vendor/pr3642/vendor/staged-width-t530/owners/independent_literal.py", + "git_blob": "32755776c15660b939c92cb8835c71ec87c8c1d6", + "sha256": "36d7f4e3a611fd6b5983222887beb9a37a18bfac0d999ac5c00e3e191d1c5cc4", + "read_by": [ + "audit_inherited_controls.COPIES.PR3653-vendor" + ] + }, + { + "key": "RETIMED644-660-base.json.gz", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3653, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3653", + "commit": "607a09ff441c79b215a8127a81f4cc70021d0d9b", + "path": "research/retimed-t488-composition/local-audit/words/RETIMED644-660-base.json.gz", + "git_blob": "d69125e0c7d34af9299e411ada5c30dfc7b95ad1", + "sha256": "6df3356808e29909776be8bc0faf03df983401a267c2d740d1ac2dbcaa278269", + "read_by": [ + "verify.INPUTS:w3653_base" + ] + }, + { + "key": "RETIMED644-660-extra.json.gz", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3653, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3653", + "commit": "607a09ff441c79b215a8127a81f4cc70021d0d9b", + "path": "research/retimed-t488-composition/local-audit/words/RETIMED644-660-extra.json.gz", + "git_blob": "f3c580b06506e8888fe766c9a1e0bb1a748d7b74", + "sha256": "65624efec36b35934b750c1741ba2ad4e6df3cff86e44536b0c016ebddb0fb55", + "read_by": [ + "verify.INPUTS:w3653_extra" + ] + }, + { + "key": "independent_literal.py", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3653, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3653", + "commit": "607a09ff441c79b215a8127a81f4cc70021d0d9b", + "path": "research/retimed-t488-composition/owners/independent_literal.py", + "git_blob": "403a9cd104c7e68a5bd2431bb442d701f30828f5", + "sha256": "caa5eb4fff4908c0891c3ee41e7e6d71bf19bb710d1d7781164f10ce84bce769", + "read_by": [ + "audit_inherited_controls.COPIES.PR3653" + ] + }, + { + "key": "independent_literal.py", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3653, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3653", + "commit": "607a09ff441c79b215a8127a81f4cc70021d0d9b", + "path": "research/retimed-t488-composition/owners/upstream/independent_literal.py", + "git_blob": "e2a226950ed30e88f6c386669716b9a463dd873d", + "sha256": "8517c0d6c7cbe73438885135ac7fd9781dd5120113c9721002346dca603f5ed9", + "read_by": [ + "audit_inherited_controls.COPIES.PR3653-upstream" + ] + }, + { + "key": "CLAIM.json", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3605, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3605", + "commit": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "path": "research/staged-644-660-conditional-release/CLAIM.json", + "git_blob": "445e6a83a4cdc6e8630e86f20990b50d1311f81d", + "sha256": "2e721209f626d5111142951b1f26383d6746b4f230a4625244b5e5c84d6079d5", + "read_by": [ + "verify.INPUTS:claim3605" + ] + }, + { + "key": "independent_literal.py", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3605, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3605", + "commit": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "path": "research/staged-644-660-conditional-release/owners/independent_literal.py", + "git_blob": "5d1a7b4fd635070522e78656ccedf9bcf4bf13db", + "sha256": "da897bd5cef36943b3f5b1422fe81716b4eaa6230b056d31f8c2310cf62f8580", + "read_by": [ + "audit_inherited_controls.COPIES.PR3605" + ] + }, + { + "key": "CLAIM.json", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3630, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3630", + "commit": "bcac7fe04b9b7f7f5d3c27d620561f96c4ae5608", + "path": "research/staged-644-660-owner-successor/CLAIM.json", + "git_blob": "f82fff358656f8f6fe5d781157f12bc8b1edb62b", + "sha256": "aa4f56010fd4c1e620c742a091932ef3af05cca13886915c1c44f30e9f961aab", + "read_by": [ + "verify.INPUTS:claim3630" + ] + }, + { + "key": "README.md", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3630, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3630", + "commit": "bcac7fe04b9b7f7f5d3c27d620561f96c4ae5608", + "path": "research/staged-644-660-owner-successor/README.md", + "git_blob": "0f46d29b9d8674a1bb8851f2ea647e754ce40c12", + "sha256": "79cf49cd2274364888830d63a664f514c7b1a51d3ac54e57dc4117d432078e31", + "read_by": [ + "audit_ceiling.PINS.readme3630" + ] + }, + { + "key": "VALIDATION.json", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3630, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3630", + "commit": "bcac7fe04b9b7f7f5d3c27d620561f96c4ae5608", + "path": "research/staged-644-660-owner-successor/VALIDATION.json", + "git_blob": "5fb3ccf531d2e4c723f3a0abdf93813b8e3a77bb", + "sha256": "1d85df49a5e4b9d1262cfaffa9725e03bfe660f395bc6c08d594a0b0551fc24e", + "read_by": [ + "audit_ceiling.PINS.validation3630" + ] + }, + { + "key": "check_budget.py", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3630, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3630", + "commit": "bcac7fe04b9b7f7f5d3c27d620561f96c4ae5608", + "path": "research/staged-644-660-owner-successor/check_budget.py", + "git_blob": "a1de88c5f77ca173d581a5bcd0ed4f3144d74b56", + "sha256": "639820c9ccf72b88ae16768055ec5500a66004784f57a2fa5f218bf4d2e4ee05", + "read_by": [ + "audit_ceiling.PINS.budget3630" + ] + }, + { + "key": "independent_owners.py", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3630, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3630", + "commit": "bcac7fe04b9b7f7f5d3c27d620561f96c4ae5608", + "path": "research/staged-644-660-owner-successor/independent_owners.py", + "git_blob": "f116cc0142b4f6d674abf6e4c844142c00fb0297", + "sha256": "8d02dff267938cdb373aa617a411d8e67700e130609d2714e98ccf814e32eaef", + "read_by": [ + "audit_inherited_controls.COPIES.PR3630" + ] + }, + { + "key": "STAGED644-660-base.json.gz", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3605, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3605", + "commit": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "path": "research/staged-644-660-width-reduction/STAGED644-660-base.json.gz", + "git_blob": "dc6d321b1e8e2a837a1ff7bb60e8f8f78d043db5", + "sha256": "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653", + "read_by": [ + "audit_staged_words.PR3605_PATH" + ] + }, + { + "key": "STAGED644-660-extra.json.gz", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3605, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3605", + "commit": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "path": "research/staged-644-660-width-reduction/STAGED644-660-extra.json.gz", + "git_blob": "78e7b2bb0653c8dcc0133980a19dd9d97ebdb67e", + "sha256": "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f", + "read_by": [ + "audit_staged_words.PR3605_PATH" + ] + }, + { + "key": "independent_literal.py", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3642, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3642", + "commit": "044d24f12e74f228dd462c07ae2d7f3ea35e2be9", + "path": "research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/independent_literal.py", + "git_blob": "32755776c15660b939c92cb8835c71ec87c8c1d6", + "sha256": "36d7f4e3a611fd6b5983222887beb9a37a18bfac0d999ac5c00e3e191d1c5cc4", + "read_by": [ + "audit_inherited_controls.COPIES.PR3642-vendor" + ] + }, + { + "key": "independent_literal.py", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3642, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3642", + "commit": "044d24f12e74f228dd462c07ae2d7f3ea35e2be9", + "path": "research/staged-release-retiming-t530/owner-audit/independent_literal.py", + "git_blob": "86dc50768ff3fda8e265c08aa9314fe072e0c396", + "sha256": "b51c36ad1ae0999547edc4726d698df369fef60daaaac4f5bbea471648c9f628", + "read_by": [ + "audit_inherited_controls.COPIES.PR3642" + ] + }, + { + "key": "independent_literal.py", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3642, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3642", + "commit": "044d24f12e74f228dd462c07ae2d7f3ea35e2be9", + "path": "research/staged-release-retiming-t530/owner-audit/upstream/independent_literal.py", + "git_blob": "32755776c15660b939c92cb8835c71ec87c8c1d6", + "sha256": "36d7f4e3a611fd6b5983222887beb9a37a18bfac0d999ac5c00e3e191d1c5cc4", + "read_by": [ + "audit_inherited_controls.COPIES.PR3642-upstream" + ] + }, + { + "key": "CLAIM.json", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3624, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3624", + "commit": "515a7c4490aa32ac3ca5014feb6f7da0d6952863", + "path": "research/staged-width-t450/CLAIM.json", + "git_blob": "0d59dc3be440d616dcc24c01d38a6b2439e4b94b", + "sha256": "8f2f80438593e7efaa6bb57c881a40cedbd7b5665b4ae12c6cf215d217c98397", + "read_by": [ + "verify.INPUTS:claim3624" + ] + }, + { + "key": "independent_literal.py", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3624, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3624", + "commit": "515a7c4490aa32ac3ca5014feb6f7da0d6952863", + "path": "research/staged-width-t450/owners/independent_literal.py", + "git_blob": "d9c2450e03d9dcde39ae96f0edc835d1a67d9fe5", + "sha256": "68684584d3866b2ab76c254dd6d5be3a49d276a6e5f6353183dee4d8d84de4d4", + "read_by": [ + "audit_inherited_controls.COPIES.PR3624" + ] + }, + { + "key": "independent_literal.py", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3624, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3624", + "commit": "515a7c4490aa32ac3ca5014feb6f7da0d6952863", + "path": "research/staged-width-t450/provenance/pr3605/owners/independent_literal.py", + "git_blob": "5d1a7b4fd635070522e78656ccedf9bcf4bf13db", + "sha256": "da897bd5cef36943b3f5b1422fe81716b4eaa6230b056d31f8c2310cf62f8580", + "read_by": [ + "audit_inherited_controls.COPIES.PR3624-provenance" + ] + }, + { + "key": "CLAIM.json", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3633, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3633", + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "path": "research/staged-width-t488/CLAIM.json", + "git_blob": "3e56f9a3035ebe3da02fdf8bc6d71cde4e6c90a0", + "sha256": "3332fb6f6d5ae81da8ead667973491ebefa1803d6d96a06790386ac16243f332", + "read_by": [ + "audit_ceiling.PINS.claim", + "verify.INPUTS:claim3633" + ] + }, + { + "key": "CEILING.json", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3633, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3633", + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "path": "research/staged-width-t488/ceiling/CEILING.json", + "git_blob": "8bbec230ddf8498ac55c9ce32adabe813bf07eda", + "sha256": "a26bf26118222a5bcb6bf9f698d6b8b86003ff7b1479fd68b31f67c74945e460", + "read_by": [ + "audit_ceiling.PINS.ceiling3633" + ] + }, + { + "key": "CANDIDATE.json", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3633, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3633", + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "path": "research/staged-width-t488/owners/CANDIDATE.json", + "git_blob": "4293ad4cb76533072610c858d3f44576afe8d777", + "sha256": "fbdda845beac5bba9baa4b1b8c8f596e98f70b59e1d60ebf4f4d3e8758631bfd", + "read_by": [ + "audit_ceiling.PINS.candidate", + "verify.INPUTS:t488_candidate" + ] + }, + { + "key": "DISPATCH37.json", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3633, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3633", + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "path": "research/staged-width-t488/owners/DISPATCH37.json", + "git_blob": "c4c016ea3f3cb7bd04c1812259246a9411ad7adc", + "sha256": "4f78935b2ef1f6c08c9c16433d54015def1eccd767443b496a77ea8823690df6", + "read_by": [ + "verify.INPUTS:t488_dispatch37" + ] + }, + { + "key": "EXPECTED.json", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3633, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3633", + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "path": "research/staged-width-t488/owners/EXPECTED.json", + "git_blob": "415eac1a2b0201beac2c3e531c6fcbd1133a819f", + "sha256": "924493b6bbeade055af4916ac7bd6d7d7ec0600719f5c39636dc3f16d7ec14ea", + "read_by": [ + "audit_ceiling.PINS.expected", + "audit_inherited_controls.EXPECTED_JSON", + "verify.INPUTS:t488_expected" + ] + }, + { + "key": "ORDER37.json", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3633, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3633", + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "path": "research/staged-width-t488/owners/ORDER37.json", + "git_blob": "411004ab280d6468bdd9c98c01f153baed66c543", + "sha256": "94803d190b2b0506d9645e980b57cdbc3e98221f3b615292df8a94f1b174c984", + "read_by": [ + "verify.INPUTS:t488_order37" + ] + }, + { + "key": "PROVIDERS.json", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3633, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3633", + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "path": "research/staged-width-t488/owners/PROVIDERS.json", + "git_blob": "f321d4185339244b8b004326af70e653e611d84a", + "sha256": "d96f2798024ab83edbb8848b62c425992aec182f1f24ef46bb8286dd390618c2", + "read_by": [ + "audit_staged_words.PROVIDERS" + ] + }, + { + "key": "SOURCE-PINS.json", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3633, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3633", + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "path": "research/staged-width-t488/owners/SOURCE-PINS.json", + "git_blob": "5aa0ee4cb46308e674c5e1cedaa7eefc7bac59bd", + "sha256": "7dec42af587af3b7ae66d4fdf3d0c6157f9c85eb744edec66fa266f294378e5e", + "read_by": [ + "audit_staged_words.SOURCE_PINS" + ] + }, + { + "key": "T16-DISPATCH.json", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3633, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3633", + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "path": "research/staged-width-t488/owners/T16-DISPATCH.json", + "git_blob": "40725d2abb328ba7fee1c4f74656eecd982f2f7e", + "sha256": "282960b7163bc305675b64d1d0faee9f71b18848748326418a013626944c6488", + "read_by": [ + "verify.INPUTS:t488_dispatch_t16" + ] + }, + { + "key": "T16-ORDER.json", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3633, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3633", + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "path": "research/staged-width-t488/owners/T16-ORDER.json", + "git_blob": "470b8afb8af03fd053b6ff19bc90eb410b5c9e6b", + "sha256": "9b2106c84aed23a7c3c8b99e21d3e96c66b12f92980a42ab2f6dbbe7831ef7c4", + "read_by": [ + "verify.INPUTS:t488_order_t16" + ] + }, + { + "key": "T8-DISPATCH.json", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3633, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3633", + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "path": "research/staged-width-t488/owners/T8-DISPATCH.json", + "git_blob": "f95b6f07bf4d9e607a7ab8fcc101cdc63a725b07", + "sha256": "23877abbe8ec258eb1f2425137f9171d37b1a4414a25595abe75eb0738850a24", + "read_by": [ + "verify.INPUTS:t488_dispatch_t8" + ] + }, + { + "key": "T8-ORDER.json", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3633, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3633", + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "path": "research/staged-width-t488/owners/T8-ORDER.json", + "git_blob": "b013bdb989f7fde1b8a22ae8ed743eae3a0a62fd", + "sha256": "a1abf78fb3b88bbf4656e6ae26f148a007f744f0be4c00d480fb2424ce8766d6", + "read_by": [ + "verify.INPUTS:t488_order_t8" + ] + }, + { + "key": "independent_literal.py", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3633, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3633", + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "path": "research/staged-width-t488/owners/independent_literal.py", + "git_blob": "e2a226950ed30e88f6c386669716b9a463dd873d", + "sha256": "8517c0d6c7cbe73438885135ac7fd9781dd5120113c9721002346dca603f5ed9", + "read_by": [ + "audit_inherited_controls.COPIES.PR3633", + "audit_inherited_controls.TARGET" + ] + }, + { + "key": "independent_literal.py", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3633, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3633", + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "path": "research/staged-width-t488/provenance/pr3605/owners/independent_literal.py", + "git_blob": "5d1a7b4fd635070522e78656ccedf9bcf4bf13db", + "sha256": "da897bd5cef36943b3f5b1422fe81716b4eaa6230b056d31f8c2310cf62f8580", + "read_by": [ + "audit_inherited_controls.COPIES.PR3633-provenance" + ] + }, + { + "key": "STAGED644-660-base.json.gz", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3633, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3633", + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "path": "research/staged-width-t488/supplier3605/STAGED644-660-base.json.gz", + "git_blob": "dc6d321b1e8e2a837a1ff7bb60e8f8f78d043db5", + "sha256": "735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653", + "read_by": [ + "audit_staged_words.STAGED.base", + "verify.INPUTS:word_base" + ] + }, + { + "key": "STAGED644-660-extra.json.gz", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3633, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3633", + "commit": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "path": "research/staged-width-t488/supplier3605/STAGED644-660-extra.json.gz", + "git_blob": "78e7b2bb0653c8dcc0133980a19dd9d97ebdb67e", + "sha256": "886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f", + "read_by": [ + "audit_staged_words.STAGED.extra" + ] + }, + { + "key": "CLAIM.json", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3626, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3626", + "commit": "659fd5e7064d9466b668d7188cbb013b333a415a", + "path": "research/staged-width-t530/CLAIM.json", + "git_blob": "c11ec575770d8aabff9731ce9cc671fc9db448c9", + "sha256": "9f27717c3ddbf5eb7b9773e1b2887ff3899d354019139d916c9b8004aee2e097", + "read_by": [ + "verify.INPUTS:claim3626" + ] + }, + { + "key": "independent_literal.py", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3626, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3626", + "commit": "659fd5e7064d9466b668d7188cbb013b333a415a", + "path": "research/staged-width-t530/owners/independent_literal.py", + "git_blob": "32755776c15660b939c92cb8835c71ec87c8c1d6", + "sha256": "36d7f4e3a611fd6b5983222887beb9a37a18bfac0d999ac5c00e3e191d1c5cc4", + "read_by": [ + "audit_inherited_controls.COPIES.PR3626" + ] + }, + { + "key": "independent_literal.py", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3626, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3626", + "commit": "659fd5e7064d9466b668d7188cbb013b333a415a", + "path": "research/staged-width-t530/provenance/pr3605/owners/independent_literal.py", + "git_blob": "5d1a7b4fd635070522e78656ccedf9bcf4bf13db", + "sha256": "da897bd5cef36943b3f5b1422fe81716b4eaa6230b056d31f8c2310cf62f8580", + "read_by": [ + "audit_inherited_controls.COPIES.PR3626-provenance" + ] + }, + { + "key": "independent_literal.py", + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3638, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3638", + "commit": "d62e1acd7518a231440383f0d0dddf54d6edf8c1", + "path": "research/three-kappa-leads/independent_literal.py", + "git_blob": "4028493716bfcf3e73831067599518c055fcd2b0", + "sha256": "89c27f61ae3e6d2bdd4c469ac5b99d4f955a443c5e04c74e568c12093510efbe", + "read_by": [ + "audit_inherited_controls.COPIES.PR3638" + ] + } + ], + "vendored": [ + { + "path": "research/t488-independent-audit/vendor/pr3053/audit_common.py", + "module": "audit_common", + "git_blob": "17c4064f01b110012b54c05e64bdee8ae498e0b2", + "sha256": "7ced740252ac8d8a8c66ef3cc825008e0aacf080494d0e983fb322d7dcddbf42", + "copied_from": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/t74-3015-restore-edit-audit/vendor/pr2804/audit_common.py", + "usage": "vendored library of this contributor (byte copy of a merged file on main)" + }, + { + "path": "research/t488-independent-audit/vendor/pr3053/words_check.py", + "module": "words_check", + "git_blob": "0b646b9d5583c75a78e0c2dd7e9cfffa02055058", + "sha256": "b66414a39f5ac7b9cd32284027e13a550734901aca5f4457085a034689bc3ce6", + "copied_from": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/t74-3015-restore-edit-audit/vendor/pr2315/words_check.py", + "usage": "vendored library of this contributor (byte copy of a merged file on main)" + }, + { + "path": "research/t488-independent-audit/vendor/pr3053/fill_check80.py", + "module": "fill_check80", + "git_blob": "557e0732bfe4c030436a11f5433143c10fa07821", + "sha256": "1c4d30591969c6502605f239f40505261e99d025aa3b576a804332a6bc479b06", + "copied_from": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/t74-3015-restore-edit-audit/vendor/pr2387/fill_check80.py", + "usage": "vendored library of this contributor (byte copy of a merged file on main)" + }, + { + "path": "research/t488-independent-audit/vendor/pr3053/check_words.py", + "module": "check_words", + "git_blob": "451dbb82f147ef446a1819b1ed595b4bf5547583", + "sha256": "5996e804fa006906abff63a982c272588a44c35dfc932fdf687ef98dd3e0905f", + "copied_from": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/t74-3015-restore-edit-audit/vendor/pr2804/check_words.py", + "usage": "vendored library of this contributor (byte copy of a merged file on main)" + }, + { + "path": "research/t488-independent-audit/vendor/pr3053/audit_lib.py", + "module": "audit_lib", + "git_blob": "e8e847cc89dae6bb4e90e2c3dbebc30f615b698f", + "sha256": "e0cf84dd959d39e3f299c1e171753c29465fd5b4457561f4ab9ec0675d8e9dc1", + "copied_from": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/t74-3015-restore-edit-audit/vendor/pr2865/audit_lib.py", + "usage": "vendored library of this contributor (byte copy of a merged file on main)" + }, + { + "path": "research/t488-independent-audit/vendor/pr3053/audit_kappa.py", + "module": "audit_kappa", + "git_blob": "6e935547c98188a5fd2ba952641bf474d9323d9b", + "sha256": "8dd12fac27ba3ee7decf99a7a1e410e138ec0fc34805bb28b93fa5cc843ab0ee", + "copied_from": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/t74-3015-restore-edit-audit/audit_kappa.py", + "usage": "vendored library of this contributor (byte copy of a merged file on main)" + }, + { + "path": "research/t488-independent-audit/vendor/pr3053/audit_words.py", + "module": "audit_words", + "git_blob": "6368333e16c4f50e6eb8b5f2f4c178a2de8cbbb9", + "sha256": "ff831ad648dbecfd1c80f63245a84b762fdc70eb9fc3aa94dba23cd364857d18", + "copied_from": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/t74-3015-restore-edit-audit/audit_words.py", + "usage": "vendored library of this contributor (byte copy of a merged file on main)" + }, + { + "path": "research/t488-independent-audit/vendor/pr3053/check_accounting.py", + "module": "check_accounting", + "git_blob": "e749057dd838b715d0630de618f32d66a38da931", + "sha256": "fb6aef50da586f15cd60762edc074c20e300d65f1378a80160b3d4b840762548", + "copied_from": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/t74-3015-restore-edit-audit/vendor/pr2804/check_accounting.py", + "usage": "vendored library of this contributor (byte copy of a merged file on main)" + } + ], + "commits": { + "3605": "3efbb5de06a49ffeea6684482f2d3fe48cdca3fb", + "3624": "515a7c4490aa32ac3ca5014feb6f7da0d6952863", + "3626": "659fd5e7064d9466b668d7188cbb013b333a415a", + "3630": "bcac7fe04b9b7f7f5d3c27d620561f96c4ae5608", + "3633": "72c268f113368ea0387d188225e3f81ba6d6ef73", + "3638": "d62e1acd7518a231440383f0d0dddf54d6edf8c1", + "3642": "044d24f12e74f228dd462c07ae2d7f3ea35e2be9", + "3653": "607a09ff441c79b215a8127a81f4cc70021d0d9b" + }, + "package_data": [ + { + "path": "research/t488-independent-audit/data/FILL-columns.xz", + "sha256": "f10f95ccf2613988641533a664d15f300a6ccfd67cb3b7d636aa653c34a7e336", + "note": "PR3633 literal owner journal (output of PR3633 owners/portable_expand.py at head 72c268f1), re-encoded by tools/encode_journal.py; verify.py binds the decoded rows to PR3633 owners/EXPECTED.json payload_sha256 20662cc64df34cab409fdf31ed0f0222462530922a01308a46964d661d2374cf by byte-exact re-serialisation" + } + ], + "notes": [ + "All inputs are read with git show at the pinned commits and checked against git blob id and sha256; none is read from the working tree.", + "PR #3633, #3630, #3605, #3624, #3626, #3653, #3638 and #3642 are open; verify.py --fetch fetches their heads into refs/audit/prN (PR3638 and PR3642 only for the scope-C2 copy scan).", + "audit_inherited_controls.py also scans every .py blob of main and the eight PR heads to locate copies of PR3605's auditor (the located set must equal its pinned table) and to search for the sha256 its docstring cites; that scan is discovery beyond the pinned inputs listed here.", + "evidence/NATIVE-REPRODUCTION.json and evidence/GATE-DISABLE-DEMO.json are local-only records (not replayed); see README." + ] +} \ No newline at end of file diff --git a/research/t488-independent-audit/TASK.json b/research/t488-independent-audit/TASK.json new file mode 100644 index 0000000000..3530d45077 --- /dev/null +++ b/research/t488-independent-audit/TASK.json @@ -0,0 +1,100 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 6, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "scope_key": "pr3633-t488-independent-audit", + "original_card": { + "id": "independent-moment", + "question": "Does one changed supplier or assembly claim lack a source-bound independent check of a specific new implication?", + "starting_points": [ + "certificates/selected-result.json", + "research/rank7-joint-endframes/README.md", + "docs/research/research-family-status.md" + ], + "methods": [ + "Independently reconstruct a coordinated frame/circuit change and its single-change control, then derive the complete rank and physical ledger.", + "Implement certified moment inequalities through a different exact enclosure method." + ], + "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_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #2979 joint rank-7 end-frame proposal and the revision-6 evidence status. Its claimed kappa is not selected. Compare coordinated changes with the losing single-change controls and locate the complete physical ledger; an aggregate moment alone does not validate the mechanism.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Prioritize a bounded independent audit of #2979: reconstruct one joint group and its single-lowering control, check the declared frames/chronology, then trace changed children, idle widths and cleanup buffers into the complete invoice and both supplier caps. Choose one still-missing implication after checking existing audits. Stop with exact unresolved dependencies if full admission exceeds the session; do not launch a new lowering census on an unvalidated premise or substitute extra root digits for mechanism checking.", + "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.", + "allowed_variations": [ + "Reconstruct either a source ledger or a numeric enclosure with a different method." + ], + "scope_change_triggers": [ + "Importing the primary function and calling its output independent verification.", + "Promoting #2979 from merged source archive to validated supplier solely from author PASS receipts or aggregate pricing." + ], + "overlap_terms": [ + "independent moment", + "rank histogram", + "exact enclosure", + "2979", + "rank7 joint endframes", + "paired extraction", + "joint lowering" + ] + }, + "scope_status": "refined", + "actual_scope": "Independent verification of open PR #3633 (hexapode, head 72c268f113368ea0387d188225e3f81ba6d6ef73): the T488 allocation of Ross Richardson's staged 644/660 supplier (PR #3605), its complete invoice, its claimed attainment of the fixed-inventory packing ceiling (independently bounded by PR #3630) and its endpoint, with standard-library code that imports or executes nothing of PR3633, PR3630 or PR3605: the two supplier words through this contributor's word lineage; all 1,791,936 literal owner roles (windows derived two ways from the frozen template, families, capacities, chronological prefixes, the active-local-pair exclusion, the complete invoice, aggregate realisation, stock); an own fixed-inventory LP (a first draft mirrored PR3633's enumeration/column code and was rewritten after review) with a rigorous dual certificate, attainment and cross-checks of both published certificates; the endpoint in two rational enclosures with exact gains; PR #3653's endpoint on the same journal; and a static proof that the five reject() controls kept in PR3633's adapted owner auditor (and 14 other copies) cannot fail.", + "scope_change_reason": "The card names #2979's coordinated lowering as its first example; the line has since moved to the staged 644/660 supplier, whose newest conditional claim (PR #3633, 20 minutes old at selection) had no independent check, and Clear1nsight's handoff (discussion 1166, comment 19016699) listed an arithmetic/release audit of this line as open. The audit follows the card's methods (independent reconstruction of the complete ledger, a different exact enclosure method) on that claim.", + "declared_milestone": "audit", + "budget_minutes": 360, + "stop_rule": "Stop after the independent checks and their controls pass or a defect is found; no new allocation search, no native operator proof, no outer-transfer re-derivation.", + "outcome": "completed", + "started_utc": "2026-10-18T12:00:00Z", + "author": "Sagar Thakrar (thakrarsagar)", + "ai_assistance": "Substantial AI assistance (Claude Code, Anthropic): two scopes built by subagents, adversarial review rounds by subagents; no independent human review is claimed.", + "existing_checks_consulted": [ + "PR3633's own checks: owners/independent_literal.py (adapted from PR3605's auditor, adding artifact/source/native-pin, FILL-payload and exact ORDER/DISPATCH gates; its five controls unchanged), ceiling/verify_ceiling.py, seven admission stages run by the author with reused native caches; fresh end-to-end portable CLI not run (author disclosure).", + "PR3630 (RossRichardson): independent 2,551-pattern dual and all-T fixed-inventory ceiling; states that PR3624's certificate/invoice match its premises but did not rerun its admission.", + "PR3638 (zxv, concurrent, 11:58 UTC): a different T360 allocation tying the same endpoint, with its own dual replay; not a check of PR3633's journal.", + "PR3653 (rohanarun; ready for review since 13:46 UTC): reuses PR3633's literal T488 allocation with roger-sato's PR3642 retimed words.", + "Clear1nsight's three-route handoff in discussion 1166 (comment 19016699): arithmetic/release audit of this line open; PR3624 read only.", + "PR3642 (roger-sato): the retimed T530 words that PR3653 composes with PR3633's journal; its owner audit carries the same five controls.", + "PR3680 (jwr404), PR3681 (roger-sato, full replay of PR3605's wrapper), PR3682 (zxv, retimed releases at T360): later work on the line, none an independent check of PR3633's journal or ceiling.", + "PR3687 (this account's parallel session, 14:46 UTC): an independent exact audit of PR3605's staged words with the PR3133 control, in a different code lineage; agrees with scope C1 on the width inventory and local bill.", + "PR3677 (jwr404): the retimed local bill keeps rank mass 5,135 and lowers the moment (used by the PR3653 downstream check).", + "PR3693 (roger-sato, 15:33 UTC): audits the retimed (PR3642/PR3653) and delayed (PR3682) words, reusing PR3687's interpreter; covers the retimed words' exactness that this package does not check." + ], + "open_questions": [ + { + "question": "Does a width change, or a local-bill change beyond PR3642's retiming, raise the ceiling above 0.001730418899766071163804 (the retimed ceiling certified here for PR3633's allocation)?", + "why_it_matters": "Within scope A's fixed model (these widths and local bill, the template's bin counts/capacities, nine-call normalisation, live 896T) packing is closed for every T: PR3633 attains the ceiling (checked here) and PR3638 reports the same endpoint. PR3653 shows a local-bill change with unchanged widths moves the endpoint, with PR3633's allocation at the re-certified ceiling.", + "first_step": "Reuse audit_ceiling.py's LP to price single-helper width changes (an inventory change) and local-bill changes before building any word.", + "blocked_by": "Any width change needs a new exact supplier word (as PR3605 built for helpers 644/660)." + }, + { + "question": "Can the five owner-audit controls (15 copies across PR3605, PR3624, PR3626, PR3630, PR3633, PR3638, PR3642, PR3653) be made to test their gates?", + "why_it_matters": "Finding 1: the five reject() controls are tautologies, so the receipts carry no evidence that the gates can fail.", + "first_step": "Factor the gates into a check() function and rerun it on each mutated journal requiring the expected message (as the main-lineage checker does), or reuse audit_owners.controls.", + "blocked_by": "Nothing." + }, + { + "question": "Can the native file pins be made platform-independent?", + "why_it_matters": "Finding 2: rebuilt native files differ from the pinned files only in the gzip OS byte, so the one file-hash gate (independent_literal.py native_canonical) rejects a correct rebuild on another platform.", + "first_step": "Pin decompressed payload sha256 of CANONICAL-WORD (and FULL-WORD, LOCAL-PROGRAMS) in independent_literal.py's native_canonical and the receipts; PR3605's staged_pair.py already restores the OS byte for supplier words and PR3633 pins FILL by payload.", + "blocked_by": "Nothing." + }, + { + "question": "Does PR3633's complete fresh end-to-end replay (replay.py) pass on a machine with enough memory?", + "why_it_matters": "The author disclosed it as not run; here it passed fresh native, owners, parent-lift, rebind and discovery bind, then the discovery emit stage was killed by the OOM killer (> 5.1 GB) on a 7.9 GB machine.", + "first_step": "Rerun replay.py with >= 12 GB RAM or swap; roger-sato's PR3681 reports a full PR3605-wrapper replay that may show a working configuration.", + "blocked_by": "Memory on this machine." + } + ], + "family_expansion_decision": "None proposed. The audit admits nothing. It reports no correctness defect in PR3633's finite claims in the checked scope; shows that within the fixed packing model (the staged widths and local bill, bin counts/capacities, nine-call normalisation, live 896T) packing is closed: no allocation for any T exceeds the endpoint, so gains need a change to the supplier or to one of these premises; and reports two process defects (tautological inherited controls; platform-dependent native pins).", + "bottleneck_link": "PR #3633 is the newest conditional candidate of the complex supplier line (kappa 0.0017300963 against the selected 0.0016726602). Independent verification of its allocation and ceiling attainment, and the statement that packing on this inventory is exhausted, inform the director's next frontier and expansion decisions.", + "evidence": "verify.py --fetch (RESULT.json, about 3 min; reproduced under CPython 3.14.4 and 3.12.15; 212/212 negative controls rejected by their named rules): B all 1,791,936 roles of PR3633's journal (bound to its payload sha256) pass windows derived two ways, the active-pair exclusion (also a lemma over 18,544 triples), same-call families, capacities, chronological prefixes and the complete invoice over 983,808 bins = the claimed profile; the journal realises the aggregate's 11 capacity-patterns; stock 437,757 (24 controls); A 2,551 patterns, own simplex, rigorous dual (12 zero / 2,539 positive reduced costs on [a_lo, a_hi]), unique LP-minimum profile attained by PR3633, PR3633 CEILING.json and PR3630 dual/digest cross-checked (52 controls); C1 both staged words exact forward and dual (632 inputs), widths = PR3633 PROVIDERS, differing from PR3133 only at helpers 389/397, change localised against the parent words (50 controls); D C = 0.001730096363528623534230 in two enclosures, kappa, gains over PR3626/PR3624/PR3630/PR3605 with improvement tests; PR3653's endpoint 0.001730418899766071163804 reproduced on the same journal with the dual re-certified at it (13 controls); C2 the five inherited reject() controls proved unable to fail in 15 files (65 controls); vendor pins (8 controls). Mutation sweep: 45/45 checker mutations killed after a passing baseline (local, CPython 3.14.4). Local-only: evidence/GATE-DISABLE-DEMO.json, evidence/NATIVE-REPRODUCTION.json." +} \ No newline at end of file diff --git a/research/t488-independent-audit/VERIFY.json b/research/t488-independent-audit/VERIFY.json new file mode 100644 index 0000000000..bbd8362ea5 --- /dev/null +++ b/research/t488-independent-audit/VERIFY.json @@ -0,0 +1,20 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py", + "--fetch" + ], + "timeout_seconds": 600, + "checks": "Independent verification of open PR #3633 head 72c268f1 (hexapode, T488 staged-width allocation) in standard-library code that reads PR files only as pinned git data (git blob id and sha256) and never imports or runs PR code; --fetch (git >= 2.29, network) writes only fetched objects and refs/audit/prN for PR3633, PR3630, PR3605, PR3624, PR3626, PR3653, PR3638 and PR3642. It checks: both staged supplier words through this contributor's word lineage (forward and dual replay through cleanup and the target endpoint, tracker, cleanup re-derivation, private buffers, frame recount; widths equal PR3633 PROVIDERS.json and differ from main's PR3133 providers only at helpers 389 and 397; the change localised against the parent words on main); the complete literal journal of 1,791,936 roles (shipped compactly and bound to PR3633's pinned payload sha256 by byte-exact re-serialisation): ORDER/DISPATCH rebuilt and bound to PR3633's literal-file pins, source windows derived two ways from the frozen template, strict/closed windows, the active-local-pair exclusion per role and as a template lemma, same-call physical-family exclusion, capacities, chronological compact prefixes, the complete invoice over all 983,808 bins equal to the claimed profile, the aggregate's patterns realised exactly and the physical stock 437,757; an own fixed-inventory LP (2,551 patterns, exact simplex, rigorous dual certificate, unique LP-minimum profile, attainment by PR3633's aggregate, the all-T ceiling within the fixed model, cross-checks of PR3633 CEILING.json and PR3630's dual and digest); the endpoint C = 0.001730096363528623534230 in two rational enclosures, kappa, exact gains over PR3626, PR3624, PR3630 and PR3605 with improvement tests; PR3653's endpoint on the same journal with the dual re-certified at it; and the five reject() controls kept in PR3633's owner auditor (three unsatisfiable predicates, two +1 perturbations of equalities the preceding gate asserted), proved unable to fail in all 15 located copies. It requires every negative control (212) to be rejected by its named rule and the result to equal RESULT.json (timings excluded). See README.md." + } + ] +} diff --git a/research/t488-independent-audit/audit_ceiling.py b/research/t488-independent-audit/audit_ceiling.py new file mode 100644 index 0000000000..b03d67579c --- /dev/null +++ b/research/t488-independent-audit/audit_ceiling.py @@ -0,0 +1,873 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Scope A: an own fixed-inventory LP ceiling for the staged 644/660 supplier and its attainment by PR3633 (see the +provenance note below). + +Model (PR3633 ceiling/PROOF.md and owners/UPSTREAM-PROOF.md; PR3630's check_budget.py literal constants are parsed +and compared below and state the same model with T = 740, live 896 T). Helper widths W = (4,5,6,7,8,9) with per-call +inventory I = (26,2,18,52,97,213) and per-call local paid bill L = 2439H1+726H2+224H3+102H4+20H5+8H8; nine calls per +replica; per replica n = (672,448,448,448) bins of capacities (8,16,32,48) (18 source children x 112 ports); live +stock 896 per replica; dimension 73; H_r(a) = r^(1-a). Over its lifetime a bin holds a multiset of helper roles (a +pattern p, p_w roles of width w) with |p| = sum_w w p_w <= cap and is charged one idle child H_{cap-|p|} (nothing +when |p| = cap). The complete profile of T replicas is 9T copies of L plus the idle children; its moment is +M_T(a) = sum_r n_r r (73/r)^a / (73 * 896 T) (audit_kappa.moment with live = 896T) and its 24-digit endpoint C is +the largest 24-digit decimal with M_T(C) < 1. + +Per-replica LP. Variables x_{c,p} >= 0 for every pattern of every capacity (the empty pattern included); +sum_p x_{c,p} = n_c (4 rows) and sum_{c,p} p_w x_{c,p} = 9 I_w (6 rows); cost sum x_{c,p} H_{c-|p|}(a) + 9 L. +Patterns are generated as multisets of roles (each multiset extended only by widths >= its largest member) and +cross-validated against an independent generating-function count. Search: an own two-phase revised simplex +(Bland's rule, exact Fractions, integer costs round(10^60 * mid of the audit_kappa enclosure of 73^a H_r(a)) at +a_hi = 0.001730096363528623534231; the common factor 73^a does not change the optimal basis). Certificate, checked +by check() without trusting the search: the patterns are complete and valid; the basic solution is exact, rational, +>= 0 and meets all ten equalities; the dual y is a vector of exact rational combinations of the symbols H_r; the +reduced cost of EVERY column is a rational combination of H_r that is either identically zero or has a rigorous +interval lower bound > 0 at a_hi AND uniformly on the decimal bracket [a_lo, a_hi] (audit_kappa.H encloses +r (73/r)^a = 73^a H_r(a), a common positive factor, increasing in a for r < 73); b.y = c.x symbolically. + +Ceiling theorem (finite certificate + this written argument). Hypotheses: the widths, capacities, per-replica bin +counts n, per-call inventory I, local bill L and nine-call normalization are exactly as above; T is any positive +integer; every one of the 9T I_w width-w roles lies in exactly one bin; every one of the n_c T capacity-c bins carries +one pattern with |p| <= c and is charged exactly H_{c-|p|}; the complete profile is 9T L plus those idle children; +the moment uses live stock 896T and m = 73. Claim: every such allocation has M_T(a_hi) > 1, so its root is < a_hi +and its 24-digit endpoint is <= a_lo = a_hi - 1e-24. Proof: x = (bin counts)/T is LP-feasible; weak duality with +reduced costs >= 0 at a_hi gives idle cost(a_hi) >= T b.y(a_hi) = T c.x*(a_hi); hence sum_r n_r H_r(a_hi) >= +T sum_r P_r H_r(a_hi) for the LP-minimum per-replica profile P, i.e. M_T(a_hi) >= M_P(a_hi) (live 896) > 1 by the +enclosure. All ranks are in [1, 48] < 73, so every term r (73/r)^a increases with a and M_T(a) > 1 for all a >= a_hi; +any 24-digit C with M_T(C) < 1 is < a_hi, i.e. C <= a_lo. Adding further paid children of rank in [1,72] only +raises M_T, so the bound persists. Relaxed (dropped): source windows, physical families, chronology, call-copy +decomposition, slot limits and integrality. NOT covered: any other width vector, inventory, local bill, +capacity/bin-count model, live-stock scaling or call normalization. The dual is certified at a_hi and uniformly on +[a_lo, a_hi] only; no all-exponent dual claim. Every LP-optimal solution is supported on the symbolically tight +columns (strictly positive reduced costs elsewhere), so its profile 9L + b.y is unique. + +Attainment. PR3633's T = 488 aggregate (owners/CANDIDATE.json: groups [cap, lo, hi, n_g] per base T = 61, x +[group, pattern, count], z [group, macro-time t, width, count], S = 8) uses only tight patterns, has 488 n_c bins of +each capacity, S n_g bins per group, 4392 I_w roles of each width, z inside lo < t <= hi with width balance, call +inventory and group degree, and its idle profile + 4392 L equals the claimed profile = 488 P. Its endpoint is +therefore exactly a_lo (accepted at a_lo, rejected at a_hi): no allocation in this fixed model has a larger 24-digit +endpoint. + +Cross-checks. PR3633 ceiling/CEILING.json: model, hashed candidate field list (must be the 11 scientific fields) +and candidate sha256 binding, basis, value, dual feasibility on the own columns at their exponent (a rational with +denominator 2^60 10^6, below a_hi) and at a_hi, b.y, the root polynomial (= lcm-scaled P minus scale * 896 at rank +73, i.e. live 896 per replica) and the root interval bracketing. PR3633 CLAIM.json: profile, root interval, kappa, +candidate_endpoint, calls and roles. PR3630: the literal constants of check_budget.py (ast.literal_eval of literal +right-hand sides) equal this model with W = 896 T; its parsed basis is optimal with the same value; its dual, +re-derived by the own symbolic solver, is positive uniformly on its [LO, HI] with its stated (12, 2539) counts, and +its reduced-cost coefficient digest (own reduced costs, PR3630's documented serialisation) equals VALIDATION.json +dual.coefficient_sha256; its README bound C < a_hi. + +Rejections raise audit_common.AuditFail('ceiling.: detail'); the vendored audit_kappa engine can also raise +AuditFail('kappa.: ...') (e.g. kappa.profile for a nonpositive count, kappa.rank for rank >= 73); a missing +key, wrong shape or unparsable literal raises AuditFail('ceiling.input_format: ...'). Every negative control runs +through check() on a deep copy and counts only on its expected rule id; they include three crafted duals whose +reduced cost is undecidable inside the enclosure at a_hi or changes sign inside (a_lo, a_hi), so the interval-endpoint +choices of lower_at/lower_uniform and the evaluation exponent are exercised. + +Independence: own code from the stated mathematics; PR3633/PR3630/PR3605 files are read as data only (PR3630's +check_budget.py is parsed by regular expressions and ast.literal_eval, never executed). Provenance note: a first +draft of this module mirrored the shape of PR3633's ceiling/verify_ceiling.py pattern walk and column builder and +of owners/verify_candidate.py's z loop; after review those parts were rewritten (multiset-extension enumeration, +sparse columns, tally-based aggregate checks). + +Credits: the capacity model and the finite-pattern primal/dual approach descend from the retained coupled-carrier- +cap740 certificate lineage on main (research/coupled-carrier-cap740); Ross Richardson's PR3630 (independent 2,551- +pattern dual and all-T ceiling) and PR3605 (staged 644/660 width 8->7 supplier); hexapode's PR3633 (T488 aggregate, +ceiling certificate). Standard library only. +""" +import ast +import copy +import hashlib +import json +import math +import os +import re +import subprocess +import sys +import time +from fractions import Fraction as Q +from pathlib import Path + +try: + _HERE = Path(__file__).resolve().parent + if str(_HERE / 'vendor' / 'pr3053') not in sys.path: + sys.path.insert(0, str(_HERE / 'vendor' / 'pr3053')) +except NameError: # loaded by exec: the integration supplies the vendored modules + _HERE = None + +import audit_common as AC +import audit_kappa as AK + +need = AC.need +E24 = Q(1, 10 ** 24) +A_LO = Q('0.001730096363528623534230') +A_HI = Q('0.001730096363528623534231') +T488 = 488 +MODEL = dict(widths=(4, 5, 6, 7, 8, 9), caps=(8, 16, 32, 48), n=(672, 448, 448, 448), inv=(26, 2, 18, 52, 97, 213), + local={1: 2439, 2: 726, 3: 224, 4: 102, 5: 20, 8: 8}, calls=9, live=896) +FIELDS3633 = ['baseT', 'S', 'order', 'dispatch', 'groups', 'widths', 'inventory', 'local_profile', 'x', 'z', 'profile'] +PR3633 = '72c268f113368ea0387d188225e3f81ba6d6ef73' +PR3630 = 'bcac7fe04b9b7f7f5d3c27d620561f96c4ae5608' +PINS = { # key: (commit, path, sha256) + 'candidate': (PR3633, 'research/staged-width-t488/owners/CANDIDATE.json', + 'fbdda845beac5bba9baa4b1b8c8f596e98f70b59e1d60ebf4f4d3e8758631bfd'), + 'expected': (PR3633, 'research/staged-width-t488/owners/EXPECTED.json', + '924493b6bbeade055af4916ac7bd6d7d7ec0600719f5c39636dc3f16d7ec14ea'), + 'ceiling3633': (PR3633, 'research/staged-width-t488/ceiling/CEILING.json', + 'a26bf26118222a5bcb6bf9f698d6b8b86003ff7b1479fd68b31f67c74945e460'), + 'claim': (PR3633, 'research/staged-width-t488/CLAIM.json', + '3332fb6f6d5ae81da8ead667973491ebefa1803d6d96a06790386ac16243f332'), + 'budget3630': (PR3630, 'research/staged-644-660-owner-successor/check_budget.py', + '639820c9ccf72b88ae16768055ec5500a66004784f57a2fa5f218bf4d2e4ee05'), + 'readme3630': (PR3630, 'research/staged-644-660-owner-successor/README.md', + '79cf49cd2274364888830d63a664f514c7b1a51d3ac54e57dc4117d432078e31'), + 'validation3630': (PR3630, 'research/staged-644-660-owner-successor/VALIDATION.json', + '1d85df49a5e4b9d1262cfaffa9725e03bfe660f395bc6c08d594a0b0551fc24e'), +} + + +def read_pinned(repo, key): + commit, path, sha = PINS[key] + env = {k: v for k, v in os.environ.items() if not k.startswith('GIT_')} + p = subprocess.run(['git', '--no-replace-objects', '-C', str(repo), 'show', '%s:%s' % (commit, path)], + stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env) + need(p.returncode == 0, 'ceiling.input: git show %s:%s failed: %s' % (commit[:12], path, p.stderr.decode()[:200])) + need(hashlib.sha256(p.stdout).hexdigest() == sha, 'ceiling.input: %s sha256 mismatch' % key) + return p.stdout + + +# ---------------------------------------------------------------- patterns, columns, symbols, intervals + +def enumerate_patterns(widths, caps): + """Every (cap, p): p a nonnegative count vector over widths with sum_w w p_w <= cap (empty pattern included). + + Roles are added one at a time in nondecreasing width order, so each multiset of roles is produced once; the + result is sorted by (cap, counts), the lexicographic order PR3630 serialises its coefficients in.""" + top, layer, multisets = max(caps), [((), 0)], [((), 0)] + while layer: + layer = [(ms + (w,), s + w) for ms, s in layer for w in widths if (not ms or w >= ms[-1]) and s + w <= top] + multisets += layer + vectors = [(tuple(ms.count(w) for w in widths), s) for ms, s in multisets] + return sorted((c, v) for c in caps for v, s in vectors if s <= c) + + +def dp_count(widths, cap): + """Number of nonnegative vectors with sum w p_w <= cap: prefix sum of the coefficients of prod 1/(1 - x^w).""" + f = [1] + [0] * cap + for w in widths: + for s in range(w, cap + 1): + f[s] += f[s - w] + return sum(f) + + +def used(widths, q): + return sum(w * k for w, k in zip(widths, q)) + + +def column(model, cap, q): + """Sparse LP column {row: coefficient}: the capacity row of cap, then one row per width carrying its count.""" + col = {model['caps'].index(cap): 1} + col.update((len(model['caps']) + i, k) for i, k in enumerate(q) if k) + return col + + +def times(model, pats, amounts): + """A x for the given columns and amounts, as a dense list of the ten row sums.""" + out = [Q(0)] * (len(model['caps']) + len(model['widths'])) + for (c, q), v in zip(pats, amounts): + for i, a in column(model, c, q).items(): + out[i] += a * v + return out + + +def rhs(model): + return [Q(v) for v in model['n']] + [Q(model['calls'] * v) for v in model['inv']] + + +def tally(items, key): + """Sum the counts of (k, n) items grouped by key(k).""" + out = {} + for k, n in items: + out[key(k)] = out.get(key(k), 0) + n + return out + + +def sym_add(acc, d, coef=1): + for r, v in d.items(): + acc[r] = acc.get(r, 0) + coef * v + if acc[r] == 0: + del acc[r] + return acc + + +def idle_sym(model, cap, q): + i = cap - used(model['widths'], q) + return {i: Q(1)} if i else {} + + +def reduced_cost(model, cap, q, y): + acc = dict(idle_sym(model, cap, q)) + for i, a in column(model, cap, q).items(): + sym_add(acc, y[i], -a) + return acc + + +def b_dot(b, y): + acc = {} + for bi, yi in zip(b, y): + sym_add(acc, yi, bi) + return acc + + +_H = {} + + +def h_iv(r, a): + """Rigorous enclosure of r (73/r)^a = 73^a H_r(a) from the vendored audit_kappa engine (cached).""" + if (r, a) not in _H: + _H[r, a] = AK.H(r, a) + return _H[r, a] + + +def lower_at(sym, a): + """Lower bound of 73^a * sum_r c_r H_r(a).""" + return sum((c * h_iv(r, a)[0 if c > 0 else 1] for r, c in sym.items()), Q(0)) + + +def lower_uniform(sym, a0, a1): + """Lower bound of 73^a * sum_r c_r H_r(a) over a0 <= a <= a1 (each r (73/r)^a increases in a since r < 73).""" + return sum((c * (h_iv(r, a0)[0] if c > 0 else h_iv(r, a1)[1]) for r, c in sym.items()), Q(0)) + + +def inverse(B): + m = len(B) + z = [[Q(v) for v in row] + [Q(int(i == j)) for j in range(m)] for i, row in enumerate(B)] + for j in range(m): + k = next((k for k in range(j, m) if z[k][j]), None) + need(k is not None, 'ceiling.basis_singular: basis matrix is singular') + z[j], z[k] = z[k], z[j] + p = z[j][j] + z[j] = [v / p for v in z[j]] + for i in range(m): + if i != j and z[i][j]: + f = z[i][j] + z[i] = [u - f * v for u, v in zip(z[i], z[j])] + return [row[m:] for row in z] + + +def symbolic_dual(model, basis): + """y with B^T y = c_B, each y_i an exact rational combination {rank: coefficient} of the symbols H_r.""" + m = len(basis) + cols = [column(model, cap, q) for cap, q in basis] + Binv = inverse([[col.get(i, 0) for col in cols] for i in range(m)]) + y = [] + for i in range(m): + acc = {} + for k, (cap, q) in enumerate(basis): + if Binv[k][i]: + sym_add(acc, idle_sym(model, cap, q), Binv[k][i]) + y.append(acc) + return y + + +def profile_of(model, basis, x): + prof = {r: model['calls'] * Q(v) for r, v in model['local'].items()} + for (cap, q), v in zip(basis, x): + sym_add(prof, idle_sym(model, cap, q), v) + return prof + + +# ---------------------------------------------------------------- search (own simplex; not trusted by check) + +def simplex(model, patterns, a): + m, b = 10, rhs(model) + cols = [column(model, cap, q) for cap, q in patterns] + real = len(cols) + cols += [{i: 1} for i in range(m)] + costs = [] + for cap, q in patterns: + i = cap - used(model['widths'], q) + lo, hi = h_iv(i, a) if i else (0, 0) + costs.append(round((lo + hi) / 2 * 10 ** 60)) + basis, iters = list(range(real, real + m)), [0, 0] + + def phase(cost, ph): + while True: + Binv = inverse([[cols[j].get(i, 0) for j in basis] for i in range(m)]) + xB = [sum(Binv[i][k] * b[k] for k in range(m)) for i in range(m)] + y = [sum(cost[basis[k]] * Binv[k][i] for k in range(m)) for i in range(m)] + inb = set(basis) + enter = next((j for j in range(real) if j not in inb + and cost[j] - sum(y[i] * v for i, v in cols[j].items()) < 0), None) + if enter is None: + return Binv, xB + d = [sum(Binv[i][k] * v for k, v in cols[enter].items()) for i in range(m)] + cand = [(xB[i] / d[i], basis[i], i) for i in range(m) if d[i] > 0] + need(cand, 'ceiling.search: unbounded LP') + basis[min(cand)[2]] = enter + iters[ph] += 1 + Binv, xB = phase([0] * real + [1] * m, 0) + need(sum(v for v, j in zip(xB, basis) if j >= real) == 0, 'ceiling.search: LP infeasible') + for r in range(m): # drive zero-level artificials out (the 10 rows have full rank) + if basis[r] >= real: + j = next(j for j in range(real) if j not in basis + and sum(Binv[r][k] * v for k, v in cols[j].items()) != 0) + basis[r] = j + Binv = inverse([[cols[jj].get(i, 0) for jj in basis] for i in range(m)]) + Binv, xB = phase(costs + [0] * m, 1) + order = sorted(range(m), key=lambda i: basis[i]) + B = [patterns[basis[i]] for i in order] + return dict(basis=B, x=[xB[i] for i in order], y=symbolic_dual(model, B), iterations=iters) + + +# ---------------------------------------------------------------- parsing of PR3630 literals (data only) + +def parse_pr3630(src, readme): + def lit(pattern, what): + m = re.search(pattern, src, re.M) + need(m, 'ceiling.x3630_parse: %s literal not found' % what) + try: + return ast.literal_eval(m.group(1)) + except (ValueError, SyntaxError) as e: + need(False, 'ceiling.x3630_parse: %s is not a literal (%s)' % (what, e)) + consts = {k: lit(r'^%s = (.+)$' % k, k) for k in ('CAPS', 'WIDTHS', 'CAP_TOTAL', 'INVENTORY', 'L')} + consts['M'], consts['T'], consts['W'] = lit(r'^M, T, W = (.+)$', 'M, T, W') + consts['calls'] = 9 if re.search(r'^rhs = list\(map\(Q, CAP_TOTAL\)\) \+ \[Q\(9 \* n\) for n in INVENTORY\]$', + src, re.M) else None + m = re.search(r'^specs = \[(.*)\]$', src, re.M) + need(m, 'ceiling.x3630_parse: specs literal not found') + specs = [(int(c), tuple(int(v) for v in ws.replace(' ', '').split(',') if v), Q(int(p), int(d or 1))) + for c, ws, p, d in re.findall(r'\((\d+), \(([\d, ]*)\), Q\((\d+)(?:, (\d+))?\)\)', m.group(1))] + lo = re.search(r"^LO = Q\('([0-9.]+)'\)$", src, re.M) + hi = re.search(r'^HI = LO \+ Q\(1, 10 \*\* 24\)$', src, re.M) + cnt = re.search(r'\(len\(tight\), len\(strict\)\) == \((\d+), (\d+)\)', src) + bound = re.search(r'C < (0\.\d{24})', readme) + need(len(specs) == 10 and lo and hi and cnt and bound, 'ceiling.x3630_parse: basis/endpoints/counts/bound') + return dict(consts=consts, specs=specs, LO=lo.group(1), HI='LO + 1e-24', + counts=[int(cnt.group(1)), int(cnt.group(2))], bound=bound.group(1)) + + +def digest3630(model, pats, rcs): + """PR3630's coefficient digest: per pattern in (cap, counts) order, json [[cap, counts, idle], sorted (r, str)].""" + h = hashlib.sha256() + for c, q in sorted(pats): + h.update(json.dumps([[c, list(q), c - used(model['widths'], q)], sorted((r, str(v)) for r, v in + rcs[c, q].items())], + separators=(',', ':')).encode()) + return h.hexdigest() + + +def projection_sha(cand, fields): + return hashlib.sha256(json.dumps({k: cand[k] for k in fields}, sort_keys=True, separators=(',', ':')).encode() + ).hexdigest() + + +# ---------------------------------------------------------------- the main check + +def rule_of(e): + return str(e).split(':', 1)[0] + + +def check(D): + """Main check; the positive run and every negative control go through here.""" + try: + return _check(D) + except (KeyError, IndexError, TypeError, ValueError, ZeroDivisionError, AttributeError) as e: + raise AC.AuditFail('ceiling.input_format: malformed input (%s: %s)' % (type(e).__name__, e)) from e + + +def _check(D): + model, a_hi, rec = D['model'], D['a_hi'], {} + W, caps, calls = model['widths'], model['caps'], model['calls'] + b = rhs(model) + # 1. enumeration: every pattern fits, no duplicates, and the per-capacity count equals the DP count + pats = D['patterns'] + need(all(c in caps and len(q) == len(W) and all(type(k) is int and k >= 0 for k in q) and used(W, q) <= c + for c, q in pats), 'ceiling.enum_valid: a listed pattern does not fit its capacity') + need(len(set(pats)) == len(pats), 'ceiling.enum_distinct: duplicate pattern') + split = {c: sum(1 for cc, _ in pats if cc == c) for c in caps} + dp = {c: dp_count(W, c) for c in caps} + need(split == dp, 'ceiling.enum_complete: per-capacity counts %s != independent counts %s' % (split, dp)) + rec['patterns'] = dict(per_capacity={str(c): split[c] for c in caps}, total=len(pats)) + pset = set(pats) + # 2. primal: exact basic solution, >= 0, all ten equalities + cert = D['cert'] + basis, x, y = [(c, tuple(q)) for c, q in cert['basis']], cert['x'], cert['y'] + need(len(basis) == len(x) == 10 and all(p in pset for p in basis), 'ceiling.primal_column: basis not in enumeration') + need(all(v >= 0 for v in x), 'ceiling.primal_sign: negative basic amount') + Ax = times(model, basis, x) + need(Ax == b, 'ceiling.primal_rows: A x = %s != b = %s' % (Ax, b)) + # 3. dual feasibility of every column: symbolic zero, or rigorous positive lower bound at a_hi and on [a_lo, a_hi] + need(len(y) == 10, 'ceiling.dual_shape: ten dual entries required') + tight, strict, rcs = [], [], {} + for c, q in pats: + rc = reduced_cost(model, c, q, y) + rcs[c, q] = rc + if not rc: + tight.append((c, q)) + continue + lo = lower_at(rc, a_hi) + need(lo > 0, 'ceiling.dual_feasible: reduced cost of (%d, %s) = %s has lower bound %.3e at a_hi' + % (c, q, rc, float(lo))) + need(lower_uniform(rc, A_LO, A_HI) > 0, 'ceiling.dual_uniform: reduced cost of (%d, %s) not positive on ' + '[a_lo, a_hi]' % (c, q)) + strict.append(lo) + tset = set(tight) + # 4. strong duality: b.y == c.x symbolically + by = b_dot(b, y) + cx = {} + for (c, q), v in zip(basis, x): + sym_add(cx, idle_sym(model, c, q), v) + need(by == cx, 'ceiling.strong_duality: b.y %s != c.x %s' % (by, cx)) + P = profile_of(model, basis, x) + rec['lp'] = dict(a_hi=str(a_hi), basis=[dict(capacity=c, pattern=list(q), idle=c - used(W, q), x=str(v)) + for (c, q), v in zip(basis, x)], + dual=[{str(r): str(v) for r, v in sorted(yi.items())} for yi in y], + symbolically_zero=len(tight), strictly_positive=len(strict), + min_strict_lower_scaled_by_73a='%.6e' % float(min(strict)), + dual_uniform_on_bracket=[str(A_LO), str(A_HI)], + tight_patterns=[[c, list(q)] for c, q in tight], + minimum_profile_per_replica={str(r): str(v) for r, v in sorted(P.items())}, + idle_per_replica={str(r): str(v) for r, v in sorted(cx.items())}) + # 5. claimed profile (EXPECTED and CLAIM, T = 488) / 488 == LP minimum + cand = D['candidate'] + S, G, base = cand['S'], cand['groups'], cand['baseT'] + T = base * S + need(T == D['expected']['replicas'] == D['claim']['replicas'] == T488, 'ceiling.claimed_profile: T != 488') + for name in ('expected', 'claim'): + cp = {int(r): Q(v, T) for r, v in D[name]['profile'].items()} + need(cp == P, 'ceiling.claimed_profile: %s profile / 488 != LP minimum' % name) + # 6. attainment by the PR3633 aggregate + need(all(type(row) is list and len(row) == 4 and all(type(v) is int for v in row) and row[3] > 0 for row in G) + and all(type(e) is list and len(e) == 3 and type(e[0]) is int and type(e[2]) is int and type(e[1]) is list + and len(e[1]) == len(W) and all(type(k) is int for k in e[1]) for e in cand['x']) + and all(type(e) is list and len(e) == 4 and all(type(v) is int for v in e) for e in cand['z']), + 'ceiling.input_format: candidate groups/x/z must be integer lists [cap,lo,hi,n>0]/[g,[6],n]/[g,t,w,n]') + need(cand['widths'] == list(W) and {int(k): v for k, v in cand['inventory'].items()} == dict(zip(W, model['inv'])) + and {int(k): v for k, v in cand['local_profile'].items()} == model['local'] + and len(cand['order']) == calls * base and D['expected']['calls'] == calls * T, + 'ceiling.attain_model: candidate widths/inventory/local bill/nine-call normalization') + bins = {(g, tuple(q)): n for g, q, n in cand['x']} + need(len(bins) == len(cand['x']) and all(0 <= g < len(G) and n > 0 for (g, q), n in bins.items()), + 'ceiling.attain_format: x has a repeated (group, pattern), a group index out of range or a count <= 0') + kinds = {(G[g][0], q) for g, q in bins} + need(kinds <= pset, 'ceiling.attain_pattern: %s not enumerated' % sorted(kinds - pset)[:3]) + loose = sorted(kinds - tset) + need(not loose, 'ceiling.attain_tight: %d aggregate bin pattern(s) have positive reduced cost, e.g. %s' + % (len(loose), loose[:3])) + need(tally(bins.items(), lambda k: k[0]) == {g: S * row[3] for g, row in enumerate(G)}, + 'ceiling.attain_bins: bins per group != S n_g') + per_cap = tally(bins.items(), lambda k: G[k[0]][0]) + need(per_cap == {c: T * nc for c, nc in zip(caps, model['n'])} + and tally(((row[0], row[3]) for row in G), lambda c: c) == {c: base * nc for c, nc in zip(caps, model['n'])}, + 'ceiling.attain_bins: bins per capacity %s != 488 n' % per_cap) + roles = [sum(n * k[1][i] for k, n in bins.items()) for i in range(len(W))] + need(roles == [calls * T * v for v in model['inv']], 'ceiling.attain_roles: roles per width %s != 4392 I' % roles) + flow = {(g, t, w): n for g, t, w, n in cand['z']} + need(len(flow) == len(cand['z']) and all(0 <= g < len(G) and w in W and n > 0 for (g, t, w), n in flow.items()), + 'ceiling.attain_format: z has a repeated (group, time, width), a bad group/width or a count <= 0') + outside = sorted(k for k in flow if not G[k[0]][1] < k[1] <= G[k[0]][2]) + need(not outside, 'ceiling.attain_window: %d z entries outside their group window (lo, hi], e.g. %s' + % (len(outside), outside[:3])) + supply = tally((((g, w), n * k) for (g, q), n in bins.items() for w, k in zip(W, q) if k), lambda k: k) + need(tally(flow.items(), lambda k: (k[0], k[2])) == supply, + 'ceiling.attain_zbalance: per (group, width) z total != roles carried by that group\'s bins') + need(tally(flow.items(), lambda k: (k[1], k[2])) == {(t, w): S * v for t in range(len(cand['order'])) + for w, v in zip(W, model['inv'])}, + 'ceiling.attain_zcalls: per (macro-call, width) z total != S I_w') + over = sorted(k for k, v in tally(flow.items(), lambda k: (k[0], k[1])).items() if v > S * G[k[0]][3]) + need(not over, 'ceiling.attain_zdegree: %d (group, time) loads exceed S n_g, e.g. %s' % (len(over), over[:3])) + idle = tally(bins.items(), lambda k: G[k[0]][0] - used(W, k[1])) + idle.pop(0, None) + full = sym_add({r: calls * T * v for r, v in model['local'].items()}, idle) + for name, prof in (('candidate', cand['profile']), ('expected', D['expected']['profile']), + ('claim', D['claim']['profile'])): + need({int(r): v for r, v in prof.items()} == full, 'ceiling.attain_profile: idle + 4392 L != %s profile' % name) + used_kinds = sorted([c, list(q)] for c, q in kinds) + rec['attainment'] = dict(T=T, S=S, base_T=base, groups=len(G), x_entries=len(bins), z_entries=len(flow), + bins_per_capacity={str(c): v for c, v in sorted(per_cap.items())}, + roles_per_width={str(w): v for w, v in zip(W, roles)}, + idle_profile={str(r): v for r, v in sorted(idle.items())}, + full_profile={str(r): v for r, v in sorted(full.items())}, + tight_patterns_used=len(kinds), + nonbasic_tight_used=[k for k in used_kinds if (k[0], tuple(k[1])) not in set(basis)], + equals_488_times_LP_minimum=True) + # 7. root: claimed endpoint C accepted, C + 1e-24 rejected (live 896 T), for the LP minimum and the claimed profile + live = model['live'] * T + cl = D['claim'] + C = Q(cl['root_interval'][0]) + need(C > 0 and (C * 10 ** 24).denominator == 1, 'ceiling.endpoint_format: claimed C %s is not a 24-digit decimal' % C) + mom = lambda p, a: AK.moment(p, a, live=live) + profiles = {'lp_minimum_x488': {r: v * T for r, v in P.items()}, + 'pr3633_claimed': {int(r): v for r, v in D['expected']['profile'].items()}} + rec['root'] = {} + for name, prof in profiles.items(): + need(AK.accepts(mom(prof, C)), 'ceiling.root_accept: %s not accepted at claimed endpoint %s' % (name, C)) + need(AK.rejects(mom(prof, C + E24)), 'ceiling.root_reject: %s not rejected at %s' % (name, C + E24)) + rec['root'][name] = AK.endpoint_check(prof, C, mom=mom) + need(AK.rejects(AK.moment(P, a_hi, live=model['live'])), 'ceiling.root_ceiling: LP minimum not rejected at a_hi') + need(Q(cl['root_interval'][1]) == C + E24 and C + E24 == a_hi, + 'ceiling.claim_interval: claimed root interval is not [C, C + 1e-24] with C + 1e-24 = a_hi') + kappa = Q(cl['kappa']) + need(kappa == C - AK.KAPPA_TERMS[0] - AK.KAPPA_TERMS[1], 'ceiling.kappa: kappa != C - 1e-46 - 1e-70') + need(Q(cl['candidate_endpoint']) == kappa and cl['calls'] == calls * T and cl['roles'] == calls * T * sum(model['inv']), + 'ceiling.claim_fields: CLAIM candidate_endpoint/calls/roles differ from kappa/4392/4392 sum(I)') + rec['root'].update(endpoint=AK.dec(C, 24), kappa=cl['kappa'], candidate_endpoint_equals_kappa=True, live=live, + lp_minimum_per_replica_rejected_at_a_hi=True, + ceiling='for every positive integer T every complete allocation of this fixed model has ' + 'M_T(a_hi) > 1, so its 24-digit endpoint is <= %s; PR3633 attains it' % AK.dec(C, 24)) + # 8a. cross-check PR3633 ceiling/CEILING.json + cj = D['ceiling3633'] + need(cj['widths'] == list(W) and cj['capacities'] == list(caps) + and {int(k): v for k, v in cj['inventory'].items()} == dict(zip(W, model['inv'])) + and {int(k): v for k, v in cj['local_profile'].items()} == model['local'] + and [Q(v) for v in cj['rhs_per_replica']] == b, 'ceiling.x3633_model: CEILING.json model differs') + need(cj['candidate_scientific_fields'] == FIELDS3633, + 'ceiling.x3633_fields: hashed candidate field list %s != the 11 scientific fields' % cj['candidate_scientific_fields']) + need(projection_sha(cand, FIELDS3633) == cj['candidate_scientific_sha256'], + 'ceiling.x3633_binding: candidate projection sha256') + cb = [(e['capacity'], tuple(e['counts'])) for e in cj['basis']] + cx3633 = [Q(e['amount_per_replica']) for e in cj['basis']] + need(all(p in pset for p in cb) and all(e['idle'] == e['capacity'] - used(W, e['counts']) for e in cj['basis']) + and times(model, cb, cx3633) == b and all(v >= 0 for v in cx3633), + 'ceiling.x3633_basis: CEILING.json primal basis infeasible') + need(profile_of(model, cb, cx3633) == P and {int(r): Q(v) for r, v in cj['full_profile_per_replica'].items()} == P, + 'ceiling.x3633_value: CEILING.json optimal value differs from the LP minimum') + y3633 = [{int(r): Q(v) for r, v in row.items()} for row in cj['dual_by_constraint']] + need(len(y3633) == 10, 'ceiling.x3633_dual: ten dual entries required') + e3633 = Q(cj['exponent']) + xs = {} + for label, a in (('at_their_exponent', e3633), ('at_a_hi', a_hi)): + z = s = 0 + for c, q in pats: + rc = reduced_cost(model, c, q, y3633) + if not rc: + z += 1 + else: + need(lower_at(rc, a) > 0, 'ceiling.x3633_dual: CEILING.json dual infeasible at %s for (%d, %s)' + % (label, c, q)) + s += 1 + xs[label] = [z, s] + need(b_dot(b, y3633) == cx, 'ceiling.x3633_dual_value: CEILING.json dual value b.y differs from the LP minimum') + scale = math.lcm(*(v.denominator for v in P.values())) + poly = {int(r): v for r, v in cj['scaled_root_profile'].items()} + need(poly == {**{r: int(v * scale) for r, v in P.items()}, 73: -scale * model['live']}, + 'ceiling.x3633_rootpoly: CEILING.json root polynomial != %d P - %d H73 (live 896 per replica)' + % (scale, scale * model['live'])) + rl, rh = (Q(v) for v in cj['root_interval']) + need(e3633 == rh and rl < rh and AK.accepts(AK.moment(P, rl, live=model['live'])) + and AK.rejects(AK.moment(P, rh, live=model['live'])) and A_LO < rh <= a_hi, + 'ceiling.x3633_root: CEILING.json root interval does not bracket the LP-minimum root below a_hi') + rec['x3633'] = dict(basis_equal=sorted(cb) == sorted(basis), amounts_equal=dict(zip(cb, cx3633)) == dict(zip(basis, x)), + dual_equal=y3633 == y, zero_strict=xs, value_equal=True, field_list_pinned=True, + root_polynomial_scale=scale, exponent=cj['exponent'], + exponent_denominator_is_2p60_10p6=e3633.denominator == 2 ** 60 * 10 ** 6, + exponent_minus_a_hi='%.6e' % float(e3633 - a_hi), root_interval=cj['root_interval'], + root_lower_minus_a_lo='%.6e' % float(rl - A_LO), + note='their dual is certified at a rational exponent e = their root-interval upper end, with ' + 'a_lo < e <= a_hi; by monotonicity rejection at e implies rejection at a_hi; their root ' + 'interval is not the decimal bracket but brackets the same unique root') + # 8b. cross-check PR3630 (constants and basis parsed from check_budget.py; dual re-derived by the own solver) + r30 = D['pr3630'] + k30 = r30['consts'] + need(tuple(k30['CAPS']) == caps and tuple(k30['WIDTHS']) == W and tuple(k30['CAP_TOTAL']) == model['n'] + and tuple(k30['INVENTORY']) == model['inv'] and k30['L'] == model['local'] and k30['calls'] == calls + and k30['M'] == 73 and type(k30['T']) is int and k30['T'] > 0 and k30['W'] == model['live'] * k30['T'], + 'ceiling.x3630_model: PR3630 constants %s differ from this model' % k30) + b30 = [(c, tuple(ws.count(w) for w in W)) for c, ws, _ in r30['specs']] + x30 = [v for _, _, v in r30['specs']] + need(all(p in pset for p in b30) and all(v > 0 for v in x30) and times(model, b30, x30) == b, + 'ceiling.x3630_basis: PR3630 basis infeasible') + need(profile_of(model, b30, x30) == P, 'ceiling.x3630_value: PR3630 optimal value differs from the LP minimum') + y30 = symbolic_dual(model, b30) + lo30 = Q(r30['LO']) + z = s = 0 + rc30 = {} + for c, q in pats: + rc = rc30[c, q] = reduced_cost(model, c, q, y30) + if not rc: + z += 1 + continue + need(lower_at(rc, a_hi) > 0 and lower_uniform(rc, lo30, lo30 + E24) > 0, + 'ceiling.x3630_dual: PR3630 dual not positive for (%d, %s)' % (c, q)) + s += 1 + need([z, s] == r30['counts'], 'ceiling.x3630_dual: zero/strict counts %s != stated %s' % ([z, s], r30['counts'])) + v30 = D['validation3630']['dual'] + dig = digest3630(model, pats, rc30) + need(dig == v30['coefficient_sha256'] and [v30['patterns'], v30['symbolically_zero'], v30['strict']] + == [len(pats), z, s], 'ceiling.x3630_digest: own reduced-cost digest %s or counts != VALIDATION.json dual %s' + % (dig, v30)) + need(lo30 == A_LO and lo30 + E24 == a_hi and Q(r30['bound']) == a_hi, + 'ceiling.x3630_bound: PR3630 stated bracket/bound differ from [a_lo, a_hi]') + rec['x3630'] = dict(model_equal=True, model_T=k30['T'], model_live=k30['W'], + basis_equal=sorted(b30) == sorted(basis), amounts_equal=dict(zip(b30, x30)) == dict(zip(basis, x)), + dual_equal_to_own=y30 == y, zero_strict=[z, s], uniform_on_bracket=True, value_equal=True, + coefficient_sha256=dig, digest_matches_validation=True, + stated_bound=r30['bound'], bound_confirmed=True) + return rec + + +# ---------------------------------------------------------------- driver and negative controls + +def load(repo): + raw = {k: read_pinned(repo, k) for k in PINS} + D = dict(model=MODEL, a_hi=A_HI, patterns=enumerate_patterns(MODEL['widths'], MODEL['caps']), + candidate=json.loads(raw['candidate']), expected=json.loads(raw['expected']), + ceiling3633=json.loads(raw['ceiling3633']), claim=json.loads(raw['claim']), + validation3630=json.loads(raw['validation3630']), + pr3630=parse_pr3630(raw['budget3630'].decode(), raw['readme3630'].decode())) + return D, {k: dict(commit=PINS[k][0], path=PINS[k][1], sha256=PINS[k][2]) for k in PINS} + + +def controls(D, rec): + """Negative controls: each mutates a deep copy of D and runs it through check(); killed only on its rule id.""" + tight = {(c, tuple(q)) for c, q in rec['lp']['tight_patterns']} + basis = [(c, tuple(q)) for c, q in D['cert']['basis']] + W, G0 = D['model']['widths'], D['candidate']['groups'] + inc = lambda v: v + 1 + out = [] + + def edit(*path, f): # replace the value at a nested path by f(value) + def mut(d): + o = d + for k in path[:-1]: + o = o[k] + o[path[-1]] = f(o[path[-1]]) + return mut + + def qstr(delta): + return lambda v: str(Q(v) + delta) + + def dual_row0(g): # capacity-8 row dual + g (a {rank: coefficient} combination) + return edit('cert', 'y', 0, f=lambda yi: sym_add(dict(yi), g)) + + def h1_over_h3(a, pick3): # q with q H3 ~ H1 at exponent a (from the cached enclosures) + (l1, h1), (l3, h3) = h_iv(1, a), h_iv(3, a) + return (l1 + h1) / 2 / (l3 if pick3 == 'lo' else (l3 + h3) / 2) + q_hi = h1_over_h3(A_HI, 'lo') # q lo(H3) = mid(H1) at a_hi: sign undecidable inside the enclosure + q_mid = h1_over_h3((A_LO + A_HI) / 2, 'mid') # H1 - q H3 crosses zero inside (a_lo, a_hi), increasing in a + + def dup_tight(d): # a tight basic column replaced by a duplicate of another column of its capacity + i = next(i for i, p in enumerate(d['patterns']) if p in tight and p in basis) + d['patterns'][i] = next(p for p in d['patterns'] if p[0] == d['patterns'][i][0] and p != d['patterns'][i]) + + def x_add(c, g, q, n): # n more bins of pattern q in group g (merging, dropping emptied entries) + e = next((e for e in c['x'] if e[0] == g and e[1] == q), None) + if e is None: + c['x'].append([g, list(q), n]) + else: + e[2] += n + c['x'] = [e for e in c['x'] if e[2]] + + def swap_pattern(pick): # one x entry's pattern replaced by another of its capacity chosen by pick + def mut(d): + c = d['candidate'] + have = {(g, tuple(q)) for g, q, n in c['x']} + for e in c['x']: + q2 = next((p for cc, p in d['patterns'] if cc == G0[e[0]][0] and p != tuple(e[1]) and pick((cc, p)) + and (e[0], p) not in have), None) + if q2 is not None: + e[1] = list(q2) + return + need(False, 'ceiling.controls: no pattern swap available') + return mut + + def x_move(d): # one bin moved to another group of the same capacity: per-group counts broken + c = d['candidate'] + g1, q = c['x'][0][0], c['x'][0][1] + g2 = next(g for g, row in enumerate(G0) if g != g1 and row[0] == G0[g1][0]) + x_add(c, g1, q, -1) + x_add(c, g2, q, 1) + + def group_grow(d): # a capacity-48 group gets n_g + 1 and S more empty bins: per-capacity counts broken + c = d['candidate'] + g = next(g for g, row in enumerate(G0) if row[0] == 48) + c['groups'][g][3] += 1 + x_add(c, g, [0] * len(W), c['S']) + + def split(key): # an entry with count >= 2 split into two entries with the same key + def mut(d): + rows = d['candidate'][key] + e = next(e for e in rows if e[-1] >= 2) + e[-1] -= 1 + rows.append(copy.deepcopy(e[:-1]) + [1]) + return mut + + def z_time(which): + def mut(d): + c = d['candidate'] + e = c['z'][0] + if which == 'lo': + e[1] = G0[e[0]][1] + elif which == 'hi+1': + e[1] = G0[e[0]][2] + 1 + else: # another in-window macro-time: width balance kept, call inventory broken + have = {(g, t, w) for g, t, w, n in c['z']} + for e in c['z']: + t2 = next((t for t in range(G0[e[0]][1] + 1, G0[e[0]][2] + 1) if (e[0], t, e[2]) not in have), + None) + if t2 is not None: + e[1] = t2 + return + need(False, 'ceiling.controls: no free in-window macro-time') + return mut + + def z_group(d): # a z entry moved to another group whose window contains t: width balance broken + c = d['candidate'] + have = {(g, t, w) for g, t, w, n in c['z']} + for e in c['z']: + g2 = next((g for g, row in enumerate(G0) if g != e[0] and row[1] < e[1] <= row[2] + and (g, e[1], e[2]) not in have), None) + if g2 is not None: + e[0] = g2 + return + need(False, 'ceiling.controls: no other group for a z entry') + + def z_degree(d): # 1-unit 4-cycle move: balance and call totals kept, a saturated (g, t) overloaded + c, S = d['candidate'], d['candidate']['S'] + flow = {(g, t, w): n for g, t, w, n in c['z']} + load_ = tally(flow.items(), lambda k: (k[0], k[1])) + for g2, t1 in sorted(k for k, v in load_.items() if v == S * G0[k[0]][3]): + for (g1, t, w) in [k for k in flow if k[1] == t1 and k[0] != g2]: + t2 = next((k[1] for k in flow if k[0] == g2 and k[2] == w and k[1] != t1 + and G0[g1][1] < k[1] <= G0[g1][2]), None) + if t2 is not None: + for k, v in (((g1, t1, w), -1), ((g2, t1, w), 1), ((g2, t2, w), -1), ((g1, t2, w), 1)): + flow[k] = flow.get(k, 0) + v + c['z'] = [[*k, v] for k, v in flow.items() if v] + return + need(False, 'ceiling.controls: no degree move available') + + def c3633_fields(d): # shorter field list with its projection hash recomputed: only the list pin catches it + cj = d['ceiling3633'] + cj['candidate_scientific_fields'] = [f for f in FIELDS3633 if f != 'z'] + cj['candidate_scientific_sha256'] = projection_sha(d['candidate'], cj['candidate_scientific_fields']) + + def c3633_row0(delta): + return edit('ceiling3633', 'dual_by_constraint', 0, f=lambda row: {**row, '1': str(Q(row.get('1', '0')) + delta)}) + + def p30_pivot(d): # PR3630 basis -> adjacent feasible basis: a non-tight column pivoted in, unique ratio + specs, model = d['pr3630']['specs'], d['model'] + B = [(c, tuple(ws.count(w) for w in W)) for c, ws, _ in specs] + cols = [column(model, c, q) for c, q in B] + Binv = inverse([[col.get(i, 0) for col in cols] for i in range(len(B))]) + for c, q in d['patterns']: + if (c, q) in tight: + continue + dj = [sum(Binv[i][k] * v for k, v in column(model, c, q).items()) for i in range(len(B))] + ratios = sorted((specs[i][2] / dj[i], i) for i in range(len(B)) if dj[i] > 0) + if ratios and (len(ratios) == 1 or ratios[0][0] < ratios[1][0]): + th, leave = ratios[0] + specs[:] = [(s[0], s[1], s[2] - th * dj[i]) for i, s in enumerate(specs) if i != leave] + [ + (c, tuple(w for w, k in zip(W, q) for _ in range(k)), th)] + return + need(False, 'ceiling.controls: no non-degenerate pivot available') + + overfull = lambda cap: [0] * (len(W) - 1) + [cap // W[-1] + 1] + for name, mut, rule in ( + # enumeration and primal + ('drop_tight_pattern_column', edit('patterns', f=lambda ps: [p for p in ps if p != next( + b for b in basis if b in tight)]), 'ceiling.enum_complete'), + ('pattern_overfull', edit('patterns', 0, f=lambda p: (p[0], tuple(overfull(p[0])))), 'ceiling.enum_valid'), + ('duplicate_replaces_tight_column', dup_tight, 'ceiling.enum_distinct'), + ('primal_amount_negated', edit('cert', 'x', 0, f=lambda v: -v), 'ceiling.primal_sign'), + ('primal_amount_plus_1', edit('cert', 'x', 0, f=inc), 'ceiling.primal_rows'), + # dual: coarse and sharp perturbations, and three crafted near-zero reduced costs + ('dual_plus_1e-40_H1', dual_row0({1: Q(1, 10 ** 40)}), 'ceiling.dual_feasible'), + ('dual_undecidable_within_enclosure', dual_row0({1: Q(1), 3: -q_hi}), 'ceiling.dual_feasible'), + ('dual_negative_at_a_hi_positive_at_a_lo', dual_row0({1: Q(1), 3: -q_mid}), 'ceiling.dual_feasible'), + ('dual_positive_at_a_hi_negative_at_a_lo', dual_row0({1: Q(-1), 3: q_mid}), 'ceiling.dual_uniform'), + ('weak_feasible_dual_minus_1e-3_H1', dual_row0({1: -Q(1, 1000)}), 'ceiling.strong_duality'), + # claimed profiles + ('expected_profile_plus_H1', edit('expected', 'profile', '1', f=inc), 'ceiling.claimed_profile'), + ('claim_profile_plus_H1', edit('claim', 'profile', '1', f=inc), 'ceiling.claimed_profile'), + # aggregate + ('x_entry_malformed', edit('candidate', 'x', 0, f=lambda e: e[:2]), 'ceiling.input_format'), + ('x_count_float', edit('candidate', 'x', 0, 2, f=float), 'ceiling.input_format'), + ('candidate_inventory_edit', edit('candidate', 'inventory', '4', f=inc), 'ceiling.attain_model'), + ('x_entry_split_duplicate', split('x'), 'ceiling.attain_format'), + ('aggregate_overfull_pattern', edit('candidate', 'x', 0, f=lambda e: [e[0], overfull(G0[e[0]][0]), e[2]]), + 'ceiling.attain_pattern'), + ('aggregate_nontight_pattern', swap_pattern(lambda p: p not in tight), 'ceiling.attain_tight'), + ('x_count_plus_1', edit('candidate', 'x', 0, 2, f=inc), 'ceiling.attain_bins'), + ('x_bin_moved_between_groups', x_move, 'ceiling.attain_bins'), + ('group_plus_1_with_S_empty_bins', group_grow, 'ceiling.attain_bins'), + ('aggregate_other_tight_pattern', swap_pattern(lambda p: p in tight), 'ceiling.attain_roles'), + ('z_entry_split_duplicate', split('z'), 'ceiling.attain_format'), + ('z_at_window_lo', z_time('lo'), 'ceiling.attain_window'), + ('z_at_window_hi_plus_1', z_time('hi+1'), 'ceiling.attain_window'), + ('z_moved_to_other_group', z_group, 'ceiling.attain_zbalance'), + ('z_moved_to_other_call', z_time('move'), 'ceiling.attain_zcalls'), + ('z_degree_overload', z_degree, 'ceiling.attain_zdegree'), + ('candidate_profile_plus_H1', edit('candidate', 'profile', '1', f=inc), 'ceiling.attain_profile'), + # root and claim + ('claimed_endpoint_not_24_digit', edit('claim', 'root_interval', 0, f=qstr(Q(1, 10 ** 30))), + 'ceiling.endpoint_format'), + ('claimed_endpoint_plus_1e-24', edit('claim', 'root_interval', 0, f=qstr(E24)), 'ceiling.root_accept'), + ('claimed_endpoint_minus_1e-24', edit('claim', 'root_interval', 0, f=qstr(-E24)), 'ceiling.root_reject'), + ('certify_at_a_lo', edit('a_hi', f=lambda v: A_LO), 'ceiling.root_ceiling'), + ('claim_interval_upper_plus_1e-24', edit('claim', 'root_interval', 1, f=qstr(E24)), 'ceiling.claim_interval'), + ('kappa_plus_1e-70', edit('claim', 'kappa', f=qstr(Q(1, 10 ** 70))), 'ceiling.kappa'), + ('candidate_endpoint_changed', edit('claim', 'candidate_endpoint', f=lambda v: '1/1000'), + 'ceiling.claim_fields'), + # PR3633 CEILING.json + ('ceiling3633_inventory_edit', edit('ceiling3633', 'inventory', '4', f=inc), 'ceiling.x3633_model'), + ('ceiling3633_short_field_list', c3633_fields, 'ceiling.x3633_fields'), + ('candidate_dispatch_edit', edit('candidate', 'dispatch', 0, -1, f=lambda v: -7), 'ceiling.x3633_binding'), + ('ceiling3633_amount_edit', edit('ceiling3633', 'basis', 2, 'amount_per_replica', f=qstr(1)), + 'ceiling.x3633_basis'), + ('ceiling3633_full_profile_edit', edit('ceiling3633', 'full_profile_per_replica', '1', f=qstr(1)), + 'ceiling.x3633_value'), + ('ceiling3633_dual_perturb', c3633_row0(Q(1, 1000)), 'ceiling.x3633_dual'), + ('ceiling3633_weak_dual', c3633_row0(-Q(1, 1000)), 'ceiling.x3633_dual_value'), + ('ceiling3633_rootpoly_live', edit('ceiling3633', 'scaled_root_profile', '73', f=inc), + 'ceiling.x3633_rootpoly'), + ('ceiling3633_root_lower_at_upper', edit('ceiling3633', 'root_interval', f=lambda r: [r[1], r[1]]), + 'ceiling.x3633_root'), + # PR3630 + ('pr3630_live_plus_1', edit('pr3630', 'consts', 'W', f=inc), 'ceiling.x3630_model'), + ('pr3630_amount', edit('pr3630', 'specs', 2, f=lambda s: (s[0], s[1], s[2] + 1)), 'ceiling.x3630_basis'), + ('pr3630_adjacent_suboptimal_basis', p30_pivot, 'ceiling.x3630_value'), + ('pr3630_bracket_moved_to_0', edit('pr3630', 'LO', f=lambda v: '0'), 'ceiling.x3630_dual'), + ('pr3630_counts', edit('pr3630', 'counts', f=lambda v: [13, 2538]), 'ceiling.x3630_dual'), + ('pr3630_digest', edit('validation3630', 'dual', 'coefficient_sha256', f=lambda v: '0' * 64), + 'ceiling.x3630_digest'), + ('pr3630_bound', edit('pr3630', 'bound', f=lambda v: '0.001730096363528623534232'), 'ceiling.x3630_bound')): + AC.attempt(name) + d = copy.deepcopy(D) + mut(d) + try: + check(d) + got = None + except AC.AuditFail as e: + got = rule_of(e) + out.append(dict(name=name, expected=rule, raised=got, killed=got == rule)) + return out + + +def run(repo=None): + t0 = time.time() + repo = repo or (_HERE.parents[1] if _HERE else Path.cwd()) + D, pins = load(repo) + t1 = time.time() + found = simplex(D['model'], D['patterns'], D['a_hi']) + D['cert'] = dict(basis=found['basis'], x=found['x'], y=found['y']) + t2 = time.time() + rec = check(D) + t3 = time.time() + ctl = controls(D, rec) + need(all(c['killed'] for c in ctl), 'ceiling.controls: a negative control survived or raised another rule: %s' + % [c for c in ctl if not c['killed']]) + rec.update(status='PASS_FIXED_MODEL_LP_CEILING_ATTAINED_BY_PR3633', simplex_iterations=found['iterations'], + controls=ctl, inputs=pins, + seconds=dict(load=round(t1 - t0, 2), search=round(t2 - t1, 2), check=round(t3 - t2, 2), + controls=round(time.time() - t3, 2), total=round(time.time() - t0, 2)), + scope='Fixed staged 644/660 supplier (widths, inventory, local bill), capacities/bin counts, nine-call ' + 'normalization and live 896T; windows, families, chronology and integrality relaxed. Dual ' + 'certified at a_hi and uniformly on [a_lo, a_hi] only. No literal-owner, native, outer or ' + 'multiplication-theorem claim.') + return rec + + +if __name__ == '__main__': + print(json.dumps(run(sys.argv[1] if len(sys.argv) > 1 else None), indent=1)) diff --git a/research/t488-independent-audit/audit_endpoint.py b/research/t488-independent-audit/audit_endpoint.py new file mode 100644 index 0000000000..8b0991bad9 --- /dev/null +++ b/research/t488-independent-audit/audit_endpoint.py @@ -0,0 +1,232 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Scope D: the complex endpoint and kappa of PR #3633 from the complete profile recounted by audit_owners, with two +rational enclosures, the exact gains over the predecessors, and the improvement tests. + +M_T(a) = sum_r n_r r (73/r)^a / (73 * 896 T); C is the largest 24-digit decimal with M_T(C) < 1 and M_T(C + 1e-24) +> 1; kappa = C - 1e-46 - 1e-70 (the inherited outer margins, recorded by every package of this line). Enclosures: +audit_kappa.moment (atanh/Taylor series with explicit tails, outward rounding to 1e-60; PR3053) and +check_accounting.moment (640-bit fixed point; PR2804). Both must accept at C and reject at C + 1e-24 (the second +covers ranks {1,2,3,4,5,7,8,16,32,48}, which contain the T488 ranks). The improvement test asks that each +predecessor's complete profile (at its own T) is rejected at PR3633's C, i.e. the gain is a real moment gain and not +a rounding artefact. The BIT side is not re-derived: PR3605's recorded unchanged BIT endpoint is only compared. + +Rejections raise audit_common.AuditFail('endpoint.: ...') or the vendored 'kappa.*' rules. +Standard library only. +""" +from fractions import Fraction as Q + +from audit_common import need + +E24 = Q(1, 10 ** 24) +MARGINS = Q(1, 10 ** 46) + Q(1, 10 ** 70) +LIVE_PER_REPLICA = 896 + + +def dec24(q): + n = q * 10 ** 24 + need(n.denominator == 1 and n > 0, 'endpoint.format: not a positive 24-digit decimal') + n = int(n) + return '%d.%024d' % (n // 10 ** 24, n % 10 ** 24) + + +def intkeys(d): + return dict((int(k), v) for k, v in d.items()) + + +def moments(AK, CA, prof, a, T): + live = LIVE_PER_REPLICA * T + own = AK.moment(prof, a, live=live) + ven = CA.moment(prof, a, live=live) + need(max(own[0], ven[0]) <= min(own[1], ven[1]), 'endpoint.two_impl: enclosures disjoint at %s' % a) + return own, ven + + +def endpoint(AK, CA, prof, T, C): + """endpoint.accept / endpoint.reject in both implementations.""" + own_c, ven_c = moments(AK, CA, prof, C, T) + need(own_c[1] < 1 and ven_c[1] < 1, 'endpoint.accept: M(C) not below 1 in both enclosures') + own_n, ven_n = moments(AK, CA, prof, C + E24, T) + need(own_n[0] > 1 and ven_n[0] > 1, 'endpoint.reject: M(C + 1e-24) not above 1 in both enclosures') + return dict(C=dec24(C), M_C_minus_1=['%.4e' % float(own_c[0] - 1), '%.4e' % float(own_c[1] - 1)], + M_next_minus_1=['%.4e' % float(own_n[0] - 1), '%.4e' % float(own_n[1] - 1)], + vendored_agrees=True) + + +def run(AK, CA, recounted, claim, predecessors, bit_endpoint): + """recounted: profile from audit_owners; claim: PR3633 CLAIM.json; predecessors: {label: (T, profile, kappa)}.""" + prof = intkeys(recounted) + need(prof == intkeys(claim['profile']), 'endpoint.profile: recounted profile != CLAIM.json profile') + T = claim['replicas'] + lo, hi = (Q(x) for x in claim['root_interval']) + need(hi - lo == E24 and (lo * 10 ** 24).denominator == 1, 'endpoint.format: root_interval is not one 24-digit step') + C = lo + rec = dict(endpoint=endpoint(AK, CA, prof, T, C)) + kappa = Q(claim['kappa']) + need(kappa == C - MARGINS and Q(claim['candidate_endpoint']) == kappa, + 'endpoint.kappa: CLAIM kappa/candidate_endpoint != C - 1e-46 - 1e-70') + rec['kappa'] = str(kappa) + gains = {} + for label, (Tp, pp, kp) in sorted(predecessors.items()): + g = kappa - Q(kp) + need(g > 0, 'endpoint.gain: no gain over %s' % label) + own = AK.moment(intkeys(pp), C, live=LIVE_PER_REPLICA * Tp) + need(own[0] > 1, 'endpoint.improvement: %s profile is not rejected at PR3633 C' % label) + gains[label] = dict(replicas=Tp, kappa=str(Q(kp)), gain=str(g), gain_float='%.6e' % float(g), + predecessor_M_at_C_minus_1='%.3e' % float(own[0] - 1)) + rec['gains'] = gains + need(C < Q(bit_endpoint), 'endpoint.bit: complex endpoint is not below the recorded unchanged BIT endpoint') + rec['bit'] = dict(unchanged_bit_endpoint=bit_endpoint, source='PR3605 CLAIM.json (recorded, not re-derived)', + complex_binds=True) + return rec + + +def controls(AK, CA, AL, recounted, claim, predecessors, bit_endpoint): + out = [] + E = lambda name, rule, fn: AL.expect(out, name, rule, fn) + + def claim_with(**kw): + c = dict(claim) + c.update(kw) + return c + lo = Q(claim['root_interval'][0]) + up = lo + E24 + E('claimed_endpoint_one_step_high', 'endpoint.accept', + lambda: run(AK, CA, recounted, claim_with(root_interval=[str(up), str(up + E24)], + kappa=str(up - MARGINS), candidate_endpoint=str(up - MARGINS)), + predecessors, bit_endpoint)) + down = lo - E24 + E('claimed_endpoint_one_step_low', 'endpoint.reject', + lambda: run(AK, CA, recounted, claim_with(root_interval=[str(down), str(lo)], + kappa=str(down - MARGINS), candidate_endpoint=str(down - MARGINS)), + predecessors, bit_endpoint)) + E('kappa_without_second_margin', 'endpoint.kappa', + lambda: run(AK, CA, recounted, claim_with(kappa=str(lo - Q(1, 10 ** 46))), predecessors, bit_endpoint)) + E('kappa_with_doubled_second_margin', 'endpoint.kappa', + lambda: run(AK, CA, recounted, claim_with(kappa=str(lo - Q(1, 10 ** 46) - Q(2, 10 ** 70)), + candidate_endpoint=str(lo - Q(1, 10 ** 46) - Q(2, 10 ** 70))), + predecessors, bit_endpoint)) + bad = dict(intkeys(recounted)) + bad[48] -= 1 + E('recount_one_idle_48_short', 'endpoint.profile', + lambda: run(AK, CA, bad, claim, predecessors, bit_endpoint)) + # A predecessor whose profile were one unpaid rank-48 child better per call-normalised replica would still lose; + # the real control: a hypothetical predecessor at PR3633's own profile is NOT an improvement. + same = dict(predecessors, hypothetical=(claim['replicas'], claim['profile'], str(Q(claim['kappa']) - Q(1, 10 ** 80)))) + E('predecessor_equal_to_candidate', 'endpoint.improvement', + lambda: run(AK, CA, recounted, claim, same, bit_endpoint)) + T26, P26, _ = predecessors['PR3626'] + above = dict(predecessors, PR3626=(T26, P26, str(Q(claim['kappa']) + Q(1, 10 ** 30)))) + E('predecessor_kappa_above_candidate', 'endpoint.gain', + lambda: run(AK, CA, recounted, claim, above, bit_endpoint)) + class DisjointEngine(object): + @staticmethod + def moment(prof, a, m=73, live=1): + lo, hi = CA.moment(prof, a, m=m, live=live) + return lo + 1, hi + 1 + E('second_enclosure_disjoint', 'endpoint.two_impl', + lambda: run(AK, DisjointEngine, recounted, claim, predecessors, bit_endpoint)) + E('bit_endpoint_below_complex', 'endpoint.bit', + lambda: run(AK, CA, recounted, claim, predecessors, '0.001730000000000000000000')) + return out + + +# --------------------------------------------------------------------------------------------------------------- +# Downstream: PR #3653 (rohanarun, head 607a09ff) composes roger-sato's PR #3642 retimed supplier words with +# PR3633's literal T488 allocation. If its words keep the staged helper widths, PR3633's journal (audited in scope B) hosts +# them unchanged, the idle part of the invoice is unchanged, and the complete profile is PR3633's + 4392 (L' - L). +# The fixed-inventory LP of scope A depends on the local bill only through the constant 9L: its optimal basis and dual +# are unchanged, but dual feasibility must be re-certified at the retimed endpoint (retimed_dual_certificate). + +def endpoint_of(AK, prof, T, lo_guess, span=Q(1, 10 ** 5)): + """The 24-digit endpoint of prof by bisection on the 24-digit grid (own enclosure, live 896 T).""" + live = LIVE_PER_REPLICA * T + lo = (lo_guess * 10 ** 24).__floor__() + hi = ((lo_guess + span) * 10 ** 24).__floor__() + need(AK.moment(prof, Q(lo, 10 ** 24), live=live)[1] < 1 and AK.moment(prof, Q(hi, 10 ** 24), live=live)[0] > 1, + 'downstream.bracket: initial bracket does not straddle 1') + while hi - lo > 1: + mid = (lo + hi) // 2 + e = AK.moment(prof, Q(mid, 10 ** 24), live=live) + if e[1] < 1: + lo = mid + elif e[0] > 1: + hi = mid + else: + raise AssertionError('grid point straddles 1') + return Q(lo, 10 ** 24) + + +def retimed_dual_certificate(CEIL, basis, a0, a1): + """downstream.dual: PR3633's optimal basis (scope A) stays dual feasible uniformly on [a0, a1]. The column costs + (idle children) do not involve the local bill, so the same dual applies to the retimed supplier; this is checked + at the retimed endpoint, not inferred from the certificate at PR3633's exponent.""" + model = CEIL.MODEL + y = CEIL.symbolic_dual(model, basis) + tight = positive = 0 + for cap, q in CEIL.enumerate_patterns(model['widths'], model['caps']): + rc = dict((r, c) for r, c in CEIL.reduced_cost(model, cap, q, y).items() if c) + if not rc: + tight += 1 + continue + need(CEIL.lower_uniform(rc, a0, a1) > 0, + 'downstream.dual: reduced cost of (%d, %s) not certified positive on [%s, %s]' % (cap, list(q), a0, a1)) + positive += 1 + return dict(tight=tight, strictly_positive_uniform=positive, interval=[dec24(a0), dec24(a1)]) + + +def downstream_3653(AK, CA, AL, CW, words, staged_widths, staged_local, audited_profile, lp_per_replica, outer_claim, + CEIL=None, basis=None): + T, calls = 488, 4392 + locs = [] + for tag, pid in (('base', 'gauge44'), ('extra', 'extra')): + fr = CW.frame_recount(AL.parse_word(words[tag])) + need(list(fr['helper_widths']) == list(staged_widths[pid]), + 'downstream.widths: PR3653 %s word changes helper widths' % tag) + locs.append(dict((int(k), v) for k, v in fr['paid'].items())) + need(locs[0] == locs[1], 'downstream.local: the two retimed words have different local bills') + L1, L0 = locs[0], dict((int(k), v) for k, v in staged_local.items()) + prof = dict((int(k), v) for k, v in audited_profile.items()) + for r in set(L0) | set(L1): + prof[r] = prof.get(r, 0) + calls * (L1.get(r, 0) - L0.get(r, 0)) + prof = dict((r, n) for r, n in sorted(prof.items()) if n) + lp = dict((int(k), v) for k, v in lp_per_replica.items()) + lp1 = dict(lp) + for r in set(L0) | set(L1): + lp1[r] = lp1.get(r, 0) + 9 * (L1.get(r, 0) - L0.get(r, 0)) + need(dict((r, n) for r, n in prof.items()) == dict((r, v * T) for r, v in sorted(lp1.items()) if v), + 'downstream.ceiling: PR3653 profile is not 488 x the LP minimum with the retimed local bill') + C = endpoint_of(AK, prof, T, Q('0.00173')) + end = endpoint(AK, CA, prof, T, C) + cert = retimed_dual_certificate(CEIL, basis, C, C + E24) + kappa = Q(outer_claim['kappa_rational']) + need(kappa == C - MARGINS, 'downstream.kappa: PR3653 kappa %s != own endpoint %s - 1e-46 - 1e-70' + % (outer_claim['kappa'], C)) + return dict(retimed_local_bill=dict(sorted(L1.items())), delta_per_call=dict( + sorted((r, L1.get(r, 0) - L0.get(r, 0)) for r in set(L0) | set(L1) if L1.get(r, 0) != L0.get(r, 0))), + profile=prof, endpoint=end, kappa=str(kappa), widths_equal_staged=True, + profile_equals_488_retimed_lp_minimum=True, dual_certificate_at_retimed_endpoint=cert) + + +def downstream_controls(AK, CA, AL, CW, words, staged_widths, staged_local, audited_profile, lp_per_replica, + outer_claim, CEIL=None, basis=None): + out = [] + E = lambda name, rule, fn: AL.expect(out, name, rule, fn) + run = lambda **kw: downstream_3653(AK, CA, AL, CW, kw.get('words', words), kw.get('sw', staged_widths), + staged_local, kw.get('prof', audited_profile), kw.get('lp', lp_per_replica), + kw.get('oc', outer_claim), CEIL, kw.get('basis', basis)) + # A feasible but suboptimal basis: swap the empty capacity-48 pattern for a non-tight one; its dual is not + # feasible at the retimed endpoint. + alt = list(basis) + k = next(i for i, (cap, q) in enumerate(alt) if cap == 48 and not any(q)) + alt[k] = (48, (0, 0, 0, 0, 6, 0)) + E('downstream_dual_of_other_basis', 'downstream.dual', lambda: run(basis=alt)) + sw = dict((pid, list(ws)) for pid, ws in staged_widths.items()) + sw['gauge44'][389] = 8 + E('downstream_staged_width_389_reverted', 'downstream.widths', lambda: run(sw=sw)) + lp = dict(lp_per_replica) + lp[48] = lp[48] - Q(1, 4) + E('downstream_lp_minimum_one_quarter_idle48_short', 'downstream.ceiling', lambda: run(lp=lp)) + oc = dict(outer_claim) + oc['kappa_rational'] = str(Q(outer_claim['kappa_rational']) + E24) + E('downstream_kappa_one_step_high', 'downstream.kappa', lambda: run(oc=oc)) + return out diff --git a/research/t488-independent-audit/audit_inherited_controls.py b/research/t488-independent-audit/audit_inherited_controls.py new file mode 100644 index 0000000000..61f0c3b2f6 --- /dev/null +++ b/research/t488-independent-audit/audit_inherited_controls.py @@ -0,0 +1,938 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Scope C2: the five reject(name, test) controls of PR3633's owners/independent_literal.py (kept from PR3605's +adapted owner audit) cannot detect a disabled or weakened gate; the same holds in every located copy. + +Static analysis only (ast); no code of PR3605, PR3624, PR3626, PR3630, PR3633, PR3638, PR3642 or PR3653 is imported +or executed. The file +defines `need(v, m)` (raise iff not v) and `reject(name, test)`, which runs `need(not test(), ...)`: a control +"passes" iff its lambda returns a falsy value. analyse(source, ctx) is the main check (positive run and every +negative control): + controls.pin sha256 of the source is the pinned value + controls.need_def need's body is exactly `if not v: raise ...` (no other effect) + controls.reject_def reject's body is exactly `need(not test(), msg); controls.append(name)` + controls.bindings need and reject are bound exactly once in the module, by those defs (no later rebinding) + controls.gate_purity no gate (a need(...) call outside a function) binds or mutates anything by name (lambda + bodies included): no assignment expression, mutating method, x.at(...), out=, or in-place + numpy function (copyto, put, place, putmask, ...); a module function called by a gate declares + no global/nonlocal and mutates only its own local names (never a parameter or module name) + controls.inventory the reject() calls are exactly the five inherited names, each with a lambda + controls.tautology every lambda (i) calls no module function and no need/reject, only pure builtins/numpy + constructors (so its value is the same whether or not any gate exists), and (ii) matches a + proof pattern showing it is False on every input that reaches it: + irreflexive `a < a ...` (or >), identical side-effect-free operands on numbers: no value + duplicate_set `len({int(e), int(e)}) == 2`: a one-element set, for every input + shifted_column `array_equal(r_[X[0,k], X[:u,k]], tile(arange(M), N))`, M >= 2, X a matrix, + no step: entries 0 and 1 of the first array are both X[0,k], of the second 0 + and 1 (or the lengths differ); for every X, u and N + gate_offset `int(A[I[0]]) + d == int(B[0])`, d != 0, after an unconditional earlier gate + `need(array_equal(A[I], B))`, I last bound by np.lexsort/np.argsort (an integer + index array, so A[I][0] == A[I[0]]) + gate_bump `dict(H) == bad` with `bad = dict(P); bad[k] += d` (d != 0) after an + unconditional earlier gate asserting `dict(H) == P` (a conjunct of an `and`) + For the two gate patterns, every statement strictly between the premise gate and the control, + other than reject() calls and the `bad` pair, references none of the premise names, calls no + module function except need, and mutates only objects built fresh inside the region (region + rule). + Verdicts when no proof is accepted (all raise controls.tautology): 'genuine' = the lambda calls + a gate's module function on arguments that differ syntactically from every gate call of it + (it feeds changed data to the gate predicate); 'gate-coupled' = it calls need/reject or a + module function, but only as the gates do (not certified either way); 'unproven' = no pattern. + controls.pattern each control is proved by the pattern expected for its name + controls.data_* (PR3633 file, when journal rows are given) the premises the proofs rely on, evaluated in pure + Python on the actual T488 values: data_pin (rows bound to PR3633 EXPECTED.json payload_sha256 + 20662cc6... by compact re-serialisation; ORDER/DISPATCH rebuilt from the pinned base + chronologies and bound to EXPECTED literal_files; PROVIDERS.json and the profile from PR3633's + head; TEMPLATE/PLAN from main), data_rows, data_identity (rows are the ordered helper + identities), data_window (row 0's time is inside its own source window), data_prefix (the + first bin's offsets are prefix sums of the provider widths), data_mass (the profile mass is + 65088 x 488). The predicate values are reported but carry no data content: three are + data-independent by their pattern, and the hole and rank1 values are reduced forms fixed by + the premises (H itself is not recomputed here; that is the literal-owner audit's scope). +Fairness: the gates themselves are real checks evaluated on the real data; this is a control-coverage defect (the five +controls never feed changed data to any gate, so they would also pass with that gate deleted), not evidence that the +owner journal is wrong. The copies of the same controls in PR3605/PR3624/PR3626/PR3630/PR3633 are located (every +.py blob of main and the eight PR heads containing the control text), pinned and analysed structurally with the same +function; the cited original (SHA256 1001cb1c...) is searched among all those .py blobs by sha256. +Not mutation-controlled (fail-closed reads that must pass on the pinned bytes): controls.git, the input pins +(show_pinned, ORDER/DISPATCH/PROVIDERS/FILL file pins in build_t488/read_local_fill) and the located-copies set +(controls.copies). The journal-payload pin and every analyser rule have negative controls. +Model and limits: names are tracked syntactically; mutation is recognised through stores, augmented assignments, +the MUTATING method names, x.at(...), out= and INPLACE_NP. shortcut: a library call that mutates an argument outside +those lists (np.random.shuffle, setattr, ...), or mutation of a mutable element shared into a fresh container, is +not recognised; neither occurs in the located files (by inspection: their regions mutate only used, idle, H, controls +and bad), upgrade to a callee whitelist if this analyser is applied to other files. Standard library only. +""" +import ast +import gzip +import json +import os +import re +import subprocess +import sys +import time + +_HERE = os.path.dirname(os.path.abspath(__file__)) +_VENDOR = os.path.join(_HERE, 'vendor', 'pr3053') +if _VENDOR not in sys.path: + sys.path.insert(0, _VENDOR) +import audit_common as AC # noqa: E402 +import audit_lib as AL # noqa: E402 + +REPO = os.path.dirname(os.path.dirname(_HERE)) +SCRATCH_OWNERS = os.path.join(REPO, '.loop-scratch', 'iter22', 't488-owners') +MAIN = '20ecf2891d80b5acf18d980b2164fb44ea7faa90' +COMMITS = dict(PR3605='3efbb5de06a49ffeea6684482f2d3fe48cdca3fb', PR3624='515a7c4490aa32ac3ca5014feb6f7da0d6952863', + PR3626='659fd5e7064d9466b668d7188cbb013b333a415a', PR3630='bcac7fe04b9b7f7f5d3c27d620561f96c4ae5608', + PR3633='72c268f113368ea0387d188225e3f81ba6d6ef73', PR3638='d62e1acd7518a231440383f0d0dddf54d6edf8c1', + PR3642='044d24f12e74f228dd462c07ae2d7f3ea35e2be9', PR3653='607a09ff441c79b215a8127a81f4cc70021d0d9b') +ORIGINAL_SHA256 = '1001cb1c8b4ee1f93c23b58b094565ec1b3931eee0ea091a23504696e380be9e' +P605 = ('5d1a7b4fd635070522e78656ccedf9bcf4bf13db', 'da897bd5cef36943b3f5b1422fe81716b4eaa6230b056d31f8c2310cf62f8580') +# label -> (pr, path, git blob, sha256) +TARGET = ('PR3633', 'research/staged-width-t488/owners/independent_literal.py', + 'e2a226950ed30e88f6c386669716b9a463dd873d', '8517c0d6c7cbe73438885135ac7fd9781dd5120113c9721002346dca603f5ed9') +COPIES = { + 'PR3605': ('PR3605', 'research/staged-644-660-conditional-release/owners/independent_literal.py') + P605, + 'PR3624': ('PR3624', 'research/staged-width-t450/owners/independent_literal.py', + 'd9c2450e03d9dcde39ae96f0edc835d1a67d9fe5', '68684584d3866b2ab76c254dd6d5be3a49d276a6e5f6353183dee4d8d84de4d4'), + 'PR3624-provenance': ('PR3624', 'research/staged-width-t450/provenance/pr3605/owners/independent_literal.py') + P605, + 'PR3626': ('PR3626', 'research/staged-width-t530/owners/independent_literal.py', + '32755776c15660b939c92cb8835c71ec87c8c1d6', '36d7f4e3a611fd6b5983222887beb9a37a18bfac0d999ac5c00e3e191d1c5cc4'), + 'PR3626-provenance': ('PR3626', 'research/staged-width-t530/provenance/pr3605/owners/independent_literal.py') + P605, + 'PR3630': ('PR3630', 'research/staged-644-660-owner-successor/independent_owners.py', + 'f116cc0142b4f6d674abf6e4c844142c00fb0297', '8d02dff267938cdb373aa617a411d8e67700e130609d2714e98ccf814e32eaef'), + 'PR3633': TARGET, + 'PR3633-provenance': ('PR3633', 'research/staged-width-t488/provenance/pr3605/owners/independent_literal.py') + P605, + 'PR3638': ('PR3638', 'research/three-kappa-leads/independent_literal.py', + '4028493716bfcf3e73831067599518c055fcd2b0', '89c27f61ae3e6d2bdd4c469ac5b99d4f955a443c5e04c74e568c12093510efbe'), + 'PR3642': ('PR3642', 'research/staged-release-retiming-t530/owner-audit/independent_literal.py', + '86dc50768ff3fda8e265c08aa9314fe072e0c396', 'b51c36ad1ae0999547edc4726d698df369fef60daaaac4f5bbea471648c9f628'), + 'PR3642-upstream': ('PR3642', 'research/staged-release-retiming-t530/owner-audit/upstream/independent_literal.py', + '32755776c15660b939c92cb8835c71ec87c8c1d6', + '36d7f4e3a611fd6b5983222887beb9a37a18bfac0d999ac5c00e3e191d1c5cc4'), + 'PR3642-vendor': ('PR3642', 'research/staged-release-retiming-t530/full-admission/vendor/staged-width-t530/owners/' + 'independent_literal.py', '32755776c15660b939c92cb8835c71ec87c8c1d6', + '36d7f4e3a611fd6b5983222887beb9a37a18bfac0d999ac5c00e3e191d1c5cc4'), + 'PR3653': ('PR3653', 'research/retimed-t488-composition/owners/independent_literal.py', + '403a9cd104c7e68a5bd2431bb442d701f30828f5', 'caa5eb4fff4908c0891c3ee41e7e6d71bf19bb710d1d7781164f10ce84bce769'), + 'PR3653-upstream': ('PR3653', 'research/retimed-t488-composition/owners/upstream/independent_literal.py') + TARGET[2:], + 'PR3653-vendor': ('PR3653', 'research/retimed-t488-composition/full-replay/vendor/pr3642/vendor/staged-width-t530/' + 'owners/independent_literal.py', '32755776c15660b939c92cb8835c71ec87c8c1d6', + '36d7f4e3a611fd6b5983222887beb9a37a18bfac0d999ac5c00e3e191d1c5cc4'), +} +EXPECTED_JSON = ('PR3633', 'research/staged-width-t488/owners/EXPECTED.json', '415eac1a2b0201beac2c3e531c6fcbd1133a819f', + '924493b6bbeade055af4916ac7bd6d7d7ec0600719f5c39636dc3f16d7ec14ea') +TEMPLATE = (MAIN, 'research/rank7-joint-endframes/allocation/vendor/TEMPLATE.json.gz', + '114808c32b1799da53524bdc25cea67efb60009e', '21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e') +PLAN = (MAIN, 'research/rank7-joint-endframes/allocation/vendor/PLAN.json.gz', + '7a1db55a4d53ee99280be4f3ab7d29f7b2033adf', 'd566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e') +NAMES = ('duplicate helper', 'strict lower endpoint used as available', 'same-call family reused', + 'unpaid chronological hole', 'one unpaid rank1 child') +PATTERN_OF = dict(zip(NAMES, ('shifted_column', 'irreflexive', 'duplicate_set', 'gate_offset', 'gate_bump'))) +PURE_CALLS = {'np.array_equal', 'np.tile', 'np.arange', 'bool', 'len', 'int', 'dict'} +FRESH = {'np.zeros', 'np.ones', 'np.empty', 'np.full', 'np.repeat', 'Counter', 'dict', 'list', 'set'} +INPLACE_NP = {'np.copyto', 'np.put', 'np.place', 'np.putmask', 'np.fill_diagonal', 'np.put_along_axis'} +CONTROL_TEXT = b'strict lower endpoint used as available' +MUTATING = {'append', 'extend', 'insert', 'pop', 'remove', 'clear', 'sort', 'reverse', 'update', 'setdefault', + 'popitem', 'add', 'discard', 'fill', 'resize', 'put', 'itemset', 'partition', 'write_text', 'write_bytes'} +COLUMNS = ['time', 'helper', 'owner_replica', 'child', 'port', 'offset'] +# PR3633 owners/ base chronology files (name, git blob, sha256) +BASE_ORDERS = (('ORDER37.json', '411004ab280d6468bdd9c98c01f153baed66c543', + '94803d190b2b0506d9645e980b57cdbc3e98221f3b615292df8a94f1b174c984'), + ('T8-ORDER.json', 'b013bdb989f7fde1b8a22ae8ed743eae3a0a62fd', + 'a1abf78fb3b88bbf4656e6ae26f148a007f744f0be4c00d480fb2424ce8766d6'), + ('T16-ORDER.json', '470b8afb8af03fd053b6ff19bc90eb410b5c9e6b', + '9b2106c84aed23a7c3c8b99e21d3e96c66b12f92980a42ab2f6dbbe7831ef7c4')) +BASE_DISPATCH = (('DISPATCH37.json', 'c4c016ea3f3cb7bd04c1812259246a9411ad7adc', + '4f78935b2ef1f6c08c9c16433d54015def1eccd767443b496a77ea8823690df6'), + ('T8-DISPATCH.json', 'f95b6f07bf4d9e607a7ab8fcc101cdc63a725b07', + '23877abbe8ec258eb1f2425137f9171d37b1a4414a25595abe75eb0738850a24'), + ('T16-DISPATCH.json', '40725d2abb328ba7fee1c4f74656eecd982f2f7e', + '282960b7163bc305675b64d1d0faee9f71b18848748326418a013626944c6488')) +PROVIDERS_PIN = ('f321d4185339244b8b004326af70e653e611d84a', + 'd96f2798024ab83edbb8848b62c425992aec182f1f24ef46bb8286dd390618c2') + + +# ------------------------------------------------------------------------------------------------- inputs --- +def git(*args, **kw): + p = subprocess.run(['git', '-C', REPO] + list(args), stdout=subprocess.PIPE, stderr=subprocess.PIPE, + env=AC.git_env(), **kw) + AC.need(p.returncode == 0, 'controls.git: git %s failed: %s' % (' '.join(args)[:120], p.stderr.decode()[:200])) + return p.stdout + + +def show_pinned(commit, path, blob, sha): + data = git('show', '%s:%s' % (commit, path)) + AC.need(AC.git_blob_id(data) == blob and AC.sha256(data) == sha, 'controls.pin: %s:%s is not blob %s / sha256 %s' + % (commit[:12], path, blob[:12], sha[:12])) + return data + + +def spec_bytes(spec): + pr, path, blob, sha = spec + return show_pinned(COMMITS[pr], path, blob, sha) + + +def scan_trees(): + """Every .py blob in the trees of main and the eight PR heads (git ls-tree -r, read back with git cat-file --batch and + re-hashed): the ones containing the control text, with blob id and sha256, must equal the pinned COPIES table; + also returns the blobs whose sha256 is the cited original's and the number of .py blobs scanned.""" + blobs = {} + for label, commit in [('main', MAIN)] + sorted(COMMITS.items()): + for ent in git('ls-tree', '-r', '-z', commit).split(b'\0'): + if ent: + meta, path = ent.split(b'\t', 1) + _, typ, oid = meta.split() + if typ == b'blob' and path.endswith(b'.py'): + blobs.setdefault(oid.decode(), []).append((label, commit, path.decode('utf-8'))) + data = git('cat-file', '--batch', input=('\n'.join(blobs) + '\n').encode()) + found, original, i = {}, [], 0 + for oid, where in blobs.items(): + nl = data.index(b'\n', i) + hdr = data[i:nl].split() + n = int(hdr[2]) + body = data[nl + 1:nl + 1 + n] + i = nl + 2 + n + AC.need(hdr[0].decode() == oid and AC.git_blob_id(body) == oid, 'controls.git: cat-file returned %r for %s' + % (hdr[:2], oid)) + sha = AC.sha256(body) + if sha == ORIGINAL_SHA256: + original += ['%s:%s' % (label, path) for label, _, path in where] + if CONTROL_TEXT in body: + for label, commit, path in where: + found['%s:%s' % (label, path)] = dict(commit=commit, git_blob=oid, sha256=sha) + AC.need(i == len(data), 'controls.git: trailing cat-file output') + want = dict(('%s:%s' % (pr, path), (blob, sha)) for pr, path, blob, sha in COPIES.values()) + got = dict((k, (v['git_blob'], v['sha256'])) for k, v in found.items()) + AC.need(got == want, 'controls.copies: located copies %r != pinned %r' % (sorted(got), sorted(want))) + return found, original, len(blobs) + + +# ------------------------------------------------------------------------------------------- ast helpers --- +def dump(node): + return ast.dump(node, annotate_fields=False) + + +def callee(call): + return dotted(call.func) + + +def dotted(f): + parts = [] + while isinstance(f, ast.Attribute): + parts.append(f.attr) + f = f.value + if isinstance(f, ast.Name): + return '.'.join([f.id] + parts[::-1]) + return None + + +def is_call(node, name, nargs=None): + return isinstance(node, ast.Call) and callee(node) == name and not node.keywords and \ + (nargs is None or len(node.args) == nargs) + + +def is_const(node, pred=lambda v: True): + return isinstance(node, ast.Constant) and not isinstance(node.value, bool) and pred(node.value) + + +def int_value(node): + """The int of a literal like 5 or -1 (parsed as USub(5)), else None.""" + if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.USub) and is_const(node.operand, lambda v: isinstance(v, int)): + return -node.operand.value + return node.value if is_const(node, lambda v: isinstance(v, int)) else None + + +def side_effect_free(node): + """Names, constants, subscripts, slices, tuples and arithmetic/unary operators only (no call, no walrus).""" + ok = (ast.Name, ast.Constant, ast.Subscript, ast.Slice, ast.Tuple, ast.Load, ast.UnaryOp, ast.USub, ast.BinOp, + ast.Add, ast.Sub, ast.Mult) + return all(isinstance(n, ok) for n in ast.walk(node)) + + +def names_in(node): + return set(n.id for n in ast.walk(node) if isinstance(n, ast.Name)) + + +def bound_names(node): + """Names (re)bound, or whose object is mutated, by a statement or expression (names are syntactic, see the module + docstring): targets of assignments, augmented assignments (in place for numpy), for loops, walrus, with, del + (a Subscript/Attribute target counts its base names), receivers of MUTATING methods, the first argument of x.at(...) + and of the in-place numpy functions INPLACE_NP, and out= arguments.""" + out = set() + for n in ast.walk(node): + targets = [] + if isinstance(n, (ast.Assign, ast.Delete)): + targets = n.targets + elif isinstance(n, (ast.AugAssign, ast.AnnAssign, ast.For, ast.NamedExpr)): + targets = [n.target] + elif isinstance(n, ast.withitem) and n.optional_vars is not None: + targets = [n.optional_vars] + for t in targets: + out |= names_in(t) + if isinstance(n, ast.Call): + if isinstance(n.func, ast.Attribute) and n.func.attr in MUTATING: + out |= names_in(n.func.value) + if n.args and ((isinstance(n.func, ast.Attribute) and n.func.attr == 'at') or callee(n) in INPLACE_NP): + out |= names_in(n.args[0]) + for kw in n.keywords: + if kw.arg == 'out': + out |= names_in(kw.value) + return out + + +def binding_sites(tree, name): + """Every node of the module that binds `name`: def/class, a Name store/del, an import alias, global/nonlocal.""" + out = [] + for n in ast.walk(tree): + if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)) and n.name == name: + out.append(n) + elif isinstance(n, ast.Name) and n.id == name and not isinstance(n.ctx, ast.Load): + out.append(n) + elif isinstance(n, ast.alias) and (n.asname or n.name.split('.')[0]) == name: + out.append(n) + elif isinstance(n, (ast.Global, ast.Nonlocal)) and name in n.names: + out.append(n) + return out + + +def need_calls(stmt): + """need(...) calls in a module statement (functions and lambdas excluded).""" + out = [] + + def walk(n): + if isinstance(n, (ast.FunctionDef, ast.Lambda)): + return + if is_call(n, 'need'): + out.append(n) + for ch in ast.iter_child_nodes(n): + walk(ch) + walk(stmt) + return out + + +# --------------------------------------------------------------------------------------- the main check --- +def check_defs(tree): + funcs = dict((n.name, n) for n in tree.body if isinstance(n, ast.FunctionDef)) + nd = funcs.get('need') + AC.need(nd is not None and [a.arg for a in nd.args.args] == ['v', 'm'] and len(nd.body) == 1 + and isinstance(nd.body[0], ast.If) and not nd.body[0].orelse and len(nd.body[0].body) == 1 + and isinstance(nd.body[0].body[0], ast.Raise) + and dump(nd.body[0].test) == dump(ast.UnaryOp(ast.Not(), ast.Name('v', ast.Load()))), + 'controls.need_def: need is not exactly "if not v: raise"') + rj = funcs.get('reject') + ok = rj is not None and [a.arg for a in rj.args.args] == ['name', 'test'] and len(rj.body) == 2 + if ok: + s1, s2 = rj.body + ok = isinstance(s1, ast.Expr) and is_call(s1.value, 'need', 2) and \ + dump(s1.value.args[0]) == dump(ast.UnaryOp(ast.Not(), ast.Call(ast.Name('test', ast.Load()), [], []))) and \ + isinstance(s2, ast.Expr) and is_call(s2.value, 'controls.append', 1) and \ + dump(s2.value.args[0]) == dump(ast.Name('name', ast.Load())) + AC.need(ok, 'controls.reject_def: reject is not exactly "need(not test(), msg); controls.append(name)"') + for f in ('need', 'reject'): + sites = binding_sites(tree, f) + AC.need(sites == [funcs[f]], 'controls.bindings: %s is bound %d times (lines %r), not only by its def' + % (f, len(sites), [getattr(x, 'lineno', None) for x in sites])) + return funcs + + +def gates_of(tree): + """[(statement index, unconditional?, need call, message text)] for every module-level gate.""" + out = [] + for i, st in enumerate(tree.body): + for call in need_calls(st): + msg = call.args[1] if len(call.args) > 1 else None + text = msg.value if is_const(msg) else (ast.unparse(msg) if msg is not None else '') + out.append((i, isinstance(st, ast.Expr) and st.value is call, call, text)) + return out + + +def gate_purity(gates, funcs): + called = set() + for i, _, call, text in gates: + called |= set(callee(n) for n in ast.walk(call) if isinstance(n, ast.Call)) & set(funcs) + AC.need(not bound_names(call), 'controls.gate_purity: gate %r binds or mutates %r' % (text, sorted(bound_names(call)))) + for f in sorted(called - {'need'}): + fn = funcs[f] + params = set(a.arg for a in fn.args.args) + local = set(n.id for n in ast.walk(fn) if isinstance(n, ast.Name) and isinstance(n.ctx, ast.Store)) - params + AC.need(not any(isinstance(n, (ast.Global, ast.Nonlocal)) for n in ast.walk(fn)) + and bound_names(fn) <= local, + 'controls.gate_purity: gate function %s declares global/nonlocal or mutates a parameter or a module-level ' + 'name (%r)' + % (f, sorted(bound_names(fn) - local))) + + +def find_controls(tree): + out = [] + for i, st in enumerate(tree.body): + if isinstance(st, ast.Expr) and is_call(st.value, 'reject'): + c = st.value + AC.need(len(c.args) == 2 and is_const(c.args[0], lambda v: isinstance(v, str)) + and isinstance(c.args[1], ast.Lambda) and not c.args[1].args.args, + 'controls.inventory: reject call at statement %d is not reject("name", lambda: ...)' % i) + out.append((i, c.args[0].value, c.args[1])) + else: + AC.need(not any(is_call(n, 'reject') for n in ast.walk(st)), 'controls.inventory: nested reject call') + AC.need(tuple(n for _, n, _ in out) == NAMES, 'controls.inventory: %r != %r' % ([n for _, n, _ in out], NAMES)) + return out + + +class Unproven(Exception): + pass + + +def region_clear(tree, funcs, lo, hi, names, allowed=()): + """Region rule: every statement strictly between lo and hi, other than reject() calls and `allowed`, references + none of `names`, calls no module function except need, and mutates (bound_names other than a plain `name = ...`) + only names bound earlier in the region to a fresh object (a FRESH constructor call or a list/dict/set display), so + a view or alias of a premise object bound before the gate cannot be mutated by name.""" + fresh = set() + for j in range(lo + 1, hi): + st = tree.body[j] + if j in allowed or (isinstance(st, ast.Expr) and is_call(st.value, 'reject')): + continue + hit = names_in(st) & set(names) + if hit: + raise Unproven('statement %d between the premise gate and the control references %r' % (j, sorted(hit))) + calls = set(callee(n) for n in ast.walk(st) if isinstance(n, ast.Call)) & (set(funcs) - {'need'}) + if calls: + raise Unproven('statement %d between the premise gate and the control calls module function(s) %r' + % (j, sorted(calls))) + plain = isinstance(st, ast.Assign) and all(isinstance(t, ast.Name) for t in st.targets) + mutated = bound_names(st) - (set(t.id for t in st.targets) if plain else set()) + if mutated - fresh: + raise Unproven('statement %d between the premise gate and the control mutates %r, not built fresh in the ' + 'region' % (j, sorted(mutated - fresh))) + if plain: + new = isinstance(st.value, (ast.List, ast.Dict, ast.Set)) or (isinstance(st.value, ast.Call) + and callee(st.value) in FRESH) + for t in st.targets: + (fresh.add if new else fresh.discard)(t.id) + + +def premise_gate(tree, gates, at, test): + """The latest unconditional gate before statement `at` whose test satisfies test(expr).""" + for i, uncond, call, text in reversed(gates): + if i < at and uncond and test(call.args[0]): + return i, text + raise Unproven('no unconditional earlier gate supplies the premise') + + +def prove(tree, funcs, gates, at, body): + """(pattern, premise gate message or None, data-independent?, argument) or raise Unproven.""" + e = body.args[0] if is_call(body, 'bool', 1) else body + # irreflexive + if isinstance(e, ast.Compare) and isinstance(e.ops[0], (ast.Lt, ast.Gt)) and dump(e.left) == dump(e.comparators[0]) \ + and side_effect_free(e.left): + return ('irreflexive', None, True, 'first conjunct is %s %s itself: false for every value' + % (ast.unparse(e.left), '<' if isinstance(e.ops[0], ast.Lt) else '>')) + if isinstance(e, ast.Compare) and len(e.ops) == 1 and isinstance(e.ops[0], ast.Eq): + L, R = e.left, e.comparators[0] + # duplicate_set + if is_call(L, 'len', 1) and isinstance(L.args[0], ast.Set) and len(L.args[0].elts) == 2 \ + and is_const(R, lambda v: v == 2): + a, b = L.args[0].elts + if dump(a) == dump(b) and is_call(a, 'int', 1) and side_effect_free(a.args[0]): + return ('duplicate_set', None, True, '{%s, same} has one element for every input, so len != 2' + % ast.unparse(a)) + if is_call(e, 'np.array_equal', 2): + A, B = e.args + if isinstance(A, ast.Subscript) and dotted(A.value) == 'np.r_' \ + and isinstance(A.slice, ast.Tuple) and len(A.slice.elts) == 2 and is_call(B, 'np.tile', 2) \ + and is_call(B.args[0], 'np.arange', 1) and is_const(B.args[0].args[0], lambda v: isinstance(v, int) and v >= 2): + first, rest = A.slice.elts + # the slice's upper bound is free: X[:u,k] starts with X[0,k] for every u (or is empty, lengths differ) + if isinstance(first, ast.Subscript) and isinstance(rest, ast.Subscript) and dump(first.value) == dump(rest.value) \ + and isinstance(first.slice, ast.Tuple) and isinstance(rest.slice, ast.Tuple) \ + and len(first.slice.elts) == len(rest.slice.elts) == 2 and is_const(first.slice.elts[0], lambda v: v == 0) \ + and isinstance(rest.slice.elts[0], ast.Slice) and rest.slice.elts[0].lower is None \ + and rest.slice.elts[0].step is None and dump(first.slice.elts[1]) == dump(rest.slice.elts[1]) \ + and side_effect_free(A.slice): + return ('shifted_column', None, True, 'entries 0 and 1 of the first array are both %s, of tile(arange(%d))' + ' are 0 and 1: never equal' % (ast.unparse(first), B.args[0].args[0].value)) + if isinstance(e, ast.Compare) and len(e.ops) == 1 and isinstance(e.ops[0], ast.Eq): + L, R = e.left, e.comparators[0] + # gate_offset: int(A[I[0]]) + d == int(B[0]) + if isinstance(L, ast.BinOp) and isinstance(L.op, ast.Add) and is_const(L.right, lambda v: isinstance(v, int) and v)\ + and is_call(L.left, 'int', 1) and is_call(R, 'int', 1): + x, y = L.left.args[0], R.args[0] + if isinstance(x, ast.Subscript) and isinstance(x.slice, ast.Subscript) and is_const(x.slice.slice, lambda v: v == 0) \ + and isinstance(y, ast.Subscript) and is_const(y.slice, lambda v: v == 0) \ + and side_effect_free(ast.Tuple([x, y], ast.Load())): + Ad, Id, Bd = dump(x.value), dump(x.slice.value), dump(y.value) + + def gate_test(t): + return is_call(t, 'np.array_equal', 2) and isinstance(t.args[0], ast.Subscript) \ + and dump(t.args[0].value) == Ad and dump(t.args[0].slice) == Id and dump(t.args[1]) == Bd + gi, text = premise_gate(tree, gates, at, gate_test) + I = x.slice.value + last = [st for st in tree.body[:gi] if isinstance(I, ast.Name) and I.id in bound_names(st)][-1:] + if not (last and isinstance(last[0], ast.Assign) and len(last[0].targets) == 1 + and dump(last[0].targets[0]) == dump(ast.Name(I.id, ast.Store())) + and isinstance(last[0].value, ast.Call) and callee(last[0].value) in ('np.lexsort', 'np.argsort')): + raise Unproven('index %s is not last bound by np.lexsort/np.argsort before the gate' % ast.unparse(I)) + region_clear(tree, funcs, gi, at, names_in(x) | names_in(y)) + return ('gate_offset', text, False, 'gate gives %s == %s, so the predicate is v + %d == v' + % (ast.unparse(x), ast.unparse(y), L.right.value)) + # gate_bump: dict(H) == bad, bad = dict(P); bad[k] += d + if is_call(L, 'dict', 1) and isinstance(L.args[0], ast.Name) and isinstance(R, ast.Name): + H, bad = L.args[0].id, R.id + stmts = tree.body[:at] + asg = [j for j, s in enumerate(stmts) if bad in bound_names(s)] + if len(asg) >= 2: # a third binding of bad after asg[0] is rejected by the region rule below + s1, s2 = stmts[asg[0]], stmts[asg[1]] + if isinstance(s1, ast.Assign) and len(s1.targets) == 1 and dump(s1.targets[0]) == dump(ast.Name(bad, ast.Store())) \ + and is_call(s1.value, 'dict', 1) and isinstance(s1.value.args[0], ast.Name) \ + and isinstance(s2, ast.AugAssign) and isinstance(s2.op, ast.Add) \ + and isinstance(s2.target, ast.Subscript) and dump(s2.target.value) == dump(ast.Name(bad, ast.Load())) \ + and is_const(s2.target.slice) and is_const(s2.value, lambda v: isinstance(v, int) and v): + P = s1.value.args[0].id + want = dump(ast.Compare(ast.Call(ast.Name('dict', ast.Load()), [ast.Name(H, ast.Load())], []), + [ast.Eq()], [ast.Name(P, ast.Load())])) + + def gate_test(t): + parts = t.values if isinstance(t, ast.BoolOp) and isinstance(t.op, ast.And) else [t] + return any(dump(p) == want for p in parts) + gi, text = premise_gate(tree, gates, asg[0], gate_test) + region_clear(tree, funcs, gi, at, {H, P}, allowed=set(asg)) + region_clear(tree, funcs, asg[0], at, {bad}, allowed={asg[1]}) + return ('gate_bump', text, False, 'gate gives dict(%s) == %s and %s differs from %s at key %r' + % (H, P, bad, P, s2.target.slice.value)) + raise Unproven('no proof pattern matches') + + +def args_key(call): + return dump(ast.Tuple(list(call.args), ast.Load())) + repr([(k.arg, dump(k.value)) for k in call.keywords]) + + +def classify(tree, funcs, gates, at, name, lam): + gate_args = {} # module function (need excluded) -> argument dumps of its calls inside gates + for _, _, call, _ in gates: + for n in ast.walk(call): + if isinstance(n, ast.Call) and callee(n) in set(funcs) - {'need'}: + gate_args.setdefault(callee(n), set()).add(args_key(n)) + lam_calls = [n for n in ast.walk(lam.body) if isinstance(n, ast.Call)] + calls = sorted(set(callee(n) for n in lam_calls)) + + def fail(verdict, why): + e = AC.AuditFail('controls.tautology: control %r is %s: %s' % (name, verdict, why)) + e.verdict = verdict + raise e + changed = sorted(set(callee(n) for n in lam_calls if callee(n) in gate_args and args_key(n) not in gate_args[callee(n)])) + if changed: + fail('genuine', 'calls gate function(s) %r on arguments that differ from every gate call' % changed) + coupled = [f for f in calls if f in funcs or f in ('need', 'reject')] + if coupled: + fail('gate-coupled', 'calls module function(s) %r, only on the gates\' own arguments' % coupled) + other = [f for f in calls if f not in PURE_CALLS] + if other: + fail('unproven', 'calls %r outside the pure builtin/numpy constructors' % other) + for n in ast.walk(lam.body): + if isinstance(n, ast.NamedExpr): + fail('unproven', 'assignment expression in the lambda') + try: + pattern, premise, independent, argument = prove(tree, funcs, gates, at, lam.body) + except Unproven as u: + fail('unproven', str(u)) + return dict(name=name, source=None, pattern=pattern, premise_gate=premise, data_independent=independent, + argument=argument, calls=calls, free_names=sorted(names_in(lam.body) - {'np'}), + calls_a_gate=False, verdict='tautological') + + +def analyse(source, ctx): + """The main check: pin, defs, gate purity, inventory, one tautology proof per control, optional T488 data.""" + AC.need(AC.sha256(source) == ctx['sha256'], 'controls.pin: source sha256 %s' % AC.sha256(source)) + text = source.decode('utf-8') + tree = ast.parse(text) + funcs = check_defs(tree) + gates = gates_of(tree) + gate_purity(gates, funcs) + ctrls = find_controls(tree) + first = ctrls[0][0] + res = [] + for at, name, lam in ctrls: + r = classify(tree, funcs, gates, at, name, lam) + AC.need(r['pattern'] == PATTERN_OF[name], 'controls.pattern: %r proved by %s, expected %s' + % (name, r['pattern'], PATTERN_OF[name])) + r['source'] = ast.get_source_segment(text, lam) + res.append(r) + pre = [g for g in gates if g[0] < first] + out = dict(sha256=AC.sha256(source), controls=res, gates_before_controls=len(pre), + unconditional_gates_before_controls=sum(1 for g in pre if g[1]), + gate_messages=sorted(set(g[3] for g in gates)), + original_sha256_claimed=(re.findall(r'Original SHA256 ([0-9a-f]{64})', text) or [None])[0]) + if ctx.get('data') is not None: + out['t488'] = evaluate(res, ctx['data']) + return out + + +# ------------------------------------------------------------------------------------ actual T488 values --- +def owners_file(name, blob, sha): + return show_pinned(COMMITS['PR3633'], 'research/staged-width-t488/owners/' + name, blob, sha) + + +def compact_sha(obj): + """sha256 of the compact JSON text plus newline (the byte format of PR3633's literal files).""" + return AC.sha256(json.dumps(obj, separators=(',', ':')).encode() + b'\n') + + +def payload_sha(rows): + return compact_sha(dict(columns=COLUMNS, dispatch_overrides=[], rows=rows)) + + +def build_t488(rows): + """T488 data for the evaluation, from git-pinned inputs only, plus the journal rows. ORDER/DISPATCH are rebuilt + as 8 copies of the 61 base replicas (ORDER37 + T8 at +37 + T16 at +45, copy cp at +61*cp) and must hash to + PR3633's EXPECTED.json literal_files pins; the rows are bound to its payload_sha256 inside evaluate().""" + exp = json.loads(spec_bytes(EXPECTED_JSON)) + base, bdisp = [], {} + for (oname, ob, osha), (dname, db, dsha), off in zip(BASE_ORDERS, BASE_DISPATCH, (0, 37, 45)): + base += [[s, r + off] for s, r in json.loads(owners_file(oname, ob, osha))] + bdisp.update(((s, r + off), q) for s, r, q in json.loads(owners_file(dname, db, dsha))) + order = [[s, r + 61 * cp] for s, r in base for cp in range(8)] + dispatch = [[s, r + 61 * cp, bdisp[(s, r)]] for s, r in base for cp in range(8)] + lit = exp['literal_files'] + AC.need(compact_sha(order) == lit['ORDER.json'], 'controls.data_pin: rebuilt ORDER != EXPECTED pin') + AC.need(compact_sha(dispatch) == lit['DISPATCH.json'], 'controls.data_pin: rebuilt DISPATCH != EXPECTED pin') + prov = owners_file('PROVIDERS.json', *PROVIDERS_PIN) + AC.need(AC.sha256(prov) == lit['PROVIDERS.json'], 'controls.data_pin: PROVIDERS.json != EXPECTED pin') + return dict(rows=rows, payload_sha256=exp['payload_sha256'], order=order, dispatch=dispatch, + providers=json.loads(prov), replicas=exp['replicas'], + profile=dict((int(k), v) for k, v in exp['profile'].items()), + template=json.loads(gzip.decompress(show_pinned(*TEMPLATE))), + plan=json.loads(gzip.decompress(show_pinned(*PLAN)))) + + +def read_local_fill(owners_dir): + """Rows of the locally regenerated FILL.json.gz (file sha256 = PR3633 EXPECTED literal_files pin).""" + raw = open(os.path.join(owners_dir, 'FILL.json.gz'), 'rb').read() + AC.need(AC.sha256(raw) == json.loads(spec_bytes(EXPECTED_JSON))['literal_files']['FILL.json.gz'], + 'controls.data_pin: FILL.json.gz sha256') + j = json.loads(gzip.decompress(raw)) + AC.need(j['columns'] == COLUMNS and j['dispatch_overrides'] == [], 'controls.data_pin: journal schema') + return j['rows'] + + +def source_window(template, clock, r, child): + """(lo, hi) of idle child `child` in replica r: hi = time of the replica's latest local sweep when the child's idle + sweep runs, lo = latest time the sweep's pair was touched (local sweep or bridge) before it, else -1.""" + pair_of_stage = dict((x['stage'], x['pair']) for x in template['recipe'] if x['kind'] == 'local') + last, now = {}, None + for ev in template['execution_schedule']: + if ev['kind'] == 'local_cover_sweep': + now = clock[(ev['stage'], r)] + last[pair_of_stage[ev['stage']]] = now + elif ev['kind'] == 'bridge': + last[ev['src']] = last[ev['dst']] = now + elif ev['kind'] == 'idle_cover_sweep' and child in ev['child_indices']: + return last.get(ev['pair'], -1), now + raise AC.AuditFail('controls.data_window: child %d has no source window' % child) + + +def first_role(rows): + """Index of the first role in (owner, child, port, time) order: the first entry of the gate's z[idx].""" + return min(range(len(rows)), key=lambda i: (rows[i][2], rows[i][3], rows[i][4], rows[i][0], i)) + + +def evaluate(res, d): + """The premises the proofs use, checked on the actual T488 values (each with its own rule id), and the predicate + values, which are fixed by each predicate's form once the premises hold (reported with their basis).""" + rows, order = d['rows'], d['order'] + AC.need(payload_sha(rows) == d['payload_sha256'], 'controls.data_pin: journal rows do not re-serialise to the ' + 'pinned FILL payload sha256') + N, M = len(order), 408 + AC.need(len(rows) == N * M, 'controls.data_rows: %d rows != %d calls x 408' % (len(rows), N)) + t0, h0, o0, c0, p0, z0 = rows[0] + prem, val = {}, {} + # duplicate helper: the gate 'complete literal ordered helper identities' (time, helper) == (i // 408, i % 408) + AC.need(all(r[0] == i // M and r[1] == i % M for i, r in enumerate(rows)), + 'controls.data_identity: helper/time columns are not the ordered identities') + prem['duplicate helper'] = 'rows are the ordered (call, helper) identities' + helper = [r[1] for r in rows] + shifted = [helper[0]] + helper[:-1] + val['duplicate helper'] = dict(value=shifted == [i % M for i in range(len(rows))], + basis='data-independent (shifted_column: entries 0 and 1 are equal)') + # strict lower endpoint: the window gate on row 0, lo < t <= hi + clock = dict(((s, r), t) for t, (s, r) in enumerate(order)) + lo, hi = source_window(d['template'], clock, o0, c0) + AC.need(lo < t0 <= hi, 'controls.data_window: row 0 time %d outside its window (%d, %d]' % (t0, lo, hi)) + prem['strict lower endpoint used as available'] = dict(lo=lo, hi=hi, t=t0, holds='lo < t <= hi') + val['strict lower endpoint used as available'] = dict(value=bool(lo < lo <= hi), basis='data-independent (lo < lo)') + # same-call family reused: the physical family of row 0 + fam = 2 * d['plan']['pairs'][str(c0)] + d['plan']['sides'][str(c0)] + f = o0 * 896 + fam * 112 + p0 + val['same-call family reused'] = dict(value=len({int(f), int(f)}) == 2, family=f, + basis='data-independent (one-element set)') + # unpaid chronological hole: the first sorted role's bin has prefix-sum offsets (the gate z[idx] == expected) + prov = dict(((s, r), p) for s, r, p in d['dispatch']) + width = lambda t, h: d['providers'][prov[tuple(order[t])]]['widths'][h] # noqa: E731 + k0 = first_role(rows) + b = rows[k0][2:5] + members = sorted((r[0], i) for i, r in enumerate(rows) if r[2:5] == b) + acc = 0 + for t, i in members: + AC.need(rows[i][5] == acc, 'controls.data_prefix: bin %r offset at time %d is %d, prefix %d' + % (b, t, rows[i][5], acc)) + acc += width(t, rows[i][1]) + prem['unpaid chronological hole'] = dict(bin=b, bin_roles=len(members), holds='offsets are prefix sums of widths') + val['unpaid chronological hole'] = dict(value=rows[k0][5] + 1 == 0, z=rows[k0][5], expected=0, + basis='reduced form: expected[0] = 0 (first role of its bin) and the ' + 'premise gives z = 0') + # one unpaid rank1 child: with the gate dict(H) == profile the predicate is profile == bad + AC.need(sum(k * v for k, v in d['profile'].items()) == 65088 * d['replicas'], + 'controls.data_mass: profile mass != 65088 x replicas (second conjunct of the same gate)') + prem['one unpaid rank1 child'] = dict(rank1=d['profile'][1], holds='profile mass = 65088 x 488; H not recomputed') + bad = dict(d['profile']) + bad[1] += 1 + val['one unpaid rank1 child'] = dict(value=d['profile'] == bad, basis='reduced form: profile == profile + {1: 1}') + return dict(premises=prem, predicate_values=val) + + +# -------------------------------------------------------------------------------------------- controls --- +def controls(source, ctx, out): + """Negative controls, all through analyse(): source edits (re-pinned, so only the named rule can reject them) and, + with T488 data, data mutants (re-pinned payload unless the pin itself is the target).""" + text = source.decode() + + def through(src, data='keep', repin=True): + b = src.encode() if isinstance(src, str) else src + c = dict(ctx, sha256=AC.sha256(b) if repin else ctx['sha256']) + if data != 'keep': + c['data'] = data + return lambda: analyse(b, c) + + def sub(old, new, base=None): + base = text if base is None else base + AC.need(base.count(old) == 1, 'controls.harness: anchor %r found %d times' % (old[:40], base.count(old))) + return base.replace(old, new) + + def taut(name, src, verdict): + AL.expect(out, name, 'controls.tautology', through(src, None), attrs=dict(verdict=verdict)) + + gate109 = "need(np.array_equal(z[idx],expected),'every chronological pending mask is a compact prefix')" + hist = "need(dict(H)==profile and sum(r*n for r,n in H.items())==65088*T,'independent complete histogram')" + hole = 'lambda: int(z[idx[0]])+1==int(expected[0])' + region = 'controls=[]\n' # first statement after the last premise gate, before every control + b = bytearray(source) + b[100] ^= 1 + AL.expect(out, 'source byte flipped, pin kept', 'controls.pin', through(bytes(b), None, repin=False)) + # verdicts other than tautological + scaffold = sub(gate109, "def prefix_ok(zz,ee):return bool(np.array_equal(zz,ee))\n" + "need(prefix_ok(z[idx],expected),'every chronological pending mask is a compact prefix')") + taut('genuine control: the hole lambda feeds a shifted journal to the gate predicate prefix_ok', + sub(hole, 'lambda: prefix_ok(np.r_[z[idx][:1]+1,z[idx][1:]],expected)', scaffold), 'genuine') + taut('gate-coupled lambda: not prefix_ok(z[idx],expected), the gate call itself (not genuine)', + sub(hole, 'lambda: not prefix_ok(z[idx],expected)', scaffold), 'gate-coupled') + # each proof-pattern condition: a satisfiable (or unsupported) edit must not be certified + lower = 'lo[o[0],c[0]]=0\n' + gate109), + 'unproven') + taut('gate_offset: index rebound by a with statement before the gate', + sub(gate109, "with open('/dev/null') as idx:pass\n" + gate109), 'unproven') + taut('region: expected=expected+1 between gate and control', sub(region, region + 'expected=expected+1\n'), + 'unproven') + taut('region: np.copyto(z,z-1) between gate and control', sub(region, region + 'np.copyto(z,z-1)\n'), 'unproven') + taut('region: alias e=expected[:]; e[0]+=1 between gate and control', + sub(region, region + 'e=expected[:];e[0]+=1\n'), 'unproven') + taut('region: rows[0,5]-=1 between gate and control (z is a view of rows; no premise name)', + sub(region, region + 'rows[0,5]-=1\n'), 'unproven') + taut('region: alias r2=rows; r2[0,5]-=1 between gate and control (alias bound in the region, not fresh)', + sub(region, region + 'r2=rows\nr2[0,5]-=1\n'), 'unproven') + taut('region: module function (mutating z, defined before the gate) called between gate and control', + sub(region, region + 'f()\n', sub(gate109, 'def f():\n z[0]=1\n' + gate109)), 'unproven') + taut('gate_bump: bad[1]+=0 (bad == profile)', sub('bad[1]+=1', 'bad[1]+=0'), 'unproven') + taut('gate_bump: bad[1]*=1 (bad == profile)', sub('bad[1]+=1', 'bad[1]*=1'), 'unproven') + taut('gate_bump: histogram gate with "or" instead of "and"', sub(hist, hist.replace(' and ', ' or ')), 'unproven') + taut('gate_bump: histogram gate without its dict(H)==profile conjunct', + sub(hist, "need(sum(r*n for r,n in H.items())==65088*T,'independent complete histogram')"), 'unproven') + taut('gate_bump: H[1]+=1 between the histogram gate and the control', sub(region, region + 'H[1]+=1\n'), + 'unproven') + taut('gate_bump: bad.__setitem__(1,bad[1]-1) inside the bad pair (bad == profile after the bump)', + sub('bad=dict(profile);bad[1]+=1;', 'bad=dict(profile);bad.__setitem__(1,bad[1]-1);bad[1]+=1;'), 'unproven') + lam_lower = 'lambda: bool(lo[o[0],c[0]] %d, whose source window excludes time %d (re-pinned)' % (c0, c1, t0), + 'controls.data_window', through(source, dict(d, rows=rows, payload_sha256=payload_sha(rows)), False)) + rows = list(d['rows']) + k0 = first_role(rows) + rows[k0] = rows[k0][:5] + [rows[k0][5] + 1] + AL.expect(out, 'T488 first-bin role offset +1, an unpaid hole (re-pinned)', 'controls.data_prefix', + through(source, dict(d, rows=rows, payload_sha256=payload_sha(rows)), False)) + prof = dict(d['profile']) + prof[1] += 1 + AL.expect(out, 'T488 profile rank-1 count +1', 'controls.data_mass', through(source, dict(d, profile=prof), False)) + + +# ------------------------------------------------------------------------------------------------ main --- +def run_integrated(I=None, owners_rows=None, with_controls=True): + """Structural analysis of PR3633's auditor and its located copies; with owners_rows (the journal rows [t, h, o, c, p, z] + in journal order) also the T488 premises, the rows bound to PR3633's payload sha256 by re-serialisation. I is + accepted for the integration interface; inputs are read with this module's own pinned git reads.""" + t0 = time.time() + copies, original_found, scanned = scan_trees() + source = spec_bytes(TARGET) + ctx = dict(sha256=TARGET[3], data=None if owners_rows is None else build_t488(owners_rows)) + target = analyse(source, ctx) + per_copy = {} + for label, spec in sorted(COPIES.items()): + r = analyse(spec_bytes(spec), dict(sha256=spec[3], data=None)) + per_copy[label] = dict(path=spec[1], commit=COMMITS[spec[0]], git_blob=spec[2], sha256=spec[3], + patterns=[c['pattern'] for c in r['controls']], + all_tautological=all(c['verdict'] == 'tautological' for c in r['controls']), + gates_before_controls=r['gates_before_controls'], + original_sha256_claimed=r['original_sha256_claimed'], + gates_only_here_vs_PR3633=sorted(set(r['gate_messages']) - set(target['gate_messages'])), + gates_missing_here_vs_PR3633=sorted(set(target['gate_messages']) - set(r['gate_messages']))) + out = [] + attempted = 0 + if with_controls: + AL.harness_selftest() + n0 = len(AC.ATTEMPTED) + controls(source, ctx, out) + attempted = len(AC.ATTEMPTED) - n0 + finding = ('All five reject() controls of PR3633 owners/independent_literal.py (and of its %d located copies) are ' + 'tautological: three are unsatisfiable for every input (irreflexive a= 0 and t == lo + 1 + initial += lo < 0 + w = wbc[t][h] + need(0 <= z and z + w <= cap[c], 'owners.capacity: row %d offset %d width %d cap %d' % (i, z, w, cap[c])) + # Pass 2: one role per physical family per call. + seen, current = set(), -1 + for row in rows: + t, h, o, c, p, z = row + if t != current: + seen, current = set(), t + f = (o * CLASSES + cls[c]) * PORTS + p + need(f not in seen, 'owners.family: call %d reuses physical family (%d, %d, %d)' % (t, o, cls[c], p)) + seen.add(f) + # Pass 3: chronological compact prefixes (rows are in time order, so bins fill chronologically). + used = {} + patterns = {} + for row in rows: + t, h, o, c, p, z = row + b = (o * CHILDREN + c) * PORTS + p + w = wbc[t][h] + u = used.get(b, 0) + need(z == u, 'owners.prefix: bin (%d, %d, %d) role at time %d has offset %d, pending prefix %d' + % (o, c, p, t, z, u)) + used[b] = u + w + patterns.setdefault(b, []).append(w) + # Pass 4: the complete invoice over every bin, including empty ones. + idle = Counter() + for o in range(T): + for c in range(CHILDREN): + for p in range(PORTS): + left = cap[c] - used.get((o * CHILDREN + c) * PORTS + p, 0) # >= 0 by passes 1 and 3 + if left: + idle[left] += 1 + H = Counter(dict((r, n * CALLS) for r, n in LOCAL.items())) + H.update(idle) + H = dict(sorted(H.items())) + need(H == dict(sorted(ctx['claimed'].items())), 'owners.histogram: recount %r != claimed %r' % (H, ctx['claimed'])) + mass = sum(r * n for r, n in H.items()) + need(mass == 65088 * T, 'owners.histogram: rank mass %d != 65088 T' % mass) + by_cap = Counter((cap[(b // PORTS) % CHILDREN], tuple(sorted(ws))) for b, ws in patterns.items()) + empty = Counter() + for o in range(T): + for c in range(CHILDREN): + for p in range(PORTS): + if (o * CHILDREN + c) * PORTS + p not in patterns: + empty[cap[c], ()] += 1 + by_cap.update(empty) + return dict(rows=len(rows), calls=CALLS, replicas=T, bins=T * CHILDREN * PORTS, used_bins=len(patterns), + idle=dict(sorted(idle.items())), profile=H, rank_mass=mass, pattern_multiset=by_cap, + active_pair_lemma_triples=ctx['active_pair_lemma_triples'], + window_boundaries=dict(roles_at_closed_upper_endpoint=at_upper, + roles_one_after_strict_lower_endpoint=after_lower, + roles_in_initially_open_windows=initial)) + + +def aggregate_patterns(candidate): + """The literal per-capacity pattern multiset implied by PR3633's aggregate (groups [cap, lo, hi, n], x rows + [group, pattern-vector over widths 4..9, count]).""" + W = (4, 5, 6, 7, 8, 9) + out = Counter() + for gi, q, n in candidate['x']: + capg = candidate['groups'][gi][0] + out[capg, tuple(w for w, k in zip(W, q) for _ in range(k))] += n + return out + + +def check_aggregate(record, candidate): + """owners.aggregate: the literal journal realises exactly the aggregate's bin patterns, capacity by capacity.""" + agg = aggregate_patterns(candidate) + lit = record['pattern_multiset'] + need(agg == lit, 'owners.aggregate: literal pattern multiset differs from the aggregate in %d entries' + % len(set(agg.items()) ^ set(lit.items()))) + return dict(distinct_capacity_patterns=len(lit), bins=sum(lit.values())) + + +def check_stock(word, template, buffers): + """owners.stock: physical = 896 T + 408 helpers + 8 centres + 91 buffers + 2 coefficient registers, each + component read from the staged word (helpers, centres, private buffers) and the template (coefficient + namespace). PR3633 reports 437,757.""" + helpers = word['report']['R'] - len(word['removed']) + centres = len(word['centers']) + lo, hi = template['private_namespace']['coefficient'] + total = CLASSES * PORTS * T + helpers + centres + buffers + (hi - lo) + need((helpers, centres, buffers, hi - lo) == (408, 8, 91, 2) and total == 437757, + 'owners.stock: physical %d from (%d, %d, %d, %d)' % (total, helpers, centres, buffers, hi - lo)) + return dict(live=CLASSES * PORTS * T, helpers=helpers, centres=centres, private_buffers=buffers, + coefficient=hi - lo, physical=total) + + +# --------------------------------------------------------------------------------------------------------------- +# Negative controls. Each mutates one object (journal row, claimed profile, input file, template), runs the SAME +# function the positive run uses (audit, make_ctx, check_order, check_dispatch, binding, check_aggregate, +# check_stock) and must be rejected with exactly the named rule id (audit_lib.expect). Journal rows are mutated in +# place and restored in a finally block. + +def _swap_row(rows, i, new): + old = rows[i] + rows[i] = new + return old + + +def _with_row(rows, i, new, fn): + old = _swap_row(rows, i, new) + try: + fn() + finally: + rows[i] = old + + +def _with_rows(rows, changes, fn): + olds = [(i, rows[i]) for i, _ in changes] + for i, new in changes: + rows[i] = new + try: + fn() + finally: + for i, old in olds: + rows[i] = old + + +def bin_index(rows, ctx): + """Per bin: chronological list of row indices (positive data only).""" + out = {} + for i, (t, h, o, c, p, z) in enumerate(rows): + out.setdefault((o, c, p), []).append(i) + return out + + +def controls(rows, ctx, inp, AL): + out = [] + cap, cls, win, wbc = ctx['cap'], ctx['cls'], ctx['win'], ctx['wbc'] + run = lambda: audit(rows, ctx) + E = lambda name, rule, fn, **kw: AL.expect(out, name, rule, fn, **kw) + t, h, o, c, p, z = rows[5] + E('row_not_six_integers', 'owners.schema', lambda: _with_row(rows, 5, [t, h, o, c, p, float(z)], run)) + E('swapped_helper_identities', 'owners.identity', + lambda: _with_rows(rows, [(5, [t, rows[6][1], o, c, p, z]), (6, [t, h] + rows[6][2:])], run)) + E('port_out_of_range', 'owners.bounds', lambda: _with_row(rows, 5, [t, h, o, c, PORTS, z], run)) + # Strict lower endpoint: re-host a role at time t on a child of the same replica that opens exactly at t. + lower = next((i, c2) for i, (t, h, o, c, p, z) in enumerate(rows) for c2 in range(CHILDREN) + if win[o][c2][0] == t) + i, c2 = lower + E('role_at_strict_lower_endpoint', 'owners.window', lambda: _with_row(rows, i, rows[i][:3] + [c2] + rows[i][4:], run), + row=i) + upper = next((i, c2) for i, (t, h, o, c, p, z) in enumerate(rows) for c2 in range(CHILDREN) + if win[o][c2][1] == t - 1 and win[o][c2][0] < t) + i2, c3 = upper + E('role_after_closed_upper_endpoint', 'owners.window', + lambda: _with_row(rows, i2, rows[i2][:3] + [c3] + rows[i2][4:], run), row=i2) + # Active local pair: put a role of call t on its own call's replica, on a child of the call's active pair (the + # per-role gate runs before the window check); and a window table whose child stays open across a same-pair stage + # (the template-level lemma, through the function make_ctx uses). + t, h, o, c, p, z = rows[11] + c_act = next(c2 for c2 in range(CHILDREN) if ctx['pair_of'][c2] == ctx['call_pair'][t]) + E('role_on_own_active_local_pair', 'owners.active_pair', + lambda: _with_row(rows, 11, [t, h, ctx['call_replica'][t], c_act, p, z], run)) + bad_win = [list(w) for w in win] + r0 = 0 + c0 = next(c2 for c2 in range(CHILDREN) if ctx['pair_of'][c2] == ctx['stage_pair'][STAGES - 1]) + bad_win[r0][c0] = (-1, ctx['clock'][STAGES - 1, r0]) + E('window_open_across_same_pair_stage', 'owners.active_pair', + lambda: check_active_pair_lemma(bad_win, ctx['clock'], ctx['stage_pair'], ctx['pair_of'])) + # Same-call family reuse: put role B of call 0 on role A's bin at A's offset, with B no wider than A. + a = 0 + b = next(j for j in range(1, HELPERS) if wbc[0][rows[j][1]] <= wbc[0][rows[a][1]]) + E('same_call_family_reused', 'owners.family', + lambda: _with_row(rows, b, rows[b][:2] + rows[a][2:5] + [rows[a][5]], run), rows=[a, b]) + t, h, o, c, p, z = rows[7] + E('offset_overflows_capacity', 'owners.capacity', + lambda: _with_row(rows, 7, [t, h, o, c, p, cap[c] - wbc[t][h] + 1], run)) + bins = bin_index(rows, ctx) + # Unpaid hole: the last role of a bin with spare capacity moves up by one. + hole = next(ix[-1] for key, ix in bins.items() + if rows[ix[-1]][5] + wbc[rows[ix[-1]][0]][rows[ix[-1]][1]] < cap[key[1]]) + E('unpaid_chronological_hole', 'owners.prefix', + lambda: _with_row(rows, hole, rows[hole][:5] + [rows[hole][5] + 1], run), row=hole) + # Offsets not in time order: in a two-role bin with different widths, the later role takes offset 0. + pair = next(ix for key, ix in bins.items() if len(ix) == 2 + and wbc[rows[ix[0]][0]][rows[ix[0]][1]] != wbc[rows[ix[1]][0]][rows[ix[1]][1]]) + w0, w1 = (wbc[rows[j][0]][rows[j][1]] for j in pair) + E('offsets_not_in_time_order', 'owners.prefix', + lambda: _with_rows(rows, [(pair[0], rows[pair[0]][:5] + [w1]), (pair[1], rows[pair[1]][:5] + [0])], run), + rows=list(pair)) + E('dropped_role', 'owners.shape', lambda: audit(rows[:-1], ctx)) + bad = dict(ctx, claimed=dict(ctx['claimed'])) + bad['claimed'][1] += 1 + E('claimed_profile_plus_one_rank1', 'owners.histogram', lambda: audit(rows, bad)) + # The pre-change PR3133 provider widths (main's PR3133-PROVIDERS.json; they differ from the staged words exactly at + # helpers 389 and 397, 7 -> 8) do not host this journal. + old = dict((pid, list(ws)) for pid, ws in inp['pr3133_widths'].items()) + need(all([j for j in range(HELPERS) if old[pid][j] != inp['widths'][pid][j]] == [389, 397] for pid in old), + 'owners.widths: PR3133 and staged widths do not differ exactly at helpers 389 and 397') + oldctx = dict(ctx, wbc=[old[pid] for pid in inp['providers_by_call']]) + E('pr3133_widths_for_helpers_389_397', inp['pr3133_width_rule'], lambda: audit(rows, oldctx)) + order = [list(x) for x in inp['order']] + order[0], order[1] = order[1], order[0] + E('order_entries_swapped', 'owners.order', lambda: check_order(order, *inp['base_orders'])) + disp = [list(x) for x in inp['dispatch']] + disp[0][2] = 'extra' if disp[0][2] == 'gauge44' else 'gauge44' + E('dispatch_provider_flipped', 'owners.dispatch', lambda: check_dispatch(disp, inp['order'], *inp['base_dispatch'])) + tm = json.loads(json.dumps(inp['template'])) + sw = next(e for e in tm['execution_schedule'] if e['kind'] == 'idle_cover_sweep' and e['from_level'] >= 0) + sw['from_level'] -= 1 + E('template_level_annotation_shifted', 'owners.windows_agree', + lambda: make_ctx(inp['order'], inp['clock'], inp['providers_by_call'], inp['widths'], tm, inp['plan'], + inp['claimed'])) + tk = json.loads(json.dumps(inp['template'])) + next(e for e in tk['execution_schedule'] if e['kind'] == 'terminal')['kind'] = 'terminal_mutated' + E('template_unknown_event_kind', 'owners.windows', + lambda: make_ctx(inp['order'], inp['clock'], inp['providers_by_call'], inp['widths'], tk, inp['plan'], + inp['claimed'])) + pl = json.loads(json.dumps(inp['plan'])) + pl['sides']['1'] = 1 - pl['sides']['1'] + E('plan_side_flipped_merges_family_classes', 'owners.windows_disjoint', + lambda: make_ctx(inp['order'], inp['clock'], inp['providers_by_call'], inp['widths'], inp['template'], pl, + inp['claimed'])) + t, h, o, c, p, z = rows[9] + E('journal_row_changed_after_pinning', 'owners.binding', + lambda: _with_row(rows, 9, [t, h, o, c, p, z + 1], lambda: binding(rows, inp['payload_sha256']))) + swapped = [list(x) for x in inp['order']] + swapped[0], swapped[1] = swapped[1], swapped[0] + E('rebuilt_order_differs_from_pinned_literal_file', 'owners.literal_files', + lambda: check_literal_files(inp['expected'], swapped, inp['dispatch'], inp['claimed'])) + bad_disp = [list(x) for x in inp['dispatch']] + bad_disp[-1][2] = 'extra' if bad_disp[-1][2] == 'gauge44' else 'gauge44' + E('rebuilt_dispatch_differs_from_pinned_literal_file', 'owners.literal_files', + lambda: check_literal_files(inp['expected'], inp['order'], bad_disp, inp['claimed'])) + cand = json.loads(json.dumps(inp['candidate'])) + cand['x'][0][2] += 1 + E('aggregate_pattern_count_changed', 'owners.aggregate', lambda: check_aggregate(inp['record'], cand)) + wd = json.loads(json.dumps(inp['word'])) + wd['centers'] = wd['centers'][:-1] + E('word_with_seven_centres', 'owners.stock', lambda: check_stock(wd, inp['template'], inp['buffers'])) + return out + + +# --------------------------------------------------------------------------------------------------------------- +# Entry point used by verify.py. I is audit_common.PinnedInputs over verify.INPUTS (git blob id + sha256 pins); +# widths {provider: [408 widths]} come from audit_staged_words (own frame recount of the two supplier words). + +def literal_file_bytes(name, obj): + """PR3633's expander serialisation of its literal side files (owners/portable_expand.py documents the format).""" + if name == 'PROFILE.json': + return (json.dumps(dict((int(k), v) for k, v in sorted(obj.items(), key=lambda kv: int(kv[0]))), indent=2) + + '\n').encode() + return (json.dumps(obj, separators=(',', ':')) + '\n').encode() + + +def check_literal_files(expected, order, dispatch, profile): + """owners.literal_files: the ORDER, DISPATCH and PROFILE rebuilt here serialise to PR3633's pinned literal files.""" + got = dict((n, sha256(literal_file_bytes(n, o))) for n, o in + (('ORDER.json', order), ('DISPATCH.json', dispatch), ('PROFILE.json', profile))) + for n, h in got.items(): + need(h == expected['literal_files'][n], 'owners.literal_files: rebuilt %s sha256 %s != pinned %s' + % (n, h, expected['literal_files'][n])) + return got + + +def run(I, widths, rows, AL, with_controls=True): + """rows: decode_columns(data/FILL-columns.xz); binding() below fixes them to PR3633's pinned payload.""" + exp = I.json('t488_expected') + o37, o8, o16 = I.json('t488_order37'), I.json('t488_order_t8'), I.json('t488_order_t16') + d37, d8, d16 = I.json('t488_dispatch37'), I.json('t488_dispatch_t8'), I.json('t488_dispatch_t16') + base = base_order(o37, o8, o16) + order = [[s, r + BASE * cp] for s, r in base for cp in range(COPIES)] + clock = check_order(order, o37, o8, o16) + bd = {} + for rows_, off in ((d37, 0), (d8, 37), (d16, 45)): + for s, r, pid in rows_: + bd[s, r + off] = pid + dispatch = [[s, r, bd[s, r % BASE]] for s, r in order] + pbc, counts = check_dispatch(dispatch, order, d37, d8, d16) + need(counts == {'extra': 1680, 'gauge44': 2712}, 'owners.dispatch: provider counts %r' % counts) + files = check_literal_files(exp, order, dispatch, exp['profile']) + need(exp['rows'] == CALLS * HELPERS and exp['replicas'] == T and exp['calls'] == CALLS and exp['physical'] == 437757, + 'owners.binding: EXPECTED.json header') + bind = binding(rows, exp['payload_sha256']) + template, plan = I.json('template'), I.json('plan') + ctx = make_ctx(order, clock, pbc, widths, template, plan, exp['profile']) + rec = audit(rows, ctx) + agg = check_aggregate(rec, I.json('t488_candidate')) + word = I.json('word_base') + stock = check_stock(word, template, len(word['helper_final'])) + out = dict(order_dispatch=dict(calls=CALLS, base_replicas=BASE, copies=COPIES, providers=counts, + literal_files_sha256=files), + binding=bind, audit=dict((k, v) for k, v in rec.items() if k != 'pattern_multiset'), + aggregate=agg, stock=stock) + if with_controls: + pr3133 = I.json('pr3133_providers') + inp = dict(widths=widths, pr3133_widths=dict((pid, pr3133[pid]['widths']) for pid in widths), providers_by_call=pbc, pr3133_width_rule='owners.capacity', order=order, + base_orders=(o37, o8, o16), dispatch=dispatch, base_dispatch=(d37, d8, d16), template=template, + plan=plan, clock=clock, claimed=exp['profile'], payload_sha256=exp['payload_sha256'], + candidate=I.json('t488_candidate'), record=rec, word=word, buffers=len(word['helper_final']), + expected=exp) + out['controls'] = controls(rows, ctx, inp, AL) + return out diff --git a/research/t488-independent-audit/audit_staged_words.py b/research/t488-independent-audit/audit_staged_words.py new file mode 100644 index 0000000000..64c6fc47b4 --- /dev/null +++ b/research/t488-independent-audit/audit_staged_words.py @@ -0,0 +1,506 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Scope C1: PR3633's two supplier words (PR3605's staged 644/660 width reduction) through this contributor's merged +PR3053 word lineage, with no code of PR3633, PR3605, PR3630, PR3624 or PR3626. + +Inputs (all read with plain `git -C show :`, then pinned by git blob id and sha256; nothing of a +PR is imported or executed): + PR3633 head 72c268f1 research/staged-width-t488/supplier3605/STAGED644-660-{base,extra}.json.gz (the words) + research/staged-width-t488/owners/SOURCE-PINS.json (its native_source_word_sha256 pins) + research/staged-width-t488/owners/PROVIDERS.json (widths used by its owner journal) + PR3605 head 3efbb5de research/staged-644-660-width-reduction/STAGED644-660-*.json.gz (byte identity only) + main 20ecf289 research/rank7-coupled-586-588-carrier-fold/edits/FINAL-WORD-*.json.gz (PR3133 parents; + byte-identical copies at research/coupled-carrier-cap740/words/*.json.gz) + research/coupled-carrier-cap740/vendor/PR3133-PROVIDERS.json + +audit_word(tag, raw, ctx) is the per-word main check (positive run and every negative control): + staged.pin sha256(raw) is the pinned value + vendored word_pipeline (audit_words, PR3053): parse + 36 initial corrections, warp algebra, literal frame recount, + words.counts, words.report_fields, words.declared, forward and dual free-operator replay + through cleanup, the own exact tracker, words.cleanup (literal inverse-reverse), words.buffers + staged.providers recount helper widths == PR3633 PROVIDERS.json entry (base->gauge44, extra->extra) + staged.providers_paid recount paid profile == the same entry's actual_paid_profile + staged.pr3133_widths the widths differ from the parent's PR3133-PROVIDERS entry exactly at helper indices 389, 397 + (8 -> 7) + staged.registers those indices are the live helper registers PR3605 names (644 and 660; ctx['staged_regs']) + staged.parent_diff.* localisation against the PR3133 parent word (one rule id per fact): + .keys / .replace / .warps same top-level keys; no unequal replace block; warps change only together with B + .warp_record / .warp_alignment every warp record unchanged except its B position, which follows the B alignment + .sections section-level counts == PR3605's published edit (B: 8 deleted, 4 inserted; cleanup: 4 + inserted; restore: 1 replaced; report: profile/inventory; start_extra: 644/660; warps: 72 + moved); every other section unchanged + .deleted the 8 deleted B items are helper-to-target writes, 4 from 644 and 4 from 660 + .inserted the 4 inserted B items are helper-to-helper donor releases, 2 from 644 and 2 from 660 + .cleanup_pairs the 4 cleanup inserts carry the same (target, source) pairs as the B inserts + .restore the replaced restore item is 210 and only its frame changes, to FULL + .start_extra start_extra of 644/660 goes from [30] to [429, 30] +Expected counts (words.counts) and why: + live 632 = 2*112 + 408; helpers 408 (PR3605 README "all 408 helper roles"; PR3633's owner audit gates R==408); + buffers 91 (PR3605 README "91 private buffers"; PR3633 gates len(zero_buffers)==91); warps 72 and corrections 36 + (the lineage's published EXPECT_COUNTS, main research/t74-3015-restore-edit-audit/verify.py, and the parent word + recounted by the same function); a_prelude_events and the section lengths = the parent's, except B -4 and + cleanup +4 (PR3605: eight writes replaced by four releases whose inverses enter the cleanup). +Declared profile/inventory (words.declared): staged {1:2439,2:726,3:224,4:102,5:20,8:8} / + {4:26,5:2,6:18,7:52,8:97,9:213}; parent {1:2433,2:724,3:228,4:102,5:20,8:8} / {4:26,5:2,6:18,7:50,8:99,9:213} + (PR3605 README; the parent profile also equals PR3133-PROVIDERS actual_paid_profile). +Negative controls go through audit_word, each on both words, and are counted by audit_lib.expect (exact rule id, and +stage for replays); every rule above has at least one control that only it can reject (the parent_diff facts by +parent mutants that keep the section counts, so each reaches its own fact). staged.registers is controlled with a +mismatched declared register pair (the data side, P['live'], is the vendored parser's; a relabelled-word control was +not built). Not mutation-controlled: the fail-closed git/pin reads of fixed inputs (staged.git, staged.pin, +staged.pr3605_identity) and run()'s parent positive control (staged.parent_counts, staged.parent_providers), which +must pass on the pinned bytes. Standard library only. +""" +import copy +import difflib +import gzip +import json +import os +import subprocess +import sys +import time +from collections import Counter + +_HERE = os.path.dirname(os.path.abspath(__file__)) +_VENDOR = os.path.join(_HERE, 'vendor', 'pr3053') +if _VENDOR not in sys.path: + sys.path.insert(0, _VENDOR) +import audit_common as AC # noqa: E402 +import audit_lib as AL # noqa: E402 +import audit_words as AW # noqa: E402 + +REPO = os.path.dirname(os.path.dirname(_HERE)) +MAIN = '20ecf2891d80b5acf18d980b2164fb44ea7faa90' +PR3633 = '72c268f113368ea0387d188225e3f81ba6d6ef73' +PR3605 = '3efbb5de06a49ffeea6684482f2d3fe48cdca3fb' +V = AL.V +FULL = list(AL.FULL_LIST) +TAGS = ('base', 'extra') +PROVIDER = dict(base='gauge44', extra='extra') + +# (commit, path, git blob, sha256) +STAGED = dict( + base=(PR3633, 'research/staged-width-t488/supplier3605/STAGED644-660-base.json.gz', + 'dc6d321b1e8e2a837a1ff7bb60e8f8f78d043db5', '735c540b1fe29d0ceeb4d2f304ec941e5f2bd3bc92bafc8cce2b4f9a67a3b653'), + extra=(PR3633, 'research/staged-width-t488/supplier3605/STAGED644-660-extra.json.gz', + '78e7b2bb0653c8dcc0133980a19dd9d97ebdb67e', '886338fc32da14f3389a82c8120a1bcf9c5e2f0ec3e9b2d377fdae809e1d977f')) +PR3605_PATH = 'research/staged-644-660-width-reduction/STAGED644-660-%s.json.gz' +PARENT = dict( + base=(MAIN, 'research/rank7-coupled-586-588-carrier-fold/edits/FINAL-WORD-base.json.gz', + 'cb4cc24a4545944627ad595c0c5080196952b9f0', '300a9b8ad1d554f0e6f84f43f3f5fd870a5b4e5f81ad856900b6e8999684892e'), + extra=(MAIN, 'research/rank7-coupled-586-588-carrier-fold/edits/FINAL-WORD-extra.json.gz', + 'decc8f26d8aab108baf75f0d8b2d1012eb06d076', '495d030f1e03b90e954dad3043994f03293d41b9ed220a3beaef849df435d3f0')) +PARENT_COPY = 'research/coupled-carrier-cap740/words/%s.json.gz' +SOURCE_PINS = (PR3633, 'research/staged-width-t488/owners/SOURCE-PINS.json', '5aa0ee4cb46308e674c5e1cedaa7eefc7bac59bd', + '7dec42af587af3b7ae66d4fdf3d0c6157f9c85eb744edec66fa266f294378e5e') +PROVIDERS = (PR3633, 'research/staged-width-t488/owners/PROVIDERS.json', 'f321d4185339244b8b004326af70e653e611d84a', + 'd96f2798024ab83edbb8848b62c425992aec182f1f24ef46bb8286dd390618c2') +PR3133_PROVIDERS = (MAIN, 'research/coupled-carrier-cap740/vendor/PR3133-PROVIDERS.json', None, + '52eb0d85caa7b2d4a93acdf5011f52b793f61ddca86235fb03cd9a09397ad4cd') + +DECLARED = dict(local_profile={1: 2439, 2: 726, 3: 224, 4: 102, 5: 20, 8: 8}, + width_inventory={4: 26, 5: 2, 6: 18, 7: 52, 8: 97, 9: 213}) +DECLARED_PARENT = dict(local_profile={1: 2433, 2: 724, 3: 228, 4: 102, 5: 20, 8: 8}, + width_inventory={4: 26, 5: 2, 6: 18, 7: 50, 8: 99, 9: 213}) +EXPECT_LINEAGE = dict(live=2 * V + 408, helpers=408, buffers=91, warps=72, corrections=36) +SECTION_DELTA = dict(B=-4, cleanup=4) +WIDTH_CHANGES = [(389, 8, 7), (397, 8, 7)] +STAGED_REGS = (644, 660) +LOCALISATION = dict( + B=dict(deleted=8, inserted=4, replaced=0), + cleanup=dict(deleted=0, inserted=4, replaced=0), + restore=dict(deleted=0, inserted=0, replaced=1), + report=dict(keys=['local_profile', 'width_inventory']), + start_extra=dict(keys=['644', '660']), + warps=dict(position_only=72)) +STAGE_FWD = 'forward replay, before cleanup' +STAGE_DUAL_BUF = 'dual replay, buffers after cleanup' +STAGE_FWD_FINAL = 'forward replay, final map after cleanup' + + +# ------------------------------------------------------------------------------------------------- inputs --- +def git(*args): + p = subprocess.run(['git', '-C', REPO] + list(args), stdout=subprocess.PIPE, stderr=subprocess.PIPE, + env=AC.git_env()) + AC.need(p.returncode == 0, 'staged.git: git %s failed: %s' % (' '.join(args)[:120], p.stderr.decode()[:200])) + return p.stdout + + +def read_pinned(spec): + """Bytes of commit:path, checked against the pinned git blob id and sha256 (None = not pinned).""" + commit, path, blob, sha = spec + data = git('show', '%s:%s' % (commit, path)) + AC.need(blob is None or AC.git_blob_id(data) == blob, 'staged.pin: %s blob %s != %s' + % (path, AC.git_blob_id(data), blob)) + AC.need(sha is None or AC.sha256(data) == sha, 'staged.pin: %s sha256 %s != %s' % (path, AC.sha256(data), sha)) + return data + + +def gz_json(raw): + return json.loads(gzip.decompress(raw).decode('utf-8')) + + +def gz_bytes(w): + return gzip.compress(json.dumps(w, separators=(',', ':')).encode(), mtime=0) + + +def counts_of(P, w): + c = AW.counts(P, w) + return dict((k, c[k]) for k in sorted(EXPECT_LINEAGE)), c + + +# ------------------------------------------------------------------------------------------ localisation --- +def list_diff(a, b): + sm = difflib.SequenceMatcher(None, [json.dumps(x) for x in a], [json.dumps(x) for x in b], autojunk=False) + out = dict(deleted=0, inserted=0, replaced=0) + ops = [o for o in sm.get_opcodes() if o[0] != 'equal'] + for tag, i1, i2, j1, j2 in ops: + if tag == 'delete': + out['deleted'] += i2 - i1 + elif tag == 'insert': + out['inserted'] += j2 - j1 + else: + AC.need(i2 - i1 == j2 - j1, 'staged.parent_diff.replace: unequal replace block %r' % ((tag, i1, i2, j1, j2),)) + out['replaced'] += i2 - i1 + return out, ops, sm + + +def b_position_map(sm, n_old, n_new): + """Parent B position -> staged B position for every position inside an equal block (and the end).""" + m = {n_old: n_new} + for tag, i1, i2, j1, j2 in sm.get_opcodes(): + if tag == 'equal': + for k in range(i2 - i1): + m[i1 + k] = j1 + k + return m + + +def localise(parent, w): + """Section-level differences parent -> staged word (counts only), with the per-item facts of PR3605's edit.""" + loc, facts = {}, {} + AC.need(sorted(parent) == sorted(w), 'staged.parent_diff.keys: key sets differ %r' % sorted(set(parent) ^ set(w))) + smB = None + for k in sorted(w): + a, b = parent[k], w[k] + if a == b: + continue + if k == 'warps': + continue + if isinstance(a, list): + loc[k], ops, sm = list_diff(a, b) + if k == 'B': + smB, opsB = sm, ops + facts[k] = ops + elif isinstance(a, dict): + loc[k] = dict(keys=sorted(x for x in set(a) | set(b) if a.get(x) != b.get(x))) + else: + loc[k] = dict(scalar=[a, b]) + if parent['warps'] != w['warps']: + AC.need(smB is not None and len(parent['warps']) == len(w['warps']), 'staged.parent_diff.warps: warps changed without B') + pos = b_position_map(smB, len(parent['B']), len(w['B'])) + moved = 0 + for ra, rb in zip(parent['warps'], w['warps']): + AC.need(ra[1:] == rb[1:], 'staged.parent_diff.warp_record: a warp record changed beyond its position') + AC.need(ra[0] in pos and pos[ra[0]] == rb[0], + 'staged.parent_diff.warp_alignment: warp at parent B position %d does not follow the B alignment' % ra[0]) + moved += ra[0] != rb[0] + loc['warps'] = dict(position_only=moved) + AC.need(loc == LOCALISATION, 'staged.parent_diff.sections: %r != %r' % (loc, LOCALISATION)) + # per-item facts of the published edit + dele = [g for t, i1, i2, _, _ in facts['B'] if t == 'delete' for g in parent['B'][i1:i2]] + ins = [g for t, _, _, j1, j2 in facts['B'] if t == 'insert' for g in w['B'][j1:j2]] + cins = [g for t, _, _, j1, j2 in facts['cleanup'] if t == 'insert' for g in w['cleanup'][j1:j2]] + AC.need(all(g[0] == 'add' and V <= g[1] < 2 * V and g[2] in STAGED_REGS for g in dele) + and Counter(g[2] for g in dele) == Counter({644: 4, 660: 4}), + 'staged.parent_diff.deleted: deleted B items are not 4+4 helper-to-target writes of 644/660') + AC.need(all(g[0] == 'add' and g[1] >= 2 * V and g[2] in STAGED_REGS for g in ins) + and Counter(g[2] for g in ins) == Counter({644: 2, 660: 2}), + 'staged.parent_diff.inserted: inserted B items are not 2+2 donor releases of 644/660') + AC.need(sorted((g[1], g[2]) for g in cins) == sorted((g[1], g[2]) for g in ins), + 'staged.parent_diff.cleanup_pairs: cleanup inserts are not the four inserted (target, source) pairs') + (_, i1, _, _, _), = facts['restore'] + ra, rb = parent['restore'][i1], w['restore'][i1] + AC.need(i1 == 210 and ra[:-1] == rb[:-1] and rb[-1] == FULL and ra[-1] != FULL, + 'staged.parent_diff.restore: restore change is not item 210 frame -> FULL') + AC.need(all(parent['start_extra'][str(r)] == [30] and w['start_extra'][str(r)] == [429, 30] for r in STAGED_REGS), + 'staged.parent_diff.start_extra: start_extra of 644/660 is not [30] -> [429, 30]') + return dict(sections=loc, b_deleted_sources=dict(Counter(g[2] for g in dele)), + b_inserted=[g[:3] for g in ins], restore_index=i1, unchanged_sections=sorted(k for k in w + if parent[k] == w[k])) + + +# ---------------------------------------------------------------------------------------- per-word check --- +def audit_word(tag, raw, ctx): + """The per-word main check (see module docstring). Returns (record, helper widths).""" + AC.need(AC.sha256(raw) == ctx['pins'][tag], 'staged.pin: %s word sha256 %s' % (tag, AC.sha256(raw))) + w = gz_json(raw) + rec, P, fr = AW.word_pipeline(w, ctx['declared'], ctx['expect'][tag]) + widths = list(fr['helper_widths']) + pid = PROVIDER[tag] + prov = ctx['providers'][pid] + AC.need(widths == prov['widths'], 'staged.providers: %s recount widths != PROVIDERS.json[%s] (first diff %r)' + % (tag, pid, next(((i, a, b) for i, (a, b) in enumerate(zip(widths, prov['widths'])) if a != b), None))) + AC.need(fr['paid'] == AL.intkeys(prov['actual_paid_profile']), + 'staged.providers_paid: %s recount paid profile %r != PROVIDERS.json[%s]' % (tag, fr['paid'], pid)) + old = ctx['pr3133'][pid]['widths'] + diffs = [(i, a, b) for i, (a, b) in enumerate(zip(old, widths)) if a != b] + AC.need(len(old) == len(widths) and diffs == WIDTH_CHANGES, + 'staged.pr3133_widths: %s diffs vs PR3133-PROVIDERS %r != %r' % (tag, diffs, WIDTH_CHANGES)) + helpers = [r for r in P['live'] if r >= 2 * V] + AC.need(tuple(helpers[i] for i, _, _ in diffs) == tuple(ctx['staged_regs']), + 'staged.registers: changed indices name registers %r, declared %r' + % ([helpers[i] for i, _, _ in diffs], ctx['staged_regs'])) + loc = localise(ctx['parents'][tag], w) + rec = dict(rec, sha256=AC.sha256(raw), provider=pid, pr3133_width_changes=[list(d) for d in diffs], + changed_registers=list(STAGED_REGS), localisation=loc) + return rec, widths + + +# -------------------------------------------------------------------------------------------- controls --- +def word_controls(tag, raw, ctx, out): + T = '[%s] ' % tag + w0 = gz_json(raw) + + def through(m, ctx2=None, repin=True): + """Run the mutant word through audit_word; repin=True gives it a matching pin, so only the deeper checks can + reject it.""" + r = gz_bytes(m) if isinstance(m, dict) else m + c = dict(ctx2 or ctx) + if repin: + c['pins'] = dict(c['pins'], **{tag: AC.sha256(r)}) + return lambda: audit_word(tag, r, c) + + def expect_count(section, d): + c2 = dict(ctx, expect=dict(ctx['expect'])) + c2['expect'][tag] = dict(ctx['expect'][tag], sections=dict(ctx['expect'][tag]['sections'])) + c2['expect'][tag]['sections'][section] += d + return c2 + + def with_parent(par): + return dict(ctx, parents=dict(ctx['parents'], **{tag: par})) + + bad = bytearray(raw) + bad[len(bad) // 2] ^= 1 + AL.expect(out, T + 'one byte of the gzip stream flipped, pin kept', 'staged.pin', through(bytes(bad), repin=False)) + + m = AL.mutant(w0) + j = next(i for i, g in enumerate(m['B']) if g[0] == 'add' and g[2] in STAGED_REGS and g[1] >= 2 * V) + m['B'][j][3] = -m['B'][j][3] + AL.expect(out, T + 'coefficient of the first donor release B[%d] flipped' % j, 'wc.replay', through(m), + stage=STAGE_FWD) + + m = AL.mutant(w0) + del m['cleanup'][0] + AL.expect(out, T + 'first cleanup item deleted, expected cleanup count lowered to match', 'wc.replay', + through(m, expect_count('cleanup', -1)), stage=STAGE_FWD_FINAL) + + m = AL.mutant(w0) + cl = m['cleanup'] + i = next(k for k in range(len(cl) - 1) if cl[k][0] == cl[k + 1][0] == 'add' + and not {cl[k][1], cl[k][2]} & {cl[k + 1][1], cl[k + 1][2]}) + cl[i], cl[i + 1] = cl[i + 1], cl[i] + P = AL.parse_word(m) + AL.replay(P, False) + AL.replay(P, True) + AW.tracker_check(AW.track(m)) + AL.expect(out, T + 'commuting cleanup items %d/%d swapped (both replays and the tracker accept)' % (i, i + 1), + 'words.cleanup', through(m), replays_and_tracker_accept=True) + + m = AL.mutant(w0) + k = next(k for k in sorted(m['helper_final'], key=int) if len(m['helper_final'][k]) < len(FULL)) + m['helper_final'][k] = list(FULL) + AL.forge(m) + AL.expect(out, T + 'helper_final frame of %s raised to FULL, report forged' % k, 'words.declared', through(m)) + + m = AL.mutant(w0) + restored = set(int(x) for x in m['helper_final']) + n = 2 * V + m['report']['R'] + helper = next(r for r in range(2 * V, n) if r not in set(m['removed']) and r not in restored) + m['cleanup'].insert(0, ['add', helper, n + min(restored), 1, 1, list(FULL)]) + AL.expect(out, T + 'cleanup prepended with helper %d += zero buffer (forward-neutral), cleanup count raised' + % helper, 'wc.replay', through(m, expect_count('cleanup', 1)), stage=STAGE_DUAL_BUF) + + AL.expect(out, T + 'declared profile/inventory of the PR3133 parent', 'words.declared', + through(raw, dict(ctx, declared=DECLARED_PARENT), repin=False)) + + c2 = dict(ctx, expect=dict(ctx['expect'])) + c2['expect'][tag] = dict(ctx['expect'][tag], helpers=409) + AL.expect(out, T + 'expected helper count 409', 'words.counts', through(raw, c2, repin=False)) + + pid = PROVIDER[tag] + prov = copy.deepcopy(ctx['providers']) + prov[pid]['widths'][WIDTH_CHANGES[0][0]] = 8 + AL.expect(out, T + 'PROVIDERS.json[%s] width of helper 644 (index 389) back to 8' % pid, 'staged.providers', + through(raw, dict(ctx, providers=prov), repin=False)) + + prov = copy.deepcopy(ctx['providers']) + prov[pid]['actual_paid_profile']['1'] += 1 + AL.expect(out, T + 'PROVIDERS.json[%s] actual_paid_profile rank-1 count +1, widths kept' % pid, + 'staged.providers_paid', through(raw, dict(ctx, providers=prov), repin=False)) + + old = copy.deepcopy(ctx['pr3133']) + old[pid]['widths'] = list(ctx['providers'][pid]['widths']) + AL.expect(out, T + 'PR3133-PROVIDERS[%s] replaced by the staged widths (no 8->7 change)' % pid, + 'staged.pr3133_widths', through(raw, dict(ctx, pr3133=old), repin=False)) + + AL.expect(out, T + 'declared changed registers (645, 660) instead of PR3605\'s (644, 660)', 'staged.registers', + through(raw, dict(ctx, staged_regs=(645, 660)), repin=False)) + + # parent_diff: each parent mutant keeps every earlier fact, so only the named one can reject it + P0 = ctx['parents'][tag] + par = AL.mutant(P0) + par['note'] = 'extra key' + AL.expect(out, T + 'parent word with an extra top-level key', 'staged.parent_diff.keys', + through(raw, with_parent(par), repin=False)) + + par = AL.mutant(P0) + k = next(k for k in range(len(P0['cleanup'])) if P0['cleanup'][k] == w0['cleanup'][k]) + par['cleanup'][k:k + 1] = [['add', 0, 0, 0, 0, []], ['add', 1, 1, 0, 0, []]] + AL.expect(out, T + 'parent cleanup[%d] replaced by two unmatched items (2-for-1 replace block)' % k, + 'staged.parent_diff.replace', through(raw, with_parent(par), repin=False)) + + par = AL.mutant(P0) + del par['warps'][-1] + AL.expect(out, T + 'parent with its last warp record removed', 'staged.parent_diff.warps', + through(raw, with_parent(par), repin=False)) + + par = AL.mutant(P0) + par['A'][par['prelude_events'] + 5][-1] = list(FULL) + AL.expect(out, T + 'parent word with one A gate frame changed', 'staged.parent_diff.sections', + through(raw, with_parent(par), repin=False)) + + par = AL.mutant(P0) + par['restore'][210] = copy.deepcopy(w0['restore'][210]) + AL.expect(out, T + 'parent word already carrying the staged restore 210', 'staged.parent_diff.sections', + through(raw, with_parent(par), repin=False)) + + _, opsB, _ = list_diff(P0['B'], w0['B']) + dels = [i for t, i1, i2, _, _ in opsB if t == 'delete' for i in range(i1, i2)] + ins_at = [(i1, j1) for t, i1, _, j1, _ in opsB if t == 'insert'] + warp_pos = set(r[0] for r in P0['warps']) + + par = AL.mutant(P0) + AL.delete_B(par, dels[0]) + AL.expect(out, T + 'parent without deleted write B[%d] (warps re-attached): 7 deletions' % dels[0], + 'staged.parent_diff.sections', through(raw, with_parent(par), repin=False)) + + par = AL.mutant(P0) + par['B'][dels[0]][2] += 1 + AL.expect(out, T + 'parent deleted write B[%d] with source %d -> %d' % (dels[0], P0['B'][dels[0]][2], + par['B'][dels[0]][2]), + 'staged.parent_diff.deleted', through(raw, with_parent(par), repin=False)) + + # parent B[i1] := the first inserted release: that release becomes matched and the staged copy of the old B[i1] + # becomes the fourth insertion (counts kept, no warp at i1) + i1, j1 = ins_at[0] + AC.need(i1 not in warp_pos and P0['B'][i1] == w0['B'][j1 + 2], 'controls.harness: B insertion point %d' % i1) + par = AL.mutant(P0) + par['B'][i1] = copy.deepcopy(w0['B'][j1]) + AL.expect(out, T + 'parent B[%d] replaced by the first inserted release: an ordinary item among the insertions' + % i1, 'staged.parent_diff.inserted', through(raw, with_parent(par), repin=False)) + + _, opsC, _ = list_diff(P0['cleanup'], w0['cleanup']) + (c1, cj1), = [(i1, j1) for t, i1, _, j1, _ in opsC if t == 'insert'][:1] + AC.need(P0['cleanup'][c1] == w0['cleanup'][cj1 + 2], 'controls.harness: cleanup insertion point %d' % c1) + par = AL.mutant(P0) + par['cleanup'][c1] = copy.deepcopy(w0['cleanup'][cj1]) + AL.expect(out, T + 'parent cleanup[%d] replaced by the first cleanup insert: one insert pair altered' % c1, + 'staged.parent_diff.cleanup_pairs', through(raw, with_parent(par), repin=False)) + + par = AL.mutant(P0) + par['restore'][210][2] -= 2 + AL.expect(out, T + 'parent restore 210 coefficient changed (non-frame field)', 'staged.parent_diff.restore', + through(raw, with_parent(par), repin=False)) + + par = AL.mutant(P0) + par['start_extra']['644'] = [31] + AL.expect(out, T + 'parent start_extra[644] = [31]', 'staged.parent_diff.start_extra', + through(raw, with_parent(par), repin=False)) + + par = AL.mutant(P0) + par['warps'][0][1] += 1 + AL.expect(out, T + 'parent warps[0] lender changed', 'staged.parent_diff.warp_record', + through(raw, with_parent(par), repin=False)) + + par = AL.mutant(P0) + par['warps'][0][0] += 1 + AL.expect(out, T + 'parent warps[0] B position shifted by one', 'staged.parent_diff.warp_alignment', + through(raw, with_parent(par), repin=False)) + + +# ------------------------------------------------------------------------------------------------ main --- +def run(controls=True): + t0 = time.time() + pins_doc = json.loads(read_pinned(SOURCE_PINS).decode()) + for tag in TAGS: + AC.need(pins_doc['native_canonical'][tag]['native_source_word_sha256'] == STAGED[tag][3], + 'staged.pin: PR3633 SOURCE-PINS native_source_word_sha256[%s] != %s' % (tag, STAGED[tag][3])) + providers = json.loads(read_pinned(PROVIDERS).decode()) + pr3133 = json.loads(read_pinned(PR3133_PROVIDERS).decode()) + raws, parents, identity = {}, {}, {} + for tag in TAGS: + raws[tag] = read_pinned(STAGED[tag]) + b3605 = git('rev-parse', '%s:%s' % (PR3605, PR3605_PATH % tag)).decode().strip() + AC.need(b3605 == STAGED[tag][2], 'staged.pr3605_identity: %s blob %s != %s' % (tag, b3605, STAGED[tag][2])) + same = read_pinned((PR3605, PR3605_PATH % tag, STAGED[tag][2], STAGED[tag][3])) + AC.need(same == raws[tag], 'staged.pr3605_identity: %s bytes differ' % tag) + identity[tag] = dict(pr3633=dict(commit=PR3633, path=STAGED[tag][1], git_blob=STAGED[tag][2]), + pr3605=dict(commit=PR3605, path=PR3605_PATH % tag, git_blob=b3605), + sha256=STAGED[tag][3], identical_bytes=True) + praw = read_pinned(PARENT[tag]) + AC.need(read_pinned((MAIN, PARENT_COPY % tag, PARENT[tag][2], PARENT[tag][3])) == praw, + 'staged.pin: parent copy %s differs' % (PARENT_COPY % tag)) + parents[tag] = gz_json(praw) + # parents (positive): the lineage pipeline with PR3605's "before" profile, widths == PR3133-PROVIDERS + parent_recs, expect = {}, {} + for tag in TAGS: + Pp = AL.parse_word(parents[tag]) + lin, cp = counts_of(Pp, parents[tag]) + AC.need(lin == EXPECT_LINEAGE, 'staged.parent_counts: %s %r != %r' % (tag, lin, EXPECT_LINEAGE)) + recp, _, frp = AW.word_pipeline(parents[tag], DECLARED_PARENT, EXPECT_LINEAGE) + pid = PROVIDER[tag] + AC.need(list(frp['helper_widths']) == pr3133[pid]['widths'] + and frp['paid'] == AL.intkeys(pr3133[pid]['actual_paid_profile']), + 'staged.parent_providers: parent %s recount != PR3133-PROVIDERS[%s]' % (tag, pid)) + parent_recs[tag] = dict(sha256=PARENT[tag][3], path=PARENT[tag][1], also_at=PARENT_COPY % tag, + counts=recp['counts'], profile=recp['profile'], inventory=recp['inventory'], + provider=pid, widths_equal_pr3133_providers=True) + sections = dict(cp['sections']) + for k, d in SECTION_DELTA.items(): + sections[k] += d + expect[tag] = dict(EXPECT_LINEAGE, a_prelude_events=cp['a_prelude_events'], sections=sections) + ctx = dict(pins=dict((t, STAGED[t][3]) for t in TAGS), declared=DECLARED, expect=expect, providers=providers, + pr3133=pr3133, parents=parents, staged_regs=STAGED_REGS) + words, widths = {}, {} + for tag in TAGS: + words[tag], widths[PROVIDER[tag]] = audit_word(tag, raws[tag], ctx) + out = [] + if controls: + AL.harness_selftest() + n0 = len(AC.ATTEMPTED) + for tag in TAGS: + word_controls(tag, raws[tag], ctx, out) + attempted = len(AC.ATTEMPTED) - n0 + return dict(scope='C1 staged supplier words through the PR3053 word lineage', words=words, parents=parent_recs, + pr3605_identity=identity, expect=expect, helper_widths=widths, controls=out, + controls_attempted=attempted if controls else 0, controls_killed=len(out), + runtime_seconds=round(time.time() - t0, 1)) + + +def summary(res): + s = dict(runtime_seconds=res['runtime_seconds'], pr3605_identity=res['pr3605_identity']) + for tag, r in res['words'].items(): + s[tag] = dict(sha256=r['sha256'], counts=r['counts'], profile=r['profile'], inventory=r['inventory'], + independent_inputs=r['independent_inputs'], buffers=r['buffers'], cleanup=r['cleanup'], + tracker_final=r['tracker']['final_identity'], pr3133_width_changes=r['pr3133_width_changes'], + changed_registers=r['changed_registers'], localisation=r['localisation']['sections'], + unchanged_sections=r['localisation']['unchanged_sections']) + s['parents'] = res['parents'] + s['controls'] = [(c['control'], c['expected'], c['rejected_by'] == c['expected']) for c in res['controls']] + return s + + +if __name__ == '__main__': + res = run(controls='--no-controls' not in sys.argv) + print(json.dumps(summary(res), indent=1, sort_keys=True)) + print('PASS C1: %d words, %d of %d controls killed (%.1fs)' % (len(res['words']), res['controls_killed'], + res['controls_attempted'], res['runtime_seconds'])) diff --git a/research/t488-independent-audit/data/FILL-columns.xz b/research/t488-independent-audit/data/FILL-columns.xz new file mode 100644 index 0000000000000000000000000000000000000000..1488aa9b6113e35c1f582a9f8c5b5a60d5e05c25 GIT binary patch literal 769472 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�$NoeU_=>{bCg{QUJ2iIOY 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�! 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