DART-Q: Deadline-Aware Real-Time Feed-Forward for Quantum Control

Research artifact for the paper accepted at IEEE QCE 2026 (IEEE International Conference on Quantum Computing and Engineering / IEEE Quantum Week), Quantum Networking & Communications (QNET) track. Toronto, Canada, September 13–18, 2026.

Authors: Charles Cao, Sergei V. Kalinin (University of Tennessee, Knoxville).

Quantum feed-forward differs from classical real-time control: many corrections reduce to classical Pauli-frame bookkeeping rather than physical gates, deadlines are set by coherence physics, and stale events can corrupt quantum state. DART-Q compiles protocol events into controller-safe action classes (frame_update, pulse_trigger, release, abort/noop), enforces physics-derived admissibility guards (epoch, sequence, deadline, context validity) in a P4-based packet front-end, and couples the front-end to the controller through a linearizable reservation, so that stale or unsafe events become safe no-ops instead of wrong actuations.

This artifact ships the code for all experiments and the data that cannot be regenerated:

• src/ contains the simulation/emulation code and drivers for the paper's main experiments. All simulation experiments use fixed random seeds, so their result files regenerate deterministically — no simulation data is shipped.
• data/ contains the raw results of the paper's QPU validation on two superconducting platforms (IBM ibm_fez, IQM Garnet via Amazon Braket). Hardware runs are not deterministically reproducible (device noise, calibration drift, paid QPU access), so these one-run snapshots are included as-is — see the disclaimers in data/ibm-fez/README.md and data/iqm-garnet/README.md.

Contents

Path	Role
src/revision_experiments.py	Core Monte Carlo chain: latency models, fidelity proxies, all sweep experiments + plotting
src/revision_models.py	Shared model definitions for the revision chain
src/run_revision_pipeline.py	One-shot driver: regenerates the simulation figures (regime map, protocols, coexistence, baselines, sensitivity bands)
src/pyp4_processor.py	DART-Q packet front-end state machine: token lifecycle, TCAM dispatch, epoch/seqno/deadline/context guards, Pauli-frame XOR
src/run_p4_correctness.py	Fault injection (7 fault classes × 3 guard levels) through the P4 state machine
src/run_p4_latency.py	Latency budget + propagation-dominated negative control, fast path through the P4 state machine
src/run_p4_control_plane.py	Control-plane race study: naive rule install vs. template+context store, via real table operations
src/plot_p4_figures.py	Regenerates the P4-backed paper figures from the three drivers above
src/correctness_fuzzing.py	Property-based guard fuzzing with bootstrap CIs (wrong-actuation table)
src/fidelity_sensitivity.py	Prints the decoherence-model sensitivity table (exp proxy vs. AD/PD/AD+PD)
src/plot_hardware_validation.py	Regenerates the hardware-validation figures from data/
src/ibm_semantic_validation.py	IBM QPU submission script (teleportation: physical vs. frame-update vs. none)
src/braket_garnet_experiment.py	Braket/IQM Garnet submission script (bit-flip code + teleportation)
p4src/desq_switch.p4	The P4 program (plus desq_switch.json, its bmv2 p4c compilation)
data/ibm-fez/	Single-run IBM Quantum (ibm_fez, Heron, 156q) snapshot + disclaimer
data/iqm-garnet/	Single-run IQM Garnet (20q, via Amazon Braket) snapshot + disclaimer

Naming note: DeSQ in p4src/desq_switch.p4 and the DeSQP4Processor class is the project's early codename for what the paper calls DART-Q; the filenames and class names are kept as-is so the code matches the compiled P4 JSON.

Setup

Tested with Python 3.12, numpy 2.4.4, matplotlib 3.10.8, seaborn 0.13.2:

pip install numpy matplotlib seaborn

The two QPU submission scripts additionally need provider SDKs and accounts (pip install qiskit qiskit-ibm-runtime with QISKIT_IBM_TOKEN set, and pip install amazon-braket-sdk boto3 with standard AWS credentials). They are not needed to reproduce any figure: the shipped data/ snapshots feed the plotting script. The P4 state machine runs in pure-Python emulation mode; no P4 toolchain is required.

Reproducing the simulation results

All experiments are seeded and finish in well under a minute total on a laptop. Outputs go to results/ and figures/ at the repo root (created on first run):

# 1. Monte Carlo chain (regime map, protocol semantics, CPU coexistence,
#    RDMA-style baseline, sensitivity bands, plus Monte Carlo versions of figs 1-4)
python src/run_revision_pipeline.py

# 2. P4-backed chain — re-runs the fast path through the real P4 state machine
#    and OVERWRITES figures 1-4 with the P4-backed versions used in the paper
python src/run_p4_correctness.py      # -> results/correctness_p4.json
python src/run_p4_latency.py          # -> results/latency_budget_p4.json, negative_control_p4.json
python src/run_p4_control_plane.py    # -> results/control_plane_p4.json
python src/plot_p4_figures.py         # -> figures/fig1..fig4 (P4-backed)

# 3. Guard fuzzing table + decoherence-model sensitivity table
python src/correctness_fuzzing.py     # -> results/fuzzing_results.json
python src/fidelity_sensitivity.py    # prints the sensitivity table

# 4. Hardware-validation figures from the shipped QPU snapshots
python src/plot_hardware_validation.py

Run step 1 before step 2 (step 2 intentionally overwrites fig1–fig4). The paper's architecture/workflow diagrams are hand-drawn and not generated by these scripts.

Citation

@inproceedings{cao2026dartq,
  author    = {Cao, Charles and Kalinin, Sergei V.},
  title     = {{DART-Q}: Deadline-Aware Real-Time Feed-Forward for Quantum Control},
  booktitle = {Proceedings of the IEEE International Conference on Quantum Computing
               and Engineering (QCE)},
  year      = {2026},
  note      = {To appear}
}

License and status

MIT License (see LICENSE). This repository is an archived research artifact accompanying the paper and is not actively maintained.