wai-quantum: pulse programs simulated under a Lindblad master equation, the same bits everywhere, their receipts binding the calibrations #551

Merged

dcharlot merged 10 commits from wai/quantum-pulse into main 2026-10-31 07:15:50 -04:00

Conversation 0 Commits 10 Files changed 64 +15166 -435

dcharlot commented 2026-10-30 12:24:37 -04:00

Owner

Copy link

Pulse programs now run as simulations: OpenPulse calibrations are read into a schedule on frames, simulated under a Lindblad master equation with a stated error bound, and run as jobs whose receipts bind the program, its calibrations, the device and the integrator. The result is the same bits on every platform. This adds no hardware pulse access.

What it adds

The OpenPulse reader (qasm::pulse, on the OpenQASM 3 reader)

• Reads cal and defcal on physical qubits, with ports (d0, m0, a0, or mapped in pulse.ports) and frames with times of their own.
• Waveforms: constant, gaussian, sech, gaussian_square, drag, sine, and explicit samples.
• Instructions: play, delay, shift_phase, set_phase, shift_frequency, set_frequency, capture (and capture_v0..v4), and barriers.
• A gate starts when its qubits and frames are free, and a frame's carrier runs on across a change of frequency. Durations are whole samples of dt.
• Refusals: the new codes Q453–Q462, added after Q452 with nothing renumbered, each with its line and column.

The simulator (quantum_pulse, in quantum_engine and full)

• Two or three levels per qubit in the rotating frame, with T1 relaxation, T2 dephasing and static ZZ couplings.
• A fixed-step, twelfth-order Taylor series, using only + − × ÷, sqrt and the repository's deterministic trigonometry.
• A proved trace-norm truncation bound, with a rounding estimate beside it. It refuses a step past 1/λ, or a run whose error would exceed its tolerance, and names the steps that would meet it (J041).
• Held to closed forms within that bound: Rabi turns, the phase axis, detuned drives, T1 decay and T2 dephasing. The final density matrix's digest is pinned and is the same on x86_64 Linux, arm64 macOS, wasm32-wasip2 and wasm32 in the browser.

Jobs (engine::pulse, method pulse)

• Each qubit's parameters come from pulse.qubits, else from a target's calibration snapshot, else from defaults, and the result says which.
• The receipt binds:
  • pulse.calibration: digests of the program, its calibrations, the schedule and the device, plus the target's name, hash and calibration id;
  • pulse.integrator: the integrator and its step;
  • pulse.density_hash: the final state's bits.
• engine::pulse::check re-runs a sealed job and names every field that differs.
• New job codes J040 and J041.

Surfaces

• CLI: run --method pulse --pulse OPTIONS (and plan), pulse schedule (a timeline per frame), and pulse check.
• Both MCP servers: the new tools pulse_schedule and pulse_check. The run tools gain the method pulse and the pulse options.
• Service: pulse jobs run through /v1/jobs and /v1/run. New routes POST /v1/pulse/schedule and /v1/pulse/check, with OpenAPI entries.
• wasm: QuantumEngine.pulse.
• Studio: a Pulse pane that draws the schedule as a timeline (lanes, envelopes, captures, barriers and gate calls), shows refusals with their codes, and runs the program with its bound and receipt digests.
• Desktop: a pulse command.
• Docs: docs/pulse.md, plus the READMEs (engine and CLI with their zh-CN pages, the service and the Studio), the feature matrix and the changelog.

Bounds on the service

• The system is at most 16 dimensions (MAX_DIM).
• The reader caps samples (2²²), waveform samples (2²⁰), instructions (2²⁰) and calls (2¹⁸).
• A program is at most 1 MiB.
• A pulse check re-runs its job, so it is held to 2×10¹⁰ multiply-adds. Past that, it names the local command.
• A pulse job is held to the simulator's 4×10¹¹. At its nominal rate of 10⁹ per second, the job's time limit is about 400 s, after which its worker is killed, as for every other method.

Checked

Where	Result
Linux build host	Engine --features full --lib: 1087 passed. The pulse workflow's job, replayed: 26 passed; three feature sets clean under -D warnings. Service: mcp:: 14 passed, then the full suite 37 + 1. CLI: 70 passed (bin), every target passed. wai-web quantum_engine::: 27 passed.
Linux build host, smoke and gates	CLI and service smoke.sh passed. check_schemas.py: 42 tool answers valid. Breaking gate: no unacknowledged break. Repository checks: all 10 lines ok. check_docs.py on docs/pulse.md: every block passed.
macOS build host	Pinned bits in debug and release: 2 passed each. wasip2 under wasmtime: 26 passed. wai-web wasm32: 19 passed. studio.test.mjs run twice: 246 checks passed, none failed. Desktop: 15 passed.
After rebasing onto main 4902e6679 (macOS build host)	The Studio's browserless tests passed (hardware, telemetry, update, locales). build-views --check passed after the views page was rebuilt (see below). studio.test.mjs run twice: every check passed. Desktop: 18 passed (17 plus pulse), clippy clean, check ok.

The views page. The pulse pane changed studio.css, which the views page is built from, so the page was rebuilt (3f2f4d9ce) with wai/wai-quantum-views/build.sh in catthehacker/ubuntu:act-22.04 with Rust 1.98.0, as the views workflow rebuilds it. A macOS build gives the same script and styles but other engine bytes, so it was not used. The engine inside the page is rebuilt from the current sources as well. The copy on main held an older one, which #549's views job warned of.

The same density digest came out on x86_64 Linux, arm64 macOS, wasip2 and wasm32.

Not checked by hand: the new workflow's bits legs on the arm64 Linux and macOS runners were replayed on the macOS host only. This PR's CI is their first run on the forge runners.

Not done

• Pulse access on real hardware.
• pulse_check in the Python package and the editors.
• Cross-resonance (exchange-coupled) dynamics: the model takes static ZZ coupling and one tone per qubit at a time, and refuses anything else.
• A capture's back-action: a capture ends its qubit's schedule, and joint readings are given only when captures start together.

Breaking

api:rust:wai_quantum::engine::schema::FILES grew from 22 to 23 (pulse.v1.json). The changelog acknowledges it.

🤖 Generated with Claude Code

Pulse programs now run as simulations: OpenPulse calibrations are read into a schedule on frames, simulated under a Lindblad master equation with a stated error bound, and run as jobs whose receipts bind the program, its calibrations, the device and the integrator. The result is the same bits on every platform. This adds no hardware pulse access. ## What it adds **The OpenPulse reader** (`qasm::pulse`, on the OpenQASM 3 reader) - Reads `cal` and `defcal` on physical qubits, with ports (`d0`, `m0`, `a0`, or mapped in `pulse.ports`) and frames with times of their own. - Waveforms: `constant`, `gaussian`, `sech`, `gaussian_square`, `drag`, `sine`, and explicit samples. - Instructions: `play`, `delay`, `shift_phase`, `set_phase`, `shift_frequency`, `set_frequency`, `capture` (and `capture_v0`..`v4`), and barriers. - A gate starts when its qubits and frames are free, and a frame's carrier runs on across a change of frequency. Durations are whole samples of `dt`. - Refusals: the new codes `Q453`–`Q462`, added after `Q452` with nothing renumbered, each with its line and column. **The simulator** (`quantum_pulse`, in `quantum_engine` and `full`) - Two or three levels per qubit in the rotating frame, with T1 relaxation, T2 dephasing and static ZZ couplings. - A fixed-step, twelfth-order Taylor series, using only `+ − × ÷`, `sqrt` and the repository's deterministic trigonometry. - A proved trace-norm truncation bound, with a rounding estimate beside it. It refuses a step past 1/λ, or a run whose error would exceed its tolerance, and names the steps that would meet it (`J041`). - Held to closed forms within that bound: Rabi turns, the phase axis, detuned drives, T1 decay and T2 dephasing. The final density matrix's digest is pinned and is the same on x86_64 Linux, arm64 macOS, wasm32-wasip2 and wasm32 in the browser. **Jobs** (`engine::pulse`, method `pulse`) - Each qubit's parameters come from `pulse.qubits`, else from a target's calibration snapshot, else from defaults, and the result says which. - The receipt binds: - `pulse.calibration`: digests of the program, its calibrations, the schedule and the device, plus the target's name, hash and calibration id; - `pulse.integrator`: the integrator and its step; - `pulse.density_hash`: the final state's bits. - `engine::pulse::check` re-runs a sealed job and names every field that differs. - New job codes `J040` and `J041`. **Surfaces** - CLI: `run --method pulse --pulse OPTIONS` (and `plan`), `pulse schedule` (a timeline per frame), and `pulse check`. - Both MCP servers: the new tools `pulse_schedule` and `pulse_check`. The run tools gain the method `pulse` and the `pulse` options. - Service: pulse jobs run through `/v1/jobs` and `/v1/run`. New routes `POST /v1/pulse/schedule` and `/v1/pulse/check`, with OpenAPI entries. - wasm: `QuantumEngine.pulse`. - Studio: a Pulse pane that draws the schedule as a timeline (lanes, envelopes, captures, barriers and gate calls), shows refusals with their codes, and runs the program with its bound and receipt digests. - Desktop: a `pulse` command. - Docs: `docs/pulse.md`, plus the READMEs (engine and CLI with their zh-CN pages, the service and the Studio), the feature matrix and the changelog. ## Bounds on the service - The system is at most 16 dimensions (`MAX_DIM`). - The reader caps samples (2²²), waveform samples (2²⁰), instructions (2²⁰) and calls (2¹⁸). - A program is at most 1 MiB. - A pulse check re-runs its job, so it is held to 2×10¹⁰ multiply-adds. Past that, it names the local command. - A pulse job is held to the simulator's 4×10¹¹. At its nominal rate of 10⁹ per second, the job's time limit is about 400 s, after which its worker is killed, as for every other method. ## Checked | Where | Result | |---|---| | Linux build host | Engine `--features full --lib`: 1087 passed. The pulse workflow's job, replayed: 26 passed; three feature sets clean under `-D warnings`. Service: `mcp::` 14 passed, then the full suite 37 + 1. CLI: 70 passed (bin), every target passed. wai-web `quantum_engine::`: 27 passed. | | Linux build host, smoke and gates | CLI and service `smoke.sh` passed. `check_schemas.py`: 42 tool answers valid. Breaking gate: no unacknowledged break. Repository checks: all 10 lines ok. `check_docs.py` on `docs/pulse.md`: every block passed. | | macOS build host | Pinned bits in debug and release: 2 passed each. wasip2 under wasmtime: 26 passed. wai-web wasm32: 19 passed. `studio.test.mjs` run twice: 246 checks passed, none failed. Desktop: 15 passed. | | After rebasing onto main 4902e6679 (macOS build host) | The Studio's browserless tests passed (hardware, telemetry, update, locales). `build-views --check` passed after the views page was rebuilt (see below). `studio.test.mjs` run twice: every check passed. Desktop: 18 passed (17 plus `pulse`), clippy clean, `check` ok. | **The views page.** The pulse pane changed `studio.css`, which the views page is built from, so the page was rebuilt (`3f2f4d9ce`) with `wai/wai-quantum-views/build.sh` in `catthehacker/ubuntu:act-22.04` with Rust 1.98.0, as the views workflow rebuilds it. A macOS build gives the same script and styles but other engine bytes, so it was not used. The engine inside the page is rebuilt from the current sources as well. The copy on main held an older one, which #549's views job warned of. The same density digest came out on x86_64 Linux, arm64 macOS, wasip2 and wasm32. **Not checked by hand:** the new workflow's `bits` legs on the arm64 Linux and macOS runners were replayed on the macOS host only. This PR's CI is their first run on the forge runners. ## Not done - Pulse access on real hardware. - `pulse_check` in the Python package and the editors. - Cross-resonance (exchange-coupled) dynamics: the model takes static ZZ coupling and one tone per qubit at a time, and refuses anything else. - A capture's back-action: a capture ends its qubit's schedule, and joint readings are given only when captures start together. ## Breaking `api:rust:wai_quantum::engine::schema::FILES` grew from 22 to 23 (`pulse.v1.json`). The changelog acknowledges it. 🤖 Generated with [Claude Code](https://claude.com/claude-code)

dcharlot added 9 commits 2026-10-30 12:24:37 -04:00

wai-quantum: OpenPulse read into a schedule on frames ... a14daafa70

qasm::pulse reads a pulse program's calibrations (cal and defcal on
physical qubits) and runs them in program order into a schedule: ports,
frames with their own times, the waveform templates (constant, gaussian,
sech, gaussian_square, drag, sine) and explicit samples, play, delay,
shift_phase, set_phase, shift_frequency, set_frequency, captures, barriers,
and each gate call with the samples it spans. A gate starts when its qubits
and frames are free; a frame's carrier runs on continuously across a
frequency change, and each play records the carrier's phase at its first
sample. Durations are whole samples of dt or refused.

What it does not take is refused with a code and its place: Q453 to Q462
join qasm::diag after Q452, renumbering nothing, and the table in
docs/qasm-diagnostics.md holds them.

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

wai-quantum: a pulse simulator under a Lindblad master equation, the same bits everywhere, its error bounded ... fd289c5afb

quantum_pulse (feature quantum_pulse, in quantum_engine and full) runs a
pulse schedule on the qubits its ports reach: two or three levels each in
its rotating frame, the drive as the frames' carriers set it, anharmonicity,
static couplings, and relaxation and dephasing from T1 and T2.

Each sample is integrated in the frame of each qubit's tone, where the
generator is constant: a fixed number of steps of a twelfth-order Taylor
series, then a diagonal phase back. Only + - * / and sqrt are used in a
fixed order with the crate's own sine and cosine, so the density matrix
is the same bits on every platform; a test pins its digest, which x86_64
and arm64 reproduce. The plan states a proved bound on the trace distance
from the model's exact solution and an estimate of rounding beside it, and
refuses a step longer than 1/lambda or a schedule whose error would pass
its tolerance, naming the steps that would meet it.

Tests hold it to closed forms within the bound it states: Rabi turns, the
axis a quarter turn of phase gives, detuned drives, T1 decay and T2
dephasing, a detuned play split in two; and to joint captures, leakage
with three levels, and the model's refusals.

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

wai-quantum: pulse runs as jobs, their receipts binding the program, calibrations, device, target and integrator ... 2f44231e1a

engine::pulse makes a pulse program a job of the method pulse, planned and
run through catalog::plan and run::run like every job, so every host that
runs jobs runs it: the device from a target's calibration snapshot and the
request's pulse options over the defaults, each parameter saying where it
came from; counts sampled from the captures' joint reading (into the
program's bits) or the final state; the accuracy class bounded, with the
proved truncation bound and the rounding estimate.

The result's pulse.calibration holds the control program's digest, its
calibrations', the schedule's and the device's, and the target snapshot's
name, hash and calibration id; pulse.integrator the integrator and its
step; pulse.density_hash the final state's bits. The job's receipt seals
them with the result. engine::pulse::check holds a sealed pulse job to its
request: the signature, the program's digest, and the request run again,
each differing field named. engine::pulse::schedule draws the schedule for
a view; tools() gives the pulse_schedule and pulse_check tools for both
servers.

J040 and J041 join the job layer's refusals; the verdict of a pulse run is
its own (executed, bounded). schemas/pulse.v1.json is new (FILES grows from
22 to 23); the job request and result schemas gain the pulse options and
the pulse result, and the accuracy its bound.

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

wai-quantum-cli, wai-quantum-service: pulse runs, schedules and checks on the command line, both MCP servers and the job service ... 290c170d06

A pulse program runs as a job of the method pulse everywhere jobs run:
wai-quantum run --method pulse --pulse OPTIONS (and plan), the MCP tools
run_quantum_circuit and plan_quantum_circuit on both servers (their method
and pulse options in the input schema), and the job service's /v1/jobs and
/v1/run, through its queue, workers and receipts. A pulse run accepts the
verdict hosts ask for and carries its own, and a run's printed result shows
its integrator, captures, device and what its receipt binds.

wai-quantum pulse schedule draws a program's frames as timelines with their
plays, captures and barriers, its gate calls and waveforms; wai-quantum
pulse check holds a sealed pulse job to its request by running it again.
Both MCP servers serve pulse_schedule and pulse_check, and the service
POST /v1/pulse/schedule and /v1/pulse/check, a check held to the work a
call there takes. The API description, both smoke scripts, the committed
tool lists and the agent docs are regenerated; the Simplified Chinese help
summarises the new command.

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

wai-web, CI: pulse calls in the page, and the pulse layer's bits held on every platform ... 074f328286

QuantumEngine.pulse gives the page the schedule and check calls, sealed
with the page's key; a pulse run is the page's run with method pulse. A
native test and a wasm32 test run the same pulse job to one pinned digest
of its final density matrix, the engine's own; wai-web-wasm.yml's pins move
from 26 to 27 (native) and from 18 to 19 (wasm32).

wai-quantum-pulse.yml runs the pulse reader's, the simulator's and the pulse
jobs' 26 tests by name in a release build on Linux, builds each feature set
that holds them without warnings, runs the pinned digests in debug and
release builds on arm64 Linux and on macOS, and runs the 26 tests under
wasm32-wasip2 by wasmtime.

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

wai-quantum docs: the pulse page, the READMEs and the feature matrix ... 13151abfd7

docs/pulse.md gives a pulse program, its schedule, its run as a job, its
check and a refusal, all run by the docs checker against the command line
(the receipt a block writes verified), and states the reader's constructs,
the model, the integrator and its bound, what a receipt binds, and the
options. The engine's and the command line's READMEs (with their Simplified
Chinese translations), the service's README, the docs index and the
OpenQASM 3 feature matrix name the pulse layer; the agent docs are
regenerated from the matrix. The reader's module documentation states the
qubit timeline a gate waits for.

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

quantum-studio, wai-quantum-desktop: the pulse pane, and the changelog of the pulse layer ... 6fea0b484e

The Studio's Pulse pane draws a pulse program's schedule as a timeline: a
lane per frame with its port and qubit, each play its waveform's envelope at
its samples, captures hatched, barriers as rules, phase and frequency
changes as ticks, and the gate calls as brackets above, each mark titled
with its samples and its line. A program the pulse reader refuses is
answered with its code; an example loads a DRAG x and sx and a measurement.
A run on the pulse simulator is a job of the method pulse in the page,
giving each capture's reading, the counts, the bound and what the receipt
binds, every answer's seal checked there. The tab, the service and the
desktop app each answer the pane (the desktop app's new pulse command), and
studio.test.mjs drives it end to end.

wai/CHANGELOG.md records the pulse layer under Unreleased, with the one
breaking change the gate reports: schema::FILES grew from 22 to 23.

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

wai-quantum-service smoke, schema contract: pulse runs within the submission window and under a second schema checker ... 8fc12cf8b8

The service smoke stays within the 30 submissions a client makes in a
window (29 now, 30 on a host with a GPU): its set gains a pulse item, run as
a job of the method pulse, and POST /v1/pulse/check runs that item again and
holds it to its result, in place of separate schedule and run calls. The
schema contract script calls pulse_schedule and the pulse run and plan
tools over the command line's MCP server, and checks the run with
pulse_check, each answer held to its output schema by the second JSON
Schema implementation.

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

wai-quantum views: the page rebuilt with the pulse pane's styles, in the image CI rebuilds it in ... 3f2f4d9ce9

The pulse pane's styles changed studio.css, which the views page is built from,
so build-views --check refused the page main holds. 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. Its script is unchanged and its styles carry
the pane's. The engine inside it is rebuilt from the current sources too. The
page on main held an older engine, which CI warned of on #549.

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

dcharlot referenced this pull request from a commit 2026-10-30 14:26:05 -04:00

wai-quantum-py: the getting-started notebook's method list names pulse

dcharlot added 1 commit 2026-10-30 14:26:05 -04:00

wai-quantum-py: the getting-started notebook's method list names pulse ... 2bc4466bb5

The notebook prints wq.methods(), which now lists the method pulse, so its stored
output no longer matched and the notebook check failed on Linux and macOS (#551).
Its outputs are rewritten with ci/check.sh --write-notebooks, and a second run of
ci/check.sh matched all five notebooks. Only this cell's compared output changed;
the other notebooks' rewrites differed only in timestamps and widget ids, which the
check does not compare, so they are left as they were.

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

dcharlot merged commit 55524840f1 into main 2026-10-31 07:15:50 -04:00

dcharlot referenced this pull request from a commit 2026-10-31 07:15:51 -04:00

Merge pull request 'wai-quantum: pulse programs simulated under a Lindblad master equation, the same bits everywhere, their receipts binding the calibrations' (#551) from wai/quantum-pulse into main

dcharlot referenced this pull request 2026-10-31 07:17:18 -04:00

wai-quantum: QIR and jeff read and written on every surface, each conversion checked, bounded against hostile input #554

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

No description provided.