# What is readout?

A superconducting processor does not emit classical bits the way a laptop
does. After the gates finish you still have a microwave echo from the readout
resonator. Something must decide what that echo means. That decision step is
readout discrimination. In software language it is classification of an
in-phase and quadrature time series into a classical label.

When readout fails, every layer above it looks broken. Algorithms appear
noisy. Benchmarks look worse than the gates deserve. Error correction spends
budget on measurement errors that a better discriminator might have avoided.
So the community invents better discriminators: matched filters, deep
networks, filter and network hybrids, reservoir-style expansions, and path
signatures. Each paper shows a win on some dataset. Each lab still has to ask
a practical question: on this cooldown, with this measurement length, which
method should we ship?

That question is what ARCADE is built to answer.

## What ARCADE is

Think of ARCADE as an open bake-off harness rather than as a model-zoo
marketing page. You bring traces once, either as HDF5 or NPY or as the bundled
demo set. ARCADE prepares those traces identically for every method. Classical,
neural, and hybrid classifiers train and score under the same splits. You leave
with rankings, optional duration curves, diagnostics, optional FPGA estimates,
and a shareable report.

Stopping after that sentence is enough for a first mental model. ARCADE
compares readout methods so you can choose with evidence under a frozen recipe.

## Pipeline intuition

```text
data → features → classifiers → optional optimization → hardware → report
```

When ``qec.enabled`` is true, an additional stage maps accuracy into logical
error rate and wall-clock cycle curves. Orchestration lives in
``ArcadePipeline`` and in ``arcade.run``. See ``arcade.runner`` for the
callable surface.

For fairness rules see {doc}`shared_recipe`. For metric definitions see
{doc}`metrics`.