From c1187a843403000cb6591f1fb4914f509be96d3e Mon Sep 17 00:00:00 2001 From: Figo Lam Date: Tue, 27 Oct 2026 11:11:40 +0000 Subject: [PATCH 1/2] Audit selected MOVE phase coverage and physical handoff --- .../selected-move-phase-coverage/README.md | 81 +++++++++ .../selected-move-phase-coverage/RESULT.json | 71 ++++++++ .../selected-move-phase-coverage/SOURCES.json | 72 ++++++++ .../selected-move-phase-coverage/TASK.json | 83 +++++++++ .../VALIDATION.md | 52 ++++++ .../selected-move-phase-coverage/VERIFY.json | 44 +++++ .../selected-move-phase-coverage/verify.py | 166 ++++++++++++++++++ 7 files changed, 569 insertions(+) create mode 100644 research/selected-move-phase-coverage/README.md create mode 100644 research/selected-move-phase-coverage/RESULT.json create mode 100644 research/selected-move-phase-coverage/SOURCES.json create mode 100644 research/selected-move-phase-coverage/TASK.json create mode 100644 research/selected-move-phase-coverage/VALIDATION.md create mode 100644 research/selected-move-phase-coverage/VERIFY.json create mode 100644 research/selected-move-phase-coverage/verify.py diff --git a/research/selected-move-phase-coverage/README.md b/research/selected-move-phase-coverage/README.md new file mode 100644 index 0000000000..c72dc3a070 --- /dev/null +++ b/research/selected-move-phase-coverage/README.md @@ -0,0 +1,81 @@ +# Selected MOVE phase coverage: a corrected handoff + +**Source-coverage finding with one independent finite operator check; no new κ.** The selected #5599 checker already compares both signed Pauli conjugations and the exact image of `|0>` for every distinct local MOVE pair. The latter fixes absolute phase. Its registered path covers all 3,447 MOVE occurrences (2,887 distinct ordered pairs, including 11 owned occurrences). These are inventory counts, not 3,447 newly replayed operators. + +The added value is a correction to the proposed next task in [#5837](https://github.com/CrocSwap/integer-mult-bounds/pull/5837), head `764e7bd6d615d92019445bec92e2a473af021878`. Its [README](https://github.com/unpaidmoon/integer-mult-bounds/blob/764e7bd6d615d92019445bec92e2a473af021878/research/native-scalar-chart-lift/README.md) says the selected native checker “only compares width-1 signed Pauli recipes” and proposes an absolute-phase group-identity census. The existing checker includes that phase comparison. A fresh census should be justified as independent verification of existing coverage, rather than a newly missing algebraic implication. The predecessor's scalar proposition is unaffected, and its physical tape limitation is valid. + +Scientific base: canonical main `de5ec2e7a6074068452f45b1a191b5c72832df4a`, priority revision 8. Selected source: #5599, `09dd0965711ca7eeb169057a420abab1c9052137`. Exact bytes are in [SOURCES.json](SOURCES.json). The four execution-chain files below are unchanged between those commits. [TASK.json](TASK.json) records the refined `uniform-transfer-audit` scope. The canonical public context is [the #5837 handoff](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19209962). + +## Existing coverage, traced to its entry point + +All source links below resolve in the pinned base tree; these are source-inspection findings, not a new execution of the full selected suite. + +| Source | What it already does | +| --- | --- | +| [VERIFY.json](../p104-helper-subspace-splits/VERIFY.json) | Registers normal and optimized `verify.py`, including native maps. | +| [verify.py](../p104-helper-subspace-splits/verify.py), `run` and `main` | Authenticates inputs, reconstructs the split word, runs `L.replay(word)` and `L.native(word)`, then structurally compares both reconstructed WORD and RESULT to saved artifacts unless `--write` is explicit. | +| [local.py](../p104-helper-subspace-splits/local.py), `replay` | Checks every MOVE's current source chart, ownership, nesting and paid rank. | +| [local.py](../p104-helper-subspace-splits/local.py), `native` | Traverses every MOVE without a public/private exclusion; caches only repeated ordered frame pairs. Lowers `chart(a).adjoint().then(chart(b))`, checks the independent chart circuit and rank, and separately covers helper endpoints and main adapters. | +| [native_verify.py](../p104-native-channel/vendor/native_verify.py), `equal` | Requires both `tableau(actual) == tableau(expected)` and `state(actual) == state(expected)`. `state` uses exact Gaussian integer pairs and a dyadic denominator, including global phase. | +| `local.native`, wrong-phase control | Increments the first recipe's left phase modulo four and requires rejection. | + +The source circuit order means “execute the old chart's adjoint, then the new chart.” For column vectors the resulting matrix is `C_b C_a^{-1}`. This note does not invert that order. + +The [selected proof](../p104-helper-subspace-splits/PROOF.md) already invokes exact phases and all-width frame induction. The [maintainer review](../../docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md) explicitly records signed-Pauli and absolute-phase checks while retaining universal native implementation as an assumption. Its prior complete replay is inherited evidence; it was not rerun here. + +## Why this is exact matrix equality, and what lifts + +Let `U,V` be invertible operators on `n` binary axes with equal signed conjugations of every `X_j,Z_j`. Then `W = V^{-1}U` commutes with those generators. Commutation with all `Z_j` forces `W` to be diagonal in the computational basis, since different bit strings have different joint eigenvalues. Commutation with each `X_j` equates diagonal entries along every edge of the connected Boolean cube. Hence `W = cI`. Exact equality `U|0> = V|0>` forces `c=1`, because `V|0>` is nonzero. Thus `U=V`, including absolute phase. + +Consequently `U^(tensor f) = V^(tensor f)` for every integer `f>=1`. The mixed-product identity also gives `(AB)^(tensor f) = A^(tensor f) B^(tensor f)`, so products and inverses lift gatewise. This elementary implication is already part of [Matarener's #5442 argument](../allwidth-caller-certificate/PROOF.md); no new theorem priority is claimed and its converse/Burnside argument is not needed here. + +The premise is the declared width-`f` tensor semantics of the operators. Tensor power is not additive: a width-one linear relation among distinct operators need not lift with fixed external coefficients. Scalar ADD/SCALE coefficients remain outside tensor powers. A central phase that belongs to a native operator remains inside them. This distinction is why the phase check matters, but it does not supply a physical arbitrary-width executor. + +## New bounded evidence: the actual first MOVE + +Zero-based event 9589 is `["MOVE",224,3,0,false]`, from frame `[]` to `[11]`. Independently of the retained `state` and `tableau` equality routines, [verify.py](verify.py) compares all 512 basis columns of its lowered rank-one recipe with + +```text +U = ((1+i) I + (1-i) X_11 Z_3)/2, +X_11 |x> = |x xor 11>, Z_3 |x> = (-1)^(x_0+x_1) |x>. +``` + +Bits are numbered from zero. The canonical basis completion has columns `(11,1,2,4,16,32,64,128,256)`. Its diagonal form is `q(x)=2*x_3*(x_0+x_1) mod 4`. With `K=D_q P_G`, the frame is `K C_1 K^{-1}`. Conjugating the nontrivial branch gives `P_G X_1 P_G^{-1}=X_11` and `q(x xor 11)-q(x)=2*(x_0+x_1) mod 4`, proving the displayed formula. Bits 0, 1 and 3 are active; all six untouched bits are included in the exhaustive columns. + +The independent recipe evaluator applies its two monomial records directly and adds the two Gaussian numerators over denominator two. The compiler supplies only the candidate recipe; neither its own state evaluator nor the retained interpreter decides the new equality verdict. + +All 512 columns match. Incrementing `left.phase` by one changes every column to exactly `iU`; toggling `left.offset` bit zero changes every column and is separately detected. Only after that independent verdict, the retained checker is called diagnostically: the original passes; the phase mutant has the same signed tableau and fails specifically with `phase-only control: exact global phase`. At the origin: + +| Address | Original numerator / 2 | Phase mutant numerator / 2 | +| --- | --- | --- | +| 0 | `1+i` | `-1+i` | +| 11 | `1-i` | `1+i` | + +[RESULT.json](RESULT.json) is the generated exact receipt. All 3,447 occurrences are counted, but **only this one ordered pair is newly executed**. The general all-width consequence is the written argument, not a finite width sweep. + +## Reproduce + +CPython 3.12, standard library only, from the repository root: + +```sh +python3 -I -W error -B research/selected-move-phase-coverage/verify.py +python3 -I -O -W error -B research/selected-move-phase-coverage/verify.py +python3 -B scripts/research_package.py --package research/selected-move-phase-coverage +python3 -B scripts/check_research_commit.py --package research/selected-move-phase-coverage --check-source-history +``` + +The direct verifier is read-only and works in the official Git-free export. It authenticates every live source before import and isolates import bytecode caches. Expected status is `PASS_INDEPENDENT_FIRST_MOVE_CLOSED_FORM`; normal and optimized receipts agree. [VALIDATION.md](VALIDATION.md) records actual commands/results, internal review and unrun obligations. A source-integrity pass is not a mathematical proof. + +## Open next questions + +The remaining useful task is physical: bind this same rank-one recipe to an actual arbitrary-width owner/tape interface. Specify the complete input vector, spectators, entry/exit layout and head positions, both monomial normalizers, the rank-one child, owned/borrowed scratch and restoration. Prove that the literal address/phase operations realize its tensor power for every permitted `f`, and attach every preparation, movement, normalization and return charge to the actual caller tariff. Start with this event and its dynamically lowered recipe; stop at the first missing head map, primitive contract or cost inequality. Another width-one group census does not fill that gap. + +The current `native` function synthesizes recipes during verification and saves counts plus a recipe-payload hash; it does not emit an arbitrary-width tape program. The older [selected-monomial-tape-lift](../selected-monomial-tape-lift/README.md) and [selected-control-reservations](../selected-control-reservations/README.md) concern #5413's 145-axis caller and provide relevant record/address contracts, not automatic admission of #5599's changed caller. Exact source/layout compatibility must be proved before reuse. No implementation expansion is undertaken or reserved here. + +All five selected framework assumptions remain. No full native census, selected cold replay, complete body/controller proof, cost improvement, rounded multiplier, Lean check or physical implementation is claimed. The shared compiler supplies the tested recipe; the closed-form oracle is independent of both state engines but shares the documented monomial grammar. The general checker implementation is not formally verified. + +## Credit and review status + +Prepared for **DLamdata**, with substantial **OpenAI Codex assistance**, including two native agents for independent mathematical checking and skeptical source review. This is internal AI review, not independent human or proof-kernel review. Apache-2.0. + +Credit unpaidmoon for #5837 and the precise follow-up question; Ali Romman for #5599 and the source verification path; Pierre-Loic Doulcet / hexapode for #5565; Mark / Matarener for #5442 and the algebraic/physical distinction; Chris R / Clear1nsight for independent caller/native verification; and Dugongue, icekylinx, David Arias, Cinna Davis, Gareth Davidson, Cao Yifan, zxv, Jacob Alan Sussman and the retained Clifford/controller/compiler lineage. Frozen predecessor files and the selected frontier are unchanged. diff --git a/research/selected-move-phase-coverage/RESULT.json b/research/selected-move-phase-coverage/RESULT.json new file mode 100644 index 0000000000..83b805e66b --- /dev/null +++ b/research/selected-move-phase-coverage/RESULT.json @@ -0,0 +1,71 @@ +{ + "status": "PASS_INDEPENDENT_FIRST_MOVE_CLOSED_FORM", + "base": "de5ec2e7a6074068452f45b1a191b5c72832df4a", + "word_sha256": "bbb072bced5824a8d9094c49be2fc51fbfdd05fb2b7dab8106e1275053075099", + "producer_sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "checker_sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38", + "event_index_zero_based": 9589, + "event": [ + "MOVE", + 224, + 3, + 0, + false + ], + "domain": "all 512 width-one basis columns of the first actual MOVE", + "closed_form": "((1+i)I + (1-i)X_11 Z_3)/2", + "columns_checked": 512, + "phase_fault_columns_detected": 512, + "address_fault_columns_detected": 512, + "move_occurrences_counted": 3447, + "distinct_move_pairs_counted": 2887, + "owned_move_occurrences_counted": 11, + "newly_replayed_move_pairs": 1, + "mutant_relation": "i times original operator", + "source_signed_tableau_unchanged": true, + "source_rejection": "phase-only control: exact global phase", + "origin_column_numerators_over_2": [ + [ + 0, + [ + 1, + 1 + ] + ], + [ + 11, + [ + 1, + -1 + ] + ] + ], + "mutant_origin_column_numerators_over_2": [ + [ + 0, + [ + -1, + 1 + ] + ], + [ + 11, + [ + 1, + 1 + ] + ] + ], + "new_checker_dependencies": "standard library; source compiler produces fixture; independent direct column formula decides equality before retained verifier diagnostic", + "authenticated_inputs": [ + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/allwidth-caller-certificate/PROOF.md", + "research/p104-helper-subspace-splits/PROOF.md", + "research/p104-helper-subspace-splits/VERIFY.json", + "research/p104-helper-subspace-splits/WORD.json.gz", + "research/p104-helper-subspace-splits/local.py", + "research/p104-helper-subspace-splits/verify.py", + "research/p104-native-channel/vendor/clifford_exact.py", + "research/p104-native-channel/vendor/native_verify.py" + ] +} diff --git a/research/selected-move-phase-coverage/SOURCES.json b/research/selected-move-phase-coverage/SOURCES.json new file mode 100644 index 0000000000..f6a13b5e32 --- /dev/null +++ b/research/selected-move-phase-coverage/SOURCES.json @@ -0,0 +1,72 @@ +{ + "schema_version": 1, + "base_commit": "de5ec2e7a6074068452f45b1a191b5c72832df4a", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8", + "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "usage": "input", + "git_blob": "8089de45c78fb229a70ee1587cc90aacaca01ebc", + "sha256": "7688e5d8bf40fcdfb5bea43ba47e1f8d60a77a91ede6c307bb8163a9a7e16b3f" + }, + { + "path": "research/allwidth-caller-certificate/PROOF.md", + "usage": "input", + "git_blob": "d9ea1027c4ef5a732d8e3f429695fde5b1fdf738", + "sha256": "5f79f819bbafc020cfd5a0e37bed28a067fc16ed5c9f51dee148f4c5e30f7386" + }, + { + "path": "research/p104-helper-subspace-splits/PROOF.md", + "usage": "input", + "git_blob": "ca979984444a431b02b62da7094a3b23d5341742", + "sha256": "f4c68acf9373e34d88e14e1a7791b4b739c8b5297a1ae4c0121f579a02fde04e" + }, + { + "path": "research/p104-helper-subspace-splits/VERIFY.json", + "usage": "input", + "git_blob": "f02fe9b97043e626e9906346d230508247a5871d", + "sha256": "30499c00a5c6a9718561a152e8008ce1a765535647306dc4b2d2a7ce78b7b2ac" + }, + { + "path": "research/p104-helper-subspace-splits/WORD.json.gz", + "usage": "input", + "git_blob": "e325091e3051afe37a2d9c82f85afe9028510edb", + "sha256": "bbb072bced5824a8d9094c49be2fc51fbfdd05fb2b7dab8106e1275053075099" + }, + { + "path": "research/p104-helper-subspace-splits/local.py", + "usage": "input", + "git_blob": "e6e28bacdad7cb51400d827b9a6e02f2b605d357", + "sha256": "ef430511ce36fc658ab711bd84cd2d7b484b8af173238ff89cbfec6139fefbad" + }, + { + "path": "research/p104-helper-subspace-splits/verify.py", + "usage": "input", + "git_blob": "547751915ad09b2229bacf29af02241b0ef29696", + "sha256": "f79c78d009d8a88bc5721644237074569fbb992fe7e49784f4b0c0a97523ea91" + }, + { + "path": "research/p104-native-channel/vendor/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/p104-native-channel/vendor/native_verify.py", + "usage": "input", + "git_blob": "2c209dfa9cfade3bc20ac5fc9d876b433a147f8c", + "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38" + } + ] +} diff --git a/research/selected-move-phase-coverage/TASK.json b/research/selected-move-phase-coverage/TASK.json new file mode 100644 index 0000000000..211cf88977 --- /dev/null +++ b/research/selected-move-phase-coverage/TASK.json @@ -0,0 +1,83 @@ +{ + "schema_version": 1, + "task_id": "uniform-transfer-audit", + "priority_revision": 8, + "base_commit": "de5ec2e7a6074068452f45b1a191b5c72832df4a", + "original_card": { + "id": "uniform-transfer-audit", + "question": "Can one of the selected record's five inherited assumptions be proved at its actual caller?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Choose one assumption ID (native_all_columns, owned_erasure, compiler, precision_tape, analytic_recovery), one quantified implication and exact dependency closure. Check current handoffs, including #5625 row reentry and #5707 root-prefix lowering, without treating their partial scope as the whole theorem. Prove or falsify that implication with a caller-bound argument; stop at the chosen obligation. Finite tests or root digits do not discharge an all-size statement.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "existing_checks": [ + { + "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "refined", + "actual_scope": "Audit whether the selected #5599 MOVE phase/all-width handoff in #5837 identifies uncovered algebraic work; distinguish existing coverage from the physical native_all_columns obligation.", + "scope_change_reason": "The source already checks absolute phase. Resolve that source-specific coverage discrepancy and stop with the physical implementation handoff; do not repeat complete selected admission.", + "bottleneck_link": "Prevents redundant all-width group-identity work and directs the selected native_all_columns audit to actual arbitrary-width execution and tariffs.", + "budget_minutes": 30, + "stop_rule": "Stop when existing algebraic coverage and its remaining physical premise are precisely established; no new tape implementation campaign.", + "outcome": "completed", + "evidence": "README source trace and commutant/tensor argument; RESULT.json independently checks all 512 basis columns of actual event9589, phase/address fault controls, and counts 3447 MOVE occurrences.", + "author": "DLamdata with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance: lead integration, one independent verifier and one skeptical source reviewer; no independent human or proof-kernel review.", + "open_questions": [ + { + "question": "Can the actual first MOVE recipe be realized on the permitted arbitrary-width owner/tape interface at the retained tariff?", + "why_it_matters": "Exact group-element equality does not construct or price physical execution, the remaining native_all_columns premise.", + "first_step": "Pin event9589 and emit both monomial normalizers plus its rank-one child; specify entry/exit owner and head layout, spectators, scratch and restoration.", + "blocked_by": "Source-bound physical address/head maps, primitive contracts, complete charges and caller-layout compatibility remain to be supplied." + } + ] +} diff --git a/research/selected-move-phase-coverage/VALIDATION.md b/research/selected-move-phase-coverage/VALIDATION.md new file mode 100644 index 0000000000..179e85a5df --- /dev/null +++ b/research/selected-move-phase-coverage/VALIDATION.md @@ -0,0 +1,52 @@ +# Validation and review + +Prepared for DLamdata with substantial OpenAI Codex assistance. Apache-2.0. This is local verification and internal AI review, not hosted CI success, human mathematical acceptance or proof-kernel verification. + +## Scope and environment + +The scientific input is canonical main `de5ec2e7a6074068452f45b1a191b5c72832df4a`, priority revision 8. The selected source is `09dd0965711ca7eeb169057a420abab1c9052137`. The selected record and baseline binding checks passed. The four traced execution-chain files have identical Git content at the selected head and base. The code and evidence concern one actual MOVE, alongside a complete occurrence inventory and a source-coverage argument. No full selected replay was run. + +CPython 3.12.14, Linux x86_64, glibc 2.41; standard library only. The shared environment was activated without changing its dependencies, managed authentication or remotes. No package installation was needed. Direct runs isolate the source imports from existing bytecode caches. + +## Commands actually run + +From the contribution repository root, with the activated Python 3.12 interpreter: + +```sh +python -I -W error -B research/selected-move-phase-coverage/verify.py +python -I -O -W error -B research/selected-move-phase-coverage/verify.py +python -B scripts/research_package.py --package research/selected-move-phase-coverage +``` + +All passed. Normal and optimized stdout agree byte-for-byte with [RESULT.json](RESULT.json), SHA256 `1f01afc7022e37b5d5fa54679fb89371254a9bf0c2b11c59d08dfb768f844a51`. The [registered log](logs/registered.log) includes both exact receipts and `PASS_REGISTERED_RESEARCH_PACKAGE research/selected-move-phase-coverage outcome=completed`. The complete registered invocation took approximately 0.82 seconds locally; its individual command limits are 30 seconds. + +The evidence is 512 exact positive columns, 512 detected phase-fault columns, 512 detected address-fault columns, an unchanged signed tableau under the phase fault, and rejection specifically by the retained absolute-phase check. The source inventory is 3,447 MOVE occurrences, 2,887 ordered frame pairs and 11 owned occurrences; only one pair is newly replayed. + +## Internal review and resolved findings + +An independent native agent derived the Pauli-commutant proof before reading the other review. It derived the first MOVE's closed form directly from the canonical basis and diagonal form, then compared every basis column through a separate monomial-record evaluator. The original independent normal/optimized runs passed in 0.181/0.266 seconds. The lead integrated that calculation with source authentication, inventory counts, address-fault controls and portable replay. The verifier agent reviewed those changes and found no blocking issue. + +A second native agent traced the actual registered path through `VERIFY.json`, `verify.run`, `local.replay`, `local.native`, `native_verify.equal` and the final saved-word comparison. It then reviewed the completed README, verifier, receipt and manifests, and independently ran the normal isolated warning-strict command. It confirmed the same receipt SHA256 and unchanged reviewed files. + +Review findings resolved: + +- Separate existing all-occurrence coverage from the single newly executed pair; distinguish occurrence count from distinct pairs. +- Preserve #5837's scalar proposition and valid physical limitation; correct only its description of the existing phase check and resulting next task. +- State the circuit execution order and keep native phases inside tensor powers while external scalar coefficients remain outside. +- Distinguish dynamically synthesized recipes from a literal arbitrary-width tape program. +- Correct a draft's spectator count from seven to six; all 512 tested columns were unchanged. +- Use fresh import-cache namespaces so `-B` cannot consume stale source-module bytecode. +- Add an address fault as a nonphase control; retain explicit runtime checks under optimized Python. +- Describe the future input as a dynamically lowered recipe, rather than implying a retained emitted tape word. + +Both final internal reviews found no blocking issue in the narrowed claim. The producer remains shared because it supplies the actual source recipe; the independent equality oracle does not use either state engine, but shares the declared monomial semantics. The audit does not formally prove the complete compiler/checker implementation. + +## Overlap and research decision + +The initial completed scan at 2026-10-27T11:03:55Z covered all 7,845 local notes, 437 open PRs, 5,350 Discussion records and 4,943 closed/merged PRs, with complete remote pagination and no warnings. The source-impact target is the exact #5837 handoff, not an assertion of literature-wide novelty. Relevant predecessors #5442 and the selected #5599 proof already contain the elementary lifting argument. The selected-monomial and control-reservation packages concern the older #5413 caller and require a source/layout applicability argument before reuse. + +Decision: finish the bounded coverage correction and release the physical implementation task. Repeating a full selected census would not resolve that physical premise. No broader search, new supplier, cost change or family expansion was performed. + +## Unrun obligations + +No `make verify`, `make frontier5599-verify`, all-map native replay, complete body/controller endpoint replay, physical tape executor, rounded multiplier, Lean or Docker run was performed. All five selected framework assumptions remain. Hosted CI, if a PR is opened, is reported separately on that PR and is not inferred from these local passes. diff --git a/research/selected-move-phase-coverage/VERIFY.json b/research/selected-move-phase-coverage/VERIFY.json new file mode 100644 index 0000000000..caad56b06f --- /dev/null +++ b/research/selected-move-phase-coverage/VERIFY.json @@ -0,0 +1,44 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/allwidth-caller-certificate/PROOF.md", + "research/p104-helper-subspace-splits/PROOF.md", + "research/p104-helper-subspace-splits/VERIFY.json", + "research/p104-helper-subspace-splits/WORD.json.gz", + "research/p104-helper-subspace-splits/local.py", + "research/p104-helper-subspace-splits/verify.py", + "research/p104-native-channel/vendor/clifford_exact.py", + "research/p104-native-channel/vendor/native_verify.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 30, + "checks": "Authenticate sources, count MOVE coverage, independently check 512 columns of one actual MOVE and reject phase/address faults; diagnose retained absolute-phase rejection." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 30, + "checks": "Repeat the same bounded exact evidence with assertions disabled; no whole-supplier replay." + } + ] +} diff --git a/research/selected-move-phase-coverage/verify.py b/research/selected-move-phase-coverage/verify.py new file mode 100644 index 0000000000..9f7368684b --- /dev/null +++ b/research/selected-move-phase-coverage/verify.py @@ -0,0 +1,166 @@ +"""Independent rank-one closed-form audit; no native state/tableau engine used for verdict. + +Prepared for DLamdata with substantial OpenAI Codex assistance. Apache-2.0. +Producer is used only to obtain the selected recipe; the checker is direct Q(i) arithmetic. +""" +import copy +import gzip +import hashlib +import importlib.util +import json +from pathlib import Path +import sys +import tempfile + +if len(sys.argv) != 1: + raise SystemExit('usage: verify.py') +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +SOURCE = ROOT / 'research/p104-native-channel/vendor/clifford_exact.py' +WORD = ROOT / 'research/p104-helper-subspace-splits/WORD.json.gz' +EXPECTED_WORD_SHA256 = 'bbb072bced5824a8d9094c49be2fc51fbfdd05fb2b7dab8106e1275053075099' + +def need(value, message): + if not value: + raise ValueError(message) + +def authenticate(): + """Authenticate the inspected source closure before executing either engine.""" + rows = json.loads((HERE / 'SOURCES.json').read_bytes())['files'] + checked = [] + for row in rows: + if row['usage'] != 'input': + continue + raw = (ROOT / row['path']).read_bytes() + need(hashlib.sha256(raw).hexdigest() == row['sha256'], 'source SHA256: ' + row['path']) + need(hashlib.sha1(b'blob ' + str(len(raw)).encode() + b'\0' + raw).hexdigest() + == row['git_blob'], 'source Git blob: ' + row['path']) + checked.append(row['path']) + return checked + +def module(path, name): + spec = importlib.util.spec_from_file_location(name, path) + out = importlib.util.module_from_spec(spec) + sys.modules[name] = out + spec.loader.exec_module(out) + return out + +def rotate(pair, power): + # Exact multiplication in Z[i], deliberately no source helper. + re, im = pair + for _ in range(power % 4): + re, im = -im, re + return re, im + +def monomial_image(record, x): + bits = [(x >> j) & 1 for j in range(9)] + exponent = record['phase'] + exponent += sum(record['linear_Z4'][j] * bits[j] for j in range(9)) + for j in range(9): + for k in range(j + 1, 9): + exponent += 2 * ((record['quadratic_rows'][j] >> k) & 1) * bits[j] * bits[k] + out = record['offset'] + for j, row in enumerate(record['matrix_rows']): + bit = sum(((row >> k) & 1) * bits[k] for k in range(9)) % 2 + out ^= bit << j + return out, exponent % 4 + +def literal_rank_one_column(recipe, x): + need(recipe['rank'] == 1, 'rank-one domain') + y, phase_right = monomial_image(recipe['right'], x) + column = {} + # (I+iI+X-iX)/2; all stored values are numerators over 2. + for middle, numerator in [(y, (1, 1)), (y ^ 1, (1, -1))]: + z, phase_left = monomial_image(recipe['left'], middle) + term = rotate(numerator, phase_left + phase_right) + old = column.get(z, (0, 0)) + column[z] = old[0] + term[0], old[1] + term[1] + return {k: v for k, v in column.items() if v != (0, 0)} + +def closed_form_column(x): + # From K = D_Q P_G, G e_0 = 11 and q_Q(x)=2*x_3*(x_0+x_1): + # K C_1 K^-1 = (1+i)/2 I + (1-i)/2 X_11 Z_3. + sign = -1 if ((x & 1) ^ ((x >> 1) & 1)) else 1 + return {x: (1, 1), x ^ 11: (sign, -sign)} + +authenticated_inputs = authenticate() +need(hashlib.sha256(WORD.read_bytes()).hexdigest() == EXPECTED_WORD_SHA256, 'source word hash') +w = json.loads(gzip.decompress(WORD.read_bytes())) +moves = [e for e in w['program'] if e[0] == 'MOVE'] +pair_count = len({tuple(e[2:4]) for e in moves}) +need((len(moves), pair_count, sum(e[4] for e in moves)) == (3447, 2887, 11), + 'selected MOVE inventory') +index, move = next((i, e) for i, e in enumerate(w['program']) if e[0] == 'MOVE') +need(index == 9589 and move == ['MOVE', 224, 3, 0, False], 'selected first MOVE binding') +need(w['frames'][3] == [] and w['frames'][0] == [11], 'selected chart binding') +need(hashlib.sha256(SOURCE.read_bytes()).hexdigest() == '2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962', 'compiler source hash') +with tempfile.TemporaryDirectory(prefix='move-phase-bytecode-') as cache: + old_cache = sys.pycache_prefix + sys.pycache_prefix = cache + try: + C = module(SOURCE, 'independent_first_move_producer') + finally: + sys.pycache_prefix = old_cache +operation = C.canonical_frame(9, ()).adjoint().then(C.canonical_frame(9, (11,))) +recipe, _ = C.lower_child(operation) +mutant = copy.deepcopy(recipe) +mutant['left']['phase'] = (mutant['left']['phase'] + 1) % 4 +offset_mutant = copy.deepcopy(recipe) +offset_mutant['left']['offset'] ^= 1 +for x in range(512): + actual = literal_rank_one_column(recipe, x) + expected = closed_form_column(x) + need(actual == expected, 'closed-form operator mismatch at ' + str(x)) + changed = literal_rank_one_column(mutant, x) + need(changed == {a: rotate(b, 1) for a, b in expected.items()}, 'mutation not exactly i*U') + need(changed != expected, 'phase-only fault invisible at ' + str(x)) + need(literal_rank_one_column(offset_mutant, x) != expected, + 'address fault invisible at ' + str(x)) +# V is used only after the independent verdict, to test its rejection branch. +checker_path = ROOT / 'research/p104-native-channel/vendor/native_verify.py' +need(hashlib.sha256(checker_path.read_bytes()).hexdigest() == '3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38', 'checker source hash') +with tempfile.TemporaryDirectory(prefix='move-phase-bytecode-') as cache: + old_cache = sys.pycache_prefix + sys.pycache_prefix = cache + try: + V = module(checker_path, 'selected_native_checker') + finally: + sys.pycache_prefix = old_cache +expected_circuit = V.adjoint(V.frame(w['frames'][3], 9)) + V.frame(w['frames'][0], 9) +V.equal(V.recipe(recipe), expected_circuit, 'positive source control') +need(V.tableau(V.recipe(mutant)) == V.tableau(expected_circuit), 'mutant changed signed action') +try: + V.equal(V.recipe(mutant), expected_circuit, 'phase-only control') +except ValueError as error: + need(str(error) == 'phase-only control: exact global phase', 'unexpected rejection path') + rejection = str(error) +else: + raise ValueError('source checker accepted phase-only mutation') +report = { + 'status': 'PASS_INDEPENDENT_FIRST_MOVE_CLOSED_FORM', + 'base': 'de5ec2e7a6074068452f45b1a191b5c72832df4a', + 'word_sha256': EXPECTED_WORD_SHA256, + 'producer_sha256': hashlib.sha256(SOURCE.read_bytes()).hexdigest(), + 'checker_sha256': hashlib.sha256((ROOT / 'research/p104-native-channel/vendor/native_verify.py').read_bytes()).hexdigest(), + 'event_index_zero_based': index, + 'event': move, + 'domain': 'all 512 width-one basis columns of the first actual MOVE', + 'closed_form': '((1+i)I + (1-i)X_11 Z_3)/2', + 'columns_checked': 512, + 'phase_fault_columns_detected': 512, + 'address_fault_columns_detected': 512, + 'move_occurrences_counted': len(moves), + 'distinct_move_pairs_counted': pair_count, + 'owned_move_occurrences_counted': sum(e[4] for e in moves), + 'newly_replayed_move_pairs': 1, + 'mutant_relation': 'i times original operator', + 'source_signed_tableau_unchanged': True, + 'source_rejection': rejection, + 'origin_column_numerators_over_2': sorted(literal_rank_one_column(recipe, 0).items()), + 'mutant_origin_column_numerators_over_2': sorted(literal_rank_one_column(mutant, 0).items()), + 'new_checker_dependencies': 'standard library; source compiler produces fixture; independent direct column formula decides equality before retained verifier diagnostic', + 'authenticated_inputs': authenticated_inputs, +} +need(json.loads(json.dumps(report)) == json.loads((HERE / 'RESULT.json').read_bytes()), + 'saved audit receipt') +print(json.dumps(report, indent=2)) From d73faa6ed09d1a72d8c40bde43b268f2ddfd20d8 Mon Sep 17 00:00:00 2001 From: Figo Lam Date: Tue, 27 Oct 2026 11:12:42 +0000 Subject: [PATCH 2/2] Record internal review and portable verification evidence --- .../selected-move-phase-coverage/SOURCES.json | 12 ++ .../VALIDATION.md | 20 ++- .../logs/portable-check.json | 22 +++ .../logs/registered.txt | 145 ++++++++++++++++++ .../logs/scientific-commit-check.txt | 1 + .../logs/scientific-export-check.txt | 1 + 6 files changed, 200 insertions(+), 1 deletion(-) create mode 100644 research/selected-move-phase-coverage/logs/portable-check.json create mode 100644 research/selected-move-phase-coverage/logs/registered.txt create mode 100644 research/selected-move-phase-coverage/logs/scientific-commit-check.txt create mode 100644 research/selected-move-phase-coverage/logs/scientific-export-check.txt diff --git a/research/selected-move-phase-coverage/SOURCES.json b/research/selected-move-phase-coverage/SOURCES.json index f6a13b5e32..daa599080c 100644 --- a/research/selected-move-phase-coverage/SOURCES.json +++ b/research/selected-move-phase-coverage/SOURCES.json @@ -67,6 +67,18 @@ "usage": "input", "git_blob": "2c209dfa9cfade3bc20ac5fc9d876b433a147f8c", "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38" + }, + { + "path": "research/selected-monomial-tape-lift/README.md", + "usage": "provenance", + "git_blob": "94e47cea4427ed0072f8283f431793b52601be9b", + "sha256": "f34e186a0576eea5b15b5d2368274cc77c96d2150e8a3d3fbd67275e020c8a3f" + }, + { + "path": "research/selected-control-reservations/README.md", + "usage": "provenance", + "git_blob": "2ff556a541a32274ed88a85801d3f3b77138de43", + "sha256": "cccf5d032f5bdaa7e1f6d331e882d27108b473216a4cdd68e83647ef0312f259" } ] } diff --git a/research/selected-move-phase-coverage/VALIDATION.md b/research/selected-move-phase-coverage/VALIDATION.md index 179e85a5df..0c831291d3 100644 --- a/research/selected-move-phase-coverage/VALIDATION.md +++ b/research/selected-move-phase-coverage/VALIDATION.md @@ -18,7 +18,7 @@ python -I -O -W error -B research/selected-move-phase-coverage/verify.py python -B scripts/research_package.py --package research/selected-move-phase-coverage ``` -All passed. Normal and optimized stdout agree byte-for-byte with [RESULT.json](RESULT.json), SHA256 `1f01afc7022e37b5d5fa54679fb89371254a9bf0c2b11c59d08dfb768f844a51`. The [registered log](logs/registered.log) includes both exact receipts and `PASS_REGISTERED_RESEARCH_PACKAGE research/selected-move-phase-coverage outcome=completed`. The complete registered invocation took approximately 0.82 seconds locally; its individual command limits are 30 seconds. +All passed. Normal and optimized stdout agree byte-for-byte with [RESULT.json](RESULT.json), SHA256 `1f01afc7022e37b5d5fa54679fb89371254a9bf0c2b11c59d08dfb768f844a51`. The [registered log](logs/registered.txt) includes both exact receipts and `PASS_REGISTERED_RESEARCH_PACKAGE research/selected-move-phase-coverage outcome=completed`. The complete registered invocation took approximately 0.82 seconds locally; its individual command limits are 30 seconds. The evidence is 512 exact positive columns, 512 detected phase-fault columns, 512 detected address-fault columns, an unchanged signed tableau under the phase fault, and rejection specifically by the retained absolute-phase check. The source inventory is 3,447 MOVE occurrences, 2,887 ordered frame pairs and 11 owned occurrences; only one pair is newly replayed. @@ -50,3 +50,21 @@ Decision: finish the bounded coverage correction and release the physical implem ## Unrun obligations No `make verify`, `make frontier5599-verify`, all-map native replay, complete body/controller endpoint replay, physical tape executor, rounded multiplier, Lean or Docker run was performed. All five selected framework assumptions remain. Hosted CI, if a PR is opened, is reported separately on that PR and is not inferred from these local passes. + +## Committed scientific snapshot and portable replay + +Scientific snapshot `c1187a843403000cb6591f1fb4914f509be96d3e` passed the committed-byte, executable-mode and full source-history preflight for 16 package/input files. Its official export passed integrity checking. Commands: + +```sh +python -B scripts/check_research_commit.py --package research/selected-move-phase-coverage --check-source-history --check-modes +python -B scripts/export_research_package.py export --package research/selected-move-phase-coverage --ref c1187a843403000cb6591f1fb4914f509be96d3e --output /tmp/selected-move-phase-coverage.tar +python -B scripts/export_research_package.py check /tmp/selected-move-phase-coverage.tar +``` + +The artifact location is replaceable; the executed archive was in external research scratch. See [byte/history receipt](logs/scientific-commit-check.txt), [export receipt](logs/scientific-export-check.txt) and [portable receipt](logs/portable-check.json). + +After extraction, both direct commands were run from an unrelated directory using an absolute Python 3.12 path, empty PATH, and read-only package/input files and directories. Both produced the exact saved scientific receipt, in 0.242/0.265 seconds. All 17 files including the export manifest retained their bytes and modes. A separate writable copy with one newline appended to the compiler source failed before imports with `source SHA256: research/p104-native-channel/vendor/clifford_exact.py`, exit 1 and empty stdout. + +The final publication commit adds only these validation records and provenance documentation to that scientific snapshot. The final committed-byte/export checks are repeated before publication and reported with the final head in the PR. No scientific executable or result changed after the checked snapshot. + +A second complete open/discussion refresh at 2026-10-27T11:11:29Z retained 437 open PRs and 5,350 Discussion records with no warnings. #5837 remained at its pinned head. The earlier fully paginated closed/merged snapshot remains timestamped 11:03:54Z. Canonical main was fetched again and remained `de5ec2e7a6074068452f45b1a191b5c72832df4a`; relevant guidance and the selected record were unchanged. No competing correction was found within these text/source checks; unpublished work and arbitrary diffs are outside their coverage. diff --git a/research/selected-move-phase-coverage/logs/portable-check.json b/research/selected-move-phase-coverage/logs/portable-check.json new file mode 100644 index 0000000000..f9d6a7cc6f --- /dev/null +++ b/research/selected-move-phase-coverage/logs/portable-check.json @@ -0,0 +1,22 @@ +{ + "status": "PASS_READ_ONLY_GIT_FREE_EXPORT_AND_SOURCE_FAULT", + "scientific_commit": "c1187a843403000cb6591f1fb4914f509be96d3e", + "files_including_export_manifest": 17, + "unchanged_bytes_and_modes": true, + "runs": [ + { + "mode": "normal", + "exit": 0, + "seconds": 0.242, + "status": "PASS_INDEPENDENT_FIRST_MOVE_CLOSED_FORM" + }, + { + "mode": "optimized", + "exit": 0, + "seconds": 0.265, + "status": "PASS_INDEPENDENT_FIRST_MOVE_CLOSED_FORM" + } + ], + "source_fault_exit": 1, + "source_fault_diagnostic": "source SHA256: research/p104-native-channel/vendor/clifford_exact.py" +} diff --git a/research/selected-move-phase-coverage/logs/registered.txt b/research/selected-move-phase-coverage/logs/registered.txt new file mode 100644 index 0000000000..27bd4a24e8 --- /dev/null +++ b/research/selected-move-phase-coverage/logs/registered.txt @@ -0,0 +1,145 @@ +CHECK Authenticate sources, count MOVE coverage, independently check 512 columns of one actual MOVE and reject phase/address faults; diagnose retained absolute-phase rejection. +{ + "status": "PASS_INDEPENDENT_FIRST_MOVE_CLOSED_FORM", + "base": "de5ec2e7a6074068452f45b1a191b5c72832df4a", + "word_sha256": "bbb072bced5824a8d9094c49be2fc51fbfdd05fb2b7dab8106e1275053075099", + "producer_sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "checker_sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38", + "event_index_zero_based": 9589, + "event": [ + "MOVE", + 224, + 3, + 0, + false + ], + "domain": "all 512 width-one basis columns of the first actual MOVE", + "closed_form": "((1+i)I + (1-i)X_11 Z_3)/2", + "columns_checked": 512, + "phase_fault_columns_detected": 512, + "address_fault_columns_detected": 512, + "move_occurrences_counted": 3447, + "distinct_move_pairs_counted": 2887, + "owned_move_occurrences_counted": 11, + "newly_replayed_move_pairs": 1, + "mutant_relation": "i times original operator", + "source_signed_tableau_unchanged": true, + "source_rejection": "phase-only control: exact global phase", + "origin_column_numerators_over_2": [ + [ + 0, + [ + 1, + 1 + ] + ], + [ + 11, + [ + 1, + -1 + ] + ] + ], + "mutant_origin_column_numerators_over_2": [ + [ + 0, + [ + -1, + 1 + ] + ], + [ + 11, + [ + 1, + 1 + ] + ] + ], + "new_checker_dependencies": "standard library; source compiler produces fixture; independent direct column formula decides equality before retained verifier diagnostic", + "authenticated_inputs": [ + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/allwidth-caller-certificate/PROOF.md", + "research/p104-helper-subspace-splits/PROOF.md", + "research/p104-helper-subspace-splits/VERIFY.json", + "research/p104-helper-subspace-splits/WORD.json.gz", + "research/p104-helper-subspace-splits/local.py", + "research/p104-helper-subspace-splits/verify.py", + "research/p104-native-channel/vendor/clifford_exact.py", + "research/p104-native-channel/vendor/native_verify.py" + ] +} +CHECK Repeat the same bounded exact evidence with assertions disabled; no whole-supplier replay. +{ + "status": "PASS_INDEPENDENT_FIRST_MOVE_CLOSED_FORM", + "base": "de5ec2e7a6074068452f45b1a191b5c72832df4a", + "word_sha256": "bbb072bced5824a8d9094c49be2fc51fbfdd05fb2b7dab8106e1275053075099", + "producer_sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "checker_sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38", + "event_index_zero_based": 9589, + "event": [ + "MOVE", + 224, + 3, + 0, + false + ], + "domain": "all 512 width-one basis columns of the first actual MOVE", + "closed_form": "((1+i)I + (1-i)X_11 Z_3)/2", + "columns_checked": 512, + "phase_fault_columns_detected": 512, + "address_fault_columns_detected": 512, + "move_occurrences_counted": 3447, + "distinct_move_pairs_counted": 2887, + "owned_move_occurrences_counted": 11, + "newly_replayed_move_pairs": 1, + "mutant_relation": "i times original operator", + "source_signed_tableau_unchanged": true, + "source_rejection": "phase-only control: exact global phase", + "origin_column_numerators_over_2": [ + [ + 0, + [ + 1, + 1 + ] + ], + [ + 11, + [ + 1, + -1 + ] + ] + ], + "mutant_origin_column_numerators_over_2": [ + [ + 0, + [ + -1, + 1 + ] + ], + [ + 11, + [ + 1, + 1 + ] + ] + ], + "new_checker_dependencies": "standard library; source compiler produces fixture; independent direct column formula decides equality before retained verifier diagnostic", + "authenticated_inputs": [ + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/allwidth-caller-certificate/PROOF.md", + "research/p104-helper-subspace-splits/PROOF.md", + "research/p104-helper-subspace-splits/VERIFY.json", + "research/p104-helper-subspace-splits/WORD.json.gz", + "research/p104-helper-subspace-splits/local.py", + "research/p104-helper-subspace-splits/verify.py", + "research/p104-native-channel/vendor/clifford_exact.py", + "research/p104-native-channel/vendor/native_verify.py" + ] +} +PASS_REGISTERED_RESEARCH_PACKAGE research/selected-move-phase-coverage outcome=completed diff --git a/research/selected-move-phase-coverage/logs/scientific-commit-check.txt b/research/selected-move-phase-coverage/logs/scientific-commit-check.txt new file mode 100644 index 0000000000..f7ba72f882 --- /dev/null +++ b/research/selected-move-phase-coverage/logs/scientific-commit-check.txt @@ -0,0 +1 @@ +PASS_RESEARCH_COMMIT_BYTES {"commit": "c1187a843403000cb6591f1fb4914f509be96d3e", "files": 16, "package": "research/selected-move-phase-coverage", "executable_modes_checked": true, "source_history_commits": ["de5ec2e7a6074068452f45b1a191b5c72832df4a"]} diff --git a/research/selected-move-phase-coverage/logs/scientific-export-check.txt b/research/selected-move-phase-coverage/logs/scientific-export-check.txt new file mode 100644 index 0000000000..6eb77b5edc --- /dev/null +++ b/research/selected-move-phase-coverage/logs/scientific-export-check.txt @@ -0,0 +1 @@ +PASS_RESEARCH_EXPORT {"commit": "c1187a843403000cb6591f1fb4914f509be96d3e", "package": "research/selected-move-phase-coverage", "files": 16}