A free quantum job service: OpenQASM 3 run, checked and signed, with no account or key.
Maintain this server? Claim it
Call this server's tools from your browser. Nothing to install.
Requests go through mcptry because browsers can't call most MCP servers directly. Header values are sent to the server for that request only and are never stored or logged.
Tool list from our last check. Connect live to refresh it.
Whether two programs are the same circuit up to a global phase, and how the engine knows: Clifford circuits by their tableaus at any size, others on every basis state to 8 qubits, then by checked rewrites of one followed by the other's inverse to nothing (a proof at any width), then on random product states to 22 (evidence, not proof), otherwise unchecked with the reason. Its `verdict` is that decision; `verification` is the level it reached, as every tool's verdict states it. A check that would take long here is refused with the command that runs it locally.
Whether two programs are the same circuit up to a global phase, and how the engine knows: Clifford circuits by their tableaus at any size, others on every basis state to 8 qubits, then by checked rewrites of one followed by the other's inverse to nothing (a proof at any width), then on random product states to 22 (evidence, not proof), otherwise unchecked with the reason. Its `verdict` is that decision; `verification` is the level it reached, as every tool's verdict states it. A check that would take long here is refused with the command that runs it locally.
| Argument | Type | Description |
|---|---|---|
| a* | string | |
| b* | string |
{
"type": "object",
"required": [
"a",
"b"
],
"properties": {
"a": {
"type": "string"
},
"b": {
"type": "string"
}
}
}Every exact classical route to simulating a program, priced on it: the stabilizer tableau, the cut-rank sum, an exact matrix product state at a rigorous bond bound, the light cone of a one-qubit expectation value, and the state vector. The cheapest is named for each question. A cheap route proves the program classically easy; none being cheap proves nothing about hardness. A thorough search, with a contraction tree, runs locally: wai-quantum shortcuts --thorough.
| Argument | Type | Description |
|---|---|---|
| qasm* | string |
{
"type": "object",
"required": [
"qasm"
],
"properties": {
"qasm": {
"type": "string"
}
}
}Compile an OpenQASM program through named passes (lowering, checked rewrites, phase folding, one- and two-qubit resynthesis, and every rotation off the multiples of π/4 written as a Clifford+T word within its share of the ε budget), each checked where it acts. Returns the compiled program and a certificate sealed with the service's key: each pass's counts before and after, its check and verdict (proof, exact or approximate with its distance), the budget and the bound the distances add to. verify_quantum_receipt checks it. Quote the bound; an approximate compile is not exact. A large or very fine compile is refused with the local command.
| Argument | Type | Description |
|---|---|---|
| qasm* | string | |
| basis | string | clifford_t (default): every rotation off the multiples of π/4 written as a Clifford+T word within its share of epsilon; standard: nothing approximated. |
| level | integer | 0: lower and approximate; 1 (default): also checked rewrites and phase folding; 2: also one- and two-qubit resynthesis. |
| epsilon | number | The most the output may differ from the program in the operator norm, up to a global phase, shared by its rotations (default 1e-6). |
{
"type": "object",
"required": [
"qasm"
],
"properties": {
"qasm": {
"type": "string"
},
"basis": {
"enum": [
"clifford_t",
"standard"
],
"type": "string",
"description": "clifford_t (default): every rotation off the multiples of π/4 written as a Clifford+T word within its share of epsilon; standard: nothing approximated."
},
"level": {
"type": "integer",
"maximum": 2,
"minimum": 0,
"description": "0: lower and approximate; 1 (default): also checked rewrites and phase folding; 2: also one- and two-qubit resynthesis."
},
"epsilon": {
"type": "number",
"description": "The most the output may differ from the program in the operator norm, up to a global phase, shared by its rotations (default 1e-6).",
"exclusiveMinimum": 0
}
}
}A program's measures, computed by the engine: gates by kind, two-qubit gates, depth and two-qubit depth, T count, whether it is a Clifford circuit, and a fidelity under reference error rates (a model, not a run). Also its smells, each with its lines: gates that cancel, rotations that merge or do nothing, idle qubits, and qubits acted on but never measured.
| Argument | Type | Description |
|---|---|---|
| qasm* | string |
{
"type": "object",
"required": [
"qasm"
],
"properties": {
"qasm": {
"type": "string"
}
}
}What the service would do with a job or a set, running nothing: the method and why, the memory, the estimated time and energy (each with its basis: this service's own timings and readings where it has them, otherwise the planner's nominal rate, and no energy figure without readings), the bounds that apply, where you stand against your limits, and whether the service would take it now, or the refusal it would give, with its code. Takes what run_quantum_circuit or run_quantum_set takes. It counts as one submission.
| Argument | Type | Description |
|---|---|---|
| qasm | string | The program, OpenQASM 3 (or 2), read as the whole language: registers, aliases and slices; the standard gates, `U` and `gphase`; user `gate` definitions and `def` subroutines, inlined; every modifier (`ctrl @`, `negctrl @`, `inv @`, `pow(k) @`) on any gate, lowered exactly; classical types (int, uint, float, angle, complex, bool, bit, arrays), their arithmetic and built-in functions, computed on reading; `for`, `while`, `switch`, `break`, `continue`; measurement and `reset` anywhere; classical control on measured bits (`if (c[0]) x q[1];`, `if (c >= 2) { … } else { … }`, `&&`, `||`); a `while` on measured bits takes `@wai.max_iterations N` before it. `output` declarations come back in the result; `delay`, `box` and `stretch` are carried and labelled as not applied; `defcal` and `cal` are kept, not run. A program that measures in the middle or acts on what it measured runs on statevector or stabilizer: counts split their shots at each measurement; expectation values are exact, of the state before the final measurements. What the reader refuses comes back with a code, as `[Q103]`; qasm_diagnostics says what each code means. |
| seed | integer | Sampling seed (default 1); the same job and seed give the same counts. |
| noise | object |
What a fault-tolerant quantum computer would need to run a program. First its logical counts: T gates, Toffolis, rotations (each costed at the T count of its own synthesised Clifford+T word, within its share of the budget), measurements, T depth and total depth, and logical qubits with the ancillas that gates under several controls need. Then, on a physical qubit, the planar model's code distance (the gate-based surface code's model fitted to this engine's own decoders), T factories, physical qubits and runtime, and the frontier of estimates trading qubits for time. Takes a program, or a logical-counts or routine document. Every estimate is sealed in the resource-estimate receipt family, binding the program's digest and the ε budget; the answer's notes state the model's assumptions. Quote the figures with the qubit and the budget, and call them an estimate. Sealed with the service's key; verify_quantum_receipt checks the seals and re-runs it. A program with more than 256 distinct rotation angles, or a budget too fine for its rotations, is refused with the local command.
| Argument | Type | Description |
|---|---|---|
| name | string | The program's name in a routine document. |
| qasm | string | The program, OpenQASM 3 or 2. Give this, counts or routine. |
| qubit | any | The physical qubit: a reference qubit (ns-e4, the default: 50 ns gates, 1e-4 error; us-* are 100 µs gates, meas-* measurement-based), or one described. |
| budget | number | The probability the run may fail, shared by logical errors, distillation and the rotations' synthesis (default 1e-3). |
A job's status, and its result when it is done. The service keeps every job across its restarts for its retention (a day on the public service); a job that was running when it stopped comes back interrupted, with the reason.
| Argument | Type | Description |
|---|---|---|
| id* | string |
{
"type": "object",
"required": [
"id"
],
"properties": {
"id": {
"type": "string"
}
}
}The program with its smells fixed in its own text (all of them, and each alone), each candidate with its measures and the equivalence check's verdict against the program. A candidate the check finds different is never returned.
| Argument | Type | Description |
|---|---|---|
| qasm* | string |
{
"type": "object",
"required": [
"qasm"
],
"properties": {
"qasm": {
"type": "string"
}
}
}The device targets the service knows by name: synthetic, made up in the shapes of published formats, each with its qubits, pairs, the gates a program compiles to, the spread of its T1 and readout errors, and its hash. A job may give its own target document instead.
No arguments.
{
"type": "object",
"properties": {}
}Every code the OpenQASM reader gives (each refusal and warning carries one, as `[Q103]` at the end of its message): its outcome (refused, lowered, carried, preserved or warned) and its meaning; and beside them, under job_codes, the codes of what is asked of a program (`[J011]`: the request, the method, an intent, a repair, the host). A code never changes meaning once released. Give `code` for one of either.
| Argument | Type | Description |
|---|---|---|
| code | string | One code, as Q103 or J011. |
{
"type": "object",
"properties": {
"code": {
"type": "string",
"description": "One code, as Q103 or J011."
}
}
}Show an error-correcting code and certify its distance: its checks (Z-type: they see X errors) and stabilizers (X-type), k counted by rank, a layout to draw it, the decoders it admits, and its distance certificate. In each sector the certificate gives the least weight of a logical found, a witness of that weight, and every lighter support ruled out by an exhaustive search over connected supports (a bivariate-bicycle code's translations checked as symmetries before use), re-checkable node for node. Give `certificate` to check one: its witnesses and the search run again. Sealed with the service's key. Quote the certificate's distance and its reading; a search stopped by `bound` settles nothing past it.
| Argument | Type | Description |
|---|---|---|
| code* | any | A code by name: surface:D (the rotated surface code, odd D from 3 to 15), toric:L (2 to 12), steane, color:D (the triangular 6.6.6 colour code, odd D from 3 to 15), bb:72, bb:90, bb:108, bb:144 (or gross) or bb:288 (bivariate-bicycle codes); or {"family", "distance" | "size" | "n"}. |
| bound | integer | The heaviest support to search (default the code's nominal distance). |
| certify | boolean | Certify the distance (default true). |
| certificate | object | A certificate (wai.quantum.distance/1) to check against the code. |
{
"type": "object",
"required": [
"code"
],
"properties": {
"code": {
"description": "A code by name: surface:D (the rotated surface code, odd D from 3 to 15), toric:L (2 to 12), steane, color:D (the triangular 6.6.6 colour code, odd D from 3 to 15), bb:72, bb:90, bb:108, bb:144 (or gross) or bb:288 (bivariate-bicycle codes); or {\"family\", \"distance\" | \"size\" | \"n\"}."
},
"bound": {
"type": "integer",
"maximum": 24,
"minimum": 1,
"description": "The heaviest support to search (default the code's nominal distance)."
},
"certify": {
"type": "boolean",
"description": "Certify the distance (default true)."
},
"certificate": {
"type": "object",
"description": "A certificate (wai.quantum.distance/1) to check against the code."
}
}
}Decode with the engine's decoders. At code capacity, give `code` and a `syndrome` (the violated checks) or an `error` (the flipped qubits: its syndrome is taken and its residual judged, logical or not): matching (exact) and union_find for codes whose qubits sit in at most two checks; color for colour codes (restriction to matching on the three restricted lattices, lifted at each colour, completed below half the distance by an exact search); relay_bp for any code (it can stall on a degenerate error of a topological code, and then says it did not converge); search for the lightest error with the syndrome up to max_weight. At circuit level, give `memory` ({distance, rounds, p}: the rotated surface-code memory experiment), `circuit` (the circuit text: tags, Pauli-target observables and coordinates read) or `model` (detector error model text, decompositions with ^ read), with the fired `detectors` (the prediction: which observables flipped) or `shots` (sampled and decoded: the failure rate and its standard error): matching (exact), correlated (exact matching twice through the model's decomposed faults, the second answer kept only when the model's mechanisms explain it more cheaply), union_find, bp_osd, or window (a sliding window: `window` {commit, buffer} rounds; every edge set below half the distance is corrected once the buffer is at least (d + 1)/2). Sealed with the service's key.
| Argument | Type | Description |
|---|---|---|
| code | any | A code by name: surface:D (the rotated surface code, odd D from 3 to 15), toric:L (2 to 12), steane, color:D (the triangular 6.6.6 colour code, odd D from 3 to 15), bb:72, bb:90, bb:108, bb:144 (or gross) or bb:288 (bivariate-bicycle codes); or {"family", "distance" | "size" | "n"}. |
| seed | integer | The sampling seed (default 1). |
| error | array |
Measure logical failure rates over distances and physical error rates: family surface at circuit level (decoders matching, correlated or union_find; the code model P(d) = a·(p/p*)^((d+1)/2) per round fitted to the points), or color, toric or surface_capacity at code capacity. Each point gives its shots, failures, rate and standard error; below_threshold says, at each p, whether every larger distance failed less. Sealed with the service's key. Report rates with their errors: a crossing measured on few shots is not a threshold.
| Argument | Type | Description |
|---|---|---|
| p | array | Physical error rates. |
| seed | integer | |
| shots | integer | Shots at each point (default 10000). |
| family | string | surface (circuit level, the default) or a code at code capacity. |
| rounds | integer | surface: rounds (default the distance). |
| decoder | string | surface: the decoder (default matching). |
| distances | array | Odd distances (default 3, 5, 7). |
{
"type": "object",
"properties": {
"p": {
"type": "array",
"items": {
"type": "number",
"maximum": 0.5,
"minimum": 0
},
"description": "Physical error rates."
},
"seed": {
"type": "integer",
"minimum": 0
},
"shots": {
"type": "integer",
"minimum": 1,
"description": "Shots at each point (default 10000)."
},
"family": {
"enum": [
"surface",
"color",
"toric",
"surface_capacity"
],
"type": "string",
"description": "surface (circuit level, the default) or a code at code capacity."
},
"rounds": {
"type": "integer",
"minimum": 1,
"description": "surface: rounds (default the distance)."
},
"decoder": {
"enum": [
"matching",
"correlated",
"union_find"
],
"type": "string",
"description": "surface: the decoder (default matching)."
},
"distances": {
"type": "array",
"items": {
"type": "integer"
},
"description": "Odd distances (default 3, 5, 7)."
}
}
}Worked examples, each a complete job (OpenQASM program and arguments) with what it shows: a Bell pair, a rotation, QAOA, noise, a 1000-qubit GHZ state, 100-qubit dynamics, 200 qubits as a matrix product state. Pass an example's job to run_quantum_circuit as it is, or adapt it.
No arguments.
{
"type": "object",
"properties": {}
}The methods with their qubit limits and what each answers, the accuracy classes, the per-client limits, the current load, how jobs are kept and metered, the receipt keys, and the conventions (bit order, Pauli strings).
No arguments.
{
"type": "object",
"properties": {}
}Repair a program the reader refuses, changing only the lines its diagnostics flag. The engine makes the fixes that are mechanical (a missing `;`, an undeclared register's size, a measurement with no target, an unbounded while given the bound chosen, an angle the bit-exact method refuses rounded to the bits chosen with its rounding stated), and holds a fix you propose (`proposed`) to the flagged lines: any change to another line is rejected (J021) and nothing is changed. Returns the repaired program, each repair with its code and every line it changed, what needs a person with the reader's advice, and the verdict.
| Argument | Type | Description |
|---|---|---|
| qasm* | string | |
| rules | boolean | false: only check the proposal. |
| sizes | object | A register's size, for one used before it is declared (Q102). |
| proposed | string | Your repaired version: taken only if every changed line is a flagged one (or a line added beside one). |
| diagnostics | array | Codes you saw that reading the text does not raise (Q500). |
| dyadic_bits | integer | Round each angle the bit-exact method refuses (Q500) to the nearest multiple of 2π/2^K. |
| max_iterations |
Run an OpenQASM program as it would run on a device target: compiled exactly to its gates, placed on its most reliable qubits and routes (the expected success given), checked against the circuit, and simulated under the noise its calibration gives, on the density matrix or by trajectories. Counts and expectation values with their distance from the ideal distribution, the noise derived, and a receipt that binds the target's hash. A model of the device, not a run on it. Every angle must be a dyadic multiple of 2π. Waits up to 50 s, as run_quantum_circuit does.
| Argument | Type | Description |
|---|---|---|
| qasm* | string | The program, OpenQASM 3 (or 2), read as the whole language: registers, aliases and slices; the standard gates, `U` and `gphase`; user `gate` definitions and `def` subroutines, inlined; every modifier (`ctrl @`, `negctrl @`, `inv @`, `pow(k) @`) on any gate, lowered exactly; classical types (int, uint, float, angle, complex, bool, bit, arrays), their arithmetic and built-in functions, computed on reading; `for`, `while`, `switch`, `break`, `continue`; measurement and `reset` anywhere; classical control on measured bits (`if (c[0]) x q[1];`, `if (c >= 2) { … } else { … }`, `&&`, `||`); a `while` on measured bits takes `@wai.max_iterations N` before it. `output` declarations come back in the result; `delay`, `box` and `stretch` are carried and labelled as not applied; `defcal` and `cal` are kept, not run. A program that measures in the middle or acts on what it measured runs on statevector or stabilizer: counts split their shots at each measurement; expectation values are exact, of the state before the final measurements. What the reader refuses comes back with a code, as `[Q103]`; qasm_diagnostics says what each code means. |
| seed | integer | Sampling seed (default 1); the same job and seed give the same counts. |
| noise | object | Optional noise, each a probability: depolarizing_1q, depolarizing_2q, amplitude_damping, dephasing (after each gate on its qubits), readout (each measured bit). |
Run an OpenQASM program and return measurement counts, Pauli expectation values and/or amplitudes. The service chooses the method (bit-exact or double-precision state vector up to 32 qubits, single precision on a GPU to 33, stabilizer tableau for Clifford circuits up to 32768 qubits, matrix product states up to 4096, sparse Pauli dynamics for expectation values up to 1024 with an error bound, an exact density matrix or trajectories for noise), reports why and how accurate, and signs the result. Give `intent` (an exact distribution, or a reference program it must equal or whose state it must prepare) and the engine checks it with the run. Every answer carries `verdict`: the level the engine checked to (proof, evidence, executed, parsed, refused), whether the intent holds and a plain statement, sealed in the receipt. Waits up to 50 s; a longer job answers with status running and an id for get_quantum_job.
| Argument | Type | Description |
|---|---|---|
| qasm* | string | The program, OpenQASM 3 (or 2), read as the whole language: registers, aliases and slices; the standard gates, `U` and `gphase`; user `gate` definitions and `def` subroutines, inlined; every modifier (`ctrl @`, `negctrl @`, `inv @`, `pow(k) @`) on any gate, lowered exactly; classical types (int, uint, float, angle, complex, bool, bit, arrays), their arithmetic and built-in functions, computed on reading; `for`, `while`, `switch`, `break`, `continue`; measurement and `reset` anywhere; classical control on measured bits (`if (c[0]) x q[1];`, `if (c >= 2) { … } else { … }`, `&&`, `||`); a `while` on measured bits takes `@wai.max_iterations N` before it. `output` declarations come back in the result; `delay`, `box` and `stretch` are carried and labelled as not applied; `defcal` and `cal` are kept, not run. A program that measures in the middle or acts on what it measured runs on statevector or stabilizer: counts split their shots at each measurement; expectation values are exact, of the state before the final measurements. What the reader refuses comes back with a code, as `[Q103]`; qasm_diagnostics says what each code means. |
| seed |
Run several OpenQASM programs as one set (`programs`: each a program's text or a job), or one program over a grid of its inputs (`qasm` with `sweep`, as {"theta": [0.1, 0.2], "n": [2, 3]}: every combination; integer inputs written out, float and angle inputs bound to the double given). The set's other fields (shots, observables, seed, intent, …) apply to every item. Each item gets its own result and receipt, each stating its verdict, and one receipt over the set binds every item through a Merkle root; verify_quantum_receipt checks it whole. At most 100 items, run one after another in one job. Waits up to 50 s; a longer set answers with status running and an id for get_quantum_job.
| Argument | Type | Description |
|---|---|---|
| qasm | string | With sweep: the program, which declares the inputs the sweep gives values (`input uint n;`, `input float theta;`, `input angle phi;`). |
| seed | integer | Sampling seed (default 1); the same job and seed give the same counts. |
| noise | object | Optional noise, each a probability: depolarizing_1q, depolarizing_2q, amplitude_damping, dephasing (after each gate on its qubits), readout (each measured bit). |
| shots | integer | Measurement shots. Default 1024 when no observables or amplitudes are asked for. |
| sweep | object | Each input of qasm and its values: every combination runs, the names in sorted order, the first varying slowest; an integer input's values are whole numbers. |
| intent | any | What the program must do, checked by the engine with the run: the result's `verdict` states how far it checked (proof, evidence, executed, parsed, refused) and whether the intent holds, sealed by the receipt. |
A device target's qubits, pairs, native gates with the spread of their errors and durations, its calibration snapshot and its hash; with view, each qubit's place for drawing its coupling map with its readout and one-qubit errors, and each pair's two-qubit error. Give a built-in target's name or a target document.
| Argument | Type | Description |
|---|---|---|
| view | boolean | |
| target* | any | A built-in target's name, or a target document. |
{
"type": "object",
"required": [
"target"
],
"properties": {
"view": {
"type": "boolean"
},
"target": {
"description": "A built-in target's name, or a target document."
}
}
}Whether a result's receipt (an Ed25519 signature by the service) seals exactly that request and that result. Pass the job's own `request` (as run_quantum_circuit or get_quantum_job returns it: a run here asks for its verdict, so the request it seals says so) and its result.
| Argument | Type | Description |
|---|---|---|
| result* | object | |
| request* | object |
{
"type": "object",
"required": [
"request",
"result"
],
"properties": {
"result": {
"type": "object"
},
"request": {
"type": "object"
}
}
}| Optional noise, each a probability: depolarizing_1q, depolarizing_2q, amplitude_damping, dephasing (after each gate on its qubits), readout (each measured bit). |
| shots | integer | Measurement shots. Default 1024 when no observables or amplitudes are asked for. |
| sweep | object | Each input of qasm and its values: every combination runs, the names in sorted order, the first varying slowest; an integer input's values are whole numbers. |
| intent | any | What the program must do, checked by the engine with the run: the result's `verdict` states how far it checked (proof, evidence, executed, parsed, refused) and whether the intent holds, sealed by the receipt. |
| method | string | Leave as auto unless you need a particular method. |
| repair | any | Repair the program first, on the lines its diagnostics flag alone (as repair_qasm does): true, or the choices {"max_iterations": N, "dyadic_bits": K, "sizes": {"q": 3}}. The result's `repaired` holds the program that ran and each repair. |
| target | any | A device target: a built-in target's name (list_targets) or a target document (wai.quantum.target/1). The program is then compiled to its gates, placed where it is most likely to succeed and simulated under its noise, its hash in the receipt; not with noise or amplitudes. The service reads the document given and fetches nothing. |
| compile | object | Compile the program first (as compile_qasm does) and run the compiled circuit: with basis clifford_t it runs bit-exact, and the result's `compiled` states its distance from the program. |
| options | object | Advanced, per method: max_bond (mps), threshold and max_terms (pauli), fusion (statevector), trajectories. |
| mitigate | any | Mitigate the job's expectation values (or, for readout, its counts) under its own noise: zne (the whole program folded U(U†U)^k and extrapolated), pea (the noise learned as a sparse Pauli–Lindblad model and amplified), pec (the learned channels inverted and sampled), cdr (a line fitted over near-Clifford training circuits), vd (two copies), readout (the counts' flips inverted). Needs noise and observables (shots for readout), at most 8 qubits. The result's `mitigation` gives raw and mitigated values with standard errors, the ideal value (known because this is a simulation), the method's bias and variance assumptions and its cost. A method's name, or an object. |
| programs | array | The set's programs: each a program's text, or a job ({"qasm", …}) whose own fields win over the set's. |
| amplitudes | array | Basis states to give amplitudes of: one character per qubit, qubit n-1 first, e.g. "0011". |
| observables | array | Pauli strings to take expectation values of, e.g. ["Z0", "Z0 Z1", "X2 Y3"]. Qubits count from 0. |
{
"type": "object",
"properties": {
"qasm": {
"type": "string",
"description": "The program, OpenQASM 3 (or 2), read as the whole language: registers, aliases and slices; the standard gates, `U` and `gphase`; user `gate` definitions and `def` subroutines, inlined; every modifier (`ctrl @`, `negctrl @`, `inv @`, `pow(k) @`) on any gate, lowered exactly; classical types (int, uint, float, angle, complex, bool, bit, arrays), their arithmetic and built-in functions, computed on reading; `for`, `while`, `switch`, `break`, `continue`; measurement and `reset` anywhere; classical control on measured bits (`if (c[0]) x q[1];`, `if (c >= 2) { … } else { … }`, `&&`, `||`); a `while` on measured bits takes `@wai.max_iterations N` before it. `output` declarations come back in the result; `delay`, `box` and `stretch` are carried and labelled as not applied; `defcal` and `cal` are kept, not run. A program that measures in the middle or acts on what it measured runs on statevector or stabilizer: counts split their shots at each measurement; expectation values are exact, of the state before the final measurements. What the reader refuses comes back with a code, as `[Q103]`; qasm_diagnostics says what each code means."
},
"seed": {
"type": "integer",
"description": "Sampling seed (default 1); the same job and seed give the same counts."
},
"noise": {
"type": "object",
"properties": {
"readout": {
"type": "number"
},
"dephasing": {
"type": "number"
},
"depolarizing_1q": {
"type": "number"
},
"depolarizing_2q": {
"type": "number"
},
"amplitude_damping": {
"type": "number"
}
},
"description": "Optional noise, each a probability: depolarizing_1q, depolarizing_2q, amplitude_damping, dephasing (after each gate on its qubits), readout (each measured bit)."
},
"shots": {
"type": "integer",
"maximum": 1000000,
"minimum": 0,
"description": "Measurement shots. Default 1024 when no observables or amplitudes are asked for."
},
"sweep": {
"type": "object",
"description": "Each input of qasm and its values: every combination runs, the names in sorted order, the first varying slowest; an integer input's values are whole numbers.",
"additionalProperties": {
"type": "array",
"items": {
"type": "number"
},
"minItems": 1
}
},
"intent": {
"anyOf": [
{
"type": "object",
"properties": {
"name": {
"type": "string"
},
"note": {
"type": "string"
},
"seed": {
"type": "integer",
"minimum": 0,
"description": "For a sampled intent: the sampling seed (default: the job's)."
},
"test": {
"enum": [
"chi_squared",
"g_test"
],
"description": "For a sampled intent: Pearson's chi-squared test, or the G-test (the likelihood ratio)."
},
"alpha": {
"type": "number",
"description": "For a sampled intent: the significance level, as 0.01.",
"exclusiveMaximum": 1,
"exclusiveMinimum": 0
},
"shots": {
"type": "integer",
"minimum": 1,
"description": "For a sampled intent: the samples the test takes."
},
"require": {
"const": "proof"
},
"sampled": {
"type": "object",
"description": "A distribution the program's samples are held to: the program run as the job runs it for `shots` at `seed`, and the counts tested by `test` at the significance level `alpha` (all three required). Evidence, never proof.",
"additionalProperties": {
"type": "number",
"maximum": 1,
"minimum": 0
}
},
"prepares": {
"type": "string",
"description": "A reference program's text: the same state from |0…0⟩, the same qubits measured into the same bits."
},
"tolerance": {
"type": "number",
"maximum": 1,
"minimum": 0,
"description": "For a distribution: the total variation distance it is held within (default 1e-9)."
},
"equivalent": {
"type": "string",
"description": "A reference program's text: the same circuit up to a global phase, by the equivalence ladder."
},
"distribution": {
"type": "object",
"description": "The exact distribution of the measured bits, keyed by the classical bits with the highest bit first, as {\"00\": 0.5, \"11\": 0.5}.",
"additionalProperties": {
"type": "number",
"maximum": 1,
"minimum": 0
}
}
},
"description": "One of distribution, equivalent, prepares or sampled; with note, name, and \"require\": \"proof\" (evidence then counts as unchecked)."
},
{
"type": "array",
"items": {
"type": "object",
"properties": {
"name": {
"type": "string"
},
"note": {
"type": "string"
},
"seed": {
"type": "integer",
"minimum": 0,
"description": "For a sampled intent: the sampling seed (default: the job's)."
},
"test": {
"enum": [
"chi_squared",
"g_test"
],
"description": "For a sampled intent: Pearson's chi-squared test, or the G-test (the likelihood ratio)."
},
"alpha": {
"type": "number",
"description": "For a sampled intent: the significance level, as 0.01.",
"exclusiveMaximum": 1,
"exclusiveMinimum": 0
},
"shots": {
"type": "integer",
"minimum": 1,
"description": "For a sampled intent: the samples the test takes."
},
"require": {
"const": "proof"
},
"sampled": {
"type": "object",
"description": "A distribution the program's samples are held to: the program run as the job runs it for `shots` at `seed`, and the counts tested by `test` at the significance level `alpha` (all three required). Evidence, never proof.",
"additionalProperties": {
"type": "number",
"maximum": 1,
"minimum": 0
}
},
"prepares": {
"type": "string",
"description": "A reference program's text: the same state from |0…0⟩, the same qubits measured into the same bits."
},
"tolerance": {
"type": "number",
"maximum": 1,
"minimum": 0,
"description": "For a distribution: the total variation distance it is held within (default 1e-9)."
},
"equivalent": {
"type": "string",
"description": "A reference program's text: the same circuit up to a global phase, by the equivalence ladder."
},
"distribution": {
"type": "object",
"description": "The exact distribution of the measured bits, keyed by the classical bits with the highest bit first, as {\"00\": 0.5, \"11\": 0.5}.",
"additionalProperties": {
"type": "number",
"maximum": 1,
"minimum": 0
}
}
},
"description": "One of distribution, equivalent, prepares or sampled; with note, name, and \"require\": \"proof\" (evidence then counts as unchecked)."
},
"minItems": 1
}
],
"description": "What the program must do, checked by the engine with the run: the result's `verdict` states how far it checked (proof, evidence, executed, parsed, refused) and whether the intent holds, sealed by the receipt."
},
"method": {
"enum": [
"auto",
"exact",
"statevector",
"statevector_single",
"stabilizer",
"pauli",
"mps",
"tensor_network",
"cutrank",
"cutrank_single",
"density_matrix",
"trajectories"
],
"type": "string",
"description": "Leave as auto unless you need a particular method."
},
"repair": {
"description": "Repair the program first, on the lines its diagnostics flag alone (as repair_qasm does): true, or the choices {\"max_iterations\": N, \"dyadic_bits\": K, \"sizes\": {\"q\": 3}}. The result's `repaired` holds the program that ran and each repair."
},
"target": {
"description": "A device target: a built-in target's name (list_targets) or a target document (wai.quantum.target/1). The program is then compiled to its gates, placed where it is most likely to succeed and simulated under its noise, its hash in the receipt; not with noise or amplitudes. The service reads the document given and fetches nothing."
},
"compile": {
"type": "object",
"properties": {
"dd": {
"enum": [
"xx",
"xy4"
],
"type": "string",
"description": "Dynamical decoupling in each window where a qubit idles long enough, checked to change nothing without noise."
},
"basis": {
"enum": [
"clifford_t",
"standard"
],
"type": "string",
"description": "clifford_t (default): every rotation off the multiples of π/4 written as a Clifford+T word within its share of epsilon; standard: nothing approximated."
},
"level": {
"type": "integer",
"maximum": 2,
"minimum": 0,
"description": "0: lower and approximate; 1 (default): also checked rewrites and phase folding; 2: also one- and two-qubit resynthesis."
},
"twirl": {
"description": "Twirl each two-qubit Clifford gate with Paulis from a seeded stream: true, or {\"seed\": N}. One seed is one instance, checked to be the same circuit."
},
"epsilon": {
"type": "number",
"description": "The most the output may differ from the program in the operator norm, up to a global phase, shared by its rotations (default 1e-6).",
"exclusiveMinimum": 0
}
},
"description": "Compile the program first (as compile_qasm does) and run the compiled circuit: with basis clifford_t it runs bit-exact, and the result's `compiled` states its distance from the program."
},
"options": {
"type": "object",
"description": "Advanced, per method: max_bond (mps), threshold and max_terms (pauli), fusion (statevector), trajectories."
},
"mitigate": {
"anyOf": [
{
"enum": [
"zne",
"pea",
"pec",
"cdr",
"vd",
"readout"
],
"type": "string"
},
{
"type": "object",
"required": [
"method"
],
"properties": {
"keep": {
"type": "integer",
"minimum": 0,
"description": "cdr: non-Clifford gates each training circuit keeps (default 2, and always one fewer than the program has)."
},
"seed": {
"type": "integer",
"minimum": 0
},
"shots": {
"type": "integer",
"maximum": 1000000,
"minimum": 1,
"description": "Shots per circuit (default 10000; 2000 per sampled circuit for pec)."
},
"method": {
"enum": [
"zne",
"pea",
"pec",
"cdr",
"vd",
"readout"
],
"type": "string"
},
"factors": {
"type": "array",
"items": {
"type": "number"
},
"description": "zne: odd whole numbers (default 1, 3, 5); pea: factors from 1 to 10 (default 1, 1.5, 2)."
},
"samples": {
"type": "integer",
"minimum": 2,
"description": "pec: sampled circuits (default 200)."
},
"training": {
"type": "integer",
"minimum": 3,
"description": "cdr: training circuits (default 16)."
},
"learn_shots": {
"type": "integer",
"minimum": 100,
"description": "pea, pec: shots per depth of the cycle benchmarking that learns the noise (default 60000)."
},
"extrapolation": {
"enum": [
"richardson",
"linear",
"exponential"
],
"type": "string"
}
}
}
],
"description": "Mitigate the job's expectation values (or, for readout, its counts) under its own noise: zne (the whole program folded U(U†U)^k and extrapolated), pea (the noise learned as a sparse Pauli–Lindblad model and amplified), pec (the learned channels inverted and sampled), cdr (a line fitted over near-Clifford training circuits), vd (two copies), readout (the counts' flips inverted). Needs noise and observables (shots for readout), at most 8 qubits. The result's `mitigation` gives raw and mitigated values with standard errors, the ideal value (known because this is a simulation), the method's bias and variance assumptions and its cost. A method's name, or an object."
},
"programs": {
"type": "array",
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "object",
"required": [
"qasm"
]
}
]
},
"maxItems": 100,
"minItems": 1,
"description": "The set's programs: each a program's text, or a job ({\"qasm\", …}) whose own fields win over the set's."
},
"amplitudes": {
"type": "array",
"items": {
"type": "string"
},
"description": "Basis states to give amplitudes of: one character per qubit, qubit n-1 first, e.g. \"0011\"."
},
"observables": {
"type": "array",
"items": {
"type": "string"
},
"description": "Pauli strings to take expectation values of, e.g. [\"Z0\", \"Z0 Z1\", \"X2 Y3\"]. Qubits count from 0."
}
}
}| counts |
| object |
| A logical-counts document instead of a program: numQubits, tCount, rotationCount, rotationDepth, cczCount, ccixCount, measurementCount. |
| export | string | Also give the program's counts as a logical-counts or a routine document, under export. |
| routine | object | A routine document instead of a program (version v1: routines with their ports, resources, children and connections). |
| calibration | string | The gate-based surface code's model: fitted to this engine's exact-matching decoder (default) or its union-find decoder, or the planar model's assumed one. |
| max_slowdown | integer | The most the frontier slows the program by to need fewer factories (default 256). |
{
"type": "object",
"properties": {
"name": {
"type": "string",
"description": "The program's name in a routine document."
},
"qasm": {
"type": "string",
"description": "The program, OpenQASM 3 or 2. Give this, counts or routine."
},
"qubit": {
"anyOf": [
{
"enum": [
"us-e3",
"us-e4",
"ns-e3",
"ns-e4",
"meas-e4",
"meas-e6"
],
"type": "string"
},
{
"type": "object",
"properties": {
"name": {
"type": "string"
},
"gate_ns": {
"type": "number"
},
"meas_ns": {
"type": "number"
},
"t_error": {
"type": "number"
},
"clifford_error": {
"type": "number"
},
"instruction_set": {
"enum": [
"gate",
"measurement"
],
"type": "string"
}
}
}
],
"description": "The physical qubit: a reference qubit (ns-e4, the default: 50 ns gates, 1e-4 error; us-* are 100 µs gates, meas-* measurement-based), or one described."
},
"budget": {
"type": "number",
"description": "The probability the run may fail, shared by logical errors, distillation and the rotations' synthesis (default 1e-3).",
"exclusiveMaximum": 1,
"exclusiveMinimum": 0
},
"counts": {
"type": "object",
"description": "A logical-counts document instead of a program: numQubits, tCount, rotationCount, rotationDepth, cczCount, ccixCount, measurementCount."
},
"export": {
"enum": [
"counts",
"routine"
],
"type": "string",
"description": "Also give the program's counts as a logical-counts or a routine document, under export."
},
"routine": {
"type": "object",
"description": "A routine document instead of a program (version v1: routines with their ports, resources, children and connections)."
},
"calibration": {
"enum": [
"exact_matching",
"union_find",
"assumed"
],
"type": "string",
"description": "The gate-based surface code's model: fitted to this engine's exact-matching decoder (default) or its union-find decoder, or the planar model's assumed one."
},
"max_slowdown": {
"type": "integer",
"maximum": 4096,
"minimum": 1,
"description": "The most the frontier slows the program by to need fewer factories (default 256)."
}
}
}| The flipped qubits, by index. |
| model | string | A detector error model in its text. |
| shots | integer | Sample this many shots of the circuit and decode each. |
| memory | object | The rotated surface-code memory experiment at circuit level. |
| window | object | window: rounds each window commits and the rounds after them it sees. |
| circuit | string | A noisy Clifford circuit in the circuit text. |
| decoder | string | The decoder (default: matching, or color for a colour code, relay_bp for a bivariate-bicycle code). |
| syndrome | array | The violated checks, by index. |
| detectors | array | The detectors that fired. |
| max_weight | integer | search: the heaviest error to try. |
{
"type": "object",
"properties": {
"code": {
"description": "A code by name: surface:D (the rotated surface code, odd D from 3 to 15), toric:L (2 to 12), steane, color:D (the triangular 6.6.6 colour code, odd D from 3 to 15), bb:72, bb:90, bb:108, bb:144 (or gross) or bb:288 (bivariate-bicycle codes); or {\"family\", \"distance\" | \"size\" | \"n\"}."
},
"seed": {
"type": "integer",
"minimum": 0,
"description": "The sampling seed (default 1)."
},
"error": {
"type": "array",
"items": {
"type": "integer",
"minimum": 0
},
"description": "The flipped qubits, by index."
},
"model": {
"type": "string",
"description": "A detector error model in its text."
},
"shots": {
"type": "integer",
"minimum": 1,
"description": "Sample this many shots of the circuit and decode each."
},
"memory": {
"type": "object",
"properties": {
"p": {
"type": "number"
},
"rounds": {
"type": "integer"
},
"distance": {
"type": "integer"
}
},
"description": "The rotated surface-code memory experiment at circuit level."
},
"window": {
"type": "object",
"properties": {
"buffer": {
"type": "integer"
},
"commit": {
"type": "integer"
},
"budget_ns": {
"type": "integer"
}
},
"description": "window: rounds each window commits and the rounds after them it sees."
},
"circuit": {
"type": "string",
"description": "A noisy Clifford circuit in the circuit text."
},
"decoder": {
"enum": [
"matching",
"union_find",
"color",
"relay_bp",
"search",
"correlated",
"bp_osd",
"window"
],
"type": "string",
"description": "The decoder (default: matching, or color for a colour code, relay_bp for a bivariate-bicycle code)."
},
"syndrome": {
"type": "array",
"items": {
"type": "integer",
"minimum": 0
},
"description": "The violated checks, by index."
},
"detectors": {
"type": "array",
"items": {
"type": "integer",
"minimum": 0
},
"description": "The detectors that fired."
},
"max_weight": {
"type": "integer",
"maximum": 8,
"minimum": 0,
"description": "search: the heaviest error to try."
}
}
}| integer |
| The bound for an unbounded `while` on measured bits (Q310), as the person chose it. |
{
"type": "object",
"required": [
"qasm"
],
"properties": {
"qasm": {
"type": "string"
},
"rules": {
"type": "boolean",
"description": "false: only check the proposal."
},
"sizes": {
"type": "object",
"description": "A register's size, for one used before it is declared (Q102).",
"additionalProperties": {
"type": "integer",
"minimum": 1
}
},
"proposed": {
"type": "string",
"description": "Your repaired version: taken only if every changed line is a flagged one (or a line added beside one)."
},
"diagnostics": {
"type": "array",
"description": "Codes you saw that reading the text does not raise (Q500)."
},
"dyadic_bits": {
"type": "integer",
"maximum": 32,
"minimum": 1,
"description": "Round each angle the bit-exact method refuses (Q500) to the nearest multiple of 2π/2^K."
},
"max_iterations": {
"type": "integer",
"minimum": 1,
"description": "The bound for an unbounded `while` on measured bits (Q310), as the person chose it."
}
}
}| shots | integer | Measurement shots. Default 1024 when no observables or amplitudes are asked for. |
| intent | any | What the program must do, checked by the engine with the run: the result's `verdict` states how far it checked (proof, evidence, executed, parsed, refused) and whether the intent holds, sealed by the receipt. |
| repair | any | Repair the program first, on the lines its diagnostics flag alone (as repair_qasm does): true, or the choices {"max_iterations": N, "dyadic_bits": K, "sizes": {"q": 3}}. The result's `repaired` holds the program that ran and each repair. |
| target* | any | A device target: a built-in target's name (list_targets) or a target document (wai.quantum.target/1). The program is then compiled to its gates, placed where it is most likely to succeed and simulated under its noise, its hash in the receipt; not with noise or amplitudes. The service reads the document given and fetches nothing. |
| compile | object | Compile the program first (as compile_qasm does) and run the compiled circuit: with basis clifford_t it runs bit-exact, and the result's `compiled` states its distance from the program. |
| options | object | Advanced, per method: max_bond (mps), threshold and max_terms (pauli), fusion (statevector), trajectories. |
| mitigate | any | Mitigate the job's expectation values (or, for readout, its counts) under its own noise: zne (the whole program folded U(U†U)^k and extrapolated), pea (the noise learned as a sparse Pauli–Lindblad model and amplified), pec (the learned channels inverted and sampled), cdr (a line fitted over near-Clifford training circuits), vd (two copies), readout (the counts' flips inverted). Needs noise and observables (shots for readout), at most 8 qubits. The result's `mitigation` gives raw and mitigated values with standard errors, the ideal value (known because this is a simulation), the method's bias and variance assumptions and its cost. A method's name, or an object. |
| amplitudes | array | Basis states to give amplitudes of: one character per qubit, qubit n-1 first, e.g. "0011". |
| observables | array | Pauli strings to take expectation values of, e.g. ["Z0", "Z0 Z1", "X2 Y3"]. Qubits count from 0. |
{
"type": "object",
"required": [
"qasm",
"target"
],
"properties": {
"qasm": {
"type": "string",
"description": "The program, OpenQASM 3 (or 2), read as the whole language: registers, aliases and slices; the standard gates, `U` and `gphase`; user `gate` definitions and `def` subroutines, inlined; every modifier (`ctrl @`, `negctrl @`, `inv @`, `pow(k) @`) on any gate, lowered exactly; classical types (int, uint, float, angle, complex, bool, bit, arrays), their arithmetic and built-in functions, computed on reading; `for`, `while`, `switch`, `break`, `continue`; measurement and `reset` anywhere; classical control on measured bits (`if (c[0]) x q[1];`, `if (c >= 2) { … } else { … }`, `&&`, `||`); a `while` on measured bits takes `@wai.max_iterations N` before it. `output` declarations come back in the result; `delay`, `box` and `stretch` are carried and labelled as not applied; `defcal` and `cal` are kept, not run. A program that measures in the middle or acts on what it measured runs on statevector or stabilizer: counts split their shots at each measurement; expectation values are exact, of the state before the final measurements. What the reader refuses comes back with a code, as `[Q103]`; qasm_diagnostics says what each code means."
},
"seed": {
"type": "integer",
"description": "Sampling seed (default 1); the same job and seed give the same counts."
},
"noise": {
"type": "object",
"properties": {
"readout": {
"type": "number"
},
"dephasing": {
"type": "number"
},
"depolarizing_1q": {
"type": "number"
},
"depolarizing_2q": {
"type": "number"
},
"amplitude_damping": {
"type": "number"
}
},
"description": "Optional noise, each a probability: depolarizing_1q, depolarizing_2q, amplitude_damping, dephasing (after each gate on its qubits), readout (each measured bit)."
},
"shots": {
"type": "integer",
"maximum": 1000000,
"minimum": 0,
"description": "Measurement shots. Default 1024 when no observables or amplitudes are asked for."
},
"intent": {
"anyOf": [
{
"type": "object",
"properties": {
"name": {
"type": "string"
},
"note": {
"type": "string"
},
"seed": {
"type": "integer",
"minimum": 0,
"description": "For a sampled intent: the sampling seed (default: the job's)."
},
"test": {
"enum": [
"chi_squared",
"g_test"
],
"description": "For a sampled intent: Pearson's chi-squared test, or the G-test (the likelihood ratio)."
},
"alpha": {
"type": "number",
"description": "For a sampled intent: the significance level, as 0.01.",
"exclusiveMaximum": 1,
"exclusiveMinimum": 0
},
"shots": {
"type": "integer",
"minimum": 1,
"description": "For a sampled intent: the samples the test takes."
},
"require": {
"const": "proof"
},
"sampled": {
"type": "object",
"description": "A distribution the program's samples are held to: the program run as the job runs it for `shots` at `seed`, and the counts tested by `test` at the significance level `alpha` (all three required). Evidence, never proof.",
"additionalProperties": {
"type": "number",
"maximum": 1,
"minimum": 0
}
},
"prepares": {
"type": "string",
"description": "A reference program's text: the same state from |0…0⟩, the same qubits measured into the same bits."
},
"tolerance": {
"type": "number",
"maximum": 1,
"minimum": 0,
"description": "For a distribution: the total variation distance it is held within (default 1e-9)."
},
"equivalent": {
"type": "string",
"description": "A reference program's text: the same circuit up to a global phase, by the equivalence ladder."
},
"distribution": {
"type": "object",
"description": "The exact distribution of the measured bits, keyed by the classical bits with the highest bit first, as {\"00\": 0.5, \"11\": 0.5}.",
"additionalProperties": {
"type": "number",
"maximum": 1,
"minimum": 0
}
}
},
"description": "One of distribution, equivalent, prepares or sampled; with note, name, and \"require\": \"proof\" (evidence then counts as unchecked)."
},
{
"type": "array",
"items": {
"type": "object",
"properties": {
"name": {
"type": "string"
},
"note": {
"type": "string"
},
"seed": {
"type": "integer",
"minimum": 0,
"description": "For a sampled intent: the sampling seed (default: the job's)."
},
"test": {
"enum": [
"chi_squared",
"g_test"
],
"description": "For a sampled intent: Pearson's chi-squared test, or the G-test (the likelihood ratio)."
},
"alpha": {
"type": "number",
"description": "For a sampled intent: the significance level, as 0.01.",
"exclusiveMaximum": 1,
"exclusiveMinimum": 0
},
"shots": {
"type": "integer",
"minimum": 1,
"description": "For a sampled intent: the samples the test takes."
},
"require": {
"const": "proof"
},
"sampled": {
"type": "object",
"description": "A distribution the program's samples are held to: the program run as the job runs it for `shots` at `seed`, and the counts tested by `test` at the significance level `alpha` (all three required). Evidence, never proof.",
"additionalProperties": {
"type": "number",
"maximum": 1,
"minimum": 0
}
},
"prepares": {
"type": "string",
"description": "A reference program's text: the same state from |0…0⟩, the same qubits measured into the same bits."
},
"tolerance": {
"type": "number",
"maximum": 1,
"minimum": 0,
"description": "For a distribution: the total variation distance it is held within (default 1e-9)."
},
"equivalent": {
"type": "string",
"description": "A reference program's text: the same circuit up to a global phase, by the equivalence ladder."
},
"distribution": {
"type": "object",
"description": "The exact distribution of the measured bits, keyed by the classical bits with the highest bit first, as {\"00\": 0.5, \"11\": 0.5}.",
"additionalProperties": {
"type": "number",
"maximum": 1,
"minimum": 0
}
}
},
"description": "One of distribution, equivalent, prepares or sampled; with note, name, and \"require\": \"proof\" (evidence then counts as unchecked)."
},
"minItems": 1
}
],
"description": "What the program must do, checked by the engine with the run: the result's `verdict` states how far it checked (proof, evidence, executed, parsed, refused) and whether the intent holds, sealed by the receipt."
},
"repair": {
"description": "Repair the program first, on the lines its diagnostics flag alone (as repair_qasm does): true, or the choices {\"max_iterations\": N, \"dyadic_bits\": K, \"sizes\": {\"q\": 3}}. The result's `repaired` holds the program that ran and each repair."
},
"target": {
"description": "A device target: a built-in target's name (list_targets) or a target document (wai.quantum.target/1). The program is then compiled to its gates, placed where it is most likely to succeed and simulated under its noise, its hash in the receipt; not with noise or amplitudes. The service reads the document given and fetches nothing."
},
"compile": {
"type": "object",
"properties": {
"dd": {
"enum": [
"xx",
"xy4"
],
"type": "string",
"description": "Dynamical decoupling in each window where a qubit idles long enough, checked to change nothing without noise."
},
"basis": {
"enum": [
"clifford_t",
"standard"
],
"type": "string",
"description": "clifford_t (default): every rotation off the multiples of π/4 written as a Clifford+T word within its share of epsilon; standard: nothing approximated."
},
"level": {
"type": "integer",
"maximum": 2,
"minimum": 0,
"description": "0: lower and approximate; 1 (default): also checked rewrites and phase folding; 2: also one- and two-qubit resynthesis."
},
"twirl": {
"description": "Twirl each two-qubit Clifford gate with Paulis from a seeded stream: true, or {\"seed\": N}. One seed is one instance, checked to be the same circuit."
},
"epsilon": {
"type": "number",
"description": "The most the output may differ from the program in the operator norm, up to a global phase, shared by its rotations (default 1e-6).",
"exclusiveMinimum": 0
}
},
"description": "Compile the program first (as compile_qasm does) and run the compiled circuit: with basis clifford_t it runs bit-exact, and the result's `compiled` states its distance from the program."
},
"options": {
"type": "object",
"description": "Advanced, per method: max_bond (mps), threshold and max_terms (pauli), fusion (statevector), trajectories."
},
"mitigate": {
"anyOf": [
{
"enum": [
"zne",
"pea",
"pec",
"cdr",
"vd",
"readout"
],
"type": "string"
},
{
"type": "object",
"required": [
"method"
],
"properties": {
"keep": {
"type": "integer",
"minimum": 0,
"description": "cdr: non-Clifford gates each training circuit keeps (default 2, and always one fewer than the program has)."
},
"seed": {
"type": "integer",
"minimum": 0
},
"shots": {
"type": "integer",
"maximum": 1000000,
"minimum": 1,
"description": "Shots per circuit (default 10000; 2000 per sampled circuit for pec)."
},
"method": {
"enum": [
"zne",
"pea",
"pec",
"cdr",
"vd",
"readout"
],
"type": "string"
},
"factors": {
"type": "array",
"items": {
"type": "number"
},
"description": "zne: odd whole numbers (default 1, 3, 5); pea: factors from 1 to 10 (default 1, 1.5, 2)."
},
"samples": {
"type": "integer",
"minimum": 2,
"description": "pec: sampled circuits (default 200)."
},
"training": {
"type": "integer",
"minimum": 3,
"description": "cdr: training circuits (default 16)."
},
"learn_shots": {
"type": "integer",
"minimum": 100,
"description": "pea, pec: shots per depth of the cycle benchmarking that learns the noise (default 60000)."
},
"extrapolation": {
"enum": [
"richardson",
"linear",
"exponential"
],
"type": "string"
}
}
}
],
"description": "Mitigate the job's expectation values (or, for readout, its counts) under its own noise: zne (the whole program folded U(U†U)^k and extrapolated), pea (the noise learned as a sparse Pauli–Lindblad model and amplified), pec (the learned channels inverted and sampled), cdr (a line fitted over near-Clifford training circuits), vd (two copies), readout (the counts' flips inverted). Needs noise and observables (shots for readout), at most 8 qubits. The result's `mitigation` gives raw and mitigated values with standard errors, the ideal value (known because this is a simulation), the method's bias and variance assumptions and its cost. A method's name, or an object."
},
"amplitudes": {
"type": "array",
"items": {
"type": "string"
},
"description": "Basis states to give amplitudes of: one character per qubit, qubit n-1 first, e.g. \"0011\"."
},
"observables": {
"type": "array",
"items": {
"type": "string"
},
"description": "Pauli strings to take expectation values of, e.g. [\"Z0\", \"Z0 Z1\", \"X2 Y3\"]. Qubits count from 0."
}
}
}| integer |
| Sampling seed (default 1); the same job and seed give the same counts. |
| noise | object | Optional noise, each a probability: depolarizing_1q, depolarizing_2q, amplitude_damping, dephasing (after each gate on its qubits), readout (each measured bit). |
| shots | integer | Measurement shots. Default 1024 when no observables or amplitudes are asked for. |
| intent | any | What the program must do, checked by the engine with the run: the result's `verdict` states how far it checked (proof, evidence, executed, parsed, refused) and whether the intent holds, sealed by the receipt. |
| method | string | Leave as auto unless you need a particular method. |
| repair | any | Repair the program first, on the lines its diagnostics flag alone (as repair_qasm does): true, or the choices {"max_iterations": N, "dyadic_bits": K, "sizes": {"q": 3}}. The result's `repaired` holds the program that ran and each repair. |
| target | any | A device target: a built-in target's name (list_targets) or a target document (wai.quantum.target/1). The program is then compiled to its gates, placed where it is most likely to succeed and simulated under its noise, its hash in the receipt; not with noise or amplitudes. The service reads the document given and fetches nothing. |
| compile | object | Compile the program first (as compile_qasm does) and run the compiled circuit: with basis clifford_t it runs bit-exact, and the result's `compiled` states its distance from the program. |
| options | object | Advanced, per method: max_bond (mps), threshold and max_terms (pauli), fusion (statevector), trajectories. |
| mitigate | any | Mitigate the job's expectation values (or, for readout, its counts) under its own noise: zne (the whole program folded U(U†U)^k and extrapolated), pea (the noise learned as a sparse Pauli–Lindblad model and amplified), pec (the learned channels inverted and sampled), cdr (a line fitted over near-Clifford training circuits), vd (two copies), readout (the counts' flips inverted). Needs noise and observables (shots for readout), at most 8 qubits. The result's `mitigation` gives raw and mitigated values with standard errors, the ideal value (known because this is a simulation), the method's bias and variance assumptions and its cost. A method's name, or an object. |
| amplitudes | array | Basis states to give amplitudes of: one character per qubit, qubit n-1 first, e.g. "0011". |
| observables | array | Pauli strings to take expectation values of, e.g. ["Z0", "Z0 Z1", "X2 Y3"]. Qubits count from 0. |
{
"type": "object",
"required": [
"qasm"
],
"properties": {
"qasm": {
"type": "string",
"description": "The program, OpenQASM 3 (or 2), read as the whole language: registers, aliases and slices; the standard gates, `U` and `gphase`; user `gate` definitions and `def` subroutines, inlined; every modifier (`ctrl @`, `negctrl @`, `inv @`, `pow(k) @`) on any gate, lowered exactly; classical types (int, uint, float, angle, complex, bool, bit, arrays), their arithmetic and built-in functions, computed on reading; `for`, `while`, `switch`, `break`, `continue`; measurement and `reset` anywhere; classical control on measured bits (`if (c[0]) x q[1];`, `if (c >= 2) { … } else { … }`, `&&`, `||`); a `while` on measured bits takes `@wai.max_iterations N` before it. `output` declarations come back in the result; `delay`, `box` and `stretch` are carried and labelled as not applied; `defcal` and `cal` are kept, not run. A program that measures in the middle or acts on what it measured runs on statevector or stabilizer: counts split their shots at each measurement; expectation values are exact, of the state before the final measurements. What the reader refuses comes back with a code, as `[Q103]`; qasm_diagnostics says what each code means."
},
"seed": {
"type": "integer",
"description": "Sampling seed (default 1); the same job and seed give the same counts."
},
"noise": {
"type": "object",
"properties": {
"readout": {
"type": "number"
},
"dephasing": {
"type": "number"
},
"depolarizing_1q": {
"type": "number"
},
"depolarizing_2q": {
"type": "number"
},
"amplitude_damping": {
"type": "number"
}
},
"description": "Optional noise, each a probability: depolarizing_1q, depolarizing_2q, amplitude_damping, dephasing (after each gate on its qubits), readout (each measured bit)."
},
"shots": {
"type": "integer",
"maximum": 1000000,
"minimum": 0,
"description": "Measurement shots. Default 1024 when no observables or amplitudes are asked for."
},
"intent": {
"anyOf": [
{
"type": "object",
"properties": {
"name": {
"type": "string"
},
"note": {
"type": "string"
},
"seed": {
"type": "integer",
"minimum": 0,
"description": "For a sampled intent: the sampling seed (default: the job's)."
},
"test": {
"enum": [
"chi_squared",
"g_test"
],
"description": "For a sampled intent: Pearson's chi-squared test, or the G-test (the likelihood ratio)."
},
"alpha": {
"type": "number",
"description": "For a sampled intent: the significance level, as 0.01.",
"exclusiveMaximum": 1,
"exclusiveMinimum": 0
},
"shots": {
"type": "integer",
"minimum": 1,
"description": "For a sampled intent: the samples the test takes."
},
"require": {
"const": "proof"
},
"sampled": {
"type": "object",
"description": "A distribution the program's samples are held to: the program run as the job runs it for `shots` at `seed`, and the counts tested by `test` at the significance level `alpha` (all three required). Evidence, never proof.",
"additionalProperties": {
"type": "number",
"maximum": 1,
"minimum": 0
}
},
"prepares": {
"type": "string",
"description": "A reference program's text: the same state from |0…0⟩, the same qubits measured into the same bits."
},
"tolerance": {
"type": "number",
"maximum": 1,
"minimum": 0,
"description": "For a distribution: the total variation distance it is held within (default 1e-9)."
},
"equivalent": {
"type": "string",
"description": "A reference program's text: the same circuit up to a global phase, by the equivalence ladder."
},
"distribution": {
"type": "object",
"description": "The exact distribution of the measured bits, keyed by the classical bits with the highest bit first, as {\"00\": 0.5, \"11\": 0.5}.",
"additionalProperties": {
"type": "number",
"maximum": 1,
"minimum": 0
}
}
},
"description": "One of distribution, equivalent, prepares or sampled; with note, name, and \"require\": \"proof\" (evidence then counts as unchecked)."
},
{
"type": "array",
"items": {
"type": "object",
"properties": {
"name": {
"type": "string"
},
"note": {
"type": "string"
},
"seed": {
"type": "integer",
"minimum": 0,
"description": "For a sampled intent: the sampling seed (default: the job's)."
},
"test": {
"enum": [
"chi_squared",
"g_test"
],
"description": "For a sampled intent: Pearson's chi-squared test, or the G-test (the likelihood ratio)."
},
"alpha": {
"type": "number",
"description": "For a sampled intent: the significance level, as 0.01.",
"exclusiveMaximum": 1,
"exclusiveMinimum": 0
},
"shots": {
"type": "integer",
"minimum": 1,
"description": "For a sampled intent: the samples the test takes."
},
"require": {
"const": "proof"
},
"sampled": {
"type": "object",
"description": "A distribution the program's samples are held to: the program run as the job runs it for `shots` at `seed`, and the counts tested by `test` at the significance level `alpha` (all three required). Evidence, never proof.",
"additionalProperties": {
"type": "number",
"maximum": 1,
"minimum": 0
}
},
"prepares": {
"type": "string",
"description": "A reference program's text: the same state from |0…0⟩, the same qubits measured into the same bits."
},
"tolerance": {
"type": "number",
"maximum": 1,
"minimum": 0,
"description": "For a distribution: the total variation distance it is held within (default 1e-9)."
},
"equivalent": {
"type": "string",
"description": "A reference program's text: the same circuit up to a global phase, by the equivalence ladder."
},
"distribution": {
"type": "object",
"description": "The exact distribution of the measured bits, keyed by the classical bits with the highest bit first, as {\"00\": 0.5, \"11\": 0.5}.",
"additionalProperties": {
"type": "number",
"maximum": 1,
"minimum": 0
}
}
},
"description": "One of distribution, equivalent, prepares or sampled; with note, name, and \"require\": \"proof\" (evidence then counts as unchecked)."
},
"minItems": 1
}
],
"description": "What the program must do, checked by the engine with the run: the result's `verdict` states how far it checked (proof, evidence, executed, parsed, refused) and whether the intent holds, sealed by the receipt."
},
"method": {
"enum": [
"auto",
"exact",
"statevector",
"statevector_single",
"stabilizer",
"pauli",
"mps",
"tensor_network",
"cutrank",
"cutrank_single",
"density_matrix",
"trajectories"
],
"type": "string",
"description": "Leave as auto unless you need a particular method."
},
"repair": {
"description": "Repair the program first, on the lines its diagnostics flag alone (as repair_qasm does): true, or the choices {\"max_iterations\": N, \"dyadic_bits\": K, \"sizes\": {\"q\": 3}}. The result's `repaired` holds the program that ran and each repair."
},
"target": {
"description": "A device target: a built-in target's name (list_targets) or a target document (wai.quantum.target/1). The program is then compiled to its gates, placed where it is most likely to succeed and simulated under its noise, its hash in the receipt; not with noise or amplitudes. The service reads the document given and fetches nothing."
},
"compile": {
"type": "object",
"properties": {
"dd": {
"enum": [
"xx",
"xy4"
],
"type": "string",
"description": "Dynamical decoupling in each window where a qubit idles long enough, checked to change nothing without noise."
},
"basis": {
"enum": [
"clifford_t",
"standard"
],
"type": "string",
"description": "clifford_t (default): every rotation off the multiples of π/4 written as a Clifford+T word within its share of epsilon; standard: nothing approximated."
},
"level": {
"type": "integer",
"maximum": 2,
"minimum": 0,
"description": "0: lower and approximate; 1 (default): also checked rewrites and phase folding; 2: also one- and two-qubit resynthesis."
},
"twirl": {
"description": "Twirl each two-qubit Clifford gate with Paulis from a seeded stream: true, or {\"seed\": N}. One seed is one instance, checked to be the same circuit."
},
"epsilon": {
"type": "number",
"description": "The most the output may differ from the program in the operator norm, up to a global phase, shared by its rotations (default 1e-6).",
"exclusiveMinimum": 0
}
},
"description": "Compile the program first (as compile_qasm does) and run the compiled circuit: with basis clifford_t it runs bit-exact, and the result's `compiled` states its distance from the program."
},
"options": {
"type": "object",
"description": "Advanced, per method: max_bond (mps), threshold and max_terms (pauli), fusion (statevector), trajectories."
},
"mitigate": {
"anyOf": [
{
"enum": [
"zne",
"pea",
"pec",
"cdr",
"vd",
"readout"
],
"type": "string"
},
{
"type": "object",
"required": [
"method"
],
"properties": {
"keep": {
"type": "integer",
"minimum": 0,
"description": "cdr: non-Clifford gates each training circuit keeps (default 2, and always one fewer than the program has)."
},
"seed": {
"type": "integer",
"minimum": 0
},
"shots": {
"type": "integer",
"maximum": 1000000,
"minimum": 1,
"description": "Shots per circuit (default 10000; 2000 per sampled circuit for pec)."
},
"method": {
"enum": [
"zne",
"pea",
"pec",
"cdr",
"vd",
"readout"
],
"type": "string"
},
"factors": {
"type": "array",
"items": {
"type": "number"
},
"description": "zne: odd whole numbers (default 1, 3, 5); pea: factors from 1 to 10 (default 1, 1.5, 2)."
},
"samples": {
"type": "integer",
"minimum": 2,
"description": "pec: sampled circuits (default 200)."
},
"training": {
"type": "integer",
"minimum": 3,
"description": "cdr: training circuits (default 16)."
},
"learn_shots": {
"type": "integer",
"minimum": 100,
"description": "pea, pec: shots per depth of the cycle benchmarking that learns the noise (default 60000)."
},
"extrapolation": {
"enum": [
"richardson",
"linear",
"exponential"
],
"type": "string"
}
}
}
],
"description": "Mitigate the job's expectation values (or, for readout, its counts) under its own noise: zne (the whole program folded U(U†U)^k and extrapolated), pea (the noise learned as a sparse Pauli–Lindblad model and amplified), pec (the learned channels inverted and sampled), cdr (a line fitted over near-Clifford training circuits), vd (two copies), readout (the counts' flips inverted). Needs noise and observables (shots for readout), at most 8 qubits. The result's `mitigation` gives raw and mitigated values with standard errors, the ideal value (known because this is a simulation), the method's bias and variance assumptions and its cost. A method's name, or an object."
},
"amplitudes": {
"type": "array",
"items": {
"type": "string"
},
"description": "Basis states to give amplitudes of: one character per qubit, qubit n-1 first, e.g. \"0011\"."
},
"observables": {
"type": "array",
"items": {
"type": "string"
},
"description": "Pauli strings to take expectation values of, e.g. [\"Z0\", \"Z0 Z1\", \"X2 Y3\"]. Qubits count from 0."
}
}
}| method | string | Leave as auto unless you need a particular method. |
| repair | any | Repair the program first, on the lines its diagnostics flag alone (as repair_qasm does): true, or the choices {"max_iterations": N, "dyadic_bits": K, "sizes": {"q": 3}}. The result's `repaired` holds the program that ran and each repair. |
| target | any | A device target: a built-in target's name (list_targets) or a target document (wai.quantum.target/1). The program is then compiled to its gates, placed where it is most likely to succeed and simulated under its noise, its hash in the receipt; not with noise or amplitudes. The service reads the document given and fetches nothing. |
| compile | object | Compile the program first (as compile_qasm does) and run the compiled circuit: with basis clifford_t it runs bit-exact, and the result's `compiled` states its distance from the program. |
| options | object | Advanced, per method: max_bond (mps), threshold and max_terms (pauli), fusion (statevector), trajectories. |
| mitigate | any | Mitigate the job's expectation values (or, for readout, its counts) under its own noise: zne (the whole program folded U(U†U)^k and extrapolated), pea (the noise learned as a sparse Pauli–Lindblad model and amplified), pec (the learned channels inverted and sampled), cdr (a line fitted over near-Clifford training circuits), vd (two copies), readout (the counts' flips inverted). Needs noise and observables (shots for readout), at most 8 qubits. The result's `mitigation` gives raw and mitigated values with standard errors, the ideal value (known because this is a simulation), the method's bias and variance assumptions and its cost. A method's name, or an object. |
| programs | array | The set's programs: each a program's text, or a job ({"qasm", …}) whose own fields win over the set's. |
| amplitudes | array | Basis states to give amplitudes of: one character per qubit, qubit n-1 first, e.g. "0011". |
| observables | array | Pauli strings to take expectation values of, e.g. ["Z0", "Z0 Z1", "X2 Y3"]. Qubits count from 0. |
{
"type": "object",
"properties": {
"qasm": {
"type": "string",
"description": "With sweep: the program, which declares the inputs the sweep gives values (`input uint n;`, `input float theta;`, `input angle phi;`)."
},
"seed": {
"type": "integer",
"description": "Sampling seed (default 1); the same job and seed give the same counts."
},
"noise": {
"type": "object",
"properties": {
"readout": {
"type": "number"
},
"dephasing": {
"type": "number"
},
"depolarizing_1q": {
"type": "number"
},
"depolarizing_2q": {
"type": "number"
},
"amplitude_damping": {
"type": "number"
}
},
"description": "Optional noise, each a probability: depolarizing_1q, depolarizing_2q, amplitude_damping, dephasing (after each gate on its qubits), readout (each measured bit)."
},
"shots": {
"type": "integer",
"maximum": 1000000,
"minimum": 0,
"description": "Measurement shots. Default 1024 when no observables or amplitudes are asked for."
},
"sweep": {
"type": "object",
"description": "Each input of qasm and its values: every combination runs, the names in sorted order, the first varying slowest; an integer input's values are whole numbers.",
"additionalProperties": {
"type": "array",
"items": {
"type": "number"
},
"minItems": 1
}
},
"intent": {
"anyOf": [
{
"type": "object",
"properties": {
"name": {
"type": "string"
},
"note": {
"type": "string"
},
"seed": {
"type": "integer",
"minimum": 0,
"description": "For a sampled intent: the sampling seed (default: the job's)."
},
"test": {
"enum": [
"chi_squared",
"g_test"
],
"description": "For a sampled intent: Pearson's chi-squared test, or the G-test (the likelihood ratio)."
},
"alpha": {
"type": "number",
"description": "For a sampled intent: the significance level, as 0.01.",
"exclusiveMaximum": 1,
"exclusiveMinimum": 0
},
"shots": {
"type": "integer",
"minimum": 1,
"description": "For a sampled intent: the samples the test takes."
},
"require": {
"const": "proof"
},
"sampled": {
"type": "object",
"description": "A distribution the program's samples are held to: the program run as the job runs it for `shots` at `seed`, and the counts tested by `test` at the significance level `alpha` (all three required). Evidence, never proof.",
"additionalProperties": {
"type": "number",
"maximum": 1,
"minimum": 0
}
},
"prepares": {
"type": "string",
"description": "A reference program's text: the same state from |0…0⟩, the same qubits measured into the same bits."
},
"tolerance": {
"type": "number",
"maximum": 1,
"minimum": 0,
"description": "For a distribution: the total variation distance it is held within (default 1e-9)."
},
"equivalent": {
"type": "string",
"description": "A reference program's text: the same circuit up to a global phase, by the equivalence ladder."
},
"distribution": {
"type": "object",
"description": "The exact distribution of the measured bits, keyed by the classical bits with the highest bit first, as {\"00\": 0.5, \"11\": 0.5}.",
"additionalProperties": {
"type": "number",
"maximum": 1,
"minimum": 0
}
}
},
"description": "One of distribution, equivalent, prepares or sampled; with note, name, and \"require\": \"proof\" (evidence then counts as unchecked)."
},
{
"type": "array",
"items": {
"type": "object",
"properties": {
"name": {
"type": "string"
},
"note": {
"type": "string"
},
"seed": {
"type": "integer",
"minimum": 0,
"description": "For a sampled intent: the sampling seed (default: the job's)."
},
"test": {
"enum": [
"chi_squared",
"g_test"
],
"description": "For a sampled intent: Pearson's chi-squared test, or the G-test (the likelihood ratio)."
},
"alpha": {
"type": "number",
"description": "For a sampled intent: the significance level, as 0.01.",
"exclusiveMaximum": 1,
"exclusiveMinimum": 0
},
"shots": {
"type": "integer",
"minimum": 1,
"description": "For a sampled intent: the samples the test takes."
},
"require": {
"const": "proof"
},
"sampled": {
"type": "object",
"description": "A distribution the program's samples are held to: the program run as the job runs it for `shots` at `seed`, and the counts tested by `test` at the significance level `alpha` (all three required). Evidence, never proof.",
"additionalProperties": {
"type": "number",
"maximum": 1,
"minimum": 0
}
},
"prepares": {
"type": "string",
"description": "A reference program's text: the same state from |0…0⟩, the same qubits measured into the same bits."
},
"tolerance": {
"type": "number",
"maximum": 1,
"minimum": 0,
"description": "For a distribution: the total variation distance it is held within (default 1e-9)."
},
"equivalent": {
"type": "string",
"description": "A reference program's text: the same circuit up to a global phase, by the equivalence ladder."
},
"distribution": {
"type": "object",
"description": "The exact distribution of the measured bits, keyed by the classical bits with the highest bit first, as {\"00\": 0.5, \"11\": 0.5}.",
"additionalProperties": {
"type": "number",
"maximum": 1,
"minimum": 0
}
}
},
"description": "One of distribution, equivalent, prepares or sampled; with note, name, and \"require\": \"proof\" (evidence then counts as unchecked)."
},
"minItems": 1
}
],
"description": "What the program must do, checked by the engine with the run: the result's `verdict` states how far it checked (proof, evidence, executed, parsed, refused) and whether the intent holds, sealed by the receipt."
},
"method": {
"enum": [
"auto",
"exact",
"statevector",
"statevector_single",
"stabilizer",
"pauli",
"mps",
"tensor_network",
"cutrank",
"cutrank_single",
"density_matrix",
"trajectories"
],
"type": "string",
"description": "Leave as auto unless you need a particular method."
},
"repair": {
"description": "Repair the program first, on the lines its diagnostics flag alone (as repair_qasm does): true, or the choices {\"max_iterations\": N, \"dyadic_bits\": K, \"sizes\": {\"q\": 3}}. The result's `repaired` holds the program that ran and each repair."
},
"target": {
"description": "A device target: a built-in target's name (list_targets) or a target document (wai.quantum.target/1). The program is then compiled to its gates, placed where it is most likely to succeed and simulated under its noise, its hash in the receipt; not with noise or amplitudes. The service reads the document given and fetches nothing."
},
"compile": {
"type": "object",
"properties": {
"dd": {
"enum": [
"xx",
"xy4"
],
"type": "string",
"description": "Dynamical decoupling in each window where a qubit idles long enough, checked to change nothing without noise."
},
"basis": {
"enum": [
"clifford_t",
"standard"
],
"type": "string",
"description": "clifford_t (default): every rotation off the multiples of π/4 written as a Clifford+T word within its share of epsilon; standard: nothing approximated."
},
"level": {
"type": "integer",
"maximum": 2,
"minimum": 0,
"description": "0: lower and approximate; 1 (default): also checked rewrites and phase folding; 2: also one- and two-qubit resynthesis."
},
"twirl": {
"description": "Twirl each two-qubit Clifford gate with Paulis from a seeded stream: true, or {\"seed\": N}. One seed is one instance, checked to be the same circuit."
},
"epsilon": {
"type": "number",
"description": "The most the output may differ from the program in the operator norm, up to a global phase, shared by its rotations (default 1e-6).",
"exclusiveMinimum": 0
}
},
"description": "Compile the program first (as compile_qasm does) and run the compiled circuit: with basis clifford_t it runs bit-exact, and the result's `compiled` states its distance from the program."
},
"options": {
"type": "object",
"description": "Advanced, per method: max_bond (mps), threshold and max_terms (pauli), fusion (statevector), trajectories."
},
"mitigate": {
"anyOf": [
{
"enum": [
"zne",
"pea",
"pec",
"cdr",
"vd",
"readout"
],
"type": "string"
},
{
"type": "object",
"required": [
"method"
],
"properties": {
"keep": {
"type": "integer",
"minimum": 0,
"description": "cdr: non-Clifford gates each training circuit keeps (default 2, and always one fewer than the program has)."
},
"seed": {
"type": "integer",
"minimum": 0
},
"shots": {
"type": "integer",
"maximum": 1000000,
"minimum": 1,
"description": "Shots per circuit (default 10000; 2000 per sampled circuit for pec)."
},
"method": {
"enum": [
"zne",
"pea",
"pec",
"cdr",
"vd",
"readout"
],
"type": "string"
},
"factors": {
"type": "array",
"items": {
"type": "number"
},
"description": "zne: odd whole numbers (default 1, 3, 5); pea: factors from 1 to 10 (default 1, 1.5, 2)."
},
"samples": {
"type": "integer",
"minimum": 2,
"description": "pec: sampled circuits (default 200)."
},
"training": {
"type": "integer",
"minimum": 3,
"description": "cdr: training circuits (default 16)."
},
"learn_shots": {
"type": "integer",
"minimum": 100,
"description": "pea, pec: shots per depth of the cycle benchmarking that learns the noise (default 60000)."
},
"extrapolation": {
"enum": [
"richardson",
"linear",
"exponential"
],
"type": "string"
}
}
}
],
"description": "Mitigate the job's expectation values (or, for readout, its counts) under its own noise: zne (the whole program folded U(U†U)^k and extrapolated), pea (the noise learned as a sparse Pauli–Lindblad model and amplified), pec (the learned channels inverted and sampled), cdr (a line fitted over near-Clifford training circuits), vd (two copies), readout (the counts' flips inverted). Needs noise and observables (shots for readout), at most 8 qubits. The result's `mitigation` gives raw and mitigated values with standard errors, the ideal value (known because this is a simulation), the method's bias and variance assumptions and its cost. A method's name, or an object."
},
"programs": {
"type": "array",
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "object",
"required": [
"qasm"
]
}
]
},
"maxItems": 100,
"minItems": 1,
"description": "The set's programs: each a program's text, or a job ({\"qasm\", …}) whose own fields win over the set's."
},
"amplitudes": {
"type": "array",
"items": {
"type": "string"
},
"description": "Basis states to give amplitudes of: one character per qubit, qubit n-1 first, e.g. \"0011\"."
},
"observables": {
"type": "array",
"items": {
"type": "string"
},
"description": "Pauli strings to take expectation values of, e.g. [\"Z0\", \"Z0 Z1\", \"X2 Y3\"]. Qubits count from 0."
}
}
}