# Qubit Desk

> Paste one OpenQASM circuit and the calibration data for the device you are about to submit it to,
> and find out in one sitting whether it will run, whether its signal survives decoherence, and what
> the run costs. https://qubit-desk.skillsafe.ai/

Qubit Desk is a browser app. It has no server of its own: the circuit parsing, the decomposition
arithmetic, the routing walk, the coherence budget and the shot arithmetic all run on the page, and
only the three AI lanes cost anything.

## The task it is for

You have a circuit that works on the simulator and a booking on real hardware. Between those two
facts sit a native gate set you do not use, a coupling map your entangling pairs do not respect, a
coherence time your critical path may exceed, and a shot budget that may be larger than your
session. Qubit Desk is the sitting where you find that out before you spend the booking.

## What is free, and what it actually computes

Everything in this section runs in the browser, with no account and no credits.

- **A real OpenQASM 2.0 / 3.0 reader.** Registers in both dialects, gate applications with `ctrl`,
  `negctrl`, `inv` and `pow` modifiers, barriers, resets, `delay` in real time units, both
  measurement forms (`measure q -> c;` and `c = measure q;`), and classical control.
- **Loops are expanded, onto the qubits each iteration actually touches.** `for int i in [0:11]`
  becomes twelve operations on twelve different qubits. The `start:step:stop` form is supported.
  The loop variable is substituted at identifier granularity, so `q[i]` is rewritten and `include`
  and `sin(i)` are not damaged.
- **Register broadcasts are expanded.** `h q;` on a twelve-qubit register is twelve operations. A
  broadcast counted once understates the gate count, the depth and the error budget at the same time.
- **A `gate` definition's body is never counted as circuit.** A gate defined in the file is costed
  from its own body instead of being reported as an unknown.
- **A loop whose bounds are not literal, and a `while`, are counted ZERO times, not once.** They are
  reported as not assessable and every total is then labelled a lower bound, with "at least" attached
  everywhere it is shown.
- **Depth and entangling depth** by per-qubit layering; barriers synchronise without adding a layer,
  delays advance the clock without adding a layer.
- **Decomposition cost per gate name** against the device's declared basis, from the standard
  equivalence library — a Toffoli reads as six entanglers, a SWAP as three, a controlled-phase as two.
- **Routing cost** by breadth-first distance on the pasted coupling map: SWAPs under the identity
  layout, the worst pair named, and the result labelled a lower bound that a real layout pass usually
  beats.
- **The coherence budget**: the critical path plus the routing cost against whichever of T1 and T2
  binds. The mitigation credit for dynamical decoupling is conditional on the idle fraction being the
  dominant term, and is capped at 80% of the coherence time.
- **The success probability** from the gate and readout error rates, labelled an upper bound because
  the basis-change rotations a transpiler inserts are not counted and crosstalk is not modelled.
- **Mid-circuit measurement detected by order, not by presence.** A measurement at the end is not
  mid-circuit; an operation on that qubit afterwards is.
- **Classical-bit collisions**: two measurements writing one bit is a silent overwrite, and it is
  reported with both line numbers.
- **The shot arithmetic**: the shot-noise floor for the requested standard error, and the explicit
  note that noise-induced bias does not shrink with shots.
- **The parameter-shift gradient budget**: two circuits per parameter per step. Array-typed
  parameter declarations (`input array[float[64], 48] th;`) and indexed references (`th[17]`) are
  counted element by element, not as one parameter.

Fourteen named checks report as `pass`, `attention`, `fail` or **`not assessable`**. A check whose
device field is missing is never counted as a pass, and the count shown ("11 of 14 checks ran") is
the count reported.

## The three metered lanes

One work object — the circuit and the device — and one composed system prompt with an explicit
`task` router.

| `task` | What it answers | Credited to |
| --- | --- | --- |
| `audit` | Will it run on this device at all? Width, gate set, layout and routing, measurements, transpiler settings, what must change before submitting. | `@k-dense-ai/qiskit` |
| `decohere` | Does the signal survive? The duration against T1/T2, which Lindblad channel dominates, what the error budget predicts, which mitigation applies to *this* circuit, what to simulate first. | `@k-dense-ai/qutip` |
| `budget` | What does it cost? The shot plan and its statistical floor, the parameter-shift budget, trainability at this width, and what changes on another vendor's native gate set. | `@k-dense-ai/pennylane` |

Every lane returns the same envelope — `lane`, `title`, `verdict`, `headline`, `summary`, `findings`,
`reconciliation`, `context_notes`, `unassessable`, `body` — and only `body` differs. `verdict` is one
of `runnable`, `runnable_with_changes`, `needs_rework`, `not_viable`, which is the same vocabulary the
free read uses, so a disagreement between the browser and the lane is a real disagreement and is
shown as one.

Every free-read flag carries a `uid` and every lane must return exactly one `reconciliation` entry per
uid. A flag the reply never addresses is rendered as unanswered rather than quietly dropped.

## Provenance

A derived work of three SkillSafe skills, credited individually above and in the app's footer:
`@k-dense-ai/qiskit`, `@k-dense-ai/qutip` and `@k-dense-ai/pennylane`. It is not a republication of
those skills.

## What it is not

It is not a transpiler and does not claim to be one. The routing figure is a lower bound under the
identity layout; a real layout-and-routing pass usually beats it. The single-qubit counts omit the
basis-change rotations a compiler inserts around each entangler, so the success probability is an
upper bound. Crosstalk, leakage out of the computational subspace and calibration drift are not
modelled at all. Run the transpiler before you believe a number, and treat every figure here as the
question to ask it rather than the answer.

## Pages

- `/` — the app.
- `/api.html` — the API tutorial: base URL, the `{data}`/`{error}` envelope, the error-code table,
  and numbered steps from a token to a streamed run, each tabbed across cURL, Python, JavaScript, Go,
  Java, Ruby, PHP and C#. The `task` field is documented first, with one worked example per lane.
- `/tokens.html` — token management for this app in this browser. `noindex`, and not in the sitemap.