betaFeedback

WorksPhysics and Astronomy

QQLink: A Declarative Framework for Multi-QPU Quantum Workflow Orchestration

Abstract

Distributed quantum protocols require measurement outcomes produced at one node to control operations at another. We present QQLink, a programming and orchestration layer that expresses these dependencies in a single program, using workflow nodes, deferred measurement references, and declared entanglement, and derives the cross-node coordination automatically. Its planner constructs a provably acyclic dependency graph in time linear in the total size of the instructions' qubit footprints. The same programs execute through simulator backends or are lowered to dynamic circuits on partitioned quantum hardware. We evaluate seven protocol workflows. Exhaustive feedforward-branch tests on the simulator runtime path, over tomographically complete input sets, yield output-state infidelities of at most 5×10−125\times10^{-12} and no incorrect classical outputs, and replaying every plan in random topological orders leaves each final state unchanged. Separate executor processes run the plans with delayed messages, with the joint quantum state held by a centralized simulation service. Every run with the full plan is correct, and removing required cross-node dependencies causes protocol failures. The lowered circuits match hand-written implementations of the same construction in two-qubit gate and conditional-block counts. Runs on two IBM Heron processors, each partitioned into virtual QPUs, demonstrate same-chip execution in two sessions a week apart. The runs also show large variation between sessions and losses beyond what calibration-derived noise models predict. Coherence-sensitive checks do not establish coherent Toffoli operation or preservation of the intended repetition-code superposition. These results support QQLink's workflow semantics on the tested execution paths and identify limits of the current hardware realization; execution across physically networked QPUs remains future work.

Introduction

A quantum program that spans several quantum processing units (QPUs) is not merely a collection of circuits compiled separately. Teleportation, superdense coding, and non-local gate constructions all rely on coordination across program boundaries. A measurement produced in one part of the program must be referenced in another, and a conditional correction must be applied at the right execution point. The same program should also be portable between a simulator, where it is developed, and hardware, where it is eventually run. Distributed quantum computing has long been studied as a route past the size of a single processor [2, 1], and modular architectures have been proposed for several hardware platforms [20, 21]. A recent experiment executed a distributed quantum algorithm across an optical network link between two processors [3]. This progress widens the gap between what hardware can do and what existing software can readily express. A recent survey of production quantum–high-performance computing (HPC) software stacks [42] names as an open problem the extension of their communication semantics from one-way circuit submission to bidirectional interaction.

Quantum software development kits (SDKs) such as Qiskit [9], Cirq [10], and PennyLane [11] provide mature support for circuit construction, transpilation, and, in some cases, dynamic control flow within one circuit on one backend [22, 23]. They do not provide a reusable orchestration layer in which application intent is expressed separately from backend placement and execution decisions. Adjacent problems have been addressed at other levels of the stack. Circuit cutting [12, 13] replaces quantum communication with classical post-processing and cannot express real-time feedforward. Compiler-level partitioning [14, 15, 24, 25] decides where gates run but not how mid-circuit outcomes are routed at runtime. Network simulators [16, 17, 26] model link-layer physics below the application. Message-passing proposals [29] define communication primitives, and quantum-network node software, from the NetQASM instruction set and SDK [28] to the QNodeOS operating system [45] and the Qoala execution environment [57], executes per-node programs whose cross-node coordination the programmer writes; none derives that coordination from one program over all nodes. § 9 positions each of these lines of work in detail.

QQLink addresses this gap. It is a programming and orchestration layer that separates what a workflow computes from where and how it executes. Applications declare workflow nodes, deferred measurement references, conditional feedforward, and cross-node interactions through a backend-neutral interface. The platform layer maps those abstractions onto simulators or same-chip hardware, including partitioned virtual-QPU layouts on IBM backends. QQLink is not a replacement for backend-native SDKs but a layer above them that captures multi-QPU workflow semantics in a portable form.

Two terms recur throughout the paper. A workflow node is a program-level participant in the application, such as Alice or Bob in a communication protocol; each node declares the qubits it owns. A virtual QPU (vQPU) is an execution-level partition of a shared backend used to realize a workflow node at runtime. The first belongs to the application layer, the second to the platform layer, and the mapping between them is decided at planning time. Our vQPUs are entangled partitions of one backend that exchange Bell pairs and feedforward; the term is also used for independent, non-interacting partitions that execute unrelated circuits in parallel [38], which is a different construction. Figure 1 shows the two on a partitioned chip. Two sectors of one QPU act as Alice and Bob, a quantum path between sectors carries the entanglement, and a classical path through the control system carries a measurement outcome back as a conditional gate.

Figure 1. Same-chip execution of a cross-node conditional. One QPU (qubit lattice) hosts two virtual QPUs, VQPU-1 (Alice) and VQPU-2 (Bob), as disjoint sectors (dashed). Two kinds of link cross the sector boundary. The q-channel (purple) is the quantum path between qAq_A and qBq_B that realizes a Bell pair or a cross-virtual CNOT; on a partitioned chip it is a native two-qubit gate routed through intermediate qubits, which is the co-located path of the channel-selection policy. Dark qubits are allocated; the three between qAq_A and qBq_B are claimed by routing and belong to neither sector. The c-channel (orange) is classical feedforward, in which the outcome mm of a measurement on Alice’s sector conditions a gate UU on qkq_k in Bob’s sector. On the IBM path the whole workflow is lowered before submission into one dynamic circuit, and the condition is evaluated by the QPU control system during the shot; no host-side QQLink code runs between the measurement and UU. Neither the workflow nor the application names a physical qubit; the sector mapping is decided at planning time.

The question the paper answers is whether the coordination semantics of multi-QPU protocols can be captured in a backend-agnostic workflow abstraction such that (a) one program runs unchanged on different simulators and on partitioned hardware, (b) planning is deterministic, acyclic, and linear in the size of the program, (c) the abstraction adds no circuit-level cost relative to hand-written dynamic circuits of the same construction, and (d) the plan suffices to run a program on separate executors, one per node, that share no controller. Condition (d) separates QQLink from a single dynamic circuit with named registers, which satisfies (a) and (c) on one backend but fixes one global order and one controller. The test of (d), one controller process per node with delayed messages and no dispatcher (§ 8.4), is therefore the central evidence for what the abstraction adds; the evaluation reports it directly after the correctness checks. This paper makes the following contributions.

  1. A programming model for multi-QPU-style workflows based on workflow nodes, typed deferred measurement references, declarative entanglement links, cross-node conditional gates, and an explicit ordering primitive (§ 3).

  2. A planning algorithm that derives dependencies from qubit footprints in authoring order and from measurement references, with proved guarantees (deterministic output, an edge for every local and cross-node measurement reference, acyclicity at the granularity of execution units, and independence of the result from the topological order) and measured cost of 8 to 17 microseconds per instruction, linear over three orders of magnitude of program size (§ 4).

  3. Execution mechanisms that realize the plan on heterogeneous targets, namely virtual-QPU partitioning, a channel-selection policy, per-instruction conditional dispatch, retry and timeout controls, and a hardware path (§ 5).

  4. Seven protocol workflows authored entirely at the application layer, namely superdense coding, register teleportation, entanglement swapping, a Grover search and a Bernstein–Vazirani algorithm built from teleported gates, a three-node Toffoli gate, and a three-node repetition code; and a single-node accept/reject control loop for the task layer (§ 7).

  5. A systems evaluation answering (a)–(d), with exhaustive forced-branch verification of every feedforward branch on the simulator runtime path, on tomographically complete inputs, and replay of every plan in random topological orders; execution on one controller process per node with delayed messages, and separate ablations of the measurement and footprint edges between nodes; a cost-of-abstraction comparison against hand-written dynamic circuits over transpiler settings and against an independent distribution compiler; planning overhead; and same-chip runs on two IBM Heron processors in two sessions, with controls that break the correlation between outcomes and corrections, coherence-sensitive checks, and a study of the excess loss of the deeper workflows (§ 8).

We are deliberate about scope. The hardware results reported here are same-chip, virtual-QPU demonstrations, each on a single partitioned device. They are not physically distributed, multi-chip experiments across networked QPUs; that regime is the goal the abstractions are designed for, but realizing it on hardware remains future work (§ 10). The separate-executor experiment distributes the control plane across processes but keeps the quantum state in one simulator. Throughout, “distributed” describes the class of protocols QQLink expresses, not the physical execution substrate demonstrated.

Background and Requirements

A multi-QPU-style quantum workflow consists of several circuit regions related by entanglement and by feedforward, in which measurements in one region drive conditional operations in another. This pattern arises in quantum teleportation [5], superdense coding [6], non-local gates derived from gate teleportation [4, 35], and distributed search and factoring algorithms [3, 8]. In each case the protocol is a workflow whose correctness depends on the ordering of local operations, the availability of shared entanglement, and the use of measurement outcomes to drive later computation. These dependencies must remain well defined independently of the backend on which the workflow runs.

These constraints yield four requirements for a software layer aimed at multi-QPU workflow semantics.

QQLink satisfies these requirements by treating a multi-QPU protocol as a workflow with explicit application-level structure rather than as a one-off composition of backend calls. § 3 to § 5 describe the model, the planner, and the execution mechanisms in turn; § 7 returns to R1–R4 and shows how the eight workflows exercise each of them.

Programming Model

QQLink is organized into two layers, application and platform, connected by a planning interface (Figure 2). The application layer captures what a workflow computes in terms of workflow nodes and the dependencies between them; the platform layer decides where and how it executes. No component in the application layer references a physical backend.

Figure 2. The two-layer model on the running example (Script lst:teleport1). Orange carries classical information, cyan carries quantum information, and purple marks an entanglement link. The top panel shows the application layer with the two WorkflowCircuits, Alice (q0q_0, q1q_1) and Bob (q0q_0), drawn on the qubits they will occupy (grey qubits are unallocated) and listed as the backend-free instruction streams the developer wrote. The EntanglementLink ℓ\ell ties Alice’s q1q_1 to Bob’s q0q_0. Alice’s measurements return MeasureRef handles m0m_0, m1m_1 (meters); Bob’s two if_then conditionals reference them across the circuit boundary and are drawn as the XX and ZZ corrections applied to Bob’s q0q_0, the c-channel of Figure 1. No backend name or physical qubit address appears. In the bottom panel, the platform layer’s plan() (Algorithm alg:plan) turns the program into an ExecutionPlan of three units. Alice’s stream is one unit; Bob is split at each conditional into unit_1 and unit_2, chained by the intra-circuit edge of pass 1 (grey) and tied to Alice’s measurements by the two cross-circuit edges of pass 2 (orange, dashed), which place both of Bob’s units after Alice’s measurements on the time axis. The backend map co-locates the two circuits as virtual QPUs on one backend, and the executor dispatches units to a simulator or to a partitioned chip.

Workflow programs and circuits

A developer constructs a WorkflowProgram containing one or more named WorkflowCircuits, one per workflow node. Each circuit records a sequence of instructions (gates, measurements, conditional blocks, Bell-pair requests, and cross-circuit CNOT operations) without referencing any physical backend. A circuit declares nn qubits; the platform layer maps them to physical indices later. The application layer is purely descriptive. A circuit does not allocate qubits, open backend connections, or evaluate conditionals. It appends instructions to a list. The same circuit object can therefore be inspected, serialized, or transformed by the orchestrator without side effects, and several planning strategies can be applied to one workflow without re-authoring it.

Deferred measurement references

The abstraction that makes cross-node protocols expressible is the MeasureRef. When a circuit measures a qubit, the call returns a lightweight typed handle carrying the circuit’s identity and a string label. Comparing the handle with a classical value (m0 == 1) produces a condition, which is passed to if_then(condition, gates) on any circuit in the program, including a different one. Because the condition encodes its source circuit, a single if_then call on Bob’s circuit expresses “apply XX to my qubit 0 if Alice’s measurement m0 returned 1.” This is a cross-circuit conditional feedforward that requires no imperative branching and no explicit messaging. Script lst:teleport1 shows the complete single-qubit teleportation program, which we use as the running example in § 4.

A second, gate-free use of the same handle is wait_for(ref). It records that the circuit’s subsequent instructions must be ordered after the referenced measurement without applying any gate. The planner derives ordering from the qubits each instruction acts on (§ 4), so wait_for is needed only for constraints that are not visible in the instruction streams, for example a decision that must follow an outcome without touching a qubit. The planner treats it as a dependency edge; executors and the hardware lowering treat it as a no-op.

def build_teleportation():
    wp = WorkflowProgram("teleportation")
    alice = wp.create_circuit("alice", num_qubits=2)
    bob = wp.create_circuit("bob", num_qubits=1)
    bell = wp.declare_entanglement("alice", 1, "bob", 0)
    alice.gate("RY", [0], params=[pi / 3])   # state to send
    alice.request_bell_pair(1, bell)
    alice.gate("CNOT", [0, 1])               # Bell measurement
    alice.gate("H", [0])
    m0 = alice.measure(0, label="m0")
    m1 = alice.measure(1, label="m1")
    bob.if_then(m1 == 1, [("X", [0])])       # cross-circuit
    bob.if_then(m0 == 1, [("Z", [0])])       # feedforward
    return wp

Declarative entanglement

Entanglement follows the same philosophy. The program registers Bell-pair requirements between circuit–qubit pairs via declare_entanglement(), producing EntanglementLink objects that carry no placement information. Each link names two circuit–qubit pairs and is assigned a unique identifier that circuits reference when they call request_bell_pair(). This call emits a bell_pair instruction into the circuit’s stream, recording the link identifier and the local qubit index, but performs no quantum operation. Similarly, cross_cnot() records a non-local CNOT request that names the target circuit and qubit by identifier rather than by physical address. In both cases the instruction is self-describing, and the platform layer determines how and where each operation is realized at dispatch time.

Ordering semantics

“Declarative” in QQLink refers to entanglement and feedforward. The program states which Bell pairs exist and which outcome drives which correction, and the planner derives the messages and the order. Operation order is not declarative. Every instruction carries its position in a counter shared by all circuits of a program, and the planner orders two operations on the same qubit, including the two endpoints of a Bell-pair or cross-CNOT request, the way they were written. The model is therefore closer to a single-threaded tracing interface with namespaced registers than to a set of independently authored node programs. The program is written in one thread, and swapping two calls on different circuits that touch a common qubit changes the plan. This is a deliberate choice. It makes the plan a deterministic function of the program text (P1 in § 4), and it lets the planner recover cross-circuit order from qubit footprints without asking the developer for explicit synchronization. Authoring node programs concurrently, by separate parties or processes, would need an explicit merge of their instruction streams, or a partial order stated through wait_for alone, and is outside the present model (§ 10). Execution, by contrast, need not follow the authoring thread. Units whose footprints are disjoint have no edge between them and may run concurrently on different nodes, which § 8.4 exercises with one controller process per node.

Planning

The platform layer translates the declarative description into concrete execution. Its central component, the Orchestrator, consumes a WorkflowProgram and produces an ExecutionPlan, an ordered list of ExecutionUnits with dependency edges, backend assignments, and planning metadata. Algorithm alg:plan states the procedure.

\caption{Two-pass plan construction}
\label{alg:plan}
\begin{algorithmic}[1]
\Require WorkflowProgram $P$ with circuits $c_1,\dots,c_m$; backend catalog $B$
\Ensure ExecutionPlan $(U, E, \beta)$: units, dependency edges, backend map
\State $U \gets \emptyset$;\; $E \gets \emptyset$;\; $\Lambda \gets \emptyset$ \Comment{$\Lambda$: map from (circuit, label) to unit}
\ForAll{circuits $C_i$} \Comment{Pass 1: segmentation}
  \If{every qubit of $C_i$ is measured, no operation acts on a qubit after its measurement, and $C_i$ has no conditional}
    \State one segment for the whole stream (whole-circuit mode)
  \Else
    \State split the stream at every measurement, conditional, Bell-pair, and cross-CNOT boundary into segments $s_{i,1},\dots,s_{i,k_i}$
  \EndIf
\EndFor
\State $\mathit{last} \gets \emptyset$ \Comment{Pass 1b: units and footprint edges in authoring order}
\ForAll{instructions $x$ of $P$ in authoring order, in segment $s$}
  \State $u \gets$ the open unit of $s$, or a new one if none is open
  \If{some $(c,q) \in \mathrm{footprint}(x)$ has $\mathit{last}[(c,q)] \notin \{\bot, u\}$ written after the first instruction of $u$}
    \State close $u$;\; $u \gets$ new open unit of $s$ \Comment{refinement for (P3)}
  \EndIf
  \State add $x$ to $u$;\; $U \gets U \cup \{u\}$
  \If{$x$ measures with label $\ell$} $\Lambda[(\mathrm{circuit}(x), \ell)] \gets u$ \Comment{a repeated pair is rejected} \EndIf
  \ForAll{$(c, q) \in \mathrm{footprint}(x)$} \Comment{both endpoints of Bell-pair and cross-CNOT requests}
    \If{$\mathit{last}[(c,q)] \notin \{\bot, u\}$} $E \gets E \cup \{(\mathit{last}[(c,q)], u)\}$ \EndIf
    \State $\mathit{last}[(c,q)] \gets u$
  \EndFor
\EndFor
\ForAll{units $u \in U$} \Comment{Pass 2: measurement-reference edges}
  \ForAll{conditionals and \texttt{wait\_for} in $u$, referencing $(c', \ell)$ on any circuit $c'$, local or remote}
    \If{$\Lambda[(c', \ell)] \neq u$} $E \gets E \cup \{(\Lambda[(c', \ell)], u)\}$ \EndIf
  \EndFor
\EndFor
\State group circuits transitively by shared entanglement links and cross-circuit references; for each group choose $\beta \in B$ with sufficient capacity
\State \Return $(U, E, \beta)$
\end{algorithmic}
Pass 1: segmentation and qubit footprints.

The orchestrator walks each circuit’s instruction stream. A circuit whose qubits are all measured, which applies no operation to a qubit after measuring it, and which contains no conditional is emitted as a single whole-circuit unit; otherwise the stream is segmented at measurement, conditional, Bell-pair, and cross-CNOT boundaries, and each segment becomes one execution unit unless the refinement described below splits it. A conditional both starts and ends a segment, so it is always a unit of its own. The gates authored before it are not held back until its outcome is known, and the gates after it cannot run before it. Dependencies between units are then derived from qubit footprints; we call these footprint edges. Every instruction carries the position at which it was authored, from a counter shared by all circuits of a program, and the planner replays the instructions in that order, recording for each (circuit, qubit) pair the last unit that acted on it; a unit depends on the last unit that acted on any qubit in its footprint. Bell-pair and cross-CNOT requests act on both endpoints, so a request on Alice’s side whose other end is Bob’s qubit is ordered after Bob’s last operation on that qubit, and Bob’s next operation on it is ordered after the request. Segments of one circuit that act on disjoint qubits receive no edge between them. A wait_for instruction acts as a barrier, and its footprint is every qubit of its circuit. Because a request also acts on the other circuit’s qubit, the instructions of a segment need not be contiguous in authoring order with respect to the qubits it touches, because Bob may act on Alice’s qubit between two of Alice’s gates on it. The same replay therefore refines segments into units. An instruction opens a new unit of its segment when one of its qubits was last touched by another unit after the first instruction of the current one. Without this rule, two circuits that issue requests on each other’s qubits can produce a dependency cycle. As units are formed, the measurement-label map LL associates every labeled measurement, keyed by its circuit and label, with the unit that produces it; two circuits may use the same label, and a label repeated within one circuit is rejected.

Figure 3. Three-qubit register teleportation (Script lst:teleport) as authored and as planned. (a) The multi-QPU circuit on the nine allocated qubits, with Alice’s data qubits a0a_0–a2a_2 and Bell halves a3a_3–a5a_5 (VQPU-1), Bob’s b0b_0–b2b_2 (VQPU-2). The three Bell pairs (blue CNOTs) are the only gates that cross the sector boundary; each of Alice’s measurement outcomes drives one correction on Bob through a classical wire (orange). The corrections are drawn in the order the planner emits them. (b) The execution plan as a DAG produced by Algorithm alg:plan. Alice’s single unit produces six labeled outcomes; each of Bob’s six units depends on it through a cross-circuit edge (orange, dashed) from pass 2. The footprint analysis of pass 1 chains only units that act on the same qubit (grey). The three per-qubit chains are independent, so the critical path is three units for any register size, although the work in Alice’s unit grows with the register.

Pass 2: measurement-reference edges.

The second pass scans all units for conditional and wait_for instructions. For each one it looks up the unit that produces the referenced measurement in the label map and inserts a measurement-reference edge (measurement edge for short) from that unit, whether the measurement was taken on the same circuit or on another one. The footprint edges of pass 1 do not cover a local reference. In a circuit that measures qubit 0 as mm and then applies XX to qubit 1 if m=1m = 1, the conditional’s footprint is disjoint from the measured qubit, and only the measurement-reference edge orders the two. A single pass would fail whenever a conditional on one circuit references a measurement from a circuit that has not yet been processed. Deferring the resolution of references to a pass that runs after all units have been formed handles arbitrary reference patterns regardless of circuit processing order.

Backend selection.

Backend selection does not depend on the two passes; the implementation runs it before pass 1. The orchestrator groups circuits that are connected by entanglement links or cross-circuit references, so that every Bell pair can be realized through a co-located cross-virtual CNOT and every cross-circuit reference is resolved on one backend, and then selects a backend with sufficient qubit capacity for each group. The grouping is transitive. If Alice shares a link with Bob and Bob shares a link with Carol, all three are placed on the same backend.

Running example.

For Script lst:teleport1, Alice’s circuit becomes one unit (state preparation, Bell-pair request, CNOT, Hadamard, two measurements) and Bob’s becomes two conditional units. The second pass links each of Bob’s units to Alice’s measurement unit, yielding a directed acyclic graph (DAG) of units that dispatches the corrections only after the outcomes are available. Figure 3 shows the circuit and the graph for the three-qubit register case. Alice’s single unit fans out to three independent two-unit chains on Bob’s side, one per teleported qubit, because corrections on different qubits have disjoint footprints.

Guarantees and cost.

Three properties of the plan follow from the construction and are used in the evaluation.

  1. Determinism. Both passes depend only on the instruction streams and the backend catalog, not on runtime state. Repeated planning of the same program yields the same units, edges, and backend assignments.

  2. Dependency completeness. Every conditional and wait_for, on the producing circuit or on another one, references a labeled measurement (a measurement without a label receives one automatically); pass 1 records every labeled measurement before pass 2 begins, and a reference whose measurement no unit produces is rejected at planning; hence every reference receives an edge from its producing unit, independent of the order in which circuits were authored or processed. Every pair of units that act on a common (circuit, qubit) pair is connected by a chain of footprint edges, since the replay links each access to the previous one.

  3. Acyclicity. Let f(u)f(u) be the authoring position of the first instruction of unit uu. Every edge (u,v)(u, v) satisfies f(u)<f(v)f(u) < f(v). A footprint edge arises from consecutive accesses x∈ux \in u and y∈vy \in v to one (circuit, qubit) pair, with xx before yy. If xx came after f(v)f(v), the refinement would have opened a new unit at yy, so xx precedes f(v)f(v) and f(u)≤x<f(v)f(u) \le x < f(v). A measurement edge points from the unit producing a label to the unit of a conditional or wait_for that consumes it; a wait_for is recorded as a conditional without gates, so like every conditional it starts its unit, and it can only be recorded after the measurement whose handle it consumes, so again f(u)<f(v)f(u) < f(v). Hence ff increases strictly along every edge and the graph is acyclic, so a dispatcher that receives every completion never waits on a cycle. Acyclicity does not exclude a stall caused by a lost message, an unavailable resource, or a failed service. The co-located dispatcher can bound each unit with a timeout and report the failure, while the separate executors have no timeout (§ 5.3). The dispatcher’s topological sort also checks acyclicity at run time and rejects a plan with a cycle.

We measure the size of a program by S=∑x∈I∣footprint(x)∣S = \sum_{x \in I} |\mathrm{footprint}(x)|, the total length of its instructions’ footprints, which counts every qubit of every gate in a conditional body, both endpoints of a Bell-pair or cross-CNOT request, every qubit of a multi-qubit custom gate, and every qubit of the circuit for a wait_for or another instruction that acts as a barrier. Both passes touch each footprint entry a constant number of times, and the label map and the refinement give constant-time hashed lookups, so planning takes O(S+∣E∣)O(S + |E|) time. In every workflow and synthetic program of this paper, no footprint has more than two entries and no instruction is a barrier, so S≤2∣I∣S \le 2|I|. Each footprint entry adds at most one footprint edge and each measurement reference at most one measurement edge, so ∣E∣≤S+∣I∣|E| \le S + |I| and planning is linear in the number of instructions. Dispatch requires a topological order of the units; we compute it with Kahn’s algorithm, using a heap that releases ready units in authoring order, in O((∣U∣+∣E∣)log⁡∣U∣)O((|U| + |E|)\log|U|), so that execution follows the program as written wherever the dependencies allow. Any topological order yields the same result as the authoring order. Two units that no path connects act on disjoint (circuit, qubit) pairs (P2), and neither reads a measurement the other produces (P2), so their operations, measurements included, commute, and every linear extension of the plan composes the same quantum instruments. For each record of measurement outcomes, the post-measurement state and the probability of the record are therefore independent of the order. § 8.3 checks this statement by replaying plans in random topological orders.

Execution Mechanisms

The plan is dispatched by walking the dependency graph in topological order and invoking a user-supplied callback for each unit. QQLink provides a default WorkflowExecutor that allocates qubits sequentially across vQPUs on a shared physical backend and translates each instruction at dispatch time. Standard gates and measurements map directly to QPU operations, and Bell-pair and cross-CNOT instructions are realized through a cross-virtual CNOT on the shared state. This section describes the mechanisms that operate across the application–platform boundary.

Per-instruction conditional dispatch

Classical feedforward is fully declarative. The application writes bob.if_then(m0 == 1, [("X", [0])]) where m0 is a MeasureRef from Alice’s circuit; no imperative branch, message-passing call, or backend name appears. Because the mechanism is driven by the measurement label rather than by the consuming circuit, it generalizes to chains, in which a measurement on c1c_1 can drive corrections on c2c_2, whose own measurement can drive corrections on c3c_3, with the orchestrator resolving the full dependency graph.

Conditions are evaluated per instruction at dispatch time. Every conditional is its own unit (§ 4), and the executor reads the recorded outcome and applies the conditional gates only if it matches; the unit is dispatched either way, so nothing is silently dropped and the plan’s bookkeeping (which unit produced which outcome, how many attempts it took) stays complete. The gate-teleportation workflows of § 7 depend on this behavior, since their ancilla resets are conditional gates interleaved with unconditional ones.

For this to be correct, a backend adapter must honor one contract. A mid-circuit measurement must collapse the simulated state exactly once, and subsequent operations must act on the branch that was observed. An adapter that re-executes the accumulated circuit on every measurement and returns a freshly sampled bit violates this contract; the corrections it applies are then uncorrelated with the branch that later measurements sample, and every feedforward protocol degrades to the statistics of uncorrected branches (§ 8.8).

Entanglement channels and virtual-QPU partitioning

A request_bell_pair() instruction is recorded in the stream but not realized until dispatch time, when the executor applies a Hadamard and a cross-virtual CNOT to the partner qubit. A channel-selection policy chooses, in order of precedence, among three paths, namely a co-located path that executes the CNOT directly on the shared state when both vQPUs share a backend; a built-in simulated channel when they do not; and a provider-native channel that delegates to a hardware-specific executor (for example an ion-trap shuttle or a photonic link) when a physical quantum network is available. The simulated channel is a control-flow model of a link, not a physics model. It has a success probability, an optional Pauli error injected on both endpoints, and a latency, and it reports every attempt in the operation record. It cannot create entanglement between two independent state vectors, so protocol outcomes obtained through it are not meaningful; its purpose is to exercise placement, retry, and latency accounting for workflows whose nodes live on different backends (§ 8.7). Only the co-located path yields protocol-level results in this paper.

The co-located path relies on virtual-QPU partitioning, which maps several workflow nodes onto disjoint qubit ranges of one backend, for example c1c_1 on [0,k)[0,k) and c2c_2 on [k,n)[k,n). Bell pairs and cross-virtual CNOTs between partitions then act on the same state, modeling entanglement correlations without a physical network or multiple simulator instances. Figure 1 (Introduction) shows both kinds of link on a partitioned chip. The quantum path between sectors is the co-located path, and the classical loop through the control system is the feedforward.

Reliability controls and failure contract

The orchestrator dispatches a unit only after all its dependencies, on the same circuit or another one, have completed. The runtime makes four commitments about failure. (i) Retry eligibility. A unit whose dispatch fails before any of its instructions has completed is retried up to a configurable number of times with optional backoff. A unit that fails after one or more instructions have acted on the state is not retried, because re-dispatching it would apply its first operations twice; the failure is propagated at once, together with the results of the units that did complete. Recovery from such a failure needs a restart of the workflow or the error-detection structure of the protocol. (ii) Missing references. In the co-located executor, a conditional whose measurement has not been recorded is an error, not a skipped correction. With a complete plan (P2) this cannot happen, so the error signals an executor that violates the plan. The separate executors evaluate a missing outcome as no correction, a case that only the edge ablations of § 8.4 exercise. (iii) Ownership. A Bell-pair request or cross-circuit CNOT is issued by the unit of the requesting circuit and orders the other circuit’s qubit through its footprint; the remote circuit performs no matching operation. (iv) Delivery. The co-located executors share one process and need no messages, and their dispatcher can bound each unit with a timeout. The separate executors of § 8.4 assume that every completion message is delivered exactly once, with arbitrary delay; they have no timeout, so a lost message would leave its consumers waiting, and loss, duplication, and process failure are outside what we test. Channel operations carry their own retry budget and timeout, so a failed link attempt is repeated without re-dispatching the unit. Program, task, and queue state can be serialized to JSON and restored, which enables post-hoc trace analysis and restart of the classical orchestration state; the quantum state of a simulator or device is not checkpointed. The accept/reject workflow of § 7 instead retries at the application level, in a loop that plans and dispatches each attempt through the orchestrator.

Hardware path

The hardware path submits one dynamic circuit per workflow. A plan is lowered by emitting its units in topological order on a global register in which each circuit occupies a contiguous block; labeled measurements receive one classical bit each and conditionals become if_test blocks on that bit. The same lowering is used in § 8.5 to compare against hand-written circuits and in § 8.7 for noise sweeps, so the circuit that reaches the device is the circuit those experiments analyze. The hardware runner then chooses the vQPU sector, the physical qubits that host the lowered register, either by letting the Qiskit preset pass manager score layouts with the backend’s calibration data or by an exhaustive search for the connected line of qubits with the lowest sum of two-qubit-gate and readout errors. Along that line, the qubits are either placed in Cuthill–McKee order of their interaction graph, which can interleave nodes, or, as in the main runs reported here, node by node, so that each virtual QPU occupies a contiguous stretch and the sectors are disjoint. Readout-calibration circuits on the same physical qubits are bundled into the same Sampler job, so that a tensored readout-error inversion of the application-level check bits is available as a post-processing step; feedforward bits are consumed on the device and cannot be mitigated. The numbers reported in § 8.6 are raw. Every run record stores the UTC submission and completion times, the backend name and processor family, the timestamp of the calibration the device reported, the T1T_1, T2T_2, readout and single-qubit gate errors of every physical qubit used and the two-qubit gate error of every coupler between them, the physical qubits assigned to each circuit, the transpiled depth and two-qubit count, the job identifier and its timing metrics, the raw counts, and the versions of the software stack including the QQLink commit. None of this is visible at the application layer. The same program object is planned once and executed on a simulator, on a fake backend with the device’s noise model, or on the device.

The fake-backend dry run uses Qiskit Aer’s simulator built from the backend’s calibration (AerSimulator.from_backend), either from the snapshot shipped with Qiskit’s fake ibm_kingston or from the calibration that the device reports at the time of the run. Its noise model contains, for every gate, a depolarizing error together with thermal relaxation over the gate’s duration; for every qubit, the reported readout error; and an error on reset. A measurement carries only its readout error, with no relaxation during its duration (2.3 μ2.3\,\mus on the fake backend), and the circuits are not scheduled, so a qubit that waits while another qubit is measured or while a conditional is resolved accrues no error. Explicit delay instructions do receive thermal relaxation from T1T_1 and T2T_2. The dry run therefore models gate and readout infidelity but not the time structure that feedforward introduces (idle intervals and conditional execution), which the probes of § 8.6 examine directly.

Implementation

Figure 4 maps the concepts of § 3 to § 5 onto the software. QQLink is a Python package organized in four layers that correspond to the four bands of the figure.

Layering.

The application layer (qqlink.workflow) holds the WorkflowProgram, WorkflowCircuit, MeasureRef, and EntanglementLink classes. A circuit’s methods append backend-free instruction dictionaries to a stream; nothing in this layer imports a simulator or a provider SDK. The platform layer (qqlink.platform) contains the Orchestrator, the ExecutionPlan and its units, and the placement policies, which implement one PlacementPolicy protocol (a simulator policy and a hardware-capability policy are provided). The runtime (qqlink.user, qqlink.dsl, qqlink.runtime) predates the workflow layer. It is the message-driven core of the framework, in which DistributedQuantumProgram wraps QuantumProgram and delegates to four subsystems, the QubitMapper that owns virtual-QPU partitions and answers the co-location test, the channel executors, the MessageProcessor that validates and applies classical instruction payloads (not exercised by the experiments reported here), and the QuantumTaskManager that provides task dependencies, retries, timeouts, and JSON persistence. The backend layer (qqlink.user.backends) implements one abstract Backend contract for Qulacs, Qiskit Aer, and IBM Runtime.

From plan to backend.

The WorkflowExecutor is the only component that spans the platform and runtime layers. It reads the runtime backend name resolved during planning, registers one shared backend, allocates each circuit a contiguous virtual-QPU block on it, and exposes a dispatch(unit) callback that translates each instruction of a unit into runtime calls. Gates and measurements become apply_gate and measure on the circuit’s vQPU, Bell-pair and cross-CNOT instructions become execute_cross_virtual_cnot, and conditionals are evaluated against the measurements the executor has recorded. Because the executor is a callback, a different executor can be substituted without touching the planner, for example the two-backend executor of § 8.7, the dynamic-circuit lowering of the hardware path, and the process-per-node executor of § 8.4, which does not use the dispatcher at all and gives each node only its own units. The workflow layer was added on top of the existing runtime rather than replacing it; a compatibility bridge to the earlier API (dashed in Figure 4) exists for parity tests and is not used in this paper.

Adapter contract.

Every backend implements initialize_state, apply_gate, measure, and reset, plus an asynchronous job interface for hardware, and must honor the single-shot measurement contract of § 5; the contract is tested by running the feedforward workflows on every adapter.

Extension points.

Four registration APIs extend the framework without modifying it. They add custom gates and optimization hooks on the program, placement policies on the orchestrator, channel executors (simulated, provider-native, or user-supplied) on the runtime, and backend plugins through register_backend. The provider-native channel executor is the intended attachment point for physical inter-chip links; it exists today as a scaffold with deterministic executor selection and no hardware behind it.

Figure 4. Software architecture of QQLink. Bands are Python packages. The application layer records backend-free instruction streams; the platform layer plans them into an ExecutionPlan; the WorkflowExecutor binds each unit to a runtime backend and drives the pre-existing message-driven runtime and its four subsystems; all execution reaches hardware or simulators through one Backend contract. Black arrows are the path a program takes from authoring to execution; grey arrows are delegation inside the runtime (the four subsystems join one bus into the Backend contract). Dashed arrows mark the compatibility bridge between the legacy API and the workflow path; dashed leaders on the right mark the registration APIs through which the framework is extended.

Application Workflows

We validate QQLink with seven protocol workflows of increasing complexity and one control loop. Superdense coding, multi-qubit teleportation, and a two-node Grover search exercise entanglement declaration, cross-circuit feedforward, and multi-round gate teleportation with ancilla reuse. Entanglement swapping is the quantum-repeater primitive and tests feedforward across a chain of three nodes joined by two links; a distributed Bernstein–Vazirani algorithm splits an oracle across two nodes; a three-node Toffoli gate tests tripartite orchestration; a three-node repetition code extracts syndromes across nodes and corrects an injected error by feedforward. A single-node accept/reject loop, with no cross-node edge, tests the task layer. All eight are authored entirely at the application layer, with no backend name in any circuit definition; the seven protocol workflows are the ones run on hardware.

Multi-channel superdense coding

Superdense coding [6] transmits two classical bits through one qubit and a shared Bell pair. We generalize the protocol to kk parallel channels, in which Alice and Bob each hold kk qubits and share kk independent Bell pairs, so 2k2k classical bits are communicated in one round. For each channel, Alice prepares her half of the Bell pair via request_bell_pair, encodes two bits by applying one of {I,X,Z,Y}\{I, X, Z, Y\}, and decodes with a cross_cnot onto Bob’s qubit followed by a Hadamard and a measurement of her own; Bob measures his qubit. We sweep k∈{1,2,4}k \in \{1,2,4\}, from 2 to 8 physical qubits. Because the protocol involves no conditional feedforward, it isolates the entanglement declaration and channel realization mechanisms. Script lst:dense in Appendix § 13 shows the construction; the loop body is identical for every channel. This protocol is also the cleanest entry point for same-chip hardware experiments because it requires only terminal measurement.

Multi-qubit teleportation

Quantum teleportation [5] transfers an unknown state using a shared Bell pair and two classical bits of feedforward. We generalize to an nn-qubit register, in which Alice holds 2n2n qubits (nn data and nn Bell halves), Bob holds nn qubits, and each qubit is teleported through its own link, Bell measurement, and correction round. Data qubit ii is prepared as RY(π/(i+2)) ∣0⟩R_Y(\pi/(i{+}2))\,|0\rangle so that every qubit carries a distinct known state. After Alice measures her data and Bell qubits, her two outcomes per qubit drive Pauli corrections on Bob’s side through if_then calls whose conditions reference MeasureRefs from Alice’s circuit. The orchestrator resolves these references during planning, inserting 2n2n cross-circuit edges without any coordination code from the developer (Script lst:teleport).

We sweep n∈{1,3,5,7}n \in \{1,3,5,7\}, from 3 to 21 physical qubits. The sweep separates two costs. The planning-level resources (units and cross-circuit edges) grow linearly with nn, whereas the statevector simulation cost grows exponentially with the total qubit count 3n3n. This provides a baseline against which hardware experiments can distinguish orchestration overhead from noise-induced degradation.

def build_multi_teleportation(n):
    wp = WorkflowProgram("multi_teleportation")
    alice = wp.create_circuit("alice", num_qubits=2*n)
    bob = wp.create_circuit("bob", num_qubits=n)
    for i in range(n):
        alice.gate("RY", [i], params=[pi / (i + 2)])
    for i in range(n):
        a_data, a_bell, b_bell = i, n + i, i
        link = wp.declare_entanglement(
            "alice", a_bell, "bob", b_bell,
            link_id=f"bell_{i}")
        alice.request_bell_pair(a_bell, link)
        alice.gate("CNOT", [a_data, a_bell])
        alice.gate("H", [a_data])
        m0 = alice.measure(a_data, label=f"m0_{i}")
        m1 = alice.measure(a_bell, label=f"m1_{i}")
        bob.if_then(m1 == 1, [("X", [b_bell])])
        bob.if_then(m0 == 1, [("Z", [b_bell])])
    return wp

Entanglement swapping

Entanglement swapping is the elementary step of a quantum repeater [16, 28]. Two nodes that never interact end up sharing a Bell pair because a third node measures its halves of two independent pairs. Alice–Charlie and Charlie–Bob share Bell pairs; Charlie performs a Bell measurement on his two halves, and Bob applies Xm1Zm0X^{m_1} Z^{m_0} (Script lst:swap in Appendix § 13). Alice’s and Bob’s qubits are then in ∣Φ+⟩|\Phi^+\rangle. The workflow adds a third node and a feedforward chain in which both outcomes of one Bell measurement drive one remote qubit. The check measures Alice’s and Bob’s qubits in the same basis, ZZ or XX, where a Bell state yields equal outcomes with certainty.

Two-node Grover search via gate teleportation

This workflow combines entanglement, feedforward, and ancilla management. We implement a two-qubit Grover search [7, 3] in which each search qubit resides on a separate node, each accompanied by a network ancilla. The oracle and the diffusion operator both require a non-local controlled-ZZ (CZ) between the nodes. Each CZ is decomposed as CZ=(I⊗H) CNOT (I⊗H)\mathrm{CZ} = (I \otimes H)\,\mathrm{CNOT}\,(I \otimes H), where the CNOT is realized through the Gottesman–Chuang gate teleportation protocol [4]. The two nodes consume a shared Bell pair on their ancillas, perform two sequential mid-circuit measurements with cross-circuit corrections, and reset the ancillas to ∣0⟩|0\rangle for reuse in the next teleported gate.

Script lst:gtcnot shows the teleported CNOT as a reusable building block. Each invocation declares a fresh entanglement link, requests a Bell pair, and emits four if_then conditionals, two Pauli corrections and two ancilla resets. Two of the four reference a measurement on the other node, so each teleported CNOT contributes two cross-circuit edges to the plan. Script lst:grover in Appendix § 13 composes two teleported CZ gates (oracle and diffusion) into a complete Grover iteration. For two qubits a single iteration amplifies the marked state to unit probability; we verify all four marked states. Per search the workflow consumes two Bell pairs, generates eight conditional instructions, and requires that ancillas be correctly reset between teleported gates. It therefore exercises per-instruction conditional evaluation, multi-round dependency resolution, and mid-circuit qubit reuse at once.

def add_teleported_cnot(wp, ctrl, cname, tgt, tname,
                        prefix, lc):
    """CNOT(ctrl[0] -> tgt[0]) via gate teleportation.
    Uses ancilla qubits ctrl[1], tgt[1]."""
    link = wp.declare_entanglement(
        cname, 1, tname, 1, link_id=f"epr_{prefix}_{lc}")
    ctrl.request_bell_pair(1, link)
    lc += 1
    ctrl.gate("CNOT", [0, 1])
    m1 = ctrl.measure(1, label=f"{prefix}_m1")
    tgt.if_then(m1 == 1, [("X", [1])])
    tgt.gate("CNOT", [1, 0])
    tgt.gate("H", [1])
    m2 = tgt.measure(1, label=f"{prefix}_m2")
    ctrl.if_then(m2 == 1, [("Z", [0])])
    ctrl.if_then(m1 == 1, [("X", [1])])   # reset ancillas
    tgt.if_then(m2 == 1, [("X", [1])])
    return lc, m1, m2

Distributed Bernstein–Vazirani

The Bernstein–Vazirani algorithm recovers a hidden string ss from one query to the oracle f(x)=s⋅xf(x) = s \cdot x. Distributed variants have been proposed [40], and a distributed Deutsch–Jozsa and phase estimation over teleported CNOTs were demonstrated between nodes 7 km apart [39]. We split the input register across two nodes. Alice holds two input qubits and a network ancilla, Bob holds two input qubits, the oracle target prepared in ∣−⟩|-\rangle, and a network ancilla (Script lst:bv in Appendix § 13). The oracle is a CNOT from each input with si=1s_i = 1 into the target, local on Bob’s side and teleported for Alice’s bits through the primitive of Script lst:gtcnot with explicit qubit indices. After a Hadamard on every input, measuring the inputs returns ss. The workflow is the paper’s second algorithm, and its oracle, unlike the Grover oracle, is data-dependent, because the number of teleported gates equals the number of ones in Alice’s part of ss.

Three-node Toffoli gate

A Toffoli (CCNOT) gate spread over three nodes tests whether the same primitives compose when entanglement links and feedforward chains span every pair of a set of nodes. We use the standard decomposition of the Toffoli gate into six CNOTs and single-qubit TT and T†T^\dagger rotations [37]. Nodes A, B, and C each hold one circuit qubit and one network ancilla; the six CNOTs span the pairs B–C, A–C, and A–B, and each is realized by the teleported CNOT of Script lst:gtcnot. Script lst:toffoli in Appendix § 13 shows the construction.

This construction tests ancilla reuse across interactions with two different remote nodes. Node C’s ancilla is reused by four consecutive teleported gates whose control sides alternate between A and B. The second gate’s first instruction on A, a Bell-pair request whose other end is C’s ancilla, carries no measurement reference to the first gate’s final reset of that ancilla, so a planner that ordered only by measurement references would be free to schedule it first. The footprint analysis of pass 1 orders it correctly, because the request acts on C’s ancilla, so it depends on C’s last operation on that qubit, the reset. No synchronization instruction is needed. By the accounting of the primitive, the workflow consumes six Bell pairs, performs twelve mid-circuit measurements plus three final ones, and emits 24 conditional gates, twelve of which reference a measurement on another node. Because node C participates in four of the six teleported gates, its instruction stream interleaves conditionals sourced from both A and B; pass 2 of Algorithm alg:plan resolves these regardless of the order in which the three circuits are processed (P2). We verify the full eight-row truth table, in which qubit C flips exactly when A=B=1A = B = 1.

Distributed repetition code

Error correction across modules is one motivation for a distributed programming model, and its smallest instance is a bit-flip repetition code whose three physical qubits sit on three nodes (Script lst:repetition in Appendix § 13). Node A prepares the logical input (∣0⟩\lvert 0\rangle, ∣1⟩\lvert 1\rangle, or ∣+⟩\lvert +\rangle) and encodes it as α∣000⟩+β∣111⟩\alpha\lvert 000\rangle + \beta\lvert 111\rangle with two teleported CNOTs into B and C. A bit flip is then injected on one node, or on none. Two syndrome ancillas on node B collect s1=ZAZBs_1 = Z_A Z_B (teleported CNOT from A, local CNOT from B) and s2=ZBZCs_2 = Z_B Z_C (local CNOT from B, teleported CNOT from C). Decoding needs one classical AND, since the error is on B exactly when s1=s2=1s_1 = s_2 = 1. A QQLink conditional tests a single measurement bit, so the AND is computed on a third ancilla by a CNOT from the s2s_2 ancilla that runs only when s1=1s_1 = 1, and measured as tBt_B. The corrections are then the single-bit conditionals XBtBX_B^{t_B} on the syndrome node and, on the other two nodes, XAs1⊕tBX_A^{s_1 \oplus t_B} and XCs2⊕tBX_C^{s_2 \oplus t_B}, each written as two conditionals on the same qubit. The workflow consumes four Bell pairs and fourteen measurements and emits 22 conditional instructions, of which twelve reference a measurement on another node, including the four decoder corrections on A and C, which are sourced from syndromes measured on B. After correction the three data qubits agree in the computational basis and equal the logical input when it is ∣0⟩\lvert 0\rangle or ∣1⟩\lvert 1\rangle; we verify all twelve combinations of three inputs and four error locations, and the syndrome triple (s1,s2,tB)(s_1, s_2, t_B) identifies the error location in every case.

Accept/reject control loop

The final workflow exercises the task layer rather than a quantum primitive. It borrows the verify-and-discard pattern of resource-state factories [36] without performing any distillation. A factory node prepares a TT-state with a per-round rotation error ϵ\epsilon drawn uniformly from [−a,a][-a, a], applies a check, and accepts or rejects the attempt on the check outcome; a rejected attempt is retried up to a bound (Script lst:magic in Appendix § 13). The program declares a consumer node, but no operation reaches it. The workflow has no cross-node edge (Table 8 in Appendix § 12) and is a single-node control loop. We evaluate two check circuits. The parity check entangles the data qubit with an ancilla and measures the ancilla; because the prepared state is an equal superposition in the computational basis, this check rejects with probability 1/21/2 independently of ϵ\epsilon. The verification check applies T†T^\dagger and HH to the data qubit and measures it, which rejects with probability sin⁡2(ϵ/2)\sin^2(\epsilon/2) and therefore responds to the injected error. With RR retries and a per-attempt acceptance probability qq, the per-round acceptance probability is 1−(1−q)R+11-(1-q)^{R+1}, with q=1/2q = 1/2 for the parity check and q=1/2+sin⁡(a)/(2a)q = 1/2 + \sin(a)/(2a) for the verification check. The verification check measures, and so consumes, the state it verifies, and the loop is in effect the sampling of a biased coin with retries. The purpose of the workflow is narrower. It shows that accept/reject decisions, bounded retries, and per-round provenance are expressible with the same orchestrator and task primitives used by the protocol workflows, and that the observed statistics match the model. It does not exercise cross-node features, is not run on hardware, and is counted separately from the seven protocol workflows above.

Coverage of the requirements

Taken together, the eight workflows cover R1–R4. Every protocol is authored without backend names (R1). Teleportation, entanglement swapping, Grover, Bernstein–Vazirani, Toffoli, the repetition code, and the accept/reject loop rely on if_then conditionals whose dependencies are resolved by the orchestrator; all but the last do so across circuits (R2). The orchestrator co-locates entangled circuit groups, transitively for the three-node workflows, and provisions Bell pairs through the channel-selection policy of § 5 (R3). The dependency-safe dispatch that sequences a measurement before the corrections it drives operates identically for the three-unit teleportation plan, the eighteen-unit Grover plan, the 51- to 52-unit three-circuit Toffoli plan, and the 41- to 42-unit repetition-code plan whose corrections on two nodes are driven by syndromes measured on the third. An application-level loop over the orchestrator drives the accept/reject retries (R4).

Evaluation

We evaluate QQLink as a software layer for portable multi-QPU workflow semantics. The evaluation asks (Q1) whether planning is deterministic and its output and cost scale as the model predicts; (Q2) whether the workflow model produces correct protocol behavior on independent simulators; (Q3) whether the plan suffices to run a workflow on separate executors, one per node, that share no dispatcher and learn of each other’s progress only through delayed messages; (Q4) what the abstraction costs at the circuit level relative to hand-written dynamic circuits; (Q5) whether the same-chip IBM path realizes measurement-reference and feedforward semantics on partitioned virtual-QPU backends; and (Q6) how the runtime behaves under injected faults, channel failures, and gate noise. We do not present QQLink as a hardware performance benchmark or as a study of multi-chip distributed quantum execution. The six questions map onto the four conditions of the introduction. Q2 and Q5 answer (a), Q1 answers (b), Q4 answers (c), and Q3 answers (d); Q6 checks the runtime controls.

Methodology

Simulator experiments use two independent backends, Qulacs 0.6.14 [18] (statevector) and Qiskit Aer 0.17.2 with Qiskit 2.5.2, which mirrors the IBM transpilation and execution stack, under Python 3.11 on a Linux workstation (Intel Xeon E5-2680 v4, 28 cores, 62 GB RAM). Every number in this section is produced by scripts included in the review snapshot and in the planned release (Data and Code Availability); each script writes a JSON record from which the tables are generated. Correctness is established by exhaustive forced-branch execution on the runtime path (§ 8.3). In addition, the end-to-end runs on both simulators, which are stochastic in their Bell-measurement outcomes, are repeated with fixed seeds, with 16 trials per configuration with randomly drawn messages or inputs, and for teleportation a deterministic per-qubit check in which the inverse preparation RY(−π/(i+2))R_Y(-\pi/(i{+}2)) is applied to Bob’s qubit ii after the corrections and the qubit is measured, which must yield 0. For entanglement swapping, Alice’s and Bob’s qubits are measured in the same basis (ZZ or XX, 16 trials each) and must agree; for Bernstein–Vazirani, all 16 hidden strings are run four times each and the measured string must equal ss; for the repetition code, each of the twelve (logical input, error location) cases is run four times and the three data qubits, measured in the computational basis, must agree and equal the logical input when it is ∣0⟩\lvert 0\rangle or ∣1⟩\lvert 1\rangle. Noise sweeps use Aer with a depolarizing channel of strength pp on two-qubit gates, p/10p/10 on single-qubit gates, and a readout error that flips each measured bit with probability pp, the same for 0 and 1, at 4000 shots. Cost comparisons transpile on a Qiskit GenericBackendV2 with linear coupling and control-flow support at optimization level 1 with a fixed transpiler seed. Hardware runs execute on one IBM backend at a time, partitioned into vQPUs through the path of § 5.4, with 4096 shots per circuit and three independent repeats per configuration, in two sessions a week apart on each of ibm_kingston and ibm_fez; the per-run records (calibration snapshot, physical qubits, job identifiers, counts) are included in the review snapshot and in the planned release.

Planning determinism, structure, and cost (Q1)

Appendix § 12 (Table 8) lists the plans produced by the orchestrator for each workflow across its sweep. Planning each program five times from fresh orchestrator instances yields byte-identical serialized plans in every case, as (P1) predicts. Dense coding plans to k+1k{+}1 units, namely Alice’s whole-circuit unit and one measurement unit per channel on Bob’s side, each joined to Alice’s by a footprint edge. Bob’s side splits into one unit per channel because Alice’s cross-circuit CNOT on channel ii acts on Bob’s qubit ii before Bob measures it, and her requests on later channels act on Bob’s qubits in between; the refinement of § 4 separates them. Teleportation plans to 2n+12n{+}1 units with 2n2n cross-circuit edges, one per correction, nn intra-circuit edges (the XX then ZZ on each of Bob’s qubits), and a critical path of three units for every nn, because the per-qubit chains have disjoint footprints (Figure 3). Entanglement swapping plans to five units across three circuits with a critical path of five, because the plan is a single chain from the Bell-pair requests through Charlie’s measurement and Bob’s corrections to the check. Grover plans to 18 units with a critical path of 11, Bernstein–Vazirani (with two teleported terms) to 19 units with a critical path of 11, and the Toffoli workflow to 51 or 52 units with 23 cross-circuit edges and a critical path of 30; the critical paths of these three are dominated by the sequential reuse of the network ancillas. The Toffoli plan has 52 units when node A’s input is 1, because the refinement then separates A’s input preparation from its first Bell-pair request. The repetition code plans to 41 or 42 units, depending on whether an error is injected and where, with 18 cross-circuit edges and a critical path of 22 or 23; its four teleported CNOTs all reuse node B’s network ancilla, which again sets the critical path. Figure 5 plots the teleportation planning resources over the extended sweep n=1,…,9n = 1,\dots,9; units and edges are exactly linear while the critical path stays constant.

Figure 5. Planning resources for nn-qubit teleportation. Execution units grow as 2n+12n{+}1 and cross-circuit edges as 2n2n; both are exact over the sweep, so plan size is linear in the number of teleported qubits, while the critical path is three units throughout.

To measure planning cost beyond the protocol workflows, we generate synthetic programs with C∈{2,…,64}C \in \{2,\dots,64\} circuits and R∈{4,…,256}R \in \{4,\dots,256\} rounds of (gate, labeled measurement, conditional), where half of the conditionals reference a measurement on another circuit, up to 49,08849{,}088 instructions, 32,70432{,}704 units, and 48,89648{,}896 edges. Figure 6(a) shows that the two-pass planner runs in 8–17 μ\mus per instruction across the whole range, with no super-linear trend. Figure 6(b) shows the topological ordering step before and after replacing the repeated-scan implementation with Kahn’s algorithm. At the largest size, ordering drops from 73 s to 78 ms, and the orchestration overhead of a no-op dispatch from 2.2 ms to 8.2 μ\mus per unit. Over the tested range, planning therefore adds microseconds per instruction, whereas the earlier ordering step added tens of seconds at the largest size.

Figure 6. Orchestration cost on synthetic workflows (2–64 circuits, 22–49,088 instructions). (a) Two-pass planning time is linear in the number of instructions at 8–17 μ\mus per instruction (dashed reference: 10 μ\mus). (b) Topological ordering time versus number of units for the original repeated-scan implementation and for Kahn’s algorithm; the former is quadratic and reaches 73 s at 32,704 units, the latter stays below 80 ms.

Correctness on two simulators (Q2)

We verify the protocol workflows exhaustively over their feedforward branches rather than by sampling. Random trials are a weak test of the feedforward branches. Sixteen trials of one-qubit teleportation miss one of its four correction branches with probability about 4%4\%, the Toffoli workflow has 2122^{12} branches, and the single-shot inverse-preparation check, on the real-amplitude state RY(θ)∣0⟩R_Y(\theta)\lvert 0\rangle, passes an omitted ZZ correction with probability cos⁡2θ\cos^2\theta, which is 0.850.85 for θ=π/8\theta = \pi/8, the angle of the seventh qubit of the largest swept register. On the QQLink runtime path (orchestrator, dispatcher, and Qulacs executor), we force every mid-circuit measurement to each outcome in turn, project and renormalize the state, and prune a branch when the probability of its forced outcome is below 10−1010^{-10}. Each feasible branch is thus run exactly once, deterministically, rather than sampled. For workflows with a quantum output (teleportation, entanglement swapping, Toffoli, and the repetition code) the output measurements are removed, the inputs are loaded from the tomographically complete set {∣0⟩,∣1⟩,∣+⟩,∣+i⟩}\{\lvert 0\rangle, \lvert 1\rangle, \lvert +\rangle, \lvert {+i}\rangle\} on every input qubit, complex phases included, and the fidelity of the output qubits with the ideal output state is computed in every branch. We also check that each branch probability is the same for every input. Each branch then acts linearly on the input, and in exact arithmetic fidelity one on a tomographically complete set proves that it implements the ideal map. In floating point the check bounds the infidelity of each tested output state, not a channel norm, and we report that bound. For workflows with a classical output (dense coding, Grover, and Bernstein–Vazirani) the output measurements are forced too, and a wrong output must be infeasible in every branch.

Table 1 reports the results. In all 2.7×1052.7 \times 10^5 branch executions with a quantum output, every tested output state equals the ideal output to floating-point precision (infidelity at most 5×10−125\times10^{-12}), and the branch probabilities agree across inputs to the same precision. This holds for every branch of three-qubit teleportation, of entanglement swapping, and of the repetition code for each error location, and for all 2122^{12} branches of the Toffoli workflow on 64 inputs. For every input of every workflow, the probabilities of the executed branches sum to one up to round-off (3×10−153\times10^{-15}), so the pruned branches carry no measurable probability. No feasible branch of dense coding, Grover, or any of the 16 Bernstein–Vazirani strings returns a wrong output. To check that the procedure discriminates, we remove the ZZ correction on one qubit of three-qubit teleportation, and the minimum fidelity drops to zero. The repetition-code runs also confirm the decoder’s syndromes. The triple (s1,s2,tB)(s_1, s_2, t_B) equals (0,0,0)(0,0,0), (1,0,0)(1,0,0), (1,1,1)(1,1,1), and (0,1,0)(0,1,0) for no error and errors on A, B, and C. Randomized end-to-end runs on Qulacs and on Qiskit Aer, 16 per configuration, return the expected outcome in every case on both simulators; they test the Aer path, which the forced-branch procedure does not reach. The lowered circuit that the hardware path submits is checked separately. Transpiled with the layout procedure of the hardware runs for Qiskit’s simulated versions of both devices, each of the 38 hardware configurations returns the expected outcome in every one of 200 shots of a noiseless simulation. The coverage therefore differs by path. The runtime path is verified branch by branch on a tomographically complete input set, while the Aer path, the lowered circuits, and the separate executors of § 8.4 are checked by sampling the application-level outcome, which would not reveal an error that leaves that outcome unchanged, such as a phase on a qubit measured in the computational basis.

Schedule invariance.

The dispatcher runs units in authoring order, and the statement of § 4 that any topological order gives the same result is checked by replay. For each of the 38 hardware configurations and for 100 random programs of two or three circuits, which contain cross-circuit CNOTs, local entangling gates, and 132 local and 158 remote measurement references, we run the plan in authoring order on the runtime path, sampling every measurement, from the workflow’s own preparation and from two random product states with complex amplitudes on every qubit. We then replay the plan in random topological orders, a uniformly random ready unit at every step, forcing the kk-th measurement of each qubit to the recorded outcome; the footprint edges fix the order of the measurements on each qubit, so the forced outcomes define the same branch in every order. All 12,096 replays reach a final state of fidelity one with the authoring-order state to within 6×10−136\times10^{-13}, with the same branch probability and the same recorded measurements. As a negative control, we replay the 38 hardware configurations in random orders that respect the footprint edges but not the measurement edges. These replays fail in 5,109 of 7,296 cases and in all 27 configurations whose measurement edges are not implied by footprint edges. The other configurations are dense coding, which has no conditional, and teleportation and swapping, where the unit that measures also issued the Bell-pair request on the corrected qubit, so that a footprint edge already orders the correction after the measurement.

Accept/reject loop.

Table 2 compares the acceptance fraction over 4000 rounds with two retries against the analytic model for both check circuits, with 95% Wilson intervals. The parity check stays at the coin-flip value 0.8750.875 for every error amplitude, and the verification check follows 1−(1−q(a))31-(1-q(a))^3, from certain acceptance at small aa to 0.890.89 at a=3a = 3; in every cell shown the observed fraction lies within 1.51.5 standard errors of the model. We also ran a=0.1a = 0.1 and 0.30.3, which deviate most, by −1.8-1.8 and −2.3-2.3 standard errors in the parity check. Over all eight amplitudes, the parity cells give χ2=11.9\chi^2 = 11.9 for eight degrees of freedom (p≈0.16p \approx 0.16). An earlier run with 400 rounds showed the parity fraction up to 2.72.7 standard errors above the model at a=3a = 3; the tenfold larger sample places that excess within sampling error.

WorkflowInputsBranches per inputBranch runsResult
Teleportation (n=1n{=}1)4416Fmin⁡=1F_{\min} = 1
Teleportation (n=2n{=}2)1616256Fmin⁡=1F_{\min} = 1
Teleportation (n=3n{=}3)64644096Fmin⁡=1F_{\min} = 1
Entanglement swapping–44Fmin⁡=1F_{\min} = 1
Repetition code (per error location)42561024Fmin⁡=1F_{\min} = 1
Toffoli644096262,144Fmin⁡=1F_{\min} = 1
Dense coding (k=1,2k{=}1, 2; six messages)–160 wrong
Grover (4 marked states)–16640 wrong
Bernstein–Vazirani (16 strings)–1–161000 wrong

Table 1. Exhaustive forced-branch verification in simulation, on the QQLink runtime path with the Qulacs state-vector simulator. Quantum outputs: minimum output-state fidelity over every feasible branch and every input from {∣0⟩,∣1⟩,∣+⟩,∣+i⟩}\{\lvert 0\rangle, \lvert 1\rangle, \lvert +\rangle, \lvert {+i}\rangle\} per input qubit; Fmin⁡=1F_{\min} = 1 means 1−Fmin⁡≤5×10−121 - F_{\min} \le 5\times10^{-12}. Classical outputs: feasible branches that return a wrong outcome.

aa (rad)Parity: observedmodelVerification: observedmodel
0.00.879 [0.869, 0.889]0.8751.000 [0.999, 1.000]1.000
0.60.868 [0.857, 0.878]0.8751.000 [0.999, 1.000]1.000
1.00.876 [0.866, 0.886]0.8751.000 [0.999, 1.000]1.000
1.50.875 [0.864, 0.885]0.8750.995 [0.993, 0.997]0.995
2.00.873 [0.863, 0.883]0.8750.982 [0.977, 0.985]0.980
3.00.879 [0.869, 0.889]0.8750.894 [0.884, 0.903]0.892

Table 2. Accept/reject loop. Fraction of 4000 rounds accepted within two retries versus the error amplitude aa, with 95% Wilson intervals, for the parity check (q=1/2q = 1/2) and the verification check (q=1/2+sin⁡a/(2a)q = 1/2 + \sin a/(2a)), against the model value 1−(1−q)31-(1-q)^3.

Separate executors (Q3)

The correctness results above run in one shared state vector, and the hardware runs of § 8.6 run as one dynamic circuit; in both, the nodes of a workflow collapse into one program whose registers carry the node names. Qiskit expresses that case directly, with named registers and if_test. What QQLink adds is a plan that does not need the collapse. Each node’s units, with the dependencies that cross node boundaries made explicit, are enough to run the node on its own controller. Q3 tests exactly that. Each circuit of a workflow runs in its own operating-system process that receives only that circuit’s units and their dependency lists; there is no dispatcher. A controller runs a unit when the units it depends on have completed, and learns of completions on other nodes, with the measurement outcomes they produced, only from messages that arrive in its inbox after a latency L+U(0,L)L + U(0, L). Conditionals are evaluated from the outcomes a node has received. Quantum operations go to an entanglement service, a further process that holds the joint state of all qubits in one Qulacs state vector and applies requests in arrival order. The service is a stand-in for the physical layer, the nodes’ registers and the links between them, since a classical simulation of entangled nodes needs one joint state; it makes no scheduling decision. What is distributed is the control plane, namely readiness, ordering, feedforward, and messaging.

We run the 32 hardware configurations of the six workflows with cross-node feedforward (dense coding has none), 16 times each, at L=0L = 0, 2, and 10 ms, with the full plan and with three ablations of the edges between units of different circuits (Figure 7), namely removing all of them, removing only the measurement edges, which the planner derived from a measurement reference alone, and removing only the footprint edges, derived from a shared qubit alone; an edge with both origins is kept in the two partial ablations. With the full plan all 1536 runs are correct. With every cross-node edge removed, 519 are, between 20% and 49% per workflow family pooled over latencies, and the loss occurs at every latency, including L=0L = 0. The partial ablations separate the two kinds of dependency. Without the measurement edges, 627 of 1536 runs are correct. A node evaluates a correction before the outcome that drives it has arrived and skips it, and Grover, Bernstein–Vazirani, Toffoli, and the repetition code fall to 20–40%. Without the footprint edges, 1068 are. A node issues a teleported gate’s Bell-pair request or reuses an ancilla before the other node has finished with the shared qubit, which breaks Bernstein–Vazirani, Toffoli, and the repetition code (51–79%) but leaves Grover intact. Teleportation and swapping survive both partial ablations and fail when all cross-node edges are removed; in teleportation, the cross-node edges from Alice’s measuring unit to Bob’s corrections have both origins.

The execution span, from the first unit’s start to the last unit’s end, follows the plan’s critical path. After subtracting the span at L=0L = 0, it is proportional to the number of cross-node message hops on the longest dependency path times the mean latency 1.5L1.5L, with fitted slope 1.041.04 (R2=0.99R^2 = 0.99), from one hop for teleportation to twelve for Toffoli. Units on different nodes with no path between them run concurrently, so the span grows with the depth of the cross-node dependency chain, not with the number of units or messages.

This experiment answers the alternative of a single dynamic circuit, which fixes one global order and one controller; the QQLink plan is what lets the same program run without either, with correctness resting on the cross-node edges that the planner derives and the developer never writes. Three limits apply. The quantum state is simulated in one place, so the experiment says nothing about the physics of remote entanglement or about entanglement-generation constraints; latencies are emulated on one machine, not measured over a network; and every message is delivered exactly once, so loss, duplication, and process failure are not tested (§ 5.3).

Figure 7. Workflows on separate executor processes, one per node, exchanging completions and outcomes as messages with latency L+U(0,L)L + U(0, L). (a) Execution span above its value at L=0L = 0 against the number of cross-node hops on the plan’s critical path times the mean latency, for the 32 workflow configurations; dashed: slope one. (b) Fraction of correct runs per workflow family (16 runs per configuration and latency, pooled over latencies) with the full plan, with the cross-node edges that come only from measurement references removed, with those that come only from shared qubits removed, and with all cross-node edges removed; error bars are 95% Wilson intervals.

Instruction-level overhead and cost of abstraction (Q4)

Figure 8 summarizes the instruction-level resource consumption, as authored, of dense coding and teleportation, the workflows with a size parameter, and of Grover; Table 9 in Appendix § 12 lists the full counts. Dense coding and teleportation scale linearly in every count with kk and nn, and their fraction of distributed instructions (Bell-pair requests, cross-circuit CNOTs, and conditionals) is constant, at 33.3% for dense coding and 37.5% for teleportation at every scale. Grover carries 9–10 instructions per qubit and Toffoli 12–13, because each teleported CNOT costs one Bell pair, two measurements, and four conditionals in addition to the local gates. Apart from the cost of single-bit conditions in the repetition decoder, discussed below, this cost is intrinsic to gate teleportation, not to the framework, which the next comparison makes precise.

Figure 8. Scaling of instruction-level overhead across the full protocol sweeps. (a) The fraction of distributed instructions (conditionals, Bell-pair requests, cross-circuit CNOTs) is constant at 33.3% for dense coding and 37.5% for teleportation regardless of qubit count. Grover (single point at 4 qubits, marked state 0101) has a lower distributed fraction (26.3%) because its instruction count is dominated by local oracle and diffusion gates. (b) Per-qubit instruction density is constant for dense coding (3.0) and teleportation (2.67) across the sweep; Grover’s 9.5 instructions per qubit reflects the intrinsic cost of gate teleportation (dashed line: direct-entanglement baseline at 3.0).

To separate protocol cost from abstraction cost, we lower each workflow to a dynamic circuit with the hardware path of § 5.4 and compare it against a circuit for the same protocol written directly in Qiskit, with the same teleported-gate construction, after transpiling both for the same generic backend (Qiskit’s GenericBackendV2; Table 3). On every workflow the lowered circuit has the same two-qubit gate count and the same number of conditional blocks as the hand-written one, and the same depth on all but the repetition code, where the two circuits differ only in the numbering of their classical bits and routing can give the lowered circuit one more layer of depth. The equality holds across transpiler settings. Over ten transpiler seeds at optimization levels 1 and 3, the minimum, median, and maximum two-qubit count and depth of the lowered and hand-written circuits coincide on every workflow, except for the repetition code, whose lowered circuit is deeper by one layer at the extremes of the seed range. This comparison has a limit that we state plainly. Both circuits are ours and use the same teleported-gate construction, so the equality shows that the lowering is faithful to the construction the program describes, and that planning and lowering add nothing on top of it; it does not show that the construction is the one an expert or a compiler would choose, nor that the circuit uses resources optimally. The host-side cost is the planning and dispatch overhead of § 8.2, microseconds per instruction; on the hardware path no host code runs during a shot.

One cost of the programming model itself shows only against a baseline that does not share its restriction. A QQLink conditional tests one measurement bit, so the repetition-code decoder computes s1∧s2s_1 \wedge s_2 on a third syndrome ancilla with a conditional CNOT and measures it. Written by hand with the decoder in classical expressions, which OpenQASM 3 and IBM dynamic circuits accept, the same distributed circuit needs 8 instead of 9 qubits, 13 instead of 14 measurements, and 19 instead of 22 conditional blocks, and each of its 12 configurations is correct in a noiseless simulation. Most of the saving appears after routing. On the line-coupled backend of Table 3 at optimization level 1 it needs 39–42 two-qubit gates over ten seeds (median 42) against 46–79 (median 61) for the lowered circuit, and transpiled for ibm_kingston’s coupling map 38 against 78. Conditions over several measurement references would remove this cost (§ 10).

The monolithic column, which realizes the Grover, Toffoli, and repetition-code gates directly without teleportation, quantifies the cost of distribution instead. A Toffoli over three nodes costs 39 two-qubit gates against 9, and the repetition code 67 against 25 for a monolithic version with the same measured syndromes and decoder. To see how much of that cost a distribution compiler would remove, we distribute the monolithic circuits with pytket-dqc [56], fixing its qubit placement to the nodes of our workflows and applying its embedding and detached-gate refinements (Table 4). For Grover both use two Bell pairs. For the Toffoli gate pytket-dqc needs three Bell pairs where our workflow, with one teleported CNOT per nonlocal gate of the textbook decomposition, uses six, and for the encoding and syndrome extraction of the repetition code three where ours uses four. QQLink executes the distribution it is given and does not optimize it; the comparison quantifies what a compiler placed in front of the planner would save, and is the case for treating distribution compilers as producers of QQLink programs (§ 9).

Two planner choices matter for the match with hand-written circuits. First, ordering is plan metadata, not circuit content. An earlier version of the Toffoli workflow synchronized the reuse of node C’s ancilla with trivial conditional gates, which appeared as ten extra conditional blocks and three extra layers of depth in the lowered circuit, and the footprint analysis of § 4 removes them. Second, the lowering emits units in the planner’s topological order, which follows authoring order wherever the dependencies allow; a topological order that ignored authoring order produced the same gate counts but two to six extra layers of depth.

QQLink loweredHand-writtenMonolithic
Workflow2q / depth / cond.2q / depth / cond.2q / depth
Dense (k=1k{=}1)2 / 11 / 02 / 11 / 0–
Dense (k=4k{=}4)8 / 11 / 08 / 11 / 0–
Teleport (n=1n{=}1)2 / 10 / 22 / 10 / 2–
Teleport (n=7n{=}7)14 / 10 / 1414 / 10 / 14–
Grover (0101)6 / 29 / 86 / 29 / 82 / 12
Toffoli (110110)39 / 83 / 2439 / 83 / 249 / 20
Repetition (∣1L⟩\lvert 1_L\rangle, flip on B)67 / 64 / 2267 / 63 / 2225 / 23

Table 3. Cost of abstraction. Two-qubit gate count, depth, and number of conditional blocks after transpilation on a GenericBackendV2 with linear coupling (optimization level 1, fixed seed; other seeds and optimization level 3 in the text). “Hand-written” is the same protocol authored directly in Qiskit with the same teleported-gate construction; “monolithic” realizes the non-local gates directly and is the reference for the cost of distribution (for the repetition code, direct CNOTs with the same measured syndromes and conditional decoder on six qubits).

pytket-dqc
WorkflowQQLinkone per gaterefined
Grover222
Toffoli663
Repetition code443

Table 4. Bell pairs consumed by the QQLink workflows as authored and by the same monolithic circuits distributed with pytket-dqc over the same qubit placement, with one Bell pair per nonlocal gate and after its embedding and detached-gate refinements. The repetition-code row counts the encoding and syndrome CNOTs.

Same-chip hardware runs (Q5)

We ran the seven protocol workflows on ibm_kingston, a 156-qubit IBM Heron r2 processor, through the path of § 5.4, as 38 configurations, one dynamic circuit each, 4096 shots, and three independent repeats, run between 17:04 and 18:35 UTC on 2026-10-09 against the calibration the device reported at 15:48 UTC. Each node of a workflow occupies its own contiguous stretch of the lowest-error line of qubits for the workflow’s size, so the virtual QPUs are disjoint sectors of the chip; Table 5 lists the physical qubits of every node. On those qubits, the median T1T_1 was 242 μ242\,\mus, the median T2T_2 123 μ123\,\mus, the readout error at most 0.83%0.83\%, and the CZ error at most 0.58%0.58\%. All circuits are transpiled at optimization level 1 except dense coding, which is transpiled without optimization so that, for message 00, the Bell-pair CNOT and the decoding CNOT are not cancelled and the circuit still tests entanglement. We report the fraction of shots that pass the application-level check, pooled over the repeats, with a 95% Wilson interval. A pass/fail check has a chance level that depends on its outcome space, and a circuit without working feedforward can pass it often. Every configuration with feedforward is therefore also run under controls that break the correlation between outcomes and corrections. In (C1) every conditional block is removed, and in (C2) every conditional block is applied or omitted at random, with three fixed random patterns pooled. The ancilla resets of teleported gates are conditional blocks too, so C1 and C2 also change what happens to reused ancillas and shorten the circuit. A reset is a conditional XX on the qubit whose outcome it tests; every other conditional block, including the decoder’s conditional CNOT in the repetition code, counts as a correction. Because C1 and C2 alter the resets, the second session below adds two controls that keep the physical control structure. In (C1′') the corrections are removed and the resets kept, and in (C3) every correction is kept as a conditional block in its place but conditioned on an independent fair coin. Each correction has its own coin, measured on an extra qubit at the start of the same shot, and the resets stay conditioned on the true outcomes. C3 keeps the conditional blocks and resets of the nominal circuit, adds the coin measurements before them, and breaks the outcome–correction correlation in every shot. On ibm_kingston every control ran on the physical qubits of the nominal circuit of its session, C3 with one extra qubit for the coins. C3 then has the same two-qubit gate count and the same number of conditional blocks as the nominal circuit of the second session, except for the repetition code (72 instead of 81 two-qubit gates), and a smaller transpiled depth (126 instead of 174 for Toffoli), so it is close to the nominal circuit but not physically identical. C1 is run once per session, C1′' and C3 once in the second session, each with 4096 shots, and C2 with three random patterns of 4096 shots each. Three patterns sample few of the possible assignments. Their success differs by at most 4.6 points within a configuration and session, except in the repetition code, where it differs by up to 27 points. Taking each pattern as a separate control changes no comparison below, since the same configurations fall under a control level. The highest control of a session is the control level of a check. It is an empirical reference for these circuits, not a bound on what a classical strategy could achieve. The margin is the success minus the control level. We give it with a 95% Newcombe interval for the difference of two proportions pooled over shots, so the uncertainty of the control enters it; the interval does not include the variation between repeats.

WorkflowConfigurationPhysical qubits per node2q / depthSuccess (%)Control (%)
Dense codingk=1k{=}1; message 00 / 01 / 10 / 11A: 148; B: 1492 / 1597.5 / 97.4 / 97.6 / 97.2--
Dense codingk=2k{=}2; messages (00,01) / (11,10)A: 109, 118; B: 128, 1297 / 2492.2 / 92.4--
Teleportationn=1n{=}1A: 109, 118; B: 1292 / 1895.0 [94.6, 95.4]51
Teleportationn=2n{=}2A: 91, 98, 110, 111; B: 109, 11810 / 3290.0 [89.5, 90.5]25
Teleportationn=3n{=}3A: 25, 26, 37, 45, 46, 47; B: 38, 48, 4924 / 4482.7 [82.0, 83.4]14
Entanglement swappingZZ/XXbasisA: 109; C: 118, 129; B: 1283 / 15--1892.1 / 92.250 / 50
Grovermarked 00 / 01 / 10 / 11A: 109, 118; B: 128, 1296 / 4373.6 / 73.1 / 73.5 / 72.426 / 26 / 25 / 26
Bernstein--Vaziranis=1001s{=}1001/01100110(one teleported term)A: 91, 98, 111; B: 109, 110, 118, 12910 / 3583.1 / 83.647 / 48
Bernstein--Vaziranis=1111s{=}1111(two teleported terms)A: 91, 98, 111; B: 109, 110, 118, 12920 / 5744.8 [43.9, 45.7]23
Toffoliinput 000 / 001 / 010 / 011A: 91, 98; B: 110, 111; C: 109, 11854 / 17473.3 / 63.6 / 58.5 / 51.832 / 30 / 32 / 29
Toffoliinput 100 / 101 / 110 / 111A: 91, 98; B: 110, 111; C: 109, 11854 / 17455.1 / 49.9 / 44.5 / 46.830 / 28 / 17 / 18
Repetition code∣0L⟩\lvert 0_L\rangle; flip none / A / B / CA: 25, 26; B: 37, 45, 46, 47, 48; C: 38, 4978 / 128--12967.1 / 44.3 / 57.4 / 55.827 / 10 / 24 / 24
Repetition code∣1L⟩\lvert 1_L\rangle; flip none / A / B / CA: 25, 26; B: 37, 45, 46, 47, 48; C: 38, 4978 / 128--12952.2 / 38.4 / 43.6 / 44.420 / 9 / 23 / 23
Repetition code∣+L⟩\lvert +_L\rangle; flip none / A / B / CA: 25, 26; B: 37, 45, 46, 47, 48; C: 38, 4978 / 128--12967.4 / 64.9 / 65.9 / 66.127 / 25 / 25 / 26

Table 5. Hardware results on ibm\_kingston (Heron r2), 2026-10-09, 4096 shots, three repeats per configuration. Each node occupies a disjoint stretch of physical qubits (A, B, C: node names; for entanglement swapping, C is the middle node). ``2q / depth'' is the transpiled two-qubit gate count and depth. Success is the percentage of shots that pass the application-level check, pooled over the repeats; the 95% Wilson interval is given for single-configuration rows and is at most ±0.9\pm 0.9 points for every entry. Control is the larger of the success percentages of the same circuit with every conditional block removed (C1) and applied at random (C2); Table 11 in Appendix § 12 gives every repeat, the second session, and all four controls. Readout mitigation is not applied.

Outcomes.

On ibm_kingston every configuration with feedforward succeeds above its control level, with a margin whose 95% lower bound is at least 19 points. Within this session, the corrections that the plan routes between nodes act on the device. Dense coding, entanglement swapping, and one- and two-qubit teleportation succeed in at least 90%90\% of shots, and three-qubit teleportation in 83%83\%. The workflows built from teleported gates lose more. Grover succeeds in 7272–74%74\% of shots for every marked state, Toffoli in 4545–73%73\% (highest for input 000, lowest for inputs 110 and 111), and the repetition code in 3838–67%67\%. The partition into disjoint sectors costs success only where it adds routing. Compared with a layout in which the qubits of different nodes interleave along the same line, success agrees within two points on every workflow except the repetition code, whose disjoint layout needs 78 instead of 57 two-qubit gates and loses 3 to 11 points.

A second session.

Seven days later, on 2026-10-16 between 14:40 and 15:01 UTC, we repeated the suite on ibm_kingston with three repeats and all four controls, against the calibrations reported at 14:27 UTC (suite, C1, C2, and the coherence checks) and 14:46 UTC (C1′', C3, and probe (v) below). The sector search, run on that day’s calibration, placed most workflows on other qubits. Twenty-three of the 38 configurations reproduce within 3 points; dense coding, one- and three-qubit teleportation, swapping, and Grover change by at most 2.7 points. Bernstein–Vazirani and Toffoli, which the search placed on qubits 137 and 147–152, lose 18 to 31 points. Two-qubit teleportation, on qubits 147–152, loses 6, and the repetition code changes by −9-9 to +10+10 points across error locations. The standard deviation between the three repeats of a session is at most 1.91.9 points on ibm_kingston and 3.43.4 points on ibm_fez, so the variation between sessions and sectors is four to sixteen times larger, and the pooled intervals of Table 5 describe one session on one set of qubits. The calibration the device reports does not predict the change. A noise model built from its calibration of 2026-10-16 (15:21 UTC) and applied to the qubits of both sessions gives two-term Bernstein–Vazirani 92%92\% and 91%91\% and Toffoli 8484–87%87\% on either set of qubits; only three-qubit teleportation differs between the two sets by more than 3 points (90%90\% against 93%93\%). In the pooled-shot comparison, every configuration with feedforward still exceeds all four controls of its session, C1′' and C3 included, but the smallest lower bound of the margin, for Toffoli input 101, falls to 0.7 points (Table 11).

On ibm_fez (Table 10 and Table 12), two-term Bernstein–Vazirani falls below its control level on 2026-10-09 (18.3%18.3\% against 22%22\%). On 2026-10-16 only C1′' and C3 were run on ibm_fez, for Bernstein–Vazirani and Toffoli, in a separate job whose sector search placed them on qubits 108–112, 118, 129, and 130 instead of the suite’s 137 and 142–147, so that day’s comparisons are between sectors. Against these controls two-term Bernstein–Vazirani exceeds its control level (30.6%30.6\%, margin at least 7 points), and Toffoli inputs 100 and 101, which exceed their controls on 2026-10-09, fall 2.8 points below C1′', which keeps the resets, but still exceed C3. Every other ibm_fez configuration with feedforward succeeds above its control level in the sessions in which its controls were run.

What the checks show.

The application-level checks differ in what they establish, and four further checks, summarized in Table 6, test what a pass/fail check of the classical output cannot see. Teleportation’s inverse-preparation check tests only the input it prepares. We therefore teleported each of the six cardinal states, a 2-design, on ibm_kingston on 2026-10-16 and checked each by inverse preparation. The measured quantity is the six-state mean survival probability, 0.9610.961 [0.960,0.963][0.960, 0.963]. With ideal state preparation and readout it would be the average fidelity FavgF_\mathrm{avg} of the teleportation channel and correspond to a process fidelity of (3Favg−1)/2=0.942(3F_\mathrm{avg} - 1)/2 = 0.942 [0.940,0.944][0.940, 0.944]. We did not characterize preparation and readout separately, so both numbers are estimates that attribute their errors to the channel. For entanglement swapping, the agreement in the XX and ZZ bases, measured on separate runs of the same circuit with trusted single-qubit measurements and no readout correction, bounds the fidelity of the swapped pair with ∣Φ+⟩\lvert\Phi^+\rangle by F≥pequal,X+pequal,Z−1F \ge p_{\mathrm{equal},X} + p_{\mathrm{equal},Z} - 1. The estimate of the right-hand side is 0.8430.843 [0.836,0.850][0.836, 0.850] on 2026-10-09 and 0.8640.864 [0.857,0.870][0.857, 0.870] on 2026-10-16, so under these assumptions F≥0.836F \ge 0.836 and F≥0.857F \ge 0.857 at 95% confidence, and the swapped pair is entangled.

The Toffoli truth table tests classical behavior only; a channel that dephased its output would pass it. With one control in ∣+⟩\lvert +\rangle, the other in a basis state bb, and the target in ∣−⟩\lvert -\rangle, the gate maps the ∣+⟩\lvert +\rangle control to ∣−⟩\lvert -\rangle exactly when b=1b = 1. We ran this check for control A in ∣+⟩\lvert +\rangle with bB∈{0,1}b_B \in \{0, 1\} and for control B in ∣+⟩\lvert +\rangle with bA∈{0,1}b_A \in \{0, 1\}. A shot passes when the XX-basis readouts of the ∣+⟩\lvert +\rangle control and of the target and the ZZ-basis readout of the other control all take their ideal values. The check passes in 1313–24%24\% of shots, against 8080–82%82\% in the device-noise simulation. Complete dephasing of the ∣+⟩\lvert +\rangle control would halve the success of the matching truth-table inputs, and for three of the four configurations the check reaches about half of the mean truth-table success of the two inputs that the control superposes, on the same day and qubits. The check does not establish coherent Toffoli action on that sector. The repetition code’s computational-basis agreement for ∣+L⟩\lvert +_L\rangle would also accept an incoherent mixture of ∣000⟩\lvert 000\rangle and ∣111⟩\lvert 111\rangle. Read in the XX basis, the logical state has even parity in 4848–53%53\% of shots for every error location, against 8585–86%86\% in simulation. The runs therefore do not demonstrate that the intended logical superposition is preserved. The parity alone does not tell dephasing from a coherent phase error, since the state (∣000⟩+i∣111⟩)/2(\lvert 000\rangle + i\lvert 111\rangle)/\sqrt{2} also gives 50%50\%. We claim no error-correction advantage over an unencoded qubit. The repetition-code runs test the routing of syndromes to corrections across nodes, not error correction.

CheckDateObservableShotsMeasuredModelInterpretation
Teleportationn=1n{=}1, six cardinal inputs2026-10-16mean survival probability of inverse preparation6×4096×36 \times 4096 \times 30.961 [0.960, 0.963]; per state 0.949--0.9760.982--0.987process fidelity 0.942 if preparation and readout errors are attributed to the channel
Entanglement swapping2026-10-09 / 2026-10-16pequal,X+pequal,Z−1p_{\mathrm{equal},X} + p_{\mathrm{equal},Z} - 1, a lower bound on the fidelity with∣Φ+⟩\lvert\Phi^+\rangle2×4096×32 \times 4096 \times 3per date0.843 [0.836, 0.850] / 0.864 [0.857, 0.870]0.95 / 0.96F≥0.836F \ge 0.836/0.8570.857at 95% confidence; pair entangled
Toffoli, one control in∣+⟩\lvert +\rangle, target in∣−⟩\lvert -\rangle2026-10-16all three readouts ideal,XXbasis on the∣+⟩\lvert +\ranglecontrol and the target4×4096×34 \times 4096 \times 313.4--24.3%80--82%coherent action not established
Repetition code,∣+L⟩\lvert +_L\rangle, flip none / A / B / C2026-10-16even logicalXXparity4×4096×34 \times 4096 \times 348.3--53.0%85--86%preservation of the intended superposition not established

Table 6. Coherence-sensitive checks on ibm\_kingston. Shots are given as configurations ×\times shots ×\times repeats. Measured values are pooled over repeats. Brackets are 95% confidence intervals, computed as Wilson intervals for single proportions and as normal-approximation intervals for the teleportation mean over the six inputs and for the swapping bound, a sum of two independent proportions. Values joined by a dash are ranges over the configurations of a row, not intervals; model values are ranges or point values from 4000-shot simulations. The model is the device-noise simulation with the calibration of 2026-10-16, 15:21 UTC. Readout mitigation is not applied.

Where the deeper workflows lose.

To separate the device’s gate and readout errors from the structure of the circuits, we simulated every configuration, transpiled for the physical qubits of each session, with the noise model built from the calibration of 2026-10-16 at 15:21 UTC (§ 5.4), the model used above; for the first session’s qubits it describes the device a week after the runs. Without noise, every circuit transpiled for these qubits passes its check in every shot. The gap between device and model divides the workflows in two. On the first session’s qubits, dense coding, teleportation, and entanglement swapping fall short of the model by at most 7 points, the most for three-qubit teleportation with its 24 two-qubit gates. The workflows built from teleported gates fall short by more, and not in proportion to their gate counts. Grover, with 6 two-qubit gates, falls short by 23–24 points; Bernstein–Vazirani by 11–12 points with one teleported term and by 47 with two (45%45\% on the device against 92%92\% in the model); Toffoli by 13 points for input 000 up to 40 for input 110; and the repetition code by 18–38 points. On the second session’s qubits the gaps of these workflows are 15 to 65 points. This excess loss is not explained by the model’s gate and readout errors, so it lies in what the model omits or misdescribes. Candidates are qubits that idle while others are measured, corrections executed as conditional blocks, crosstalk, errors that a measurement induces on neighboring qubits, and, as the second session suggests, qubit defects that the reported calibration does not show.

Five probes bear on these candidates; their qubits are those the sector search selected on the day of each run. The first four ran on ibm_fez, where two-term Bernstein–Vazirani was weakest on 2026-10-09. (i) Idle qubits accrue phase. We ran a Ramsey sequence on an explicit delay of 0 to 24 μ24\,\mus, read out in the XX and YY bases with one run of 4096 shots per delay. A linear fit to the phase, with bootstrap intervals for shot noise only, gives a rotation at 25.725.7 kHz [25.4,25.9][25.4, 25.9] for one qubit of the Bernstein–Vazirani sector on 2026-10-09, and at 13.513.5 [13.1,13.8][13.1, 13.8] and 1.01.0 [0.6,1.3][0.6, 1.3] kHz for two qubits of another sector on 2026-10-12. The second qubit of the Bernstein–Vazirani sector oscillates at 45.145.1 [44.8,45.4][44.8, 45.4] kHz in the XX basis with no YY component, which is consistent with a qubit frequency that switches between two values on either side of the drive frequency and not with a fixed detuning. On both qubits of that sector, a single echo at the midpoint removes the oscillation; the 2026-10-12 run had no echo variant. On 2026-10-12, two qubits of a third sector, held by a barrier until eight rounds of measurement and correction on other qubits had finished, keep their state in 97%97\% of shots, so in that sector waiting through feedforward is harmless. (ii) Conditional execution can disturb the qubits it acts on. In every round, two qubits each receive a gate twice under the same random condition, measured on a third qubit, so that the net operation is the identity. On qubits 142 and 143 of the Bernstein–Vazirani sector on 2026-10-09, both keep their state after one round in 9595–96%96\% of shots; after four rounds one qubit is left in a random state and the other is found inverted in 8888–89%89\% of shots, for XX as well as ZZ gates. On qubits 8 and 9 on 2026-10-12, both keep their state in 9292–93%93\% of shots after one round, and each keeps it in 7777–81%81\% after four.

(iii) Coherent control in place of feedforward. Every measurement stays in place, so the measurement record is unchanged. Each conditional block on another qubit becomes the corresponding controlled gate from the measured qubit, which by the deferred-measurement principle acts as the classically controlled gate, and the conditional XX that resets a reused ancilla becomes an unconditional reset. No classical feedforward remains. On ibm_fez on 2026-10-12, two-term Bernstein–Vazirani then succeeds in 48%48\% of shots instead of 17%17\%, although its two-qubit gate count doubles from 20 to 39. In the same job, teleportation, Grover, one-term Bernstein–Vazirani, and Toffoli become worse by 1.7 to 14 points. On 2026-10-09, rewriting the ZZ correction on the controls as HH, a conditional XX, and HH raises two-term Bernstein–Vazirani from 19%19\% to 31%31\%. (iv) Echoes on idle intervals. IBM Runtime rejects its own dynamical decoupling for dynamic circuits, so we wrote one pair of XX gates per idle interval into the lowered circuit, anchored by barriers. This raises Bernstein–Vazirani from 74%74\% to 8383–84%84\% with one term and from 17%17\% to 28%28\% with two, but lowers three-qubit teleportation from 85%85\% to 36%36\% and the repetition code by up to 36 points. For teleportation the barriers serialize the circuit and lengthen it by about half its depth; for the repetition code, whose depth does not grow, the cause is not resolved. The echo pass changes the transpiled circuit beyond the echoes (two-term Bernstein–Vazirani, for example, goes from 20 to 32 two-qubit gates), so these comparisons are not between otherwise identical circuits. (v) Coherent control on the same qubits. To remove the differences of device, sector, and day from probe (iii), we ran the feedforward and coherent-control versions of every teleportation, Grover, Bernstein–Vazirani, and Toffoli configuration on the same physical qubits of ibm_kingston on 2026-10-16, interleaved in one job, two rounds each. On these qubits, coherent control lowers two-term Bernstein–Vazirani from 23%23\% to 12%12\% (difference −11-11 [−12,−10][-12, -10] points), Grover by 10 to 12 points, and teleportation by 2 to 5 points. It raises one-term Bernstein–Vazirani by 6 points and changes Toffoli by −5-5 to +12+12 points, depending on the input.

These probes establish sensitivity, not a mechanism. The success of the deeper workflows depends on how the dynamic control is executed (as feedforward, as coherent control, or with echoes) and on where it runs. The effect of coherent control on two-term Bernstein–Vazirani changes sign between the ibm_fez sector of 2026-10-12 and the ibm_kingston sector of 2026-10-16, and the second-session loss on ibm_kingston does not appear in the reported calibration. We therefore do not attribute the excess loss to one process. Characterizing it would need controlled comparisons across sectors and days, and timing information that the runs do not give, because Qiskit’s scheduler does not accept conditional blocks, and the runtime reports no per-circuit durations. The plan identifies every correction and the qubit it acts on, so choosing coherent control or feedforward per correction is a local decision of the hardware path.

What the runs establish.

For Q5, the same program object that runs on two simulators and on separate executors runs on the devices with no change at the application layer. On ibm_kingston, in both sessions, every configuration with feedforward succeeds above the control level of its check in the pooled-shot comparison. The lower bound of the smallest margin, 0.7 points in the second session, comes from an interval that excludes the variation between repeats, so the comparison does not establish an advantage that holds across jobs, sectors, or calibrations. On ibm_fez three configurations fall below their control level in one of the two sessions. Each number is tied to a calibration snapshot, a physical sector per node, and a job identifier. The runs also show what same-chip execution of these protocols does not yet deliver. The workflows built from teleported gates fall up to 65 points short of a simulation with the device’s gate and readout errors, their success changes by up to 31 points between sessions on qubits that the calibration does not distinguish, and the coherence-sensitive checks do not establish coherent Toffoli action or preservation of the intended repetition-code superposition.

Robustness and noise sensitivity (Q6)

Runtime controls.

This experiment is a functional check of the retry and channel controls, not a fault-tolerance result. We wrap the executor in a dispatcher that raises a transient error with probability pfailp_\mathrm{fail} before a unit executes, and run 200 Grover searches (18 units) for each combination of pfail∈{0,0.1,0.3,0.5}p_\mathrm{fail} \in \{0, 0.1, 0.3, 0.5\} and retry budget {0,2,5}\{0, 2, 5\} (Figure 9(a)). Completion follows the binomial expectation. Without retries it is (1−pfail)18(1-p_\mathrm{fail})^{18}, and 29 and 1 of 200 runs complete at pfail=0.1p_\mathrm{fail} = 0.1 and 0.30.3 (expected 30 and 0.3). With five retries, 200 and 197 complete (expected 200 and 197), and 163 at 0.50.5, two binomial standard deviations above the expected 151. Every completed run returned the marked state. Because the fault is injected before the unit runs, a retry is trivially safe; the cases that matter physically are not covered. For a fault after some of a unit’s instructions have acted on the state, the runtime applies rule (i) of § 5.3 and reports the failure without retrying it, which a unit test checks. On the hardware path the workflow is one circuit and unit-level retry does not apply. Figure 9(b) checks the channel-level retries in the same way. In a two-qubit teleportation, each of the two Bell-pair requests succeeds with probability ss on a simulated link that models availability, not entanglement. Without retries completion is s2s^2, and three channel-level retries raise it to 100, 97, and 87 of 100 at s=0.9,0.7,0.5s = 0.9, 0.7, 0.5. The separate-executor experiment of § 8.4 replaces the shared dispatcher with message passing between processes; it does not model link failures.

Figure 9. Runtime controls under failure. (a) Fraction of 200 Grover workflows (18 units each) that complete when each unit dispatch fails with probability pfailp_\mathrm{fail}, for three retry budgets; every completed run returned the marked state. (b) Fraction of 100 two-qubit teleportation workflows that complete when Alice and Bob run on separate simulator instances and each Bell pair traverses a simulated link with success probability ss, without and with three channel-level retries. The 95% binomial interval of each point is at most ±0.07\pm0.07 in (a) and ±0.10\pm0.10 in (b).

Gate and readout noise.

Figure 10 shows the success probability of the decoded outcome for the lowered dynamic circuits of five workflows on Aer under the noise model of § 8.1, namely dense coding with k=2k{=}2, three-qubit teleportation, Grover with marked state 01, Toffoli with input 110, and the repetition code on ∣1L⟩\lvert 1_L\rangle with a flip on B. The orchestration is unchanged across the sweep; only the noise strength varies. At p=10−2p = 10^{-2} dense coding succeeds with probability 0.93, teleportation 0.90, Grover 0.90, the repetition code 0.83, and Toffoli 0.82; at p=3×10−2p = 3\times10^{-2} the values are 0.80, 0.75, 0.76, 0.58, and 0.57. The Toffoli and repetition-code workflows, with 39 and 67 two-qubit gates after transpilation, are the most fragile, which is the protocol cost of Table 3 made visible under noise; the repetition code corrects the injected flip but, at these physical error rates, not the errors the protocol itself introduces. The sweep isolates gate and readout noise; it omits the time structure of the dynamic circuit, which § 8.6 probes on hardware.

Figure 10. Success probability of the decoded outcome versus noise strength pp (depolarizing pp on two-qubit gates, p/10p/10 on single-qubit gates, readout error pp; 4000 shots) for the lowered dynamic circuits of five workflows. The leftmost point is the noiseless case; the 95% binomial interval of each point is at most ±0.016\pm0.016, smaller than the markers. The two workflows with the most two-qubit gates are the most fragile; planning adds no gates beyond the authored construction.

Lessons learned

Several defects surfaced during this work, each caught by one of the checks above rather than by inspection. We list them because they show which checks a framework of this kind needs. (i) An earlier Aer adapter re-executed the accumulated circuit on every mid-circuit measurement and returned the most frequent bit of 1024 shots. Dense coding, which has no feedforward, passed. Teleportation, Grover, and Toffoli succeeded only about as often as with uncorrelated corrections (8/16, 22/64, and 44/128), while Qulacs passed every check. The defect shows the adapter contract of § 5 in concrete form, and it was caught only because two simulators were compared. (ii) The first topological ordering was quadratic in the number of units (§ 8.2); only the synthetic sweep, not the protocol workflows, was large enough to show it. (iii) The first planner split a segment only at the requesting circuit’s own request, so two circuits issuing requests on each other’s qubits could produce a dependency cycle. None of the eight workflows did, and the dispatcher’s topological sort would have rejected one; the refinement and proof of § 4 close the gap. Randomly generated programs with cross-circuit requests now form part of the test suite. Before the change, 211 of 300 produced a cycle, and none did after. (iv) Qulacs defines rotation gates as exp⁡(+iθP/2)\exp(+i\theta P/2), the opposite sign to Qiskit, and the Qulacs adapter passed the angle through. Every workflow in this paper is invariant under the flip, so no result changed, but a program with an asymmetric rotation would have prepared different states on the two simulators, contrary to condition (a) of the introduction. A test now compares single-qubit rotations across backends. (v) Qiskit Aer, given one batch that mixes control-flow circuits with circuits that have fewer classical bits, returned counts for the wrong circuits in our runs. A batched dry run reported, for example, 0.400.40 for the Bernstein–Vazirani string 00110011, which succeeds with probability 0.970.97 when simulated alone under the same noise model. The dry run now simulates circuits one at a time; hardware jobs, which return results per circuit, were not affected.

Related Work

Several lines of work address parts of the multi-QPU software stack. We group them by the level at which they operate and state, for each, the delta to QQLink.

Distributed circuit compilation and partitioning.

Andrés-Martı́nez and Heunen [14] and Ferrari et al. [15] partition monolithic circuits across QPUs by minimizing inter-partition communication, through hypergraph partitioning or integer programming. Baker et al. [24] partition in time slices for modular architectures, and AutoComm [25] aggregates communication into burst operations at compile time. pytket-dqc [56] distributes a monolithic circuit over heterogeneous modular networks and implements the resulting nonlocal gates with entanglement-assisted communication, minimizing the number of Bell pairs consumed. These approaches produce static partitions and leave runtime concerns, such as when a conditional correction may run or how Bell pairs are provisioned, to the execution layer. These compilers and QQLink meet at the teleported gate. A compiler such as pytket-dqc or AutoComm decides where nonlocal gates go and how to batch their communication, starting from a monolithic circuit; QQLink starts from per-node programs in which the teleported gates are already written, and decides when each correction may run and on what target. The two are complementary, because a distribution produced by such a compiler is an input QQLink could plan, with QQLink’s platform layer choosing placement, resolving cross-circuit dependencies, and orchestrating execution. § 8.5 measures the gap. With the qubit placement of our workflows fixed, pytket-dqc distributes the Toffoli gate with half the Bell pairs our hand-authored workflow uses. At the fault-tolerant end, network-based quantum computing [55] is an architecture and compilation framework for many small nodes holding one or a few logical qubits each, in which data keeps moving through the network; it fixes the machine organization that a runtime such as QQLink would then program against. Surveys of the field [1, 34] catalog these compilers but do not identify a workflow-level orchestration layer of the kind proposed here.

Circuit cutting and knitting.

Circuit cutting [12, 13] decomposes a circuit into sub-circuits that run independently on separate backends, with classical post-processing reconstructing the global expectation value. This trades quantum communication for exponential classical overhead and suits settings where entanglement distribution is unavailable. In its standard form it cannot express protocols that require real-time feedforward, such as the Pauli corrections in teleportation or the conditional resets in gate teleportation, because the sub-circuits never interact at runtime. QQLink takes the opposite stance. It assumes that entanglement and classical channels are available and provides the runtime machinery to consume them.

Quantum network simulators and network stacks.

NetSquid [16], SeQUeNCe [17], and QuNetSim [26] model network-layer physics such as photon loss, link scheduling, purification, and memory decoherence. Interlin-q [27] adds a control-node model for distributed algorithm simulation on top of QuNetSim. Chen et al. [49] orchestrate Bell-pair generation, routing, and caching through a hub-and-spoke photonic interconnect, deciding when to schedule teleportation-based nonlocal gates under loss and decoherence; their orchestrator allocates entanglement as a physical resource, which is the service QQLink’s entanglement channels consume. These simulators and orchestrators model or allocate the network; QQLink operates above them and could target a network simulator as a provider-native channel executor.

Quantum-internet node software.

Three systems for programmable quantum-network nodes are the closest to QQLink in their abstractions, and Table 7 compares them. NetQASM [28] is a platform-independent instruction set for hybrid programs on a network node together with a Python SDK. In the SDK a host program runs on one node; measurement results are futures that resolve when the queued operations are flushed to the node controller; entanglement is generated through EPR (Einstein–Podolsky–Rosen pair) sockets whose create and recv calls must be paired on the two nodes; and classical information crosses nodes through explicit socket messages. QNodeOS [45] is an operating system that executes such per-node programs, with entanglement request sockets, virtual qubit addresses, and multitasking; it ran applications on two nitrogen-vacancy (NV) center nodes and was given a driver for a trapped-ion node, and its architecture is platform independent. Qoala [57] extends QNodeOS with a program format of host-code blocks, local routines, and entanglement-request routines. Its runtime turns program segments into tasks of a directed acyclic task graph with precedence and deadline constraints and schedules them jointly and asynchronously; it is evaluated with a simulator validated against network hardware. All three partition an application into single-node programs whose cross-node coordination the programmer writes, namely paired socket calls, sends and receives, and the order in which they occur. QQLink differs in where coordination comes from. A program describes all nodes at once; a correction on one node references the measurement handle of another; entanglement is declared once as a link; and the planner derives the cross-node dependencies, both measurement references and the ordering of shared qubits, together with each node’s units (§ 4). The per-node units with their incoming edges are exactly what the separate executors of § 8.4 run, so a QNodeOS or Qoala node could serve as the executor for one node of a QQLink plan, with the plan’s edges becoming its messages and socket calls.

Authoring unitCross-node coordinationSchedulingDemonstrated on
NetQASM SDKone host program per nodewritten: paired EPR-socket calls, socket messages; results as futuresprogram order per nodeNetSquid, SimulaQron
QNodeOSper-node programs (NetQASM)written, as above; entanglement request socketsnode OS, multitaskingtwo NV-center nodes; trapped-ion driver
Qoalaper-node programs (host blocks, routines)written per noderuntime task DAG with deadlines, joint and asynchronoussimulator validated against hardware
QQLinkone program over all nodesderived: measurement and footprint edges from handles and declared linkstopological dispatch, or one controller per nodeQulacs, Aer, separate processes, same-chip IBM Heron

Table 7. QQLink and the closest node-level software for quantum networks.

Programming models for multi-QPU execution.

QMPI [29] proposes a message-passing interface for distributed quantum programs, transposing the Message Passing Interface (MPI) model to quantum communication. NetQMPI, an MPI-inspired model in the same spirit, has been coupled to the CUNQA emulator, which exposes virtual QPUs on HPC systems, as its execution backend [54]; in both, the programmer writes the communication explicitly, whereas QQLink derives it from declared entanglement and measurement references. OpenQASM 3 [23] and hardware demonstrations of dynamic circuits [22] support mid-circuit measurement and classical feedforward within a single circuit on a single backend, but do not extend to cross-circuit or cross-backend conditionals. Heterogeneous frameworks such as XACC [30] and CUDA-Q [31] target multiple backends through a common intermediate representation but treat each program as a single kernel bound to one QPU; XACC’s virtual QPUs [38] parallelize independent circuits rather than entangled partitions. QQLink differs in that the unit of authoring is the workflow node with typed measurement handles, and the orchestrator, not the programmer, resolves the resulting dependency graph.

Hybrid workflow and task systems.

Covalent [19], Qiskit Serverless [32], and Pilot-Quantum [33] orchestrate hybrid quantum–classical workflows as directed task graphs, providing retry logic, distributed execution, and HPC resource management. From a software-architecture perspective, Weder et al. [51] argue that hybrid applications need two orchestrations at once, a workflow over quantum and classical programs and a deployment topology, and Beisel et al. [52] collect operations patterns for packaging, executing, and observing such applications. Qunicorn [53] gives unified access to heterogeneous quantum cloud offerings by translating circuit and result formats, and QCOEM [50] schedules independent tasks across noisy, queued backends by multi-objective optimization. In all of these the quantum program is an opaque task bound to one backend; none models inter-QPU entanglement, cross-circuit conditional gates, or entanglement-aware placement. QQLink unifies intra- and inter-circuit feedforward with entanglement-aware planning and dependency-safe dispatch in one framework, and its task layer could itself be hosted by such a workflow system.

Quantum–HPC software stacks.

Production quantum–HPC stacks integrate QPUs into computing centers as accelerators. The Quantum Framework (QFw) [41] orchestrates hybrid applications over simulators and hardware with HPC process management, and the Munich Quantum Software Stack [43] exposes heterogeneous devices behind a device-management interface. The openQSE survey [42] reviews nine such stacks and proposes a reference architecture whose Quantum Runtime Interface and QHPC-Interconnect layers mediate between resource managers and devices; it names as an open gap that communication semantics in these stacks must extend beyond one-way circuit submission to bidirectional interaction. QQLink is not a stack in this sense. It manages neither processes nor devices, its task layer could be hosted by QFw, and its workflows could be scheduled by a multi-tenant placement framework such as CloudQC [44], which allocates many independent jobs across a QPU cluster. What QQLink supplies, at the application and workflow layer, is one form of the bidirectional interaction the survey identifies as missing, with measurement outcomes that cross between programs, entanglement declared as a resource, and a planner that turns both into a dependency graph the runtime executes. Three further works are close in intent. NetQIR [46] extends the Quantum Intermediate Representation (QIR) with distributed primitives and is a possible lowering target below QQLink’s planner. Zhang et al. [47] simulate distributed circuits end to end with communication-noise models by inserting teleported gates into a monolithic circuit, whereas QQLink starts from per-node programs and also executes them on hardware. Finally, Gupta et al. [48] quantify the crossover between gate teleportation and circuit cutting as a function of interconnect noise, which indicates when a runtime built around entanglement and classical channels is preferable to cutting alone.

Experimental distributed quantum computing.

Main et al. [3] executed a distributed Grover search across an optical network link between two ion-trap modules using teleported gates. The Grover workflow of § 7.4 reproduces the structure of that experiment at the application layer; the difference is that our execution substrate is a partitioned single chip rather than two networked modules, a limitation discussed next.

Limitations and Threats to Validity

Execution substrate.

QQLink validates multi-QPU workflow semantics in two settings, namely simulator execution and same-chip virtual-QPU execution on two IBM backends, each partitioned on its own. These results support the programming model and execution layer, but they do not constitute an experimental study of physically distributed multi-chip execution across networked hardware. Protocol-level results are obtained through the co-located path, and the separate-executor experiment of § 8.4 distributes the control plane but keeps the joint state in one entanglement-service process, because two independent state vectors cannot share a Bell pair; its latencies are emulated on one machine. Extending the channel path to provider-native executors for physical links across distinct chips is an open engineering task. On a partitioned chip, a “non-local” gate is a native two-qubit gate between sectors, so hardware counts in Table 5 bound only the same-chip realization and say nothing about link-limited fidelity.

Hardware evaluation depth.

§ 8.6 states what the runs establish; four features of their design limit how far the results generalize. First, the suite comes from two sessions a week apart on each of two devices, and success changed between sessions by up to 31 points on ibm_kingston and 14 on ibm_fez; two sessions show this variation but do not characterize its distribution. Second, the margins over the controls are pooled-shot intervals that exclude the variation between repeats, and the ibm_fez controls of 2026-10-16 ran on other qubits than the suite. Third, the probes use different sectors on different days, and the device-noise simulations are unscheduled, assign no error to idle intervals, and come from a calibration that did not predict the second-session loss. Fourth, the coherence-sensitive checks ran in one or two sessions on one sector each, and for the Toffoli gate and the repetition code they fail, so for these workflows the runs establish classical input–output behavior and the routing of outcomes to corrections, not coherent operation. The noise sweep of § 8.7 quantifies protocol fragility only within a depolarizing-plus-readout model, which omits these effects.

Parallelism is exposed but not exploited.

The plan records dependencies at qubit granularity, so the per-qubit chains of Figure 3 are independent and the teleportation critical path is three units for any register size. The default dispatcher still executes units one at a time in a topological order, so this parallelism is not yet realized; a concurrent dispatcher is future work, and since the sequential dispatcher costs 2 to 8 microseconds per unit in all but one configuration of the synthetic sweep (48 in that one), it would pay off only against backend latency, not against orchestration cost. The separate-executor experiment shows the gain in the setting where it matters. There, independent units on different nodes run concurrently, and the span follows the cross-node critical path.

Single-bit conditionals.

A conditional tests one measurement bit against one value. Decisions that depend on several bits, such as the AND in the repetition-code decoder, are expressed by computing the function on an ancilla with classically controlled gates and measuring it, which costs a qubit and a measurement per Boolean gate, and in the repetition code 19 to 40 two-qubit gates after routing (§ 8.5). This is a limitation of QQLink, not of the targets. OpenQASM 3 compares whole bit registers with integers in its conditions [23], and Qiskit’s dynamic circuits branch on classical expressions over several bits, including the comparisons and bitwise AND, OR, and XOR that IBM Heron processors accept in real time [9]. A condition over several measurement references, lowered to such an expression in if_test when the references end up in one circuit and evaluated by the receiving node when they arrive from several, is a direct extension of the model; it would remove the decoder ancilla of the repetition code.

Noise-aware planning.

The sector selector uses backend target data to prefer lower-error cross-sector entangling pairs and cleaner measurement endpoints, but the general orchestrator does not incorporate broader device signals such as T1T_1/T2T_2 coherence times, global routing cost, or multi-hop coupling constraints into end-to-end placement decisions. The plugin architecture supports custom placement policies, and integrating richer noise-aware heuristics is a natural next step.

Scale and construct validity.

The protocol workflows involve two to three circuits and up to 21 qubits per configuration; the planner was exercised on synthetic programs up to 64 circuits and 5×1045\times10^4 instructions, but not on real protocols of that size. Plan metrics and instruction counts measure the orchestration layer’s bookkeeping; wall-clock overhead is measured with a no-op dispatcher and on simulators, not against hardware queue and execution times.

Conclusion

The coordination that multi-QPU protocols need can be derived from one program over all nodes rather than written by hand per node. In QQLink the program is a set of workflow nodes with deferred measurement references and declared entanglement, and the planner derives from it, in linear time, a provably acyclic dependency graph whose topological orders all give the same result. The strongest evidence is that the plan alone carries the coordination. On the simulator runtime path, exhaustive branch tests over tomographically complete input sets give every tested quantum output state an infidelity of at most 5×10−125\times10^{-12} relative to its ideal output, and when each node runs in its own process and learns of the others only through delayed messages, every run with the full plan is correct while removing its cross-node edges breaks the protocols that need them.

The hardware runs place a limit on same-chip execution that the gate counts do not show. The workflows built from teleported gates fall up to 65 points short of a simulation with the device’s gate and readout errors, change by up to 31 points between sessions on qubits that the reported calibration does not distinguish, and their coherence-sensitive checks do not establish coherent Toffoli action or preservation of the intended repetition-code superposition. Their success depends on how the dynamic control is executed, as feedforward or as coherent control, and the direction of that effect differs between sectors; we have not identified the process responsible. The plan marks every correction, so choosing between feedforward and coherent control is a decision the hardware path can make per correction. The next steps follow from the same structure. They are a dispatcher that runs independent units concurrently, a distribution compiler as a producer of QQLink programs, conditions over several measurement references, and provider-native channels toward multi-chip execution. The abstractions were designed so that none of these requires changing existing application programs.

Data and Code Availability

The QQLink source code, the workflow library and example scripts, the experiment harness that generates every table and figure of § 8 (experiments/), the resulting JSON records, and the hardware run records (counts, calibration snapshots, physical-qubit assignments, and job identifiers) will be released under an open-source license at https://github.com/ORNL-QCI/qqlink upon publication, with the commit corresponding to this manuscript tagged and archived with a DOI. For review, a snapshot of this commit with the code, scripts, and records is deposited on Zenodo with restricted access and is available to reviewers at https://doi.org/10.5281/zenodo.23570273.

Supplementary tables

Table 10 lists the first-session hardware results on the second device, and Table 11 and Table 12 both sessions on each device with every repeat and all four controls (§ 8.6). Table 8 lists the execution plans of § 8.2, of which Figure 5 plots the teleportation rows, and Table 9 the instruction-level counts of § 8.5, of which Figure 8 plots the distributed fraction and the instruction density.

WorkflowCircuitsQubitsUnitsCross edgesIntra edgesLL
Dense coding (k=1,2,4k{=}1,2,4)22k2kk+1k{+}1kk02
Teleportation (n=1,3,5,7n{=}1,3,5,7)23n3n2n+12n{+}12n2nnn3
Entanglement swapping345325
Grover (per marked state)241871711
Bernstein–Vazirani (s=1111s{=}1111)271971811
Toffoli (per input)3651–522352–5330
Repetition code (per case)3941–421843–4422–23
Accept/reject loop (per round)233012

Table 8. Execution plans produced by Algorithm alg:plan. Cross edges join units of different circuits (footprint or measurement edges); intra edges join units of one circuit; LL is the critical-path length in units. Plans are byte-identical on every invocation (P1).

WorkflowQubitsGatesMeas.BellxCNOTCond.Dist. frac.Instr./qubit
Dense (kk)2k2k2k2k2k2kkkkk00.3333.00
Teleport (nn)3n3n3n3n2n2nnn02n2n0.3752.67
Swapping4242020.4002.50
Grover42262080.2639.50
Bernstein–Vazirani71882080.2785.14
Toffoli6291560240.40512.33
Repetition code9161440220.4646.22
Accept/reject loop3310010.2001.67

Table 9. Instruction-level resource consumption per authored workflow. Local gates exclude gates inside conditionals; the distributed fraction counts Bell-pair requests, cross-circuit CNOTs, and conditional instructions. Grover, Bernstein–Vazirani, Toffoli, and repetition-code counts are for marked state 0101, hidden string 11111111, input 110110, and logical ∣1⟩\lvert 1\rangle with a flip on B; other inputs differ by at most two local gates or, for Bernstein–Vazirani, by the number of teleported terms. The accept/reject row is for one round with the parity check; the verification check of Script lst:magic has one more local gate.

WorkflowConfigurationPhysical qubits per node2q / depthSuccess (%)Control (%)
Dense codingk=1k{=}1; message 00 / 01 / 10 / 11A: 142; B: 1432 / 1596.9 / 97.0 / 96.8 / 96.3--
Dense codingk=2k{=}2; messages (00,01) / (11,10)A: 141, 142; B: 143, 1447 / 2493.7 / 94.3--
Teleportationn=1n{=}1A: 142, 143; B: 1442 / 1897.0 [96.7, 97.3]52
Teleportationn=2n{=}2A: 142, 143, 144, 145; B: 146, 14710 / 3291.0 [90.5, 91.5]27
Teleportationn=3n{=}3A: 127, 137, 144, 145, 146, 147; B: 141, 142, 14324 / 4484.0 [83.4, 84.7]14
Entanglement swappingZZ/XXbasisA: 141; C: 142, 143; B: 1443 / 15--1894.5 / 92.950 / 50
Grovermarked 00 / 01 / 10 / 11A: 141, 142; B: 143, 1446 / 4364.6 / 63.9 / 64.8 / 63.725 / 26 / 26 / 25
Bernstein--Vaziranis=1001s{=}1001/01100110(one teleported term)A: 142, 143, 144; B: 145, 146, 147, 14810 / 3574.7 / 74.548 / 48
Bernstein--Vaziranis=1111s{=}1111(two teleported terms)A: 142, 143, 144; B: 145, 146, 147, 14820 / 5718.3 [17.6, 19.0]22
Toffoliinput 000 / 001 / 010 / 011A: 142, 143; B: 144, 145; C: 146, 14754 / 17451.5 / 43.8 / 43.9 / 36.332 / 29 / 32 / 29
Toffoliinput 100 / 101 / 110 / 111A: 142, 143; B: 144, 145; C: 146, 14754 / 17438.1 / 30.6 / 32.2 / 38.530 / 28 / 17 / 18
Repetition code∣0L⟩\lvert 0_L\rangle; flip none / A / B / CA: 127, 137; B: 143, 144, 145, 146, 147; C: 141, 14278 / 137--13974.0 / 39.8 / 44.3 / 72.126 / 11 / 25 / 27
Repetition code∣1L⟩\lvert 1_L\rangle; flip none / A / B / CA: 127, 137; B: 143, 144, 145, 146, 147; C: 141, 14278 / 137--13952.6 / 33.5 / 34.7 / 51.319 / 9 / 19 / 21
Repetition code∣+L⟩\lvert +_L\rangle; flip none / A / B / CA: 127, 137; B: 143, 144, 145, 146, 147; C: 141, 14278 / 137--13970.6 / 67.3 / 67.0 / 70.227 / 25 / 26 / 26

Table 10. Hardware results on the second device, ibm\_fez (Heron r2), 2026-10-09, 17:32--17:40 UTC, in the format of Table 5.

ConfigurationRepeats, 10-09Repeats, 10-16Δ\DeltaControls, 10-16Margin, 10-09 / 10-16
Dense k1 0097.1 / 98.0 / 97.497.4 / 97.8 / 97.5+0.1+0.1[−0.3-0.3,+0.4+0.4]----
Dense k1 0197.6 / 97.1 / 97.697.1 / 97.0 / 97.1−0.3-0.3[−0.7-0.7,+0.1+0.1]----
Dense k1 1097.4 / 97.8 / 97.696.3 / 96.4 / 96.8−1.1-1.1[−1.5-1.5,−0.7-0.7]----
Dense k1 1197.3 / 97.2 / 97.096.7 / 96.8 / 96.3−0.6-0.6[−1.1-1.1,−0.2-0.2]----
Dense k2 00 0192.5 / 92.2 / 92.092.3 / 91.6 / 91.7−0.4-0.4[−1.1-1.1,+0.3+0.3]----
Dense k2 11 1093.2 / 91.8 / 92.291.4 / 92.2 / 91.8−0.6-0.6[−1.3-1.3,+0.0+0.0]----
Teleport n195.1 / 94.9 / 95.097.5 / 98.0 / 97.6+2.7+2.7[+2.2+2.2,+3.1+3.1]52 / 50 / 51 / 51+42.3+42.3/+44.5+44.5
Teleport n289.8 / 89.8 / 90.584.8 / 82.8 / 84.0−6.1-6.1[−7.0-7.0,−5.3-5.3]25 / 26 / 26 / 25+63.3+63.3/+56.5+56.5
Teleport n382.8 / 83.2 / 82.182.4 / 83.0 / 83.2+0.2+0.2[−0.8-0.8,+1.1+1.1]11 / 14 / 11 / 13+67.2+67.2/+67.7+67.7
Swap Z91.9 / 92.5 / 91.992.4 / 92.9 / 91.8+0.3+0.3[−0.4-0.4,+0.9+0.9]50 / 50 / 51 / 50+40.1+40.1/+40.1+40.1
Swap X92.5 / 91.6 / 92.593.6 / 94.2 / 94.2+1.8+1.8[+1.2+1.2,+2.4+2.4]50 / 50 / 50 / 51+41.1+41.1/+41.9+41.9
Grover 0073.3 / 72.9 / 74.675.0 / 75.3 / 75.5+1.7+1.7[+0.6+0.6,+2.7+2.7]27 / 25 / 27 / 26+46.1+46.1/+46.8+46.8
Grover 0172.3 / 72.7 / 74.373.9 / 75.2 / 74.2+1.3+1.3[+0.2+0.2,+2.4+2.4]26 / 25 / 24 / 25+45.9+45.9/+47.2+47.2
Grover 1074.0 / 72.9 / 73.675.5 / 74.1 / 74.0+1.0+1.0[−0.0-0.0,+2.1+2.1]24 / 24 / 25 / 26+47.1+47.1/+46.9+46.9
Grover 1172.4 / 71.7 / 73.074.4 / 75.5 / 74.5+2.4+2.4[+1.3+1.3,+3.5+3.5]24 / 24 / 24 / 26+44.6+44.6/+47.4+47.4
BV 100183.8 / 82.0 / 83.464.4 / 65.5 / 64.0−18.4-18.4[−19.5-19.5,−17.3-17.3]49 / 48 / 49 / 47+35.1+35.1/+13.8+13.8
BV 011083.8 / 83.7 / 83.363.6 / 64.6 / 64.7−19.3-19.3[−20.4-20.4,−18.3-18.3]50 / 47 / 48 / 48+34.3+34.3/+12.9+12.9
BV 111145.8 / 43.8 / 44.726.2 / 25.9 / 24.7−19.2-19.2[−20.3-20.3,−18.0-18.0]20 / 20 / 18 / 20+20.9+20.9/+3.9+3.9
Toffoli 00073.5 / 73.2 / 73.142.0 / 41.9 / 43.3−30.8-30.8[−32.0-32.0,−29.6-29.6]30 / 32 / 32 / 31+40.0+40.0/+9.0+9.0
Toffoli 00163.8 / 63.1 / 63.935.0 / 35.5 / 34.0−28.8-28.8[−30.0-30.0,−27.6-27.6]30 / 29 / 30 / 28+32.1+32.1/+3.3+3.3
Toffoli 01057.3 / 59.8 / 58.339.1 / 38.1 / 39.7−19.5-19.5[−20.7-20.7,−18.3-18.3]31 / 31 / 33 / 32+25.0+25.0/+4.4+4.4
Toffoli 01153.8 / 50.9 / 50.634.1 / 34.1 / 32.9−18.1-18.1[−19.3-19.3,−16.9-16.9]29 / 29 / 30 / 28+20.9+20.9/+1.7+1.7
Toffoli 10054.5 / 55.9 / 55.130.9 / 31.4 / 30.1−24.3-24.3[−25.5-25.5,−23.1-23.1]24 / 24 / 23 / 21+24.2+24.2/+5.3+5.3
Toffoli 10150.6 / 49.9 / 49.426.6 / 26.2 / 25.8−23.8-23.8[−24.9-24.9,−22.6-22.6]24 / 22 / 21 / 20+20.6+20.6/+0.7+0.7
Toffoli 11043.8 / 44.8 / 45.020.7 / 22.2 / 20.6−23.4-23.4[−24.5-24.5,−22.2-22.2]14 / 13 / 11 / 13+26.4+26.4/+5.9+5.9
Toffoli 11147.6 / 46.7 / 46.324.3 / 23.2 / 24.2−22.9-22.9[−24.1-24.1,−21.8-21.8]15 / 15 / 15 / 16+27.0+27.0/+6.9+6.9
Rep. 0 --65.5 / 67.8 / 67.868.8 / 68.1 / 67.5+1.1+1.1[−0.1-0.1,+2.2+2.2]28 / 25 / 27 / 13+38.4+38.4/+38.7+38.7
Rep. 0 A44.0 / 44.5 / 44.444.8 / 45.1 / 43.2+0.1+0.1[−1.2-1.2,+1.3+1.3]1 / 10 / 1 / 13+33.5+33.5/+30.0+30.0
Rep. 0 B57.5 / 56.9 / 57.849.1 / 49.1 / 46.6−9.1-9.1[−10.3-10.3,−7.9-7.9]26 / 9 / 25 / 12+32.2+32.2/+20.9+20.9
Rep. 0 C54.9 / 56.4 / 56.067.7 / 65.6 / 64.5+10.2+10.2[+8.9+8.9,+11.4+11.4]25 / 9 / 25 / 12+29.9+29.9/+38.8+38.8
Rep. 1 --51.8 / 53.2 / 51.550.2 / 50.5 / 48.2−2.5-2.5[−3.7-3.7,−1.2-1.2]22 / 15 / 23 / 12+30.8+30.8/+25.5+25.5
Rep. 1 A38.9 / 37.4 / 39.037.2 / 37.2 / 34.7−2.1-2.1[−3.3-3.3,−0.9-0.9]1 / 9 / 2 / 11+28.7+28.7/+23.9+23.9
Rep. 1 B44.8 / 43.8 / 42.441.3 / 40.1 / 37.6−4.0-4.0[−5.2-5.2,−2.7-2.7]21 / 16 / 20 / 12+19.5+19.5/+17.0+17.0
Rep. 1 C44.0 / 43.8 / 45.546.3 / 48.2 / 46.1+2.4+2.4[+1.2+1.2,+3.7+3.7]22 / 9 / 22 / 13+19.8+19.8/+23.3+23.3
Rep.++--67.3 / 67.7 / 67.264.6 / 65.3 / 63.5−3.0-3.0[−4.1-4.1,−1.8-1.8]25 / 26 / 25 / 25+39.1+39.1/+37.3+37.3
Rep.++A64.1 / 63.9 / 66.763.9 / 63.7 / 64.7−0.8-0.8[−2.0-2.0,+0.4+0.4]25 / 24 / 24 / 25+38.2+38.2/+37.5+37.5
Rep.++B65.4 / 67.7 / 64.764.0 / 62.7 / 64.0−2.4-2.4[−3.6-3.6,−1.2-1.2]24 / 25 / 25 / 24+39.0+39.0/+37.2+37.2
Rep.++C65.2 / 67.3 / 66.064.3 / 63.7 / 63.6−2.3-2.3[−3.4-3.4,−1.1-1.1]24 / 25 / 26 / 25+38.5+38.5/+36.3+36.3

Table 11. Both hardware sessions on ibm\_kingston, 2026-10-09 and 2026-10-16, 4096 shots per repeat. Repeats: success (%) of each of the three repeats. Δ\Delta: pooled second-session minus first-session success, with a 95% Newcombe interval (points). Controls: C1 / C2 / C1′' / C3 of the second session (%; C1 corrections and resets removed, C2 conditional blocks applied at random, C1′' corrections removed and resets kept, C3 corrections conditioned on an independent coin). Margin: lower bound of the 95% Newcombe interval of success minus each control of the same session, the smallest over the controls, for each session (points). The physical qubits of the first session are those of Table 5; the sector search placed most workflows on other qubits in the second.

ConfigurationRepeats, 10-09Repeats, 10-16Δ\DeltaControls, 10-16Margin, 10-09 / 10-16
Dense k1 0096.6 / 97.4 / 96.796.0 / 95.5 / 95.6−1.2-1.2[−1.7-1.7,−0.7-0.7]----
Dense k1 0196.7 / 97.0 / 97.295.8 / 96.6 / 96.7−0.6-0.6[−1.1-1.1,−0.2-0.2]----
Dense k1 1096.5 / 97.0 / 97.095.9 / 95.5 / 95.2−1.3-1.3[−1.8-1.8,−0.8-0.8]----
Dense k1 1196.0 / 96.0 / 96.996.3 / 96.0 / 95.6−0.3-0.3[−0.8-0.8,+0.1+0.1]----
Dense k2 00 0193.8 / 94.1 / 93.190.4 / 90.7 / 90.0−3.3-3.3[−4.0-4.0,−2.6-2.6]----
Dense k2 11 1093.9 / 94.4 / 94.789.1 / 89.4 / 89.6−4.9-4.9[−5.6-5.6,−4.3-4.3]----
Teleport n196.7 / 97.2 / 97.397.4 / 97.0 / 97.5+0.3+0.3[−0.1-0.1,+0.7+0.7]-- / -- / -- / --+43.7+43.7/ --
Teleport n290.4 / 90.9 / 91.786.5 / 85.9 / 87.2−4.5-4.5[−5.2-5.2,−3.7-3.7]-- / -- / -- / --+63.4+63.4/ --
Teleport n383.6 / 84.3 / 84.280.0 / 80.1 / 79.4−4.2-4.2[−5.1-5.1,−3.2-3.2]-- / -- / -- / --+68.6+68.6/ --
Swap Z94.5 / 94.8 / 94.390.6 / 90.5 / 89.5−4.3-4.3[−5.0-5.0,−3.7-3.7]-- / -- / -- / --+44.0+44.0/ --
Swap X92.7 / 92.9 / 93.089.1 / 89.2 / 89.0−3.8-3.8[−4.5-4.5,−3.1-3.1]-- / -- / -- / --+41.9+41.9/ --
Grover 0064.8 / 64.3 / 64.867.2 / 67.4 / 68.1+2.9+2.9[+1.8+1.8,+4.1+4.1]-- / -- / -- / --+37.8+37.8/ --
Grover 0163.9 / 63.8 / 64.066.7 / 67.3 / 67.8+3.4+3.4[+2.2+2.2,+4.6+4.6]-- / -- / -- / --+37.2+37.2/ --
Grover 1064.6 / 65.0 / 64.766.9 / 66.8 / 67.2+2.2+2.2[+1.0+1.0,+3.4+3.4]-- / -- / -- / --+37.1+37.1/ --
Grover 1163.7 / 62.5 / 64.965.7 / 66.6 / 66.1+2.4+2.4[+1.2+1.2,+3.6+3.6]-- / -- / -- / --+37.3+37.3/ --
BV 100175.4 / 74.9 / 74.067.6 / 69.3 / 68.7−6.2-6.2[−7.4-7.4,−5.1-5.1]-- / -- / 50 / 47+24.9+24.9/+17.0+17.0
BV 011074.0 / 74.6 / 75.067.7 / 69.0 / 67.4−6.5-6.5[−7.6-7.6,−5.3-5.3]-- / -- / 47 / 46+24.5+24.5/+19.0+19.0
BV 111118.3 / 18.7 / 17.830.5 / 30.9 / 30.5+12.3+12.3[+11.3+11.3,+13.4+13.4]-- / -- / 21 / 22−5.1-5.1/+7.1+7.1
Toffoli 00053.7 / 50.3 / 50.642.0 / 43.4 / 41.9−9.1-9.1[−10.3-10.3,−7.8-7.8]-- / -- / 32 / 35+18.0+18.0/+6.0+6.0
Toffoli 00145.5 / 42.5 / 43.435.8 / 33.5 / 34.9−9.1-9.1[−10.3-10.3,−7.9-7.9]-- / -- / 28 / 24+12.8+12.8/+5.6+5.6
Toffoli 01045.6 / 43.0 / 43.241.5 / 42.5 / 42.2−1.8-1.8[−3.1-3.1,−0.6-0.6]-- / -- / 31 / 35+10.5+10.5/+5.2+5.2
Toffoli 01137.5 / 34.7 / 36.635.6 / 36.4 / 35.7−0.4-0.4[−1.6-1.6,+0.8+0.8]-- / -- / 27 / 22+5.8+5.8/+7.6+7.6
Toffoli 10039.9 / 37.4 / 36.922.0 / 24.1 / 24.7−14.5-14.5[−15.6-15.6,−13.3-13.3]-- / -- / 26 / 20+6.2+6.2/−4.3-4.3
Toffoli 10132.0 / 29.0 / 30.718.0 / 19.1 / 20.4−11.4-11.4[−12.4-12.4,−10.3-10.3]-- / -- / 22 / 14+0.5+0.5/−4.3-4.3
Toffoli 11032.3 / 30.7 / 33.721.8 / 22.2 / 27.1−8.6-8.6[−9.7-9.7,−7.4-7.4]-- / -- / 14 / 10+14.7+14.7/+8.7+8.7
Toffoli 11137.7 / 39.1 / 38.724.1 / 24.5 / 27.9−13.0-13.0[−14.1-14.1,−11.8-11.8]-- / -- / 16 / 18+19.0+19.0/+6.4+6.4
Rep. 0 --74.0 / 74.7 / 73.467.7 / 67.8 / 70.1−5.5-5.5[−6.6-6.6,−4.4-4.4]-- / -- / -- / --+46.0+46.0/ --
Rep. 0 A40.4 / 39.6 / 39.549.8 / 46.5 / 51.2+9.4+9.4[+8.1+8.1,+10.6+10.6]-- / -- / -- / --+28.3+28.3/ --
Rep. 0 B43.7 / 45.2 / 44.151.3 / 50.5 / 53.1+7.3+7.3[+6.1+6.1,+8.6+8.6]-- / -- / -- / --+18.0+18.0/ --
Rep. 0 C71.9 / 72.5 / 72.060.8 / 60.3 / 62.4−10.9-10.9[−12.1-12.1,−9.7-9.7]-- / -- / -- / --+44.0+44.0/ --
Rep. 1 --50.7 / 54.6 / 52.444.1 / 42.6 / 46.0−8.3-8.3[−9.6-9.6,−7.1-7.1]-- / -- / -- / --+32.5+32.5/ --
Rep. 1 A33.4 / 33.4 / 33.734.2 / 32.5 / 34.8+0.3+0.3[−0.9-0.9,+1.5+1.5]-- / -- / -- / --+23.9+23.9/ --
Rep. 1 B32.4 / 36.7 / 34.844.4 / 43.0 / 44.5+9.3+9.3[+8.1+8.1,+10.5+10.5]-- / -- / -- / --+14.0+14.0/ --
Rep. 1 C49.8 / 53.1 / 51.038.5 / 37.0 / 38.7−13.2-13.2[−14.4-14.4,−12.0-12.0]-- / -- / -- / --+28.9+28.9/ --
Rep.++--70.0 / 72.0 / 69.963.1 / 61.7 / 64.7−7.5-7.5[−8.6-8.6,−6.3-6.3]-- / -- / -- / --+42.3+42.3/ --
Rep.++A66.0 / 68.0 / 67.958.9 / 59.4 / 61.7−7.3-7.3[−8.5-8.5,−6.1-6.1]-- / -- / -- / --+41.2+41.2/ --
Rep.++B67.3 / 67.5 / 66.257.1 / 58.1 / 63.4−7.5-7.5[−8.7-8.7,−6.3-6.3]-- / -- / -- / --+39.8+39.8/ --
Rep.++C70.1 / 70.6 / 70.060.6 / 59.1 / 62.0−9.7-9.7[−10.9-10.9,−8.5-8.5]-- / -- / -- / --+42.7+42.7/ --

Table 12. Both hardware sessions on ibm\_fez, 2026-10-09 and 2026-10-16, 4096 shots per repeat. Repeats: success (%) of each of the three repeats. Δ\Delta: pooled second-session minus first-session success, with a 95% Newcombe interval (points). Controls: C1 / C2 / C1′' / C3 of the second session (%; C1 corrections and resets removed, C2 conditional blocks applied at random, C1′' corrections removed and resets kept, C3 corrections conditioned on an independent coin). Margin: lower bound of the 95% Newcombe interval of success minus each control of the same session, the smallest over the controls, for each session (points). On 2026-10-16 the controls were run for Bernstein--Vazirani and Toffoli only, and only C1′' and C3, in a separate job on a different sector (qubits 108--112, 118, 129, 130) from the nominal circuits; the differences between nominal and control on that day therefore do not isolate the effect of feedforward.

Workflow scripts

The scripts below complete § 7 with dense coding, entanglement swapping, Grover search, Bernstein–Vazirani, the Toffoli gate, the repetition code, and the accept/reject control loop. Each is the QQLink program that the evaluation plans, simulates, and lowers to hardware.

ENCODING = {(0,0): None, (0,1): "X",
            (1,0): "Z",  (1,1): "Y"}

def build_dense_coding(messages, k):
    wp = WorkflowProgram("dense_coding")
    alice = wp.create_circuit("alice", num_qubits=k)
    bob = wp.create_circuit("bob", num_qubits=k)
    for i in range(k):
        bell = wp.declare_entanglement(
            "alice", i, "bob", i, link_id=f"bell_{i}")
        alice.request_bell_pair(i, bell)
        gate = ENCODING[tuple(messages[i])]
        if gate is not None:
            alice.gate(gate, [i])
        alice.cross_cnot(i, "bob", i)
        alice.gate("H", [i])
        alice.measure(i, label=f"a_{i}")
        bob.measure(i, label=f"b_{i}")
    return wp
def build_entanglement_swapping(basis="Z"):
    wp = WorkflowProgram("entanglement_swapping")
    alice = wp.create_circuit("alice", num_qubits=1)
    charlie = wp.create_circuit("charlie", num_qubits=2)
    bob = wp.create_circuit("bob", num_qubits=1)
    l1 = wp.declare_entanglement("alice", 0, "charlie", 0)
    l2 = wp.declare_entanglement("charlie", 1, "bob", 0)
    alice.request_bell_pair(0, l1)      # |Phi+> on (a0, c0)
    charlie.request_bell_pair(1, l2)    # |Phi+> on (c1, b0)
    charlie.gate("CNOT", [0, 1])        # Bell measurement
    charlie.gate("H", [0])
    m0 = charlie.measure(0, label="m0")
    m1 = charlie.measure(1, label="m1")
    bob.if_then(m1 == 1, [("X", [0])])  # swap corrections
    bob.if_then(m0 == 1, [("Z", [0])])
    if basis == "X":
        alice.gate("H", [0]); bob.gate("H", [0])
    alice.measure(0, label="check_a")
    bob.measure(0, label="check_b")
    return wp
def add_teleported_cz(wp, alice, bob, prefix, lc):
    bob.gate("H", [0])
    lc, _, _ = add_teleported_cnot(
        wp, alice, "alice", bob, "bob", prefix, lc)
    bob.gate("H", [0])
    return lc

def build_grover(marked):
    wp = WorkflowProgram("grover")
    alice = wp.create_circuit("alice", num_qubits=2)
    bob = wp.create_circuit("bob", num_qubits=2)
    lc = 0
    alice.gate("H", [0]); bob.gate("H", [0])
    if marked[0] == 0: alice.gate("X", [0])
    if marked[1] == 0: bob.gate("X", [0])
    lc = add_teleported_cz(wp, alice, bob, "ora", lc)
    if marked[0] == 0: alice.gate("X", [0])
    if marked[1] == 0: bob.gate("X", [0])
    for g in ["H", "X"]:
        alice.gate(g, [0]); bob.gate(g, [0])
    lc = add_teleported_cz(wp, alice, bob, "dif", lc)
    for g in ["X", "H"]:
        alice.gate(g, [0]); bob.gate(g, [0])
    alice.measure(0, label="a")
    bob.measure(0, label="b")
    return wp
def build_bernstein_vazirani(s_alice, s_bob):
    nA, nB = len(s_alice), len(s_bob)
    wp = WorkflowProgram("bernstein_vazirani")
    alice = wp.create_circuit("alice", num_qubits=nA + 1)
    bob = wp.create_circuit("bob", num_qubits=nB + 2)
    t, anc_b, anc_a = nB, nB + 1, nA
    for i in range(nA): alice.gate("H", [i])
    for i in range(nB): bob.gate("H", [i])
    bob.gate("X", [t]); bob.gate("H", [t])     # target |->
    lc = 0
    for i, bit in enumerate(s_bob):
        if bit: bob.gate("CNOT", [i, t])       # local terms
    for i, bit in enumerate(s_alice):
        if bit:                                # teleported terms
            lc = tcnot(wp, alice, "alice", i, anc_a,
                       bob, "bob", t, anc_b, f"bv{i}", lc)
    for i in range(nA):
        alice.gate("H", [i]); alice.measure(i, label=f"s_a{i}")
    for i in range(nB):
        bob.gate("H", [i]); bob.measure(i, label=f"s_b{i}")
    return wp
def build_toffoli(a_val, b_val, c_val):
    wp = WorkflowProgram("toffoli")
    nA = wp.create_circuit("nodeA", num_qubits=2)
    nB = wp.create_circuit("nodeB", num_qubits=2)
    nC = wp.create_circuit("nodeC", num_qubits=2)
    def tcnot(c, cn, t, tn, p, lc):
        return add_teleported_cnot(wp, c, cn, t, tn, p, lc)[0]
    T, Tdg = pi/4, -pi/4
    if a_val: nA.gate("X", [0])
    if b_val: nB.gate("X", [0])
    if c_val: nC.gate("X", [0])
    nC.gate("H", [0]); lc = 0
    lc = tcnot(nB, "nodeB", nC, "nodeC", "bc1", lc)
    nC.gate("RZ", [0], params=[Tdg])
    lc = tcnot(nA, "nodeA", nC, "nodeC", "ac1", lc)
    nC.gate("RZ", [0], params=[T])
    lc = tcnot(nB, "nodeB", nC, "nodeC", "bc2", lc)
    nC.gate("RZ", [0], params=[Tdg])
    lc = tcnot(nA, "nodeA", nC, "nodeC", "ac2", lc)
    nB.gate("RZ", [0], params=[T]); nC.gate("RZ", [0], params=[T])
    lc = tcnot(nA, "nodeA", nB, "nodeB", "ab1", lc)
    nA.gate("RZ", [0], params=[T]); nB.gate("RZ", [0], params=[Tdg])
    lc = tcnot(nA, "nodeA", nB, "nodeB", "ab2", lc)
    nC.gate("H", [0])
    nA.measure(0, label="a"); nB.measure(0, label="b")
    nC.measure(0, label="c")
    return wp
def build_repetition_code(logical=0, error=None):
    wp = WorkflowProgram("repetition_code")
    A = wp.create_circuit("nodeA", num_qubits=2)
    B = wp.create_circuit("nodeB", num_qubits=5)
    C = wp.create_circuit("nodeC", num_qubits=2)
    DA, NA = 0, 1; DC, NC = 0, 1
    DB, S1, S2, DEC, NB = 0, 1, 2, 3, 4
    if logical == 1: A.gate("X", [DA])
    elif logical == "+": A.gate("H", [DA])
    lc = 0                                    # encode |psi>|00>
    lc = tcnot(A, "nodeA", DA, NA, B, "nodeB", DB, NB, "encB", lc)
    lc = tcnot(A, "nodeA", DA, NA, C, "nodeC", DC, NC, "encC", lc)
    if error == "A": A.gate("X", [DA])        # injected bit flip
    elif error == "B": B.gate("X", [DB])
    elif error == "C": C.gate("X", [DC])
    lc = tcnot(A, "nodeA", DA, NA, B, "nodeB", S1, NB, "synA", lc)
    B.gate("CNOT", [DB, S1]); B.gate("CNOT", [DB, S2])
    lc = tcnot(C, "nodeC", DC, NC, B, "nodeB", S2, NB, "synC", lc)
    s1 = B.measure(S1, label="s1")
    B.if_then(s1 == 1, [("CNOT", [S2, DEC])])   # dec = s1 AND s2
    s2 = B.measure(S2, label="s2")
    tb = B.measure(DEC, label="tb")
    B.if_then(tb == 1, [("X", [DB])])
    A.if_then(s1 == 1, [("X", [DA])])
    A.if_then(tb == 1, [("X", [DA])])
    C.if_then(s2 == 1, [("X", [DC])])
    C.if_then(tb == 1, [("X", [DC])])
    A.measure(DA, label="out_a"); B.measure(DB, label="out_b")
    C.measure(DC, label="out_c")
    return wp
def build_distillation_round(noise_angle=0.0):
    wp = WorkflowProgram("distillation_round")
    factory = wp.create_circuit("factory", num_qubits=2)
    consumer = wp.create_circuit("consumer", num_qubits=1)
    factory.gate("H", [0])                       # noisy T-state
    factory.gate("RZ", [0], params=[pi/4 + noise_angle])
    factory.gate("RZ", [0], params=[-pi/4])      # T^dagger, H:
    factory.gate("H", [0])                       # verification
    syn = factory.measure(0, label="syndrome")
    factory.if_then(syn == 1, [("X", [0])])      # reset
    return wp

def run_distillation(n_rounds, max_retries, noise, rng):
    orch = Orchestrator(available_backends=BACKENDS)
    rounds, total = [], 0
    for r in range(n_rounds):
        accepted, attempts = False, 0
        for _ in range(1 + max_retries):
            attempts += 1; total += 1
            wp = build_distillation_round(
                rng.uniform(-noise, noise))
            plan = orch.plan(wp)
            ex = WorkflowExecutor(wp, backend_name="qulacs")
            orch.dispatch_plan(plan, ex.dispatch)
            if ex.get_measurement("factory", "syndrome") == 0:
                accepted = True; break
        rounds.append({"round": r, "accepted": accepted,
                       "attempts": attempts})
    return {"rounds": rounds, "total": total}

References

  1. [1]Caleffi, M., Amoretti, M., Ferrari, D., Illiano, J., Manzalini, A., & Cacciapuoti, A. S. (2024). Distributed Quantum Computing: A Survey. Computer Networks, 254, 110672. https://doi.org/10.1016/j.comnet.2024.110672
  2. [2]Cuomo, D., Caleffi, M., & Cacciapuoti, A. S. (2020). Towards a Distributed Quantum Computing Ecosystem. IET Quantum Communication, 1(1), 3–8. https://doi.org/10.1049/iet-qtc.2020.0002
  3. [3]Main, D., Drmota, P., Nadlinger, D. P., Ainley, E. M., Agrawal, A., Nichol, B. C., Srinivas, R., Araneda, G., & Lucas, D. M. (2025). Distributed Quantum Computing across an Optical Network Link. Nature, 638(8050), 383–388. https://doi.org/10.1038/s41586-024-08404-x
  4. [4]Gottesman, D., & Chuang, I. L. (1999). Demonstrating the Viability of Universal Quantum Computation Using Teleportation and Single-Qubit Operations. Nature, 402(6760), 390–393. https://doi.org/10.1038/46503
  5. [5]Bennett, C. H., Brassard, G., Crépeau, C., Jozsa, R., Peres, A., & Wootters, W. K. (1993). Teleporting an Unknown Quantum State via Dual Classical and Einstein-Podolsky-Rosen Channels. Physical Review Letters, 70(13), 1895–1899. https://doi.org/10.1103/PhysRevLett.70.1895
  6. [6]Bennett, C. H., & Wiesner, S. J. (1992). Communication via One- and Two-Particle Operators on Einstein-Podolsky-Rosen States. Physical Review Letters, 69(20), 2881–2884. https://doi.org/10.1103/PhysRevLett.69.2881
  7. [7]Grover, L. K. (1996). A Fast Quantum Mechanical Algorithm for Database Search. Proceedings of the 28th Annual ACM Symposium on Theory of Computing (STOC '96), 212–219. https://doi.org/10.1145/237814.237866
  8. [8]Yimsiriwattana, A., & Lomonaco Jr., S. J. (2004). Distributed Quantum Computing: A Distributed Shor Algorithm. Quantum Information and Computation II, 5436, 360–372. https://doi.org/10.1117/12.546504
  9. [9]Javadi-Abhari, A., Treinish, M., Krsulich, K., Wood, C. J., Lishman, J., Gacon, J., Martiel, S., Nation, P. D., Bishop, L. S., Cross, A. W., Johnson, B. R., & Gambetta, J. M. (2024). Quantum Computing with Qiskit. https://doi.org/10.48550/arXiv.2405.08810
  10. [10]Cirq Developers. (2024). Cirq: A Python Framework for Creating, Editing, and Invoking Noisy Intermediate Scale Quantum Circuits. In https://quantumai.google/cirq. https://doi.org/10.5281/zenodo.4062499
  11. [11]Bergholm, V., Izaac, J., Schuld, M., Gogolin, C., et al. (2018). PennyLane: Automatic Differentiation of Hybrid Quantum-Classical Computations. https://doi.org/10.48550/arXiv.1811.04968
  12. [12]Peng, T., Harrow, A. W., Ozols, M., & Wu, X. (2020). Simulating Large Quantum Circuits on a Small Quantum Computer. Physical Review Letters, 125(15), 150504. https://doi.org/10.1103/PhysRevLett.125.150504
  13. [13]Tang, W., Tomesh, T., Suchara, M., Larson, J., & Martonosi, M. (2021). CutQC: Using Small Quantum Computers for Large Quantum Circuit Evaluations. Proceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS '21), 473–486. https://doi.org/10.1145/3445814.3446758
  14. [14]Andrés-Martínez, P., & Heunen, C. (2019). Automated Distribution of Quantum Circuits via Hypergraph Partitioning. Physical Review A, 100(3), 032308. https://doi.org/10.1103/PhysRevA.100.032308
  15. [15]Ferrari, D., Cacciapuoti, A. S., Amoretti, M., & Caleffi, M. (2021). Compiler Design for Distributed Quantum Computing. IEEE Transactions on Quantum Engineering, 2, 1–20. https://doi.org/10.1109/TQE.2021.3053921
  16. [16]Coopmans, T., Knegjens, R., Dahlberg, A., Maier, D., Nijsten, L., de Oliveira Filho, J., Papendrecht, M., Rabbie, J., Rozpędek, F., Skrzypczyk, M., Wubben, L., de Jong, W., Podareanu, D., Torres-Knoop, A., Elkouss, D., & Wehner, S. (2021). NetSquid, a NETwork Simulator for QUantum Information Using Discrete Events. Communications Physics, 4(1), 164. https://doi.org/10.1038/s42005-021-00647-8
  17. [17]Wu, X., Kolar, A., Chung, J., Jin, D., Zhong, T., Kettimuthu, R., & Suchara, M. (2021). SeQUeNCe: A Customizable Discrete-Event Simulator of Quantum Networks. Quantum Science and Technology, 6(4), 045027. https://doi.org/10.1088/2058-9565/ac22f6
  18. [18]Suzuki, Y., Kawase, Y., Masumura, Y., Hiraga, Y., Nakadai, M., Chen, J., Nakanishi, K. M., Mitarai, K., Imai, R., Tamiya, S., Yamamoto, T., Yan, T., Kawakubo, T., Nakagawa, Y. O., Ibe, Y., Zhang, Y., Yamashita, H., Yoshimura, H., Hayashi, A., & Fujii, K. (2021). Qulacs: A Fast and Versatile Quantum Circuit Simulator for Research Purpose. Quantum, 5, 559. https://doi.org/10.22331/q-2021-10-06-559
  19. [19]Agnostiq Inc. (2022). Covalent: Pythonic Tool for Orchestrating Hybrid Quantum-Classical Workflows. In https://github.com/AgnostiqHQ/covalent.
  20. [20]Monroe, C., Raussendorf, R., Ruthven, A., Brown, K. R., Maunz, P., Duan, L.-M., & Kim, J. (2014). Large-Scale Modular Quantum-Computer Architecture with Atomic Memory and Photonic Interconnects. Physical Review A, 89(2), 022317. https://doi.org/10.1103/PhysRevA.89.022317
  21. [21]Jnane, H., Undseth, B., Cai, Z., Benjamin, S. C., & Koczor, B. (2022). Multicore Quantum Computing. Physical Review Applied, 18(4), 044064. https://doi.org/10.1103/PhysRevApplied.18.044064
  22. [22]Córcoles, A. D., Takita, M., Inoue, K., Lekuch, S., Minev, Z. K., Chow, J. M., & Gambetta, J. M. (2021). Exploiting Dynamic Quantum Circuits in a Quantum Algorithm with Superconducting Qubits. Physical Review Letters, 127(10), 100501. https://doi.org/10.1103/PhysRevLett.127.100501
  23. [23]Cross, A., Javadi-Abhari, A., Alexander, T., de Beaudrap, N., Bishop, L. S., Heidel, S., Ryan, C. A., Sivarajah, P., Smolin, J., Gambetta, J. M., & Johnson, B. R. (2022). OpenQASM 3: A Broader and Deeper Quantum Assembly Language. ACM Transactions on Quantum Computing, 3(3), 12:1–12:50. https://doi.org/10.1145/3505636
  24. [24]Baker, J. M., Duckering, C., Hoover, A., & Chong, F. T. (2020). Time-Sliced Quantum Circuit Partitioning for Modular Architectures. Proceedings of the 17th ACM International Conference on Computing Frontiers (CF '20), 98–107. https://doi.org/10.1145/3387902.3392617
  25. [25]Wu, A., Zhang, H., Li, G., Shabani, A., Xie, Y., & Ding, Y. (2022). AutoComm: A Framework for Enabling Efficient Communication in Distributed Quantum Programs. 55th IEEE/ACM International Symposium on Microarchitecture (MICRO), 1027–1041. https://doi.org/10.1109/MICRO56248.2022.00074
  26. [26]DiAdamo, S., Nötzel, J., Zanger, B., & Beşe, M. M. (2021). QuNetSim: A Software Framework for Quantum Networks. IEEE Transactions on Quantum Engineering, 2, 1–12. https://doi.org/10.1109/TQE.2021.3092395
  27. [27]Parekh, R., Ricciardi, A., Darwish, A., & DiAdamo, S. (2021). Quantum Algorithms and Simulation for Parallel and Distributed Quantum Computing. 2021 IEEE/ACM Second International Workshop on Quantum Computing Software (QCS), 9–19. https://doi.org/10.1109/QCS54837.2021.00005
  28. [28]Dahlberg, A., van der Vecht, B., Delle Donne, C., Skrzypczyk, M., te Raa, I., Kozlowski, W., & Wehner, S. (2022). NetQASM---A Low-Level Instruction Set Architecture for Hybrid Quantum--Classical Programs in a Quantum Internet. Quantum Science and Technology, 7(3), 035023. https://doi.org/10.1088/2058-9565/ac753f
  29. [29]Häner, T., Steiger, D. S., Hoefler, T., & Troyer, M. (2021). Distributed Quantum Computing with QMPI. Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis (SC '21), 1–13. https://doi.org/10.1145/3458817.3476172
  30. [30]McCaskey, A. J., Lyakh, D. I., Dumitrescu, E. F., Powers, S. S., & Humble, T. S. (2020). XACC: A System-Level Software Infrastructure for Heterogeneous Quantum--Classical Computing. Quantum Science and Technology, 5(2), 024002. https://doi.org/10.1088/2058-9565/ab6bf6
  31. [31]Kim, J.-S., McCaskey, A., Heim, B., Modani, M., Stanwyck, S., & Costa, T. (2023). CUDA Quantum: The Platform for Integrated Quantum-Classical Computing. 2023 60th ACM/IEEE Design Automation Conference (DAC), 1–4. https://doi.org/10.1109/DAC56929.2023.10247886
  32. [32]IBM Quantum. (2024). Qiskit Serverless. In https://github.com/Qiskit/qiskit-serverless. https://github.com/Qiskit/qiskit-serverlessgithub.com/Qiskit/qiskit-serverless
  33. [33]Mantha, P., Kiwit, F. J., Saurabh, N., Jha, S., & Luckow, A. (2025). Pilot-Quantum: A Middleware for Quantum-HPC Resource, Workload and Task Management. 2025 IEEE 25th International Symposium on Cluster, Cloud and Internet Computing (CCGrid), 1–10. https://doi.org/10.1109/CCGRID64434.2025.00070
  34. [34]Barral, D., Cardama, F. J., Díaz-Camacho, G., Faílde, D., Llovo, I. F., Mussa-Juane, M., Vázquez-Pérez, J., Villasuso, J., Piñeiro, C., Costas, N., Pichel, J. C., Pena, T. F., & Gómez, A. (2025). Review of Distributed Quantum Computing: From Single QPU to High Performance Quantum Computing. Computer Science Review, 57, 100747. https://doi.org/10.1016/j.cosrev.2025.100747
  35. [35]Eisert, J., Jacobs, K., Papadopoulos, P., & Plenio, M. B. (2000). Optimal Local Implementation of Nonlocal Quantum Gates. Physical Review A, 62(5), 052317. https://doi.org/10.1103/PhysRevA.62.052317
  36. [36]Bravyi, S., & Kitaev, A. (2005). Universal Quantum Computation with Ideal Clifford Gates and Noisy Ancillas. Physical Review A, 71(2), 022316. https://doi.org/10.1103/PhysRevA.71.022316
  37. [37]Nielsen, M. A., & Chuang, I. L. (2010). Quantum Computation and Quantum Information. Cambridge University Press. https://doi.org/10.1017/CBO9780511976667
  38. [38]Claudino, D., Lyakh, D. I., & McCaskey, A. J. (2024). Parallel Quantum Computing Simulations via Quantum Accelerator Platform Virtualization. Future Generation Computer Systems, 160, 264–273. https://doi.org/10.1016/j.future.2024.06.007
  39. [39]Liu, X., Hu, X.-M., Zhu, T.-X., Zhang, C., Xiao, Y.-X., Miao, J.-L., Ou, Z.-W., Li, P.-Y., Liu, B.-H., Zhou, Z.-Q., Li, C.-F., & Guo, G.-C. (2024). Nonlocal Photonic Quantum Gates over 7.0 km. Nature Communications, 15, 8529. https://doi.org/10.1038/s41467-024-52912-3
  40. [40]Zhou, X., Qiu, D., & Luo, L. (2023). Distributed Bernstein--Vazirani Algorithm. Physica A: Statistical Mechanics and its Applications, 629, 129209. https://doi.org/10.1016/j.physa.2023.129209
  41. [41]Chundury, S., Shehata, A., Kim, S., Gopalakrishnan Meena, M., Lu, C., Gottiparthi, K., Coello Perez, E. A., Mueller, F., & Suh, I.-S. (2025). Scaling Hybrid Quantum-HPC Applications with the Quantum Framework. Proceedings of the SC '25 Workshops of the International Conference for High Performance Computing, Networking, Storage and Analysis, 1888–1897. https://doi.org/10.1145/3731599.3767553
  42. [42]Shehata, A., Austin, B., Beck, T., Burgholzer, L., Chernoguzov, A., Churchill, S., Delgado, A., Eckert, Y., Heckey, J., Kissell, K., Klymko, K., Moles, J., Naughton, T., O'Riordan, L. J., Ortiz Pauyac, C., Prawiroatmodjo, G., Rrapaj, E., Schindler, J., Schulz, L., … Schulz, M. (2026). Quantum-HPC Software Stacks and the openQSE Reference Architecture: A Survey. https://arxiv.org/abs/2604.20912
  43. [43]Burgholzer, L., Echavarria, J., Hopf, P., Stade, Y., Rovara, D., Schmid, L., Kaya, E., Mete, B., Farooqi, M. N., Chung, M., De Pascale, M., Schulz, L., Schulz, M., & Wille, R. (2026). The Munich Quantum Software Stack: Connecting End Users, Integrating Diverse Quantum Technologies, Accelerating HPC. Proceedings of the Supercomputing Asia and International Conference on High Performance Computing in Asia Pacific Region (SCA/HPCAsia '26), 55–67. https://doi.org/10.1145/3773656.3773669
  44. [44]Zhou, R., Gan, Y., Liu, Y., & Qian, C. (2025). CloudQC: A Network-aware Framework for Multi-tenant Distributed Quantum Computing. https://arxiv.org/abs/2504.20389
  45. [45]Delle Donne, C., Iuliano, M., van der Vecht, B., Ferreira, G. M., Jirovská, H., van der Steenhoven, T. J. W., Dahlberg, A., Skrzypczyk, M., Fioretto, D., Teller, M., Filippov, P., Montblanch, A. R.-P., Fischer, J., van Ommen, H. B., Demetriou, N., Leichtle, D., Music, L., Ollivier, H., te Raa, I., … Wehner, S. (2025). An operating system for executing applications on quantum network nodes. Nature, 639, 321–328. https://doi.org/10.1038/s41586-025-08704-w
  46. [46]Cardama, F. J., Vázquez-Pérez, J., Piñeiro, C., Pena, T. F., Pichel, J. C., & Gómez, A. (2026). NetQIR: An extension of QIR for distributed quantum computing. Future Generation Computer Systems, 174, 107989. https://doi.org/10.1016/j.future.2025.107989
  47. [47]Zhang, S., Xiong, L., Liu, Y., Mark, B. L., Yang, L., Yang, Z., & Jiang, W. (2025). An End-to-End Distributed Quantum Circuit Simulator. https://arxiv.org/abs/2511.19791
  48. [48]Gupta, S., Dilley, D. J., Sheshko, N., Gonzales, A., Sullivan, S. E., Singh, M. K., & Saleem, Z. H. (2026). Gate Teleportation vs.\ Circuit Cutting in Distributed Quantum Computing. Advanced Quantum Technologies, 9, e70424. https://doi.org/10.1002/qute.70424
  49. [49]Chen, K.-C., Burt, F., Panigrahy, N. K., & Leung, K. K. (2026). Adaptive Resource Orchestration for Distributed Quantum Computing Systems. IEEE Internet Computing, 30(1), 16–25. https://doi.org/10.1109/MIC.2026.3652322
  50. [50]Pham, T. N., Nguyen, H. T., & Le-Trung, Q. (2026). QCOEM: Quantum Cloud Orchestration with Evolutionary Multi-Objective Optimization. 2026 IEEE 19th International Conference on Cloud Computing (CLOUD), 460–466. https://doi.org/10.1109/CLOUD72782.2026.00059
  51. [51]Weder, B., Barzen, J., Leymann, F., & Zimmermann, M. (2021). Hybrid Quantum Applications Need Two Orchestrations in Superposition: A Software Architecture Perspective. 2021 IEEE International Conference on Web Services (ICWS). https://doi.org/10.1109/ICWS53863.2021.00015
  52. [52]Beisel, M., Barzen, J., Leymann, F., & Weder, B. (2025). Operations Patterns for Hybrid Quantum Applications. Proceedings of the 15th International Conference on Cloud Computing and Services Science (CLOSER), 26–36. https://doi.org/10.5220/0013246900003950
  53. [53]Weder, B., Barzen, J., Beisel, M., Bühler, F., Georg, D., Leymann, F., & Stiliadou, L. (2025). Qunicorn: A Middleware for the Unified Execution Across Heterogeneous Quantum Cloud Offerings. 2025 IEEE/ACM International Workshop on Quantum Software Engineering (Q-SE), 17–24. https://doi.org/10.1109/Q-SE66736.2025.00009
  54. [54]Vázquez-Pérez, J., Cardama, F. J., Pena, T. F., & Gómez, A. (2026). Emulating NetQMPI Applications with CUNQA: A Decoupled Architecture for HPC Environments. 2026 IEEE 46th International Conference on Distributed Computing Systems Workshops (ICDCSW), 178–183. https://doi.org/10.1109/ICDCSW72724.2026.00045
  55. [55]Naito, S., Suzuki, Y., & Tokunaga, Y. (2026). Network-Based Quantum Computing: An Efficient Design Framework for Many-Small-Node Distributed Fault-Tolerant Quantum Computing. IEEE Transactions on Quantum Engineering, 7, 3104632. https://doi.org/10.1109/TQE.2026.3722428
  56. [56]Andres-Martinez, P., Forrer, T., Mills, D., Wu, J.-Y., Henaut, L., Yamamoto, K., Murao, M., & Duncan, R. (2024). Distributing circuits over heterogeneous, modular quantum computing network architectures. Quantum Science and Technology, 9(4), 045021. https://doi.org/10.1088/2058-9565/ad6734
  57. [57]van der Vecht, B., Yücel, A. T., Jirovská, H., & Wehner, S. (2025). Qoala: an Application Execution Environment for Quantum Internet Nodes. https://doi.org/10.48550/arXiv.2502.17296

Paper details

vlnc:W_my87qtbk
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 1

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Physics and Astronomy

Not recorded for this paper

View statement
Looking for related papers…
Contents