Qubit16

Run a quantum circuit

Simulate an OpenQASM 3 circuit on an ideal statevector simulator and sample measurement outcomes. Returns the shot counts AND the final statevector amplitudes (most simulators return counts only) so you can reason about phases, not just probabilities. Limits: 16 qubits, shots clamped to 1–4096. Pass a seed for reproducible sampling.

Inspect the state mid-circuit

Step-through inspector: simulate an OpenQASM 3 circuit and return the statevector AFTER step N (step 0 is the initial |0…0⟩ state, step k is the state after the k-th gate). Also returns each qubit’s Bloch vector at that step. Use it to watch superposition and entanglement appear gate by gate.

List circuit challenges

The full challenge catalogue: id, brief, difficulty, register size, and — where the challenge provides fixed apparatus — the starting circuit as QASM. Grade an attempt with grade_challenge. Hints are withheld here so a solver earns them; a failed grade returns one.

Grade a challenge attempt

Run a submitted OpenQASM 3 circuit through the same deterministic grader the Qubit16 UI uses and return pass/fail, a score, and per-check feedback. Grading is phase-aware where the challenge demands it and never compares raw amplitudes (global phase is ignored). Accepts catalogue ids from list_challenges AND generated ids from generate_challenge (gen-<kind>-d<difficulty>-s<seed> — the challenge is deterministically rebuilt from the id).

Generate a practice challenge

Generate a fresh, verified-solvable practice challenge. Deterministic: the same (kind, difficulty, seed) always yields the same challenge, and every challenge was verified by execution before being returned — the generator ran its own reference solution through the real simulator and grader and confirmed a full pass, that the empty circuit fails, and that every solution gate matters (so par is tight). Grade attempts with grade_challenge using the returned id. Hints and the reference solution are

Build a study session plan

Turn a learner progress snapshot into a structured study plan: weak skills (started but below the mastery bar), next unlocked concepts, and a diagnose → teach → practice → check session with concrete lesson slugs, challenge ids and app routes. STATELESS: the plan is computed from the arguments alone using the same recommender as the /coach page — nothing is stored, and the same snapshot always yields the same plan. Pass an empty progress object for a start-here plan.

Export a circuit as a Jupyter notebook

Build a runnable Jupyter notebook (.ipynb, nbformat 4.5) from an OpenQASM 3 circuit — the same export the app offers. The qiskit variant loads the QASM via qiskit.qasm3 and runs it on Aer or the reference Sampler; the pennylane variant rebuilds the circuit gate by gate (PennyLane has no QASM 3 importer). The result is deterministic: the same circuit exports byte-identical notebooks. Save the `notebook` string as a .ipynb file.

Submit a circuit to real quantum hardware

Submit an OpenQASM 3 circuit to a real quantum device (IBM or AWS Braket). THIS SPENDS REAL MONEY AND REQUIRES AUTHENTICATION: the MCP request must carry an "Authorization: Bearer <supabase access token>" header for a signed-in Qubit16 account on a plan that includes hardware.real (Pro or above). The submission goes through the exact /api/hardware/submit gate chain the web app uses — rate limits, identity, entitlement, and the monthly job quota — and refuses with the same errors. Unauthenticated

List course lessons

Metadata for every lesson in the Qubit16 course: slug, title, level, minutes, prerequisites, objectives, and whether the full body is free. Fetch one with get_lesson.

Read a lesson

One lesson by slug. Free (foundations) lessons include the full body — prose, code, quizzes, key points. Paid (advanced track) lessons return metadata only; their bodies are never served on this surface.

Quantum gate reference

The full gate library this simulator supports — the same entries the circuit builder palette shows — with arity, whether the gate takes an angle, the QASM name to use in run_circuit, and a teaching description.

Generate a circuit verified against a spec

Turn a SPEC — a target measurement distribution, a target statevector, or a target unitary (each up to global phase where that applies), with optional gate-set / depth / gate-count constraints — into a circuit that PASSES that spec on an exact statevector simulator. Runs a generate → verify → repair loop: a model proposes a circuit, the simulator checks it, and on failure the diagnostics (which basis states are off and by how much, fidelity, which gates violate constraints) are fed back for anot

Start an experiment record

Open a new experiment: a lab-notebook record with a title and a hypothesis stated up front. Returns its id. Then call run_step for each circuit you run (the circuit, where it ran, the result and your note are appended, never edited) and conclude_experiment when you are done. A human reads the record at /workbench/experiments/<id>. Records on this deployment are readable by anyone who can reach that page; do not put secrets in them.

Run a circuit and record it as an experiment step

Run an OpenQASM 3 circuit on a target and append the step — circuit, target parameters, result and your note — to an experiment record. Targets: "simulator" (ideal statevector; returns counts and amplitudes; ≤ 16 qubits), "noisy-simulator" (a Pauli depolarising + readout-error model; returns counts and how many shots suffered a gate error; ≤ 10 qubits), and "hardware" (submits through the same authenticated, quota-checked route as submit_hardware_job and records the job handle; a refused submiss

Write the conclusion of an experiment

Close an experiment with a conclusion: what the steps showed, whether the hypothesis survived, and what you would run next. After this no further steps can be added. Calling it again replaces the conclusion (the last word wins) but never touches the steps.

List experiment records

Every experiment on this deployment, newest first: id, title, hypothesis, step count, whether it is concluded, and when. Fetch one with get_experiment.

Read an experiment record

One experiment in full: hypothesis, every step with its circuit, target, result and note, and the conclusion if written.