Transaction-Science/open-standards
Watch
1
0
Fork
You've already forked open-standards
 0
Code Issues Pull requests Projects Releases 17 Packages Wiki Activity Actions

wai-quantum: receipts say where their counts come from and what was set at the provider, and a second verifier checks them #660

Merged
dcharlot merged 24 commits from wai/quantum-receipt-fields into main 2026-11-06 14:45:15 -05:00
Conversation 0 Commits 24 Files changed 259 +27034 -955
259 changed files with 27034 additions and 955 deletions
Download patch file Download diff file Expand all files Collapse all files

21
.github/wai-conformance/verifiers/quantum-receipts.sh vendored Normal file
View file

@ -0,0 +1,21 @@
# step: quantum job receipts · receipt_verify.py
# order: 701
# paths: wai/extensions/quantum-providers.md
# working-directory: .
#
# Job receipts (wai.quantum.provider/1 section 8, wai/quantum-conformance/receipts/): the
# corpus's crafted half is what generate.py writes; receipt_verify.py, written in Python from
# section 8 alone and sharing no code with the engine (its BLAKE3, Ed25519, RFC 8785 text and
# strict reader its own, standard library only), passes its self-test against published
# answers and the number texts a JavaScript engine wrote, and gives every receipt of the
# corpus exactly the reasons the manifest gives; and each of its planted defects makes that
# fail. The reference's half of the differential, `wai-quantum verify` on every receipt and
# on every one-member change of each valid one, runs in wai-quantum-cli.yml beside the build
# of the binary. Run isolated (-I).
python3 -I wai/quantum-conformance/receipts/generate.py --check
python3 -I wai/quantum-conformance/receipts/generate.py --self-test
python3 -I wai/quantum-conformance/tools/receipt_verify.py --self-test wai/wai-quantum/src/engine/testdata/es-number-tostring.txt
python3 -I wai/quantum-conformance/tools/receipt_differential.py --second-only
for plant in lenient-key no-alg last-duplicate no-inexact measured-simulator whole-cap lax-small-order-r no-canonical-spelling set-seal-only names-layout-only; do
python3 -I wai/quantum-conformance/tools/receipt_differential.py --second-only --plant "$plant" | tail -1
done

48
.github/workflows/wai-quantum-cli.yml vendored
View file

@ -8,7 +8,10 @@ name: wai-quantum command line
# include the model harness (src/eval.rs): every task's reference solved and an
# empty program not, a scripted run, a model server on this machine asked and one
# elsewhere refused, and the corpus (wai/quantum-conformance/eval/) held to the
# task set.
# task set. And job receipts by two verifiers (wai/quantum-conformance/receipts/):
# `verify` and receipt_verify.py, written from the provider protocol's section 8
# alone, each held to the corpus's manifest and to the other on every receipt and
# every one-member change of each valid one, and each planted defect caught.
concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
@ -22,6 +25,11 @@ on:
- 'wai/wai-quantum-cli/**'
- 'wai/wai-quantum-qpu/**'
- 'wai/quantum-conformance/eval/**'
- 'wai/quantum-conformance/receipts/**'
- 'wai/quantum-conformance/tools/receipt_verify.py'
- 'wai/quantum-conformance/tools/receipt_differential.py'
- 'wai/quantum-conformance/tools/referee.py'
- 'wai/extensions/quantum-providers.md'
- 'rust-toolchain.toml'
- '.github/workflows/wai-quantum-cli.yml'
pull_request:
@ -30,6 +38,11 @@ on:
- 'wai/wai-quantum-cli/**'
- 'wai/wai-quantum-qpu/**'
- 'wai/quantum-conformance/eval/**'
- 'wai/quantum-conformance/receipts/**'
- 'wai/quantum-conformance/tools/receipt_verify.py'
- 'wai/quantum-conformance/tools/receipt_differential.py'
- 'wai/quantum-conformance/tools/referee.py'
- 'wai/extensions/quantum-providers.md'
- 'rust-toolchain.toml'
- '.github/workflows/wai-quantum-cli.yml'
@ -80,7 +93,13 @@ jobs:
# Your own providers end to end (tests/providers.rs), against the
# reference provider this binary serves, and their jobs as MCP
# tasks, each test by name.
for t in a_person_adds_tests_plans_and_runs_on_a_provider_and_the_receipt_verifies \
for t in json_output_does_not_skip_the_history_it_was_asked_to_check \
lines_judge_a_set_as_a_set \
the_mcp_tool_given_a_job_s_text_gives_the_corpus_s_verdict \
a_member_named_twice_is_unreadable_on_every_kind_of_job \
the_mcp_tool_gives_the_corpus_s_verdict_on_what_a_parsed_job_shows \
a_named_credential_that_is_empty_never_falls_to_the_account_s_keys \
a_person_adds_tests_plans_and_runs_on_a_provider_and_the_receipt_verifies \
a_run_that_is_not_free_is_refused_until_the_person_confirms_it \
a_credential_is_kept_in_a_file_only_its_owner_reads_and_appears_in_nothing_printed \
a_provider_over_http_runs_with_its_credential_in_the_header \
@ -110,6 +129,31 @@ jobs:
set -euo pipefail
cargo build --locked --release
bash smoke.sh ./target/release/wai-quantum
# Job receipts, judged by two verifiers that share no code: this binary's `verify`, and
# receipt_verify.py, written in Python from wai/extensions/quantum-providers.md section 8
# alone (standard library only, its BLAKE3 and Ed25519 its own). The corpus's crafted half
# is what generate.py writes; the second verifier's self-test holds its BLAKE3, Ed25519,
# RFC 8785 and number text to published answers. Then both verifiers and the manifest must
# agree on every receipt of the corpus, and the two verifiers on every receipt made from a
# valid one by changing one member, or by setting a number past a double's whole numbers.
# Each planted defect of the second verifier (a lenient key check, alg unchecked, the last
# of a duplicate member kept, inexact numbers let through, a simulator's counts let pass as
# measured, a ceiling on every whole number, R of small order let through, the canonical
# spelling of a large double refused, a set's seal checked and nothing of its items,
# qubit names held to the layouts only) must make the
# differential fail: the proof that it can. A plant that the corpus alone catches is caught
# by the second-only run too, in the independent verifiers' step.
- name: Job receipts, two verifiers
shell: bash
run: |
set -euo pipefail
python3 -I wai/quantum-conformance/receipts/generate.py --check
python3 -I wai/quantum-conformance/receipts/generate.py --self-test
python3 -I wai/quantum-conformance/tools/receipt_verify.py --self-test wai/wai-quantum/src/engine/testdata/es-number-tostring.txt
python3 -I wai/quantum-conformance/tools/receipt_differential.py --reference wai/wai-quantum-cli/target/release/wai-quantum
for plant in lenient-key no-alg last-duplicate no-inexact measured-simulator whole-cap lax-small-order-r no-canonical-spelling set-seal-only names-layout-only; do
python3 -I wai/quantum-conformance/tools/receipt_differential.py --reference wai/wai-quantum-cli/target/release/wai-quantum --plant "$plant" | tail -1
done
# The release binary, pinned by version and SHA-256, rather than a build from source.
# Every WAI workflow that runs wasmtime pins this one version, and every run passes
# -W nan-canonicalization=y -W relaxed-simd-deterministic=y: every NaN a float

6
.github/workflows/wai-quantum-contract.yml vendored
View file

@ -136,7 +136,11 @@ jobs:
set -euo pipefail
for pair in "wai-quantum $WAI_QUANTUM_BASELINE" "wai-quantum-cli $WAI_QUANTUM_CLI_BASELINE" "wai-quantum-qpu $WAI_QUANTUM_QPU_BASELINE"; do
set -- $pair
latest=$(cargo info "$1" 2>/dev/null | sed -n 's/^version: *\([^ ]*\).*/\1/p' | head -1 || true)
# `cargo info` names the version it would select and, when that is not the newest,
# the newest after it: `version: 0.4.0 (latest 0.4.1)`. The last published is the latter.
line=$(cargo info "$1" 2>/dev/null | sed -n 's/^version: *//p' | head -1 || true)
latest=$(printf '%s\n' "$line" | sed -n 's/.*(latest \([^)]*\)).*/\1/p')
[ -n "$latest" ] || latest=${line%% *}
if [ -z "$latest" ]; then
echo "::warning::crates.io did not say which version of $1 is the last; the check runs against $2"
elif [ "$latest" != "$2" ]; then

2
.github/workflows/wai-quantum-py.yml vendored
View file

@ -18,6 +18,7 @@ on:
push:
branches: [main]
paths:
- 'wai/quantum-conformance/receipts/**'
- 'wai/wai-quantum/**'
- 'wai/wai-quantum-py/**'
- 'wai/wai-quantum-cli/**'
@ -26,6 +27,7 @@ on:
- '.github/workflows/wai-quantum-py.yml'
pull_request:
paths:
- 'wai/quantum-conformance/receipts/**'
- 'wai/wai-quantum/**'
- 'wai/wai-quantum-py/**'
- 'wai/wai-quantum-cli/**'

27
.github/workflows/wai-quantum-qpu.yml vendored
View file

@ -79,9 +79,10 @@ jobs:
# tests never touch one but the macOS leg's own.
export WAI_QUANTUM_CREDENTIALS=file
cargo test --locked 2>&1 | tee "$RUNNER_TEMP/test.log"
# The library (46), the clients against their contracts (8), and the
# providers end to end (12), each binary's count pinned.
for n in 46 8 12; do
# The library (81, the cloud-tasks client's 26 among them), the clients
# against their contracts (15), and the providers end to end (12), each
# binary's count pinned.
for n in 81 15 12; do
grep -qE "^test result: ok\. $n passed; 0 failed" "$RUNNER_TEMP/test.log" || { echo "::error::a test binary did not pass all $n of its tests"; exit 1; }
done
for t in curl_carries_a_request_to_a_server_and_back every_operation_over_http every_operation_over_a_local_process \
@ -90,7 +91,25 @@ jobs:
a_credential_reaches_the_provider_and_nothing_a_run_returns \
job::tests::a_recorded_job_outlives_what_sent_it_and_seals_as_a_run_would job::tests::running_out_of_patience_does_not_cancel_the_job \
job::tests::nothing_is_sent_that_could_not_be_recorded_first job::tests::a_job_that_may_have_been_sent_is_never_sent_again \
ledger::tests::a_handle_cannot_reach_outside_the_records; do
ledger::tests::a_handle_cannot_reach_outside_the_records \
cloud_tasks::tests::the_signature_is_the_published_example cloud_tasks::tests::a_processor_gets_a_verbatim_box_on_its_own_qubit_names \
cloud_tasks::tests::a_submission_names_the_persons_own_bucket_and_never_carries_their_secret \
job::tests::what_a_provider_states_of_its_counts_is_sealed_and_a_statement_out_of_form_is_refused \
job::tests::a_job_recorded_before_clients_stated_what_they_sent_says_no_one_stated_it \
every_built_in_kind_states_what_it_sent_and_its_receipt_keeps_every_rule \
cloud_tasks::tests::temporary_keys_send_their_token_and_sign_it cloud_tasks::tests::the_look_for_a_secret_reads_a_request_s_body \
cloud_tasks::tests::a_program_on_a_qubit_past_the_sixty_fourth_is_read_back cloud_tasks::tests::a_dotted_bucket_is_read_by_path_where_its_host_has_no_certificate \
registry::tests::a_named_credential_that_gives_nothing_is_an_error_saying_where_it_looked \
registry::tests::every_part_of_kept_keys_is_taken_out_of_a_message_whole_or_cut_short \
sampler_v2::tests::a_simulated_backend_is_not_silicon \
a_job_recorded_by_the_last_release_is_sealed_with_a_receipt_this_one_accepts \
a_receipt_names_the_device_s_qubits_as_the_program_was_sent_on_them \
cloud_tasks::tests::signing_gives_the_published_test_suite_s_signatures \
cloud_tasks::tests::a_client_that_did_not_submit_a_task_does_not_read_it_through_today_s_device \
cloud_tasks::tests::a_task_is_asked_after_in_the_region_its_id_names \
registry::tests::a_kind_this_build_does_not_know_is_kept_and_the_rest_is_read \
a_cloud_task_cancelled_while_it_waits_ends_cancelled \
cloud_tasks_round_trip_through_their_contract a_job_collected_later_is_read_through_the_qubits_it_was_sent_on; do
grep -q "^test $t \.\.\. ok$" "$RUNNER_TEMP/test.log" || { echo "::error::$t did not run and pass"; exit 1; }
done
- name: Clippy

3
.github/workflows/wai-quantum-service.yml vendored
View file

@ -17,6 +17,7 @@ on:
push:
branches: [main]
paths:
- 'wai/quantum-conformance/receipts/**'
- 'wai/wai-quantum/**'
- 'wai/wai-quantum-service/**'
# The command line's agent docs list this service's tools from a snapshot
@ -26,6 +27,7 @@ on:
- '.github/workflows/wai-quantum-service.yml'
pull_request:
paths:
- 'wai/quantum-conformance/receipts/**'
- 'wai/wai-quantum/**'
- 'wai/wai-quantum-service/**'
# The command line's agent docs list this service's tools from a snapshot
@ -77,6 +79,7 @@ jobs:
set -euo pipefail
cargo test --locked --release 2>&1 | tee "$RUNNER_TEMP/test.log"
grep -qE '^test result: ok\. [1-9][0-9]* passed; 0 failed' "$RUNNER_TEMP/test.log" || { echo "::error::no test ran"; exit 1; }
grep -q '^test the_service_gives_every_receipt_the_verdict_the_corpus_gives_it \.\.\. ok$' "$RUNNER_TEMP/test.log" || { echo "::error::the service was not held to the corpus of receipts"; exit 1; }
cargo clippy --locked --release --all-targets -- -D warnings
# The engine's parts of the service, each required by name: sets and
# sweeps and their Merkle paths, a result's provenance, the package

3
.github/workflows/wai-quantum-studio.yml vendored
View file

@ -9,6 +9,8 @@ name: wai-quantum studio and desktop
# history kept across a reload; a device target's coupling map coloured by its
# errors, a run placed and simulated on it, and the layout drawn on the map;
# nothing scrolls sideways at a phone's width;
# - test/verify-text.test.mjs, without a browser: a receipt is checked on the text it
# came in, not an object written out again.
# - test/hardware.test.mjs, without a browser: "Your hardware" asks the person before
# a run that is not free, never before a free one, and sends nothing on a "no"; a job
# in the provider's queue is asked after by its id, Cancel cancels it there, "Wait in
@ -134,6 +136,7 @@ jobs:
npm ci --no-audit --no-fund
npx playwright install --with-deps chromium
node test/hardware.test.mjs
node test/verify-text.test.mjs
node test/service.test.mjs
node test/telemetry.test.mjs
node test/update.test.mjs

2
.github/workflows/wai-web-wasm.yml vendored
View file

@ -264,7 +264,7 @@ jobs:
run: |
set -euo pipefail
cargo test --locked --lib --features quantum_engine quantum_engine:: 2>&1 | tee "$RUNNER_TEMP/wai-web-engine.log"
grep -q "test result: ok. 29 passed; 0 failed" "$RUNNER_TEMP/wai-web-engine.log"
grep -q "test result: ok. 30 passed; 0 failed" "$RUNNER_TEMP/wai-web-engine.log"
# The crate's native unit tests, run on the host: the pure-Rust halves of the
# bindings, which wasm_tests does not run. They decode the committed integer
# payloads to their sidecars' SHA-256 (int_payload::tests) and check that the

91
wai/changes/2026-11-05-provider-receipts-state-counts-execution-second-verifier.md Normal file
View file

@ -0,0 +1,91 @@
### wai-quantum: a provider's receipt states where its counts come from, what was set at the provider, and a simulator's counts as simulated; and a second verifier, written from the text alone, checks every receipt
- **Where the counts come from** (`counts_source`, [extensions/quantum-providers.md](extensions/quantum-providers.md)
§8.3): `shots` (tallied from one record a shot), `vendor_counts` (the provider's own) or `probabilities`
(rebuilt by largest remainders: derived, not shot records). `native-turns` always rebuilds them;
`cloud-tasks` reads a task's rows and rebuilds only when its result has none; `sampler-v2` tallies shots;
`prx-circuits` takes the service's counts.
- **What was set at the provider** (`execution`, §8.3): each of mitigation, twirling, decoupling, remapping and
optimisation `off`, `on`, or `default` when the request sets nothing for it, whether the gates were to run
as written, and what the client sent (the body's members and the settings among them). Each built-in client
builds it from the very body it posts (`Provider::execution`), and a test holds every one to the body its
scripted service received: `sampler-v2` turns decoupling and twirling off, `native-turns` debiasing,
`cloud-tasks` puts a processor's gates in the service's verbatim box, and `prx-circuits` sends only
`circuits` and `shots`, so it sets nothing and says so. A provider of the open protocol may state both in its
`result` answer (§5.5); one that wraps another service must.
- **A simulator's counts are `simulated`, not `measured`.** The class follows the provider's provenance:
`measured` for `silicon`, `simulated` for a simulator or an emulator, with `approximate: true` when the
provider's `describe` says its simulator is approximate. The note no longer claims "no mitigation", which no
client turned off or recorded. A receipt sealed before (the earlier form) verifies as it did, and a verifier
reads its class by its provenance and says so, without claiming when it was sealed: nothing in it says. A receipt from a person's account names that account, so the
corpus holds none; the two `cloud-tasks` runs on a cloud service's simulator, sealed as `measured` on 5 November,
were checked by hand with the differential's `--extra`, and verify and read as simulated.
- **A job recorded by the last release, and collected by this one, gets a receipt this one accepts.** Its record has
its program, so its text is added, and no one stated what was sent, so its `execution` says `nobody`, which every
kind takes.
- **The receipt says which qubits.** `compiled.qasm3` is on the coupling map's indices, and `compiled.qubit_names`
gives the device's own name for each, as it was when the job was sent, where a client sends it under them
(`cloud-tasks`, `prx-circuits`).
- **`sampler-v2` reads a backend's `simulator`:** a simulated backend's counts are `simulated`, not `measured`.
- **The compiled program's text** is in the receipt (`compiled.qasm3`), beside its hash, so anyone can read
the program the device was sent and check the one against the other.
- **The receipt's text is §8 of the protocol**: what a provider's result carries, the seal byte for byte,
the strict reader, the canonical text and the first form's, the strict Ed25519 rules, the per-kind rows,
the seventeen reasons a verifier gives, and what a receipt proves. `wai_quantum::engine::job::check`
(and `check_text`, `check_bytes`) gives them, and every surface's `verify` goes through it: `POST /v1/verify` and
the service's tool, which until now checked the seal alone, the command line's tool, its `verify` on a set, an
estimate or an algorithm's answer, the Python package, the desktop app, the browser and `job::verify`. A surface
given a job's text reads it as text, so a member named twice is found. Each answers with `reasons` beside `valid`
and `key`, and each set item is held to the rules of a job.
- **What a host seals, its verifier accepts.** `qec` on the command line, the desktop, the browser and Python took a
seed of any size and sealed the double, and `verify` now refuses that text (`inexact_number`). A compile, a pulse,
an estimate, `@Seal` and a project's intent check took such a number too. Each now refuses the request where it reads
it, as a run has, and a whole number no double holds in a result is written as the double sealed
(`receipt::seal_into`). **A receipt already sealed with one stays refused** (only `qec`'s, given a seed past 2^53):
its signature holds, what it sealed is the double, and written as that double's digits it verifies.
`wai-quantum-qec` seeds past 2^53 − 1 are a refusal now, not a rounding. VERSIONING.md says so.
- **A whole double past 2^53 verifies as RFC 8785 writes it.** §8.2 promises that a result verifies after any JSON
reader and writer has carried it, and RFC 8785 (and JavaScript) write 2^60 as 1152921504606847000, its shortest
digits padded with zeros, which `inexact_number` refused. That spelling, the double's own, is now taken; every other
spelling of an inexact whole number is still refused. A host screens every number of a request it seals, as it
writes it and as RFC 8785 does, so it seals nothing its verifier refuses.
- **§8.6: a set's receipt.** A set (`wai.quantum.set/1`) is now part of §8: its receipt seals its request and its head;
each item that ran is a job of its own; its items are the ones its request gives; its root is the Merkle root of the
items' leaves, and each item's path leads to it. Three reasons: `set_items`, `set_item`, `set_root`. Every surface
judges a set by it, the second verifier included, and the corpus holds two sets the command line made and eleven
crafted to break one rule each. Python's text and path inputs and `verify --lines` read a genuine set as a plain job
and refused every one: they no longer do. A set's own request, its sweep's values among them, is screened as a run's.
An item is read for its `index`, `request`, `result`, `error` and `path`; the rest of it is the host's, unsealed.
An item's receipt names the set's key; a failed item writes no number its leaf (the canonical form's digest)
could not seal; an empty set, or an item that is itself a set, is refused.
- **A receipt is checked on its text.** The Studio, the desktop app and the npm package's example verified an object
written out again by JavaScript, which moves a member named by digits ahead of the others and rewrites a large whole
number, so a genuine first-form receipt failed. They pass the text they were given; an object is written out only
when it is all there is. The tools of the command line and the job service take a job's text (`job`), so they see
what parsing loses, and their tests hold them to the whole corpus, none skipped.
- **`compiled.qubit_names` names every qubit the text acts on**, each `$` and its digits in `qasm3`, not only those of
the layouts: routing can pass through a qubit in neither.
- **A whole number has no ceiling but a count's.** The reference capped every whole number at 2^53 − 1 where §8.4 caps
only a count's value, and read equal strings as different shots; §8.4 was right, and it follows it now, with sums
exact. The differential could not see this, since it changed a number only by adding to it: it now tries values past
a double's whole numbers, and shots in both request and result, and a plant that restores the ceiling proves it can.
- **`verify --json --history` checks the history**, as the text does, and `verify --json` on a set, an estimate or an
algorithm's answer gives JSON. `--history` on one of those is refused, rather than ignored.
- **The reference was too lenient, and is not now.** It accepted, as valid: a receipt under the identity as
its key, for any content (a library's default Ed25519 check takes a small-order key); `alg` other than
`ed25519`; `canon: null`, read as the first form; hex in upper case or with `+` (a second spelling of an
unsealed receipt); and a member named twice. A key with a two-byte character among its hex digits made
`wai-quantum verify` panic. It now refuses each, decodes keys and `R` canonically, refuses `S ≥ ℓ` itself
whatever the library's features, and keeps a first-form result's member order when it removes the receipt.
- **`wai-quantum verify --json`** gives a job's verdict as data (valid, the reasons, the key, the form, and
what a provider's result says of itself), and **`--lines`** judges one job a line. Its text names the
rules a receipt breaks and, for a provider's result, its class, its counts' source and its `execution`.
- **A second verifier** (`quantum-conformance/tools/receipt_verify.py`), written in Python from §8 alone by a
reader who had not seen the reference, standard library only (its BLAKE3, Ed25519, RFC 8785 text and strict
reader its own). Its readings of the text, gap by gap, became §8's sentences. A corpus
(`quantum-conformance/receipts/`): receipts made by the command line, the job service and every built-in
kind through a scripted service, the engine's fixtures, and receipts crafted to break one rule each, every
expectation written by hand. `receipt_differential.py` holds the two verifiers and the manifest to each
other on every receipt and on every one-member change of each valid one, and each defect planted in the
second verifier must be caught; CI runs it beside the build of the command line, and the second verifier
against the manifest among the independent verifiers.

65
wai/changes/2026-11-05-qpu-built-in-provider-kind-cloud-tasks.md Normal file
View file

@ -0,0 +1,65 @@
### wai-quantum-qpu: a built-in provider kind for a cloud service of quantum tasks
- **`cloud-tasks`** ([wai-quantum-qpu/src/cloud_tasks.rs](wai-quantum-qpu/src/cloud_tasks.rs), the fourth built-in
protocol and the sixth kind in [bring-your-own-quantum.md](wai-quantum-qpu/bring-your-own-quantum.md)). `wai-quantum
providers add NAME --kind cloud-tasks --set region=… --set device=… --set bucket=… --credential-stdin` connects one
device on the person's own account. Requests are signed with their keys (Signature Version 4), so the secret never
crosses the wire, and results land in their own storage bucket.
- **The program runs as compiled.** On a processor it is OpenQASM 3 in a verbatim box on physical qubits, with every
angle an exact multiple of pi. A device whose native gates are `rx rz cz` takes the `rzsxxcz` basis, with `sx` and `x`
written as `rx(pi/2)` and `rx(pi)`: they differ only by a global phase, which no count can see. A device whose native
gates fit no basis is refused, with what it runs in the message, rather than compiled by someone else.
- **On a processor the estimate is the whole charge; on a simulator, the least it can be.** The service's API states
only the device's price per shot. The estimate adds the service's fee per task (0.30 USD, from its price list of
2026-11-05) and says where each part comes from. A simulator is billed by the minute with a three-second minimum, and
how long a task takes is not known before it runs, so its estimate is that minimum: `Estimate::at_least`, and
`at_least: true` in a plan and a receipt, and every surface says "at least".
- **A job is read through the qubits it was sent on.** An index of the device's coupling map means what the device's
list said on the day, and that list can change while a job waits. `Provider::qubit_names` gives the device's own names
for a program's qubits, a job's record keeps them beside its program, and `Provider::counts_stated` reads through
them, without asking the device again. A client with no record of a job on a processor refuses rather than guess.
- **A paid result can be read.** A qubit past the sixty-fourth can be read back: logical qubits are read from the row by
label, with no packing into a 64-bit word. A qubit the program ended on that was not measured is an error, not a zero.
- **Nothing is sent to a name that is not one.** `region` and `bucket` go into hosts that get signed requests, so
`CloudTasks::new` refuses what could not be one, as `providers add` does. A bucket with a dot is legal, and is read by
path, since the storage service's certificate covers one label; results are read from the bucket the task names,
whatever the entry names by now. This kind reaches two hosts and takes no `--endpoint`: it refuses one rather than
listing an address it would not use.
- **A named credential that gives nothing is an error.** A built-in kind falls back to its environment variables only
when the entry names no credential, here and in the three older kinds. With one named and empty, it says where it
looked, and signs with nothing else.
- **Every part of the keys is taken out of a message.** `Target::with_secrets`, and `Secret::redact` removes what a cut
at a length leaves of a value too.
- **`wai-qpu probe` and `certify` ask for `--yes` wherever a job may spend:** on a processor, as `certify` did, and on
anything the service does not state is free (a price stated, or none). `probe` asked for nothing before.
- **A task is asked after where it is.** Its region is read from its id, and its results from the bucket it names, in
that region, whatever the provider's entry names by now. A client reads a processor's task through the qubits it
read only when it submitted that task itself; otherwise through the job's record, or not at all.
- **`providers test`** says "at least" of a simulator's minimum, in what it ran and in why it ran nothing.
- **Signing is held to the published test suite** (its v4 vectors): paths with spaces, UTF-8 and every unreserved
character, by the task service's rule and by storage's, and a request with a body. The fake service the client is
tested against reads the bucket from the host or, for a name with a dot, from the path; walks a task through
queued, running and completed, or cancelling and cancelled; and writes results in the published result schema's
form (gate-model task result v1: `measuredQubits` the device's qubit numbers, as integers).
- **`CloudTasks::with_endpoints` is `CloudTasks::with_base`**: a test server for the task service only. Results are
always read from the storage service's own hosts, as the bucket's name addresses them.
- **A list of providers holding a kind this build does not know** is read: that entry is left as it is, noted, kept
when the list is saved, and not used. **A list holding a `cloud-tasks` entry cannot be read by an earlier build**
(`wai-quantum-qpu` 0.4.1 and before, `wai-quantum-cli` 0.2.4 and before, and the desktop app built on them): they
refuse the whole file, every provider in it. That cannot be fixed in the releases already out; a person who shares
one list between versions keeps a `cloud-tasks` entry out of it until every one of them is this version or later.
- **A simulator can run a processor's gates.** `--set basis=gpizz` on one of the service's simulators compiles to that
basis, so the gates can be checked before paying for a processor. A processor refuses the setting.
- **`Method::Put`** and `Request::put` in the crate's transport, for cancelling a task.
- **The crate is 0.5.0, since its Rust API breaks** (`wai-quantum/VERSIONING.md`: before 1.0 a breaking change raises
the 0.y component). `registry::Kind` gains `CloudTasks`, before `Http` and `Process`, whose discriminants move; and
`transport::Method` gains `Put`. Both were exhaustive, so a `match` on either without a wildcard arm no longer
compiles, and a cast of `Kind::Http` or `Kind::Process` to a number gives another value. What to do instead:
- give a `match` on `Kind` or on `Method` a wildcard arm. Both are `#[non_exhaustive]` from this version: a kind and a
method are each a value of a list that grows, which a minor release may add to, and with the enums exhaustive every
new kind would have been a breaking release. Inside the crate a `match` stays exhaustive, so a kind added there
without its name, its settings and its client still fails to build;
- read `Kind::ALL` as a slice (`Kind::ALL.iter()`): it was an array, `[Kind; 5]`, whose type changed with every kind;
- name a kind by `Kind::name()` and read one with `Kind::parse`, never by its number.
`wai-quantum-cli` and the desktop app require 0.5.0. Neither's own API changes.

9
wai/changes/2026-11-05-studio-code-shown-in-one-step.md Normal file
View file

@ -0,0 +1,9 @@
### quantum-studio: a code's summary, certificate and lattice change in one step
- **The error-correction pane** ([quantum-studio/src/qec-view.js](quantum-studio/src/qec-view.js)) showed a newly chosen
code's summary and decoders while its seal was still being checked, over the lattice and the certificate of the code
chosen before; a qubit clicked in that moment was flipped in the new code. The seal is now checked first, and the
summary, the decoders, the certificate and the lattice change together, as a decode's already did. A threshold drew
its plot before the check and wrote its reading after; they change together too. The browser test read the lattice
as soon as the summary named the new code, and once saw the surface code's two faces where it expected the colour
code's nine; it is unchanged, and passes with the seal's check slowed, where it failed before.

475
wai/extensions/quantum-providers.md
View file

@ -44,8 +44,12 @@ person's credential and signing key (the command line, the desktop app).
3. **Exact programs.** A client compiles a circuit exactly to the device's
native gates and connectivity and checks the compiled program against the
circuit before sending it. Angles cross the wire exactly (§4).
4. **Measured, not recomputed.** A provider's counts are sealed as measured on
the device it names (§8). Nothing recomputes them.
4. **Returned, not recomputed.** A provider's counts are sealed as the device
it names returned them (§8): `measured` for a processor, `simulated` for a
simulator or an emulator, which no device measured. The result says where
the counts come from, since counts rebuilt from probabilities are derived
and not shot records, and what was set off at the provider. Nothing
recomputes them.
## 2. Transports
@ -166,7 +170,7 @@ No fields. The answer describes the device:
|---|---|
| `protocol` | `"wai.quantum.provider/1"` |
| `provider`, `device` | the provider's name for itself, and the device's |
| `provenance` | `silicon` (a processor), `emulator`, or `simulator`; with `simulator` (or `emulator`) a sentence naming what it is |
| `provenance` | `silicon` (a processor), `emulator`, or `simulator`; with `simulator` (or `emulator`) a sentence naming what it is, in the member of that name (`"simulator": "…"`) |
| `qubits` | the device's qubit count |
| `native_gates` | the gates it runs; a client compiles to the first of the bases of §4 whose every gate is listed |
| `connectivity` | `"all"`, or the pairs `[a, b]` a two-qubit gate may act on, in either order |
@ -175,6 +179,7 @@ No fields. The answer describes the device:
| `billing` | `{"free": true}`, or `{"unit", "price", "currency"}`: the billing unit (`shot`, `job`, `second`, …), the price of one as a decimal string (`"0.0003"`), and the currency or credit it is in; optionally `free_tier`, the free use offered and its limits, as the provider states them |
| `max_shots` | optional: the most shots a job may ask |
| `seeded` | optional: `true` when a job's `seed` makes its counts reproducible (a simulator) |
| `approximate` | optional, with `simulator` or `emulator`: `true` when its results are approximate (a truncated tensor network, a sampled Pauli path); a result is then labelled so (§8.1) |
A client MUST NOT take a device to be free unless `billing` says
`"free": true`, or an estimate says so (§5.2).
@ -221,9 +226,17 @@ Field: `job`. The answer, once the job is `done`:
| `calibration` | optional: the calibration snapshot the job ran under, when it is not the one `describe` names |
| `charged` | optional: `{"amount", "currency"}`, what the job cost |
| `energy` | optional: `{"kwh"}`, the provider's own figure for the job's energy |
| `counts_source` | optional: where the counts come from (§8.3): `shots` (tallied from one record a shot), `vendor_counts` (the device's or service's own counts), or `probabilities` (rebuilt from probabilities); an answer without it is read as `vendor_counts` |
| `execution` | optional: how the device ran the program (§8.3): each of `mitigation`, `twirling`, `decoupling`, `remapping` and `optimisation` as `off`, `on`, `none` (the device has no such step) or `unknown` (a step the provider cannot vouch for), `verbatim` (`true` when the gates ran as written, on the qubits named), and an optional `note` |
A `result` asked twice of the same job MUST give the same counts.
A provider that relays a job to another service (a wrapper around a service's
own interface) MUST give `execution`, from what it sets in its own request, and
MUST give `counts_source`, `probabilities` when it rebuilds counts from them.
Each is the provider's word, and sealed as such (§8.3). A client refuses a
`counts_source` or an `execution` not of the form above, and seals nothing.
### 5.6 `cancel`
Field: `job`. The answer's `status` is `cancelled`, or `done` for a job that
@ -279,40 +292,399 @@ that it can spend the person's money.
## 8. The receipt
The host seals each provider job as the job service seals its own: an Ed25519
signature, by the host's key, over the request as submitted and the result
as returned, each in its RFC 8785 canonical text, verified by the same
verifier. The result's `method` is `provider` and its accuracy class is
`measured`. It carries:
The host seals each provider job as the job service seals its own, and the
same verifier checks both: an Ed25519 signature, by the host's key, over the
request as submitted and the result as returned (§8.2). A job's body is an
object holding `request`, the job as it was asked, and `result`, which carries
its `receipt`. This section says what a provider's result carries (§8.1), how
it is sealed and read (§8.2), what its counts' source and its `execution` say
(§8.3), what a verifier checks and the reason it gives for each failure
(§8.4), and what the receipt proves (§8.5). A verifier of §8.2 and §8.4 checks
any job's receipt, a provider's or not.
- `provider`: the person's name for it, its kind, its protocol, the device,
its provenance, and the BLAKE3 hash of its `describe` answer;
- `calibration`: the calibration snapshot the job ran under;
- `compiled`: the basis, the BLAKE3 hash of the compiled program's OpenQASM 3
text, its gate and swap counts, its initial and final layout, the check it
passed before it was sent, and how it was placed (`placement`: with a
calibration read as a target, the target's hash, the layout's expected
success and the fewest-swaps layout's);
- `job`: the provider's job id and the status checks before it finished;
- `counts`, keyed by the program's classical bits (§6);
- `ideal`: the circuit's exact distribution set beside the counts (up to 22
qubits): the total variation distance, the Hellinger fidelity, and the
distance the shots alone would leave on average;
- `cost`: the estimate shown before submitting, what the provider says it
charged, and whether the person confirmed a run that was not free;
- `energy`: unmetered here, with the provider's own figure, labelled as its
own, when it gives one.
### 8.1 What a provider's result carries
What the receipt proves: that this result, with these counts, is what the
signer's host received for this request from the provider and device it
names, under the calibration snapshot named, for the compiled program whose
hash it carries; and that the host compiled that program exactly and checked
it against the circuit before sending it. What it does not prove: that the
device ran that program, or ran anything. The counts are the provider's word,
and they are not reproducible by recomputation: the same job run again gives
other counts. The `ideal` distance says how far they are from what the
circuit gives; a distance well above the sampling distance is the device's
error, or a program the device did not run as sent.
| member | |
|---|---|
| `method` | `provider` |
| `accuracy` | `class`: `measured` when the provider's `provenance` is `silicon`, `simulated` when it is a simulator's or an emulator's (no device measured those counts); `approximate`: `true`, only on a `simulated` result whose provider's `describe` says `approximate` (§5.1), and absent otherwise; `note`, a sentence |
| `provider` | `name` (the person's name for it, the request's `provider`), `kind` (`sampler-v2`, `prx-circuits`, `native-turns`, `cloud-tasks`, `http` or `process`), `protocol` (`wai.quantum.provider/1`, or a built-in client's own), `device`, `provenance` (`silicon`; or `simulator` or `emulator`, alone or followed by `:` and the sentence naming it), `qubits` (the device's), `basis` (§4), and `describe`, the BLAKE3 of the RFC 8785 text (§8.2) of the provider's `describe` answer (for a built-in kind, of the description its client makes of the device). `provenance` is `silicon` exactly, or its part before any `:` is `simulator` or `emulator` |
| `calibration` | the calibration snapshot the job ran under, as the provider names it, or `null` |
| `compiled` | the program sent: `basis`; `qasm3`, its OpenQASM 3 text, `$i` being index `i` of the coupling map the provider described; `qubit_names`, the device's own name for each index the program uses, where a client sends it under those names (a `cloud-tasks` processor's labels, each index itself on its simulator; a `prx-circuits` device's qubits), each as it was when the job was sent; `program`, the BLAKE3 of `qasm3`'s UTF-8 bytes; `hash`, a sentence saying so; `native_gates`, `two_qubit_gates` and `swaps`, its counts; `layout` and `final_layout`, for each logical qubit the index it starts and ends on; `checked`, the check it passed before it was sent; `placement`, how it was placed (with a calibration read as a target, the target's hash, the layout's expected success and the fewest-swaps layout's) |
| `job` | `id`, the provider's id for the job, and `polls`, the status checks before it finished |
| `counts` | keyed by the program's classical bits (§6), each outcome that occurred with its count, at least 1 (a host drops an outcome a provider counts 0); with `distinct_outcomes`, the outcomes that occurred, and `omitted_shots`, the shots of outcomes not listed (at most 65,536 outcomes are listed). Every provider result an engine has sealed carries these, the earlier form's included |
| `shots` | the shots: the request's, 1024 when it gives none |
| `counts_source` | where the counts come from (§8.3) |
| `execution` | how the device was asked to run the program (§8.3) |
| `ideal` | the circuit's exact distribution p set beside the counts' frequencies q (up to 22 qubits): `computed`, and when it is `true` `total_variation_distance` (½ Σ \|q − p\|), `hellinger_fidelity` ((Σ √(p·q))²), `sampling_tvd_expected` (½ Σ √(2p(1 − p)/(π·shots)), the distance the shots alone leave on average, by the normal approximation) and `ideal_outcomes`; when `false`, `why`. The host computes them, and no verifier can without the program's simulation |
| `cost` | `free`; `estimate`, the estimate shown before submitting (an object, with `unknown`, a sentence, when none was known); `charged`, what the provider says it charged (`{"amount", "currency"}`), or `null`; `confirmed`, `true` exactly when the run was not free: such a run ran only with the person's confirmation (§7), and a free run needs none and records none |
| `energy` | `unmetered`, saying why it is not metered here; and, when the provider gives one, its own figure `service_kwh`, labelled as its own by `service_kwh_is` |
| `engine`, `schema` | the engine that made the result (`{"name": "wai-quantum", "version"}`) and `wai.quantum.job-result/1` |
A result sealed before results carried `counts_source` and `execution` is of
the *earlier form*: it carries neither, its class is `measured` whatever ran
it, and some of the members above are missing. It verifies by §8.4's rules
for that form. A verifier reads its class by its provenance, and says so: a
simulator's counts sealed as `measured` are a simulator's.
A job's `id` is the provider's, sealed: some name the person's account (a
cloud account's number inside a task's identifier). Sharing a receipt shares
it.
### 8.2 How it is sealed, and how a job is read
**The seal.** The result's `receipt` is an object:
| member | |
|---|---|
| `alg` | `ed25519` |
| `canon` | `rfc8785`; absent on a receipt of the first form (below) |
| `key` | the signer's Ed25519 public key `A`, its 32 bytes as 64 hex digits |
| `digest` | the digest signed, 32 bytes as 64 hex digits |
| `signature` | the signature `R ‖ S`, 64 bytes as 128 hex digits |
Hex digits are lower case, `0`–`9` and `a`–`f`, and nothing else. The receipt
is not sealed, so each member has one spelling. Any other member of the
receipt is ignored.
The digest is BLAKE3 (32 bytes, the hash mode) of
d ‖ u64(|Q|) ‖ Q ‖ u64(|T|) ‖ T
where `d` is the 27 ASCII bytes `wai:quantum-service-receipt` and then the one
byte `0x02` (`0x01` for the first form); `Q` is the canonical text of `request`;
`T` is the canonical text of `result` with its `receipt` member removed; and
`u64(n)` is `n` as 8 bytes, big-endian. The signature is Ed25519 as RFC 8032
§5.1 defines it, with no context and not prehashed, over the 32 bytes of the
digest. Since the domain byte is inside the digest, a receipt of one form does
not verify as the other.
Only `request` and `result` are sealed. Whatever else a job's body holds (its
`status`, `id`, `method`, `why`, `estimate` and times) is the host's, and
unsealed: a verifier takes nothing from it, and its verdict does not change
with it.
**Reading.** A job is read from its text, strictly, before anything is
checked. The text is UTF-8 with no byte order mark, and one JSON value
(RFC 8259) with whitespace allowed around it. It is unreadable when:
- an object names a member twice (names compared after their escapes are read);
- a string holds a lone surrogate: a `\u` escape of a high surrogate not
followed at once by one of a low surrogate, or of a low surrogate alone;
- a string holds a control character (U+0000 to U+001F) not escaped;
- a number's magnitude is 2^1024 − 2^970 or more, which rounds to an infinite
double;
- arrays and objects nest deeper than 127, the outermost counted as the first.
A noncharacter (U+FDD0 to U+FDEF, and the last two code points of each plane)
is a character like any other. Each number is read as the nearest IEEE 754
double, ties to even; a number too small for any double other than zero reads
as zero. A whole number written as one (a literal with no fraction and no
exponent) in the request or the result that no double holds exactly says more
than the receipt seals, since the seal holds its double (§8.4,
`inexact_number`), unless it is the canonical text (below) of the double it
reads as. That one spelling is RFC 8785's for a whole double whose magnitude is
2^53 or more and under 10^21 (a negative one with its `-`), its shortest digits
padded with zeros (2^60 as
1152921504606847000), and what any JSON writer that follows RFC 8785 or
ECMAScript writes: it reads as the double that was sealed, and no other
spelling of an inexact whole number is taken. A canonical receipt seals every number as its double; a
first-form receipt seals a whole number written as one in its writer's integer
range by its digits, and every other number by its double (below), and only
what a receipt seals as a double is held to this.
**The canonical text** of a value is RFC 8785's:
- `true`, `false` and `null` as they are;
- a string between `"`s, with `"` and `\` escaped as `\"` and `\\`; U+0008,
U+0009, U+000A, U+000C and U+000D as `\b`, `\t`, `\n`, `\f` and `\r`; every
other character below U+0020 as `\u00` and two lower-case hex digits; and
every other character as its own UTF-8 bytes, unescaped (`/` and U+007F
included) and not normalised;
- a number as ECMAScript's Number::toString writes the double it reads as
(ECMA-262, 6.1.6.1.20): zero (also negative zero) as `0`; otherwise, with
`s` the fewest decimal digits `d1 … dk` that read back as the double (of
those, the nearest to it, a tie going to the even last digit) and `n` such
that the value is 0.`s` × 10^n: if k ≤ n ≤ 21, the digits and n − k zeros;
if 0 < n ≤ 21, the digits with a `.` after the first n; if −6 < n ≤ 0, `0.`,
−n zeros, and the digits; otherwise `d1`, then `.` and `d2 … dk` when k > 1,
then `e`, a sign (`+` or `-`), and |n − 1| in decimal; a negative number is
the same with `-` before it;
- an array as `[`, its values' texts joined by `,`, and `]`;
- an object as `{`, its members joined by `,`, each the name's text, `:` and
the value's text, in the order of their names compared as sequences of
UTF-16 code units (unsigned), and `}`;
- with no whitespace anywhere outside strings.
So a result verifies after any JSON reader and writer has carried it, even
one that writes `1.0` as `1` or orders members otherwise.
**The first form.** The first receipts, which name no `canon`, sealed the text
their signer's JSON writer wrote, not the canonical text, under the domain byte
`0x01`. A verifier reads `Q` and `T` as that writer did: the value's compact
text (no whitespace outside strings), its object members in the order the job
gives them (the result's `receipt` removed, the others kept in order), its
strings as in the canonical text, and its numbers so:
- a whole number written as one (no fraction, no exponent), without a `-` and
from 0 to 2^64 − 1, or with a `-` and from −2^63 to −1, is written as its
decimal digits, with its `-` (so `-0` is a double: `-0.0`);
- every other number is written from its double: `-0.0` for negative zero, and
`0.0` for zero; otherwise, with `s` = `d1 … dk` and `n` as above, if n ≥ k
and n ≤ 16, the digits, n − k zeros and `.0`; if 0 < n ≤ 16, the digits with
a `.` after the first n; if −5 < n ≤ 0, `0.`, −n zeros and the digits;
otherwise `d1`, then `.` and `d2 … dk` when k > 1, then `e`, a sign (`+`
or `-`), and |n − 1| in decimal (`1e+16`, `1e-7`); a negative number is the
same with `-` before it.
The first form was sealed from 2026-10-17 to 2026-10-20, every receipt by one
writer, whose text these rules restate.
A first-form receipt verifies only as its signer wrote it: reordered members
break it, and so can a number written another way. No host writes the first
form now. A `canon` other than `rfc8785` (`null` among them) names no form.
**The signature, strictly.** RFC 8032 leaves some choices open, and two
verifiers that chose differently would disagree on the same receipt. A
verifier here:
- decodes `A` and `R` as RFC 8032 §5.1.3 does, and refuses an encoding whose y
(its low 255 bits, little-endian) is p = 2^255 − 19 or more, one that is not
on the curve, and one with x = 0 and the sign bit set;
- refuses `A` of small order (a point P with [8]P the identity) and `A` not in
the prime-order subgroup ([ℓ]A not the identity, ℓ = 2^252 +
27742317777372353535851937790883648493);
- refuses `R` of small order, and `S` (little-endian) of ℓ or more;
- accepts exactly when [S]B = R + [k]A, with k = SHA-512(R ‖ A ‖ the 32
digest bytes) read little-endian, mod ℓ, compared as points with no cofactor
(and so as their canonical encodings).
Without the rules on `A`, the identity as `A`, any `S` and `R` = [S]B hold
for every digest: a receipt for any content at all. A library's default check
also takes the identity as `R` with `S` = 0.
### 8.3 Where the counts come from, and how the device was asked to run them
**`counts_source`** is one of:
| value | the counts are |
|---|---|
| `shots` | tallied from the device's records, one a shot |
| `vendor_counts` | the provider's own counts, as it returned them |
| `probabilities` | rebuilt from the probabilities the device gave: each `p·shots` rounded down, then the shots left given one each to the largest remainders, a tie to the lower outcome. They are derived, and not shot records |
Who did so is read from `provider.kind`. On a built-in kind the host's client
did, and it is the host's word. On `http` and `process` the host received counts
and did neither, and it is the provider's word for how it made them (§5.5): the
rule for rebuilding them is the one the provider says it kept, which the host
cannot vouch for.
**`execution`** says what the host knows of the five steps a provider may
take between receiving a program and running it: `mitigation` (correcting
counts after the run, readout correction or debiasing), `twirling` (of gates
or of measurements), `decoupling` (dynamical decoupling of idle qubits),
`remapping` (moving the program to other qubits) and `optimisation`
(rewriting its gates). It is an object of:
| member | |
|---|---|
| `stated_by` | `client`, the host's client from the request it sends; `provider`, the provider in its `result` answer (§5.5); or `nobody` |
| the five steps | each `off` or `on` (by a setting the client sent, or as the provider states), `default` (said by a client: its request sets nothing for it, so the provider's default stands, whatever it is), `none` (said by a provider: its device has no such step), or `unknown` (when nobody states it, or a provider cannot vouch for the step) |
| `verbatim` | `true` when the request asks for the gates to run as written, on the qubits named (a verbatim box); `false` when it does not; `null` when nobody states it |
| `sent` | with `client` only: `fields`, the members of the request's body, each once, in increasing order of their UTF-8 bytes; and `settings`, an object of what the request sets: JSON Pointers (RFC 6901) into the body, each with the value it holds there, and names for settings the body holds otherwise (`verbatim_box`); and nothing else |
| `note` | optional: a sentence |
and nothing else. Its rules: with `stated_by` `client`, each step is `off`,
`on` or `default`, `verbatim` is `true` or `false`, and `sent` is given; with
`provider`, each step is `off`, `on`, `none` or `unknown`, `verbatim` is
`true` or `false`, and there is no `sent`; with `nobody`, each step is
`unknown`, `verbatim` is `null` and there is no `sent`. Each key of
`sent.settings` either begins with `/`, and its first reference token (up to
the next `/`, its `~1` and `~0` read as `/` and `~`) is one of `fields`, the
rest of it not read; or is a name, not empty, that does not begin with `/`. A program run as written is
neither remapped nor optimised, so with `verbatim` `true`, `remapping` and
`optimisation` are each `off` or `none`. A client that says a step is `off` or
`on` says by which setting: `settings` is then not empty.
**What each built-in kind records.** A client builds its `execution` from the
very body it sends, so that what is stated is what was sent, and its counts'
source from what the service answered. These are their rows. A later client
that sends something else adds a row; a row is never removed, so every
receipt keeps verifying. A kind of the open protocol (`http`, `process`)
records the provider's word (`provider`), or `nobody` when it says nothing. On
any kind, a job recorded before its client stated what it sent, and collected
since, is stated by `nobody`: nothing else is known of what was sent.
| kind | `counts_source` | `sent.fields` | `sent.settings` | steps | `verbatim` |
|---|---|---|---|---|---|
| `sampler-v2` | `shots` | `backend`, `params`, `program_id` | `/params/options/dynamical_decoupling/enable`: `false`, `/params/options/twirling/enable_gates`: `false`, `/params/options/twirling/enable_measure`: `false` | `decoupling` and `twirling` `off`; the other three `default` | `false` |
| `prx-circuits` | `vendor_counts` | `circuits`, `shots` | none: the client sends nothing else | all five `default` | `false` |
| `native-turns` | `probabilities`: the service answers probabilities, so its counts are always rebuilt | `backend`, `input`, `settings`, `shots`, `type`; and `noise`, on its simulator under a device's noise model | `/input/gateset`: `native`, `/settings/error_mitigation/debiasing`: `false`; and `/noise/model`: the model's name, with `noise` | `mitigation` `off`; the other four `default` | `false` |
| `cloud-tasks`, on a processor (`silicon`) | `shots`, from the task's rows; `probabilities`, when its result holds none | `action`, `clientToken`, `deviceArn`, `outputS3Bucket`, `outputS3KeyPrefix`, `shots` | `verbatim_box`: `true`, the program's gates in the service's verbatim box on physical qubits | `remapping` and `optimisation` `off`; the other three `default` | `true` |
| `cloud-tasks`, on a simulator | as on a processor | as on a processor | none | all five `default` | `false` |
A row is the `execution` its kind states, less its `note`: `stated_by` is
`client`, and every member is as the row gives it. A row holds for its
provenance: `cloud-tasks`' first row for `silicon`, its second for any other
(a simulator or an emulator); `native-turns`' row with `noise` for any
provenance but `silicon`, its model's name a string, not empty, and its row
without `noise` for any. `prx-circuits` sends only
`circuits` and `shots`, so it turns nothing off, and says so. No row says a
provider runs a program as sent where its client sets nothing that asks it to.
### 8.4 What a verifier checks
A verifier reads the job (§8.2) and reports every reason below that applies,
as a set: none for a valid receipt. It is valid exactly when there is none.
| reason | when |
|---|---|
| `unreadable` | the text breaks a rule of reading (§8.2). Reported alone |
| `not_a_job` | the value is not an object whose `request` and `result` are both objects. Reported alone |
| `no_receipt` | the result has no `receipt`. Reported alone |
| `receipt_form` | the receipt is not an object; its `alg` is not `ed25519`; it has a `canon` other than `rfc8785`; or its `key`, `digest` or `signature` is not lower-case hex of its length. When it is reported, the next three are not checked |
| `digest_mismatch` | the digest the receipt states is not the digest (§8.2) of this request and result |
| `bad_key` | `key` is refused by the strict rules (§8.2). When it is reported, the signature is not checked |
| `bad_signature` | the signature does not hold, strictly (§8.2), over the digest the receipt states (so a body changed after it was sealed gives `digest_mismatch` alone) |
| `inexact_number` | a whole number written as one, in what the receipt seals (the request, and the result less its receipt; for a set, the request and its head, §8.6) and sealed as a double (§8.2), is not a double, and is not the canonical text of the double it reads as. A receipt is of the first form when `receipt_form` is not reported and it has no `canon`; one that `receipt_form` refuses names no form, and its numbers are read as a canonical receipt's |
| `provider_class` | a provider's result whose `accuracy.class` is not the one its form gives: `measured` in the earlier form; in the stated form, `measured` for `silicon` and `simulated` for a provenance whose part before any `:` is `simulator` or `emulator` (none for any other); or whose `accuracy.approximate` is present and not `true`, or `true` in the earlier form or on a class other than `simulated`. Or a result of another method whose class is `measured` or `simulated` |
| `request_provider` | a provider's result whose `provider.name` is not a string equal to the request's `provider` |
| `request_shots` | a provider's result whose `shots` is not the request's (1024 when the request gives none, or `null`) |
| `counts` | a provider's result whose `counts` is not an object of outcomes, all of one length and each of `0` and `1` only, to whole numbers from 1 to 2^53 − 1; or whose `shots` (a whole number of at least 1), `omitted_shots` and `distinct_outcomes` (whole numbers of at least 0) are missing; or whose counts and `omitted_shots` do not sum to `shots`; or whose `distinct_outcomes` is not the number of outcomes listed when `omitted_shots` is 0; or, when it is not 0, lists other than 65,536 outcomes, or no more distinct outcomes than it lists |
| `provider_members` | a stated provider's result (below) without, or with a wrong type of: `provider`'s `name`, `kind`, `protocol` and `device` (each a string not empty), `provenance` (as `provider_class` reads it), `describe` (64 lower-case hex digits), `qubits` (a whole number of at least 1) and `basis` (equal to `compiled.basis`); `calibration` (a string or `null`); `compiled`'s `basis` (`rzsxxcz`, `prxcz` or `gpizz`), `program` (64 lower-case hex digits), `qasm3` (a string), `native_gates`, `two_qubit_gates` and `swaps` (whole numbers of at least 0), `layout` and `final_layout` (arrays of whole numbers of at least 0) and `checked` (a string); `compiled.qubit_names`, where it is given or required, is below; `job`'s `id` (a string not empty) and `polls` (a whole number of at least 0); `ideal.computed` (`true` or `false`); `cost`'s `free` and `confirmed` (each `true` or `false`), `estimate` (an object) and `charged` (`null`, or an object whose `amount` and `currency` are strings); `energy.unmetered` (a string), and `energy.service_kwh_is` (a string) when there is `energy.service_kwh`; `schema` (`wai.quantum.job-result/1`); `engine.name` (`wai-quantum`) and `engine.version` (a string) |
| `counts_source` | a stated provider's result whose `counts_source` is not one of §8.3's values, or, for a kind with rows, not one the rows that hold for its provenance give |
| `execution` | a stated provider's result whose `execution` breaks a rule of §8.3; or, for a kind with rows, is neither one of the rows that hold for its provenance nor stated by `nobody`; or, for `http` and `process`, is not stated by `provider` or `nobody` |
| `compiled_program` | a stated provider's result whose `compiled.program` is not the BLAKE3 of `compiled.qasm3`'s UTF-8 bytes, when `qasm3` is a string and `program` is 64 lower-case hex digits |
| `cost_confirmation` | a stated provider's result whose `cost.confirmed` is `true` on a free run or `false` on one that is not free (§7), when both are `true` or `false` |
A provider's result is one whose `method` is `provider`. It is *stated* when it
carries a member `counts_source` or a member `execution` (whatever their
values), and of the earlier form when it carries neither; the earlier form is
held to `provider_class`, `request_provider`, `request_shots` and `counts`
only. A whole number is any number whose value is whole, however it is
written (`1`, `1.0`, `1e0`), however large; only a count's value has a ceiling,
and a sum is exact, not a double's. A number's value, in every rule here and on
every form of receipt, is its nearest double (§8.2): the digits of a first-form
receipt are for what it sealed, and for nothing checked here. `-0` is 0.
"The request's" is by value: two equal strings are the same, and that a string
is no number is another rule's to say.
A class a verifier does not know is not a reason: a later version may add one
(VERSIONING.md).
`compiled.qubit_names` is required of a stated result of `cloud-tasks` or
`prx-circuits` whose `execution` is stated by `client`, and optional otherwise.
When given (`null` is given, and is no object) it is an object: each key an index
in decimal, with no leading zero; each value a string, not empty; the value of
every entry of `layout` and `final_layout`, written in decimal in full, is among
its keys; and so is every index `qasm3` acts on, when `qasm3` is a string: each
`$` anywhere in it followed by one or more of the ASCII digits 0 to 9 names the
index those digits read as, written in decimal with no leading zero (a `$`
followed by no such digit names none). Otherwise it is a `provider_members` reason.
**What a host seals, its own verifier accepts.** A host refuses a request holding
a whole number past ±(2^53 − 1), or any number that it or RFC 8785 would write in
a spelling this section refuses, where it reads it, on every path to a seal (a
set's own request, its sweep's values among them, included); and it writes a
whole number no double holds in a result as the double it seals. A receipt an
earlier release sealed with such a number is refused with `inexact_number`,
though its signature holds: what it sealed is the double, and its text says
more. Written as that double's exact digits, or as its canonical text, it
verifies. The local hosts' `qec` took a seed of any size; their compile, pulse,
estimate and `@Seal` took any number in a request; and a set took any number in
its own request and its sweep's values. The job service refused such a number
in every request but a set's own.
A verifier also states, for a provider's result (one with no receipt
included), its class as its provenance reads it, and, in the stated form, its
counts' source and its `execution`, each as the result gives it.
These are all the rules: what §8.1 names and this table does not check
(`compiled.hash` and `placement`, the notes, the `ideal` figures, the
estimate's contents) is the host's word, unchecked. The schemas
(`wai.quantum.job-result/1`, `wai.quantum.receipt/2`) describe what a host
writes; a verifier judges by this section.
### 8.5 What the receipt proves, and what it does not
A valid receipt proves that the holder of the key it names signed this
request and this result, nothing else and nothing less: every member of
both, the counts, `counts_source` and `execution` among them. It does not
say whose key it is. The job service publishes its keys and their windows
(`GET /.well-known/wai-quantum-receipt-keys`); a host's key is the person's
own, and anyone relying on a receipt decides whether they trust it. Nothing
sealed carries a time: a receipt can be shown again, and no window can be
applied to it from its bytes. For the same reason a host can still seal a
result of the earlier form, stating neither its counts' source nor its
`execution`; a verifier then holds it to the earlier form's rules, reads its
class by its provenance, and says that it states neither. A host can likewise
seal a stated result with `execution` stated by `nobody` on any kind, meant for
a job recorded before its client said what it sent: that says nothing of what
was sent, and a verifier says that nobody stated it.
Everything the result says the host received, sent and checked is the host's
own word, signed: that this was the provider's answer, under the calibration
snapshot named, and that the host compiled the program whose text and hash it
carries exactly and checked it against the circuit before sending it. The
compiled program's text is in the receipt, with the device's names for its
qubits where its client uses them, so anyone can read which gates were sent to
which qubits and check its hash. It is not the bytes sent: a client writes the
same gates in what its service takes. `execution` says what the request
asked of the provider. What it does not prove: that the device ran that
program, or ran anything. The counts are the provider's word, and they are
not reproducible by recomputation: the same job run again gives other counts.
A provider's simulator's counts say what its software gives, which is why
they are `simulated`, not `measured`. The `ideal` distance says how far the
counts are from what the circuit gives; a distance well above the sampling
distance is the device's or the simulator's error, or a program not run as
sent.
### 8.6 A set's receipt
A set is one request that runs many jobs (`programs`, a list of programs or
jobs, or `sweep`, values for the inputs of the request's own `qasm`); its result
has `"format": "wai.quantum.set/1"`. Its `head` is its result less `items` and
`receipt`. The set's receipt seals the set's request and its head, by §8.2, as a
job's seals its request and result; each item that ran carries a result with a
receipt of its own, over its own request. A verifier reads a set as it reads a
job (§8.2), and reports, beside §8.4's reasons for the set's request and head
(`unreadable`, `not_a_job`, `no_receipt`, `receipt_form`, `digest_mismatch`,
`bad_key`, `bad_signature`, `inexact_number`; the provider rules do not apply to
a head), each of these that applies:
| reason | when |
|---|---|
| `set_items` | `items` is not a non-empty array whose `i`-th entry is an object with `index` equal to `i` (a whole number), `request` an object, exactly one of the members `result` (an object) and `error` (a string) present (a member that is present is so whatever its value, `null` included), and `path` an array of strings each of 64 lower-case hex digits. When it is reported so, the next two are not checked. Or: `count` is not the number of items; or the items are not the ones the request gives. With `programs` (an array, and no `sweep`), item `i`'s request is the request less `programs`, `sweep` and `dry_run`, with program `i` over it: a string as `qasm`, or an object's members, each replacing one of the same name. With `sweep` (an object, and no `programs`), each of its values is a non-empty array, the items are as many as the product of their lengths, and each item's request less `qasm` is the request less `programs`, `sweep`, `dry_run` and `qasm`, its `qasm` a string (the request's program written out at its point, which §8 does not check: below). A request with neither, or with both, gives no items; a member that is `null` is none. Requests are compared as JSON values: members in any order, numbers by value |
| `set_item` | an item with a `result` is not a valid job: `{"request": its request, "result": its result}`, read as §8.2 reads a job, gives any reason of §8.4; or its result is a set's (`format` `wai.quantum.set/1`: an item is one job); or its receipt is valid and names a `key` other than the set's receipt's `key` member as it stands (one the set's receipt does not have included). Or an item with an `error` has a request that writes a whole number its leaf could not seal: as `inexact_number` reads one in a canonical receipt, whatever the set's form, since a leaf is the canonical form's digest |
| `set_root` | `root` is not 64 lower-case hex digits, or not the Merkle root of the items' leaves; or an item's `path` does not lead from its leaf to `root` |
An item's leaf is the digest (§8.2, the canonical form's) of its request and its
result less its `receipt`, or, for an item with an `error`, of its request and
`{"error": the error}`. The Merkle tree: a leaf's hash is BLAKE3 of
`moq-jwp:merkle-leaf` and the byte `0x01`, then the leaf; a node's is BLAKE3 of
`moq-jwp:merkle-node` and the byte `0x01`, then the left hash and the right; a
level of odd length pairs its last hash with itself; the root of one leaf is its
hash. A path lists the sibling at each level from the leaf up: with `n` items it
has as many entries as halvings (rounding up) take `n` to 1, and a path of any
other length does not lead to the root; at each level the item's position,
halved at each step, says whether the sibling is on the right (an even position)
or the left. This is the tree the WAI worlds' and provenance receipts use, its
domains theirs, kept so that every set already sealed verifies. Two things
follow from it. The root alone does not fix the number of items (a last leaf
paired with itself gives the root a level of one more would), and `count`,
sealed in the head, does; one item shown with its path and the head alone is
placed by `count`. And the root does not say whether an item failed: an item
with an `error` and one whose result is `{"error": …}` have one leaf, and only
the item's own receipt tells them apart.
An item is read for its `index`, `request`, `result`, `error` and `path`; what
else it holds (its `status`, `method`, `why`, a sweep's `point`) is the host's,
unsealed, as a job body's members beyond its request and result are, and a
member its own receipt holds beyond its five is ignored, as a job's is.
The engine also writes each item of a sweep out again at its point, and says
whether each `qasm` is that program (`derived`, beside the reasons); that is the
engine's check of the set, not a rule of its receipt, and a verifier that does
not write programs out does not make it.
## 9. Conformance
@ -339,7 +711,31 @@ The reference provider (`wai-quantum providers reference --stdio`, or
`--http ADDR`) is this protocol around WAI's exact simulator. It is the
provider the tests run against over both transports, and the template to
copy: a provider for any device is the reference with its simulation replaced
by the device.
by the device. It states its counts' source and its `execution` (§5.5).
**Receipts.** `quantum-conformance/receipts/` holds job receipts and what a
verifier must say of each (§8.4): receipts made by the command line on this
machine and by the job service, provider jobs of every built-in kind through
services that follow their contracts, the earlier form, the first (receipts the
first form's own writer sealed, and others `generate.py` made from §8.2's text),
and receipts sealed to break one rule each. A
receipt from a person's account names that account, and is not published: it is
checked with the differential's `--extra`, outside CI. A receipt once made is
kept, pinned by its digest. Two verifiers judge every one of them, and every
receipt made from a valid one by changing one member, numbers among them to
values past a double's range of whole numbers: `wai-quantum verify`, and
`quantum-conformance/tools/receipt_verify.py`, written from §8 alone in another
language and sharing no code with the engine. They must report the same reasons
for every receipt, and the manifest's for each in the corpus. Every other
surface that verifies is held to the manifest by its own tests, given each
receipt's text: the job service over HTTP and as a tool, the command line's tool
(each takes the job's text), the Python package (text, bytes or a path), the
desktop app and a browser tab. A surface given a job already parsed into objects
(a tool's `request` and `result`, a Python dict) cannot see what parsing loses:
a member named twice (`unreadable`), and a whole number past what its reader
keeps (`inexact_number`). It reports every other reason, and is held to the
manifest on every receipt but those. A tool's text is a JSON string, which holds
UTF-8 only, so text that is not UTF-8 reaches a verifier only as a file's bytes.
## 10. Versioning
@ -347,3 +743,10 @@ by the device.
string; a provider that speaks only this one answers `unsupported_version` to
another. Fields marked optional may be added to answers without a new
version, and a client MUST ignore fields it does not know.
A result's receipt seals every member it holds, so a member a later text adds
to the result is in no receipt sealed before it, and every such receipt
verifies as it did (§8.4's earlier form). `counts_source`, `execution`,
`compiled.qasm3`, the class `simulated` and `accuracy.approximate` were added
so, as were the answers' `counts_source` and `execution` and `describe`'s
`approximate`.

7
wai/quantum-conformance/README.md
View file

@ -25,6 +25,13 @@ and jeff), each with the program it must read to, its round trip and its
refusals, and OpenQASM written to each, are `formats/`, with a README of its
own.
Job receipts, as the provider protocol's §8 states them (the seal, its strict
reader and signature, and the rules of a provider's result), are `receipts/`, with
a README of its own: receipts the command line, the job service and every built-in
provider kind made, and receipts crafted to break one rule each, judged by
`wai-quantum verify` and by a second verifier written from §8 alone
(`tools/receipt_verify.py`), held to each other by `tools/receipt_differential.py`.
An entry with no `capability` is a `wai.quantum.circuit` vector. The trees are the
one reference all three surfaces are checked against, rather than being checked
against each other.

82
wai/quantum-conformance/receipts/README.md Normal file
View file

@ -0,0 +1,82 @@
# Job receipts
A job's receipt, as [the provider protocol's §8](../../extensions/quantum-providers.md#8-the-receipt)
states it, judged by two verifiers that share no code. Each must give every receipt here
exactly the reasons the manifest names (§8.4): none for a valid one.
| file | what |
|---|---|
| `manifest.json` | every receipt in `jobs/`, the reasons a verifier must give it, how it was made, and what it is. Every expectation is written by hand from §8.4; none is copied from a verifier's output |
| `jobs/cli-*.json` | made by the command line on this machine, sealed with the published demo key (`make.sh`): runs by several methods, a compile, and runs on the reference provider over a local process, free and priced |
| `jobs/service-*.json` | made by the free job service, sealed with its key (`make.sh`) |
| `jobs/scripted-*.json` | provider jobs of every built-in kind (`sampler-v2`, `prx-circuits`, `native-turns` with and without a noise model, `cloud-tasks` on a processor and on its simulator, with rows of shots and with probabilities), each through a service that follows that provider's published contract, sealed with the demo key (`wai-quantum-qpu/tests/clients.rs`, `every_built_in_kind_states_what_it_sent_and_its_receipt_keeps_every_rule`, with `WAI_QUANTUM_RECEIPT_CORPUS` set to this directory) |
| `jobs/first-form-*.json` | sealed by the job service as it was on 18 October 2026 (commit 72d18742d), so by the first form's own writer, not by a restatement of it |
| `jobs/fixture-*.json` | the engine's pinned fixtures, sealed by earlier engines: a run before results named their engine, a provider job of the earlier form, and a compile |
| `jobs/crafted-*.json` | made by `generate.py` from the receipts above, each changed one way: the seal's form, the strict signature (a weak-key forgery, `S + ℓ`, a mixed-order key, …), the first form, what any JSON reader and writer may do (and so must change nothing), the strict reader, and each rule of a provider's result, each sealed again with the demo key where the change is inside the seal so that one rule alone breaks |
The made receipts are kept as they were made, each pinned by its digest in `made.lock.json`:
a receipt missing or changed fails `generate.py --check`. A receipt made again differs in its
times (and, from the service, perhaps its key) and verifies all the same, so none is made again
to pass a test. A row of §8.3 that a client stops writing is held by the receipt that has it.
## The two verifiers
- `wai-quantum verify --json FILE` (and `--lines FILE`, one job a line): the reference,
`wai_quantum::engine::job::check`.
- [`../tools/receipt_verify.py`](../tools/receipt_verify.py): written in Python from §8
alone, by a reader who had not seen the reference. Standard library only: its BLAKE3,
Ed25519, RFC 8785 text and strict reader are its own, each held to published answers by
`--self-test`.
[`../tools/receipt_differential.py`](../tools/receipt_differential.py) holds them to each
other:
```sh
python3 -I receipts/generate.py --check # the crafted half is as written
python3 -I tools/receipt_verify.py --self-test ../wai-quantum/src/engine/testdata/es-number-tostring.txt
python3 -I tools/receipt_differential.py --reference PATH/wai-quantum
python3 -I tools/receipt_differential.py --reference PATH/wai-quantum --plant lenient-key
python3 -I tools/receipt_differential.py --second-only # no build: the second verifier and the manifest
```
The differential requires, for every receipt here, that both verifiers and the manifest name
the same reasons, and that both verifiers state the same key, form, class read by provenance
and counts' source. Then it changes every valid receipt one member at a time (each member of
its request, its result, its receipt and its unsealed envelope, removed, and its value
replaced) and requires the same reasons from both for every change, and two oracles beside
them: a change inside the request, the result or the receipt is never valid, and a change to
the unsealed envelope, or a member added to the receipt, never changes the verdict.
It also changes each number of the provider receipts to values past a double's whole numbers,
and sets a job's shots in both its request and its result, to see a limit one verifier has and
the other does not; and it seals those of the demo key again, so that each is judged by what it
says and not only by its digest.
`--plant NAME` runs the second verifier with a defect planted in it: a lenient key check,
`alg` unchecked, the last of a member named twice kept, inexact numbers let through, a
simulator's counts let pass as measured, a ceiling on every whole number, `R` of small order
let through. The differential succeeds only when it catches the plant. That is the proof that
it can fail.
`--extra DIR` adds receipts a person holds and does not publish: both verifiers must find each
valid. A receipt from a cloud account's task names that account's number in its job id, and
the receipt seals it, so the corpus holds none: the shape of such a receipt is here
(`scripted-cloud-tasks-*`), and real ones are checked with `--extra`.
CI runs the whole differential beside the build of the command line
(`.github/workflows/wai-quantum-cli.yml`, job `cli-linux`), and the second verifier against
the manifest, with its plants, among the independent verifiers
(`.github/wai-conformance/verifiers/quantum-receipts.sh`).
## Making it again
```sh
bash receipts/make.sh PATH/wai-quantum receipts/jobs # the command line's and the service's
(cd ../wai-quantum-qpu && WAI_QUANTUM_RECEIPT_CORPUS=$PWD/../quantum-conformance/receipts/jobs \
cargo test --test clients every_built_in_kind) # the built-in kinds'
python3 -I receipts/generate.py # the crafted half and the manifest
```
Making them again replaces receipts a release already judged, and `--check` then fails: add
receipts under new names, and keep the ones there. A new name is added to `MADE` in
`generate.py`; `generate.py --pin NAME` records its digest, and refuses a name it holds.

885
wai/quantum-conformance/receipts/generate.py Normal file
View file

@ -0,0 +1,885 @@
#!/usr/bin/env python3
"""generate.py: the crafted half of the receipt corpus (README.md).
python3 -I generate.py # writes jobs/crafted-*.json and manifest.json
python3 -I generate.py --check # fails unless both are what it would write
The corpus has two halves. The made half (`jobs/cli-*`, `jobs/service-*`,
`jobs/scripted-*`, `jobs/fixture-*`) was sealed by the command line, the job
service, the provider clients and earlier engines, and is kept as it was made:
nothing here writes it. The crafted half is made here from the made half, each
receipt changed in one way and, where the change is inside what is sealed,
sealed again with the published demo key (seed 42 repeated, the key
`wai-quantum --demo-key` signs with), so that the one rule it breaks is the
only thing wrong with it. The manifest names, for every receipt in both halves,
the reasons a verifier must give (wai/extensions/quantum-providers.md
section 8.4), each written here by hand from that section: none is copied from
a verifier's output.
To seal, it needs BLAKE3, the RFC 8785 text and Ed25519 signing. BLAKE3 is the
integer-only referee's (../tools/referee.py, which shares no code with the
engine); the other two are written below. Neither verifier is imported: the
two verifiers judge what this writes, and must agree with each other and with
the manifest.
Standard library only, Python 3.9+.
"""
import copy
import hashlib
import importlib.util
import json
import os
import struct
import sys
from decimal import Decimal
HERE = os.path.dirname(os.path.abspath(__file__))
JOBS = os.path.join(HERE, "jobs")
sys.dont_write_bytecode = True
_spec = importlib.util.spec_from_file_location("referee", os.path.join(HERE, "..", "tools", "referee.py"))
_referee = importlib.util.module_from_spec(_spec)
_spec.loader.exec_module(_referee)
blake3 = _referee.blake3
# ------------------------------------------------------------------ JSON text
class Raw(object):
"""A number written as this literal, whatever value it stands for."""
def __init__(self, literal, value):
self.literal, self.value = literal, value
def es_number(x):
"""ECMAScript's Number::toString of the double x (section 8.2)."""
x = float(x)
if x == 0:
return "0"
sign = "-" if x < 0 else ""
t = Decimal(repr(abs(x))).as_tuple()
digits = "".join(map(str, t.digits)).rstrip("0") or "0"
k = len(digits)
n = len("".join(map(str, t.digits))) + t.exponent
if k <= n <= 21:
body = digits + "0" * (n - k)
elif 0 < n <= 21:
body = digits[:n] + "." + digits[n:]
elif -6 < n <= 0:
body = "0." + "0" * (-n) + digits
else:
e = n - 1
body = digits[0] + ("." + digits[1:] if k > 1 else "") + "e" + ("+" if e >= 0 else "-") + str(abs(e))
return sign + body
def first_number(v):
"""A number as the first form's writer wrote it (section 8.2)."""
if isinstance(v, bool):
raise TypeError
if isinstance(v, int) and (0 <= v < 2 ** 64 or -2 ** 63 <= v < 0):
return str(v)
x = float(v)
if x == 0:
return "-0.0" if str(x).startswith("-") else "0.0"
sign = "-" if x < 0 else ""
t = Decimal(repr(abs(x))).as_tuple()
digits = "".join(map(str, t.digits)).rstrip("0") or "0"
k = len(digits)
n = len("".join(map(str, t.digits))) + t.exponent
if k <= n <= 16:
body = digits + "0" * (n - k) + ".0"
elif 0 < n <= 16:
body = digits[:n] + "." + digits[n:]
elif -5 < n <= 0:
body = "0." + "0" * (-n) + digits
else:
e = n - 1
body = digits[0] + ("." + digits[1:] if k > 1 else "") + "e" + ("-" if e < 0 else "+") + str(abs(e))
return sign + body
_SHORT = {'"': '\\"', "\\": "\\\\", "\b": "\\b", "\t": "\\t", "\n": "\\n", "\f": "\\f", "\r": "\\r"}
def string_text(s):
out = ['"']
for c in s:
if c in _SHORT:
out.append(_SHORT[c])
elif ord(c) < 0x20:
out.append("\\u%04x" % ord(c))
else:
out.append(c)
out.append('"')
return "".join(out)
def utf16(s):
return s.encode("utf-16-be")
def text(v, form="canonical"):
"""The canonical text of v, or its first-form text (members in order)."""
if v is None:
return "null"
if v is True:
return "true"
if v is False:
return "false"
if isinstance(v, Raw):
return text(v.value, form)
if isinstance(v, (int, float)):
return es_number(v) if form == "canonical" else first_number(v)
if isinstance(v, str):
return string_text(v)
if isinstance(v, list):
return "[" + ",".join(text(x, form) for x in v) + "]"
keys = sorted(v, key=utf16) if form == "canonical" else list(v)
return "{" + ",".join(string_text(k) + ":" + text(v[k], form) for k in keys) + "}"
def dump(v, indent=0):
"""A readable file's text of v: two-space indents, Raw literals as given."""
pad, inner = " " * indent, " " * (indent + 1)
if isinstance(v, Raw):
return v.literal
if isinstance(v, dict):
if not v:
return "{}"
return "{\n" + ",\n".join(inner + json.dumps(k, ensure_ascii=False) + ": " + dump(x, indent + 1) for k, x in v.items()) + "\n" + pad + "}"
if isinstance(v, list):
if not v:
return "[]"
return "[\n" + ",\n".join(inner + dump(x, indent + 1) for x in v) + "\n" + pad + "]"
if isinstance(v, float) and v == 0 and str(v).startswith("-"):
return "-0.0"
return json.dumps(v, ensure_ascii=False)
# ---------------------------------------------------------------- Ed25519 (RFC 8032)
P = 2 ** 255 - 19
L = 2 ** 252 + 27742317777372353535851937790883648493
D = -121665 * pow(121666, P - 2, P) % P
SQRT_M1 = pow(2, (P - 1) // 4, P)
def _add(a, b):
x1, y1, z1, t1 = a
x2, y2, z2, t2 = b
A, B = (y1 - x1) * (y2 - x2) % P, (y1 + x1) * (y2 + x2) % P
C, E = t1 * 2 * D * t2 % P, z1 * 2 * z2 % P
e, f, g, h = B - A, E - C, E + C, B + A
return (e * f % P, g * h % P, f * g % P, e * h % P)
def _mul(s, pt):
q = (0, 1, 1, 0)
while s:
if s & 1:
q = _add(q, pt)
pt = _add(pt, pt)
s >>= 1
return q
def _encode(pt):
x, y, z, _ = pt
zi = pow(z, P - 2, P)
x, y = x * zi % P, y * zi % P
return (y | ((x & 1) << 255)).to_bytes(32, "little")
def _decode(b):
y = int.from_bytes(b, "little") & ((1 << 255) - 1)
sign = b[31] >> 7
if y >= P:
return None
xx = (y * y - 1) * pow(D * y * y + 1, P - 2, P) % P
x = pow(xx, (P + 3) // 8, P)
if (x * x - xx) % P:
x = x * SQRT_M1 % P
if (x * x - xx) % P:
return None
if x == 0 and sign:
return None
if x & 1 != sign:
x = P - x
return (x, y, 1, x * y % P)
BASE = _decode((4 * pow(5, P - 2, P) % P).to_bytes(32, "little"))
def public_key(seed):
h = hashlib.sha512(seed).digest()
a = int.from_bytes(h[:32], "little")
a = (a & ((1 << 254) - 8)) | (1 << 254)
return _encode(_mul(a, BASE))
def sign(seed, msg):
h = hashlib.sha512(seed).digest()
a = int.from_bytes(h[:32], "little")
a = (a & ((1 << 254) - 8)) | (1 << 254)
A = _encode(_mul(a, BASE))
r = int.from_bytes(hashlib.sha512(h[32:] + msg).digest(), "little") % L
R = _encode(_mul(r, BASE))
k = int.from_bytes(hashlib.sha512(R + A + msg).digest(), "little") % L
return R + ((r + k * a) % L).to_bytes(32, "little")
DEMO = bytes([42] * 32)
OTHER = bytes([43] * 32)
IDENTITY = bytes([1] + [0] * 31)
# A point of order 8.
ORDER8 = bytes.fromhex("c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac037a")
# --------------------------------------------------------------------- sealing
DOMAIN = b"wai:quantum-service-receipt"
def digest(request, result, form="canonical"):
q = text(request, form).encode("utf-8")
t = text({k: v for k, v in result.items() if k != "receipt"}, form).encode("utf-8")
return blake3(DOMAIN + bytes([2 if form == "canonical" else 1]) + struct.pack(">Q", len(q)) + q + struct.pack(">Q", len(t)) + t)
def seal(body, seed=DEMO, form="canonical"):
"""body with its result sealed again by seed's key, in form."""
d = digest(body["request"], body["result"], form)
receipt = {"alg": "ed25519", "canon": "rfc8785", "key": public_key(seed).hex(), "digest": d.hex(), "signature": sign(seed, d).hex()}
if form != "canonical":
del receipt["canon"]
out = copy.deepcopy(body)
out["result"] = {k: v for k, v in out["result"].items() if k != "receipt"}
out["result"]["receipt"] = receipt
return out
MERKLE_LEAF = b"moq-jwp:merkle-leaf\x01"
MERKLE_NODE = b"moq-jwp:merkle-node\x01"
def merkle_levels(leaves):
"""Each level of the tree over leaves (section 8.6), the leaves' hashes first."""
level = [blake3(MERKLE_LEAF + x) for x in leaves]
levels = [level]
while len(level) > 1:
if len(level) % 2:
level = level + [level[-1]]
levels[-1] = level
level = [blake3(MERKLE_NODE + level[i] + level[i + 1]) for i in range(0, len(level), 2)]
levels.append(level)
return levels
def set_leaf(item):
"""An item's leaf (section 8.6): the digest of its request and its result, or its error."""
if "result" in item:
return digest(item["request"], item["result"])
return digest(item["request"], {"error": item["error"]})
def seal_set(body, seed=DEMO):
"""A set with its root and paths made from its items, and its receipt over
its request and its head, sealed again."""
out = copy.deepcopy(body)
r = out["result"]
levels = merkle_levels([set_leaf(it) for it in r["items"]])
r["root"] = levels[-1][0].hex()
for i, it in enumerate(r["items"]):
path, at = [], i
for level in levels[:-1]:
path.append(level[at ^ 1].hex())
at //= 2
it["path"] = path
head = {k: v for k, v in r.items() if k not in ("items", "receipt")}
d = digest(out["request"], head)
r["receipt"] = {"alg": "ed25519", "canon": "rfc8785", "key": public_key(seed).hex(), "digest": d.hex(), "signature": sign(seed, d).hex()}
return out
def edited(body, edit, form="canonical"):
"""body changed by edit (which may change request, result or both), sealed again."""
b = copy.deepcopy(body)
edit(b)
return seal(b, form=form)
def rx(body, edit):
"""body with only its receipt changed by edit: nothing sealed again."""
b = copy.deepcopy(body)
edit(b["result"]["receipt"])
return b
def load(name):
with open(os.path.join(JOBS, name), encoding="utf-8") as f:
return json.load(f)
# --------------------------------------------------------------------- the cases
def edited_set(body, edit):
"""A set's result changed by edit, nothing sealed again."""
b = copy.deepcopy(body)
edit(b["result"])
return b
def edited_set_head(body, edit):
"""A set's head changed by edit and the set's receipt sealed again over it,
its root and paths left as they are."""
b = copy.deepcopy(body)
edit(b["result"])
head = {k: v for k, v in b["result"].items() if k not in ("items", "receipt")}
d = digest(b["request"], head)
b["result"]["receipt"] = {"alg": "ed25519", "canon": "rfc8785", "key": public_key(DEMO).hex(), "digest": d.hex(), "signature": sign(DEMO, d).hex()}
return b
def cases():
"""(file name, the text, the reasons, what it is), every crafted receipt."""
run = load("cli-run-observables.json")
prov = load("cli-provider-reference.json")
legacy = load("fixture-provider-job-legacy.json")
sampler = load("scripted-sampler-v2.json")
prx = load("scripted-prx-circuits.json")
turns = load("scripted-native-turns.json")
sim = load("scripted-cloud-tasks-simulator.json")
qpu = load("scripted-cloud-tasks-processor.json")
progs = load("cli-set-programs.json")
sweep = load("cli-set-sweep.json")
out = []
def add(name, body_or_text, reasons, what):
t = body_or_text if isinstance(body_or_text, (str, bytes)) else dump(body_or_text) + "\n"
out.append(("crafted-" + name + ".json", t, sorted(reasons), what))
# --- the seal's form (section 8.2): one spelling of each member
add("seal-alg-other", rx(run, lambda r: r.update(alg="rsa-pss")), ["receipt_form"], "an alg other than ed25519")
add("seal-canon-null", rx(run, lambda r: r.update(canon=None)), ["receipt_form"], "canon present and null: no form")
add("seal-canon-other", rx(run, lambda r: r.update(canon="jcs")), ["receipt_form"], "canon naming no form")
add("seal-key-upper", rx(run, lambda r: r.update(key=r["key"].upper())), ["receipt_form"], "the key in upper-case hex: a second spelling of one key")
def plus(r):
d = r["digest"]
i = next(i for i in range(0, 64, 2) if d[i] == "0")
r["digest"] = d[:i] + "+" + d[i + 1:]
if any(run["result"]["receipt"]["digest"][i] == "0" for i in range(0, 64, 2)):
add("seal-digest-plus", rx(run, plus), ["receipt_form"], "a + where a hex digit belongs, which a lenient hex reader takes")
add("seal-key-two-byte-char", rx(run, lambda r: r.update(key="aé" + r["key"][3:])), ["receipt_form"], "a two-byte character among the key's hex digits")
add("seal-signature-short", rx(run, lambda r: r.update(signature=r["signature"][:-2])), ["receipt_form"], "a signature one byte short")
add("seal-key-missing", rx(run, lambda r: r.pop("key")), ["receipt_form"], "no key")
b = copy.deepcopy(run)
b["result"]["receipt"] = "VALID"
add("seal-receipt-string", b, ["receipt_form"], "a receipt that is not an object")
# --- the signature, strictly
forged = copy.deepcopy(run)
forged["result"]["expectations"][0]["value"] = -1.0
d = digest(forged["request"], forged["result"])
forged["result"]["receipt"] = {"alg": "ed25519", "canon": "rfc8785", "key": IDENTITY.hex(), "digest": d.hex(), "signature": (IDENTITY + bytes(32)).hex()}
add("seal-weak-key-forgery", forged, ["bad_key"], "the identity as the key and as R, S = 0: a library's lenient check takes it for any digest, so any content verifies")
any_digest = copy.deepcopy(forged)
B = _encode(BASE)
any_digest["result"]["receipt"]["signature"] = (B + (1).to_bytes(32, "little")).hex()
add("seal-weak-key-any-digest", any_digest, ["bad_key"], "the identity as the key, R = [1]B, S = 1: [S]B = R + [k]A for every digest, R of full order")
alias = bytes([0xEE] + [0xFF] * 30 + [0x7F])
add("seal-key-noncanonical", rx(run, lambda r: r.update(key=alias.hex())), ["bad_key"], "a key whose y is p + 1: the identity, spelt a second way")
y = 2
while _decode(y.to_bytes(32, "little")) is not None:
y += 1
add("seal-key-off-curve", rx(run, lambda r: r.update(key=y.to_bytes(32, "little").hex())), ["bad_key"], "a key that is no point on the curve")
mixed = _encode(_add(_decode(public_key(DEMO)), _decode(ORDER8)))
add("seal-key-mixed-order", rx(run, lambda r: r.update(key=mixed.hex())), ["bad_key"], "the demo key plus a point of order 8: not of small order, outside the prime-order subgroup")
def s_plus_l(r):
sig = bytes.fromhex(r["signature"])
s = int.from_bytes(sig[32:], "little") + L
r["signature"] = (sig[:32] + s.to_bytes(32, "little")).hex()
add("seal-s-plus-l", rx(run, s_plus_l), ["bad_signature"], "S + l: a second spelling of the same signature")
# S made for this R by the holder of the key, so that [S]B = R + [k]A holds:
# only the rule on R can refuse it. a is the key's scalar; R is the identity
# (spelt one way or the other), so [S]B = [k]A is S = k·a.
def equation_holds(r_bytes):
def edit(r):
h = hashlib.sha512(DEMO).digest()
a = int.from_bytes(h[:32], "little")
a &= (1 << 254) - 8
a |= 1 << 254
k = int.from_bytes(hashlib.sha512(r_bytes + bytes.fromhex(r["key"]) + bytes.fromhex(r["digest"])).digest(), "little") % L
r["signature"] = (r_bytes + ((k * a) % L).to_bytes(32, "little")).hex()
return edit
add("seal-r-noncanonical", rx(run, equation_holds(alias)), ["bad_signature"], "R spelt with y of p or more")
add("seal-r-small-order", rx(run, equation_holds(IDENTITY)), ["bad_signature"], "R the identity, S made so that the equation holds: a lax check takes it")
add("seal-signature-other-key", rx(run, lambda r: r.update(signature=sign(OTHER, bytes.fromhex(r["digest"])).hex())), ["bad_signature"], "a signature by another key")
stale = copy.deepcopy(run)
stale["result"]["expectations"][0]["value"] = 0.5
add("seal-digest-stale", stale, ["digest_mismatch"], "the result changed after it was sealed: the digest alone")
add("seal-digest-other", rx(run, lambda r: r.update(digest=blake3(b"another job").hex())), ["bad_signature", "digest_mismatch"], "a digest of something else, the signature over the first")
# --- the first form
first = seal(run, form="first")
add("form-first", first, [], "a receipt of the first form, sealed over the compact text in the document's order")
exps = copy.deepcopy(run)
exps["result"]["x"] = [1e16, 1.5e300, 1e-7, 2.5e-6, 1e15, 0.00001]
add("form-first-exponents", seal(exps, form="first"), [], "a first-form receipt with numbers its writer wrote with an exponent, signed both ways (1e+16, 1e-7)")
big_first = copy.deepcopy(run)
big_first["request"]["seed"] = 2 ** 53 + 1
add("form-first-big-integer", seal(big_first, form="first"), [], "a first-form receipt sealing 2^53 + 1 by its digits, as its writer wrote it: not inexact")
past = copy.deepcopy(run)
past["request"]["seed"] = Raw("18446744073709551617", float(2 ** 64))
add("form-first-past-its-integers", seal(past, form="first"), ["inexact_number"], "a first-form receipt with 2^64 + 1 written: past the integers its writer kept by their digits, it sealed the double 2^64")
past["request"]["seed"] = Raw("18446744073709551616", float(2 ** 64))
add("form-first-past-its-integers-exact", seal(past, form="first"), [], "the same with 2^64 written, which the double holds")
unformed = rx(seal(big_first, form="first"), lambda r: r.update(alg="rsa-pss"))
unformed["request"]["seed"] = Raw("9007199254740993", 2 ** 53 + 1)
add("form-none-inexact", unformed, ["inexact_number", "receipt_form"], "a receipt with no canon and another alg names no form, so it is not of the first form, and 2^53 + 1 is inexact")
add("form-first-relabelled", rx(first, lambda r: r.update(canon="rfc8785")), ["digest_mismatch"], "a first-form receipt relabelled as canonical")
add("form-canonical-relabelled", rx(run, lambda r: r.pop("canon")), ["digest_mismatch"], "a canonical receipt relabelled as the first form")
reordered = copy.deepcopy(first)
keys = list(reordered["result"])
reordered["result"] = {k: reordered["result"][k] for k in reversed(keys[:-1])}
reordered["result"]["receipt"] = first["result"]["receipt"]
add("form-first-reordered", reordered, ["digest_mismatch"], "a first-form receipt with its result's members reordered")
respelt = copy.deepcopy(first)
respelt["result"]["expectations"][0]["value"] = Raw("1", 1)
add("form-first-respelt", respelt, ["digest_mismatch"], "a first-form receipt with 1.0 written 1, which its writer wrote 1.0")
# --- the canonical text: what any reader and writer may do changes nothing
spelt = copy.deepcopy(run)
spelt["request"] = dict(reversed(list(spelt["request"].items())))
spelt["request"]["shots"] = Raw("1.0e3", 1000)
spelt["result"]["expectations"][0]["value"] = Raw("1", 1)
t = dump(spelt) + "\n"
t = t.replace('"OPENQASM', '"\\u004fPENQASM', 1).replace('"qubits"', '"\\u0071ubits"', 1)
add("canon-respelt", t, [], "members reordered, numbers written otherwise (1.0e3, 1), names and strings with escapes")
strings = {"request": {"qasm": "OPENQASM 3.0;", "\U0001F600": "a key above the BMP", "": "sorts after it in UTF-16", "z": "tab\tnewline\ncontrol\u0001 slash/ del\u007f sep
 nonchar￿ quote\" backslash\\"},
"result": {"method": "statevector", "accuracy": {"class": "exact"}}}
add("canon-strings", seal(strings), [], "strings and names that RFC 8785 writes its own way: UTF-16 order, escapes, characters left as they are")
numbers = {"request": {"qasm": "OPENQASM 3.0;"},
"result": {"method": "statevector", "accuracy": {"class": "exact"},
"x": [1e21, 1e-7, 1e-6, 0.1 + 0.2, 5e-324, 1.7976931348623157e308, -0.0, 123456789012345680000.0, 2 ** 53, 2 ** 64, 0, -1, 1e300, 4.35, 0.000001234]}}
sealed = seal(numbers)
sealed["result"]["x"][1] = Raw("0.0000001", 1e-7)
sealed["result"]["x"][9] = Raw("18446744073709551616", 2 ** 64)
add("canon-numbers", sealed, [], "numbers at the edges of ECMAScript's layout, and 2^64, a whole number a double holds")
tiny = seal({"request": {"qasm": "OPENQASM 3.0;"}, "result": {"method": "statevector", "accuracy": {"class": "exact"}, "x": 0}})
tiny["result"]["x"] = Raw("1e-400", 0)
add("canon-underflow", tiny, [], "1e-400 reads as zero, as sealed")
near = seal({"request": {"qasm": "OPENQASM 3.0;"}, "result": {"method": "statevector", "accuracy": {"class": "exact"}, "x": 1.7976931348623157e308}})
near["result"]["x"] = Raw("1.7976931348623158e308", 1.7976931348623157e308)
add("canon-near-max", near, [], "a number just below the limit, which rounds to the largest double")
inexact = seal({"request": {"qasm": "OPENQASM 3.0;"}, "result": {"method": "statevector", "accuracy": {"class": "exact"}, "x": 2 ** 53}})
inexact["result"]["x"] = Raw("9007199254740993", 2 ** 53)
add("number-inexact", inexact, ["inexact_number"], "2^53 + 1 written, 2^53 sealed: the text says more than the seal")
big = seal({"request": {"qasm": "OPENQASM 3.0;", "seed": 2 ** 64}, "result": {"method": "statevector", "accuracy": {"class": "exact"}}})
big["request"]["seed"] = Raw("18446744073709551617", 2 ** 64)
add("number-inexact-unsealed", rx(run, lambda r: r.update(x=Raw("9007199254740993", 2 ** 53 + 1))), [], "2^53 + 1 in a member of the receipt, which nothing seals and a verifier ignores")
add("number-inexact-past-u64", big, ["inexact_number"], "2^64 + 1 in the request, 2^64 sealed")
# --- reading (section 8.2), each a text
base = dump(run) + "\n"
add("read-duplicate", base.replace('"qubits": ', '"qubits": 7,\n "qubits": ', 1), ["unreadable"], "a member of the result named twice")
add("read-duplicate-unsealed", base.replace('"status": "done"', '"status": "failed",\n "status": "done"', 1), ["unreadable"], "a member of the unsealed envelope named twice: still unreadable")
add("read-duplicate-escaped", base.replace('"qubits": ', '"qubit\\u0073": 7,\n "qubits": ', 1), ["unreadable"], "two names that are one once their escapes are read")
add("read-lone-surrogate", base.replace('"OPENQASM', '"\\ud800OPENQASM', 1), ["unreadable"], "an escaped high surrogate with no low one")
add("read-lone-low-surrogate", base.replace('"OPENQASM', '"\\udc00OPENQASM', 1), ["unreadable"], "an escaped low surrogate alone")
add("read-byte-order-mark", "" + base, ["unreadable"], "a byte order mark")
add("read-raw-control", base.replace('"OPENQASM', '"\tOPENQASM', 1), ["unreadable"], "a tab not escaped inside a string")
add("read-number-overflow", base.replace('"status": "done"', '"status": "done",\n "x": 1e400', 1), ["unreadable"], "a number no double reaches, in the unsealed envelope")
limit = "179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792"
add("read-number-at-limit", base.replace('"status": "done"', '"status": "done",\n "x": ' + limit, 1), ["unreadable"], "2^1024 - 2^970 exactly, which rounds to infinity")
deep = {"request": {"qasm": "OPENQASM 3.0;", "nest": []}, "result": {"method": "statevector", "accuracy": {"class": "exact"}}}
n = deep["request"]["nest"]
for _ in range(124):
n.append([])
n = n[0]
add("read-depth-127", seal(deep), [], "arrays and objects 127 deep, the most a reader takes")
n.append([])
add("read-depth-128", seal(deep), ["unreadable"], "128 deep")
add("read-trailing", base + "{}\n", ["unreadable"], "a second value after the first")
add("read-not-json", "signature VALID\n", ["unreadable"], "not JSON")
add("read-not-utf8", base.encode("utf-8").replace(b"OPENQASM", b"\xffPENQASM", 1), ["unreadable"], "a byte that is not UTF-8")
add("job-array", "[]\n", ["not_a_job"], "a value that is not an object")
b = copy.deepcopy(run)
del b["request"]
add("job-no-request", b, ["not_a_job"], "no request")
b = copy.deepcopy(run)
b["request"] = "OPENQASM 3.0;"
add("job-request-string", b, ["not_a_job"], "a request that is not an object")
b = copy.deepcopy(run)
del b["result"]["receipt"]
add("job-no-receipt", b, ["no_receipt"], "a result with no receipt")
b = copy.deepcopy(run)
b.update(status="failed", method="a different method", why="anything at all", id="j-another")
add("envelope-changed", b, [], "the unsealed envelope changed: nothing a verifier takes")
# --- a provider's result (section 8.4), each sealed again so one rule breaks
def at(path, value):
def f(b):
o = b
for k in path[:-1]:
o = o[k]
o[path[-1]] = value
return f
def drop(path):
def f(b):
o = b
for k in path[:-1]:
o = o[k]
del o[path[-1]]
return f
R = ("result",)
add("provider-measured-simulator", edited(prov, at(R + ("accuracy", "class"), "measured")), ["provider_class"], "a simulator's stated result labelled measured")
add("provider-approximate-false", edited(prov, at(R + ("accuracy", "approximate"), False)), ["provider_class"], "approximate given and not true")
def silicon_approximate(b):
b["result"]["provider"]["provenance"] = "silicon"
b["result"]["accuracy"]["class"] = "measured"
b["result"]["accuracy"]["approximate"] = True
add("provider-approximate-processor", edited(prov, silicon_approximate), ["provider_class"], "a processor's counts labelled approximate")
add("provider-provenance-unknown", edited(prov, at(R + ("provider", "provenance"), "fpga")), ["provider_class", "provider_members"], "a provenance that is none of silicon, simulator or emulator")
add("provider-approximate-simulator", edited(prov, at(R + ("accuracy", "approximate"), True)), [], "a simulator's result its provider states is approximate")
add("provider-request-provider", edited(prov, at(("request", "provider"), "another")), ["request_provider"], "the request names another provider")
add("provider-request-shots", edited(prov, at(("request", "shots"), 301)), ["request_shots"], "the request asks for other shots")
add("provider-request-shots-default", edited(prov, drop(("request", "shots"))), ["request_shots"], "the request gives no shots (1024), the result others")
def recount(f):
def g(b):
f(b["result"])
return g
add("provider-counts-sum", edited(prov, recount(lambda r: r["counts"].update({k: v + 1 for k, v in list(r["counts"].items())[:1]}))), ["counts"], "counts that do not sum to the shots")
def wider(r):
k, v = next(iter(r["counts"].items()))
del r["counts"][k]
r["counts"]["0" + k] = v
add("provider-counts-width", edited(prov, recount(wider)), ["counts"], "outcomes of two lengths")
add("provider-counts-zero", edited(prov, recount(lambda r: r["counts"].update({"01": 0}))), ["counts"], "an outcome listed with a count of 0")
def hidden(r):
k, v = next(iter(r["counts"].items()))
r["counts"][k] = 1
r["omitted_shots"] = v - 1
# Section 8.4: only a count's value has a ceiling, and a sum is exact.
add("provider-whole-past-safe", edited(prov, at(R + ("job", "polls"), 2 ** 53)), [], "2^53 polls: a whole number has no ceiling but a count's")
add("provider-whole-spelt-large", edited(prov, at(R + ("provider", "qubits"), 1e30)), [], "1e30 qubits: whole, and absurd, and no rule's to refuse")
def past_safe(count):
def edit(r):
r["request"]["shots"] = 2 ** 53
r["result"]["shots"] = 2 ** 53
r["result"]["counts"] = {"00": count, "11": 2 ** 53 - count} if count < 2 ** 53 else {"00": count}
r["result"]["distinct_outcomes"] = len(r["result"]["counts"])
r["result"]["omitted_shots"] = 0
return edit
add("provider-shots-past-safe", edited(prov, past_safe(2 ** 53 - 1)), [], "2^53 shots, counted within a count's ceiling")
add("provider-count-past-safe", edited(prov, past_safe(2 ** 53)), ["counts"], "a count of 2^53, past its ceiling")
def same_strings(r):
r["request"]["shots"] = "300"
r["result"]["shots"] = "300"
add("provider-shots-same-strings", edited(prov, same_strings), ["counts"], "equal strings are the request's shots, and a string is no shots")
add("provider-counts-hidden", edited(prov, recount(hidden)), ["counts"], "shots left out while fewer than 65,536 outcomes are listed")
add("provider-counts-distinct", edited(prov, recount(lambda r: r.update(distinct_outcomes=r["distinct_outcomes"] + 1))), ["counts"], "distinct_outcomes not the outcomes listed")
add("provider-members-describe", edited(prov, at(R + ("provider", "describe"), prov["result"]["provider"]["describe"].upper())), ["provider_members"], "the describe hash in upper case")
add("provider-members-no-qasm3", edited(prov, drop(R + ("compiled", "qasm3"))), ["provider_members"], "no compiled program's text")
add("provider-members-energy", edited(prov, at(R + ("energy",), {"joules": 1})), ["provider_members"], "energy as a figure measured here")
add("provider-members-kwh-unlabelled", edited(prov, at(R + ("energy", "service_kwh"), 0.001)), ["provider_members"], "the provider's energy figure not labelled as its own")
add("provider-members-no-schema", edited(prov, drop(R + ("schema",))), ["provider_members"], "no schema")
add("provider-members-no-charged", edited(prov, drop(R + ("cost", "charged"))), ["provider_members"], "no charged")
add("provider-members-basis", edited(prov, at(R + ("provider", "basis"), "gpizz")), ["provider_members"], "the provider's basis not the program's")
add("provider-counts-source-other", edited(prov, at(R + ("counts_source",), "estimated")), ["counts_source"], "a counts_source of no value")
add("provider-execution-default", edited(prov, at(R + ("execution", "twirling"), "default")), ["execution"], "a provider saying default, which only a client says")
add("provider-execution-verbatim-remapped", edited(prov, at(R + ("execution", "remapping"), "on")), ["execution"], "run as written and remapped")
add("provider-execution-sent", edited(prov, at(R + ("execution", "sent"), {"fields": [], "settings": {}})), ["execution"], "sent, which only a client states")
add("provider-execution-member", edited(prov, at(R + ("execution", "routing"), "off")), ["execution"], "a member execution does not have")
nobody = {"stated_by": "nobody", "mitigation": "unknown", "twirling": "unknown", "decoupling": "unknown", "remapping": "unknown", "optimisation": "unknown", "verbatim": None}
add("provider-execution-nobody", edited(prov, at(R + ("execution",), nobody)), [], "a provider that states nothing: no one's word")
client = {"stated_by": "client", "sent": {"fields": ["op", "program", "protocol", "shots"], "settings": {}}, "mitigation": "default", "twirling": "default", "decoupling": "default", "remapping": "default", "optimisation": "default", "verbatim": False}
add("provider-execution-client-open", edited(prov, at(R + ("execution",), client)), ["execution"], "the open protocol's client claiming to state what was set")
add("provider-compiled-program", edited(prov, at(R + ("compiled", "qasm3"), prov["result"]["compiled"]["qasm3"] + "// another program\n")), ["compiled_program"], "a program's text that is not the text its hash names")
add("provider-cost-free-confirmed", edited(prov, at(R + ("cost", "confirmed"), True)), ["cost_confirmation"], "a free run that claims a confirmation")
add("provider-cost-unconfirmed", edited(prov, at(R + ("cost", "free"), False)), ["cost_confirmation"], "a run that was not free, with no confirmation")
add("provider-stated-by-a-null", edited(legacy, at(R + ("counts_source",), None)), ["counts_source", "execution", "provider_class", "provider_members"], "an earlier-form result given counts_source null: stated by its members, whatever their values")
add("earlier-request-shots", edited(legacy, at(("request", "shots"), 65)), ["request_shots"], "an earlier-form result whose request asks other shots")
add("earlier-approximate", edited(legacy, at(R + ("accuracy", "approximate"), True)), ["provider_class"], "approximate on an earlier-form result")
add("earlier-simulated", edited(legacy, at(R + ("accuracy", "class"), "simulated")), ["provider_class"], "the earlier form labelled simulated, which no earlier engine wrote")
# --- what each built-in kind records (section 8.3)
add("kind-sampler-twirling-default", edited(sampler, at(R + ("execution", "twirling"), "default")), ["execution"], "sampler-v2 not stating the twirling it sends off")
add("kind-prx-shots", edited(prx, at(R + ("counts_source",), "shots")), ["counts_source"], "prx-circuits claiming shot records it does not read")
add("kind-prx-twirling-off", edited(prx, at(R + ("execution", "twirling"), "off")), ["execution"], "prx-circuits claiming a setting it does not send")
add("kind-turns-shots", edited(turns, at(R + ("counts_source",), "shots")), ["counts_source"], "native-turns claiming shots: its counts are always rebuilt from probabilities")
add("kind-tasks-vendor-counts", edited(qpu, at(R + ("counts_source",), "vendor_counts")), ["counts_source"], "cloud-tasks claiming the provider's own counts")
add("kind-tasks-simulator-boxed", edited(sim, at(R + ("execution",), {k: v for k, v in qpu["result"]["execution"].items()})), ["execution"], "a simulator's task stating the processor's verbatim box")
def nobody(r):
r["result"]["execution"] = dict({k: "unknown" for k in ("mitigation", "twirling", "decoupling", "remapping", "optimisation")}, stated_by="nobody", verbatim=None)
r["result"]["compiled"].pop("qubit_names")
# Section 8.4: compiled.qubit_names.
add("kind-tasks-no-names", edited(qpu, drop(R + ("compiled", "qubit_names"))), ["provider_members"], "cloud-tasks, stated by its client, not saying which of the device's qubits its indices were")
add("kind-prx-no-names", edited(prx, drop(R + ("compiled", "qubit_names"))), ["provider_members"], "prx-circuits, stated by its client, not saying which of the device's qubits its indices were")
add("kind-tasks-names-null", edited(qpu, at(R + ("compiled", "qubit_names"), None)), ["provider_members"], "null is given, and is no object")
add("kind-tasks-name-leading-zero", edited(qpu, at(R + ("compiled", "qubit_names"), dict(qpu["result"]["compiled"]["qubit_names"], **{"01": "x"}))), ["provider_members"], "an index with a leading zero")
add("kind-sampler-names-short", edited(sampler, at(R + ("compiled", "qubit_names"), {})), ["provider_members"], "names given where they are optional, and not of every index of the layouts")
add("kind-prx-nobody", edited(prx, nobody), [], "a job recorded before its client said what it sent: stated by nobody, on a kind with rows")
add("kind-tasks-processor-unboxed", edited(qpu, at(R + ("execution", "verbatim"), False)), ["execution"], "a processor's task not stating its verbatim box")
# Section 8.4: every index qasm3 acts on is named.
def acts_on_one_more(r):
c = r["result"]["compiled"]
q = max(int(k) for k in c["qubit_names"]) + 1
c["qasm3"] = c["qasm3"] + "x $%d;\n" % q
c["program"] = blake3(c["qasm3"].encode("utf-8")).hex()
add("kind-tasks-names-short-of-text", edited(qpu, acts_on_one_more), ["provider_members"], "qasm3 acts on a qubit its names do not name, outside both layouts")
# --- a whole double past 2^53, as RFC 8785 writes it (section 8.2)
def big_job(spelling):
# Each spelling stands for the double it reads as (section 8.2).
return {"request": {"qasm": "OPENQASM 3.0;", "observables": [{"pauli": "Z0", "coeff": Raw(spelling, float(spelling))}]},
"result": {"method": "statevector", "accuracy": {"class": "exact"}, "x": Raw(spelling, float(spelling))}}
add("number-canonical-spelling", seal(big_job("1152921504606847000")), [], "2^60 written as RFC 8785 writes it, its shortest digits and zeros: the double's own spelling")
add("number-exact-spelling", seal(big_job("1152921504606846976")), [], "2^60 written by its exact digits")
add("number-exponent-spelling", seal(big_job("1.152921504606847e+18")), [], "2^60 written with an exponent, as Python writes it")
add("number-near-canonical", seal(big_job("1152921504606847001")), ["inexact_number"], "digits one past the double's canonical text: another spelling of an inexact whole number")
add("number-padded-past", seal(big_job("1152921504606847000000")), ["inexact_number"], "the digits padded past 10^21, where RFC 8785 writes an exponent: not its spelling")
# --- sets (section 8.6)
S = ("result",)
add("set-error-item", seal_set(edited_set(progs, lambda r: (r["items"][1].pop("result"), r["items"][1].update(error="it did not run")))), [], "a set whose second item failed: its error is its leaf")
add("set-item-changed", seal_set(edited_set(progs, lambda r: r["items"][0]["result"]["counts"].update({"00": r["items"][0]["result"]["counts"].get("00", 0) + 1}))), ["set_item"], "an item's counts changed after it was sealed, the set sealed again over it")
add("set-root-other", edited_set_head(progs, lambda r: r.update(root="ab" * 32)), ["set_root"], "a root that is no tree's of these items, sealed by the set")
add("set-path-other", edited_set(progs, lambda r: r["items"][0]["path"].__setitem__(0, "cd" * 32)), ["set_root"], "an item's path changed: a path is not sealed, and must lead to the root")
add("set-count-other", edited_set_head(progs, lambda r: r.update(count=r["count"] + 1)), ["set_items"], "a count other than the items'")
add("set-index-swapped", edited_set(progs, lambda r: (r["items"][0].update(index=1), r["items"][1].update(index=0))), ["set_items"], "items whose index is not their place")
def other_shots(r):
it = r["items"][1]
it["request"]["shots"] = 65
sealed = seal({"request": it["request"], "result": it["result"]})
it["result"] = sealed["result"]
add("set-item-not-given", seal_set(edited_set(progs, other_shots)), ["set_items"], "an item sealed alone, and not the item the request's programs give")
add("set-head-changed", edited_set(progs, lambda r: r.update(elapsed_ms=r["elapsed_ms"] + 1)), ["digest_mismatch"], "the head changed after the set was sealed")
def failed_inexact(r):
it = r["items"][1]
it.pop("result")
it["error"] = "it did not run"
it["request"]["seed"] = Raw("9007199254740993", 2 ** 53 + 1)
add("set-error-item-inexact", seal_set(edited_set(progs, failed_inexact)), ["set_item", "set_items"], "a failed item whose request writes a number its leaf seals as another: no item's number escapes")
def first_form_set(body):
"""A set sealed in the first form: its receipt over its request and head by its writer's text."""
b = copy.deepcopy(body)
head = {k: v for k, v in b["result"].items() if k not in ("items", "receipt")}
d = digest(b["request"], head, form="first")
b["result"]["receipt"] = {"alg": "ed25519", "key": public_key(DEMO).hex(), "digest": d.hex(), "signature": sign(DEMO, d).hex()}
return b
def failed_by_digits(r):
it = r["items"][1]
it.pop("result")
it["error"] = "it did not run"
failed = seal_set(edited_set(progs, failed_by_digits))
add("set-first-form-error-item", first_form_set(failed), [], "a set of the first form, an item failed: valid")
by_digits = copy.deepcopy(failed)
by_digits["result"]["items"][1]["request"]["seed"] = Raw("9007199254740993", float(2 ** 53 + 1))
add("set-first-form-error-item-inexact", first_form_set(seal_set(by_digits)), ["set_item", "set_items"], "a set of the first form whose failed item writes 2^53 + 1 by its digits: its leaf, the canonical form's digest, seals the double")
def stranger(r):
it = r["items"][0]
it["result"] = seal({"request": it["request"], "result": it["result"]}, seed=OTHER)["result"]
add("set-item-other-key", seal_set(edited_set(progs, stranger)), ["set_item"], "an item sealed by a key other than the set's")
add("set-empty", edited_set_head(progs, lambda r: (r["items"].clear(), r.update(count=0, root="00" * 32))), ["set_items"], "a set of no items, its head sealed so")
add("set-sweep-short", seal_set(edited_set(sweep, lambda r: (r["items"].pop(), r.update(count=len(r["items"]))))), ["set_items"], "a sweep missing its last point, counted and sealed so")
big_sweep = copy.deepcopy(sweep)
big_sweep["request"]["sweep"]["theta"] = [Raw("9007199254740993", 2 ** 53 + 1)] + big_sweep["request"]["sweep"]["theta"][1:]
add("set-sweep-inexact", seal_set(big_sweep), ["inexact_number"], "a sweep's value no double holds, in the set's own request")
# --- another method claims a provider's class
add("method-measured", edited(run, at(R + ("accuracy", "class"), "measured")), ["provider_class"], "the engine's own result labelled measured")
add("method-simulated", edited(run, at(R + ("accuracy", "class"), "simulated")), ["provider_class"], "the engine's own result labelled simulated")
add("method-class-unknown", edited(run, at(R + ("accuracy", "class"), "quasi-exact")), [], "a class a verifier does not know: not a reason, since a later version may add one")
return out
# --------------------------------------------------------------------- the made half
MADE = {
"cli-run-observables.json": ("the command line, on this machine, with --demo-key: a Bell pair's expectation values", []),
"cli-run-statevector.json": ("the command line: a three-qubit circuit's counts by the state vector", []),
"cli-run-trajectories.json": ("the command line: noisy trajectories, an estimate with its error", []),
"cli-run-mps.json": ("the command line: thirty qubits as a matrix product state", []),
"cli-compile.json": ("the command line: a compile, its certificate and its receipt", []),
"cli-provider-reference.json": ("the command line, on the reference provider over a local process: a simulator's stated result", []),
"cli-provider-reference-priced.json": ("the command line, on the reference provider with a price, confirmed with --yes", []),
"service-run.json": ("the free job service, signed with its key", []),
"service-run-stabilizer.json": ("the free job service: a stabilizer job with observables", []),
"scripted-sampler-v2.json": ("sampler-v2 through a service that follows its contract", []),
"scripted-prx-circuits.json": ("prx-circuits through a service that follows its contract", []),
"scripted-native-turns.json": ("native-turns, its simulator, through a service that follows its contract", []),
"scripted-native-turns-noise.json": ("native-turns, its simulator under a device's noise model", []),
"scripted-cloud-tasks-processor.json": ("cloud-tasks on a processor: a verbatim box, rows of shots", []),
"scripted-cloud-tasks-processor-probabilities.json": ("cloud-tasks on a processor whose result holds probabilities: counts rebuilt", []),
"scripted-cloud-tasks-simulator.json": ("cloud-tasks on its simulator: simulated", []),
"fixture-job-legacy.json": ("a run sealed before results named their engine and schema (the engine's pinned fixture)", []),
"fixture-provider-job-legacy.json": ("a provider job of the earlier form: a simulator's counts sealed as measured, read as simulated", []),
"fixture-compile-legacy.json": ("a compile as an earlier page sealed it (the engine's pinned fixture)", []),
"cli-set-programs.json": ("the command line: a set of two programs, one receipt over both and each its own (section 8.6)", []),
"cli-set-sweep.json": ("the command line: a sweep of an input at three points, sealed as a set", []),
"first-form-service-run.json": ("the job service as it was on 18 October 2026, commit 72d18742d, sealing with the first form's own writer: counts", []),
"first-form-service-observables.json": ("the same service, the same writer: expectation values, doubles in its own text", []),
}
def manifest(crafted):
entries = []
for name in sorted(MADE):
what, reasons = MADE[name]
entries.append({"file": "jobs/" + name, "reasons": reasons, "made_by": "made", "what": what})
for name, _, reasons, what in crafted:
entries.append({"file": "jobs/" + name, "reasons": reasons, "made_by": "crafted", "what": what})
return {
"about": "Job receipts and the reasons a verifier must give for each (wai/extensions/quantum-providers.md section 8.4): valid when there are none. made: sealed by the command line, the job service, the provider clients or an earlier engine, kept as made. crafted: made by generate.py from those, each changed in one way and sealed again with the published demo key where the change is inside the seal. Every expectation is written by hand from section 8.4.",
"entries": entries,
}
LOCK = os.path.join(HERE, "made.lock.json")
def lock_of():
try:
with open(LOCK, encoding="utf-8") as f:
return json.load(f)
except OSError:
return {}
def digest_of(name):
with open(os.path.join(JOBS, name), "rb") as f:
return hashlib.sha256(f.read()).hexdigest()
def write_lock(lock):
with open(LOCK, "w", encoding="utf-8") as f:
f.write(json.dumps(lock, indent=2, sort_keys=True) + "\n")
def check_made():
"""A made receipt is kept: named in MADE, in jobs/, and the bytes pinned."""
lock, problems = lock_of(), []
for name in sorted(set(MADE) | set(lock)):
if name not in MADE:
problems.append("%s is pinned, and no longer in MADE: a made receipt is kept" % name)
elif name not in lock:
problems.append("%s is in MADE, and not pinned: generate.py --pin %s" % (name, name))
elif not os.path.exists(os.path.join(JOBS, name)):
problems.append("%s is pinned, and gone from jobs/: a made receipt is kept" % name)
elif digest_of(name) != lock[name]:
problems.append("%s has changed since it was pinned: a made receipt is kept as it was made, and a new one takes a new name" % name)
on_disk = {n for n in os.listdir(JOBS) if n.endswith(".json") and not n.startswith("crafted-")}
for name in sorted(on_disk - set(MADE)):
problems.append("%s is in jobs/, and not in MADE" % name)
return problems
def pin(names):
lock = lock_of()
for name in names:
if name in lock:
sys.exit("generate.py --pin: %s is pinned already: a made receipt is kept as it was made" % name)
if name not in MADE:
sys.exit("generate.py --pin: %s is not in MADE" % name)
lock[name] = digest_of(name)
write_lock(lock)
print("generate.py --pin: %d pinned, %d in all" % (len(names), len(lock)))
def self_test():
"""The pins can fail: a made receipt dropped, changed, or unnamed, in a copy."""
global JOBS, LOCK, MADE
import shutil
import tempfile
jobs, lock, made = JOBS, LOCK, MADE
failures = 0
with tempfile.TemporaryDirectory() as tmp:
try:
JOBS, LOCK = os.path.join(tmp, "jobs"), os.path.join(tmp, "made.lock.json")
os.mkdir(JOBS)
for name in made:
shutil.copy(os.path.join(jobs, name), JOBS)
shutil.copy(lock, LOCK)
name = sorted(made)[0]
def expect(what, want):
nonlocal failures
problems = check_made()
held = any(want in p for p in problems)
print(("PASS " if held else "FAIL ") + what)
failures += not held
if check_made():
print("FAIL the copy holds as it is: %s" % check_made())
failures += 1
with open(os.path.join(JOBS, name), "ab") as f:
f.write(b" ")
expect("a made receipt changed is found", "has changed")
os.remove(os.path.join(JOBS, name))
expect("a made receipt dropped is found", "gone from jobs/")
MADE = {k: v for k, v in made.items() if k != name}
expect("a made receipt dropped from MADE too is found", "no longer in MADE")
MADE = dict(made)
shutil.copy(os.path.join(jobs, name), JOBS)
with open(os.path.join(JOBS, "made-by-no-one.json"), "wb") as f:
f.write(b"{}")
expect("a receipt in jobs/ that MADE does not name is found", "not in MADE")
os.remove(os.path.join(JOBS, "made-by-no-one.json"))
MADE = dict(made, **{"new.json": ("a new one", [])})
expect("a name in MADE that is not pinned is found", "not pinned")
finally:
JOBS, LOCK, MADE = jobs, lock, made
if failures:
sys.exit(1)
print("generate.py --self-test: the pins can fail, each way")
def main():
if sys.argv[1:2] == ["--pin"]:
return pin(sys.argv[2:])
if sys.argv[1:] == ["--self-test"]:
return self_test()
check = "--check" in sys.argv[1:]
problems = check_made()
if problems:
for p in problems:
print("generate.py: " + p)
sys.exit(1)
crafted = cases()
want = {os.path.join(JOBS, name): (t if isinstance(t, bytes) else t.encode("utf-8")) for name, t, _, _ in crafted}
want[os.path.join(HERE, "manifest.json")] = (json.dumps(manifest(crafted), indent=2, ensure_ascii=False) + "\n").encode("utf-8")
stale = [n for n in os.listdir(JOBS) if n.startswith("crafted-") and os.path.join(JOBS, n) not in want]
bad = []
for path, data in sorted(want.items()):
if check:
try:
with open(path, "rb") as f:
if f.read() != data:
bad.append(path)
except OSError:
bad.append(path)
else:
with open(path, "wb") as f:
f.write(data)
if check:
for p in bad + [os.path.join(JOBS, n) for n in stale]:
print("generate.py --check: %s is not what generate.py writes" % os.path.relpath(p, HERE))
if bad or stale:
sys.exit(1)
print("generate.py --check: %d crafted receipts and the manifest are as written" % len(crafted))
else:
for n in stale:
os.remove(os.path.join(JOBS, n))
print("generate.py: wrote %d crafted receipts and the manifest" % len(crafted))
if __name__ == "__main__":
main()

1
wai/quantum-conformance/receipts/jobs/cli-compile.json Normal file
View file

File diff suppressed because one or more lines are too long

1
wai/quantum-conformance/receipts/jobs/cli-provider-reference-priced.json Normal file
View file

@ -0,0 +1 @@
{"status":"done","method":"provider","why":"on priced, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent","request":{"qasm":"OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n","shots":300,"seed":4,"provider":"priced"},"result":{"method":"provider","qubits":2,"gates":2,"accuracy":{"class":"simulated","note":"counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"},"shots":300,"provider":{"name":"priced","kind":"process","protocol":"wai.quantum.provider/1","device":"reference:line-5","provenance":"simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given","qubits":5,"basis":"rzsxxcz","describe":"c7626c0d9f68fe8e420df9cfe19f635427160bfe4902af2cc12c480b28d3b439"},"calibration":"reference-f2d9fe570421","compiled":{"basis":"rzsxxcz","program":"b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9","hash":"BLAKE3 of the program's OpenQASM 3 text, qasm3","qasm3":"OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n","native_gates":9,"two_qubit_gates":1,"swaps":0,"layout":[0,1],"final_layout":[0,1],"checked":"the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent","placement":{"chosen":"the compiler's own layout, the fewest swaps: the description states no errors"}},"job":{"id":"ref-1","polls":1},"ideal":{"computed":true,"method":"exact","total_variation_distance":0.03666666666666665,"hellinger_fidelity":0.998653743148044,"sampling_tvd_expected":0.023032943298089033,"ideal_outcomes":2,"note":"the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"},"cost":{"free":false,"estimate":{"free":false,"amount":"0.09","currency":"USD","unit":"shot","seconds":0.0},"charged":{"amount":"0.09","currency":"USD"},"confirmed":true},"energy":{"unmetered":"the work ran at the provider; this host's meter would read only the wait"},"counts_source":"shots","execution":{"stated_by":"provider","mitigation":"none","twirling":"none","decoupling":"none","remapping":"none","optimisation":"none","verbatim":true,"note":"the reference simulates the program's gates as written, on the qubits named, and corrects nothing"},"counts":{"11":161,"00":139},"distinct_outcomes":2,"omitted_shots":0,"engine":{"name":"wai-quantum","version":"0.8.1"},"schema":"wai.quantum.job-result/1","receipt":{"alg":"ed25519","canon":"rfc8785","key":"197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61","digest":"a9f7cd574d721a9a2cd9178cf38b25cd2081b6871d378bab70394fcb1861228b","signature":"7b150fc6c183213f2c776869e306016b31e586c1fe8ec702e9e9fd009a0c51a7366a25c0422a2169ef627682ff72917cb84cb693f53acec52bf24786daa5f500"}},"id":"pj-9a09dd19b51481e8","submitted_ms":1793907034821,"finished_ms":1793907034821}

1
wai/quantum-conformance/receipts/jobs/cli-provider-reference.json Normal file
View file

@ -0,0 +1 @@
{"status":"done","method":"provider","why":"on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent","request":{"qasm":"OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n","shots":300,"seed":4,"provider":"ref"},"result":{"method":"provider","qubits":2,"gates":2,"accuracy":{"class":"simulated","note":"counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"},"shots":300,"provider":{"name":"ref","kind":"process","protocol":"wai.quantum.provider/1","device":"reference:line-5","provenance":"simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given","qubits":5,"basis":"rzsxxcz","describe":"0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"},"calibration":"reference-f2d9fe570421","compiled":{"basis":"rzsxxcz","program":"b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9","hash":"BLAKE3 of the program's OpenQASM 3 text, qasm3","qasm3":"OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n","native_gates":9,"two_qubit_gates":1,"swaps":0,"layout":[0,1],"final_layout":[0,1],"checked":"the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent","placement":{"chosen":"the compiler's own layout, the fewest swaps: the description states no errors"}},"job":{"id":"ref-1","polls":1},"ideal":{"computed":true,"method":"exact","total_variation_distance":0.03666666666666665,"hellinger_fidelity":0.998653743148044,"sampling_tvd_expected":0.023032943298089033,"ideal_outcomes":2,"note":"the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"},"cost":{"free":true,"estimate":{"free":true,"seconds":0.0},"charged":null,"confirmed":false},"energy":{"unmetered":"the work ran at the provider; this host's meter would read only the wait"},"counts_source":"shots","execution":{"stated_by":"provider","mitigation":"none","twirling":"none","decoupling":"none","remapping":"none","optimisation":"none","verbatim":true,"note":"the reference simulates the program's gates as written, on the qubits named, and corrects nothing"},"counts":{"11":161,"00":139},"distinct_outcomes":2,"omitted_shots":0,"engine":{"name":"wai-quantum","version":"0.8.1"},"schema":"wai.quantum.job-result/1","receipt":{"alg":"ed25519","canon":"rfc8785","key":"197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61","digest":"0e568337eb3ba31b51bf82a2329353632aaed80d96ab197ec6c27a8e4376efb5","signature":"eb0a2972e4e8a587cfd387001c25604f0723d74000b88c9e5be540bb8ed374e9f809035dd34c2ed6ac65dee4793622a59e55d2a16b6affcbb4cfe872b3b52a09"}},"id":"pj-442c6043319912f8","submitted_ms":1793907034817,"finished_ms":1793907034817}

1
wai/quantum-conformance/receipts/jobs/cli-run-mps.json Normal file
View file

@ -0,0 +1 @@
{"status":"done","method":"mps","why":"matrix product state of 30 qubits at bond dimension 64","estimate":{"memory_bytes":277872640,"work":65732608},"request":{"qasm":"OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[30] q;\nbit[30] c;\nrx(0.3) q[0];\ncx q[0], q[1];\nrx(0.3) q[1];\ncx q[1], q[2];\nrx(0.3) q[2];\ncx q[2], q[3];\nrx(0.3) q[3];\ncx q[3], q[4];\nrx(0.3) q[4];\ncx q[4], q[5];\nrx(0.3) q[5];\ncx q[5], q[6];\nrx(0.3) q[6];\ncx q[6], q[7];\nrx(0.3) q[7];\ncx q[7], q[8];\nrx(0.3) q[8];\ncx q[8], q[9];\nrx(0.3) q[9];\ncx q[9], q[10];\nrx(0.3) q[10];\ncx q[10], q[11];\nrx(0.3) q[11];\ncx q[11], q[12];\nrx(0.3) q[12];\ncx q[12], q[13];\nrx(0.3) q[13];\ncx q[13], q[14];\nrx(0.3) q[14];\ncx q[14], q[15];\nrx(0.3) q[15];\ncx q[15], q[16];\nrx(0.3) q[16];\ncx q[16], q[17];\nrx(0.3) q[17];\ncx q[17], q[18];\nrx(0.3) q[18];\ncx q[18], q[19];\nrx(0.3) q[19];\ncx q[19], q[20];\nrx(0.3) q[20];\ncx q[20], q[21];\nrx(0.3) q[21];\ncx q[21], q[22];\nrx(0.3) q[22];\ncx q[22], q[23];\nrx(0.3) q[23];\ncx q[23], q[24];\nrx(0.3) q[24];\ncx q[24], q[25];\nrx(0.3) q[25];\ncx q[25], q[26];\nrx(0.3) q[26];\ncx q[26], q[27];\nrx(0.3) q[27];\ncx q[27], q[28];\nrx(0.3) q[28];\ncx q[28], q[29];\nc = measure q;\n","shots":20,"seed":1,"method":"mps"},"result":{"method":"mps","qubits":30,"gates":58,"accuracy":{"class":"exact","max_bond":64,"max_bond_used":2,"note":"no truncation dropped weight beyond the cutoff's rounding"},"counts":{"000000000000000000000000000000":7,"111111111111110000000000000000":2,"000000111111111000000000000000":1,"000000111111111111111111111111":1,"000011111111111111111110000000":1,"000111111111111111111111111100":1,"111100000000000000000000000000":1,"111111100000000000000000000000":1,"111111111111111000000000000000":1,"111111111111111100000000000000":1,"111111111111111111100000000000":1,"111111111111111111111000000000":1,"111111111111111111111100000000":1},"distinct_outcomes":13,"omitted_shots":0,"elapsed_ms":0,"engine":{"name":"wai-quantum","version":"0.8.1"},"schema":"wai.quantum.job-result/1","energy":{"unmetered":"the command line does not meter a run's energy"},"receipt":{"alg":"ed25519","canon":"rfc8785","key":"197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61","digest":"c23c14e79974526d6a405c4331ea3d6a99491319f070055b56f116e16a9fc0e6","signature":"c0f24e266f9c36ef4d953e4dbc00d8b028453aec138e70fc72f01df3638db1a2a6e8eac039bb314be0d33f234a857d40a5406ec8182403a27e5620f177994207"}}}

1
wai/quantum-conformance/receipts/jobs/cli-run-observables.json Normal file
View file

@ -0,0 +1 @@
{"status":"done","method":"stabilizer","why":"Clifford circuit: the stabilizer tableau of 2 qubits","estimate":{"memory_bytes":67172870,"work":2016},"request":{"qasm":"OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n","shots":1000,"seed":7,"observables":["Z0 Z1","X0"]},"result":{"method":"stabilizer","qubits":2,"gates":2,"accuracy":{"class":"exact"},"counts":{"11":505,"00":495},"distinct_outcomes":2,"omitted_shots":0,"outcome_dimension":1,"expectations":[{"observable":"Z0 Z1","coeff":1.0,"value":1.0},{"observable":"X0","coeff":1.0,"value":0.0}],"elapsed_ms":0,"engine":{"name":"wai-quantum","version":"0.8.1"},"schema":"wai.quantum.job-result/1","energy":{"unmetered":"the command line does not meter a run's energy"},"receipt":{"alg":"ed25519","canon":"rfc8785","key":"197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61","digest":"d4eaa3cf71da3405192198a7297a653644d773dc3e94761cda44b84eff45ffd1","signature":"7cd39fd1eacf313bfd17db9cce2d93aba8ff8ca1900de2a67a5b2770ea705e7e4fca420f222d4e3a4c5a7888b121de283abbd59aabc56d3a9d9164b7d8a62306"}}}

1
wai/quantum-conformance/receipts/jobs/cli-run-statevector.json Normal file
View file

@ -0,0 +1 @@
{"status":"done","method":"statevector","why":"dense double-precision state vector of 3 qubits","estimate":{"memory_bytes":268447588,"work":40},"request":{"qasm":"OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[3] q;\nbit[3] c;\nh q[0];\nt q[0];\ncx q[0], q[1];\nrz(pi/8) q[2];\ncx q[1], q[2];\nc = measure q;\n","shots":500,"seed":3,"method":"statevector"},"result":{"method":"statevector","qubits":3,"gates":5,"accuracy":{"class":"exact","fusion":3},"counts":{"000":252,"111":248},"distinct_outcomes":2,"omitted_shots":0,"elapsed_ms":0,"engine":{"name":"wai-quantum","version":"0.8.1"},"schema":"wai.quantum.job-result/1","energy":{"unmetered":"the command line does not meter a run's energy"},"receipt":{"alg":"ed25519","canon":"rfc8785","key":"197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61","digest":"12938ced9f32eddf67182b3dcd112b3f80fdababda46f3435d004f3bf4ec84f9","signature":"b0fbdd938321ce7bc12e4fed53816aeca63e290b04cf615664bd9e83909107908a1075b5566f3e7ad2f78aa917cbc2431ff73bf01c3f117d8614327d3cd8ad06"}}}

1
wai/quantum-conformance/receipts/jobs/cli-run-trajectories.json Normal file
View file

@ -0,0 +1 @@
{"status":"done","method":"trajectories","why":"300 noisy trajectories of 2 qubits, shots that share their errors sharing a state","estimate":{"memory_bytes":268443904,"work":80},"request":{"qasm":"OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n","shots":300,"seed":5,"method":"trajectories","observables":["Z0 Z1"],"noise":{"depolarizing_2q":0.03,"readout":0.02}},"result":{"method":"trajectories","qubits":2,"gates":2,"accuracy":{"class":"estimate","trajectories":300,"histories":43,"gate_applications":64,"note":"each shot is an independent noisy trajectory in law; shots that took the same errors share one state (histories counts the distinct ones); expectations are means over the trajectories with their standard errors"},"expectations":[{"observable":"Z0 Z1","coeff":1.0,"value":0.9733333333333334,"stderr":0.013266275070829938}],"counts":{"11":142,"00":138,"01":12,"10":8},"distinct_outcomes":4,"omitted_shots":0,"shots":300,"elapsed_ms":0,"engine":{"name":"wai-quantum","version":"0.8.1"},"schema":"wai.quantum.job-result/1","energy":{"unmetered":"the command line does not meter a run's energy"},"receipt":{"alg":"ed25519","canon":"rfc8785","key":"197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61","digest":"408d160222d612a9f6ecf44cf871c3cfd9b17c0c796d303149a6098411d716ba","signature":"b979ee8c0328be81843d57499b648f29a07441cd56d0e6b2071c08e31e043425cf758979c86c3a2505abedc03ffcf8c909dd998d3f54725b77035e92f5f6ac0c"}}}

1
wai/quantum-conformance/receipts/jobs/cli-set-programs.json Normal file
View file

@ -0,0 +1 @@
{"status":"done","method":"set","why":"a set of 2 items, run one after another in one process (exact, stabilizer)","estimate":{"memory_bytes":134218112,"work":176},"request":{"seed":3,"shots":64,"programs":["OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n","OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[3] q;\nbit[3] c;\nh q[0];\nt q[0];\ncx q[0], q[1];\nrz(pi/8) q[2];\ncx q[1], q[2];\nc = measure q;\n"]},"result":{"format":"wai.quantum.set/1","count":2,"done":2,"failed":0,"root":"64593524fe46385009353a9c265d08b1ef5add6248bec0713f8f5dd0650714bd","energy":{"unmetered":"the command line does not meter a run's energy"},"elapsed_ms":0,"engine":{"name":"wai-quantum","version":"0.8.1"},"schema":"wai.quantum.set/1","receipt":{"alg":"ed25519","canon":"rfc8785","key":"197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61","digest":"1569eb78f42db9a29a45bfe3a55d44d6888b665c9bdd150213655d23748bbcc7","signature":"d9fb355d4552ad7e5ed43025d4b9db64fd89a04562f6e330c85dad5143718ab472ca0d3ef7da39e7744c558710ff86631302f8c124958792434baa243d1f8202"},"items":[{"index":0,"request":{"seed":3,"shots":64,"qasm":"OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n"},"path":["dc8533cd8995ddd5d170447f7eddbf6fb54a90ef8ec8c0a32943c953e5c71adf"],"status":"done","method":"stabilizer","why":"Clifford circuit: the stabilizer tableau of 2 qubits","result":{"method":"stabilizer","qubits":2,"gates":2,"accuracy":{"class":"exact"},"counts":{"00":36,"11":28},"distinct_outcomes":2,"omitted_shots":0,"outcome_dimension":1,"elapsed_ms":0,"engine":{"name":"wai-quantum","version":"0.8.1"},"schema":"wai.quantum.job-result/1","provenance":{"schema":"wai.quantum.provenance/1","circuit":{"program":"bdcc1355a42c922e8b75eb5c015b12bc06b021de24042ab83ebca5df70d7dd8a","qubits":2,"gates":2},"computer":{"kind":"simulator","method":"stabilizer","accuracy":"exact"},"compilation":{"asked":false,"status":"not-applicable","why":"the job asked for no compile: the program ran as the reader read it, on the method's own gates"},"execution":{"shots":64,"seed":3,"plan":{"method":"stabilizer","why":"Clifford circuit: the stabilizer tableau of 2 qubits","memory_bytes":67112966,"work":136}},"software":{"engine":"wai-quantum 0.8.1","host":"wai-quantum 0.8.1"}},"energy":{"unmetered":"an item of a set: the set's own figure covers every item together, since they run in one process"},"receipt":{"alg":"ed25519","canon":"rfc8785","key":"197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61","digest":"56ab6900ccaf358ec738550e31f1e579513b3984a0a8b46081645daa1f6acb2e","signature":"15138c0199864735e0b01b616ae4ccf818134aab5182d42a9b42f51a49b02cc0661252d626c12e7933c0eee8d0d69551bfe3eb58afa637b3c8ab170ac98ac604"}}},{"index":1,"request":{"seed":3,"shots":64,"qasm":"OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[3] q;\nbit[3] c;\nh q[0];\nt q[0];\ncx q[0], q[1];\nrz(pi/8) q[2];\ncx q[1], q[2];\nc = measure q;\n"},"path":["ebc5c50b117c6f40d6fdf4cf919240b73072d25cc9806c9c76fd0fa967368cbc"],"status":"done","method":"exact","why":"bit-exact state vector of 3 qubits; not stabilizer: stabilizer needs a Clifford circuit: T is not a Clifford gate","result":{"method":"exact","qubits":3,"gates":5,"accuracy":{"class":"bit-exact"},"state_hash":"5f1ae3e98c0555290986daf0d573de16a34ba01d1993f13f134e0b1daf6f1ab5","counts":{"000":34,"111":30},"distinct_outcomes":2,"omitted_shots":0,"elapsed_ms":0,"engine":{"name":"wai-quantum","version":"0.8.1"},"schema":"wai.quantum.job-result/1","provenance":{"schema":"wai.quantum.provenance/1","circuit":{"program":"ea71913eeaa729b80f38c332ee03b2a2bb08d3430f37617ad64c83f1f91b78a9","qubits":3,"gates":5},"computer":{"kind":"simulator","method":"exact","accuracy":"bit-exact"},"compilation":{"asked":false,"status":"not-applicable","why":"the job asked for no compile: the program ran as the reader read it, on the method's own gates"},"execution":{"shots":64,"seed":3,"plan":{"method":"exact","why":"bit-exact state vector of 3 qubits; not stabilizer: stabilizer needs a Clifford circuit: T is not a Clifford gate","memory_bytes":134218112,"work":40}},"software":{"engine":"wai-quantum 0.8.1","host":"wai-quantum 0.8.1"}},"energy":{"unmetered":"an item of a set: the set's own figure covers every item together, since they run in one process"},"receipt":{"alg":"ed25519","canon":"rfc8785","key":"197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61","digest":"ddeb9ad8daad97246d28081c7a3f8d3152f975185a25261ec063eaba60f3e38b","signature":"c2c2c23f8d939e94069ef7501507c8763203324ef122247b8b748827539ccb129da636905f457ba3a62fab97153bcbc700190e9fa516c5a52115d631a3bb6600"}}}]}}

1
wai/quantum-conformance/receipts/jobs/cli-set-sweep.json Normal file
View file

File diff suppressed because one or more lines are too long

19
wai/quantum-conformance/receipts/jobs/crafted-canon-near-max.json Normal file
View file

@ -0,0 +1,19 @@
{
"request": {
"qasm": "OPENQASM 3.0;"
},
"result": {
"method": "statevector",
"accuracy": {
"class": "exact"
},
"x": 1.7976931348623158e308,
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "38b08b73a410c7a1619be74a16edbf8db9ca08ceaef467ba5ca11e713b7bcb3a",
"signature": "8650700f67fb205794512aa57353d5055b5f6b2394d84307b793534f1180c0f1c392545117dbf459d90a7ef2b53e1854033b0b296c58046caafd8d88e3f1f709"
}
}
}

35
wai/quantum-conformance/receipts/jobs/crafted-canon-numbers.json Normal file
View file

@ -0,0 +1,35 @@
{
"request": {
"qasm": "OPENQASM 3.0;"
},
"result": {
"method": "statevector",
"accuracy": {
"class": "exact"
},
"x": [
1e+21,
0.0000001,
1e-06,
0.30000000000000004,
5e-324,
1.7976931348623157e+308,
-0.0,
1.2345678901234568e+20,
9007199254740992,
18446744073709551616,
0,
-1,
1e+300,
4.35,
1.234e-06
],
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "2a2e6e3d195d7a4c6b53542ade620b6255dc426799ad368b2a5986d154e978a0",
"signature": "ef8d8a6e82dede7cf48fe706043f50eb5ed5a5dbfba4312cdabf4ffdc3001b062985cee6b617926ba6d84bb4dc9cc11eee330d4961c98574fa0b0e5da1e81c00"
}
}
}

61
wai/quantum-conformance/receipts/jobs/crafted-canon-respelt.json Normal file
View file

@ -0,0 +1,61 @@
{
"status": "done",
"method": "stabilizer",
"why": "Clifford circuit: the stabilizer tableau of 2 qubits",
"estimate": {
"memory_bytes": 67172870,
"work": 2016
},
"request": {
"observables": [
"Z0 Z1",
"X0"
],
"seed": 7,
"shots": 1.0e3,
"qasm": "\u004fPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n"
},
"result": {
"method": "stabilizer",
"\u0071ubits": 2,
"gates": 2,
"accuracy": {
"class": "exact"
},
"counts": {
"11": 505,
"00": 495
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"outcome_dimension": 1,
"expectations": [
{
"observable": "Z0 Z1",
"coeff": 1.0,
"value": 1
},
{
"observable": "X0",
"coeff": 1.0,
"value": 0.0
}
],
"elapsed_ms": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"energy": {
"unmetered": "the command line does not meter a run's energy"
},
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "d4eaa3cf71da3405192198a7297a653644d773dc3e94761cda44b84eff45ffd1",
"signature": "7cd39fd1eacf313bfd17db9cce2d93aba8ff8ca1900de2a67a5b2770ea705e7e4fca420f222d4e3a4c5a7888b121de283abbd59aabc56d3a9d9164b7d8a62306"
}
}
}

21
wai/quantum-conformance/receipts/jobs/crafted-canon-strings.json Normal file
View file

@ -0,0 +1,21 @@
{
"request": {
"qasm": "OPENQASM 3.0;",
"😀": "a key above the BMP",
"": "sorts after it in UTF-16",
"z": "tab\tnewline\ncontrol\u0001 slash/ del sep
 nonchar￿ quote\" backslash\\"
},
"result": {
"method": "statevector",
"accuracy": {
"class": "exact"
},
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "738887d81b8fd18027905bcf38d0457c117ae763e8006a74214279423290defc",
"signature": "b496932e763c4b6749caf0fdf5648eaf42777fddef97e17a92745d225d2c0bc22da4dfde963dfe71a4c263ec0c5f17f7680a2f9a9c287bff674470a3f8f62b08"
}
}
}

19
wai/quantum-conformance/receipts/jobs/crafted-canon-underflow.json Normal file
View file

@ -0,0 +1,19 @@
{
"request": {
"qasm": "OPENQASM 3.0;"
},
"result": {
"method": "statevector",
"accuracy": {
"class": "exact"
},
"x": 1e-400,
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "97577c4ef701bf5167d2d4596eca50b6d82d7cfdff09765b0c385667d4337aa2",
"signature": "fb0bb7f4be78632c21eccc7014b21cc57a60556a8c803f9d719d669bf640831dffa9915092a1069e461904c83aea30b28e39a1ae60e719701a0220dec6573b00"
}
}
}

66
wai/quantum-conformance/receipts/jobs/crafted-earlier-approximate.json Normal file
View file

@ -0,0 +1,66 @@
{
"status": "done",
"method": "provider",
"why": "a fixture",
"request": {
"qasm": "OPENQASM 3.0; qubit[2] q; bit[2] c; h q[0]; cx q[0], q[1]; c = measure q;",
"provider": "lab",
"shots": 64,
"seed": 1
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "measured",
"note": "counts measured on the device the provider names, as it returned them, with no mitigation; not reproducible by recomputation: the same job run again gives other counts, and no simulation stands in for them",
"approximate": true
},
"shots": 64,
"provider": {
"name": "lab",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference",
"provenance": "simulator"
},
"calibration": "snap-1",
"compiled": {
"basis": "rzsxxcz",
"program": "00"
},
"job": {
"id": "j-1",
"polls": 0
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03125,
"hellinger_fidelity": 0.9990224819584785,
"sampling_tvd_expected": 0.04986778505017909,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the measured counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's error, or a program the device did not run as sent"
},
"cost": {
"free": true
},
"energy": {
"unmetered": "the work ran at the provider"
},
"counts": {
"11": 34,
"00": 30
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "573a683a1abb7741b602272be809171baa68c9e5518f74c38400d5c79cdd70a3",
"signature": "489b2b3ff4ad78425c27fe6723e6fdf22113d590ab880093739cab5494f23244ff99bd7dfd8ac067d1d7e5aa785d338bc6d8654bed794fa748519371caa8d80c"
}
}
}

65
wai/quantum-conformance/receipts/jobs/crafted-earlier-request-shots.json Normal file
View file

@ -0,0 +1,65 @@
{
"status": "done",
"method": "provider",
"why": "a fixture",
"request": {
"qasm": "OPENQASM 3.0; qubit[2] q; bit[2] c; h q[0]; cx q[0], q[1]; c = measure q;",
"provider": "lab",
"shots": 65,
"seed": 1
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "measured",
"note": "counts measured on the device the provider names, as it returned them, with no mitigation; not reproducible by recomputation: the same job run again gives other counts, and no simulation stands in for them"
},
"shots": 64,
"provider": {
"name": "lab",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference",
"provenance": "simulator"
},
"calibration": "snap-1",
"compiled": {
"basis": "rzsxxcz",
"program": "00"
},
"job": {
"id": "j-1",
"polls": 0
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03125,
"hellinger_fidelity": 0.9990224819584785,
"sampling_tvd_expected": 0.04986778505017909,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the measured counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's error, or a program the device did not run as sent"
},
"cost": {
"free": true
},
"energy": {
"unmetered": "the work ran at the provider"
},
"counts": {
"11": 34,
"00": 30
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "a085a8a9f881ae3261af34c7587958db608dbcdf108c8a44e74de59828ab4189",
"signature": "50627e0eb5cd6d6c1c7249c213c9199c78b2e96e63a85aed7db39738cc13e256d3d89e68fe7bbafd764912da0612bcc7c66ec1beecea671936ad0c5c7da6ba02"
}
}
}

65
wai/quantum-conformance/receipts/jobs/crafted-earlier-simulated.json Normal file
View file

@ -0,0 +1,65 @@
{
"status": "done",
"method": "provider",
"why": "a fixture",
"request": {
"qasm": "OPENQASM 3.0; qubit[2] q; bit[2] c; h q[0]; cx q[0], q[1]; c = measure q;",
"provider": "lab",
"shots": 64,
"seed": 1
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts measured on the device the provider names, as it returned them, with no mitigation; not reproducible by recomputation: the same job run again gives other counts, and no simulation stands in for them"
},
"shots": 64,
"provider": {
"name": "lab",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference",
"provenance": "simulator"
},
"calibration": "snap-1",
"compiled": {
"basis": "rzsxxcz",
"program": "00"
},
"job": {
"id": "j-1",
"polls": 0
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03125,
"hellinger_fidelity": 0.9990224819584785,
"sampling_tvd_expected": 0.04986778505017909,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the measured counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's error, or a program the device did not run as sent"
},
"cost": {
"free": true
},
"energy": {
"unmetered": "the work ran at the provider"
},
"counts": {
"11": 34,
"00": 30
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "0a9c0322d070ee97e6841db873be08d490955262fcc5afa5fb7d16091fb6b320",
"signature": "32643e6ace3b7fd30980d8d4af64069681eadf980b97821501827bd9e3aa3b39eab7e18a6ba4128d234940426c5cf4f16a839ef1f9623d86797295904a476d0f"
}
}
}

62
wai/quantum-conformance/receipts/jobs/crafted-envelope-changed.json Normal file
View file

@ -0,0 +1,62 @@
{
"status": "failed",
"method": "a different method",
"why": "anything at all",
"estimate": {
"memory_bytes": 67172870,
"work": 2016
},
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 1000,
"seed": 7,
"observables": [
"Z0 Z1",
"X0"
]
},
"result": {
"method": "stabilizer",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "exact"
},
"counts": {
"11": 505,
"00": 495
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"outcome_dimension": 1,
"expectations": [
{
"observable": "Z0 Z1",
"coeff": 1.0,
"value": 1.0
},
{
"observable": "X0",
"coeff": 1.0,
"value": 0.0
}
],
"elapsed_ms": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"energy": {
"unmetered": "the command line does not meter a run's energy"
},
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "d4eaa3cf71da3405192198a7297a653644d773dc3e94761cda44b84eff45ffd1",
"signature": "7cd39fd1eacf313bfd17db9cce2d93aba8ff8ca1900de2a67a5b2770ea705e7e4fca420f222d4e3a4c5a7888b121de283abbd59aabc56d3a9d9164b7d8a62306"
}
},
"id": "j-another"
}

60
wai/quantum-conformance/receipts/jobs/crafted-form-canonical-relabelled.json Normal file
View file

@ -0,0 +1,60 @@
{
"status": "done",
"method": "stabilizer",
"why": "Clifford circuit: the stabilizer tableau of 2 qubits",
"estimate": {
"memory_bytes": 67172870,
"work": 2016
},
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 1000,
"seed": 7,
"observables": [
"Z0 Z1",
"X0"
]
},
"result": {
"method": "stabilizer",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "exact"
},
"counts": {
"11": 505,
"00": 495
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"outcome_dimension": 1,
"expectations": [
{
"observable": "Z0 Z1",
"coeff": 1.0,
"value": 1.0
},
{
"observable": "X0",
"coeff": 1.0,
"value": 0.0
}
],
"elapsed_ms": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"energy": {
"unmetered": "the command line does not meter a run's energy"
},
"receipt": {
"alg": "ed25519",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "d4eaa3cf71da3405192198a7297a653644d773dc3e94761cda44b84eff45ffd1",
"signature": "7cd39fd1eacf313bfd17db9cce2d93aba8ff8ca1900de2a67a5b2770ea705e7e4fca420f222d4e3a4c5a7888b121de283abbd59aabc56d3a9d9164b7d8a62306"
}
}
}

60
wai/quantum-conformance/receipts/jobs/crafted-form-first-big-integer.json Normal file
View file

@ -0,0 +1,60 @@
{
"status": "done",
"method": "stabilizer",
"why": "Clifford circuit: the stabilizer tableau of 2 qubits",
"estimate": {
"memory_bytes": 67172870,
"work": 2016
},
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 1000,
"seed": 9007199254740993,
"observables": [
"Z0 Z1",
"X0"
]
},
"result": {
"method": "stabilizer",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "exact"
},
"counts": {
"11": 505,
"00": 495
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"outcome_dimension": 1,
"expectations": [
{
"observable": "Z0 Z1",
"coeff": 1.0,
"value": 1.0
},
{
"observable": "X0",
"coeff": 1.0,
"value": 0.0
}
],
"elapsed_ms": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"energy": {
"unmetered": "the command line does not meter a run's energy"
},
"receipt": {
"alg": "ed25519",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "6b5de0b8636bf8e9fa5af54242e1f4242ba26b87fa4d7994f7f56f3cd0c48cf7",
"signature": "20934c32a4e9997bfa20ad9ac8d83ac285ea7f343976f0381a64220cbb4603d1a7c0ad06eced8ea3ff05e7100bb3f08103dbadf3364a7f0228c06d41dd445803"
}
}
}

68
wai/quantum-conformance/receipts/jobs/crafted-form-first-exponents.json Normal file
View file

@ -0,0 +1,68 @@
{
"status": "done",
"method": "stabilizer",
"why": "Clifford circuit: the stabilizer tableau of 2 qubits",
"estimate": {
"memory_bytes": 67172870,
"work": 2016
},
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 1000,
"seed": 7,
"observables": [
"Z0 Z1",
"X0"
]
},
"result": {
"method": "stabilizer",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "exact"
},
"counts": {
"11": 505,
"00": 495
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"outcome_dimension": 1,
"expectations": [
{
"observable": "Z0 Z1",
"coeff": 1.0,
"value": 1.0
},
{
"observable": "X0",
"coeff": 1.0,
"value": 0.0
}
],
"elapsed_ms": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"energy": {
"unmetered": "the command line does not meter a run's energy"
},
"x": [
1e+16,
1.5e+300,
1e-07,
2.5e-06,
1000000000000000.0,
1e-05
],
"receipt": {
"alg": "ed25519",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "12bea8e71977cbfebf01757f160fd70e568cc41c8d9caa6e3691d5bc4e7835ae",
"signature": "5b20510bfdfe9236c4bfafbc7e28045e60fecc3e19f96eb016f1f7bdddd7a1aca248d37ad15e665d43709be56b663b65d755371d341da4460b2d21296200c307"
}
}
}

60
wai/quantum-conformance/receipts/jobs/crafted-form-first-past-its-integers-exact.json Normal file
View file

@ -0,0 +1,60 @@
{
"status": "done",
"method": "stabilizer",
"why": "Clifford circuit: the stabilizer tableau of 2 qubits",
"estimate": {
"memory_bytes": 67172870,
"work": 2016
},
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 1000,
"seed": 18446744073709551616,
"observables": [
"Z0 Z1",
"X0"
]
},
"result": {
"method": "stabilizer",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "exact"
},
"counts": {
"11": 505,
"00": 495
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"outcome_dimension": 1,
"expectations": [
{
"observable": "Z0 Z1",
"coeff": 1.0,
"value": 1.0
},
{
"observable": "X0",
"coeff": 1.0,
"value": 0.0
}
],
"elapsed_ms": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"energy": {
"unmetered": "the command line does not meter a run's energy"
},
"receipt": {
"alg": "ed25519",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "c6509f912d15031a7c42fd57ec8e3ad6de8d72ff739ef0eef24cb281caf76aa7",
"signature": "bf2c455a07932c56c38b233e904339045e4710e3925fe99483654bf7af098825e7acc6448acdbf85e998150c7324f0e5146a33b69c9bcd7f0fdaf80a0cd7510c"
}
}
}

60
wai/quantum-conformance/receipts/jobs/crafted-form-first-past-its-integers.json Normal file
View file

@ -0,0 +1,60 @@
{
"status": "done",
"method": "stabilizer",
"why": "Clifford circuit: the stabilizer tableau of 2 qubits",
"estimate": {
"memory_bytes": 67172870,
"work": 2016
},
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 1000,
"seed": 18446744073709551617,
"observables": [
"Z0 Z1",
"X0"
]
},
"result": {
"method": "stabilizer",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "exact"
},
"counts": {
"11": 505,
"00": 495
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"outcome_dimension": 1,
"expectations": [
{
"observable": "Z0 Z1",
"coeff": 1.0,
"value": 1.0
},
{
"observable": "X0",
"coeff": 1.0,
"value": 0.0
}
],
"elapsed_ms": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"energy": {
"unmetered": "the command line does not meter a run's energy"
},
"receipt": {
"alg": "ed25519",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "c6509f912d15031a7c42fd57ec8e3ad6de8d72ff739ef0eef24cb281caf76aa7",
"signature": "bf2c455a07932c56c38b233e904339045e4710e3925fe99483654bf7af098825e7acc6448acdbf85e998150c7324f0e5146a33b69c9bcd7f0fdaf80a0cd7510c"
}
}
}

61
wai/quantum-conformance/receipts/jobs/crafted-form-first-relabelled.json Normal file
View file

@ -0,0 +1,61 @@
{
"status": "done",
"method": "stabilizer",
"why": "Clifford circuit: the stabilizer tableau of 2 qubits",
"estimate": {
"memory_bytes": 67172870,
"work": 2016
},
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 1000,
"seed": 7,
"observables": [
"Z0 Z1",
"X0"
]
},
"result": {
"method": "stabilizer",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "exact"
},
"counts": {
"11": 505,
"00": 495
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"outcome_dimension": 1,
"expectations": [
{
"observable": "Z0 Z1",
"coeff": 1.0,
"value": 1.0
},
{
"observable": "X0",
"coeff": 1.0,
"value": 0.0
}
],
"elapsed_ms": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"energy": {
"unmetered": "the command line does not meter a run's energy"
},
"receipt": {
"alg": "ed25519",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "410af825d4570eaf11bb082bfaeef5b7088eff7354f883f1babd528f431360ac",
"signature": "5999bc51c289421b22dd1c50861767638674e924cd749a09ff24cf01dcadfc956f6d882fd98af0607a813415ed8ec4a6fd55f0fcc30a0565a76351a9de553f03",
"canon": "rfc8785"
}
}
}

60
wai/quantum-conformance/receipts/jobs/crafted-form-first-reordered.json Normal file
View file

@ -0,0 +1,60 @@
{
"status": "done",
"method": "stabilizer",
"why": "Clifford circuit: the stabilizer tableau of 2 qubits",
"estimate": {
"memory_bytes": 67172870,
"work": 2016
},
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 1000,
"seed": 7,
"observables": [
"Z0 Z1",
"X0"
]
},
"result": {
"energy": {
"unmetered": "the command line does not meter a run's energy"
},
"schema": "wai.quantum.job-result/1",
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"elapsed_ms": 0,
"expectations": [
{
"observable": "Z0 Z1",
"coeff": 1.0,
"value": 1.0
},
{
"observable": "X0",
"coeff": 1.0,
"value": 0.0
}
],
"outcome_dimension": 1,
"omitted_shots": 0,
"distinct_outcomes": 2,
"counts": {
"11": 505,
"00": 495
},
"accuracy": {
"class": "exact"
},
"gates": 2,
"qubits": 2,
"method": "stabilizer",
"receipt": {
"alg": "ed25519",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "410af825d4570eaf11bb082bfaeef5b7088eff7354f883f1babd528f431360ac",
"signature": "5999bc51c289421b22dd1c50861767638674e924cd749a09ff24cf01dcadfc956f6d882fd98af0607a813415ed8ec4a6fd55f0fcc30a0565a76351a9de553f03"
}
}
}

60
wai/quantum-conformance/receipts/jobs/crafted-form-first-respelt.json Normal file
View file

@ -0,0 +1,60 @@
{
"status": "done",
"method": "stabilizer",
"why": "Clifford circuit: the stabilizer tableau of 2 qubits",
"estimate": {
"memory_bytes": 67172870,
"work": 2016
},
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 1000,
"seed": 7,
"observables": [
"Z0 Z1",
"X0"
]
},
"result": {
"method": "stabilizer",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "exact"
},
"counts": {
"11": 505,
"00": 495
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"outcome_dimension": 1,
"expectations": [
{
"observable": "Z0 Z1",
"coeff": 1.0,
"value": 1
},
{
"observable": "X0",
"coeff": 1.0,
"value": 0.0
}
],
"elapsed_ms": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"energy": {
"unmetered": "the command line does not meter a run's energy"
},
"receipt": {
"alg": "ed25519",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "410af825d4570eaf11bb082bfaeef5b7088eff7354f883f1babd528f431360ac",
"signature": "5999bc51c289421b22dd1c50861767638674e924cd749a09ff24cf01dcadfc956f6d882fd98af0607a813415ed8ec4a6fd55f0fcc30a0565a76351a9de553f03"
}
}
}

60
wai/quantum-conformance/receipts/jobs/crafted-form-first.json Normal file
View file

@ -0,0 +1,60 @@
{
"status": "done",
"method": "stabilizer",
"why": "Clifford circuit: the stabilizer tableau of 2 qubits",
"estimate": {
"memory_bytes": 67172870,
"work": 2016
},
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 1000,
"seed": 7,
"observables": [
"Z0 Z1",
"X0"
]
},
"result": {
"method": "stabilizer",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "exact"
},
"counts": {
"11": 505,
"00": 495
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"outcome_dimension": 1,
"expectations": [
{
"observable": "Z0 Z1",
"coeff": 1.0,
"value": 1.0
},
{
"observable": "X0",
"coeff": 1.0,
"value": 0.0
}
],
"elapsed_ms": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"energy": {
"unmetered": "the command line does not meter a run's energy"
},
"receipt": {
"alg": "ed25519",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "410af825d4570eaf11bb082bfaeef5b7088eff7354f883f1babd528f431360ac",
"signature": "5999bc51c289421b22dd1c50861767638674e924cd749a09ff24cf01dcadfc956f6d882fd98af0607a813415ed8ec4a6fd55f0fcc30a0565a76351a9de553f03"
}
}
}

60
wai/quantum-conformance/receipts/jobs/crafted-form-none-inexact.json Normal file
View file

@ -0,0 +1,60 @@
{
"status": "done",
"method": "stabilizer",
"why": "Clifford circuit: the stabilizer tableau of 2 qubits",
"estimate": {
"memory_bytes": 67172870,
"work": 2016
},
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 1000,
"seed": 9007199254740993,
"observables": [
"Z0 Z1",
"X0"
]
},
"result": {
"method": "stabilizer",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "exact"
},
"counts": {
"11": 505,
"00": 495
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"outcome_dimension": 1,
"expectations": [
{
"observable": "Z0 Z1",
"coeff": 1.0,
"value": 1.0
},
{
"observable": "X0",
"coeff": 1.0,
"value": 0.0
}
],
"elapsed_ms": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"energy": {
"unmetered": "the command line does not meter a run's energy"
},
"receipt": {
"alg": "rsa-pss",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "6b5de0b8636bf8e9fa5af54242e1f4242ba26b87fa4d7994f7f56f3cd0c48cf7",
"signature": "20934c32a4e9997bfa20ad9ac8d83ac285ea7f343976f0381a64220cbb4603d1a7c0ad06eced8ea3ff05e7100bb3f08103dbadf3364a7f0228c06d41dd445803"
}
}
}

1
wai/quantum-conformance/receipts/jobs/crafted-job-array.json Normal file
View file

@ -0,0 +1 @@
[]

54
wai/quantum-conformance/receipts/jobs/crafted-job-no-receipt.json Normal file
View file

@ -0,0 +1,54 @@
{
"status": "done",
"method": "stabilizer",
"why": "Clifford circuit: the stabilizer tableau of 2 qubits",
"estimate": {
"memory_bytes": 67172870,
"work": 2016
},
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 1000,
"seed": 7,
"observables": [
"Z0 Z1",
"X0"
]
},
"result": {
"method": "stabilizer",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "exact"
},
"counts": {
"11": 505,
"00": 495
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"outcome_dimension": 1,
"expectations": [
{
"observable": "Z0 Z1",
"coeff": 1.0,
"value": 1.0
},
{
"observable": "X0",
"coeff": 1.0,
"value": 0.0
}
],
"elapsed_ms": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"energy": {
"unmetered": "the command line does not meter a run's energy"
}
}
}

52
wai/quantum-conformance/receipts/jobs/crafted-job-no-request.json Normal file
View file

@ -0,0 +1,52 @@
{
"status": "done",
"method": "stabilizer",
"why": "Clifford circuit: the stabilizer tableau of 2 qubits",
"estimate": {
"memory_bytes": 67172870,
"work": 2016
},
"result": {
"method": "stabilizer",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "exact"
},
"counts": {
"11": 505,
"00": 495
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"outcome_dimension": 1,
"expectations": [
{
"observable": "Z0 Z1",
"coeff": 1.0,
"value": 1.0
},
{
"observable": "X0",
"coeff": 1.0,
"value": 0.0
}
],
"elapsed_ms": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"energy": {
"unmetered": "the command line does not meter a run's energy"
},
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "d4eaa3cf71da3405192198a7297a653644d773dc3e94761cda44b84eff45ffd1",
"signature": "7cd39fd1eacf313bfd17db9cce2d93aba8ff8ca1900de2a67a5b2770ea705e7e4fca420f222d4e3a4c5a7888b121de283abbd59aabc56d3a9d9164b7d8a62306"
}
}
}

53
wai/quantum-conformance/receipts/jobs/crafted-job-request-string.json Normal file
View file

@ -0,0 +1,53 @@
{
"status": "done",
"method": "stabilizer",
"why": "Clifford circuit: the stabilizer tableau of 2 qubits",
"estimate": {
"memory_bytes": 67172870,
"work": 2016
},
"request": "OPENQASM 3.0;",
"result": {
"method": "stabilizer",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "exact"
},
"counts": {
"11": 505,
"00": 495
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"outcome_dimension": 1,
"expectations": [
{
"observable": "Z0 Z1",
"coeff": 1.0,
"value": 1.0
},
{
"observable": "X0",
"coeff": 1.0,
"value": 0.0
}
],
"elapsed_ms": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"energy": {
"unmetered": "the command line does not meter a run's energy"
},
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "d4eaa3cf71da3405192198a7297a653644d773dc3e94761cda44b84eff45ffd1",
"signature": "7cd39fd1eacf313bfd17db9cce2d93aba8ff8ca1900de2a67a5b2770ea705e7e4fca420f222d4e3a4c5a7888b121de283abbd59aabc56d3a9d9164b7d8a62306"
}
}
}

112
wai/quantum-conformance/receipts/jobs/crafted-kind-prx-no-names.json Normal file
View file

@ -0,0 +1,112 @@
{
"status": "done",
"method": "provider",
"why": "on mine, prx-circuits:test-qc (prx-circuits): compiled exactly to prxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 400,
"provider": "mine"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "measured",
"note": "counts from the processor the provider names, read as counts_source says (shot records, the provider's own counts, or counts rebuilt from probabilities); not reproducible by recomputation: the same job run again gives other counts, and no simulation stands in for them; what was set off at the provider, and what was left to its defaults, is in execution"
},
"shots": 400,
"provider": {
"name": "mine",
"kind": "prx-circuits",
"protocol": "prx-circuits",
"device": "prx-circuits:test-qc",
"provenance": "silicon",
"qubits": 5,
"basis": "prxcz",
"describe": "1f6d996884468f37481db4e20932d6c0ecb84ebbbf4232f734080c61ab9fae66"
},
"calibration": null,
"compiled": {
"basis": "prxcz",
"program": "12123632bbbc70df6b58c3103f50479a72211ba109a01d9e3a581c703f160dad",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\ngate prx(theta, phi) a { rz(-phi) a; rx(theta) a; rz(phi) a; }\nbit[2] c;\nprx(pi/2, -pi/2) $0;\nprx(pi/2, -pi/2) $1;\ncz $0, $1;\nprx(pi/2, pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 4,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description does not read as a device target (describe: native_gates lists the device's gates)"
}
},
"job": {
"id": "prx-0",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.0,
"hellinger_fidelity": 1.0,
"sampling_tvd_expected": 0.019947114020071634,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": false,
"estimate": {
"unknown": "the provider gives no estimate"
},
"charged": null,
"confirmed": true
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "vendor_counts",
"execution": {
"stated_by": "client",
"sent": {
"fields": [
"circuits",
"shots"
],
"settings": {}
},
"verbatim": false,
"note": "this client sends only circuits and shots: it sets nothing, so every step is the service's default, whatever that is",
"mitigation": "default",
"twirling": "default",
"decoupling": "default",
"remapping": "default",
"optimisation": "default"
},
"counts": {
"00": 200,
"11": 200
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "86bf68db554f8d287455b0c625ee84590a3e74a8d16ff4faf03381593f09d5cc",
"signature": "d5d07ff3c01fefdee339298305a904cddc45b0d7b90f6ab8d3c00af43ff32349100737e49eb3467c450a0e84db743a6e0a9ecaab904f270768be4035f0fa3001"
}
}
}

104
wai/quantum-conformance/receipts/jobs/crafted-kind-prx-nobody.json Normal file
View file

@ -0,0 +1,104 @@
{
"status": "done",
"method": "provider",
"why": "on mine, prx-circuits:test-qc (prx-circuits): compiled exactly to prxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 400,
"provider": "mine"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "measured",
"note": "counts from the processor the provider names, read as counts_source says (shot records, the provider's own counts, or counts rebuilt from probabilities); not reproducible by recomputation: the same job run again gives other counts, and no simulation stands in for them; what was set off at the provider, and what was left to its defaults, is in execution"
},
"shots": 400,
"provider": {
"name": "mine",
"kind": "prx-circuits",
"protocol": "prx-circuits",
"device": "prx-circuits:test-qc",
"provenance": "silicon",
"qubits": 5,
"basis": "prxcz",
"describe": "1f6d996884468f37481db4e20932d6c0ecb84ebbbf4232f734080c61ab9fae66"
},
"calibration": null,
"compiled": {
"basis": "prxcz",
"program": "12123632bbbc70df6b58c3103f50479a72211ba109a01d9e3a581c703f160dad",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\ngate prx(theta, phi) a { rz(-phi) a; rx(theta) a; rz(phi) a; }\nbit[2] c;\nprx(pi/2, -pi/2) $0;\nprx(pi/2, -pi/2) $1;\ncz $0, $1;\nprx(pi/2, pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 4,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description does not read as a device target (describe: native_gates lists the device's gates)"
}
},
"job": {
"id": "prx-0",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.0,
"hellinger_fidelity": 1.0,
"sampling_tvd_expected": 0.019947114020071634,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": false,
"estimate": {
"unknown": "the provider gives no estimate"
},
"charged": null,
"confirmed": true
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "vendor_counts",
"execution": {
"mitigation": "unknown",
"twirling": "unknown",
"decoupling": "unknown",
"remapping": "unknown",
"optimisation": "unknown",
"stated_by": "nobody",
"verbatim": null
},
"counts": {
"00": 200,
"11": 200
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "ab960231ba7179c48cc1409e73cae3aea506638c566cbfc2dfc671e40b75e2f3",
"signature": "ec8629fc3f60fc2f1eae13e424c18bb0a004f45a6bf1bec7fe7fea69c619be0672e59112714d91e66b3e99c418cb7b3c676d976e66225e795a7a08b3583c2c0f"
}
}
}

116
wai/quantum-conformance/receipts/jobs/crafted-kind-prx-shots.json Normal file
View file

@ -0,0 +1,116 @@
{
"status": "done",
"method": "provider",
"why": "on mine, prx-circuits:test-qc (prx-circuits): compiled exactly to prxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 400,
"provider": "mine"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "measured",
"note": "counts from the processor the provider names, read as counts_source says (shot records, the provider's own counts, or counts rebuilt from probabilities); not reproducible by recomputation: the same job run again gives other counts, and no simulation stands in for them; what was set off at the provider, and what was left to its defaults, is in execution"
},
"shots": 400,
"provider": {
"name": "mine",
"kind": "prx-circuits",
"protocol": "prx-circuits",
"device": "prx-circuits:test-qc",
"provenance": "silicon",
"qubits": 5,
"basis": "prxcz",
"describe": "1f6d996884468f37481db4e20932d6c0ecb84ebbbf4232f734080c61ab9fae66"
},
"calibration": null,
"compiled": {
"basis": "prxcz",
"program": "12123632bbbc70df6b58c3103f50479a72211ba109a01d9e3a581c703f160dad",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\ngate prx(theta, phi) a { rz(-phi) a; rx(theta) a; rz(phi) a; }\nbit[2] c;\nprx(pi/2, -pi/2) $0;\nprx(pi/2, -pi/2) $1;\ncz $0, $1;\nprx(pi/2, pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 4,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"qubit_names": {
"0": "QB1",
"1": "QB2"
},
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description does not read as a device target (describe: native_gates lists the device's gates)"
}
},
"job": {
"id": "prx-0",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.0,
"hellinger_fidelity": 1.0,
"sampling_tvd_expected": 0.019947114020071634,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": false,
"estimate": {
"unknown": "the provider gives no estimate"
},
"charged": null,
"confirmed": true
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "client",
"sent": {
"fields": [
"circuits",
"shots"
],
"settings": {}
},
"verbatim": false,
"note": "this client sends only circuits and shots: it sets nothing, so every step is the service's default, whatever that is",
"mitigation": "default",
"twirling": "default",
"decoupling": "default",
"remapping": "default",
"optimisation": "default"
},
"counts": {
"00": 200,
"11": 200
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "128b98f68d728554428f1a732bb26656b8559e535ae45e90e054f4c09d5f65af",
"signature": "508b0388baf6595f949af0eb741f22efe99adb6b7da9787bcba685898f72b5b46484a73db9263cf6257a430ee87ad0967598276d8e1eb44341241241a18f5e00"
}
}
}

116
wai/quantum-conformance/receipts/jobs/crafted-kind-prx-twirling-off.json Normal file
View file

@ -0,0 +1,116 @@
{
"status": "done",
"method": "provider",
"why": "on mine, prx-circuits:test-qc (prx-circuits): compiled exactly to prxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 400,
"provider": "mine"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "measured",
"note": "counts from the processor the provider names, read as counts_source says (shot records, the provider's own counts, or counts rebuilt from probabilities); not reproducible by recomputation: the same job run again gives other counts, and no simulation stands in for them; what was set off at the provider, and what was left to its defaults, is in execution"
},
"shots": 400,
"provider": {
"name": "mine",
"kind": "prx-circuits",
"protocol": "prx-circuits",
"device": "prx-circuits:test-qc",
"provenance": "silicon",
"qubits": 5,
"basis": "prxcz",
"describe": "1f6d996884468f37481db4e20932d6c0ecb84ebbbf4232f734080c61ab9fae66"
},
"calibration": null,
"compiled": {
"basis": "prxcz",
"program": "12123632bbbc70df6b58c3103f50479a72211ba109a01d9e3a581c703f160dad",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\ngate prx(theta, phi) a { rz(-phi) a; rx(theta) a; rz(phi) a; }\nbit[2] c;\nprx(pi/2, -pi/2) $0;\nprx(pi/2, -pi/2) $1;\ncz $0, $1;\nprx(pi/2, pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 4,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"qubit_names": {
"0": "QB1",
"1": "QB2"
},
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description does not read as a device target (describe: native_gates lists the device's gates)"
}
},
"job": {
"id": "prx-0",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.0,
"hellinger_fidelity": 1.0,
"sampling_tvd_expected": 0.019947114020071634,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": false,
"estimate": {
"unknown": "the provider gives no estimate"
},
"charged": null,
"confirmed": true
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "vendor_counts",
"execution": {
"stated_by": "client",
"sent": {
"fields": [
"circuits",
"shots"
],
"settings": {}
},
"verbatim": false,
"note": "this client sends only circuits and shots: it sets nothing, so every step is the service's default, whatever that is",
"mitigation": "default",
"twirling": "off",
"decoupling": "default",
"remapping": "default",
"optimisation": "default"
},
"counts": {
"00": 200,
"11": 200
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "a41b3702444401d46fd34d13306ba891ceb1b29aad4581243fa435f9b1f389ef",
"signature": "1e11d6731be36a5299a7c22b5632bb7741b8bb1c39546c476175c3886601c6cc273b974889e1c5875d020d38c151e19e25bd4bce631fc577292ae84229844a01"
}
}
}

118
wai/quantum-conformance/receipts/jobs/crafted-kind-sampler-names-short.json Normal file
View file

@ -0,0 +1,118 @@
{
"status": "done",
"method": "provider",
"why": "on mine, sampler-v2:test_device (sampler-v2): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 400,
"provider": "mine"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "measured",
"note": "counts from the processor the provider names, read as counts_source says (its shot records, the provider's own counts, or counts rebuilt here from its probabilities); not reproducible by recomputation: the same job run again gives other counts, and no simulation stands in for them; what was set off at the provider, and what was left to its defaults, is in execution"
},
"shots": 400,
"provider": {
"name": "mine",
"kind": "sampler-v2",
"protocol": "sampler-v2",
"device": "sampler-v2:test_device",
"provenance": "silicon",
"qubits": 6,
"basis": "rzsxxcz",
"describe": "f25d38ec41b6c4e16dc2d5d2649b2ca23cddacb67d3de1b06add9766b5e3b879"
},
"calibration": null,
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description does not read as a device target (describe: native_gates lists the device's gates)"
},
"qubit_names": {}
},
"job": {
"id": "job-0",
"polls": 2
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.0,
"hellinger_fidelity": 1.0,
"sampling_tvd_expected": 0.019947114020071634,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": false,
"estimate": {
"unknown": "the provider gives no estimate"
},
"charged": null,
"confirmed": true
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "client",
"sent": {
"fields": [
"backend",
"params",
"program_id"
],
"settings": {
"/params/options/dynamical_decoupling/enable": false,
"/params/options/twirling/enable_gates": false,
"/params/options/twirling/enable_measure": false
}
},
"verbatim": false,
"note": "dynamical decoupling and twirling of gates and measurements are sent off; the request sets nothing for mitigation, remapping or optimisation, so the service's defaults stand; the program is sent on physical qubits in the backend's own gates",
"mitigation": "default",
"twirling": "off",
"decoupling": "off",
"remapping": "default",
"optimisation": "default"
},
"counts": {
"00": 200,
"11": 200
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "45beb4425cf0d92d77e1cfddadbdb56dfefc254e2d1eba96f8b49520d0e00cc2",
"signature": "589803c0a54dc10b636ac7c4c420ad6e2da884e1d14cb18a191335556386a8504cdbe442482982be783e188ee6e9bec7925eeda95448a9cacf7a36f8354be10e"
}
}
}

117
wai/quantum-conformance/receipts/jobs/crafted-kind-sampler-twirling-default.json Normal file
View file

@ -0,0 +1,117 @@
{
"status": "done",
"method": "provider",
"why": "on mine, sampler-v2:test_device (sampler-v2): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 400,
"provider": "mine"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "measured",
"note": "counts from the processor the provider names, read as counts_source says (its shot records, the provider's own counts, or counts rebuilt here from its probabilities); not reproducible by recomputation: the same job run again gives other counts, and no simulation stands in for them; what was set off at the provider, and what was left to its defaults, is in execution"
},
"shots": 400,
"provider": {
"name": "mine",
"kind": "sampler-v2",
"protocol": "sampler-v2",
"device": "sampler-v2:test_device",
"provenance": "silicon",
"qubits": 6,
"basis": "rzsxxcz",
"describe": "f25d38ec41b6c4e16dc2d5d2649b2ca23cddacb67d3de1b06add9766b5e3b879"
},
"calibration": null,
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description does not read as a device target (describe: native_gates lists the device's gates)"
}
},
"job": {
"id": "job-0",
"polls": 2
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.0,
"hellinger_fidelity": 1.0,
"sampling_tvd_expected": 0.019947114020071634,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": false,
"estimate": {
"unknown": "the provider gives no estimate"
},
"charged": null,
"confirmed": true
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "client",
"sent": {
"fields": [
"backend",
"params",
"program_id"
],
"settings": {
"/params/options/dynamical_decoupling/enable": false,
"/params/options/twirling/enable_gates": false,
"/params/options/twirling/enable_measure": false
}
},
"verbatim": false,
"note": "dynamical decoupling and twirling of gates and measurements are sent off; the request sets nothing for mitigation, remapping or optimisation, so the service's defaults stand; the program is sent on physical qubits in the backend's own gates",
"mitigation": "default",
"twirling": "default",
"decoupling": "off",
"remapping": "default",
"optimisation": "default"
},
"counts": {
"00": 200,
"11": 200
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "ee7cda3e0086a441525afe201c4e41683dfb8ba396a0abbdc9661b496717be8a",
"signature": "7e8ef63bb51d7e10590c8423e3115d08673c4c337e1170d01f1669f8883a93d97b5df4d8227444d9bdf5e86fab91d70043d7321c1f34fab4f74d025fe00d680d"
}
}
}

127
wai/quantum-conformance/receipts/jobs/crafted-kind-tasks-name-leading-zero.json Normal file
View file

@ -0,0 +1,127 @@
{
"status": "done",
"method": "provider",
"why": "on mine, cloud-tasks:Line (cloud-tasks): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 400,
"provider": "mine"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "measured",
"note": "counts from the processor the provider names, read as counts_source says (shot records, the provider's own counts, or counts rebuilt from probabilities); not reproducible by recomputation: the same job run again gives other counts, and no simulation stands in for them; what was set off at the provider, and what was left to its defaults, is in execution"
},
"shots": 400,
"provider": {
"name": "mine",
"kind": "cloud-tasks",
"protocol": "cloud-tasks",
"device": "cloud-tasks:Line",
"provenance": "silicon",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "4f18897e3839ecb995e7baa9eb493c654ef257b47f3056b3925be06cf1517964"
},
"calibration": "2026-11-05T00:00:00Z",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"qubit_names": {
"0": "4",
"1": "7",
"01": "x"
},
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description does not read as a device target (describe: native_gates lists the device's gates)"
}
},
"job": {
"id": "arn:task:0",
"polls": 0
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.0,
"hellinger_fidelity": 1.0,
"sampling_tvd_expected": 0.019947114020071634,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": false,
"estimate": {
"free": false,
"amount": "0.470000",
"currency": "USD",
"unit": "shot",
"note": "the device's price per shot, which its API states, and the service's fee per task of 0.30 USD, from its price list of 2026-11-05, which its API does not state"
},
"charged": null,
"confirmed": true
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "client",
"sent": {
"fields": [
"action",
"clientToken",
"deviceArn",
"outputS3Bucket",
"outputS3KeyPrefix",
"shots"
],
"settings": {
"verbatim_box": true
}
},
"verbatim": true,
"note": "the processor's gates go in the service's verbatim box on its physical qubits, so the service neither remaps nor optimises them; the task sets no device parameters, so mitigation, twirling and decoupling are the service's defaults",
"mitigation": "default",
"twirling": "default",
"decoupling": "default",
"remapping": "off",
"optimisation": "off"
},
"counts": {
"00": 200,
"11": 200
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "8a016562d8b1df385fccd9820223718a4122e51bdecd86eadec1011d7fa26748",
"signature": "b516fde68f000eecf4e4f0a34bb5ae54924f8f7b1891c9a8aa9348873c491d623f6f2ab526f84614fa1432840987b0c7148b86ccb8004166a308412e8fb94f06"
}
}
}

123
wai/quantum-conformance/receipts/jobs/crafted-kind-tasks-names-null.json Normal file
View file

@ -0,0 +1,123 @@
{
"status": "done",
"method": "provider",
"why": "on mine, cloud-tasks:Line (cloud-tasks): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 400,
"provider": "mine"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "measured",
"note": "counts from the processor the provider names, read as counts_source says (shot records, the provider's own counts, or counts rebuilt from probabilities); not reproducible by recomputation: the same job run again gives other counts, and no simulation stands in for them; what was set off at the provider, and what was left to its defaults, is in execution"
},
"shots": 400,
"provider": {
"name": "mine",
"kind": "cloud-tasks",
"protocol": "cloud-tasks",
"device": "cloud-tasks:Line",
"provenance": "silicon",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "4f18897e3839ecb995e7baa9eb493c654ef257b47f3056b3925be06cf1517964"
},
"calibration": "2026-11-05T00:00:00Z",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"qubit_names": null,
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description does not read as a device target (describe: native_gates lists the device's gates)"
}
},
"job": {
"id": "arn:task:0",
"polls": 0
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.0,
"hellinger_fidelity": 1.0,
"sampling_tvd_expected": 0.019947114020071634,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": false,
"estimate": {
"free": false,
"amount": "0.470000",
"currency": "USD",
"unit": "shot",
"note": "the device's price per shot, which its API states, and the service's fee per task of 0.30 USD, from its price list of 2026-11-05, which its API does not state"
},
"charged": null,
"confirmed": true
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "client",
"sent": {
"fields": [
"action",
"clientToken",
"deviceArn",
"outputS3Bucket",
"outputS3KeyPrefix",
"shots"
],
"settings": {
"verbatim_box": true
}
},
"verbatim": true,
"note": "the processor's gates go in the service's verbatim box on its physical qubits, so the service neither remaps nor optimises them; the task sets no device parameters, so mitigation, twirling and decoupling are the service's defaults",
"mitigation": "default",
"twirling": "default",
"decoupling": "default",
"remapping": "off",
"optimisation": "off"
},
"counts": {
"00": 200,
"11": 200
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "ff200a0bd771b0bc1c8497d893907bcf90085a18ff99c6c4a442565963cf019b",
"signature": "7957621c5af0f293f88aabed6712d7883c67f06a4776067e7a736ad314dcbe84441332b1acbf87f96581f9232bc67dc4da043af04a10b3b6f6a599e2ff2ccf0b"
}
}
}

126
wai/quantum-conformance/receipts/jobs/crafted-kind-tasks-names-short-of-text.json Normal file
View file

@ -0,0 +1,126 @@
{
"status": "done",
"method": "provider",
"why": "on mine, cloud-tasks:Line (cloud-tasks): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 400,
"provider": "mine"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "measured",
"note": "counts from the processor the provider names, read as counts_source says (shot records, the provider's own counts, or counts rebuilt from probabilities); not reproducible by recomputation: the same job run again gives other counts, and no simulation stands in for them; what was set off at the provider, and what was left to its defaults, is in execution"
},
"shots": 400,
"provider": {
"name": "mine",
"kind": "cloud-tasks",
"protocol": "cloud-tasks",
"device": "cloud-tasks:Line",
"provenance": "silicon",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "4f18897e3839ecb995e7baa9eb493c654ef257b47f3056b3925be06cf1517964"
},
"calibration": "2026-11-05T00:00:00Z",
"compiled": {
"basis": "rzsxxcz",
"program": "5bae13a719b91ebff41d268eebb83fd1b16d1048b1a25c1a55ef6e88501bad35",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\nx $2;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"qubit_names": {
"0": "4",
"1": "7"
},
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description does not read as a device target (describe: native_gates lists the device's gates)"
}
},
"job": {
"id": "arn:task:0",
"polls": 0
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.0,
"hellinger_fidelity": 1.0,
"sampling_tvd_expected": 0.019947114020071634,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": false,
"estimate": {
"free": false,
"amount": "0.470000",
"currency": "USD",
"unit": "shot",
"note": "the device's price per shot, which its API states, and the service's fee per task of 0.30 USD, from its price list of 2026-11-05, which its API does not state"
},
"charged": null,
"confirmed": true
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "client",
"sent": {
"fields": [
"action",
"clientToken",
"deviceArn",
"outputS3Bucket",
"outputS3KeyPrefix",
"shots"
],
"settings": {
"verbatim_box": true
}
},
"verbatim": true,
"note": "the processor's gates go in the service's verbatim box on its physical qubits, so the service neither remaps nor optimises them; the task sets no device parameters, so mitigation, twirling and decoupling are the service's defaults",
"mitigation": "default",
"twirling": "default",
"decoupling": "default",
"remapping": "off",
"optimisation": "off"
},
"counts": {
"00": 200,
"11": 200
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "784cccccedf14b1e8d405563a9641ec224d067ebec1c3b10b0598c75d288de52",
"signature": "4c9d215e18729eac140cff7c7580f54e61d44343b40487b3d9059a53dcd23fdd35ac04a434da149c7a2f283708ac12476e31cb56e2148afcb43a53f999898500"
}
}
}

122
wai/quantum-conformance/receipts/jobs/crafted-kind-tasks-no-names.json Normal file
View file

@ -0,0 +1,122 @@
{
"status": "done",
"method": "provider",
"why": "on mine, cloud-tasks:Line (cloud-tasks): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 400,
"provider": "mine"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "measured",
"note": "counts from the processor the provider names, read as counts_source says (shot records, the provider's own counts, or counts rebuilt from probabilities); not reproducible by recomputation: the same job run again gives other counts, and no simulation stands in for them; what was set off at the provider, and what was left to its defaults, is in execution"
},
"shots": 400,
"provider": {
"name": "mine",
"kind": "cloud-tasks",
"protocol": "cloud-tasks",
"device": "cloud-tasks:Line",
"provenance": "silicon",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "4f18897e3839ecb995e7baa9eb493c654ef257b47f3056b3925be06cf1517964"
},
"calibration": "2026-11-05T00:00:00Z",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description does not read as a device target (describe: native_gates lists the device's gates)"
}
},
"job": {
"id": "arn:task:0",
"polls": 0
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.0,
"hellinger_fidelity": 1.0,
"sampling_tvd_expected": 0.019947114020071634,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": false,
"estimate": {
"free": false,
"amount": "0.470000",
"currency": "USD",
"unit": "shot",
"note": "the device's price per shot, which its API states, and the service's fee per task of 0.30 USD, from its price list of 2026-11-05, which its API does not state"
},
"charged": null,
"confirmed": true
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "client",
"sent": {
"fields": [
"action",
"clientToken",
"deviceArn",
"outputS3Bucket",
"outputS3KeyPrefix",
"shots"
],
"settings": {
"verbatim_box": true
}
},
"verbatim": true,
"note": "the processor's gates go in the service's verbatim box on its physical qubits, so the service neither remaps nor optimises them; the task sets no device parameters, so mitigation, twirling and decoupling are the service's defaults",
"mitigation": "default",
"twirling": "default",
"decoupling": "default",
"remapping": "off",
"optimisation": "off"
},
"counts": {
"00": 200,
"11": 200
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "8e2e3610308bc46034a4a07be586f3221902b104604b8992bc12fa2a700dae96",
"signature": "d7b4cde297a98abb049d51351e9b372c4cb9045829a5fe5d3f862357331fc66ab00d22ce02c66fe7bee3d793084dbe27cfa30b2f9ffdc75bd8fb9fccc1811004"
}
}
}

126
wai/quantum-conformance/receipts/jobs/crafted-kind-tasks-processor-unboxed.json Normal file
View file

@ -0,0 +1,126 @@
{
"status": "done",
"method": "provider",
"why": "on mine, cloud-tasks:Line (cloud-tasks): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 400,
"provider": "mine"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "measured",
"note": "counts from the processor the provider names, read as counts_source says (shot records, the provider's own counts, or counts rebuilt from probabilities); not reproducible by recomputation: the same job run again gives other counts, and no simulation stands in for them; what was set off at the provider, and what was left to its defaults, is in execution"
},
"shots": 400,
"provider": {
"name": "mine",
"kind": "cloud-tasks",
"protocol": "cloud-tasks",
"device": "cloud-tasks:Line",
"provenance": "silicon",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "4f18897e3839ecb995e7baa9eb493c654ef257b47f3056b3925be06cf1517964"
},
"calibration": "2026-11-05T00:00:00Z",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"qubit_names": {
"0": "4",
"1": "7"
},
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description does not read as a device target (describe: native_gates lists the device's gates)"
}
},
"job": {
"id": "arn:task:0",
"polls": 0
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.0,
"hellinger_fidelity": 1.0,
"sampling_tvd_expected": 0.019947114020071634,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": false,
"estimate": {
"free": false,
"amount": "0.470000",
"currency": "USD",
"unit": "shot",
"note": "the device's price per shot, which its API states, and the service's fee per task of 0.30 USD, from its price list of 2026-11-05, which its API does not state"
},
"charged": null,
"confirmed": true
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "client",
"sent": {
"fields": [
"action",
"clientToken",
"deviceArn",
"outputS3Bucket",
"outputS3KeyPrefix",
"shots"
],
"settings": {
"verbatim_box": true
}
},
"verbatim": false,
"note": "the processor's gates go in the service's verbatim box on its physical qubits, so the service neither remaps nor optimises them; the task sets no device parameters, so mitigation, twirling and decoupling are the service's defaults",
"mitigation": "default",
"twirling": "default",
"decoupling": "default",
"remapping": "off",
"optimisation": "off"
},
"counts": {
"00": 200,
"11": 200
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "6b3d84a5949f1c2f311ab7939b28ced42e82b5100d2f97d20c7f2e27087625c4",
"signature": "2600b145497eba0b4f2f7f483c891f619f75df4ff661a11ca6af6ea0c3491d14345d54363ec14a9ac58a5eed72b44dd3b24ce991b8f2f537d125e8392502c80a"
}
}
}

127
wai/quantum-conformance/receipts/jobs/crafted-kind-tasks-simulator-boxed.json Normal file
View file

@ -0,0 +1,127 @@
{
"status": "done",
"method": "provider",
"why": "on mine, cloud-tasks:SIM (cloud-tasks): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 400,
"provider": "mine"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 400,
"provider": {
"name": "mine",
"kind": "cloud-tasks",
"protocol": "cloud-tasks",
"device": "cloud-tasks:SIM",
"provenance": "simulator:the service's SIM simulator",
"qubits": 34,
"basis": "rzsxxcz",
"describe": "d052d88256742b435f059d894f7ef4287325f0516a445bd0d689a4e2c4157deb"
},
"calibration": "2026-11-05T00:00:00Z",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"qubit_names": {
"0": "0",
"1": "1"
},
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description does not read as a device target (describe: native_gates lists the device's gates)"
}
},
"job": {
"id": "arn:task:0",
"polls": 0
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.0,
"hellinger_fidelity": 1.0,
"sampling_tvd_expected": 0.019947114020071634,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": false,
"estimate": {
"free": false,
"amount": "0.003750",
"currency": "USD",
"unit": "minute",
"note": "the device's price for its three-second minimum, at least; the time a task takes is not known before it runs",
"at_least": true
},
"charged": null,
"confirmed": true
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "client",
"sent": {
"fields": [
"action",
"clientToken",
"deviceArn",
"outputS3Bucket",
"outputS3KeyPrefix",
"shots"
],
"settings": {
"verbatim_box": true
}
},
"verbatim": true,
"note": "the processor's gates go in the service's verbatim box on its physical qubits, so the service neither remaps nor optimises them; the task sets no device parameters, so mitigation, twirling and decoupling are the service's defaults",
"mitigation": "default",
"twirling": "default",
"decoupling": "default",
"remapping": "off",
"optimisation": "off"
},
"counts": {
"00": 200,
"11": 200
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "93c46b86f6a3f184c8952bcb856fcc7e5cff9c22d9e8a67ecd5035914e3efdd9",
"signature": "1bc1688bad4b491825ba275c12857bcea607daedc1a9218bc97139eff311d5c7dc84d6f32d464a27bf62b0e1d39c3454fbe1cad6c458beb0dd647e8c213d7a0f"
}
}
}

126
wai/quantum-conformance/receipts/jobs/crafted-kind-tasks-vendor-counts.json Normal file
View file

@ -0,0 +1,126 @@
{
"status": "done",
"method": "provider",
"why": "on mine, cloud-tasks:Line (cloud-tasks): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 400,
"provider": "mine"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "measured",
"note": "counts from the processor the provider names, read as counts_source says (shot records, the provider's own counts, or counts rebuilt from probabilities); not reproducible by recomputation: the same job run again gives other counts, and no simulation stands in for them; what was set off at the provider, and what was left to its defaults, is in execution"
},
"shots": 400,
"provider": {
"name": "mine",
"kind": "cloud-tasks",
"protocol": "cloud-tasks",
"device": "cloud-tasks:Line",
"provenance": "silicon",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "4f18897e3839ecb995e7baa9eb493c654ef257b47f3056b3925be06cf1517964"
},
"calibration": "2026-11-05T00:00:00Z",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"qubit_names": {
"0": "4",
"1": "7"
},
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description does not read as a device target (describe: native_gates lists the device's gates)"
}
},
"job": {
"id": "arn:task:0",
"polls": 0
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.0,
"hellinger_fidelity": 1.0,
"sampling_tvd_expected": 0.019947114020071634,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": false,
"estimate": {
"free": false,
"amount": "0.470000",
"currency": "USD",
"unit": "shot",
"note": "the device's price per shot, which its API states, and the service's fee per task of 0.30 USD, from its price list of 2026-11-05, which its API does not state"
},
"charged": null,
"confirmed": true
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "vendor_counts",
"execution": {
"stated_by": "client",
"sent": {
"fields": [
"action",
"clientToken",
"deviceArn",
"outputS3Bucket",
"outputS3KeyPrefix",
"shots"
],
"settings": {
"verbatim_box": true
}
},
"verbatim": true,
"note": "the processor's gates go in the service's verbatim box on its physical qubits, so the service neither remaps nor optimises them; the task sets no device parameters, so mitigation, twirling and decoupling are the service's defaults",
"mitigation": "default",
"twirling": "default",
"decoupling": "default",
"remapping": "off",
"optimisation": "off"
},
"counts": {
"00": 200,
"11": 200
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "9883d3dd925c68b101a72180e2159ab69f59fce1c2c22900b1c0af9e6c9a9660",
"signature": "e2b8c69980fd755bb0e15673bf3807da765ae605a75ead11ba7669b8e1b4b487e9cdd5395c34266a33b911e70a3dec353a9f03c949185fa87e7f2e32ec9e940b"
}
}
}

120
wai/quantum-conformance/receipts/jobs/crafted-kind-turns-shots.json Normal file
View file

@ -0,0 +1,120 @@
{
"status": "done",
"method": "provider",
"why": "on mine, native-turns:simulator (native-turns): compiled exactly to gpizz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 400,
"provider": "mine"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 400,
"provider": {
"name": "mine",
"kind": "native-turns",
"protocol": "native-turns",
"device": "native-turns:simulator",
"provenance": "simulator:native-turns simulator, noise ideal",
"qubits": 8,
"basis": "gpizz",
"describe": "93a83ea1002d3b86cfd40a37a5b7db3b3e4f4e39ef2bfac05e248495e2c24278"
},
"calibration": null,
"compiled": {
"basis": "gpizz",
"program": "7bfa03b310e68ffe2cf1357652f9e6dadd812c852855b3ba0f2864943bbea9ff",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\ngate gpi(phi) a { rz(-2*pi*phi) a; x a; rz(2*pi*phi) a; }\ngate gpi2(phi) a { rz(-2*pi*phi) a; rx(pi/2) a; rz(2*pi*phi) a; }\ngate zz(theta) a, b { cx a, b; rz(2*pi*theta) b; cx a, b; }\nbit[2] c;\ngpi2(0.75) $0;\ngpi2(0.75) $1;\nzz(0.25) $0, $1;\ngpi2(0.5) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 4,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description does not read as a device target (describe: native_gates lists the device's gates)"
}
},
"job": {
"id": "turns-0",
"polls": 0
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.0,
"hellinger_fidelity": 1.0,
"sampling_tvd_expected": 0.019947114020071634,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": false,
"estimate": {
"unknown": "the provider gives no estimate"
},
"charged": null,
"confirmed": true
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait",
"service_kwh": 0.0,
"service_kwh_is": "the provider's own figure, not a measurement here"
},
"counts_source": "shots",
"execution": {
"stated_by": "client",
"sent": {
"fields": [
"backend",
"input",
"settings",
"shots",
"type"
],
"settings": {
"/input/gateset": "native",
"/settings/error_mitigation/debiasing": false
}
},
"verbatim": false,
"note": "debiasing is sent off and the program goes in the service's native gate set; the request sets nothing for twirling, decoupling, remapping or optimisation, so the service's defaults stand",
"mitigation": "off",
"twirling": "default",
"decoupling": "default",
"remapping": "default",
"optimisation": "default"
},
"counts": {
"00": 200,
"11": 200
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "d09075254a3f802a1ad8faabf962b9907cfad9dfdc9a21d70b23a490ee24f22f",
"signature": "7a4991206d0dbbe67a2140f7b477fc0bbf09d67f60b946ebc737a2c12840a07a8515a7901ce6cb73a7ad089422e5a54f223ba53144d4dce7da4335732fc5c005"
}
}
}

61
wai/quantum-conformance/receipts/jobs/crafted-method-class-unknown.json Normal file
View file

@ -0,0 +1,61 @@
{
"status": "done",
"method": "stabilizer",
"why": "Clifford circuit: the stabilizer tableau of 2 qubits",
"estimate": {
"memory_bytes": 67172870,
"work": 2016
},
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 1000,
"seed": 7,
"observables": [
"Z0 Z1",
"X0"
]
},
"result": {
"method": "stabilizer",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "quasi-exact"
},
"counts": {
"11": 505,
"00": 495
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"outcome_dimension": 1,
"expectations": [
{
"observable": "Z0 Z1",
"coeff": 1.0,
"value": 1.0
},
{
"observable": "X0",
"coeff": 1.0,
"value": 0.0
}
],
"elapsed_ms": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"energy": {
"unmetered": "the command line does not meter a run's energy"
},
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "3d5a689240f1cacd169bddfd7db35ce77af605dcfbe65777e233946470eacf97",
"signature": "480b1181eb0e3acdbbd20fef80fbecf68deb37921900c04d76ec0ef91ac0040df00ad2ac47517eb88a8df8266dcf11005886e79e0b8a50c36e51cd320d107f01"
}
}
}

61
wai/quantum-conformance/receipts/jobs/crafted-method-measured.json Normal file
View file

@ -0,0 +1,61 @@
{
"status": "done",
"method": "stabilizer",
"why": "Clifford circuit: the stabilizer tableau of 2 qubits",
"estimate": {
"memory_bytes": 67172870,
"work": 2016
},
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 1000,
"seed": 7,
"observables": [
"Z0 Z1",
"X0"
]
},
"result": {
"method": "stabilizer",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "measured"
},
"counts": {
"11": 505,
"00": 495
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"outcome_dimension": 1,
"expectations": [
{
"observable": "Z0 Z1",
"coeff": 1.0,
"value": 1.0
},
{
"observable": "X0",
"coeff": 1.0,
"value": 0.0
}
],
"elapsed_ms": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"energy": {
"unmetered": "the command line does not meter a run's energy"
},
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "42a25dcb02ba434508276e951bff188ddcdf89d55683f3fd508d9d65b714d3e1",
"signature": "14997c952486fe7b3916d03fbd8a9fc8b5e8d47803984ce76280eb05b204ae803c333801818ea44263569c9548c470a5ed37ffbbcfc0a91d11cfd5299cf70406"
}
}
}

61
wai/quantum-conformance/receipts/jobs/crafted-method-simulated.json Normal file
View file

@ -0,0 +1,61 @@
{
"status": "done",
"method": "stabilizer",
"why": "Clifford circuit: the stabilizer tableau of 2 qubits",
"estimate": {
"memory_bytes": 67172870,
"work": 2016
},
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 1000,
"seed": 7,
"observables": [
"Z0 Z1",
"X0"
]
},
"result": {
"method": "stabilizer",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated"
},
"counts": {
"11": 505,
"00": 495
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"outcome_dimension": 1,
"expectations": [
{
"observable": "Z0 Z1",
"coeff": 1.0,
"value": 1.0
},
{
"observable": "X0",
"coeff": 1.0,
"value": 0.0
}
],
"elapsed_ms": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"energy": {
"unmetered": "the command line does not meter a run's energy"
},
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "ae019cf1502a8829b7fd693f5a5a61afc0e4fa7929388d3079351d8b8fa1cdf4",
"signature": "1bca0b0ee08e2ed1d8cd4c217d7bae76c1f6d1b11a7262517146164658f8df01d84fd0303404a15c2518f5c1a57349bff5e8603b83682189b44a76e306f4210e"
}
}
}

25
wai/quantum-conformance/receipts/jobs/crafted-number-canonical-spelling.json Normal file
View file

@ -0,0 +1,25 @@
{
"request": {
"qasm": "OPENQASM 3.0;",
"observables": [
{
"pauli": "Z0",
"coeff": 1152921504606847000
}
]
},
"result": {
"method": "statevector",
"accuracy": {
"class": "exact"
},
"x": 1152921504606847000,
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "eb498c98ce62608edcab5016e3af0c94c70d65b3beecbae8ba2e84a505254243",
"signature": "41c70f03324932ca36662a4a2901109774d73cb362c76130f17e217cdacb242fec2922140d66847bc0c384c200ea58501a01966e5f89f6ce8ac94072f886a907"
}
}
}

25
wai/quantum-conformance/receipts/jobs/crafted-number-exact-spelling.json Normal file
View file

@ -0,0 +1,25 @@
{
"request": {
"qasm": "OPENQASM 3.0;",
"observables": [
{
"pauli": "Z0",
"coeff": 1152921504606846976
}
]
},
"result": {
"method": "statevector",
"accuracy": {
"class": "exact"
},
"x": 1152921504606846976,
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "eb498c98ce62608edcab5016e3af0c94c70d65b3beecbae8ba2e84a505254243",
"signature": "41c70f03324932ca36662a4a2901109774d73cb362c76130f17e217cdacb242fec2922140d66847bc0c384c200ea58501a01966e5f89f6ce8ac94072f886a907"
}
}
}

25
wai/quantum-conformance/receipts/jobs/crafted-number-exponent-spelling.json Normal file
View file

@ -0,0 +1,25 @@
{
"request": {
"qasm": "OPENQASM 3.0;",
"observables": [
{
"pauli": "Z0",
"coeff": 1.152921504606847e+18
}
]
},
"result": {
"method": "statevector",
"accuracy": {
"class": "exact"
},
"x": 1.152921504606847e+18,
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "eb498c98ce62608edcab5016e3af0c94c70d65b3beecbae8ba2e84a505254243",
"signature": "41c70f03324932ca36662a4a2901109774d73cb362c76130f17e217cdacb242fec2922140d66847bc0c384c200ea58501a01966e5f89f6ce8ac94072f886a907"
}
}
}

19
wai/quantum-conformance/receipts/jobs/crafted-number-inexact-past-u64.json Normal file
View file

@ -0,0 +1,19 @@
{
"request": {
"qasm": "OPENQASM 3.0;",
"seed": 18446744073709551617
},
"result": {
"method": "statevector",
"accuracy": {
"class": "exact"
},
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "3c06347b7aa7d697eaa206e237179ee68b67bbceba8e196fbefbb99c3c122c37",
"signature": "528dcb256af682e5ebf4c734b850b93c6151d4fa5b4ba25f1ea22abb6697d29e106c13c7fe5b0afcc7a182669b46bda06831a8a6e739dd0e49ecd01927e43401"
}
}
}

62
wai/quantum-conformance/receipts/jobs/crafted-number-inexact-unsealed.json Normal file
View file

@ -0,0 +1,62 @@
{
"status": "done",
"method": "stabilizer",
"why": "Clifford circuit: the stabilizer tableau of 2 qubits",
"estimate": {
"memory_bytes": 67172870,
"work": 2016
},
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 1000,
"seed": 7,
"observables": [
"Z0 Z1",
"X0"
]
},
"result": {
"method": "stabilizer",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "exact"
},
"counts": {
"11": 505,
"00": 495
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"outcome_dimension": 1,
"expectations": [
{
"observable": "Z0 Z1",
"coeff": 1.0,
"value": 1.0
},
{
"observable": "X0",
"coeff": 1.0,
"value": 0.0
}
],
"elapsed_ms": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"energy": {
"unmetered": "the command line does not meter a run's energy"
},
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "d4eaa3cf71da3405192198a7297a653644d773dc3e94761cda44b84eff45ffd1",
"signature": "7cd39fd1eacf313bfd17db9cce2d93aba8ff8ca1900de2a67a5b2770ea705e7e4fca420f222d4e3a4c5a7888b121de283abbd59aabc56d3a9d9164b7d8a62306",
"x": 9007199254740993
}
}
}

19
wai/quantum-conformance/receipts/jobs/crafted-number-inexact.json Normal file
View file

@ -0,0 +1,19 @@
{
"request": {
"qasm": "OPENQASM 3.0;"
},
"result": {
"method": "statevector",
"accuracy": {
"class": "exact"
},
"x": 9007199254740993,
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "e8a66f8c172e999ece19cf286b198df2038b2e6e3ce2d5c204061296f9fcde83",
"signature": "053080cb8ca0ead84fbb3e75c6e069b416f74b7523786411b5ed0f52a33d1c0483a0f07cb894901130022e910f1f592e5c2fc5c20666e3a89cbeafc4c8785502"
}
}
}

25
wai/quantum-conformance/receipts/jobs/crafted-number-near-canonical.json Normal file
View file

@ -0,0 +1,25 @@
{
"request": {
"qasm": "OPENQASM 3.0;",
"observables": [
{
"pauli": "Z0",
"coeff": 1152921504606847001
}
]
},
"result": {
"method": "statevector",
"accuracy": {
"class": "exact"
},
"x": 1152921504606847001,
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "eb498c98ce62608edcab5016e3af0c94c70d65b3beecbae8ba2e84a505254243",
"signature": "41c70f03324932ca36662a4a2901109774d73cb362c76130f17e217cdacb242fec2922140d66847bc0c384c200ea58501a01966e5f89f6ce8ac94072f886a907"
}
}
}

25
wai/quantum-conformance/receipts/jobs/crafted-number-padded-past.json Normal file
View file

@ -0,0 +1,25 @@
{
"request": {
"qasm": "OPENQASM 3.0;",
"observables": [
{
"pauli": "Z0",
"coeff": 1152921504606847000000
}
]
},
"result": {
"method": "statevector",
"accuracy": {
"class": "exact"
},
"x": 1152921504606847000000,
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "fae4eeb2b5f749bfbd0088d5058e3cb989a507797525f0b17e482f97a67d71f6",
"signature": "467aa73214601634746aa31d69b5599255afc8ccf146fe9e611a85efb5f2797618dfa8d7dd7b84cc56171326c902440d2c575bb36c8e2814c534df9d62fcac03"
}
}
}

111
wai/quantum-conformance/receipts/jobs/crafted-provider-approximate-false.json Normal file
View file

@ -0,0 +1,111 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would",
"approximate": false
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "53a24c80734c29ba8e177d22544d9ca1493f49dd19703e3d9a5062040253afbb",
"signature": "390965477851b9be6e624aef2018e97407238f2e7652a9a067e934c0f3988380834973f9a6d3a68faeac8e5d694bdef1b3d73ae6548f2ca46c4d158f7765dc0a"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

111
wai/quantum-conformance/receipts/jobs/crafted-provider-approximate-processor.json Normal file
View file

@ -0,0 +1,111 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "measured",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would",
"approximate": true
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "silicon",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "a0170c7dadc4781f41f9c525243c6c53473a7c7ef94a88fc4269fad9fa6664ac",
"signature": "b5444fd3d2e702cd8634773c085fa5f4bad1e40298d2064c723bd0717eedf2be2c2f7c2b7485eea6d9d7ad902e86f764cc8836c9d6e9163337f4beb06ab90108"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

111
wai/quantum-conformance/receipts/jobs/crafted-provider-approximate-simulator.json Normal file
View file

@ -0,0 +1,111 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would",
"approximate": true
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "ffcfa88daa4929744766d35392b3bf7fdbcf51e97878cdb19fdbeae1a626172a",
"signature": "f0f689b80558d1d821c9813c71d0828a397f38b7108bbc42064551a22dad8bacd77b75addbc96c9a16453e1625e37766e7a0c278de912df3b079cb5dfdfa4101"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

110
wai/quantum-conformance/receipts/jobs/crafted-provider-compiled-program.json Normal file
View file

@ -0,0 +1,110 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n// another program\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "dbbdd8d7770713a255219dacaf17bfa9bedbabd9fddd2bfd35d2fb33740e6055",
"signature": "6f7b9b1ac5cca2ed75c9358a36e9d6f411d2ce504900fd92535f53bfa0608e5e95197eeac065a438ca24c6d9317970e396634ac103a6d982fb718c7930d8a206"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

110
wai/quantum-conformance/receipts/jobs/crafted-provider-cost-free-confirmed.json Normal file
View file

@ -0,0 +1,110 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": true
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "416894d65a09f434ab45e7e1d309df13687edb32f22a699ab8beb905af55336e",
"signature": "15e91db43a12da7eb208084b23f1002957c424beb9e29e414920acc35c78554c1d40e7404e627a7dc16a91ce0b462995bf8652c7f2d985d73ff4fd10d1b1ea0f"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

110
wai/quantum-conformance/receipts/jobs/crafted-provider-cost-unconfirmed.json Normal file
View file

@ -0,0 +1,110 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": false,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "abb478f903b50347fbace67ac93b52a749145473ff7608d7da610b706d98b556",
"signature": "14371789a598adf18bad0d815b0370a42c3c4943cdcb8cfb11e4333c56db1da474412f7339fc6a24da14aaf584b79c187c3762494848ea248fb75e9690bcae09"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

109
wai/quantum-conformance/receipts/jobs/crafted-provider-count-past-safe.json Normal file
View file

@ -0,0 +1,109 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 9007199254740992,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 9007199254740992,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"00": 9007199254740992
},
"distinct_outcomes": 1,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "1f3a3a5b7949ced04e4e00758cffd058f7969b5e61ea43928224b1a360f56b95",
"signature": "b62e1fa9a993348855e06ff555e325da1f6df3e743a293347e1c48166f7ae383ab1706e2c763d9af915ccb8dd65e471ba620f02e8388318996bc0fbd5af6aa00"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

110
wai/quantum-conformance/receipts/jobs/crafted-provider-counts-distinct.json Normal file
View file

@ -0,0 +1,110 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 3,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "b4e11e0fda32a94594634c874107cdea57a7db0b920317238eed4e1ed21610b7",
"signature": "eab21b089bb99f715ed2dd8beeb2f857bd8bb9f26a04258f009e2023670c1a94471e987b9a542aabc936d0444d016fea76ec9685454fc4c0ae5d8ac549513206"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

110
wai/quantum-conformance/receipts/jobs/crafted-provider-counts-hidden.json Normal file
View file

@ -0,0 +1,110 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 1,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 160,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "6ddeab08025ea957926fb546a2990a96a3f0de50d1e2e4132f26cdf20cbec1f7",
"signature": "341faa8cac441b2027ec22e9d1fee325789d82d5adc86a22855a265b488c2498ff1b43b50be0243706a7e55360d75e48cf9f916118f11fc494c2e1cff1e46e04"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

110
wai/quantum-conformance/receipts/jobs/crafted-provider-counts-source-other.json Normal file
View file

@ -0,0 +1,110 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "estimated",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "e68d2efb118571f878bb785f009995bdfdbfee27cf9145ddb923a87697372d52",
"signature": "77545691059a152b805cd4db00032c6716219f8e370b9983e0029e29b632e2c951b0e6fcab36f8a26f0e1f172c794b83a206d5ef54488fab17925580dc85cb06"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

110
wai/quantum-conformance/receipts/jobs/crafted-provider-counts-sum.json Normal file
View file

@ -0,0 +1,110 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 162,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "8d4168defab76623a89b778ee4d676558c5885b2720d6fa72414d5f55327b0f5",
"signature": "cfec72fdb01f209a6d6ff905129cddfe8021fe354d9ce9a963e42d3650511f65ac9ba5802d3200d1a4d4be90ba6fdfcf67939867b87e9fb1a3da33ce9c490b09"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

110
wai/quantum-conformance/receipts/jobs/crafted-provider-counts-width.json Normal file
View file

@ -0,0 +1,110 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"00": 139,
"011": 161
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "9d84105009ef5704e1dfbe19ddbdd78528f2ea0371aed06b10e2a54c73deec8d",
"signature": "aea6cf228fff6dace4986ecb73e1b693795613c9c0ddb7a39f5fec5902f8c6e668ca0d1499a7e4ba97f09d35b1a256f0338dac4f554003107c788657b6a84202"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

111
wai/quantum-conformance/receipts/jobs/crafted-provider-counts-zero.json Normal file
View file

@ -0,0 +1,111 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 161,
"00": 139,
"01": 0
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "6e0f7612ef1b19d005069efc02b9b83807bb1cb6cda4f42a3e6e4d365696db03",
"signature": "76554df3f58f3fefa8af77272f24fc43c0f06197c666932079f0d2cb5c1becd07f33eea2d56b2b8fe325259b2ef324171f739c42be7da3943ff5fd2b9cdbf407"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

118
wai/quantum-conformance/receipts/jobs/crafted-provider-execution-client-open.json Normal file
View file

@ -0,0 +1,118 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "client",
"sent": {
"fields": [
"op",
"program",
"protocol",
"shots"
],
"settings": {}
},
"mitigation": "default",
"twirling": "default",
"decoupling": "default",
"remapping": "default",
"optimisation": "default",
"verbatim": false
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "831db22daa6075dab614cce2c256408ff8f0271d489a95aa3e452cc27431980c",
"signature": "d9efaf8f21a457763fb3cbc4d00c0f1b4612a5959af8b2345f39432e6f8836658aca06bbe57327578952788e7a0368fd8a4589062a594fb611d483a67c158a0b"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

110
wai/quantum-conformance/receipts/jobs/crafted-provider-execution-default.json Normal file
View file

@ -0,0 +1,110 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "default",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "5197193ff6270400bb6f4461f6ec593b96e390137331316bd20a2efc38a56ee8",
"signature": "b5806d30ca2e50d38d0a69a0a154d79b66b53b2d8fbb5914f28d47f9629ae36b4aa7c411fb70651cba28fcac6b38e1852e7a330d32e1725ae892bef61548460a"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

111
wai/quantum-conformance/receipts/jobs/crafted-provider-execution-member.json Normal file
View file

@ -0,0 +1,111 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing",
"routing": "off"
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "128bc0e89aec43cca7eca18f568949dfa3e92831fe69b1e4aa6811c37eca618a",
"signature": "79c5b7b5b6a6227c03b8da2de19ecb79959cfc05e6a75606b69f88a331c0eba340d29c447d7aaad1416ba2683e4826f9ef8689e94f764951ccb1e5ed9a4a2e06"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

109
wai/quantum-conformance/receipts/jobs/crafted-provider-execution-nobody.json Normal file
View file

@ -0,0 +1,109 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "nobody",
"mitigation": "unknown",
"twirling": "unknown",
"decoupling": "unknown",
"remapping": "unknown",
"optimisation": "unknown",
"verbatim": null
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "63867279cdd62766e2f33c28b88c0375002ff9e3b8ca02ae6637eaca076077c4",
"signature": "5e680a5eb6b4d30fe5f475a5fd0e4226edbe17c6951c7b4e11ac5e55660c01774c8af75baeb13f488e5c1bfa73fe4cd4f4c942c8128a3bd04e68ca4752b5b502"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

114
wai/quantum-conformance/receipts/jobs/crafted-provider-execution-sent.json Normal file
View file

@ -0,0 +1,114 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing",
"sent": {
"fields": [],
"settings": {}
}
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "2ef0bb61fcc0696f9e6b9af9f0da91d19cdcabdaa353493b5789d786603749b4",
"signature": "92c66c6e65bafd6a7280a47e429953d73106591557bc62dd26959689d852ad54dedf4e811fa204bdd700380a7a551e95162be75535dfe46bc209654719fbfe0a"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

110
wai/quantum-conformance/receipts/jobs/crafted-provider-execution-verbatim-remapped.json Normal file
View file

@ -0,0 +1,110 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "on",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "8e35f338722b0821d5a5a0713d355506293a536f7ae37414c5c4c5d365979f32",
"signature": "f96207f0db94318aeede85cfd6b4e672e945032bb57a7693045b590ef86fb9807d4f0eeaf788e16c1bcafc0248e372862caac9f68a0bd1ae3f44fa52ee07050e"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

110
wai/quantum-conformance/receipts/jobs/crafted-provider-measured-simulator.json Normal file
View file

@ -0,0 +1,110 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "measured",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "6524c9ea6f565cbe2ff62f26ded9dfaf34b7648e0d545cce552c0b865c3aa686",
"signature": "6957ee0c7c8943dfb15a8842e7905eb6108eeab1faf742b3fa90908db7715c3f3c3598791d92ea91376725db736333313693f93ed7617370e5fd02f704a1ff04"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

110
wai/quantum-conformance/receipts/jobs/crafted-provider-members-basis.json Normal file
View file

@ -0,0 +1,110 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "gpizz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "288a58d62f269e89c6f8173402f529f436a9a2ccd6720ba9676d0bb18b64fdbd",
"signature": "31bd8f0d729389a35093f4df742c3a2ac1f121d7d21cb6a6f25a0cab855bf0defa7c2d5fc944a371f80d88ab3378249397c49e526b1e190f34fda7d5e13cea09"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

110
wai/quantum-conformance/receipts/jobs/crafted-provider-members-describe.json Normal file
View file

@ -0,0 +1,110 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0A802ECD608FB5BCA73C5A22FF65B5A08A408416501BB5472986F6540FF91AC0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "52d70a3b6fe93eb44ae03882a764960bcc1eb2fdf7d4f422b9858e69aa852a2e",
"signature": "9830c7b6da35f20d3d4102e3ec4d0af9f7fb5de5805cdfdaa759071894d51bdaa38e58cc746253852dd8947c3d8bec99b4ea29aacb790ba8dca118d166dcca0e"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

110
wai/quantum-conformance/receipts/jobs/crafted-provider-members-energy.json Normal file
View file

@ -0,0 +1,110 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"joules": 1
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "80e568e4d5790e83948f1f5f0f71bbfa990883b808ab667546ffcafd980dd422",
"signature": "e1b621c0f312d7e4715b54cfc26e6a7c3fc209b2278fcfc7fd36b9ffb09f6f75182421b7fc6e870e888114077877372067bd1e2cbd22bd4c863e3e49c2efc706"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

111
wai/quantum-conformance/receipts/jobs/crafted-provider-members-kwh-unlabelled.json Normal file
View file

@ -0,0 +1,111 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait",
"service_kwh": 0.001
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "cc72f69cda6ae55ce068d645ca844961b7ea385aab25335b9f0cbb4596a6c505",
"signature": "36ab084f44e689a63684c9b6ace0d72d4e78c4a1c50a56e2e199fdb7fe65047668f83ee49233e58d5c3876c0caba4bc13670917f2f1237f76984f2a7d1885207"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

109
wai/quantum-conformance/receipts/jobs/crafted-provider-members-no-charged.json Normal file
View file

@ -0,0 +1,109 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "e1eefde445b25fc90b5f868d7e7dc1eae29e66e5c75d2a52fd3eadb81dbaf89a",
"signature": "f4c83e613e7ef3ec05168e12d00a238c000631b9d89feb684dbb909684714ee073d9d989f0ec2cb6de525a609e5e55498d92253590dccfe704786c770c53d101"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

109
wai/quantum-conformance/receipts/jobs/crafted-provider-members-no-qasm3.json Normal file
View file

@ -0,0 +1,109 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "0a6a07f5611128567616488705b97eacecb4f2d8a406e3dad0906ddac8c84d0f",
"signature": "af5175fcde8335f080b71fe658cbdca248062f1a20f5dcab4aa7a99c26fa5553398a45e2530e830500eed002e974b42a425c92e939348044c32e194116dd5d0f"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

109
wai/quantum-conformance/receipts/jobs/crafted-provider-members-no-schema.json Normal file
View file

@ -0,0 +1,109 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "simulator:the wai-quantum exact simulator: the state vector in fixed point, sampled with the seed given",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "df75644499c9ba9df7d63cd5a82adb372fba8db0cb490f38beb5dd70ea19c383",
"signature": "0498f9fd724c41b186009df51b4b3bde9123d5c99ca14107941e628176ab20629679f149dcb7e4f81c784a8a98777d02ea4fa6a72c63bcf04d11338999493c05"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

110
wai/quantum-conformance/receipts/jobs/crafted-provider-provenance-unknown.json Normal file
View file

@ -0,0 +1,110 @@
{
"status": "done",
"method": "provider",
"why": "on ref, reference:line-5 (wai.quantum.provider/1): compiled exactly to rzsxxcz on its qubits and checked by simulation here before it was sent",
"request": {
"qasm": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nqubit[2] q;\nbit[2] c;\nh q[0];\ncx q[0], q[1];\nc = measure q;\n",
"shots": 300,
"seed": 4,
"provider": "ref"
},
"result": {
"method": "provider",
"qubits": 2,
"gates": 2,
"accuracy": {
"class": "simulated",
"note": "counts from the provider's simulator or emulator, as provider.provenance names it, not measured on any device: classical software's sample of the program, read as counts_source says; they show what that software gives, under whatever noise it models, not what a device would"
},
"shots": 300,
"provider": {
"name": "ref",
"kind": "process",
"protocol": "wai.quantum.provider/1",
"device": "reference:line-5",
"provenance": "fpga",
"qubits": 5,
"basis": "rzsxxcz",
"describe": "0a802ecd608fb5bca73c5a22ff65b5a08a408416501bb5472986f6540ff91ac0"
},
"calibration": "reference-f2d9fe570421",
"compiled": {
"basis": "rzsxxcz",
"program": "b96b3d2e44387bac1dab89e43e29706788b0b6ed721f88d5c0f64be293c72df9",
"hash": "BLAKE3 of the program's OpenQASM 3 text, qasm3",
"qasm3": "OPENQASM 3.0;\ninclude \"stdgates.inc\";\nbit[2] c;\nrz(pi/2) $0;\nsx $0;\nrz(pi/2) $1;\nsx $1;\ncz $0, $1;\nrz(pi) $1;\nsx $1;\nrz(pi/2) $0;\nrz(pi/2) $1;\nc[0] = measure $0;\nc[1] = measure $1;\n",
"native_gates": 9,
"two_qubit_gates": 1,
"swaps": 0,
"layout": [
0,
1
],
"final_layout": [
0,
1
],
"checked": "the compiled program's final state equals the circuit's, each logical qubit on the physical qubit it ends on, by the bit-exact simulator here; nothing has been sent",
"placement": {
"chosen": "the compiler's own layout, the fewest swaps: the description states no errors"
}
},
"job": {
"id": "ref-1",
"polls": 1
},
"ideal": {
"computed": true,
"method": "exact",
"total_variation_distance": 0.03666666666666665,
"hellinger_fidelity": 0.998653743148044,
"sampling_tvd_expected": 0.023032943298089033,
"ideal_outcomes": 2,
"note": "the circuit's exact distribution over its classical bits, by the bit-exact state vector here, against the provider's counts: the total variation distance, the Hellinger fidelity, and the distance this many shots of the exact distribution would leave on average (by the normal approximation); a distance well above that is the device's or the simulator's error, or a program not run as sent"
},
"cost": {
"free": true,
"estimate": {
"free": true,
"seconds": 0.0
},
"charged": null,
"confirmed": false
},
"energy": {
"unmetered": "the work ran at the provider; this host's meter would read only the wait"
},
"counts_source": "shots",
"execution": {
"stated_by": "provider",
"mitigation": "none",
"twirling": "none",
"decoupling": "none",
"remapping": "none",
"optimisation": "none",
"verbatim": true,
"note": "the reference simulates the program's gates as written, on the qubits named, and corrects nothing"
},
"counts": {
"11": 161,
"00": 139
},
"distinct_outcomes": 2,
"omitted_shots": 0,
"engine": {
"name": "wai-quantum",
"version": "0.8.1"
},
"schema": "wai.quantum.job-result/1",
"receipt": {
"alg": "ed25519",
"canon": "rfc8785",
"key": "197f6b23e16c8532c6abc838facd5ea789be0c76b2920334039bfa8b3d368d61",
"digest": "c4b76d3b703f9df40165f058a261a0c0c7e3adf756a5b4c464b726ffceedbc9a",
"signature": "c53953f6b5f7dc81a5983a7e77bffa0caa752b00ec97bcb297ba9117b7a677f82a6a50d479be8d1200efec444e30af37b32266c77e267ebe1104b64ddf26760f"
}
},
"id": "pj-442c6043319912f8",
"submitted_ms": 1793907034817,
"finished_ms": 1793907034817
}

Some files were not shown because too many files have changed in this diff Show more