wai-quantum: a gate under many controls stays one operation on the state vector, the bit-exact method states what its lowering did, and the error-correction reader takes C_XYZ, E and PAULI_CHANNEL_1 #675

Merged

dcharlot merged 21 commits from wai/quantum-reader-scaling into main 2026-11-07 03:34:06 -05:00

Conversation 0 Commits 21 Files changed 74 +16071 -4628

dcharlot commented 2026-11-06 09:15:29 -05:00

Owner

Copy link

#662 has landed; this branch has merged main. The comparison below is rerun at the review's fixes, with the same counts.

The engine fixes the cross-simulator corpus exposed.

A gate under many controls stays one operation

ctrl(k) @ was written in standard gates by a Gray-code phase polynomial whose length doubles with each control. Now:

• The reader. qasm::read_whole keeps such a gate as one op (Op::is_whole), under up to 255 controls; Program::lowered writes it in standard gates, and gives exactly what qasm::read gives of the same text (one lowering, qasm/controls.rs, behind both). read and parse are unchanged.
• The state vector applies it as one (StateVector::run_ops, Controlled), visiting only the 2^(n − c) amplitudes its controls leave on. Its amplitudes move by double rounding, within the method's bound; "options": {"controls": "standard"} gives the old bits.
• The bit-exact method keeps its bits. Its bits are the rounding of each gate it applies, so the gate held whole gives other bits than its standard gates. A job on exact runs standard gates by default and gives the hash it gave; "options": {"controls": "whole"} holds the gate whole under its controls (the circuit2 op-log takes controls), nearer the ideal state and with another hash. The first pass of this branch made the whole form the default; the review commit (062f37182) made it opt-in, since the brief asks for bit-identical results on this method.
• Counts. gates in a result and in lint_qasm still counts standard gates, and dynamic_steps counts steps the same way, so a receipt's provenance carries the count it carried; operations (new, optional) says what a method holding gates whole ran. A state-vector job's expectation values move with its amplitudes, and a provenance's plan.work and an estimate's work follow what the method ran.
• Everything that needs standard gates (compile, QIR and jeff export, the resource estimate, the tableau, MPS, tensor networks, noise, mitigation, devices, providers, a named fabric place, registered methods) takes them, and refuses past 16 controls or MAX_OPS with Q208/Q210 as before.

What stays bit-identical, and where it was checked

• Before, from the old engine. For 24 programs (gates under 2 to 5 controls, negative controls, inv @ ctrl @, ctrl @ cu, ctrl(2) @ swap, ctrl(2) @ rzz, a controlled gphase, a 6-qubit Grover, and plain ones), the corpus branch's engine computed: the reader's standard gates, the bit-exact state_hash, a compile, the QIR and jeff exports, the resource estimate's counts, and the result's gates. All 24 rows were identical on x86_64 (an Intel Mac) and on aarch64 (Linux), and they are this branch's BEFORE table (engine/catalog/whole_tests.rs).
• After, on this branch, the test holds every row: the bit-exact hash by default and with "controls": "standard", gates on exact and on the state vector (whole) alike, compile, QIR, jeff and the estimate from both the standard and the whole reading. the_bit_exact_method_keeps_its_bits_unless_asked holds a 9-qubit Grover's default hash to read's, and the whole form to another. It passes on x86_64 (macOS) and aarch64 (Linux).
• Within bounds elsewhere: the_state_vector_of_a_whole_gate_is_its_expansion_s_within_rounding, and in the comparison every state-vector row against the exact reference (below).
• The bit-exact walk under controls (a Toffoli in standard gates takes it): the_walk_under_controls_gives_the_scan_s_bits, every base gate, both gatesets.
• Conformance hashes: every integration test with --features full (14 targets: bit_identity, the conformance corpora, qasm3_conformance, frame_reference, and the rest), every feature subset the workflows check under -D warnings, the debug test build, the command line's tests and smoke.sh, on Linux aarch64; the library's 1208 tests on x86_64 too.
• What changed on purpose: a result on exact carries accuracy.global_phase (and below_table, moved_angles when there is one), so its JSON and receipt hold them; bits and hash do not change. The committed tool lists (local-mcp.json, service-mcp.json) and the agent docs are regenerated.

Three behaviours that were silent

• Global phase. A result on exact states the phase its lowering drops (accuracy.global_phase, exactly, in 2^33rds of a turn): method statevector's state of the program that ran is e^(i·radians) times its amplitudes. The language's own state can differ from both (its U is e^(iθ/2) times the matrix both take as u, and the reader drops an uncontrolled gphase). The corpus now holds the method to the reference's state with that phase, nothing fitted.
• Angles below the table. A phase gate within the reader's tolerance, 1e-14 of a turn, of a whole turn runs as no phase on the bit-exact method, as its reader's rule has it; the result (accuracy.below_table) and the plan's why now say so, and an angle moved to a non-zero dyadic one is stated too (accuracy.moved_angles).
• The matrix-product job and the 30-qubit QFT. A job naming mps is no longer refused on an estimate at the bond it asks for: it runs under a meter of the bonds it holds and stops with J011, saying where, if those pass one job's work. The meter counts each two-site update, each move of the orthogonality center and each one-qubit gate, and holds the budget inside a gate that crosses the chain; the estimate walks the same steps, so it bounds the meter. The 30-qubit QFT of a basis state at max_bond 256 runs (mps_qft_n30_bond256), at bond 1. Its plan says metered, its work what the meter allows. auto keeps to the estimate.

Three instructions the error-correction reader refused

C_XYZ and C_ZYX; E (CORRELATED_ERROR), a flip on a carrier qubit handed to its Pauli targets; and PAULI_CHANNEL_1, as the independent flips with its law. A channel with no such flips (PAULI_CHANNEL_1(0.1, 0.1, 0)) is refused with its line, and the corpus lists that refusal as one it must give.

The review's fixes

Every finding of the review but the error-correction decode bound (another change holds it) is fixed, each with a test that failed on the code before its fix:

• The planner hang. The Clifford check of a program holding a gate whole counts its standard gates first and refuses past 16 controls (Q208) or MAX_OPS (Q210) before writing any (ctrl(41) @ z on 42 qubits, ctrl(39) @ t, a 42-qubit Grover iteration, ctrl(24) @ p(0), a loop of ctrl(16) @ p(0): refused at once, where each hung). A method's plan makes only the circuit it reads. The whole gate's phases are read exactly there, so ctrl(16) @ p(1e-7) is not taken for the identity.
• Over MCP, a gate past 16 controls runs: a verdict with no intent reads the program as it ran. A job with an intent is checked in standard gates and refused there on its line.
• Refusals. A named method that needs standard gates refuses as the reader does, on its line, with Q208/Q210 and no J011; both refusals past 16 controls name "options": {"controls": "whole"}. options.controls is read: another value, or "whole" on a job that runs standard gates, is J003, and the schema, methods list, API description, README and both MCP servers name it. Gates held whole may take 2,000,000 qubits in all (Q210).
• Counts. lint's dynamic_steps counts standard steps beside gates; operations is an engine member a registered method may not write.
• The meter. It counts each move of the orthogonality center and each one-qubit gate, holds the budget at each two-site update, and the plan walks the same steps (WorkBound), so the plan still bounds it; the pinned mps job's digest moves with its plan's work. A metered plan says metered, its work what the meter allows, and a metered job does not set the service's measured rate. Tests now run the meter at bonds the chain fills, stop a job with J011 mid-run and for its shots, and price an update at the bond it spans.
• Phases. accuracy.global_phase is stated against method statevector's state; the language's U and an uncontrolled gphase differ from it, and the note says so. below_table and moved_angles say they count the lowering's phase gates, at 1e-14 of a turn.
• The error-correction reader. PAULI_CHANNEL_1 takes every channel independent flips give, rates above 1/2 and parities of zero among them; text qubit 4294967295 (the carrier's index) and a correlated error with no index left are refused on their lines; C_XYZ/C_ZYX refuse arguments. E's targets go through the same touch as every target, so a qubit bound there covers it, plus the one carrier qubit lower adds. The QEC page and the conformance set (a circuit, its model and a refusal) hold the new forms.
• Snapshots and docs. service-mcp.json, local-mcp.json and llms-full.txt regenerated; the feature matrix, refusal table and service README say what changed.
• CI. The new tests are required by name, and the state vector's gate under controls also runs under wasm32-wasip2.
• Mutants. 14 planted faults (each of y, h, tdg, sx/sxdg, ry, u in the bit-exact whole form; phase_n's whole angle; the run's budget; the shots check; a meter that ignores the bond; the four accuracy members and the rounding guard) each fail a test.

The comparison, rerun

reproduce.sh --tier full on this branch's engine, on both hosts (results/, each file naming its trees):

file	host	pass	fail	known	refused as listed	not run	recorded
conformance-macos-arm64.json	Apple M3 Ultra, macOS 27.2	1743	0	11	10	12	12
conformance-linux-x86_64.json	AMD RYZEN AI MAX+ 395, Ubuntu 26.04.1 LTS	1738	0	11	10	14	12

Against #662's runs (1638 and 1637 pass): color_d3, qec_correlated and qec_pauli_channel now run and match the other engine mechanism by mechanism (largest difference 6.9e-18 against a bound of 2.6e-13 on the colour code), and their detection rates follow the model; qec_refused_channel_with_no_independent_form is refused, as listed. Every bit-exact state is held to OpenQASM's with the phase its result states (184 rows on Linux, largest ratio 0.14 of the bound). mps_qft_n30_bond256 runs on wai.mps, exact (error 7e-19). The added not-run rows are the other engine's: its 900 s limit on rotations_wide_n20 on Linux this time, and no model of the refused channel. The CI tier and the self-test (every fault caught) pass on macOS arm64 too.

Timings, before and after, on one host

Apple M3 Ultra (macOS 27.2, 32 logical CPUs), the same harness (tools/perf.py), the corpus branch's build then this branch's, one straight after the other, five runs each, median (results/before-after-macos-arm64.json). The host was shared: one-minute load 29 to 89 during the before build and 65 to 134 during the after build, so the after build ran under more load on every row.

case	engine	before	after
grover_n10	wai.statevector	0.0156 s, 8,290 ops	0.00018 s, 114 ops
grover_n14	wai.statevector	3.00 s, 131,214 ops	0.0022 s, 158 ops
grover_n16	wai.statevector	16.3 s, 524,452 ops	0.011 s, 180 ops
grover_n20	wai.statevector	refused, Q208	0.030 s, 224 ops
grover_n14	wai.exact (default)	8.48 s, 557,146 ops	9.18 s, 557,146 ops, the same bits
grover_n14	wai.exact_whole (asked)	8.45 s, 557,146 ops	0.0032 s, 158 ops
grover_n16	wai.exact_whole (asked)	151 s, 2,490,472 ops	0.015 s, 180 ops
grover_n20	wai.exact_whole (asked)	refused, Q208	0.32 s, 224 ops

Every case without such a gate (QFT, rotation brickworks, tableaus, error-correction sampling, matrix product states) runs the same ops before and after; their times moved by the host's load, both ways. The other engines' rows are in the file, as data.

Notes for review

• The first commit records a first pass as it was left (uncommitted, unbuilt), so the review commit reads as changes to it.
• wai-quantum/src changes fire every wai-quantum workflow.
• Clippy on the engine crate itself fails on many files before this branch and is not a CI gate; this branch's new code adds no finding to it.

🤖 Generated with Claude Code

#662 has landed; this branch has merged main. The comparison below is rerun at the review's fixes, with the same counts. The engine fixes the cross-simulator corpus exposed. ## A gate under many controls stays one operation `ctrl(k) @` was written in standard gates by a Gray-code phase polynomial whose length doubles with each control. Now: - **The reader.** `qasm::read_whole` keeps such a gate as one op (`Op::is_whole`), under up to 255 controls; `Program::lowered` writes it in standard gates, and gives exactly what `qasm::read` gives of the same text (one lowering, `qasm/controls.rs`, behind both). `read` and `parse` are unchanged. - **The state vector** applies it as one (`StateVector::run_ops`, `Controlled`), visiting only the `2^(n − c)` amplitudes its controls leave on. Its amplitudes move by double rounding, within the method's bound; `"options": {"controls": "standard"}` gives the old bits. - **The bit-exact method keeps its bits.** Its bits are the rounding of each gate it applies, so the gate held whole gives other bits than its standard gates. A job on `exact` runs standard gates by default and gives the hash it gave; `"options": {"controls": "whole"}` holds the gate whole under its controls (the circuit2 op-log takes controls), nearer the ideal state and with another hash. The first pass of this branch made the whole form the default; the review commit (`062f37182`) made it opt-in, since the brief asks for bit-identical results on this method. - **Counts.** `gates` in a result and in `lint_qasm` still counts standard gates, and `dynamic_steps` counts steps the same way, so a receipt's provenance carries the count it carried; `operations` (new, optional) says what a method holding gates whole ran. A state-vector job's expectation values move with its amplitudes, and a provenance's `plan.work` and an estimate's `work` follow what the method ran. - Everything that needs standard gates (compile, QIR and jeff export, the resource estimate, the tableau, MPS, tensor networks, noise, mitigation, devices, providers, a named fabric place, registered methods) takes them, and refuses past 16 controls or `MAX_OPS` with `Q208`/`Q210` as before. ### What stays bit-identical, and where it was checked - **Before, from the old engine.** For 24 programs (gates under 2 to 5 controls, negative controls, `inv @ ctrl @`, `ctrl @ cu`, `ctrl(2) @ swap`, `ctrl(2) @ rzz`, a controlled `gphase`, a 6-qubit Grover, and plain ones), the corpus branch's engine computed: the reader's standard gates, the bit-exact `state_hash`, a compile, the QIR and jeff exports, the resource estimate's counts, and the result's `gates`. All 24 rows were identical on x86_64 (an Intel Mac) and on aarch64 (Linux), and they are this branch's `BEFORE` table (`engine/catalog/whole_tests.rs`). - **After, on this branch,** the test holds every row: the bit-exact hash by default and with `"controls": "standard"`, `gates` on `exact` and on the state vector (whole) alike, compile, QIR, jeff and the estimate from both the standard and the whole reading. `the_bit_exact_method_keeps_its_bits_unless_asked` holds a 9-qubit Grover's default hash to `read`'s, and the whole form to another. It passes on x86_64 (macOS) and aarch64 (Linux). - **Within bounds elsewhere:** `the_state_vector_of_a_whole_gate_is_its_expansion_s_within_rounding`, and in the comparison every state-vector row against the exact reference (below). - **The bit-exact walk under controls** (a Toffoli in standard gates takes it): `the_walk_under_controls_gives_the_scan_s_bits`, every base gate, both gatesets. - **Conformance hashes:** every integration test with `--features full` (14 targets: `bit_identity`, the conformance corpora, `qasm3_conformance`, `frame_reference`, and the rest), every feature subset the workflows check under `-D warnings`, the debug test build, the command line's tests and `smoke.sh`, on Linux aarch64; the library's 1208 tests on x86_64 too. - **What changed on purpose:** a result on `exact` carries `accuracy.global_phase` (and `below_table`, `moved_angles` when there is one), so its JSON and receipt hold them; bits and hash do not change. The committed tool lists (`local-mcp.json`, `service-mcp.json`) and the agent docs are regenerated. ## Three behaviours that were silent - **Global phase.** A result on `exact` states the phase its lowering drops (`accuracy.global_phase`, exactly, in 2^33rds of a turn): method statevector's state of the program that ran is `e^(i·radians)` times its amplitudes. The language's own state can differ from both (its `U` is `e^(iθ/2)` times the matrix both take as `u`, and the reader drops an uncontrolled `gphase`). The corpus now holds the method to the reference's state with that phase, nothing fitted. - **Angles below the table.** A phase gate within the reader's tolerance, 1e-14 of a turn, of a whole turn runs as no phase on the bit-exact method, as its reader's rule has it; the result (`accuracy.below_table`) and the plan's `why` now say so, and an angle moved to a non-zero dyadic one is stated too (`accuracy.moved_angles`). - **The matrix-product job and the 30-qubit QFT.** A job naming `mps` is no longer refused on an estimate at the bond it asks for: it runs under a meter of the bonds it holds and stops with `J011`, saying where, if those pass one job's work. The meter counts each two-site update, each move of the orthogonality center and each one-qubit gate, and holds the budget inside a gate that crosses the chain; the estimate walks the same steps, so it bounds the meter. The 30-qubit QFT of a basis state at `max_bond` 256 runs (`mps_qft_n30_bond256`), at bond 1. Its plan says `metered`, its `work` what the meter allows. `auto` keeps to the estimate. ## Three instructions the error-correction reader refused `C_XYZ` and `C_ZYX`; `E` (`CORRELATED_ERROR`), a flip on a carrier qubit handed to its Pauli targets; and `PAULI_CHANNEL_1`, as the independent flips with its law. A channel with no such flips (`PAULI_CHANNEL_1(0.1, 0.1, 0)`) is refused with its line, and the corpus lists that refusal as one it must give. ## The review's fixes Every finding of the review but the error-correction decode bound (another change holds it) is fixed, each with a test that failed on the code before its fix: - **The planner hang.** The Clifford check of a program holding a gate whole counts its standard gates first and refuses past 16 controls (`Q208`) or `MAX_OPS` (`Q210`) before writing any (`ctrl(41) @ z` on 42 qubits, `ctrl(39) @ t`, a 42-qubit Grover iteration, `ctrl(24) @ p(0)`, a loop of `ctrl(16) @ p(0)`: refused at once, where each hung). A method's plan makes only the circuit it reads. The whole gate's phases are read exactly there, so `ctrl(16) @ p(1e-7)` is not taken for the identity. - **Over MCP**, a gate past 16 controls runs: a verdict with no intent reads the program as it ran. A job with an intent is checked in standard gates and refused there on its line. - **Refusals.** A named method that needs standard gates refuses as the reader does, on its line, with `Q208`/`Q210` and no `J011`; both refusals past 16 controls name `"options": {"controls": "whole"}`. `options.controls` is read: another value, or `"whole"` on a job that runs standard gates, is `J003`, and the schema, methods list, API description, README and both MCP servers name it. Gates held whole may take 2,000,000 qubits in all (`Q210`). - **Counts.** `lint`'s `dynamic_steps` counts standard steps beside `gates`; `operations` is an engine member a registered method may not write. - **The meter.** It counts each move of the orthogonality center and each one-qubit gate, holds the budget at each two-site update, and the plan walks the same steps (`WorkBound`), so the plan still bounds it; the pinned mps job's digest moves with its plan's `work`. A metered plan says `metered`, its `work` what the meter allows, and a metered job does not set the service's measured rate. Tests now run the meter at bonds the chain fills, stop a job with `J011` mid-run and for its shots, and price an update at the bond it spans. - **Phases.** `accuracy.global_phase` is stated against method statevector's state; the language's `U` and an uncontrolled `gphase` differ from it, and the note says so. `below_table` and `moved_angles` say they count the lowering's phase gates, at 1e-14 of a turn. - **The error-correction reader.** `PAULI_CHANNEL_1` takes every channel independent flips give, rates above 1/2 and parities of zero among them; text qubit 4294967295 (the carrier's index) and a correlated error with no index left are refused on their lines; `C_XYZ`/`C_ZYX` refuse arguments. `E`'s targets go through the same `touch` as every target, so a qubit bound there covers it, plus the one carrier qubit `lower` adds. The QEC page and the conformance set (a circuit, its model and a refusal) hold the new forms. - **Snapshots and docs.** `service-mcp.json`, `local-mcp.json` and `llms-full.txt` regenerated; the feature matrix, refusal table and service README say what changed. - **CI.** The new tests are required by name, and the state vector's gate under controls also runs under wasm32-wasip2. - **Mutants.** 14 planted faults (each of y, h, tdg, sx/sxdg, ry, u in the bit-exact whole form; phase_n's whole angle; the run's budget; the shots check; a meter that ignores the bond; the four accuracy members and the rounding guard) each fail a test. ## The comparison, rerun `reproduce.sh --tier full` on this branch's engine, on both hosts (`results/`, each file naming its trees): | file | host | pass | fail | known | refused as listed | not run | recorded | |---|---|---|---|---|---|---|---| | `conformance-macos-arm64.json` | Apple M3 Ultra, macOS 27.2 | 1743 | 0 | 11 | 10 | 12 | 12 | | `conformance-linux-x86_64.json` | AMD RYZEN AI MAX+ 395, Ubuntu 26.04.1 LTS | 1738 | 0 | 11 | 10 | 14 | 12 | Against #662's runs (1638 and 1637 pass): `color_d3`, `qec_correlated` and `qec_pauli_channel` now run and match the other engine mechanism by mechanism (largest difference 6.9e-18 against a bound of 2.6e-13 on the colour code), and their detection rates follow the model; `qec_refused_channel_with_no_independent_form` is refused, as listed. Every bit-exact state is held to OpenQASM's with the phase its result states (184 rows on Linux, largest ratio 0.14 of the bound). `mps_qft_n30_bond256` runs on `wai.mps`, exact (error 7e-19). The added not-run rows are the other engine's: its 900 s limit on `rotations_wide_n20` on Linux this time, and no model of the refused channel. The CI tier and the self-test (every fault caught) pass on macOS arm64 too. ## Timings, before and after, on one host Apple M3 Ultra (macOS 27.2, 32 logical CPUs), the same harness (`tools/perf.py`), the corpus branch's build then this branch's, one straight after the other, five runs each, median (`results/before-after-macos-arm64.json`). The host was shared: one-minute load 29 to 89 during the before build and 65 to 134 during the after build, so the after build ran under more load on every row. | case | engine | before | after | |---|---|---|---| | `grover_n10` | `wai.statevector` | 0.0156 s, 8,290 ops | 0.00018 s, 114 ops | | `grover_n14` | `wai.statevector` | 3.00 s, 131,214 ops | 0.0022 s, 158 ops | | `grover_n16` | `wai.statevector` | 16.3 s, 524,452 ops | 0.011 s, 180 ops | | `grover_n20` | `wai.statevector` | refused, `Q208` | 0.030 s, 224 ops | | `grover_n14` | `wai.exact` (default) | 8.48 s, 557,146 ops | 9.18 s, 557,146 ops, the same bits | | `grover_n14` | `wai.exact_whole` (asked) | 8.45 s, 557,146 ops | 0.0032 s, 158 ops | | `grover_n16` | `wai.exact_whole` (asked) | 151 s, 2,490,472 ops | 0.015 s, 180 ops | | `grover_n20` | `wai.exact_whole` (asked) | refused, `Q208` | 0.32 s, 224 ops | Every case without such a gate (QFT, rotation brickworks, tableaus, error-correction sampling, matrix product states) runs the same ops before and after; their times moved by the host's load, both ways. The other engines' rows are in the file, as data. ## Notes for review - The first commit records a first pass as it was left (uncommitted, unbuilt), so the review commit reads as changes to it. - `wai-quantum/src` changes fire every wai-quantum workflow. - Clippy on the engine crate itself fails on many files before this branch and is not a CI gate; this branch's new code adds no finding to it. 🤖 Generated with [Claude Code](https://claude.com/claude-code)

dcharlot added 15 commits 2026-11-06 09:15:29 -05:00

wai-quantum: the surface-code memory experiment at p = 0 writes the reference generator's text ... 112cc14bd3

quantum_frame::surface_code_memory documents that its text matches the
ecosystem's reference generator byte for byte. That held for every p > 0
and not for p = 0: there it wrote each noise instruction with probability
zero (DEPOLARIZE1(0) ..., X_ERROR(0) ...) and the first round's two resets on
two lines, where the reference writes no noise instruction and one reset.
The circuits meant the same thing, so the model and the samples were
unaffected; only the text differed.

It now writes no noise instruction of probability zero, and the two resets
as one instruction. A new fixture test, the reference generator's text at
d = 5 with four rounds and p = 0 (tests/data/memory_z_d5_noiseless.circuit),
failed before the change and passes after it. The fixture count pinned in
wai-quantum-processors.yml and wai-quantum-dsp.yml goes from 2 to 3.

The cross-simulator corpus found it (entry surface_z_d5_noiseless): the
engine's own generator checked against the pinned reference generator.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum: a cross-simulator conformance corpus, reproducible with one command ... ec4f2a5acc

wai/quantum-cross-simulator/ runs the engine beside pinned third-party
simulators on a published set of circuits and holds every answer to an
exact reference within a tolerance derived from the arithmetic that
produced it.

The corpus (tools/corpus.py, corpus/manifest.json with each circuit's
SHA-256): bit order, GHZ, QFT, Grover, phase estimation, random
Clifford+T, dyadic and arbitrary-angle circuits, mirror circuits, angles
at and below the fixed-point table's resolution, every gate of OpenQASM
3's standard library, measurement in the middle with reset and feedback,
stabilizer circuits to 5000 qubits, noise in closed form, wide circuits by
matrix product states and contraction, and error-correction memory
experiments to distance 15.

The references (tools/exact.py, standard library only): a state vector in
integers at scale 2^-256, exact distributions by walking every branch of a
dynamic program, and an integer stabilizer tableau with the reduced form
of a group. The bit-exact method's op-log is rerun by the existing referee
and must give the same integers and hash.

The tolerances (tools/tolerance.py): the bit-exact method's from the
extension's published bound summed over the op-log it ran; floating point
from a stated per-gate rounding model at each engine's fusion width;
sampled counts by Bernstein's inequality at a family-wise rate of 1e-6.
None is fitted to a result.

reproduce.sh fetches a pinned uv, CPython and every wheel by hash, builds
the engine with --locked, runs every check and prints PASS or FAIL.
--self-test injects six faults and passes only when each fails the run on
its own check. --perf measures run time and peak memory per engine.

provider/seeded_statevector_provider.py wraps a third-party simulator as a
process provider of wai.quantum.provider/1; provider/test.sh holds it to
the protocol's conformance vectors through `providers test`, runs it with
`run --provider` and verifies the receipt.

wai-quantum-cli/examples/cross_simulator.rs is the engine's side: one job
in, one answer out, through the calls the command line and the job service
make.

CI: the Linux leg of wai-quantum-cli.yml runs the CI tier, the self-test,
the provider template and the check that the page's results section is
what the committed results say.

Co-Authored-By: Claude Fable 5.1 <[email protected]>

wai-quantum: the cross-simulator corpus's results on two hosts, and its page ... 3e6ab36d2f

results/ holds four runs, each naming its host, every version and the git
trees of the engine and tools that produced it:

- conformance on macOS arm64 (M3 Ultra) and on Linux x86_64 (Ryzen AI Max+
  395), the full tier, from the tools as committed in the previous commit:
  1368 and 1363 checks pass, none fails. Two checks on each host are
  recorded as known disagreements of another engine with the exact
  reference, three are refusals by the engine under test of instructions
  its frame simulator does not implement, and seven (nine on Linux) were
  not run, each with its reason.
- run time and peak memory on the same two hosts, five runs a case, with
  the host's load average beside every case.

The page's results section is written from those files by tools/report.py,
and CI holds it to them. The page also says what disagreed and who was
right, what the corpus shows about conventions, where other engines are
faster (gates under many controls, and single precision on one thread),
and the limits of the comparison.

Three changes to the tools since the previous commit, none of which the
conformance run reads: a timing run on the stabilizer adapter measures one
qubit rather than reading the whole group out through the save
instruction's result, which had been most of its time; the memory baseline
uses a two-qubit job, which every adapter accepts; and the page's tables
print whole seconds and MiB, and a refusal's own words.

Co-Authored-By: Claude Fable 5.1 <[email protected]>

wai-quantum: a gate under many controls held as one op (first pass, before review) ... cd7841d4f7

The state a first pass left uncommitted, recorded as it was so that the review
and its fixes read as changes against it:

- qasm::read_whole keeps a gate whose standard form doubles with its
  controls as one op; Program::lowered writes it in standard gates, one
  lowering (qasm/controls.rs) behind both forms.
- StateVector::run_ops applies such a gate as one; the bit-exact simulator
  walks only the indices its controls leave on.
- The bit-exact method reports the global phase its lowering drops and the
  angles below its table; a named mps job runs metered on the bond it
  reaches; the error-correction reader takes C_XYZ, E and PAULI_CHANNEL_1.

Not yet built or tested as a whole; later commits review it.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum: the cross-simulator corpus's checks can fail where the review found they could not ... 3ba49a43ee

Each change below was shown first as a planted fault that the previous tools let
pass, then as a failure of the check it breaks:

- The engine under test is held to answering. A crash, a time-out or a
  refusal that corpus/expected-refusals.json does not list, in its words,
  fails the run; so does an answer to a circuit it must refuse. The bit-exact
  method's refusals are listed by its reader's rule, computed from the exact
  angles. A time-out kills the engine's whole process group.
- The bit-exact method's op-log, run in double precision, must give the
  circuit's exact state: a phase dropped in lowering now fails, where the
  distance and the referee could not see it. Each small-angle gate is checked
  held or dropped, exactly, on every engine.
- repeated_phase_k19 is held to the state with its phase, beside a quarter
  turn that a wrong sign cannot pass, and to the extension's stated figures.
- No closed-form row is exempt for the bit-exact method. QPE, Grover and the
  phase table are checked in integers, mirror_n10 by the referee.
- Matrix product states are charged what each engine reports it truncated;
  a row whose bound cannot see a wrong phase is recorded, not passed.
- Sampled counts are also held as a whole in L1 distance; the 40-qubit
  Clifford outcomes per outcome, per free bit and in number.
- The account of another engine's errors is corrected, and each claim is a
  case of a reproducer committed beside it.
- Timing records where each engine's timer runs (Aer's own experiment time),
  memory the peak of the process that ran the engine, threads what each was
  given, and ops what the engine ran.
- Provenance names the trees as they were on disk, and the toolchain the
  checkout picks. CI covers every kind of check but the wide pairwise one, on
  referee changes too, and its comment says so.
- The self-test injects every fault and requires its own check to fail, on
  its own engine only.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum: the bit-exact method keeps its bits, and gates count standard gates ... 062f371828

Review of the first pass:

- The bit-exact method's bits are the rounding of each gate it applies, so a
  gate held whole gives other bits than its standard gates. A job on exact now
  runs standard gates by default, and gives the hash it always gave; it holds
  such a gate whole only when asked, "options": {"controls": "whole"}.
  catalog::runs_whole takes the request, and the planner's bit-exact circuit
  is the one the method runs.
- A result's and lint's `gates` count standard gates however the method ran
  them, as they always have, so a receipt's provenance is unchanged;
  `operations` (new, optional) says what a method holding gates whole ran.
  The schemas say so.
- The comparison's driver follows the job path: whole on the state vector,
  standard on exact unless asked.
- The tests hold the default bit-exact hash to the one before the change.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

Merge the cross-simulator corpus's fixed checks into the reader-scaling branch ... df011db75a

compare.py is the corpus branch's, with this branch's changes made again on
it: the bit-exact method held to OpenQASM's state with the global phase its
result states; error-correction circuits with C_XYZ, E and PAULI_CHANNEL_1
compared, a model the other engine cannot give held by its sampler; a wide
entry that names its engines and bond. The expected refusals follow the
reader: the colour code, E and the Pauli channel are no longer refused, and a
channel with no independent form must be. A timed row runs the bit-exact
method asked to hold a gate whole.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum: the held-or-dropped check decides only where an answer can say ... c5702b44e0

The first full run on the M3 Ultra failed two checks on Aer at
below_grid_k60, whose phase of 2π/2^60 moves the state by 2.7e-18, far
below a double's rounding of an amplitude near 1: the share of the step its
answer took was rounding (−21), not a dropped gate. An engine now holds the
gate when its answer is within half the gate's effect of the ideal state,
drops it when within half of the state without it, and otherwise is recorded
as unable to say, not judged. A dropped gate inside the bound still fails
(the drop_phase fault at k = 48 is within 0 of the state without it).

The known disagreement on measure_twice now names the L1 check too, which
the same fault of the other engine fails.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum: the command line's committed tool list and docs follow the schemas, and the new code is clippy-clean ... 315d993ce3

- The job request's `options` says what `controls` does now: whole on the
  state vector by default, standard on the bit-exact method unless "whole".
- docs/local-mcp.json and docs/llms-full.txt regenerated from the binary
  (WAI_QUANTUM_BLESS=1); the command line's tests and smoke.sh pass.
- Clippy's findings in this branch's new code fixed; the crate's older
  findings are left as they are (clippy is not a gate on it).
- The changelog says that a bit-exact result now carries its accuracy
  members, so its JSON and receipt hold them.

Checked on Linux aarch64: the engine's tests with every feature (library
and integration, 14 targets), its debug test build, every feature subset
the workflows check under -D warnings, and the command line's tests and
smoke checks; the library tests on x86_64 too.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum: before_after.py compares a host by what it is, not its load, and shows the operations each build ran ... da3599b322

Co-Authored-By: Claude Opus 5.5 <[email protected]>

Merge the corpus branch's held-or-dropped fix into the reader-scaling branch ... 9be6a33cb0

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum: the feature matrix says the bit-exact method holds a gate whole only when asked ... d4282f6800

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum: the cross-simulator corpus rerun on both hosts, and its page as data ... fffd228757

Both hosts' full tiers, rerun on the tools of the two commits before this
one (their trees named in each results file):

- macOS arm64 (M3 Ultra): 1638 checks pass, 0 fail; 11 known (the other
  engine's two disagreements, now with their reproducers' cases), 12
  refusals as listed, 11 not run, 12 recorded and not judged.
- Linux x86_64 (Ryzen AI Max+ 395): 1637 pass, 0 fail; 11 known, 12
  refused as listed, 12 not run (the other engine's mirror_n20 timed out
  at 900 s), 12 recorded.
- The self-test catches every planted fault, each on its own check.

Timings rerun on both hosts with each engine's timer stated, its threads,
its ops, and the peak memory of the process that ran it.

The page states results as data: the ranking prose is gone, the account
of the other engine is corrected, repeated_phase_k19's figures are the
modulus and angle the extension states, and the limits say what each
sampled test can and cannot see. report.py prints each reproducer case.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum: the corpus page gives the full tier's time on both hosts ... 5f60cfcf89

Co-Authored-By: Claude Opus 5.5 <[email protected]>

Merge the corpus branch's results and page, with this branch's comparison and timings ... c16cb20861

The comparison rerun on this branch's engine (commit d4282f680; each file
names its trees):

- macOS arm64 (M3 Ultra): 1743 pass, 0 fail; 11 known, 10 refused as
  listed, 12 not run, 12 recorded.
- Linux x86_64 (Ryzen AI Max+ 395): 1738 pass, 0 fail; 11 known, 10
  refused as listed, 14 not run, 12 recorded.
- The colour code, a correlated error and a general Pauli channel match the
  other engine mechanism by mechanism, and their rates; a Pauli channel with
  no independent form is refused, as listed. The bit-exact method meets its
  bound against OpenQASM's state with the phase its result states, on every
  circuit. The 30-qubit QFT at max_bond 256 runs, exact.

Timings on both hosts, and before-after-macos-arm64.json: the same harness
on the corpus branch's build, then this branch's, on the M3 Ultra.

The page says what the results now state, and the hand-written Pauli
channel's reason is corrected: the other engine does give its model (only
the reason text changed after the runs, so the tools and corpus trees they name differ
from this commit's by that description).

Co-Authored-By: Claude Opus 5.5 <[email protected]>

dcharlot added 13 commits 2026-11-07 03:32:43 -05:00

wai-quantum: tests for the review of the reader-scaling branch, before its fixes ... 6f8f5d2b1e

Each fails on c16cb2086: a whole gate too large for standard gates hangs
the Clifford check; a tiny phase under many controls reads as Clifford; the
mps meter charges no move of the center, and holds the budget only per gate;
Pauli channels with exact independent rates above 1/2 are refused; the
carrier's index is accepted in text; C_XYZ takes arguments.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum: the review's fixes on the reader-scaling branch ... baff4c2a9b

- The Clifford check of a program holding a gate whole counts its standard
  gates first (Program::standard_within, the count `lowered` already used)
  and refuses past 16 controls (Q208) and past MAX_OPS (Q210) before
  writing any. `ctrl(41) @ z` on 42 qubits, `ctrl(39) @ t`, a Grover
  iteration on 42 qubits, `ctrl(24) @ p(0)` and a loop of `ctrl(16) @ p(0)`
  hung the planner (each method, `auto` and a dry run) with memory growing;
  they are refused at once.
- A method's plan makes only the circuit it reads: the bit-exact circuit
  for `exact`, the Clifford gates for `stabilizer`.
- The whole gate's standard gates are read exactly in that check: a phase
  under many controls smaller than the reader's tolerance
  (`ctrl(16) @ p(1e-7)`) is not taken for none.
- The mps meter counts each move of the orthogonality center and each
  one-qubit gate, and holds the budget at each two-site update, inside a gate
  that crosses the chain. The plan walks the same steps at the bond asked
  for (WorkBound, over Program::local_steps, the walk local_matrices
  writes), so it still bounds the meter.
- PAULI_CHANNEL_1 takes every channel independent flips can give, rates
  above 1/2 and parities of zero among them.
- The frame reader refuses qubit 4294967295, the carrier's index, and a
  correlated error whose carrier has no index left (4294967294 named), at
  their lines; C_XYZ and C_ZYX refuse arguments.
- The pinned mps job's digest moves with its plan's work, which now counts
  its one-qubit gates (975d7a6a… before); the CLI's llms-full.txt is
  regenerated (its feature table already said `exact` holds a gate whole
  only when asked).

Co-Authored-By: Claude Opus 5.5 <[email protected]>

Merge the corpus branch, with main ... 88e2daa95c

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum: tests for the rest of the reader-scaling review, before its fixes ... eb504d6b2c

Two seams with no behaviour come with them: a test's budget for an mps
run, and a plan's `metered`, false everywhere so far.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum: the rest of the review's fixes on the reader-scaling branch ... 55208351c3

- A named method that needs standard gates reads them, so a program they
  cannot hold is refused as the reader refuses it: on its line, with Q208
  or Q210 and no J011. Both refusals past 16 controls say how a job holds
  the gate, and no longer say the bit-exact method does so by default.
- A verdict with no intent reads the program as it ran, so a gate past 16
  controls runs over MCP, as the docs say; an intent is checked in
  standard gates, and a job with one is refused there, on its line.
- lint's dynamic_steps counts standard steps, beside gates.
- options.controls is read: another value, or "whole" on a job that runs
  standard gates, is refused (J003), and the schema, methods list, API
  description, README and both MCP servers name it.
- accuracy.global_phase is stated against method statevector's state, not
  the language's, whose U and gphase differ from it; below_table and
  moved_angles say they count phase gates, at 1e-14 of a turn.
- operations is an engine member.
- Gates held whole may take 2,000,000 qubits in all (Q210), which holds
  nothing the standard form holds.
- A metered plan says `metered`, its work what the meter allows, and such a
  job does not set the method's measured rate.
- The refusal, service and QEC pages and the corpus say what changed; the
  tests are named in CI; the conformance set holds the new text forms; the
  service snapshot and the agent docs are regenerated.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum: Q210 says what else it refuses, and the state vector's gate under controls is tested under wasm ... 0051cdeb19

Co-Authored-By: Claude Opus 5.5 <[email protected]>

Merge main ... a5c9628db1

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum: the example's plan, a comment for a macro, and a type for the walk's step ... 572d0d27b9

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum: a request's options keep the members the methods list names ... 9324f1fab0

Naming `controls` in the schema made the strict check refuse the others.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

Merge main ... f72cdaebaa

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum: the new tests take no time bound a loaded host could pass ... 3d948f6d8f

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum: the corpus rerun at the review's fixes, on both hosts ... caece6677e

The same counts as before them: 1743 pass on macOS arm64, 1738 on Linux
x86_64, none failing; the self-test catches its 23 faults on each.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

Merge main ... e8e99272ee

Co-Authored-By: Claude Opus 5.5 <[email protected]>

dcharlot merged commit e5cbe7ccbe into main 2026-11-07 03:34:06 -05:00

dcharlot referenced this pull request from a commit 2026-11-07 03:34:08 -05:00

Merge pull request 'wai-quantum: a gate under many controls stays one operation on the state vector, the bit-exact method states what its lowering did, and the error-correction reader takes C_XYZ, E and PAULI_CHANNEL_1' (#675) from wai/quantum-reader-scaling into main

dcharlot referenced this pull request 2026-11-07 08:11:58 -05:00

wai-quantum: no anonymous request ends the job service or holds it without limit #676

Sign in to join this conversation.

Reviewers

No reviewers

Labels

Clear labels

No items

No labels

Milestone

Clear milestone

No items

No milestone

Projects

Clear projects

No items

No project

Assignees

Clear assignees

No assignees

1 participant

Notifications

Subscribe

Due date

The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference

Transaction-Science/open-standards!675

No description provided.