From 989dd10b0555cd4d8afbf5d4dcfad783a9a95e40 Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Sat, 17 Oct 2026 23:14:43 +0100 Subject: [PATCH 1/2] feat(research): certify QQ16 consumer accounting gap --- .../qq16-separate-consumer-budget/CHECKS.json | 81 ++++++ .../ENGINEERING.md | 42 +++ .../qq16-separate-consumer-budget/README.md | 153 ++++++++++ .../qq16-separate-consumer-budget/RESULT.json | 135 +++++++++ .../SOURCES.json | 66 +++++ .../qq16-separate-consumer-budget/TASK.json | 79 ++++++ .../qq16-separate-consumer-budget/VERIFY.json | 39 +++ .../test_verify.py | 107 +++++++ .../qq16-separate-consumer-budget/verify.py | 262 ++++++++++++++++++ 9 files changed, 964 insertions(+) create mode 100644 research/qq16-separate-consumer-budget/CHECKS.json create mode 100644 research/qq16-separate-consumer-budget/ENGINEERING.md create mode 100644 research/qq16-separate-consumer-budget/README.md create mode 100644 research/qq16-separate-consumer-budget/RESULT.json create mode 100644 research/qq16-separate-consumer-budget/SOURCES.json create mode 100644 research/qq16-separate-consumer-budget/TASK.json create mode 100644 research/qq16-separate-consumer-budget/VERIFY.json create mode 100644 research/qq16-separate-consumer-budget/test_verify.py create mode 100644 research/qq16-separate-consumer-budget/verify.py diff --git a/research/qq16-separate-consumer-budget/CHECKS.json b/research/qq16-separate-consumer-budget/CHECKS.json new file mode 100644 index 0000000000..58d9db7937 --- /dev/null +++ b/research/qq16-separate-consumer-budget/CHECKS.json @@ -0,0 +1,81 @@ +{ + "status": "PASS_WORKING_TREE; committed/export evidence follows", + "at": "2026-10-17T22:14:27.940948+00:00", + "platform": "macOS-27.0.1-arm64-arm-64bit-Mach-O", + "commands": [ + { + "argv": [ + "/Users/nick/.local/share/uv/python/cpython-3.12.15-macos-aarch64-none/bin/python3.12", + "-Werror", + "-B", + "scripts/research_package.py", + "--package", + "research/qq16-separate-consumer-budget" + ], + "returncode": 0, + "stdout": "CHECK Authenticate fixed sources, count literal cores/added children, certify conditional mass gates and unknown actual credit\nPASS_QQ16_SEPARATE_CONSUMER_ADMISSION_GAP_NO_NEW_KAPPA\nCHECK Strict versus equality gate, numeric schema, changed source profile, Git-free replay and private corruptions\nPASS_REGISTERED_RESEARCH_PACKAGE research/qq16-separate-consumer-budget outcome=partial", + "stderr": "...\n----------------------------------------------------------------------\nRan 3 tests in 1.070s\n\nOK" + }, + { + "argv": [ + "/Users/nick/.local/share/uv/python/cpython-3.12.15-macos-aarch64-none/bin/python3.12", + "-I", + "-O", + "-Werror", + "-B", + "research/qq16-separate-consumer-budget/verify.py" + ], + "returncode": 0, + "stdout": "PASS_QQ16_SEPARATE_CONSUMER_ADMISSION_GAP_NO_NEW_KAPPA", + "stderr": "" + }, + { + "argv": [ + "/Users/nick/.local/share/uv/python/cpython-3.12.15-macos-aarch64-none/bin/python3.12", + "-I", + "-O", + "-Werror", + "-B", + "research/qq16-separate-consumer-budget/test_verify.py" + ], + "returncode": 0, + "stdout": "", + "stderr": "...\n----------------------------------------------------------------------\nRan 3 tests in 1.148s\n\nOK" + }, + { + "argv": [ + "/opt/homebrew/bin/python3.14", + "-I", + "-O", + "-Werror", + "-B", + "research/qq16-separate-consumer-budget/verify.py" + ], + "returncode": 0, + "stdout": "PASS_QQ16_SEPARATE_CONSUMER_ADMISSION_GAP_NO_NEW_KAPPA", + "stderr": "" + }, + { + "argv": [ + "/opt/homebrew/bin/python3.14", + "-I", + "-O", + "-Werror", + "-B", + "research/qq16-separate-consumer-budget/test_verify.py" + ], + "returncode": 0, + "stdout": "", + "stderr": "...\n----------------------------------------------------------------------\nRan 3 tests in 1.169s\n\nOK" + } + ], + "unrun": [ + "selected cold replay", + "complete QQ16 global native/physical continuation", + "full inherited theorem audit", + "Lean", + "Docker", + "hosted CI" + ], + "observed_limit": "Registered generic runner rejects Python3.14 because VERIFY specifies3.12; direct3.14 replay passes. Initial rejection retained in session log working-1-0.log." +} diff --git a/research/qq16-separate-consumer-budget/ENGINEERING.md b/research/qq16-separate-consumer-budget/ENGINEERING.md new file mode 100644 index 0000000000..73b0fe4a08 --- /dev/null +++ b/research/qq16-separate-consumer-budget/ENGINEERING.md @@ -0,0 +1,42 @@ +# Verification boundary + +Separate Before Serializing Shared State keeps this result in one owned package, +branch and cache. The shared Git and claim transactions use the required OS lock. +No peer, selected-science or frozen predecessor file is changed. + +Prove It Works requires matching the actual literal core and decoder word, +checking the selected idle split, running rejecting public CLI controls, and +executing committed bytes in an inode-disjoint read-only Git-free export. +An arithmetic success marker never admits the missing physical continuation. + +Power of Ten review covers verify.py and test_verify.py. There is no new +recursion or generated-code execution. Functions fit within 60 physical lines. +Source inventories have exactly eight runtime inputs and two provenance entries. +Files are capped at 16 MB, source metadata at 16 KB, receipts at 100 KB and +expanded gzip at 12 MB. Each core has 25155 events, each of nine producer cases +has at most 600 outer events, each sweep body at most 2000 events, and each +flattened case at most 4000 events. There are 3823 decoder events and three +fixed endpoint profiles with at most 73 ranks each. Temporary exports copy at +most 20 package files and the eight declared inputs. CLI subprocesses are +synchronous, have 20-second timeouts and their return codes are checked. + +Rule 3 deviation: CPython allocates managed integers, byte buffers, JSON objects, +Counters and dictionaries during this finite offline replay. Authenticated fixed +inputs and the explicit byte/event limits bound the live problem. Python and +library allocator overhead is not measured; no fixed-allocation implementation +or production service is claimed. A variable-size tool needs a separate memory +capacity review. Standard-library JSON/gzip internals retain their implementation +and recursion behavior; the checker does not interpret arbitrary source before +hash authentication. Receipt parsing failures fail closed. + +Rules 8 and 9 deviation: the tests load the single explicit package verifier +module and unittest uses its normal test dispatch. There are three test methods; +no arbitrary plug-in or predecessor executable is loaded. The verifier itself +uses only standard-library code. All validation uses explicit exceptions and +survives optimization. No assertion is used to validate scientific input. + +Warnings-as-errors, Ruff E/F/I/B/UP/C4/SIM and formatting checks cover both files. +The existing registered-package workflow runs the warning-strict replay and its +optimized controls. No additional installed dependency or repository-wide lint +policy is introduced. The prototype additive rejection is retained only in the +session cache and is explicitly withdrawn as an unconditional conclusion. diff --git a/research/qq16-separate-consumer-budget/README.md b/research/qq16-separate-consumer-budget/README.md new file mode 100644 index 0000000000..ef0ca64a8a --- /dev/null +++ b/research/qq16-separate-consumer-budget/README.md @@ -0,0 +1,153 @@ +# QQ16 separate-consumer budget and the missing idle credit + +No new kappa was obtained. The literal QQ16 core matches the selected +centre-free profile, but the local producer, decoder and endpoint tariff do +not supply a complete global owner/frame continuation. In particular, they +do not identify which selected idle-remainder work the new operations replace. +The actual complete moment and its admissible saving interval remain unknown. + +This package answers one bounded admission question. It gives a source-bound +rank ledger and a conditional unchanged-idle rejection. It does not reject +QQ16 in general or establish a favorable supplier bill. The initial additive +screen was withdrawn as an unconditional claim before publication because it +silently retained the old idle work. The correction is part of this result. + +## Exact boundary and arithmetic + +Canonical base is `6f100d4bb5083f8c35d96fd95a539811c62f245c`, priority revision 6. +The selected conditional kappa is `836330098538459/500000000000000000`. +Its complex saving is `67018507072324140917/40000000000000000000000`; +BIT saving is `1733427039589844234749/1000000000000000000000000`. +The complex side binds. These are inherited source-bound values, not a new +circuit replay or a new outer-transfer proof. + +Use the selected width 73, nine stages and 896 live data families per replica. +The full selected source has 144 calls, 14336 families and 16 replicas. Subtracting +its independently recounted idle histogram leaves the local paid profile +`{1:2412,2:418,3:432,4:142,5:82,8:8}` at every call. Both literal QQ16 cores +have precisely the same profile with the eight rank-eight children removed. +Their mass is 5522 per call. The selected idle mass is 14814 per replica. + +The screened sequence is F0, B1,2, F2, B3,4, F4, B5,6, F6, B7,8, F8. +The exact source adds 136 rank-one children, 3264 full-cover maps and 9928 +scalar macros outside its retained cores. Grant just one PR2707 decoder for +the entire sequence, even though that decoder only promises recovery from the +first F0/B1 cut. Its literal word has 336 rank-one children, 464 cover maps, +2704 ADDs and 312 CLEARs. Grant all required cut access and remaining global +closure without charge. These are favorable assumptions for a screen, not +proved nine-stage controller semantics. + +Before endpoint adapters the local child delta is `+472 H1 -72 H8` per +replica. This is an occurrence delta, not a certified global paid-profile delta. +The decoder borrows 224 current arrays without writing them and returns 224 +independent owned original arrays in F17, with 16 owned scratch arrays. +PR2678's separate-field affine/convolution theorem supplies these endpoint +tariffs for arbitrary contents and every positive common tensor depth: + +| Required endpoint | Separate child histogram | Rank mass | +|---|---|---:| +| Common FL | 224 H8 | 1792 | +| F0 gauges | 112 H8 +112 H9 | 1904 | +| Original entry gauges | 112 H16 +112 H17 | 3696 | + +That theorem excludes cross-field fusion, shared children, borrowed observations, +payload phase masks and a consumer accepting F17. We inherit its proof and exact +source receipt. We do not rerun its native phase census or strengthen its scope. + +Let C be the rank mass of old idle work actually removed by a certified new +continuation. Assume the old nine cores remain and no other rank charges change. +The proposed accounting identity is then + +``` +parent mass = 73*896 = 65408 +paid mass = 9*5522 +14814 +136 +336 +adapter_mass -C + = 64512 +472 +adapter_mass -C. +``` + +This is an explicit accounting model. It is not a proof that any particular C +is achievable, that no other ranks change, or that rank mass determines a moment. +The literal source/owner continuation must establish those implications. + +| Endpoint | Mass at C=0 | Parent minus paid mass | Necessary integer C for a strict mass gate | +|---|---:|---:|---:| +| Common FL | 66776 | -1368 | 1369 | +| F0 gauges | 66888 | -1480 | 1481 | +| Original entry gauges | 68680 | -3272 | 3273 | + +If old idle work is unchanged, C=0. These three screens fail for every saving +`a>=0` in the child-moment model, since for `0= r/73`. No floating-point root decision is needed. +Even granting both producer and decoder free gives common-FL mass 66304 and +moment `74/73` at zero saving, conditional on unchanged idle work. + +The control C=1368 makes common-FL mass exactly 65408, which fails strict +acceptance. C=1369 makes its zero-saving mass smaller by one. It does **not** +prove a positive-saving moment, a realizable credit, compatible coefficients, +chronology, physical access or new kappa. A changed histogram must be priced +at the claimed saving, including every additional charge. + +## Complete obligation ledger and decision + +| Item | Evidence status and remaining obligation | +|---|---| +| Selected core/idle split and both primitive endpoints | Proved finite arithmetic against pinned selected assembly and independent receipt; inherited circuit admission remains conditional. | +| Nine literal local cores and 136 added lines | Constructive local words; fresh occurrence recount. Their whole-controller composition and owner continuation are unknown. | +| One decoder's 336 lines and F17 output contract | Constructive local source; fresh occurrence recount, inherited native semantics. Its availability/sufficiency for the nine-stage sequence is granted only in the screen. | +| Separate endpoint tariff | Scoped predecessor proof and constructive recipes inherited from PR2678, not newly proved here. | +| Displaced idle children, coefficients, frames and placement | Unknown. No old idle charge is certified removed. No global paid-profile delta is certified. | +| Dirty helpers and restoration | Local frame-relative contracts inherited. Complete borrowed-state continuation and literal caller restoration are unknown. | +| Cover maps, wrappers and movement | 3728 added cover-map occurrences before adapters, plus native wrappers. Physical routing, travel, access, control and hosting are unknown. Counts are not zero-cost execution. | +| Owned outputs, scratch and retained cuts | Local ownership is explicit. Global capacity, lifetime, clearing and cleanup are unknown. | +| Precision, recursive tariffs and all-size applicability | Local numerical/reference work does not prove these new global implications. Unknown. | +| BIT and analytic transfer | Selected conditional BIT bill unchanged. No new complex bill exists to transfer; selected analytic assumptions do not fill this gap. | + +Family decision: narrow and stop at this admission gap. The weakest unresolved +item is an actual source/owner continuation with exact coefficients that maps +new work to the displaced remainders. The bounded test now stops because none +of the pinned local words or endpoint recipes contains that global mapping. +No additional adapter, precision, inverse or search round follows this result. +A complete optimistic physical allowance is therefore unavailable; the C=0 +screen is conditional and must not be reported as a complete QQ16 obstruction. + +## Reproduce + +The registered runner requires Python 3.12. The direct scripts support Python +3.12 or later and use only the standard library. From the repository root: + +```sh +python3.12 -Werror -B scripts/research_package.py --package research/qq16-separate-consumer-budget +python3 -I -Werror -B research/qq16-separate-consumer-budget/verify.py +python3 -I -O -Werror -B research/qq16-separate-consumer-budget/test_verify.py +``` + +Default replay is read-only and needs no environment variable. `verify.py --emit` +prints the recomputed receipt. Source paths, allowed usages, blobs and hashes +are fixed in SOURCES.json, whose own bytes are pinned in the verifier. Direct +commands work in a Git-free export containing the eight declared inputs. +Validation distinguishes booleans, integers and floats. Tests exercise equality +versus strict mass acceptance, bool counts, changed core ranks, input drift, +source-usage reclassification and typed receipt corruption in private copies. + +No selected cold replay, full native/caller replay, Lean, Docker, physical +implementation, complete mathematical exclusion, human or proof-kernel review +is claimed. CHECKS.json and the verbatim designated internal peer receipt record +actual committed/export verification separately from inherited premises. + +## Open next questions + +Can a named QQ16 caller accept F17 directly, or provide a global native +continuation that displaces enough old remainder work without repaying it in +restoration, maps or consumption? First publish the exact owner assignment, +chronological field/frame paths and coefficient maps for one complete replica. +Replay them against the selected continuation and reconstruct the entire child +histogram, then price both moments and all physical/transfer charges. Missing +source/owner continuation is the blocker. A rank count alone does not reopen +construction expansion. + +Nick Petalas, Apache-2.0. Credit Ali Romman and the retained QQ16/native team; +ywz65/PR2707 for the line-normalized decoder; Arham Tahir/PR2681 for its inverse +and retained predecessor; Nick Petalas/PR2678 for the separate-field tariff; +Douglas Colkitt for the packing/coverage planning tool; Rohan Arun/PR1094, +Jeremy Kothe, Hao Yan and the selected compiler/geometry/owner lineage. Frozen +sources remain unchanged. Internal computational checking is distinct from +independent human or proof-kernel review. diff --git a/research/qq16-separate-consumer-budget/RESULT.json b/research/qq16-separate-consumer-budget/RESULT.json new file mode 100644 index 0000000000..4169756245 --- /dev/null +++ b/research/qq16-separate-consumer-budget/RESULT.json @@ -0,0 +1,135 @@ +{ + "status": "PASS_QQ16_SEPARATE_CONSUMER_ADMISSION_GAP_NO_NEW_KAPPA", + "baseline": { + "kappa": "836330098538459/500000000000000000", + "complex_a": "67018507072324140917/40000000000000000000000", + "bit_a": "1733427039589844234749/1000000000000000000000000", + "profile": { + "1": 349604, + "2": 60192, + "3": 62585, + "4": 20448, + "5": 11808, + "7": 7, + "8": 1152, + "48": 4866 + }, + "live_families": 14336, + "calls": 144, + "replicas": 16 + }, + "core_profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82 + }, + "core_mass_per_call": 5522, + "producer_added_events": { + "retained_core": 9, + "scalar": 9928, + "native_line": 136, + "cover_map": 3264 + }, + "decoder_events": { + "clear": 312, + "add": 2704, + "line": 336, + "map": 464, + "begin": 3, + "end": 3, + "checkpoint": 1 + }, + "one_decoder_optimistic_delta": { + "1": 472, + "8": -72 + }, + "conditional_unchanged_idle_before_adapter": { + "paid_mass": 64984, + "parent_mass": 65408, + "mass_margin": 424, + "moment_at_zero": "8123/8176", + "conditional_fixed_credit_rejects_all_a_ge_zero": false, + "hypothetical_credit": 0, + "necessary_integer_credit_for_strict_mass_gate": 0 + }, + "conditional_unchanged_idle_endpoints": { + "common_FL": { + "adapter_profile": { + "8": 224 + }, + "adapter_mass": 1792, + "paid_mass": 66776, + "parent_mass": 65408, + "mass_margin": -1368, + "moment_at_zero": "8347/8176", + "conditional_fixed_credit_rejects_all_a_ge_zero": true, + "hypothetical_credit": 0, + "necessary_integer_credit_for_strict_mass_gate": 1369 + }, + "F0_gauges": { + "adapter_profile": { + "8": 112, + "9": 112 + }, + "adapter_mass": 1904, + "paid_mass": 66888, + "parent_mass": 65408, + "mass_margin": -1480, + "moment_at_zero": "8361/8176", + "conditional_fixed_credit_rejects_all_a_ge_zero": true, + "hypothetical_credit": 0, + "necessary_integer_credit_for_strict_mass_gate": 1481 + }, + "entry_gauges": { + "adapter_profile": { + "16": 112, + "17": 112 + }, + "adapter_mass": 3696, + "paid_mass": 68680, + "parent_mass": 65408, + "mass_margin": -3272, + "moment_at_zero": "8585/8176", + "conditional_fixed_credit_rejects_all_a_ge_zero": true, + "hypothetical_credit": 0, + "necessary_integer_credit_for_strict_mass_gate": 3273 + } + }, + "free_producer_decoder_common_FL": { + "paid_mass": 66304, + "parent_mass": 65408, + "mass_margin": -896, + "moment_at_zero": "74/73", + "conditional_fixed_credit_rejects_all_a_ge_zero": true, + "hypothetical_credit": 0, + "necessary_integer_credit_for_strict_mass_gate": 897 + }, + "mass_gate_boundary_controls": { + "equality": { + "paid_mass": 65408, + "parent_mass": 65408, + "mass_margin": 0, + "moment_at_zero": "1", + "conditional_fixed_credit_rejects_all_a_ge_zero": true, + "hypothetical_credit": 1368, + "necessary_integer_credit_for_strict_mass_gate": 1369 + }, + "strict_mass_only": { + "paid_mass": 65407, + "parent_mass": 65408, + "mass_margin": 1, + "moment_at_zero": "65407/65408", + "conditional_fixed_credit_rejects_all_a_ge_zero": false, + "hypothetical_credit": 1369, + "necessary_integer_credit_for_strict_mass_gate": 1369 + } + }, + "actual_idle_credit": null, + "actual_complete_moment": null, + "global_obstruction_proved": false, + "global_closure": "unknown; one decoder and all first-pair cut availability granted", + "physical_bill": "unknown; no actual source/owner continuation or displaced-idle receipt", + "kappa_status": "no new kappa; actual admissible a interval unknown" +} diff --git a/research/qq16-separate-consumer-budget/SOURCES.json b/research/qq16-separate-consumer-budget/SOURCES.json new file mode 100644 index 0000000000..68395858a3 --- /dev/null +++ b/research/qq16-separate-consumer-budget/SOURCES.json @@ -0,0 +1,66 @@ +{ + "schema_version": 1, + "base_commit": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "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/community-frontier1094-audit/ASSEMBLY.json", + "usage": "input", + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "research/community-frontier1094-audit/INDEPENDENT1094.json", + "usage": "input", + "git_blob": "009a385e26858058a18188364078d162aa6f9519", + "sha256": "301fb8a0e4ab7e3c383ff974c54c08178283b2a3453c5282757f692a3c7a4bfd" + }, + { + "path": "research/complex-local-word-ceiling/README.md", + "usage": "input", + "git_blob": "f5f742f8196da29d2c3f4dffb3c27685ca9401f6", + "sha256": "b60be039cb0e03e064a27407d0bce9e58908d793da5ee405c876de5aebfa5f81" + }, + { + "path": "research/joint-query/certificate.json.gz", + "usage": "input", + "git_blob": "c6e876d8b48d768214deee265ade428f8983b566", + "sha256": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7" + }, + { + "path": "research/qq16-entry-frame-tariff/README.md", + "usage": "input", + "git_blob": "c53ee2870d1f8f92be80502b342a941fdbfefa2f", + "sha256": "cb0e658cfbdd3fb74a43b195665d3b13d5eb8e74294831daa05165128ad9ef5d" + }, + { + "path": "research/qq16-entry-frame-tariff/RESULT.json", + "usage": "input", + "git_blob": "157d3a854f75dacb84556f53f7b259d99b25171b", + "sha256": "e562d8096502aa8b60af77dc648ee4bfd22c21ab843907442e2be84979e166be" + }, + { + "path": "research/qq16-line-normalized-decoder/README.md", + "usage": "input", + "git_blob": "e2032842955492d3765d9d8f99c1bead1ba17ae4", + "sha256": "017bb0a0ec15a5c5df446f721e9e68d4eeffac8bfe6fab2a4016a6dc0a666f14" + }, + { + "path": "research/qq16-line-normalized-decoder/WORD.json", + "usage": "input", + "git_blob": "e45320dcb07ef2dc89622e9ca68adfe826a6e9dd", + "sha256": "5623b9cd62635d47f84e78135d817cfddec7ae31c154c565bf6e16cf5ed75475" + } + ] +} diff --git a/research/qq16-separate-consumer-budget/TASK.json b/research/qq16-separate-consumer-budget/TASK.json new file mode 100644 index 0000000000..c8a8311a44 --- /dev/null +++ b/research/qq16-separate-consumer-budget/TASK.json @@ -0,0 +1,79 @@ +{ + "schema_version": 1, + "task_id": "joint-query-controller", + "priority_revision": 6, + "base_commit": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "original_card": { + "id": "joint-query-controller", + "question": "Can a literal QQ16 producer meet the proposed completed-output error budgets with dirty helpers and an affordable physical consumer?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/joint-query/README.md", + "research/joint-query/evidence/QQ16-SELECTED-WITNESS.md", + "research/joint-query/evidence/JOINT-QUERY-TRANSFER.md", + "docs/research/community-efficient1000-review.md", + "research/qq16-producer-defect-transfer/README.md" + ], + "methods": [ + "Derive one literal producer's completed-output defects and intermediate dirty-helper bounds, with its physical bill.", + "Design or audit one consumer, retention or hosting boundary and its complete cost for the pinned producer/decoder." + ], + "acceptance_gate": "Name the changed premise of the fixed F0/B1 observation obstruction. Show exactly which query is recovered, legal native reads and restoration, and a full favorable budget including cover maps, helpers and endpoints. Local inverse identities alone do not close the global controller. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the revision-6 family record and #2965 producer-defect transfer after the local QQ16 decoder contract. Its author-checked output-error estimate does not implement producer interiors, bound dirty helpers, or pay for the consumer; independently check the implication used.", + "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission." + }, + "first_experiment": "Pin one literal F0/B1 producer and its native-child contracts; derive the actual intermediate magnitude ledger and completed-output defects, including dirty helpers and correlations. Compare with #2965 budgets and price storage, movement, cleanup and F17 consumption. Stop with a precise missing bound if no producer contract supplies it; do not optimize another decoder precision constant in isolation.", + "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.", + "allowed_variations": [ + "One paid query, one changed first pair, or one precisely specified affine helper state.", + "A counterexample or lower bound for that exact proposed repair.", + "One unresolved obligation of a newer local decoder, with exact source heads and a distinct claim/domain." + ], + "scope_change_triggers": [ + "Retaining the fixed first pair and ordinary schedule while allowing only homogeneous selected-only control, already excluded by the witness.", + "Treating cover-map counts as zero-cost physical address operations.", + "Recreating the pending complete local decoder or early-record/output-bank coalescing already under investigation without a distinct audit or changed premise.", + "Treating a completed-output defect inequality as a producer-interior, dirty-range or physical-cost certificate." + ], + "overlap_terms": [ + "QQ16", + "joint-query", + "changing-chart controller", + "selected observation", + "1969", + "2540", + "early record", + "output-bank retention", + "complete native decoder", + "2965", + "producer defect", + "dirty-helper range", + "F17 consumer" + ] + }, + "scope_status": "refined", + "actual_scope": "Source-bound QQ16 nine-stage separate-consumer bill screen and exact missing displaced-idle/source-owner continuation obligation", + "scope_change_reason": "No isolated numeric constant: match actual clean-J core, price local producer/decoder and required separate endpoint tariffs, and expose unsupported unchanged-idle additivity before any kappa claim.", + "bottleneck_link": "New frame work may replace old idle remainders; neither occurrence counts nor coverage mass supplies the exact global paid histogram.", + "budget_minutes": 60, + "stop_rule": "Stop after exact source/profile check and conditional budget gate if no global owner/frame continuation exists; no new mechanism or further round.", + "outcome": "partial", + "evidence": "README.md; RESULT.json; literal source recount; test_verify.py; actual committed/export evidence and scoped internal review", + "author": "Nick Petalas", + "open_questions": [ + { + "question": "Can one actual caller provide source/owner continuation and coefficients for displaced idle work, or consume F17 directly?", + "why_it_matters": "The complete paid complex bill is unknown without it.", + "first_step": "Publish one full replica owner assignment and chronological field/frame/coefficient map and reconstruct the resulting histogram.", + "blocked_by": "No such global continuation is supplied by the pinned local producer, decoder or endpoint tariff." + } + ], + "ai_assistance": "Automated analysis and checking; no independent human or proof-kernel approval is claimed." +} diff --git a/research/qq16-separate-consumer-budget/VERIFY.json b/research/qq16-separate-consumer-budget/VERIFY.json new file mode 100644 index 0000000000..c34d2d96c6 --- /dev/null +++ b/research/qq16-separate-consumer-budget/VERIFY.json @@ -0,0 +1,39 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/community-frontier1094-audit/ASSEMBLY.json", + "research/community-frontier1094-audit/INDEPENDENT1094.json", + "research/complex-local-word-ceiling/README.md", + "research/joint-query/certificate.json.gz", + "research/qq16-entry-frame-tariff/README.md", + "research/qq16-entry-frame-tariff/RESULT.json", + "research/qq16-line-normalized-decoder/README.md", + "research/qq16-line-normalized-decoder/WORD.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-Werror", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 30, + "checks": "Authenticate fixed sources, count literal cores/added children, certify conditional mass gates and unknown actual credit" + }, + { + "argv": [ + "{python}", + "-O", + "-Werror", + "-B", + "{package}/test_verify.py" + ], + "timeout_seconds": 120, + "checks": "Strict versus equality gate, numeric schema, changed source profile, Git-free replay and private corruptions" + } + ] +} diff --git a/research/qq16-separate-consumer-budget/test_verify.py b/research/qq16-separate-consumer-budget/test_verify.py new file mode 100644 index 0000000000..3a7863f1f9 --- /dev/null +++ b/research/qq16-separate-consumer-budget/test_verify.py @@ -0,0 +1,107 @@ +#!/usr/bin/env python3 +"""Behavioral controls for the conditional budget and standalone boundary.""" + +import gzip +import importlib.util +import json +import shutil +import subprocess +import sys +import tempfile +import unittest +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +SPEC = importlib.util.spec_from_file_location("budget_check", HERE / "verify.py") +V = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(V) + + +class Controls(unittest.TestCase): + def test_strict_mass_does_not_admit_a_supplier(self): + self.assertEqual(V.budget(1792)["mass_margin"], -1368) + equal = V.budget(1792, credit=1368) + self.assertTrue(equal["conditional_fixed_credit_rejects_all_a_ge_zero"]) + strict = V.budget(1792, credit=1369) + self.assertEqual(strict["mass_margin"], 1) + result = V.report() + self.assertIsNone(result["actual_idle_credit"]) + self.assertIsNone(result["actual_complete_moment"]) + self.assertIs(result["global_obstruction_proved"], False) + + def test_numeric_types_and_source_profile(self): + for invalid in (True, 1.0, -1, 10001): + with self.subTest(invalid=invalid), self.assertRaises(ValueError): + V.budget(invalid) + for value in ({"1": True}, {"1": 1.0}, {"01": 1}, {"73": 1}): + with self.subTest(value=value), self.assertRaises(ValueError): + V.histogram(value) + with self.assertRaises(ValueError): + V.parse('{"x": 1, "x": 2}') + data = V.sources() + source = V.parse(gzip.decompress(data[V.INPUTS[3]])) + for event in source["core_words"]["forward"]: + if event[0] == "climb": + event[5] += 1 + break + with self.assertRaisesRegex(ValueError, "literal clean-J profile"): + V.producer(gzip.compress(json.dumps(source).encode())) + assembly = V.parse(data[V.INPUTS[0]]) + assembly["complex_profile"]["1"] += 1 + with self.assertRaisesRegex(ValueError, "selected profile binding"): + V.selected(assembly, V.parse(data[V.INPUTS[1]])) + + def test_git_free_cli_and_mutants(self): + files = [p for p in HERE.iterdir() if p.is_file()] + self.assertLessEqual(len(files), 20) + with tempfile.TemporaryDirectory(prefix="qq16-budget-controls-") as scratch: + root = Path(scratch) + for source in files + [ROOT / p for p in V.INPUTS]: + target = root / source.relative_to(ROOT) + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(source, target) + script = root / HERE.relative_to(ROOT) / "verify.py" + result = self.run_cli(script) + self.assertEqual(result.returncode, 0, result.stderr) + mutations = [ + (root / V.INPUTS[7], b"\n", "input hash"), + (script.parent / "SOURCES.json", b"\n", "source manifest binding"), + ] + for path, suffix, marker in mutations: + original = path.read_bytes() + path.write_bytes(original + suffix) + result = self.run_cli(script) + self.assertNotEqual(result.returncode, 0) + self.assertIn(marker, result.stderr) + path.write_bytes(original) + path = script.parent / "SOURCES.json" + original = path.read_bytes() + source = json.loads(original) + source["files"][-1]["usage"] = "provenance" + path.write_text(json.dumps(source)) + outcome = self.run_cli(script) + self.assertNotEqual(outcome.returncode, 0) + self.assertIn("source manifest binding", outcome.stderr) + path.write_bytes(original) + path = script.parent / "RESULT.json" + result = json.loads(path.read_bytes()) + result["global_obstruction_proved"] = 0 + path.write_text(json.dumps(result)) + outcome = self.run_cli(script) + self.assertNotEqual(outcome.returncode, 0) + self.assertIn("typed receipt mismatch", outcome.stderr) + + @staticmethod + def run_cli(script): + return subprocess.run( + [sys.executable, "-I", "-O", "-Werror", "-B", str(script)], + capture_output=True, + text=True, + timeout=20, + check=False, + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/research/qq16-separate-consumer-budget/verify.py b/research/qq16-separate-consumer-budget/verify.py new file mode 100644 index 0000000000..5fcb7179a2 --- /dev/null +++ b/research/qq16-separate-consumer-budget/verify.py @@ -0,0 +1,262 @@ +#!/usr/bin/env python3 +"""Source-bound QQ16 budget gap; unchanged-idle screens are conditional.""" + +import argparse +import gzip +import hashlib +import io +import json +import stat +from collections import Counter +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +MANIFEST_HASH = "11697814cc7d28f23843035cd0dd6167364275249644dfbb8668274c86f4ad93" +PREFIX = "research/" +INPUTS = ( + PREFIX + "community-frontier1094-audit/ASSEMBLY.json", + PREFIX + "community-frontier1094-audit/INDEPENDENT1094.json", + PREFIX + "complex-local-word-ceiling/README.md", + PREFIX + "joint-query/certificate.json.gz", + PREFIX + "qq16-entry-frame-tariff/README.md", + PREFIX + "qq16-entry-frame-tariff/RESULT.json", + PREFIX + "qq16-line-normalized-decoder/README.md", + PREFIX + "qq16-line-normalized-decoder/WORD.json", +) +CASES = ("F_0", "B_1_2", "F_2", "B_3_4", "F_4", "B_5_6", "F_6", "B_7_8", "F_8") +CORE = {1: 2412, 2: 418, 3: 432, 4: 142, 5: 82} + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def pairs(items): + need(len(items) <= 20000, "JSON object capacity") + result = dict(items) + need(len(result) == len(items), "duplicate JSON key") + return result + + +def parse(raw): + return json.loads(raw, object_pairs_hook=pairs) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False) + + +def regular(path, limit=16_000_000): + relative = path.relative_to(ROOT) + current = ROOT + for part in relative.parts: + current = current / part + need(not stat.S_ISLNK(current.lstat().st_mode), "source symlink") + info = path.lstat() + need(stat.S_ISREG(info.st_mode) and info.st_size <= limit, "regular file/capacity") + return path.read_bytes() + + +def sources(): + raw = regular(HERE / "SOURCES.json", 16384) + need(hashlib.sha256(raw).hexdigest() == MANIFEST_HASH, "source manifest binding") + manifest = parse(raw) + need( + type(manifest["schema_version"]) is int and manifest["schema_version"] == 1, + "schema type", + ) + rows = manifest["files"] + expected = dict.fromkeys(INPUTS, "input") + expected.update( + { + "certificates/selected-result.json": "provenance", + "docs/research/agent-task-catalog.json": "provenance", + } + ) + need(len(rows) == len(expected), "source inventory size") + need({r["path"]: r["usage"] for r in rows} == expected, "source usage/inventory") + loaded = {} + for row in rows: + if row["usage"] == "input": + raw = regular(ROOT / row["path"]) + need( + hashlib.sha256(raw).hexdigest() == row["sha256"], + "input hash " + row["path"], + ) + loaded[row["path"]] = raw + return loaded + + +def histogram(value): + need(type(value) is dict and 0 < len(value) <= 73, "histogram shape") + result = {} + for rank, count in value.items(): + need(type(rank) is str and rank.isdecimal(), "rank type") + r = int(rank) + need(0 < r < 73 and str(r) == rank, "rank domain") + need(type(count) is int and count > 0, "count type/domain") + result[r] = count + return result + + +def mass(profile): + return sum(rank * count for rank, count in profile.items()) + + +def producer(raw): + with gzip.GzipFile(fileobj=io.BytesIO(raw)) as stream: + decoded = stream.read(12_000_001) + need(len(decoded) <= 12_000_000, "expanded certificate capacity") + data = parse(decoded) + for side in ("forward", "backward"): + word = data["core_words"][side] + need(len(word) == 25155, "core event count") + profile = Counter(e[5] for e in word if e[0] == "climb") + need(dict(profile) == CORE, "literal clean-J profile") + totals = Counter() + for name in CASES: + word = data["programs"][name] + need(len(word) <= 600, "producer case capacity") + flat = [] + for event in word: + body = event[2] if event[0] in ("cover_sweep", "private_sweep") else [event] + need(len(body) <= 2000, "producer body capacity") + need( + all(e[0] not in ("cover_sweep", "private_sweep") for e in body), + "nested sweep", + ) + flat.extend(body) + need(len(flat) <= 4000, "flattened producer capacity") + count = Counter(e[0] for e in flat) + expected = 8 if name.startswith("F") else 24 + need( + count["native_line"] == expected and count["retained_core"] == 1, + "producer invoice", + ) + totals.update(count) + return dict(totals) + + +def selected(assembly, independent): + profile = histogram(assembly["complex_profile"]) + idle = histogram(independent["owner"]["idle"]) + need( + profile == histogram(independent["owner"]["profile"]), + "selected profile binding", + ) + price = independent["price"] + need(type(price["calls"]) is int and price["calls"] == 144, "call count") + need(type(price["live"]) is int and price["live"] == 14336, "live families") + need(mass(profile) == 72 * 14336 + 64 * 144, "selected coverage law") + local = CORE | {8: 8} + for rank in set(profile) | set(idle) | set(local): + need( + profile.get(rank, 0) - idle.get(rank, 0) == 144 * local.get(rank, 0), + "local/core split", + ) + need(mass(idle) == 16 * 14814, "idle mass per replica") + return { + "kappa": assembly["kappa"], + "complex_a": assembly["complex_lower"], + "bit_a": assembly["bit_lower"], + "profile": assembly["complex_profile"], + "live_families": 14336, + "calls": 144, + "replicas": 16, + } + + +def budget(adapter_mass, added=472, credit=0): + need(type(adapter_mass) is int and 0 <= adapter_mass <= 10000, "adapter mass") + need(type(added) is int and 0 <= added <= 10000, "added mass") + need(type(credit) is int and 0 <= credit <= 14814, "idle mass credit") + total = 72 * 896 + added + adapter_mass - credit + parent = 73 * 896 + return { + "paid_mass": total, + "parent_mass": parent, + "mass_margin": parent - total, + "moment_at_zero": str(Q(total, parent)), + "conditional_fixed_credit_rejects_all_a_ge_zero": total >= parent, + "hypothetical_credit": credit, + "necessary_integer_credit_for_strict_mass_gate": max( + 0, added + adapter_mass - 896 + 1 + ), + } + + +def report(): + loaded = sources() + baseline = selected(parse(loaded[INPUTS[0]]), parse(loaded[INPUTS[1]])) + produced = producer(loaded[INPUTS[3]]) + word = parse(loaded[INPUTS[7]]) + need(type(word) is list and len(word) == 3823, "decoder word shape") + counted = dict(Counter(e[0] for e in word)) + need(counted["line"] == 336 and counted["map"] == 464, "decoder native invoice") + tariff = parse(loaded[INPUTS[5]]) + rows = {} + for label, key, expected in ( + ("common_FL", "common_F_L", 1792), + ("F0_gauges", "F0", 1904), + ("entry_gauges", "entry", 3696), + ): + profile = histogram(tariff[key + "_adapter_histogram"]) + need( + mass(profile) == expected and sum(profile.values()) == 224, "adapter tariff" + ) + rows[label] = { + "adapter_profile": {str(r): n for r, n in profile.items()}, + "adapter_mass": expected, + **budget(expected), + } + need(produced["native_line"] == 136, "nine-stage added lines") + need( + all(row["mass_margin"] < 0 for row in rows.values()), + "expected strict rejection", + ) + return { + "status": "PASS_QQ16_SEPARATE_CONSUMER_ADMISSION_GAP_NO_NEW_KAPPA", + "baseline": baseline, + "core_profile": {str(r): n for r, n in CORE.items()}, + "core_mass_per_call": mass(CORE), + "producer_added_events": produced, + "decoder_events": counted, + "one_decoder_optimistic_delta": {"1": 472, "8": -72}, + "conditional_unchanged_idle_before_adapter": budget(0), + "conditional_unchanged_idle_endpoints": rows, + "free_producer_decoder_common_FL": budget(1792, added=0), + "mass_gate_boundary_controls": { + "equality": budget(1792, credit=1368), + "strict_mass_only": budget(1792, credit=1369), + }, + "actual_idle_credit": None, + "actual_complete_moment": None, + "global_obstruction_proved": False, + "global_closure": ( + "unknown; one decoder and all first-pair cut availability granted" + ), + "physical_bill": ( + "unknown; no actual source/owner continuation or displaced-idle receipt" + ), + "kappa_status": "no new kappa; actual admissible a interval unknown", + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--emit", action="store_true") + args = parser.parse_args() + result = report() + if args.emit: + print(json.dumps(result, indent=2)) + else: + expected = parse(regular(HERE / "RESULT.json", 100000)) + need(canonical(result) == canonical(expected), "typed receipt mismatch") + print(result["status"]) + + +if __name__ == "__main__": + main() From 123079bef40faf6949ebac7dfc2859c715acea80 Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Sat, 17 Oct 2026 23:17:19 +0100 Subject: [PATCH 2/2] docs(research): retain QQ16 review and export receipts --- .../EXPORT-CHECKS.json | 266 ++++++++++++++++++ .../qq16-separate-consumer-budget/REVIEW.json | 155 ++++++++++ 2 files changed, 421 insertions(+) create mode 100644 research/qq16-separate-consumer-budget/EXPORT-CHECKS.json create mode 100644 research/qq16-separate-consumer-budget/REVIEW.json diff --git a/research/qq16-separate-consumer-budget/EXPORT-CHECKS.json b/research/qq16-separate-consumer-budget/EXPORT-CHECKS.json new file mode 100644 index 0000000000..82d4f6ecc7 --- /dev/null +++ b/research/qq16-separate-consumer-budget/EXPORT-CHECKS.json @@ -0,0 +1,266 @@ +{ + "status": "PASS_COMMITTED_READ_ONLY_GIT_FREE_EXPORT", + "at": "2026-10-17T22:15:05.101130+00:00", + "scientific_commit": "989dd10b0555cd4d8afbf5d4dcfad783a9a95e40", + "archive": "/Users/nick/.cache/integer-mult-bounds-runs/worker-3-batch8-20261017T2200Z-48dfc68a/scientific.tar", + "archive_sha256": "48e8e03fee8c0940817ff2c562011c1a33658574ffbc0040c94e059d54877f1f", + "export_root": "/Users/nick/.cache/integer-mult-bounds-runs/worker-3-batch8-20261017T2200Z-48dfc68a/scientific-export", + "regular_only": true, + "inode_disjoint_from_worktree": true, + "read_only": true, + "TMPDIR": "unset", + "registered_argv_scripts_and_documented_direct_scripts": [ + { + "argv": [ + "/Users/nick/.local/share/uv/python/cpython-3.12.15-macos-aarch64-none/bin/python3.12", + "-Werror", + "-B", + "research/qq16-separate-consumer-budget/verify.py" + ], + "returncode": 0, + "log": "/Users/nick/.cache/integer-mult-bounds-runs/worker-3-batch8-20261017T2200Z-48dfc68a/scientific-export-0-0.log", + "stdout": "PASS_QQ16_SEPARATE_CONSUMER_ADMISSION_GAP_NO_NEW_KAPPA", + "stderr": "" + }, + { + "argv": [ + "/Users/nick/.local/share/uv/python/cpython-3.12.15-macos-aarch64-none/bin/python3.12", + "-O", + "-Werror", + "-B", + "research/qq16-separate-consumer-budget/test_verify.py" + ], + "returncode": 0, + "log": "/Users/nick/.cache/integer-mult-bounds-runs/worker-3-batch8-20261017T2200Z-48dfc68a/scientific-export-0-1.log", + "stdout": "", + "stderr": "...\n----------------------------------------------------------------------\nRan 3 tests in 1.243s\n\nOK" + }, + { + "argv": [ + "/Users/nick/.local/share/uv/python/cpython-3.12.15-macos-aarch64-none/bin/python3.12", + "-I", + "-O", + "-Werror", + "-B", + "research/qq16-separate-consumer-budget/verify.py" + ], + "returncode": 0, + "log": "/Users/nick/.cache/integer-mult-bounds-runs/worker-3-batch8-20261017T2200Z-48dfc68a/scientific-export-0-2.log", + "stdout": "PASS_QQ16_SEPARATE_CONSUMER_ADMISSION_GAP_NO_NEW_KAPPA", + "stderr": "" + }, + { + "argv": [ + "/Users/nick/.local/share/uv/python/cpython-3.12.15-macos-aarch64-none/bin/python3.12", + "-I", + "-O", + "-Werror", + "-B", + "research/qq16-separate-consumer-budget/test_verify.py" + ], + "returncode": 0, + "log": "/Users/nick/.cache/integer-mult-bounds-runs/worker-3-batch8-20261017T2200Z-48dfc68a/scientific-export-0-3.log", + "stdout": "", + "stderr": "...\n----------------------------------------------------------------------\nRan 3 tests in 1.118s\n\nOK" + }, + { + "argv": [ + "/opt/homebrew/bin/python3.14", + "-Werror", + "-B", + "research/qq16-separate-consumer-budget/verify.py" + ], + "returncode": 0, + "log": "/Users/nick/.cache/integer-mult-bounds-runs/worker-3-batch8-20261017T2200Z-48dfc68a/scientific-export-1-0.log", + "stdout": "PASS_QQ16_SEPARATE_CONSUMER_ADMISSION_GAP_NO_NEW_KAPPA", + "stderr": "" + }, + { + "argv": [ + "/opt/homebrew/bin/python3.14", + "-O", + "-Werror", + "-B", + "research/qq16-separate-consumer-budget/test_verify.py" + ], + "returncode": 0, + "log": "/Users/nick/.cache/integer-mult-bounds-runs/worker-3-batch8-20261017T2200Z-48dfc68a/scientific-export-1-1.log", + "stdout": "", + "stderr": "...\n----------------------------------------------------------------------\nRan 3 tests in 1.136s\n\nOK" + }, + { + "argv": [ + "/opt/homebrew/bin/python3.14", + "-I", + "-O", + "-Werror", + "-B", + "research/qq16-separate-consumer-budget/verify.py" + ], + "returncode": 0, + "log": "/Users/nick/.cache/integer-mult-bounds-runs/worker-3-batch8-20261017T2200Z-48dfc68a/scientific-export-1-2.log", + "stdout": "PASS_QQ16_SEPARATE_CONSUMER_ADMISSION_GAP_NO_NEW_KAPPA", + "stderr": "" + }, + { + "argv": [ + "/opt/homebrew/bin/python3.14", + "-I", + "-O", + "-Werror", + "-B", + "research/qq16-separate-consumer-budget/test_verify.py" + ], + "returncode": 0, + "log": "/Users/nick/.cache/integer-mult-bounds-runs/worker-3-batch8-20261017T2200Z-48dfc68a/scientific-export-1-3.log", + "stdout": "", + "stderr": "...\n----------------------------------------------------------------------\nRan 3 tests in 1.201s\n\nOK" + } + ], + "files": [ + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "bytes": 85147, + "dev": 16777232, + "ino": 229717767, + "nlink": 1 + }, + { + "path": "research/community-frontier1094-audit/INDEPENDENT1094.json", + "sha256": "301fb8a0e4ab7e3c383ff974c54c08178283b2a3453c5282757f692a3c7a4bfd", + "bytes": 2117, + "dev": 16777232, + "ino": 229717768, + "nlink": 1 + }, + { + "path": "research/complex-local-word-ceiling/README.md", + "sha256": "b60be039cb0e03e064a27407d0bce9e58908d793da5ee405c876de5aebfa5f81", + "bytes": 6462, + "dev": 16777232, + "ino": 229717770, + "nlink": 1 + }, + { + "path": "research/joint-query/certificate.json.gz", + "sha256": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7", + "bytes": 725120, + "dev": 16777232, + "ino": 229717772, + "nlink": 1 + }, + { + "path": "research/qq16-entry-frame-tariff/README.md", + "sha256": "cb0e658cfbdd3fb74a43b195665d3b13d5eb8e74294831daa05165128ad9ef5d", + "bytes": 11237, + "dev": 16777232, + "ino": 229717774, + "nlink": 1 + }, + { + "path": "research/qq16-entry-frame-tariff/RESULT.json", + "sha256": "e562d8096502aa8b60af77dc648ee4bfd22c21ab843907442e2be84979e166be", + "bytes": 133300, + "dev": 16777232, + "ino": 229717775, + "nlink": 1 + }, + { + "path": "research/qq16-line-normalized-decoder/README.md", + "sha256": "017bb0a0ec15a5c5df446f721e9e68d4eeffac8bfe6fab2a4016a6dc0a666f14", + "bytes": 6308, + "dev": 16777232, + "ino": 229717777, + "nlink": 1 + }, + { + "path": "research/qq16-line-normalized-decoder/WORD.json", + "sha256": "5623b9cd62635d47f84e78135d817cfddec7ae31c154c565bf6e16cf5ed75475", + "bytes": 115055, + "dev": 16777232, + "ino": 229717778, + "nlink": 1 + }, + { + "path": "research/qq16-separate-consumer-budget/CHECKS.json", + "sha256": "cdb35786d6ddf9bc35343fe8407b27f1b6e47304bb6a29c32bd2e85fb05b6782", + "bytes": 2859, + "dev": 16777232, + "ino": 229717780, + "nlink": 1 + }, + { + "path": "research/qq16-separate-consumer-budget/ENGINEERING.md", + "sha256": "6ed56f925a5693775c9da433b073126556d4e2037590d6fc86943eb8c2c44363", + "bytes": 2727, + "dev": 16777232, + "ino": 229717781, + "nlink": 1 + }, + { + "path": "research/qq16-separate-consumer-budget/README.md", + "sha256": "06bca43ecfa8e0d57e1866d084b9b23708506a8bedf6b598c4adb78df328ccec", + "bytes": 9440, + "dev": 16777232, + "ino": 229717782, + "nlink": 1 + }, + { + "path": "research/qq16-separate-consumer-budget/RESULT.json", + "sha256": "a60d2941254460173437f2aaf7bcc788ffed5a7f86652ed05e094b01cdd9c883", + "bytes": 3790, + "dev": 16777232, + "ino": 229717783, + "nlink": 1 + }, + { + "path": "research/qq16-separate-consumer-budget/SOURCES.json", + "sha256": "11697814cc7d28f23843035cd0dd6167364275249644dfbb8668274c86f4ad93", + "bytes": 2558, + "dev": 16777232, + "ino": 229717784, + "nlink": 1 + }, + { + "path": "research/qq16-separate-consumer-budget/TASK.json", + "sha256": "4eb6d0449107cd772171f74db9e852324d12f6680ff6ba6d153b61494ffac842", + "bytes": 5610, + "dev": 16777232, + "ino": 229717785, + "nlink": 1 + }, + { + "path": "research/qq16-separate-consumer-budget/VERIFY.json", + "sha256": "18bd92769034f2a43e508a0b8d3626cf56c13c161014dc958c06ed2764bd707c", + "bytes": 1151, + "dev": 16777232, + "ino": 229717786, + "nlink": 1 + }, + { + "path": "research/qq16-separate-consumer-budget/test_verify.py", + "sha256": "a28bc7d6e09aa694f8023fc34c87d03478bae761280a5354752dd387d927bdd7", + "bytes": 4458, + "dev": 16777232, + "ino": 229717787, + "nlink": 1 + }, + { + "path": "research/qq16-separate-consumer-budget/verify.py", + "sha256": "021a59eb550955a4725186a8d6175bcac869ed927d3ae9b86f97ecf1764db388", + "bytes": 9278, + "dev": 16777232, + "ino": 229717788, + "nlink": 1 + }, + { + "path": ".research-export.json", + "sha256": "201eb8385f5fd5f622b4a92842ea551a9cb1af3d8ac5065f7db500e1e55716cb", + "bytes": 3607, + "dev": 16777232, + "ino": 229717789, + "nlink": 1 + } + ] +} diff --git a/research/qq16-separate-consumer-budget/REVIEW.json b/research/qq16-separate-consumer-budget/REVIEW.json new file mode 100644 index 0000000000..283d191c4e --- /dev/null +++ b/research/qq16-separate-consumer-budget/REVIEW.json @@ -0,0 +1,155 @@ +{ + "reviewer_worker": 5, + "reviewer_thread": "mcp:f5cebd99-100e-4643-a203-7c26351a2640", + "reviewee_worker": 3, + "reviewee_thread": "mcp:48dfc68a-dd1e-4cae-963f-bdfa1000aaea", + "scientific_commit": "989dd10b0555cd4d8afbf5d4dcfad783a9a95e40", + "base": "6f100d4bb5083f8c35d96fd95a539811c62f245c", + "result": "PASS_SCOPED_REVIEW_NO_BLOCKING_FINDINGS", + "scope": "Source-bound occurrence ledger, conditional unchanged-idle mass screens, and actual QQ16 admission gap only. No complete physical bill, global obstruction or new kappa.", + "standards_findings": [], + "spec_math_findings": [], + "standards": "All17 committed source/input files plus export manifest are regular single-link private copies. Actual committed Git bytes match. Parsed exact source manifest binds eight runtime inputs; canonical JSON receipt distinguishes bool/int. Bounded explicit exception checks and optimized CLI controls pass. Functions <=60 lines. Frozen dependencies/shared files unchanged. User no-extra-agent rule applied; both standards/spec axes reviewed locally.", + "mathematics": "Independently recounted selected profile minus idle divided by144 = {1:2412,2:418,3:432,4:142,5:82,8:8}; idle14814/replica. Both literal cores omit exactly8H8 and have5522 mass. Verified9*5522+14814=64512. Producer136H1 plus decoder336H1 and separate adapter masses1792/1904/3696 give66776/66888/68680 versus65408 only when C=0 and unchanged cores/other charges. For0=0 moment term >=r/73, so these conditional mass failures suffice. C1368 yields equality; C1369 only one zero-saving mass unit, never supplier acceptance. Actual idle credit, histogram, ownership, coefficients, restoration, precision and complete moment remain explicitly unknown.", + "tariff_applicability": "Read actual predecessor tariff proof/model and PR2707 output contract in frozen inputs. Tariff applies only separate per-field affine/convolution conversion, inherited and not rerun here. Fixed F17 endpoint224 owned outputs confirmed. Fusion/direct F17 consumer, shared children and broader wrappers unexcluded. Nine-stage sufficiency of one decoder and cut availability are favorable grants only.", + "correction_trail": { + "initial_result_sha256": "1e2cbd5946afe2e956eb4fee217a19e976a0fb3dc733aaea382898b9eddbd41a", + "decisions_tsv_sha256": "9c548107adc37ca0a4d7e1934aa8e425a539582aea52366aa9e38446f137839e", + "finding": "Initial unconditional additive rejection withdrawn before scientific commit; final README/code/receipt consistently conditional and actual credit unknown." + }, + "file_sha256": [ + { + "path": "research/complex-local-word-ceiling/README.md", + "bytes": 6462, + "sha256": "b60be039cb0e03e064a27407d0bce9e58908d793da5ee405c876de5aebfa5f81" + }, + { + "path": "research/qq16-entry-frame-tariff/RESULT.json", + "bytes": 133300, + "sha256": "e562d8096502aa8b60af77dc648ee4bfd22c21ab843907442e2be84979e166be" + }, + { + "path": "research/qq16-entry-frame-tariff/README.md", + "bytes": 11237, + "sha256": "cb0e658cfbdd3fb74a43b195665d3b13d5eb8e74294831daa05165128ad9ef5d" + }, + { + "path": "research/qq16-line-normalized-decoder/README.md", + "bytes": 6308, + "sha256": "017bb0a0ec15a5c5df446f721e9e68d4eeffac8bfe6fab2a4016a6dc0a666f14" + }, + { + "path": "research/qq16-line-normalized-decoder/WORD.json", + "bytes": 115055, + "sha256": "5623b9cd62635d47f84e78135d817cfddec7ae31c154c565bf6e16cf5ed75475" + }, + { + "path": "research/qq16-separate-consumer-budget/SOURCES.json", + "bytes": 2558, + "sha256": "11697814cc7d28f23843035cd0dd6167364275249644dfbb8668274c86f4ad93" + }, + { + "path": "research/qq16-separate-consumer-budget/ENGINEERING.md", + "bytes": 2727, + "sha256": "6ed56f925a5693775c9da433b073126556d4e2037590d6fc86943eb8c2c44363" + }, + { + "path": "research/qq16-separate-consumer-budget/VERIFY.json", + "bytes": 1151, + "sha256": "18bd92769034f2a43e508a0b8d3626cf56c13c161014dc958c06ed2764bd707c" + }, + { + "path": "research/qq16-separate-consumer-budget/RESULT.json", + "bytes": 3790, + "sha256": "a60d2941254460173437f2aaf7bcc788ffed5a7f86652ed05e094b01cdd9c883" + }, + { + "path": "research/qq16-separate-consumer-budget/test_verify.py", + "bytes": 4458, + "sha256": "a28bc7d6e09aa694f8023fc34c87d03478bae761280a5354752dd387d927bdd7" + }, + { + "path": "research/qq16-separate-consumer-budget/TASK.json", + "bytes": 5610, + "sha256": "4eb6d0449107cd772171f74db9e852324d12f6680ff6ba6d153b61494ffac842" + }, + { + "path": "research/qq16-separate-consumer-budget/CHECKS.json", + "bytes": 2859, + "sha256": "cdb35786d6ddf9bc35343fe8407b27f1b6e47304bb6a29c32bd2e85fb05b6782" + }, + { + "path": "research/qq16-separate-consumer-budget/README.md", + "bytes": 9440, + "sha256": "06bca43ecfa8e0d57e1866d084b9b23708506a8bedf6b598c4adb78df328ccec" + }, + { + "path": "research/qq16-separate-consumer-budget/verify.py", + "bytes": 9278, + "sha256": "021a59eb550955a4725186a8d6175bcac869ed927d3ae9b86f97ecf1764db388" + }, + { + "path": "research/joint-query/certificate.json.gz", + "bytes": 725120, + "sha256": "a5ed85fac5ebf3c091482a113ab0d351eb5a7892fe2841a35e16017ec1ff49f7" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "bytes": 85147, + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "research/community-frontier1094-audit/INDEPENDENT1094.json", + "bytes": 2117, + "sha256": "301fb8a0e4ab7e3c383ff974c54c08178283b2a3453c5282757f692a3c7a4bfd" + } + ], + "archive_sha256": "48e8e03fee8c0940817ff2c562011c1a33658574ffbc0040c94e059d54877f1f", + "full_diff_sha256": "0032b8f2c5ccb7737ee16c583701444cfacff6a29111259576a03b11d58aafdc", + "actual_commands": [ + { + "command": [ + "/Users/nick/.local/share/uv/python/cpython-3.12-macos-aarch64-none/bin/python3.12", + "-Werror", + "-B", + "/Users/nick/.cache/integer-mult-bounds-runs/worker-5-batch8-20261017T2200Z-f5cebd99/peer-worker3/export/research/qq16-separate-consumer-budget/verify.py" + ], + "exit": 0, + "stdout_sha256": "0acdcd512f7f76a322fd745286e3581542faaf6e92e4205be07f12d022144d53", + "log_sha256": "0acdcd512f7f76a322fd745286e3581542faaf6e92e4205be07f12d022144d53" + }, + { + "command": [ + "/Users/nick/.local/share/uv/python/cpython-3.12-macos-aarch64-none/bin/python3.12", + "-O", + "-Werror", + "-B", + "/Users/nick/.cache/integer-mult-bounds-runs/worker-5-batch8-20261017T2200Z-f5cebd99/peer-worker3/export/research/qq16-separate-consumer-budget/test_verify.py" + ], + "exit": 0, + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "log_sha256": "4d95840b906c234391a30c1da0ff4105de5850021f5b4360646c3ca062388d44" + }, + { + "command": [ + "/opt/homebrew/opt/python@3.15/bin/python3.15", + "-I", + "-O", + "-Werror", + "-B", + "/Users/nick/.cache/integer-mult-bounds-runs/worker-5-batch8-20261017T2200Z-f5cebd99/peer-worker3/export/research/qq16-separate-consumer-budget/verify.py" + ], + "exit": 0, + "stdout_sha256": "0acdcd512f7f76a322fd745286e3581542faaf6e92e4205be07f12d022144d53", + "log_sha256": "0acdcd512f7f76a322fd745286e3581542faaf6e92e4205be07f12d022144d53" + } + ], + "independent_arithmetic_receipt": "/Users/nick/.cache/integer-mult-bounds-runs/worker-5-batch8-20261017T2200Z-f5cebd99/peer-worker3/independent-arithmetic.json", + "limits": [ + "No selected cold/heavy, native or owner/controller replay", + "No reproof of predecessor separate-field tariff, compiler/all-size, precision or outer assumptions", + "No actual displaced-idle construction or full moment; no positive saving certified", + "No human or proof-kernel certification" + ], + "at": "2026-10-17T22:16:48.734167+00:00" +}