wai-quantum 0.7.0: Python, bring your own quantum, editors, one OpenQASM 3 reader, compilation, the debugger, device targets, estimates, the verdict, and the version contract #521

Merged

dcharlot merged 94 commits from wai/quantum-ecosystem into main 2026-10-28 02:17:49 -04:00

Conversation 0 Commits 94 Files changed 403 +169020 -3060

2026-10-28

Transaction Science

wai-quantum-qpu.yml: the library's pinned count is 34, with the target placement's test ...

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

6db3a7fab6

• View at this point in history

2026-10-28 01:05:14 -04:00

2026-10-27

Transaction Science

tree-sitter-openqasm check: a program the intent set repairs from a syntax error must hold that error ...

The intent set's bell-broken.qasm is broken on purpose (a missing `;`, which
the run repairs first). The check now reads the set's manifest and requires
each program it repairs from a lexer or parser code (Q001 to Q005) to fail to
parse, as the check's own broken program does, instead of failing the job.

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

3de30aa967

• View at this point in history

2026-10-27 23:50:56 -04:00

Transaction Science

wai-quantum 0.7.0, wai-quantum-cli 0.2.0, wai-quantum-qpu 0.3.0 and the job service 0.2.0: the release's versions, its changelog heading, and every lock ...

The engine, the command line, the provider crate and the job service move to
their next 0.y, which is a major bump before 1.0 (VERSIONING.md); the Python
package stays 0.1.0 and the editor extension keeps its version. Every
dependent's requirement names the new version, and the sixteen lockfiles that
resolve any of them move with them, each read with --locked.

cargo-semver-checks keeps its baselines at the versions last published (0.6.16,
0.1.4 and 0.2.0); wai-quantum-qpu joins the check. Against them it lists the
breaking changes and passes, as each major is bumped.

The changelog's release heading summarises the twelve entries below it and
lists what a caller may have to change. DEPRECATIONS.md stays empty.

The engine's version is among the sealed bytes of a stamped result, so the
page's pinned digests move: the compile's 0a165415... to ac948133..., the
estimate's 0cd25cf6... to 8715e76b... The job pin strips the engine and
schema and does not move. The notebooks' stored outputs are re-stored.

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

3b3cedfc21

• View at this point in history

2026-10-27 23:44:28 -04:00

Transaction Science

wai-quantum ci/check_schemas.py: every schema file, and the answers of the tools the stack added ...

The full JSON Schema implementation read a fixed list of eleven schema files,
so the verdict's, the target's and the estimate's were not among them and the
job request's reference to the target's did not resolve. It now reads every
JSON file under the packages' schemas/ (fourteen today), and fails when one it
names is missing. Over the command line's MCP server it holds the answers of
the tools the stack added to their output schemas as well: a run with intents
and repair, an equivalence intent and a compile first; repair_qasm,
compile_qasm in both bases, qasm_diagnostics, estimate_resources and the
estimate's check, debug_branches, debug_step, list_targets, show_target,
run_on_target and a plan on a target (32 answers).

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

0808fce847

• View at this point in history

2026-10-27 23:44:28 -04:00

Transaction Science

wai-quantum compile: the last places that said target for the basis ...

The command line's line for a compiled run read the summary's "target", which
the rename left empty; it reads "basis". The run tools' compile option on both
MCP servers said "with target clifford_t"; it says "with basis clifford_t", and
the agent docs and committed tool lists are regenerated from them. The Studio's
engine wrapper names the request's members as the engine reads them.

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

9407dd68e8

• View at this point in history

2026-10-27 23:44:28 -04:00

Transaction Science

wai-quantum compile: the gate set compiled to is its basis, not a target ...

A compile's `target` (clifford_t or standard) named a gate set, beside the
device `target` jobs, the command line and both MCP servers already take.
It is `basis` now, everywhere: compile::Options and compile::Basis, a job's
compile.basis, `wai-quantum compile --basis`, compile_qasm's inputSchema on
both servers, the service's OpenAPI CompileOptions, the page, the Studio's
compile lens (#qs-compile-basis), the certificate's and the result's
compiled member, their schemas, and the docs. The option was never
released, so nothing is deprecated; a compile given `target` is refused,
saying basis, rather than run at the default basis unasked.

Pins that moved with the certificate's field: wai-web's COMPILE_DIGEST
(04a03934… to 0a165415…), and engine::job's no-verdict pin of a compiled job
(d714ea13… to b17615c9…). testdata/compile-legacy.json, sealed before the
stamp and the rename, still verifies; no released schema holds its form.
A provider job's compiled names its placement too.

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

e759d3cf7d

• View at this point in history

2026-10-27 23:44:28 -04:00

Transaction Science

wai-quantum schemas over the integrated stack: the verdict, the J codes, estimates, targets, the debugger and the repair, and every tool's output held ...

- verdict.v1.json (wai.quantum.verdict/1), target.v1.json
  (wai.quantum.target/1) and estimate.v1.json (wai.quantum.estimate/1) are
  committed; verdict::json_schema() and targets::schema() are those files.
- tools.v1.json: the job layer's J codes beside the reader's, a refusal as
  data, the repair, debug_step and debug_branches, the target listing and a
  target's summary, and every draw format; the job request's intent,
  verdict, target and repair, the result's verdict, target and repaired, and
  the plan's target.
- Every tool on both servers has its output schema (Registry::tool_output):
  its answer or a refusal as data, the verdict beside either and required for
  a tool that states one, and an $id versioning it
  (wai-quantum://schemas/TOOL/1). The strict every-tool tests call
  repair_qasm, estimate_resources, debug_step, debug_branches, list_targets,
  show_target and run_on_target too, and the refusals.
- An estimate's sealed result names its engine and schema; its re-run
  check leaves both out, so an estimate another version sealed re-runs.
  Pins that moved: wai-web's ESTIMATE_DIGEST (aaa42bc8… to 0cd25cf6…). The
  no-verdict byte pins in engine::job hold the bytes they held, the stamp
  left out of what they hash.
- The tool lists regenerated.

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

30f8fd2f8c

• View at this point in history

2026-10-27 23:44:28 -04:00

Transaction Science

wai-quantum schemas over the stack: the reader's and the compiler's documents held, a compile's result stamped ...

On the stack with the one reader and synthesis:

- A compile's result names the engine and its schema
  (wai.quantum.compile-result/1) inside what its receipt seals, as a job's
  does (engine::schema::stamp_as in compile::call).
- The engine's tests run jobs with outputs, durations, the reader's
  warnings, a bounded while and a compile first, and compiles at each
  target, level and with stages, each held to its schema; lint's
  diagnostics and the table of codes too. A compile the page sealed before
  (testdata/compile-legacy.json, whose bytes are the 14db506e… the page's
  test pinned) still verifies, its digest pinned.
- Both servers' tests call compile_qasm and qasm_diagnostics (and the
  service's refusals of each), held to their outputSchemas.
- wai-web: the page's sealed compile is pinned again, now that its result
  names its engine and schema.
- The tool lists and the notebooks' stored outputs regenerated.

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

10b92b87dd

• View at this point in history

2026-10-27 23:44:28 -04:00

Transaction Science

wai-quantum schemas: the reader's diagnostics and a compile named ahead of the stack that writes them ...

The stack below this branch adds the reader's diagnostic codes (lint's code,
column and length; a result's diagnostics, outputs and timing; the tool
qasm_diagnostics) and synthesis (a job's compile and its result's compiled;
the tool compile_qasm, its certificate and its receipt). The schemas name
them now, so the branch reads them once it sits on that stack:

- tools.v1.json: the error form's code, column and length; lint's
  diagnostics; a diagnostic; the table of codes and one code's row.
- job-result.v1.json: outputs, timing, diagnostics and compiled;
  job-request.v1.json: compile.
- compile-result.v1.json (wai.quantum.compile-result/1): a compile, its
  options, its certificate (wai.quantum.compile/1), its stages and its
  receipt; engine::schema::stamp_as names a compile's result as stamp names
  a job's.
- Both servers map compile_qasm and qasm_diagnostics to their answers'
  schemas (the service's with its refusal); the tool lists regenerated.

Nothing this branch writes changes: each member is optional, and the tools
are not served here.

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

76b627ac83

• View at this point in history

2026-10-27 23:44:28 -04:00

Transaction Science

wai-quantum contract: the schemas read by a second JSON Schema implementation, and a drift says what to do ...

- ci/check_schemas.py: every schema file and both committed tool lists read
  as 2020-12 schemas by a full implementation sharing no code with the
  engine's checker (the jsonschema package pinned in the Python package's
  test lock), every reference resolving as a validator resolves it, every
  outputSchema standing alone, the job bodies sealed before still following
  the job schema, and a release build's run, versions, initialize and tool
  answers following theirs. wai-quantum-contract.yml runs it.
- A test that finds the code writing what its schema does not say, a tool
  with no outputSchema, or a tool the test does not call, now says what to
  do: name the member in which schema file, map the tool in output_of(),
  call it in the test, and regenerate with WAI_QUANTUM_BLESS=1.

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

fc1c8a2951

• View at this point in history

2026-10-27 23:44:28 -04:00

Transaction Science

wai-quantum-py notebooks: their stored outputs with results that name their engine and schema ...

The doc notebooks are held to their stored outputs; a result now carries
engine and schema, so the job printed in getting-started and every receipt
shown (its digest and signature) are stored again, by
ci/check.sh --write-notebooks. A fresh run matches them.

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

5a3ef590fb

• View at this point in history

2026-10-27 23:44:28 -04:00

Transaction Science

wai-quantum: the version and deprecation policy, the deprecations page, and each README's word on what is stable ...

- wai-quantum/VERSIONING.md: the public surface of every WAI Quantum
  package, what each part of a version number promises, the schemas' rules,
  what changed in a receipt's canonical content, the support windows the
  owner decided (2026-10-27), how a deprecated item says so on each surface,
  the rule before 1.0, and what CI checks.
- wai-quantum/DEPRECATIONS.md: each deprecated item, the version that
  deprecated it, its replacement; none today.
- Every WAI Quantum README links both; the changelog entry.

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

219cc3b5f3

• View at this point in history

2026-10-27 23:44:28 -04:00

Transaction Science

wai-quantum-contract.yml: API compatibility against the last versions published, and the schema tests, in CI ...

- api: cargo-semver-checks 0.51.0, built from its source on crates.io,
  against wai-quantum 0.6.16 and wai-quantum-cli 0.1.4. Every change is
  checked as for a minor release, so each breaking change is listed; one
  fails the step only while the major (the first non-zero component, before
  1.0) is the baseline's. A step warns when crates.io holds a newer version
  than a baseline.
- schemas: the engine's, both MCP servers', the job service's job and the
  provider protocol's schema tests, each by name.
- policy: every WAI Quantum README links the policy, and the deprecations
  page's table reads.

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

4467157917

• View at this point in history

2026-10-27 23:44:28 -04:00

Transaction Science

wai-quantum: every MCP tool says what it answers, both servers and the command line report their versions, and the provider protocol has its schema ...

- Both MCP servers: each tool carries its answer's schema as its
  outputSchema, standing alone (every reference resolved); the command
  line's own tools' answers in wai-quantum-cli/schemas/local-tools.v1.json,
  the job service's in wai-quantum-service/schemas/service-tools.v1.json, the
  rest the engine's. A test calls every tool and holds its answer to its
  outputSchema with no member the schema does not name; a tool with no
  outputSchema, or not called there, fails it.
- The local server's tool list is committed (docs/local-mcp.json) beside the
  service's (docs/service-mcp.json), both held to the live lists.
- initialize gives the versions under _meta["science.transaction.wai/versions"]
  (wai.quantum.versions/1): the engine's and the server's, every schema it
  writes, the protocols it speaks, and where the policy is. The job service
  also gives them in quantum_service_info and GET /v1.
- wai-quantum version [--json]: the same, from the command line.
- wai-quantum-qpu/schemas/provider.v1.json: the open provider protocol's
  messages, answers, program and errors; every message the client sends and
  every answer the reference provider gives, in each basis, held to it.
- The job service's job in each status held to the job schema; the energy
  figure as the worker's reading gives it held to the result's.
- The agent docs (llms.txt, llms-full.txt, the AGENTS.md block, the Agent
  Skill) say how to read the versions and where the policy and the
  deprecations are; regenerated. The smoke checks check the versions.

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

6ea7825ce4

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum engine::schema: the job's documents as versioned JSON Schemas, and every result names its engine and schema ...

- schemas/ beside the crate's manifest: the job request, the job result, the
  job as a host returns it, the receipt (its second form; the first still
  verifies), the plan, the answers of the engine's tools, and the versions a
  host reports, each wai.quantum.<document>/<major> kept as <document>.v<major>.json.
- engine::schema: the names, stamp() (engine {name, version} and schema in
  every result run::run and provider::result give), versions(), and a
  checker for the subset of JSON Schema the files use, which also refuses a
  member a schema does not name so a test fails when the code drifts.
- The receipt's form is unchanged: what it seals is the result's RFC 8785
  text, which now holds two more members. Two job bodies sealed by the
  engine as it was before (testdata/*-legacy.json) still verify, their
  digests pinned.

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

179b7bcc25

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum: a device target's run and a sampled intent tested on the engine and in Python, and the docs say so ...

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

2698bb5fbf

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum: sampled intents in the verdict on every surface, and a target run's verdict ...

The debugger's sampled intent (samples of the run held to a stated
distribution by a stated test at a stated level) moves into
engine::verdict with the other kinds, so the command line, both MCP servers,
the service, the page and Python take it: the program run as the job runs it
(its method, noise, options and device target) for the intent's shots at its
seed, evidence and never proof. wai-quantum test keeps --junit, now read
from the engine's verdict. A job on a device target gets its verdict, and its
plan admits the check's memory as other jobs do. The intent set gains sampled
cases (a fair pair, a biased claim, an outcome ruled out, proof required,
under noise, and beside an exact distribution). The CLI's tool list now has
repair_qasm beside estimate_resources, the debugger's and the target tools;
the agent docs are regenerated.

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

94b2246271

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai: the verdict page, the READMEs and the changelog ...

docs/verdicts.md gives the ladder, what a verdict records, the intents, the
repair rules and every surface; the reader's diagnostics page points at the
job layer's codes. The crate's, the command line's, the service's, the
Python package's and the Studio's READMEs, and the changelog, describe them.

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

5d5ee28b8c

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum-service: an MCP run's receipt is checked against the job's own request, and the smoke reads the reader's current table ...

A run over MCP asks for its verdict, so the request it seals is the job's
own request; verify_quantum_receipt says to pass that one, and the smoke
does. The smoke's diagnostics check reads the table's codes, job codes and
worked refusals, and its refusal check the code Q310 with what to write
instead (both had been left at an older form of the reader).

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

73547b1eee

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum-py: wai_quantum.verdict and repair, run with an intent, and job.verdict ...

run and job_request take intent, verdict and repair, and Job.verdict reads
the verdict the receipt seals. verdict() gives a job's verdict, its own or
one worked out here for another intent (marked not sealed); repair() makes
the mechanical fixes on the flagged lines and refuses a proposal that changes
another line. EngineError's code reads the job layer's codes as well as the
reader's. The getting-started notebook's stored refusal carries its J011.

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

eb6e4006c0

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

quantum-studio and the desktop app: a verdict badge on every run and every assistant proposal ...

Every run asks for its verdict, sealed by the receipt, and shows its level as
a badge with the engine's statement; a result from a host that gives none,
and a refused run, have theirs worked out here and say they are not sealed.
Each of the assistant's proposals carries its badge, the model is told to
give run_job an intent and quote the verdict, and its run summaries carry
the verdict. The tab's engine and the desktop app answer verdict and repair.
The e2e checks the badge on a run, on a refused run, and on a proposal.

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

87f7670d3f

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-web: engine_verdict and engine_repair in a page, the intent set run there, and the CI pins ...

A run in the page carries its verdict sealed, a refusal its codes and, when a
verdict was asked for, the verdict of what was refused. engine_verdict works
a job's verdict out again (or for an intent given after the run, marked not
sealed), engine_repair repairs on the flagged lines. The wasm32 tests run the
intent conformance set to its verdicts; the pins are 18 native and 12 wasm32.

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

91a01965ad

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum-service: intents and repairs in jobs, POST /v1/repair, repair_qasm, and the verdict in every MCP answer ...

A job's intents are held to the equivalence check's bound before it is
queued; every refusal ends with its code (J030 to J032 for the host's own),
and an HTTP refusal carries the code as data. The MCP server's run states its
verdict, repair_qasm is new, every answer about a program carries its
verdict, and every tool a versioned output schema. The smoke checks a job
with an intent, a repaired job, a rejected proposal and a coded refusal.

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

956d0bac2a

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum-cli: run --intent, repair, test on the engine's verdict, and the MCP verdict in every answer ...

run takes --intent (a reference program, a distribution, intents, or a
project's intent.json), --verdict and --repair, prints the verdict and exits
by whether the intent holds. repair makes the mechanical fixes on the flagged
lines and checks a proposal against them. test runs the program with its
intents, so the verdict is sealed in the run's receipt. The MCP server's
run_quantum_circuit takes intent and repair and always states its verdict,
repair_qasm is new, every answer about a program carries its verdict, every
refusal its codes, and every tool a versioned output schema. The committed
agent docs and the Agent Skill are regenerated.

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

b0edea785a

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum: the verdicts resource, tool output schemas, and the rules point agents at the verdict and repair_qasm ...

The guide serves the verdict's levels, fields, intents and repair rules as
the resource wai-quantum://docs/verdicts. The intent rule now asks an agent
to give the intent to the run and quote the verdict's level, claiming nothing
past it; a new rule holds its fixes to the flagged lines through repair_qasm.
The prompts use both. engine::verdict gives the verdict's JSON Schema, each
tool's versioned output schema and the verdict every program tool states.

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

a06b842ee4

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum: the intent conformance set, natively and under wasm32-wasip2, with a CI leg ...

Programs, their intents and the verdict each must get (the level, whether
the intents hold, each outcome, strength, check and distance known by hand,
the repairs made, the refusal's code), every level of the ladder covered.
wai-quantum-verdict.yml runs it natively and under wasmtime, with the
verdict's, repair's and codes' unit tests named.

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

fafa484102

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum: a verdict for every answer, the job layer's refusal codes, and repairs held to the flagged lines ...

engine::verdict states how far the engine checked as one level of an
ordered ladder (refused, parsed, executed, evidence, proof), with what the
reader said, the method and its accuracy class, each intent checked (an
exact distribution with its distance, the same circuit as a reference by the
equivalence ladder, the same state), the critique's findings and the
repairs made, in one plain line. A job asks for it with "intent" or
"verdict": true and carries it in its result, sealed by its receipt; a job
that asks for neither gives the bytes it gave before (pinned).

engine::refusal gives every refusal of the request, the method, an intent,
a repair and the host a stable J code beside the reader's Q codes, documented
in docs/job-refusals.md and held to it by a test.

engine::repair makes the mechanical fixes (a missing ;, an undeclared
register's size, a measurement with no target, an unbounded while given the
bound chosen, a non-dyadic angle rounded to the bits chosen with its rounding
stated) on the flagged lines alone, holds a proposal to the same lines, and
says what needs a person with the reader's advice. A job may ask to be
repaired first.

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

5faba2f683

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum engine::estimate: the seal test needs the receipt feature, and says so ...

The test of a sealed estimate and its key helper are compiled only with
quantum_receipt, so the estimate's own tests build with the engine alone.

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

531e466a09

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum: the estimate page, the READMEs and the changelog ...

- wai-quantum/docs/estimate.md: the three layers; the request and the
  reference qubits; every count and how it is counted (the ladders through
  ancillas, the schedule behind each depth, a branching program's bound);
  the budget, its synthesis share and each rotation's; the layout; every
  figure of an estimate and the frontier; the calibration's decoders, grid,
  fit and extrapolation; both documents; the answer and its seals; the
  refusal codes; what it assumes; and how it is checked, with a real
  estimate.
- READMEs of wai-quantum, wai-quantum-cli and wai-quantum-service:
  estimate, POST /v1/estimate and its bounds, estimate_resources. The
  crate README's examples of the planar model's worked estimates now name
  `lab estimate`, where they live; the service README's tool list names
  compile_qasm and qasm_diagnostics, which it had left out.
- CHANGELOG: wai-quantum: resource estimation from programs.
- The command line's report reads one T count as one.

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

b919b21b5c

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum-py: wai_quantum.estimate and verify_estimate ...

- estimate(program | counts= | routine=, budget=, qubit=, calibration=,
  max_slowdown=, export=, name=, key=): the engine's estimate in-process,
  sealed with the key, the answer the command line's and the service's.
- verify_estimate(estimate): its seal, every receipt and the request
  re-run here.
- Tests: the counts of a gate under three controls, the frontier, the
  seals and a changed figure refused; the documents exported and read
  back; refusals with their codes; and the command line's `estimate --json`
  equal to the package's, receipt for receipt.
- ci/check.sh on the Linux build host: every check passed (66 pytest
  passed; clippy, the wheel, the notebooks, Python 3.9).

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

8d34ee92b9

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

quantum-studio: the frontier's ticks in a person's units, and a frontier of five in the e2e ...

- The runtime axis ticks each decade as 100 ms, 1 s, 10 s (the last
  anchored inside the plot); a rotation count that is one T count reads as
  one; the pointed row is shaded, its text kept in the text colours.
- The e2e estimates at a budget of 1e-4, where the program needs factories,
  so the frontier holds five estimates, and saves the pane's screenshot
  (test/screenshots/studio-estimate.png). On the macOS build host every
  check passed (159), with Playwright's own browser.

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

c06c97eddb

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

quantum-studio and the desktop app: the estimate pane and its frontier ...

- quantum-studio: "Estimate" under the compile lens: a physical qubit, an
  error budget and the code model (fitted to the exact-matching or
  union-find decoder, or assumed). It gives the program's logical counts
  (qubits with ancillas, measurements, T, Toffolis, rotations and the T in
  their words, T depth and depth), each rotation's share of the budget and
  its words' T counts, the calibration, the headline estimate, and the
  frontier plotted runtime against physical qubits on log scales and listed
  in a table, a point read out when pointed at or focused. Every estimate
  is sealed with the browser's key, and the seals and a re-run are checked
  in the page; an estimate goes stale when the program changes. A
  generator is estimated at its inputs.
- wai-quantum-desktop: the `estimate` and `estimate_verify` commands,
  sealed with the user's key, off the window's thread, with a test.
- The Studio e2e checks the pane (six checks, each passing on the macOS
  build host, with Playwright's own browser). The run had one failing
  check of the version history's assistant label, a timing check outside
  the pane; the stack's base commit, run there the same way, failed two of
  those checks. The desktop's 8 tests and clippy passed there.

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

12cd5bf309

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-web: the estimate in a page, sealed with the page's key, the same bytes as native ...

- QuantumEngine::estimate: a program's (or a document's) estimate, each
  estimate on the frontier sealed with the page's key in the
  resource-estimate receipt family and the answer in a job's form, so
  engine_verify checks its seal.
- engine_estimate_verify: the seal, every receipt and the request re-run in
  the tab.
- Tests: the native one pins the sealed estimate's BLAKE3; the wasm32 one
  holds the page to the same bytes (the counts, each rotation's synthesis,
  the factory search, the frontier and every seal). On the Linux build
  host: native 17 passed, wasm32 under Node 11 passed. The CI pins are 17
  and 11.

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

a92d9d08dd

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum-service: POST /v1/estimate, the MCP tool estimate_resources, and estimates re-run by verify ...

- POST /v1/estimate: the engine's estimate of a program, or of a
  logical-counts or routine document, each estimate sealed with the
  service's key in the resource-estimate receipt family and the answer in a
  job's form. It counts against the client and runs with the design checks
  (two at a time); a program of more than 200000 gates or 256 distinct
  rotation angles, or a budget leaving a rotation less than 1e-12, is
  refused (422) with the local command.
- POST /v1/verify on an estimate checks its seal and every receipt and
  re-runs the request, within the same bounds: {valid, signed, receipts,
  reproduced}.
- MCP: estimate_resources, with the engine's description and schema; and
  verify_quantum_receipt re-runs an estimate. OpenAPI: /v1/estimate and
  EstimateRequest. The tool list's test is pinned.
- smoke.sh: an estimate, its verification and a changed one refused, a
  counts document, and one too fine sent to the command line. Two checks
  written before the one reader's diagnostics resource and its while
  refusal now read them as the reader gives them (the codes, not prose).
  Every check held against a local instance on the macOS build host.
- The agent docs regenerated from the live tool lists (llms.txt,
  llms-full.txt, service-mcp.json, the skill's tools).

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

a771a5ae03

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum-cli: estimate, the MCP tool estimate_resources, and verify re-running an estimate ...

- `wai-quantum estimate prog.qasm [--budget E] [--qubit NAME|all|FILE.json]
  [--calibration exact_matching|union_find|assumed] [--max-slowdown N]`:
  the program's counts, the ε budget and its synthesis share per rotation,
  the calibration, the headline and the frontier, and the receipts checked
  and re-run here. `--json` prints the answer sealed with the user's key;
  `--counts FILE` and `--routine FILE` estimate a document;
  `--export counts|routine` prints the program's counts as one.
  `lab estimate` is unchanged and its help points here.
- `wai-quantum verify` on an estimate checks its seal, every resource
  receipt and the request re-run, and says which held.
- MCP: estimate_resources (sealed with the user's key) beside
  compile_qasm; verify_quantum_result re-runs an estimate. The tool's
  description and schema are the engine's, so both servers serve the same.
- smoke.sh: an estimate's counts, report, seal, verify, the counts exported
  and read back, a routine on every reference qubit, lab estimate as
  before. CI compares an estimate natively and as a WASI component byte
  for byte.

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

710cb954a6

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum: resource estimation from programs, calibrated from the crate's own decoders ...

- engine::estimate::count: a program written in Clifford gates, T, z
  rotations, Toffolis (one CCZ state each) and measurements; a gate under
  several controls goes through clean ancillas (x, y, z, h under c >= 3
  controls: 2c - 3 Toffolis and c - 2 ancillas; a phase under c >= 2: 2c
  Toffolis and c ancillas); a branching program is counted step by step,
  an upper bound. Each rotation is synthesised at its own angle within its
  share of the budget's synthesis share, its T count the word's. Counts:
  T, Toffolis, rotations and their T, measurements, non-Clifford, rotation
  and T depth, total depth, logical qubits with ancillas.
- Ground truth: Bell, T chains, the ripple-carry adder (2n Toffolis), the
  QFT (3(n-1) T, 3(n-1)(n-2)/2 rotations), multi-controlled gates; every
  ladder held to the gate it replaces on dense unitaries with the
  ancillas at |0>; each rotation's T count equal to engine::synth's word.
- engine::estimate::calibration: the gate-based surface code's model
  P(d) = a(p/p*)^((d+1)/2) fitted to the memory experiment decoded by exact
  matching and by union-find on the same shots (d 3, 5, 7; p 0.002 to
  0.005; 100000 shots, 25000 at d = 7; seed 1). The table is in the crate;
  a release test measures every point again, a debug one one point, and
  the example estimate_calibration prints them.
- engine::estimate::interchange: the logical-counts document and the
  routine document (v1), import and export, with the schema's checks
  (names, directions, resource types and values, unique siblings,
  connections between ports) and a self-made fixture.
- engine::estimate: the planar model on the counts, the headline and the
  frontier no estimate beats on both qubits and runtime, each estimate
  sealed in the resource-estimate receipt family (a counted program binding
  the digest, every count, the budget, the synthesis share and each
  rotation's), the frontier's naming the headline's as parent, and the
  answer sealed in a job's form; verify re-runs the request. Refusals
  carry codes QE02 to QE08.
- The engine feature now carries the resource model and the decoders'
  memory experiment; the receipt family compiles with the resource model
  and any signing feature.
- CI: wai-quantum-estimate.yml runs the tests in release (the whole
  calibration); engine::estimate joins the wasip2 module list (18 passed
  under wasmtime on the build host).

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

ed1b7e5cd0

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum: the debugger and device targets over the one reader and the compiler ...

- The service's exact tool lists hold the device targets' three tools beside
  compile_qasm and qasm_diagnostics; the command line's agent docs are
  regenerated with the debugger's and the targets' tools.

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

399892b03a

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum: device targets in the READMEs and the changelog ...

The engine's README gains Device targets (the model, the importers, the
noise, the layout, the jobs, the built-in synthetic targets and what is
checked against ground truth); the command line's, the targets verbs and
tools; the service's, GET /v1/targets and the target field; the provider
crate's, placement by a described calibration. The changelog's entry says
what is new and what is not done.

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

cb4835feaa

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

Quantum Studio: Device, a coupling map coloured by its errors and the chosen layout on it ...

Under Device the reader chooses a target: a built-in one (synthetic), one
imported here from a snapshot in any format the engine reads (kept in this
browser), or in the desktop app one kept with wai-quantum targets import.
The coupling map is drawn from the engine's view, each pair coloured by its
two-qubit error and each qubit by its readout error, one-qubit error or T1:
five bins of one hue by the device's own quantiles (an ordinal ramp, dark to
light in the dark scheme and light to dark in the light one), the poorest
pairs thicker, every mark's numbers on hover, a legend and a table. With a
target chosen, a run is compiled, placed and simulated as the device would
run it, and the noise fields wait. The layout the plan chose is drawn on the
map before the run, and the result's Device block names the target, its
hash, the placement and its expected success, the noise and the distance
from the ideal. On the service a built-in target goes by name and any other
as its document.

The e2e test draws the 27-qubit map (27 qubits, 28 pairs, binned, with
hover text), runs a Bell pair on it with the receipt checked, colours by T1,
imports a snapshot of another format, and returns to no device.

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

5ab9a6c30c

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum-desktop: device targets for the Studio ...

Three commands, targets, target and target_place, answer the Studio's
device pane with the built-in targets and the person's own (kept with
wai-quantum targets import, read through wai_quantum_cli::target_store), and
a job naming a kept target carries its document to the worker. CI checks the
new test by name.

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

d48cc8c510

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-web: device targets in a page ...

engine_targets lists the built-in targets, engine_target reads a built-in's
name or the JSON text of a target document or of a snapshot in any format
the engine reads (its summary, what the Studio draws, and its document), and
engine_target_place places a program on a target without running it
(engine::targets::job::placement, what a plan states of the target). A job
naming a target runs in the page as anywhere else. One native test and one
wasm32 test; the CI pins move to 15 and 9.

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

01d1ddd020

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum-cli: the person's targets in the library, for the desktop app too ...

The store of kept targets (where they are kept, how a request names one, the
listing) moves from the command's module to wai_quantum_cli::target_store,
which the desktop app already depends on, so both read the same targets.

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

170239ff85

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum CLI: targets import|list|show, run --target, and three MCP tools ...

`wai-quantum targets import FILE --name NAME` reads a device's calibration
or target snapshot in any format the engine reads (or, with --provider, one
of the person's providers' describe answers) and keeps it in the
configuration directory; `targets list` shows the built-in (synthetic)
targets and the person's own, `targets show` a target's qubits, pairs,
gates and errors (or its document, or what the Studio draws), `targets
schema` the document's JSON Schema. `run --target` and `plan --target` run
as the device would, a kept target going in the request as its document;
the output names the target, the placement and its expected success, the
noise and the distance from the ideal distribution.

MCP: list_targets, show_target, run_on_target, and target in the run and
plan tools; the agent docs are regenerated. The smoke checks import, list
and run on a target and verify its receipt, and CI holds a target run's
output to the native build's bytes under wasmtime.

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

0e888faacf

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum-service: jobs on device targets, GET /v1/targets and three MCP tools ...

A job may give a target: a built-in target's name or a target document,
which the service reads as given and fetches nothing for. It plans and runs
as the engine runs any target job, the target's hash in the sealed result.
GET /v1/targets lists the built-in (synthetic) targets; the OpenAPI document
describes the target field and the target document's schema; a worked
example runs a GHZ state on the heavy-hexagon target.

MCP: list_targets, show_target and run_on_target, and target in
run_quantum_circuit's schema; the command line's snapshot of this server's
tools is regenerated. The smoke checks run a target job and hold its hash to
GET /v1/targets. Each rpc test call keeps its own key, as the tests run side
by side.

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

694ad4f72b

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum-qpu: a provider's described calibration places the program ...

When a provider's describe answer states errors per qubit or per pair, the
host reads it as a device target and places the program on the qubits and
routes most likely to succeed (engine::targets::layout::place), in the
device's own gates; otherwise the compiler's own layout is kept. The program
is checked against the circuit on the device's connectivity before it is
sent, as before. The plan and the sealed result's compiled block say how it
was placed, with the target's hash and the expected success beside the
fewest-swaps layout's.

The provider protocol now states the durations field's form, and that a
client may place by the described calibration.

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

15b3deac34

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum engine: device targets, their noise, and noise-aware layout ...

engine::targets holds a device's qubits (T1, T2, frequency, the readout
assignment matrix, the measurement time), its native gates with per-qubit
and per-pair errors and durations, the coupling map and the calibration
snapshot, as one strictly read document (wai.quantum.target/1) with a JSON
Schema and a canonical RFC 8785 text whose BLAKE3 names it in a receipt.

- import reads the per-qubit and per-gate calibration properties a
  superconducting-device service publishes (alone or beside its
  configuration), an instruction-properties target, the device-capabilities
  document a cloud service returns, and the open provider protocol's
  describe. Four synthetic built-in targets, one in each shape, made up by a
  fixed-seed generator.
- noise derives a schedule per qubit and per pair: each gate's reported
  error as the depolarising channel that, with its relaxation, gives exactly
  that average infidelity; amplitude damping and dephasing from T1, T2 and
  the durations, idling included; readout from the assignment matrix.
  quantum_noisy gains Channel and Schedule for the density matrix and the
  branching trajectories; the global model keeps its bits.
- layout compares many layouts and their most reliable routes and keeps the
  highest expected success; the compiler's own (fewest swaps) wins unless
  beaten, and the program is checked against the circuit. native.rs gains
  compile_at and weighted routes; compile is unchanged.
- A job's target field (a document or a built-in name) plans and runs the
  program as the device would: the plan states the layout, the expected
  success and the noise, and the result carries the target's hash.

Ground truth: zero errors give the ideal distribution to 1e-12 in all three
bases; T1 decay, T2 coherence and the assignment matrix match their closed
forms; a gate's channels reproduce its reported average infidelity exactly
(by the Choi state); the layout equals an exhaustive search on a line.

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

f6cde79a89

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum: docs for the debugger and drawing edits; the route rule plainer; smoke extended ...

- The READMEs (engine, command line, Studio, desktop), the agent skill's
  workflow and the changelog describe the debugger, statistical intents,
  JUnit, the draw formats, state views and editing by the drawing.
- The agents' route rule ends "and nowhere else", which the public-text
  check reads as plain; the agent docs are regenerated from it.
- smoke.sh makes the binary's path absolute before a step runs from another
  directory, and checks draw --svg/--latex/--describe, debug and dap.

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

2f8ddb83b6

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

Quantum Studio and the desktop app: step through, state views, editing by the drawing ...

- Step through: the engine's debugger in the tab (wasm engine_debug) or the
  app, a slider forward and back, the next step named with its line and its
  gate marked on the diagram; each qubit's phase disk with a purity ring and
  its Bloch sphere in plain SVG; the amplitude and phase table; the reduced
  state of chosen qubits; under noise the noisy state against the noiseless
  one; and the branch tree with its weights, a branch chosen to put the path
  on it.
- Editing by the drawing: a palette gate dropped on a wire, a drawn gate
  dragged to other wires or places, or moved and deleted from the keyboard,
  each made by the engine in the program's text (engine_visual_edit) and
  recorded as the reader's edit; a gate its statement does not make alone is
  refused with its line.
- The diagram described to a screen reader in the engine's words, and the
  drawing saved as the engine's SVG or LaTeX (engine_picture).
- The desktop app answers the same calls natively (debug off the window's
  thread). The wasm workflow's counts are 16 native and 9 under Node; the
  Studio's browser test checks each view.

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

1d765f39a7

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum engine: a program that measures in the middle read in the order it runs ...

engine::describe read every circuit by the drawing's columns, and the
drawing packs a gate that waits on a measured bit into a column before the
measurement that sets it; a program that measures in the middle is now read
in the order it runs, each step with its condition, an else branch as the
negated condition. The debugger refuses probe qubits outside the program or
named twice, and writes a zero Bloch component without a sign; the command
line's branch list says each measurement and what it read.

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

0e8c187bc8

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai/tools/wai-quantum-editor: the debugger, in the extension and the other editors ...

The extension contributes breakpoints for OpenQASM and a `wai-quantum`
debugger whose launch settings (program, stopOnEntry, inputs, noise, method,
outcomes) are the ones `wai-quantum dap` reads; it starts the adapter as the
command line's dap verb, and "Debug the program" debugs the file in the
editor. The Lua configuration registers the adapter with the debug adapter
plugin, and languages.toml declares it with a launch template. test/check.mjs
holds the manifest to the adapter's source and checks the client starts it;
the editors workflow runs the debugger's module tests and tests/dap.rs on
Linux and macOS.

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

770f3b3039

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum CLI: debug, the debug adapter, statistical intents and JUnit, and draw as SVG, LaTeX or words ...

- `wai-quantum debug FILE` prints the engine debugger's state at a position
  or before a line (amplitudes, Bloch vectors, the reduced state of chosen
  qubits, entanglement across a cut), on a path of recorded outcomes;
  `--branches` lists every branch at the measurements in the middle with its
  weight.
- `wai-quantum dap` serves the debugger to editors over the debug adapter
  protocol: launch, breakpoints by line, step forward and back, continue in
  both directions, the probes and the branch tree as variables, and
  `evaluate` for reduced states, cuts and another path. tests/dap.rs drives
  it as an editor does.
- `wai-quantum test` takes sampled intents: the program run for the stated
  shots and its counts held to a distribution by Pearson's chi-squared test
  or the G-test at a stated significance level (engine::stats, the p-value
  the same bits on every platform). `--junit FILE` writes the verdicts as a
  JUnit report. The exit codes are as they were.
- `wai-quantum draw` takes `--svg`, `--latex` and `--describe`; the MCP
  `draw_circuit` takes the same as `format`.
- The stdio MCP server gains `debug_step` and `debug_branches`, read-only
  and deterministic; the agent docs are regenerated from the live lists.

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

28c148dfd2

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

wai-quantum engine: the debugger, and the circuit as LaTeX, in words and edited by its drawing ...

engine::debug steps a program forward and back one operation at a time on
the bit-exact or double-precision state vector, or the density matrix under
noise beside its noiseless state; stops before a line; and probes any
position: amplitudes with their phases, probabilities, each qubit's Bloch
vector and purity, the reduced state of chosen qubits, and entanglement
across a cut. It enumerates every branch at the measurements in the middle,
with exact weights from the tableau for a noiseless Clifford program, and
replays a recorded path. Stepping back runs again from a saved state, so a
state seen twice is the same bits; the exact method's state after the last
gate is the exact run's state_hash. Refuses past 16 qubits (8 under noise).

engine::latex draws the circuit in plain TikZ, engine::describe reads it
in words for a screen reader, and engine::visual turns a gate put on a wire,
moved or deleted into an edit of the program's own text through its syntax
tree, refusing a gate its statement does not make alone.

quantum::Circuit::apply_to runs a circuit on a given state (the debugger's
step), and the deterministic arctangent serves the engine's phases.

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

74138b816a

• View at this point in history

2026-10-27 23:44:27 -04:00

Transaction Science

tree-sitter-openqasm: an output declaration may name its value, as the reader takes it ...

The editors' CI parses every program in the repository; the OpenQASM 3
corpus's lang/output.qasm declares `output int[32] n = 3;`, which the
engine's reader takes and the grammar refused. The generated parser is
regenerated; 97 of 97 programs parse, and fmt holds on all of them.

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

0f5e2268d4

• View at this point in history

2026-10-27 22:39:46 -04:00

Transaction Science

CI: the editors' job in an image with glibc 2.39, the processor's library tests on their own features, the service smoke on the reader's table ...

- wai-quantum-editors.yml: the grammar's tree-sitter command from npm is a
  prebuilt binary needing glibc 2.39; the job runs in act-24.04, as
  wai-neural-e2e.yml's does.
- wai-quantum-dsp.yml: the library's tests build with the features their
  modules need (quantum_fabric, quantum_receipt, quantum_qbom); the whole
  engine's test binary is past the processor's direct-call reach
  (R_HEX_B22_PCREL, 8 MiB). 151 of them pass natively with those features.
- The service's smoke reads the diagnostics resource as the reader's table
  (codes and worked examples), and the unbounded while's refusal by its code
  (Q310).

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

7a384111f6

• View at this point in history

2026-10-27 21:30:57 -04:00

Transaction Science

quantum-studio test: the version checks wait for the list to say it ...

A version is recorded after the editor changes; three checks read the
current version's line at once and, on a loaded host, read the one before
(each failed in turn on two runs, and passed when read again). They now wait
for the line to say what they expect, as the merge check already does.

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

c2d1a60d4b

• View at this point in history

2026-10-27 20:05:00 -04:00

Transaction Science

wai-quantum: compiling over the one reader; the stack's tool lists hold compile_qasm ...

- engine::compile: a compiled program keeps the program's outputs and its
  calibrations; its timing and where each controlled gate was lowered name
  places in the ops the passes rewrite, so it holds neither.
- The service's exact tool list holds compile_qasm beside qasm_diagnostics;
  the command line's agent docs are regenerated.

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

145bf9a9b0

• View at this point in history

2026-10-27 19:51:35 -04:00

Transaction Science

wai: the changelog and the compiler page name the Studio's compile lens and the desktop command ...

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

6ce55b66dd

• View at this point in history

2026-10-27 19:51:35 -04:00

Transaction Science

quantum-studio and the desktop app: the compile lens, the circuit after any pass ...

- quantum-studio: "Compile" under the circuit takes the program through
  the engine's passes (Clifford+T within epsilon, or the standard gates,
  levels 0 to 2). Each pass is a row with gates, CNOTs, T gates and
  rotations before and after and its check; the line above gives the bound,
  the budget and its share per rotation, the whole output's measured
  distance and whether the sealed certificate verifies here. The circuit
  after the last pass is drawn, and choosing a pass draws the circuit after
  it. "Use" offers the compiled program for review; a compile goes stale
  when the program changes. In a tab it runs in the engine's worker and is
  sealed with the browser's key.
- wai-quantum-desktop: the `compile` command, sealed with the user's key,
  off the window's thread, with a test of its pure half.
- The Studio e2e checks the lens (all 150 checks passed on the macOS build
  host, the bundle built on the Linux one); the desktop's 6 tests and
  clippy passed there.

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

268e4bfb66

• View at this point in history

2026-10-27 19:51:35 -04:00

Transaction Science

wai-quantum: the compiler page, the READMEs and the changelog ...

- wai-quantum/docs/compiler.md: the passes and how each is checked, the
  levels, how to read epsilon (operator norm up to a global phase, shared
  among the rotations, the bound the distances add to and what it gives for
  distributions and expectations), the certificate's fields with a real one,
  determinism, and what the compile does not do.
- READMEs of wai-quantum, wai-quantum-cli and wai-quantum-service: compile,
  run --compile, POST /v1/compile and its bounds, compile_qasm.
- CHANGELOG: wai-quantum: synthesis and certified compilation.

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

d1071856ac

• View at this point in history

2026-10-27 19:51:35 -04:00

Transaction Science

wai-quantum: stages, sparse parities, a tighter reading of the bound, and the synthesis tests under wasip2 ...

- engine::compile: with "stages": true the result holds the circuit after
  each pass, for a view that draws any of them. The certificate's reading
  now says what the bound gives exactly: the output distribution within it
  in total variation, every outcome's probability too, and an expectation
  within 2*bound*|O|.
- synth::phase: a parity is a sorted list of path variables, not a bit set
  over all of them, so folding a large Clifford+T circuit does not grow with
  every Hadamard.
- wai-quantum-cli: compile prints the certificate's digest, the hash a
  compiled job's result names.
- wai-web: the pinned digest of the sealed compile follows the new reading
  (native 15 and wasm32 9 tests held on the build host).
- wai-conformance: engine::synth and engine::compile join the unit tests
  run under wasmtime (all 28 held there).

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

6164c2009e

• View at this point in history

2026-10-27 19:51:35 -04:00

Transaction Science

wai-web: the compile in a page, sealed with the page's key, the same bytes as native ...

QuantumEngine::compile takes the service's compile request and returns the
compiled program and its certificate sealed with the page's key, which
engine_verify checks. A native test and a wasm32 test compile one request
to the same pinned BLAKE3 digest (both held on the build host, the wasm32
one under Node); the native test also runs the output bit-exact. The CI
pins move to 15 native and 9 wasm32 tests.

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

b595734609

• View at this point in history

2026-10-27 19:51:35 -04:00

Transaction Science

wai-quantum-service: POST /v1/compile, compiled jobs, and the MCP tool compile_qasm ...

- POST /v1/compile: the engine's compile, its result sealed with the
  service's key in a job's form, so POST /v1/verify checks it. It runs
  with the other design checks (counted per client, two at a time), and a
  compile of more than 20000 gates, more than 256 rotations to approximate,
  or a budget that leaves a rotation less than 1e-12 is refused (422) with
  the local command.
- A job with "compile" is held to the same bounds at admission, then runs
  the compiled circuit (bit-exact for Clifford+T) and says how far it is.
- MCP: compile_qasm, and compile in run_quantum_circuit's schema; a test
  pins the tool list. OpenAPI: /v1/compile and CompileOptions.
- smoke.sh: a compile, its certificate verified, a compiled job, and a
  too-fine compile sent to the command line (all held against a local
  instance on the build host).

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

5952f6b9b6

• View at this point in history

2026-10-27 19:51:35 -04:00

Transaction Science

wai-quantum-cli: compile, run --compile, and the MCP tool compile_qasm ...

- `wai-quantum compile prog.qasm [--epsilon E] [--level 0|1|2]
  [--target clifford_t|standard]`: the compiled program to standard output,
  each pass's counts (gates, CNOTs, T, rotations) and check, the epsilon
  budget, its bound and the whole output's measured distance to standard
  error. `--json` prints the certificate sealed with the user's key, in a
  job's form, which `verify` checks; `--certificate FILE` writes it.
- `run --compile E`: the job compiles first and runs the compiled
  circuit, bit-exact for Clifford+T; the result line says how far it is.
- MCP: `compile_qasm` (sealed with the user's key), and `compile` in the
  job schema of run_quantum_circuit and plan_quantum_circuit.
- smoke.sh checks a compile, its certificate and a compiled run; CI compares
  a level-2 compile natively and as a WASI component byte for byte (they
  were equal on the build host).
- engine::compile: counts take each gate as the basis writes it, so a
  rewrite's rx(pi/4) counts as the T it is; for Clifford+T the KAK pass
  weighs rotations before CNOTs.

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

ab0f279cda

• View at this point in history

2026-10-27 19:51:35 -04:00

Transaction Science

wai-quantum: a pass pipeline with one certificate per compile, and jobs that run compiled ...

engine::compile carries a program through named passes, each checked where
it acts, and records them in one certificate:

- lower (every gate in h x y z s sdg t tdg cx cz swap rz, each kind held to
  its matrix), simplify (the checked rewrites), phase_fold (phase gates on
  one parity merged, checked by recomputing the phase polynomial: a proof in
  whole eighths of a turn), resynth_1q (Clifford+T runs in normal form,
  others as one rotation), resynth_2q (KAK on two-qubit blocks when it saves
  CNOTs), approximate (every rotation off the multiples of pi/4 as a
  Clifford+T word within its share of the epsilon budget).
- Levels 0 to 2 for the targets clifford_t and standard. A pass whose check
  fails is not applied, and says so.
- The certificate gives each pass's counts before and after, its check and
  verdict (proof, exact, approximate), the epsilon budget, its share per
  rotation and the bound the distances add to; up to eight qubits the whole
  output is also measured against the whole program on dense unitaries.
  Sealed with the job receipt, so the existing verify checks it.
- A job with "compile" runs the compiled program: with clifford_t it takes
  the bit-exact method, and the result's "compiled" states the distance.
- synth::lower and synth::phase: the decompositions and the phase folding,
  each against dense unitaries of random circuits.

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

a536c71095

• View at this point in history

2026-10-27 19:51:35 -04:00

Transaction Science

wai-quantum: rotation synthesis to Clifford+T within epsilon, Euler angles, and two-qubit KAK ...

- rz: Rz(theta) as a Clifford+T word within a requested epsilon by the
  Ross-Selinger method: the epsilon-region and the disk as a two-dimensional
  grid problem, made upright by a grid operator, each candidate tested in
  exact arithmetic, the norm equation solved, and the operator written in
  normal form. The word multiplies back exactly, and its distance to the
  rotation is computed again from the word in fixed point and rounded up;
  that is the distance reported. Against every Clifford+T operator with at
  most 11 T gates, 21 of 24 cases land on the optimal T count and the rest
  one above; T counts follow 3*log2(1/epsilon) (99 to 101 at 1e-10).
- mat: dense unitaries of a few qubits and their operator-norm distance up
  to a global phase, accurate to about 1e-15 even when they are that close.
- euler: any one-qubit unitary as Rz.Ry.Rz with the crate's own arctangent.
- kak: any two-qubit unitary as at most three CNOTs (two, or none, when the
  canonical coordinates allow), with a deterministic Jacobi eigen-solver;
  every circuit is compared with the unitary it came from.

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

c576891ef7

• View at this point in history

2026-10-27 19:51:35 -04:00

Transaction Science

wai-quantum: exact arithmetic for synthesis, Clifford+T normal form, the Diophantine step and grid problems ...

engine::synth gains the ground the rotation synthesiser stands on, each
part held to a ground truth:

- int: signed integers of any size (Knuth division, square roots, a
  primality test, Pollard-Brent factoring within a step budget), checked
  against 128-bit arithmetic and the division identity.
- real: fixed point with 320 fractional bits; pi, the square root of 2,
  sine and cosine to the last bits.
- ring: Z[sqrt 2], Z[omega], 2x2 matrices over D[omega] and their Bloch
  rotations; any unitary over D[omega] written as a word in the
  Matsumoto-Amano normal form (fewest T gates), multiplied back exactly
  and refused if it does not match. Random words come back the same
  operator with no more T gates.
- dioph: t-dagger t = xi solved in Z[omega] prime by prime, or shown to
  have no solution; against every t with coefficients in [-6, 6].
- grid: the one- and two-dimensional grid problems, grid operators and a
  reduction that makes a thin tilted ellipse upright; against brute force.

repro: the deterministic arctangent is available to the engine.

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

fbd719b308

• View at this point in history

2026-10-27 19:51:35 -04:00

Transaction Science

wai-quantum: the reader's codes reach the guide, the editor and Python ...

- engine::guide: the diagnostics resource is the reader's table (every
  code with its outcome and meaning) and worked refusals, each held by a
  test to the code and line the reader gives its example; the language
  resource carries the reader's feature matrix in place of the lists it
  kept by hand; the summary for AGENTS.md names what the reader now takes.
- engine::editor: a refusal is the reader's own diagnostic, with its code
  and the very text it names (line, column and length).
- wai-quantum-py: EngineError.code is the reader's code.
- The service's tool list holds qasm_diagnostics; the command line's
  agent docs are regenerated.

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

7a74132459

• View at this point in history

2026-10-27 19:51:35 -04:00

Transaction Science

quantum-studio test: a refusal the assistant sends back carries its code ...

The reader ends every refusal with its diagnostic code, so the proposal the
engine cannot read goes back as "line 3: unknown gate foo [Q103]"; the
test reads it so. Q320's meaning names only what refuses it.

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

9a05bd9408

• View at this point in history

2026-10-27 19:51:35 -04:00

Transaction Science

wai-quantum reader: a generator written out keeps its calibrations verbatim ...

A test that instantiate writes defcalgrammar and defcal statements out as
they were written, and that the text reads back to the same program.

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

1d605fbfd5

• View at this point in history

2026-10-27 19:51:35 -04:00

Transaction Science

wai-quantum reader: the unbounded while test reads a measured bit ...

A bit no measurement has written holds 0 and is known on reading, so the
test of a while on measured bits measures the bit first.

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

138387ae30

• View at this point in history

2026-10-27 19:51:34 -04:00

Transaction Science

wai-quantum docs: the OpenQASM 3.1 feature matrix, the READMEs and the changelog ...

docs/qasm-feature-matrix.md lists every construct of OpenQASM 3.1 (and the
OpenQASM 2 forms in common use) with what the reader does with it,
supported, lowered, carried, preserved or refused, and its code. The crate's
README describes the one reader (feature quantum_lang) and links the matrix,
the table of codes and the corpus; the command line's README gives
`diagnostics` and the codes in lint; the Studio's says the editor marks each
problem with its code. The changelog entry is in wai/CHANGELOG.md.

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

3a38538076

• View at this point in history

2026-10-27 19:51:34 -04:00

Transaction Science

wai quantum-conformance/qasm3: the OpenQASM 3 corpus, run natively, under wasm32-wasip2 and in the browser ...

59 programs, each with what the reader must do with it: the language
specification's 21 example programs, unchanged (those that run held to
their results, the rest to the code that names the first construct the
reader cannot hold exactly, or the example's own error), and a program for
each construct with a reference written without it. stdgates.qasm applies
every standard gate once, and its reference writes each in U and CX alone.

Expectations: refused (a code), warns (every warning's code), deterministic
(every shot's outcome), distribution (exact outcome probabilities),
expectations (exact Pauli values), equivalent (a reference's unitary up to a
global phase), exact (the bit-exact circuit takes it or refuses it with a
code), outputs, timing and calibrations. bundle.json holds the cases with
their text inline for builds that read no files; a test holds it equal to
the files.

CI: wai-quantum-lang.yml runs the reader's tests, the corpus natively, the
reader built without the lowerings, and the corpus under wasm32-wasip2 by
wasmtime; wai-web's wasm32 tests read every case through the page's engine
(the wasm32 count goes from 8 to 9).

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

37dfe98d2d

• View at this point in history

2026-10-27 19:51:34 -04:00

Transaction Science

wai-quantum reader: bits known on reading, subroutines called as gates, stretch expressions, nested arrays, half precision ...

What the specification's example programs need beyond the first reader:

- a bit register set by a constant (`bit[2] flags = "11";`) holds its value
  until a measurement writes it: a condition on bits known on reading is
  decided then, and known bits drop out of a condition that also reads
  measured ones; a bit holding 1 that no measurement writes, or one measured
  only on some runs, is refused (Q319), since the results carry what
  measurement writes;
- a subroutine called in gate form (`bellprep bp;`, `f(1) q, r;`);
- a duration that holds a stretch (`delay[2*g] q;`) carried as written;
- nested array values, rows and slices of them, slice assignment, `sizeof`
  by dimension, and `#dim` arguments;
- `float[16]`, rounded to half precision, ties to even;
- bits cast to a signed integer of their width read as two's complement;
- a subroutine's names are its own (a local bit may share a global
  register's name); a measurement into a classical variable is refused as
  Q128; a `let` reusing an enclosing scope's name is refused (Q101).

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

5c4d635cdd

• View at this point in history

2026-10-27 19:51:34 -04:00

Transaction Science

wai-quantum toolchain: one grammar, from_qasm reads through the reader and applies the bit-exact restriction ...

quantum_toolchain::from_qasm, the OpenQASM import of the edge component and
the processor clients, was a second reader that took one register, one
statement a line, no gate definitions and exact rational angles. It now
reads through qasm::read, as every other surface does, and then applies the
bit-exact circuit's own restriction, refusing with the reader's codes: a
non-dyadic angle (Q500), more than 255 qubits (Q501), a program whose
measurements do not all come at the end (Q502). A controlled gate the
modifiers write stays one gate under all its controls (Program::extra's
native forms), so to_qasm's output still reads back gate for gate and the
round-trip tests hold by hash.

Tests changed where a refusal changed: two registers, a gate definition and
two statements on one line are read now; a control on rz is a controlled
rz, exact; a qubit named twice is the reader's Q109 ("named twice in one
gate") where this reader said "invalid circuit". A bare radian number is now
held to the reader's dyadic tolerance (1e-14 of a turn), where this reader
accepted one within 1e-9 of a dyadic angle and rounded it.

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

6827eda4ed

• View at this point in history

2026-10-27 19:51:34 -04:00

Transaction Science

wai-quantum: the reader's diagnostic table served by the command line, both MCP servers and the browser engine ...

`wai-quantum diagnostics [--json]` prints every code with its outcome and
meaning; the stdio MCP server and the job service's MCP server each gain a
`qasm_diagnostics` tool (all codes, or one by `code`); the browser engine
gains `engine_diagnostic_codes()`. The service's description of what a
program may hold now names the whole language the reader takes and says
refusals carry codes. The tools-list tests of both servers name the new
tool; the smoke checks read a refusal's code, column and length from
`lint --json` and look a code up in the table; wai-web's native
quantum_engine count goes from 14 to 15 with a test of the codes and of a
subroutine, an inverse and a power run in the page.

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

50acae11d3

• View at this point in history

2026-10-27 19:51:34 -04:00

Transaction Science

wai-quantum engine: a job's result carries the program's outputs, its timing label and the reader's warnings ...

A job's result now holds what the program declares beyond its gates, each
only when there is one, so a program with none has the result (and the
receipt bytes) it always had: `outputs` (each declared output's value, or
the places of its bits in each outcome), `timing` (`applied: false`, code
Q400, when the program states durations the method does not apply), and
`diagnostics` (the reader's warnings and notes, each with its code). The
dynamic runner holds the bits a subroutine or block declares for itself
beside the program's, reads them, and keeps them out of the counts.

A test runs teleportation written as a subroutine with its own bits (every
shot reads 1), a repeat-until-success loop on measured bits under a declared
bound (15/16 of the shots succeed), outputs and a delay.

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

7b383e9a11

• View at this point in history

2026-10-27 19:51:34 -04:00

Transaction Science

wai-quantum: one OpenQASM 3 reader with source spans, every refusal and warning under a stable code ...

The reader is rebuilt in stages, each with the source position of what it
handles: tokens (qasm::lex), the program as written (qasm::ast, qasm::parse)
and the program run on reading (qasm::elab). qasm::diag is the table of
codes: each with its outcome (refused, lowered, carried, preserved, warned)
and a one-line meaning, served as data (codes(), codes_json()) and as
docs/qasm-diagnostics.md, which a test holds to the table. A diagnostic's
text keeps the message people read and ends with its code
("line 3: unknown gate foo [Q103]"); qasm::read gives the program, each op's
line and the warnings, and a refusal as a Diagnostic with line, column and
length. engine::job::lint carries code, column and length, and warnings
under `diagnostics`.

The language the reader now takes, each construct lowered exactly or
refused with a code: def subroutines, inlined (classical arguments by value,
qubits by reference, return values, a returned measurement written into the
caller's bit, bits a subroutine or block declares for itself); inv @, pow(k)
@ and fractional pow where an exact principal root exists, and ctrl/negctrl
on any gate, user gates included; float, angle[n] (held to n bits, with the
rounding reported), complex, uint, bool, bit arrays, arrays, casts and the
built-in functions, folded with the crate's own deterministic functions;
while (unrolled when its condition is known, or run at most
@wai.max_iterations N times on measured bits), switch, break, continue,
return and end; conditions on measured bits with comparisons, &&, || and !,
compiled to forward jumps; output declarations; delay, box, stretch, barrier
and gate durations carried as timing; defcal, cal and defcalgrammar kept
verbatim; let aliases, slices, index sets, negative indices and physical
qubits; gphase. The program carries what it declares beyond its gates in
Program::extra, and each controlled gate's native form for the bit-exact
circuit (Program::dyadic_native, qasm::exact_circuit).

A new feature, quantum_lang, holds the reader without the lowerings, so the
toolchain can read through it. Tests changed where a refusal changed:
`inv @` and a control on rz are read now; a loop variable may share a gate
parameter's name (names are scoped); `^` between integers under OPENQASM 3
is exclusive or (refused only where no version is stated); a loop may be a
loop's body; an unterminated loop body names the missing `;`.

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

13ce9a246d

• View at this point in history

2026-10-27 19:51:34 -04:00

Transaction Science

wai-quantum: the route rule reads plainly; a project's test.sh takes a relative command path ...

- engine::guide's route rule ends "and nowhere else": the service's
  instructions join every rule on one line, where the old ending and the
  signing-key rule read together as a comparison to the prose check.
- test.sh makes a relative WAI_QUANTUM absolute before it changes to the
  project's directory, and smoke.sh runs the binary by an absolute path:
  CI gives it ./target/release/wai-quantum.

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

7cd7d3b0a1

• View at this point in history

2026-10-27 19:51:34 -04:00

Transaction Science

wai-quantum-cli docs: llms-full.txt with the lsp and fmt verbs ...

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

0377bed867

• View at this point in history

2026-10-27 19:51:34 -04:00

Transaction Science

wai-quantum: the editors' support in the READMEs, the changelog and the smoke checks ...

The command line's README gains an Editors section (what the language
server brings, `wai-quantum fmt`, where the extension, the other editors'
configurations and the grammar are, and a client configuration of one's
own); the engine's README names `engine::editor` with the rest of the
engine; wai/CHANGELOG.md records the whole of it. smoke.sh checks that
fmt gives the one layout, that --check tells formatted from not, that a
program whose brace is not closed is refused with its line, and that the
server answers initialize and exits cleanly after shutdown.

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

626076f13d

• View at this point in history

2026-10-27 19:51:34 -04:00

Transaction Science

wai-quantum-editors.yml: the editors' support, in CI ...

On linux: the language service's tests (each module shown to have run),
the language server's scripted session over standard input and output and
its unit tests, the grammar regenerated with the pinned command line and
held identical to the committed parser, its corpus and highlighting, every
program in the repository parsed with no error, `wai-quantum fmt` on each
of those programs (stable on a second pass, and drawn by the engine as the
original is, or refused alike), the editor extension packaged and checked
with the built command line, and the WebAssembly extension built for
wasm32-wasip2. On macos: the language service's tests and the server's
session.

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

12e24e5b7c

• View at this point in history

2026-10-27 19:51:34 -04:00

Transaction Science

wai/tools/wai-quantum-editor: the editor extension, and configurations for other editors ...

The extension highlights OpenQASM (a TextMate grammar) and starts
`wai-quantum lsp` (path, extra arguments, generator inputs and shots in
its settings). Its lenses and palette commands run Run, Plan, Critique,
Shortcuts and Receipt through the server, and each answer goes to an
output panel; a receipt can be saved as JSON. When the command line is
missing it says so, with the install commands of the command line's
README, and offers the setting for its path. It builds to one bundled
file and packages to a .vsix with the pinned packaging tool; it is not
published.

editors/ holds a configuration for three kinds of editor: one configured
in Lua (the server through the built-in configuration or the lspconfig
plugin, the grammar through the tree-sitter plugin, and a command for each
of the server's commands), one configured by languages.toml (the server,
the formatter and the grammar, with its queries in that editor's capture
names), and one with WebAssembly extensions described by extension.toml (a
small extension that finds and starts the server, built for
wasm32-wasip2; every locked crate is at least two weeks old).

test/check.mjs (79 checks) holds the manifest to the server's commands,
the highlighting token by token, the missing-binary message to the
README, every configuration to its syntax and to the server and the
grammar, the query copies to the grammar's, and the package to exactly
the extension's files.

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

18d485bfa8

• View at this point in history

2026-10-27 19:51:34 -04:00

Transaction Science

wai/tools/tree-sitter-openqasm: OpenQASM 3 as a tree-sitter grammar ...

The grammar reads every statement of OpenQASM 3.1 (declarations of every
type, gates, subroutines and externs, modifiers and gphase, control flow,
timing, calibrations kept as text with their braces matched, pragmas and
annotations) and OpenQASM 2's qreg, creg, opaque, measure q -> c and
if(c==1). The parser is generated at ABI 14 with the pinned command line
(0.26.13) and committed; regenerating it reproduces it byte for byte.

Queries for highlighting, scopes and folds; 17 corpus tests checked tree
for tree, and the highlighting checked by 15 assertions.
script/check-programs.mjs parses every program in the repository's
conformance material and examples (the tracked .qasm files, the Studio's
worked examples, the language service's samples, the programs in the
command line's README and smoke script): 25 of 25 parse with no error,
and a broken program is refused, so a clean result means something.

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

4fd44dfbac

• View at this point in history

2026-10-27 19:51:34 -04:00

Transaction Science

wai-quantum: the language service and server for editors, and fmt ...

The engine gains `engine::editor`, the language service an editor needs,
pure and with no protocol in it:

- diagnostics: the reader's refusal on its line (one mapping function,
  `reader_diagnostic`, where stable codes and exact spans plug in), and
  the critique's smells on theirs, with their kind as the code; a
  generator is read at the given inputs, or 4;
- completion of keywords, the standard gates (with parameter
  placeholders), and the registers, gates, subroutines and variables in
  scope, by what the cursor's place takes; snippets, and sample programs
  in an empty file;
- hover: each standard gate's matrix written exactly, held entry by entry
  to the engine's own matrix under all 46 names the reader accepts; a
  user gate's matrix from the engine's matrices of its gates; each gate's
  cost as the engine counts it (two-qubit gates, T count, depth), at the
  call's angles or at generic ones, said which; a register's size;
- definition, references, highlights and rename over an index of
  declarations and scopes that reads the whole of OpenQASM 3, and a
  half-typed program; symbols, folding (blocks, comments, held blocks);
- a formatter with one layout, refusing a program whose brackets do not
  match, checked to keep every token, and tested stable and
  meaning-preserving (the engine reads the formatted program to the same
  circuit) on a corpus in every part of the language;
- lenses for Run, Plan, Critique, Shortcuts and Receipt.

The command line gains two verbs. `wai-quantum lsp` serves it over
standard input and output, UTF-16 or UTF-8 positions as agreed, the
commands run in-process on a thread of their own and signed with the
user's key; `wai-quantum fmt` formats, `--check`s and `--write`s.
tests/lsp.rs drives the binary through a scripted session from
initialize to exit.

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

c52c83d2fd

• View at this point in history

2026-10-27 19:51:34 -04:00

Transaction Science

wai-quantum: agents may use the person's own providers; one tool list for every reader ...

- engine::guide: the route rule allows a quantum provider the person
  added themselves, only for a run they ask for, and the Agent Skill says
  how (dry run, cost, the person's yes).
- The stdio MCP server's tools() now includes the provider tools, so
  tools/list, the generated llms.txt, llms-full.txt, the AGENTS.md block
  and the skill's tool reference list the same tools.

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

7d2a585008

• View at this point in history

2026-10-27 19:51:34 -04:00

Transaction Science

wai: the open provider protocol, and Bring your own quantum ...

- extensions/quantum-providers.md: wai.quantum.provider/1, its two
  transports, its messages and error codes, the program in a device's
  own gates with exact angles, the six operations, the bit order, the
  cost and confirmation rules, what the receipt proves and what it does
  not, the conformance vectors and the reference provider.
- wai-quantum-qpu/bring-your-own-quantum.md: what is free, adding a
  provider of each kind with its credential in the keychain, running on
  it from the command line, an agent and the desktop, the reference as a
  template, the receipt, and what a person does to connect a real device.
- The READMEs of wai-quantum-qpu, the command line, the engine and the
  job service (which never routes to a provider or takes a credential),
  and the CHANGELOG.

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

ca22fc8470

• View at this point in history

2026-10-27 19:51:08 -04:00

Transaction Science

Quantum Studio and the desktop app: Your hardware, with a cost dialog ...

- Desktop: providers_list, provider_estimate and run_on_provider
  commands; the app reads the credential from the keychain, seals the
  counts with the user's key, and refuses a run that is not free unless
  the page confirms it.
- Studio: a "Your hardware" switch. In the desktop app it lists the
  person's providers, asks for the estimate first and shows a dialog
  before a run that is not free; in a browser tab it says such runs go
  through the desktop app or the command line, since a tab must not hold
  a provider's credential.
- Tests: test/hardware.test.mjs (the switch's logic without a browser),
  a check in the browser test, and a desktop test of the estimate, the
  refusal and the sealed run. The Studio workflow runs the first and
  pins the last, and follows wai-quantum-qpu.

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

24adcdc918

• View at this point in history

2026-10-27 19:51:08 -04:00

Transaction Science

wai-quantum CLI: providers verbs, run --provider, and three MCP tools ...

- providers add|list|remove|describe|test|free|reference: the person's
  own providers in their registry, a credential read from standard input
  (never a command line) into the keychain, or named by an environment
  variable; describe and the conformance test; what anyone can use free;
  and the reference provider served by this binary, as a template.
- run --provider NAME [--dry-run] [--yes]: the plan with the exact native
  compile, its check and the provider's estimate; a run that is not free
  refused (exit 3) until --yes; the counts sealed with this user's key,
  checked by verify.
- MCP: providers_list, provider_estimate and run_on_provider; the last
  says it can spend the person's money and refuses without
  confirm_cost: true when the run is not free.
- A `providers` feature (default) carries it, so the WASI build without
  default features stays as it was.

CI: the command line's workflow follows wai-quantum-qpu and pins the five
end-to-end tests by name.

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

8d308815c7

• View at this point in history

2026-10-27 19:51:08 -04:00

Transaction Science

wai-quantum-qpu: bring your own quantum (open provider protocol, reference, registry, jobs) ...

- open_provider: the open provider protocol, wai.quantum.provider/1, over
  HTTP (curl, a credential only over https or to this machine) or a local
  process (one JSON line each way, the credential in its environment);
  a program travels in the device's gates with every angle an exact
  dyadic fraction of a turn, and its OpenQASM 3 beside it.
- reference: the protocol around the exact simulator, served both ways
  (wai-qpu reference --stdio | --http ADDR): the provider the tests run
  against, and the template to copy. Free, or priced per shot or job in
  exact decimals; polls, readout error and a credential checked by hash.
- conformance: the checker and its vectors (conformance/provider-v1.json),
  with the reference's counts pinned; jobs run only when free or allowed.
- registry: the person's list in their configuration directory, holding
  no credential; credentials in the keychain (the system security tool,
  or secret-tool), else a 0600 file, and every listing says which.
- job: the dry run (exact native compile, the check by simulation, the
  provider's estimate and billing unit), the refusal of a run that is not
  free until it is confirmed, and the seal of its counts by the engine.
- Provider gains details, estimate, a seeded submit and cancel, with
  defaults, so the three built-in clients keep working unchanged.

CI: the QPU workflow pins the three test binaries' counts and the new
tests by name, and a macOS leg runs the keychain test in its own
keychain file.

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

946015fa3e

• View at this point in history

2026-10-27 19:51:08 -04:00

Transaction Science

wai-quantum engine: a job on the person's own provider, read, compared and sealed ...

engine::provider says what a provider job may ask (counts of a program
whose measurements come at the end and whose angles are dyadic, so it
compiles exactly to a device's gates), turns the device's counts into a
result labelled measured with the circuit's exact distribution beside
them (total variation distance, Hellinger fidelity, and what the shots
alone would leave), and seals it so job::verify checks it.

catalog::read refuses a request that names a provider, so a host that
reaches none (the job service) never runs one on its own methods.

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

9a7ef658e5

• View at this point in history

2026-10-27 19:51:08 -04:00

Transaction Science

wai-quantum-py: release wheels on the command line tag; changelog and README ...

wai-quantum-py-release.yml builds the abi3 wheels on a wai-quantum-cli-v*
tag and attaches each with its SHA-256 to that forge release, as the
command line archives are (release/publish.sh, over the private network):
macOS arm64 and x86_64 (cross-built on the Apple-silicon runner), Linux
x86_64 and arm64 as manylinux2014 (maturin with zig 0.16.0, so the
runner glibc does not leak into the wheel; checked: the module needs
GLIBC_2.17 at most), and Windows x86_64. Each wheel that runs on its runner
is installed alone on Python 3.9 and runs tests/smoke.py first. Nothing is
published to a package index.

The changelog entry (wai/CHANGELOG.md), the crate README naming
engine::svg and the package, and ci/check.sh waiting on the service it
stops so the shell prints no job notice.

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

a8923383c4

• View at this point in history

2026-10-27 19:51:08 -04:00

Transaction Science

wai-quantum engine::svg: every mark keeps its colour without the style sheet ...

A page that strips <style> from what it shows (a notebook sanitising an
untrusted output) would leave unstyled lines with no stroke and the
background rectangle filled black. Each line and path now carries a stroke
in the text colour, each text and dot a fill, each box, ring and meter an
outline with no fill, the background none and each key swatch its hand
colour; the style sheet still overrides them all. A sixth test checks every
element of a drawing for its attribute. The doc notebooks are written again
with the new drawing, and ci/check.sh expands an empty array the way the
bash macOS ships accepts under set -u.

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

74cc2e221c

• View at this point in history

2026-10-27 19:51:08 -04:00

Transaction Science

wai-quantum-py: WAI Quantum in Python and notebooks, in-process ...

A new crate, wai/wai-quantum-py, built by maturin 1.15.0 into one abi3 wheel
per platform (pyo3 0.29.3, Python 3.9 on), module wai_quantum. Its extension
module wraps the shared job engine and nothing else: run, plan, lint, draw
(text and the engine SVG), layout, critique, improve, shortcuts,
equivalent, verify, seal, canonical, digest, methods, accuracy_classes and
history, values crossing one to one with JSON (NaN, integers past 64 bits
and non-string keys refused). A job is the service form as a plain dict
with helpers (counts, probabilities, expectations, amplitudes, method,
accuracy, receipt); Key reads and writes the command line key files and
finds the same user key; bloch gives each qubit reduced state from the
engine expectation values. A refusal raises EngineError with the engine
message, its line, and a code slot for the engine diagnostic codes.

Service is a client in the standard library alone for the job service
(submit, status, result, cancel, run), naming itself
wai-quantum-python/<version>, its receipts checked here offline.

Widgets (the widgets extra): Circuit (the engine drawing, gates clickable,
authorship marks from a history), Result, Receipt (the engine verdict) and
Bloch (drag to turn), each a plain ES module, each with static HTML (and
SVG) fallbacks that render without the widget library.

Five doc notebooks run in CI and are held to their stored outputs.
ci/check.sh is the whole check; 62 pytest tests hold the package to the
command line (same results, plans, lints, critiques, drawings, methods,
equivalence verdicts; receipts verified both ways; the same user key; the
digest recomputed from Python canonical bytes), to the service run locally,
and run the front ends under node on the payloads; Python 3.9 smoke with
the wheel alone. Workflow wai-quantum-py.yml runs it on linux and macos.

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

22fdc7a3cb

• View at this point in history

2026-10-27 19:51:08 -04:00

Transaction Science

wai-quantum engine: a circuit as a standalone SVG drawing (engine::svg) ...

The drawing the Studio makes from the layout, written once in the engine for
hosts with no page of their own (a notebook, a report, a file): the same
classes and geometry, a style sheet of its own scoped to .wq-circuit that
follows the text colour it is placed in, every number written to two
decimals so the same program writes the same bytes everywhere. Given whose
hand each operation is in, each gate is marked with its author and a key
under the drawing counts them; a condition legend and a note past 400
columns. Five tests: the Bell pair glyph by glyph, every layout item drawn
and the bytes repeatable, the authorship marks and key, escaping and number
writing, and the column cap.

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

e2ec75e00a

• View at this point in history

2026-10-27 19:51:08 -04:00