wai-quantum: jobs placed on certified GPU members or split over several, byte for byte the CPU's; Clifford+T as sums of stabilizer states #557

Merged

dcharlot merged 7 commits from wai/quantum-scale-out into main 2026-10-31 14:53:38 -04:00

Conversation 0 Commits 7 Files changed 49 +10009 -116

dcharlot commented 2026-10-31 11:33:03 -04:00

Owner

Copy link

A job can now say where its state vector runs: on the CPU, on a GPU member found on the host, or split over several. Only a member certified bit-exact against the CPU is used, so a placed job's answers are the CPU's byte for byte, and its receipt names where it ran. Clifford+T circuits gain a method of their own, stabilizer_rank: a sum of stabilizer states, exact or sampled with a stated bound. With nothing asked for, every plan and result is what it was.

What it adds

Placement (engine::fabric, feature quantum_fabric)

• A job's new fabric is auto (the default), cpu, accelerator, a member's id or key, or a list of members whose length is a power of two.
• The CUDA, HIP and OpenCL f64 state-vector members are discovered once per process and certified against the CPU on the pinned corpus (SV_DEFAULT). Only a member certified bit-exact is placed. OpenCL devices without binary64 are listed as refused.
• auto places on the CPU on every host and looks for no member. With per-gate launches and the state copied to the device and back, a whole job measured about as fast, or slower, on the fleet's GPUs (22 qubits on the laptop GPU: 159 ms on the CPU, 202 ms placed), and a planner must not route by default to a path that is not better.
• A member runs a job only when the job asks. accelerator takes the first certified member that holds the state, and one that fails during the run hands the job to the next. The receipt lists each that failed (fell_back_from, each with how it failed). When every one fails, the job is refused. A member named by id or key is used alone.
• A placement the host cannot honour is refused with the new code J013, never made elsewhere. Asking for a member puts auto onto statevector; other methods, mid-circuit programs and device targets refuse one.
• A build without quantum_fabric (the desktop app, the browser engine, the contract's build) reads every fabric and refuses all but auto (J013), with a test of its own.

Several devices on one node

• sv64::run_split splits the state by its top qubits, one partition on each member. Each partition runs the CPU's own launches. A gate on a partition qubit first has that qubit exchanged with a local one through the host's copy, so the joined state is bit-identical to the CPU's.
• Ground truth: CPU partitions equal the CPU's state vector bit for bit over the pinned corpus at every partition count, and on 12–16-qubit states with exchanges.
• Each member states the largest state it holds (max_qubits); a state or partition past it is refused at plan time.

The receipt. A placed result, or one that asked for a placement, carries fabric: the kernel, what was asked, the member, its key and class, the implementation, the parity tier, the certificate's digest, the corpus, and the energy (unmetered, with the reason). The job's receipt seals it, and the provenance's computer.fabric names the members.

Stabilizer-rank Clifford+T (quantum_stabrank, method stabilizer_rank)

• A T gate is (e^{iπ/8} I + e^{−iπ/8} S) / (2 cos π/8), so a circuit with t of them is a sum of 2^t Clifford circuits of equal weight.
• The new PhasedTableau::amplitudes gives every amplitude of a stabilizer state exactly from one reduction of the stabilizers.
• Every term is a power of 1/√2 at a whole number of sixteenths of a turn, counted as a whole number (ExactSum). The sum does not depend on how the branches are split between threads, and is evaluated once in double precision.
• An expectation value is the amplitude ⟨0|U†PU|0⟩ of one circuit with twice the T gates.
• Exact mode: terms grow as 2^t (4^t for an expectation value). Sampled mode (terms, or epsilon, at confidence): branches drawn uniformly, seeded, each from a stream of its own. The estimate is unbiased with mean squared distance (sec²(π/8)^t − 1)/terms, and the bound computed from t, terms and confidence is stated beside each value.
• Program::clifford_t lowers t, tdg, p/rz/rx/ry at odd multiples of π/4, cp at odd multiples of π/2, ccz and ccx, with the global phase kept exactly.
• Every amplitude of random Clifford+T circuits (up to 7 qubits and 10 T gates), and of random programs through the job engine, equals the dense state vector's, phase and all, within 10⁻¹² by fidelity; expectation values likewise. The sampled bound holds in at least its stated fraction of seeds.
• The planner names it, and auto chooses it by T count, for amplitudes or expectation values past the dense state vector, within one job's work: 2×10¹² tableau word operations, calibrated at about 4×10¹⁰ a second on a 16-core host (t = 12: 0.03 s; t = 16: 0.3 s; t = 18: 1.06 s).

Surfaces

• CLI: repeatable run --fabric, and wai-quantum fabric [--json], which lists the members with their limits and states the auto rule. New features cuda, hip and opencl.
• Both MCP servers: fabric in the job tools, and list_fabric on the command line's server.
• Service: reads fabric, and places only on its CPU.
• Studio: the method's plain name, "Stabilizer-rank sum" (稳定子秩求和).
• Schemas: optional members of the job request, job result and provenance, and fabric_members in the tools schema. The optional t_count, terms, bound and confidence in the result schema.
• Docs: the guide, CLI help, the engine, CLI and service READMEs (en and zh-CN), the methods list and the changelog. The agent docs are re-blessed.
• CI: hardware placement steps in wai-quantum-cuda.yml and wai-quantum-hip.yml, which ask for accelerator and check that auto names nothing, and absent-device steps. The CUDA absent job runs the CPU-partition and fabric tests by name in a container. The new library tests also run in wai-energy-receipts.yml on linux, linux-arm64 and macos.

Checked

Where	Result
Linux build host	Engine --features full --lib --tests: 1075 passed, every test binary ok, fabric_placement 5 passed. Without the fabric (contract set), engine::schema:: engine::fabric::: 11 passed. CLI: 69 + 5 + 5 + 2 + 2 + 1 passed; clippy -D warnings clean by default, with --no-default-features and with --features cuda,hip,opencl. Service: 37 + 1; mcp:: 14. CLI and service smoke: every check held. Breaking gate: only new items, no unacknowledged break. Repository checks: every line ok.
jetson-hub (laptop GPU, compute capability 8.9)	fabric_placement with CUDA and OpenCL: 5 passed, members gpu-cuda-sm89, opencl-cpu-8086, opencl-gpu-10de. One state split four ways (gpu-cuda-sm89, opencl-gpu-10de, opencl-cpu-8086 and the CPU) gives the CPU's answers byte for byte. cuda_sv and opencl_sv: 3 and 3 passed, digests pinned, mutants killed. The placement step, replayed after auto moved to the CPU: 5 passed.
framework-128gb (integrated GPU, gfx1151)	hip_sv: 3 passed. fabric_placement with HIP and OpenCL: 5 passed, the split gpu-hip-gfx1151 + opencl-gpu-1002 byte for byte. The placement step, replayed after auto moved to the CPU: 5 passed.
macOS build host	hardware, telemetry and locales: every check passed. build-views --check: ok. studio.test.mjs twice with the bundled browser: every check passed.
After rebasing onto the variational PR (Linux build host)	build-views --check: the committed page is built from its 49 sources. Service mcp::: 14 passed. CLI: 72 passed (bin) and every integration target; clippy with cuda,hip,opencl clean. Service: 37 + 1. wai-web native: 29 passed. Engine --features full: 1148 lib tests passed and every test binary (engine::fabric 5, variational 11, pulse 7, formats 24, quantum_stabrank 4). The contract feature sets' fabric and schema tests: 12 and 11 passed. CLI and service smoke: every check held. Breaking gate: no unacknowledged break. Repository checks: all 10 lines ok. check_schemas.py: 29 tools valid, 47 tool answers follow their schemas.
After rebasing onto the variational PR (macOS build host)	wai-web wasm32: 21 passed. hardware, telemetry, update and locales: every check passed. studio.test.mjs twice: every check passed.
On main 886eec584	This PR's commits sit on the variational PR as merged, so the tree under them is main's. Since the rows above, main also gained the receipt ledger's tariff version 3 (#550), the route record's version 2 (#552) and the formats PR's change to wai-conformance.yml. Every changed line is main's, and no crate this PR changes compiles them (none depends on wai-rs), so nothing was run again by hand; this PR's CI runs every leg.
After this PR's CI (macOS build host)	The Python workflow found the getting-started notebook's stored method list without stabilizer_rank (bda065b52 adds its line). wai-quantum-py/ci/check.sh: 78 passed, 5 of 5 notebooks ran and matched (36 code cells), smoke passed.

The views page was rebuilt (005584ee5) with wai/wai-quantum-views/build.sh in catthehacker/ubuntu:act-22.04 with Rust 1.98.0, as the views workflow rebuilds it: the Studio's method names feed it, and it carries this branch's engine.

Not done

• No true multi-GPU or multi-node run. No host of the fleet has two f64 GPUs (the Iris Xe has no binary64), so several devices were shown with one GPU through two backends, the CPU through OpenCL, and the CPU reference.
• Pauli propagation on a GPU. The follow-up PR keeps the state on the device between gates, places by measurement, and adds it.
• Placement in the Studio: its wasm engine has no fabric, so it refuses every placement but auto.

Breaking

None. The breaking gate lists only new items, and the changelog acknowledges no break.

🤖 Generated with Claude Code

A job can now say where its state vector runs: on the CPU, on a GPU member found on the host, or split over several. Only a member certified bit-exact against the CPU is used, so a placed job's answers are the CPU's byte for byte, and its receipt names where it ran. Clifford+T circuits gain a method of their own, `stabilizer_rank`: a sum of stabilizer states, exact or sampled with a stated bound. With nothing asked for, every plan and result is what it was. ## What it adds **Placement** (`engine::fabric`, feature `quantum_fabric`) - A job's new `fabric` is `auto` (the default), `cpu`, `accelerator`, a member's id or key, or a list of members whose length is a power of two. - The CUDA, HIP and OpenCL f64 state-vector members are discovered once per process and certified against the CPU on the pinned corpus (`SV_DEFAULT`). Only a member certified bit-exact is placed. OpenCL devices without binary64 are listed as refused. - `auto` places on the CPU on every host and looks for no member. With per-gate launches and the state copied to the device and back, a whole job measured about as fast, or slower, on the fleet's GPUs (22 qubits on the laptop GPU: 159 ms on the CPU, 202 ms placed), and a planner must not route by default to a path that is not better. - A member runs a job only when the job asks. `accelerator` takes the first certified member that holds the state, and one that fails during the run hands the job to the next. The receipt lists each that failed (`fell_back_from`, each with how it failed). When every one fails, the job is refused. A member named by id or key is used alone. - A placement the host cannot honour is refused with the new code `J013`, never made elsewhere. Asking for a member puts `auto` onto `statevector`; other methods, mid-circuit programs and device targets refuse one. - A build without `quantum_fabric` (the desktop app, the browser engine, the contract's build) reads every `fabric` and refuses all but `auto` (`J013`), with a test of its own. **Several devices on one node** - `sv64::run_split` splits the state by its top qubits, one partition on each member. Each partition runs the CPU's own launches. A gate on a partition qubit first has that qubit exchanged with a local one through the host's copy, so the joined state is bit-identical to the CPU's. - Ground truth: CPU partitions equal the CPU's state vector bit for bit over the pinned corpus at every partition count, and on 12–16-qubit states with exchanges. - Each member states the largest state it holds (`max_qubits`); a state or partition past it is refused at plan time. **The receipt.** A placed result, or one that asked for a placement, carries `fabric`: the kernel, what was asked, the member, its key and class, the implementation, the parity tier, the certificate's digest, the corpus, and the energy (unmetered, with the reason). The job's receipt seals it, and the provenance's `computer.fabric` names the members. **Stabilizer-rank Clifford+T** (`quantum_stabrank`, method `stabilizer_rank`) - A T gate is (e^{iπ/8} I + e^{−iπ/8} S) / (2 cos π/8), so a circuit with t of them is a sum of 2^t Clifford circuits of equal weight. - The new `PhasedTableau::amplitudes` gives every amplitude of a stabilizer state exactly from one reduction of the stabilizers. - Every term is a power of 1/√2 at a whole number of sixteenths of a turn, counted as a whole number (`ExactSum`). The sum does not depend on how the branches are split between threads, and is evaluated once in double precision. - An expectation value is the amplitude ⟨0|U†PU|0⟩ of one circuit with twice the T gates. - Exact mode: terms grow as 2^t (4^t for an expectation value). Sampled mode (`terms`, or `epsilon`, at `confidence`): branches drawn uniformly, seeded, each from a stream of its own. The estimate is unbiased with mean squared distance (sec²(π/8)^t − 1)/terms, and the bound computed from t, terms and confidence is stated beside each value. - `Program::clifford_t` lowers `t`, `tdg`, `p`/`rz`/`rx`/`ry` at odd multiples of π/4, `cp` at odd multiples of π/2, `ccz` and `ccx`, with the global phase kept exactly. - Every amplitude of random Clifford+T circuits (up to 7 qubits and 10 T gates), and of random programs through the job engine, equals the dense state vector's, phase and all, within 10⁻¹² by fidelity; expectation values likewise. The sampled bound holds in at least its stated fraction of seeds. - The planner names it, and `auto` chooses it by T count, for amplitudes or expectation values past the dense state vector, within one job's work: 2×10¹² tableau word operations, calibrated at about 4×10¹⁰ a second on a 16-core host (t = 12: 0.03 s; t = 16: 0.3 s; t = 18: 1.06 s). **Surfaces** - CLI: repeatable `run --fabric`, and `wai-quantum fabric [--json]`, which lists the members with their limits and states the `auto` rule. New features `cuda`, `hip` and `opencl`. - Both MCP servers: `fabric` in the job tools, and `list_fabric` on the command line's server. - Service: reads `fabric`, and places only on its CPU. - Studio: the method's plain name, "Stabilizer-rank sum" (稳定子秩求和). - Schemas: optional members of the job request, job result and provenance, and `fabric_members` in the tools schema. The optional `t_count`, `terms`, `bound` and `confidence` in the result schema. - Docs: the guide, CLI help, the engine, CLI and service READMEs (en and zh-CN), the methods list and the changelog. The agent docs are re-blessed. - CI: hardware placement steps in `wai-quantum-cuda.yml` and `wai-quantum-hip.yml`, which ask for `accelerator` and check that `auto` names nothing, and absent-device steps. The CUDA absent job runs the CPU-partition and fabric tests by name in a container. The new library tests also run in `wai-energy-receipts.yml` on linux, linux-arm64 and macos. ## Checked | Where | Result | |---|---| | Linux build host | Engine `--features full --lib --tests`: 1075 passed, every test binary ok, `fabric_placement` 5 passed. Without the fabric (contract set), `engine::schema:: engine::fabric::`: 11 passed. CLI: 69 + 5 + 5 + 2 + 2 + 1 passed; clippy `-D warnings` clean by default, with `--no-default-features` and with `--features cuda,hip,opencl`. Service: 37 + 1; `mcp::` 14. CLI and service smoke: every check held. Breaking gate: only new items, no unacknowledged break. Repository checks: every line ok. | | jetson-hub (laptop GPU, compute capability 8.9) | `fabric_placement` with CUDA and OpenCL: 5 passed, members `gpu-cuda-sm89`, `opencl-cpu-8086`, `opencl-gpu-10de`. One state split four ways (`gpu-cuda-sm89`, `opencl-gpu-10de`, `opencl-cpu-8086` and the CPU) gives the CPU's answers byte for byte. `cuda_sv` and `opencl_sv`: 3 and 3 passed, digests pinned, mutants killed. The placement step, replayed after `auto` moved to the CPU: 5 passed. | | framework-128gb (integrated GPU, gfx1151) | `hip_sv`: 3 passed. `fabric_placement` with HIP and OpenCL: 5 passed, the split `gpu-hip-gfx1151` + `opencl-gpu-1002` byte for byte. The placement step, replayed after `auto` moved to the CPU: 5 passed. | | macOS build host | `hardware`, `telemetry` and `locales`: every check passed. `build-views --check`: ok. `studio.test.mjs` twice with the bundled browser: every check passed. | | After rebasing onto the variational PR (Linux build host) | `build-views --check`: the committed page is built from its 49 sources. Service `mcp::`: 14 passed. CLI: 72 passed (bin) and every integration target; clippy with `cuda,hip,opencl` clean. Service: 37 + 1. wai-web native: 29 passed. Engine `--features full`: 1148 lib tests passed and every test binary (`engine::fabric` 5, `variational` 11, `pulse` 7, `formats` 24, `quantum_stabrank` 4). The contract feature sets' fabric and schema tests: 12 and 11 passed. CLI and service smoke: every check held. Breaking gate: no unacknowledged break. Repository checks: all 10 lines ok. `check_schemas.py`: 29 tools valid, 47 tool answers follow their schemas. | | After rebasing onto the variational PR (macOS build host) | wai-web wasm32: 21 passed. `hardware`, `telemetry`, `update` and `locales`: every check passed. `studio.test.mjs` twice: every check passed. | | On main `886eec584` | This PR's commits sit on the variational PR as merged, so the tree under them is main's. Since the rows above, main also gained the receipt ledger's tariff version 3 (#550), the route record's version 2 (#552) and the formats PR's change to `wai-conformance.yml`. Every changed line is main's, and no crate this PR changes compiles them (none depends on `wai-rs`), so nothing was run again by hand; this PR's CI runs every leg. | | After this PR's CI (macOS build host) | The Python workflow found the getting-started notebook's stored method list without `stabilizer_rank` (`bda065b52` adds its line). `wai-quantum-py/ci/check.sh`: 78 passed, 5 of 5 notebooks ran and matched (36 code cells), smoke passed. | **The views page** was rebuilt (`005584ee5`) with `wai/wai-quantum-views/build.sh` in `catthehacker/ubuntu:act-22.04` with Rust 1.98.0, as the views workflow rebuilds it: the Studio's method names feed it, and it carries this branch's engine. ## Not done - No true multi-GPU or multi-node run. No host of the fleet has two f64 GPUs (the Iris Xe has no binary64), so several devices were shown with one GPU through two backends, the CPU through OpenCL, and the CPU reference. - Pauli propagation on a GPU. The follow-up PR keeps the state on the device between gates, places by measurement, and adds it. - Placement in the Studio: its wasm engine has no fabric, so it refuses every placement but `auto`. ## Breaking None. The breaking gate lists only new items, and the changelog acknowledges no break. 🤖 Generated with [Claude Code](https://claude.com/claude-code)

dcharlot added 6 commits 2026-10-31 11:33:03 -04:00

wai-quantum: the state vector placed on the fabric's members, and split over several ... a0bd65d6af

A job's new `fabric` says where the statevector method's state runs: auto
(the default), cpu, accelerator, a member's id or key, or a list of members
(a power of two), the state split by its top qubits into one partition on
each. The CUDA, HIP and OpenCL members' f64 state vectors are discovered
once per process and certified against the CPU on the pinned corpus; only a
member certified bit-exact is placed, so a placed job's answers are the
CPU's byte for byte. A placement the host cannot honour is refused (J013),
never made elsewhere. With no member asked for and none placed, the plan and
the result are what they always were: the existing pins hold.

The partitioned run (sv64::run_split) runs the launches the CPU plans on each
partition's amplitudes; a gate on a partition qubit first has that qubit
exchanged with a local one through the host's copy. Ground truth first: CPU
partitions equal the CPU's state vector bit for bit over the pinned corpus at
every partition count and on wide states with exchanges. On the fleet, one
state split four ways over a laptop GPU (by two backends), the CPU by OpenCL
and the CPU reference gives the CPU's answers byte for byte, as does the
integrated GPU by HIP beside OpenCL.

The result carries `fabric` (member, parity tier, certificate digest, corpus,
energy unmetered with the reason), sealed by the job's receipt, and its
provenance names the members: optional members of the job request, job result
and provenance schemas, and fabric_members in the tools schema. Surfaces:
`wai-quantum run --fabric` and `wai-quantum fabric`, the CLI's cuda, hip and
opencl features, `fabric` in both MCP servers' job tools and `list_fabric` on
the command line's, the service reading it. Members gain run_launches and
max_qubits. Hardware legs in the CUDA and HIP workflows, absent legs and the
CPU-partition tests by name in containers.

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

wai-quantum: Clifford+T circuits as sums of stabilizer states (stabilizer_rank) ... 57638f48a5

A T gate is (e^{iπ/8} I + e^{−iπ/8} S) / (2 cos π/8), and T† its conjugate,
so a circuit with t of them is a sum of 2^t Clifford circuits of equal
weight. quantum_stabrank walks every branch on the phased tableau, whose new
PhasedTableau::amplitudes gives every amplitude of a stabilizer state exactly
from one reduction of the stabilizers (d = x ⊕ r in the X span, the phase
read off the product of pivot rows). Every term is a power of 1/√2 at a whole
number of sixteenths of a turn, counted as a whole number (ExactSum), so the
sum does not depend on how the branches are split between threads and is
evaluated once in double precision. An expectation value is the amplitude
⟨0|U†PU|0⟩ of one circuit with twice the T gates.

Exact mode: terms grow as 2^t (4^t for an expectation value). Sampled mode
(terms, or epsilon, at confidence): branches drawn uniformly, seeded, each
from a stream of its own; the estimate is unbiased with mean squared distance
(sec²(π/8)^t − 1)/terms, so each value is within
sqrt((sec²(π/8)^t − 1)/(terms·(1 − confidence))) with the stated probability,
computed from t, terms and confidence and stated beside each value.

Program::clifford_t lowers t, tdg, p/rz/rx/ry at odd multiples of π/4, cp at
odd multiples of π/2, ccz and ccx, with the global phase kept exactly.
Ground truth first: every amplitude of random Clifford+T circuits (up to 7
qubits, 10 T gates) and of random programs through the job engine equals the
dense state vector's, phase and all, within 1e-12, by fidelity; expectation
values likewise; the sampled bound holds in at least its stated fraction of
seeds, measured on the whole state. The planner names stabilizer_rank and
auto chooses it by T count (amplitudes or expectation values past the dense
state vector, its branches within one job's work, calibrated at about 4e10
tableau word operations a second on a 16-core host). Optional t_count, terms,
bound and confidence in the result schema; the methods list, both MCP
servers, the service and the docs name it.

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

wai-quantum: a build without the fabric honours only auto placement, and says so ... 21b9369471

The engine without quantum_fabric (the desktop app, the browser engine, the
contract's build) reads every `fabric` and refuses all but auto (J013), with a
test of its own; the placement tests that need the fabric are gated on it, and
the helpers only the fabric uses are compiled only with it, so those builds
carry no dead code.

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

wai-quantum: auto keeps the state vector on the CPU until a member is measured faster ... 780b0526ce

With one launch per gate and the state copied to the device and back, a
whole job measured about as fast, or slower on the GPU, between 18 and 22
qubits on the fleet's GPUs (22 qubits on the laptop GPU: 159 ms on the CPU,
202 ms placed). A planner must not route by default to a path that is not
better, so `auto` now places on the CPU on every host and looks for no
member: a job that does not ask runs as it always did, its result unnamed.

A member runs a job only when the job asks: `accelerator` takes the first
certified member that holds the state, and one that fails during the run
hands the job to the next, the receipt listing each that failed
(`fell_back_from`, now a list, each with how it failed); when every one
fails the job is refused (J013). A member named by id or key is alone.
Discovery, certification, the receipt's fabric block, the split and
`wai-quantum fabric` are as they were; `fabric_members` states `auto`
instead of a threshold. A test with stand-in devices holds the fall-back to
the CPU's bits and to the schema.

The hardware legs ask for `accelerator` and check that auto names nothing;
both replayed on jetson-hub and framework-128gb. Docs, help, both MCP
servers' descriptions, the guide and the changelog say so; agent docs
re-blessed.

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

quantum-studio: the stabilizer-rank sum by its plain name, and the views page rebuilt ... a11492f913

The Studio's method names gain stabilizer_rank, "Stabilizer-rank sum" in
English and its Simplified Chinese, so a plan or result made by it shows a
name rather than the method's key. The Studio's words feed the bundled views
page, so the page is rebuilt in the CI image (act-22.04, Rust 1.98.0,
wasm32-unknown-unknown), where build-views --check holds it to its 48
sources; it carries this branch's engine too.

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

wai-quantum: the agent docs blessed and the views page rebuilt with the fabric, the stabilizer-rank method and everything before them ... 6c4f6d5154

The views page was rebuilt with wai/wai-quantum-views/build.sh in catthehacker/ubuntu:act-22.04
with Rust 1.98.0, as the views workflow rebuilds it.

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

dcharlot added 1 commit 2026-10-31 13:39:30 -04:00

wai-quantum-py: the getting-started notebook's method list names stabilizer_rank ... bda065b52f

The notebook prints every method with its accuracy, and the Python
workflow holds each cell to its stored output. The stabilizer-rank
method is new in this branch, so its line goes into the stored output,
in the engine's order. Nothing else in any notebook's outputs changed.

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

dcharlot merged commit 2820e1e578 into main 2026-10-31 14:53:38 -04:00

dcharlot referenced this pull request from a commit 2026-10-31 14:53:40 -04:00

Merge pull request 'wai-quantum: jobs placed on certified GPU members or split over several, byte for byte the CPU's; Clifford+T as sums of stabilizer states' (#557) from wai/quantum-scale-out into main

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!557

No description provided.