Distributed Quantum Computing

Distributed quantum computing executes one computational task across multiple quantum processing units (QPUs) whose data qubits cannot all interact locally. The processors cooperate by transferring quantum states, consuming shared entanglement to implement nonlocal operations, distributing encoded measurements, or reconstructing selected outputs from smaller subcircuits. Classical communication coordinates every one of these methods.

Connecting QPUs does not automatically create a larger useful quantum computer. A coherent distributed execution must preserve the intended global channel; a circuit-cutting task instead targets specified classical statistics. It must also pay for partitioning, network qubits, Bell-pair generation, memories, classical latency, local operations, error correction, and synchronization. A circuit that fits on the aggregate qubit count can still be impossible to execute before its data decohere or too slow to beat a single better-connected processor.

The remote CNOT provides a concrete starting point: one shared Bell pair and local operations implement a gate across two processors. We then compare moving the data, packing several remote operations, and reconstructing observables from separate subcircuits. The comparison depends on communication time and noise as well as qubit count.

Required background. Teleportation explains state transfer and Pauli corrections. Network architectures supplies pair services and timing; modular architectures describes processor interfaces, and the software stack introduces compilation and runtime control.

Coherent computation and reconstructed statistics

The term is used for several different activities. They should be labeled before comparing performance.

Model	Resource across processors	Output
Entanglement-assisted	shared states and LOCC	live global state or channel
State transfer	quantum carriers	coherent data at a new location
Circuit cutting	repeated local runs	reconstructed statistics
Shot parallelism	independent runs	more samples or parameter points
Delegation	client–server interaction	result returned to a client

The first two rows are coherent DQC: an inaccessible reference system can remain entangled with data spanning the processors. Circuit cutting is a valuable distributed workload, but it replaces quantum communication by sampling and classical postprocessing; it generally does not leave a reusable joint quantum output. Running $10^6$ independent shots across $100$ QPUs is parallel quantum computing, not evidence that the QPUs jointly implemented a $100$-times-larger coherent circuit.

Delegation answers a different question: who supplies and trusts the computation? Blind and Delegated Quantum Computation explains privacy and verification. A distributed machine is not blind merely because its processors are separated.

Preserving the intended channel

Let processor $P_i$ expose data qubits $D_i$, communication qubits $N_i$, a local gate set $\mathcal G_i$, measurements $\mathcal M_i$, and timing and error models. A distributed compiler is given a logical program $\mathcal A$ and a network service graph. Its task is to construct an execution whose implemented channel $\widetilde{\mathcal A}$ approximates $\mathcal A$ under a declared error criterion.

The compiler must know the available transfer or entanglement services, local operations, memory capacity and accepted error. It must also distinguish data qubits from communication and ancillary qubits: physical capacity spent generating a Bell pair is unavailable for storing extra application data.

The distinction between data and communication qubits matters. If a module has one network qubit, it may be able to reach every other module over time while admitting only one entanglement attempt or remote operation at once. Aggregate qubit count and graph reachability do not reveal this port bottleneck.

Correctness must be defined at the application boundary. If the ideal circuit acts on data $Q$ entangled with an arbitrary reference $R$, a strong channel criterion is

$$\frac12 \left\| \left( \operatorname{id}_R\otimes\widetilde{\mathcal A} \right)(\rho_{RQ}) - \left( \operatorname{id}_R\otimes\mathcal A \right)(\rho_{RQ}) \right\|_1 \le \varepsilon$$

for all inputs $\rho_{RQ}$ in the specified code space, or the corresponding diamond-norm bound. For an aborting implementation, compare the complete output including its abort flag or explicitly use a subnormalized accepted map; an input-dependent normalized success branch is not generally a linear channel. Testing only computational-basis inputs can miss lost phase coherence and broken entanglement across modules.

Three Ways to Cross a Boundary

Telegate

A telegate uses preshared entanglement, local operations, measurements, classical communication, and feed-forward to implement a gate whose operands remain in separate modules. The term overlaps with gate teleportation, but that phrase is broader: it also includes teleporting data through a specially prepared resource state to implement a difficult local gate. Here telegate means a nonlocal operation between QPUs.

The network can prepare a Bell pair before the application reaches the gate. Photon loss then causes another resource-generation attempt rather than loss of the data qubits. The gate is deterministic only conditioned on an accepted pair and successful required local operations. Calling the entire service deterministic while omitting stochastic setup time is misleading.

Teledata

Teledata moves a data state from one QPU to another, usually by quantum teleportation. Gates that were nonlocal can then be executed locally. The source qubit is consumed and the destination qubit takes over its logical identity; the compiler’s placement map must change.

Teledata can save entanglement when one qubit participates in many operations at a remote module. It can also create later communication, overload the destination, or require a return teleport. State placement is therefore a time-dependent compilation decision rather than a one-time graph partition.

Circuit cutting

Circuit cutting replaces a wire or nonlocal gate by a linear combination of local preparations, operations, and measurements. The subcircuits can run without a quantum link, after which a classical estimator reconstructs a specified quantity. The price is often exponential sampling or term-count overhead in the number and kind of cuts. It is not a free substitute for entanglement-assisted execution.

Remote CNOT from One Bell Pair

The remote controlled-NOT is the basic telegate because it exposes every architectural ingredient. Alice holds control $c$ and one half $a$ of

$$\lvert\Phi^+\rangle_{ab} = \frac{\lvert00\rangle_{ab}+\lvert11\rangle_{ab}}{\sqrt2},$$

while Bob holds $b$ and target $t$. Following Eisert et al. (2000), let the arbitrary data state be

$$\lvert\psi\rangle_{ct} = \sum_{i,j\in\{0,1\}} \alpha_{ij} \lvert i\rangle_c\lvert j\rangle_t.$$

Entangle the remote control

Alice applies $\operatorname{CNOT}_{c\to a}$, measures $a$ in the computational basis, and sends outcome $m\in\{0,1\}$ to Bob. Bob applies $X_b^m$, physically or through an equivalent frame update. Up to normalization, the surviving state is

$$\lvert\Psi_1\rangle_{cbt} = \sum_{i,j} \alpha_{ij} \lvert i\rangle_c \lvert i\rangle_b \lvert j\rangle_t.$$

The control information is now encoded nonlocally in a cat-like correlation. This does not copy an arbitrary control state into $b$: tracing out $c$ removes the local phase coherence of $b$. Alice has not measured $c$, so superpositions and entanglement with a reference are preserved.

Apply the target operation locally

Bob applies $\operatorname{CNOT}_{b\to t}$:

$$\lvert\Psi_2\rangle_{cbt} = \sum_{i,j} \alpha_{ij} \lvert i\rangle_c \lvert i\rangle_b \lvert j\oplus i\rangle_t.$$

He then measures $b$ in the $X$ basis. Let $n=0$ denote outcome $\lvert+\rangle$ and $n=1$ denote $\lvert-\rangle$. The data qubits become

$$\lvert\psi_n\rangle_{ct} = Z_c^n \sum_{i,j} \alpha_{ij} \lvert i\rangle_c \lvert j\oplus i\rangle_t.$$

Bob sends $n$ to Alice, who applies $Z_c^n$ or updates the Pauli frame. Since $(Z_c^n)^2=I$, the result is

$$\lvert\psi_{\rm out}\rangle_{ct} = \operatorname{CNOT}_{c\to t} \lvert\psi\rangle_{ct}.$$

The protocol consumes one ebit, uses one local CNOT in each module, measures the two network qubits, and sends one classical bit in each direction. One ebit and one classical bit in each direction are sufficient and necessary for exact deterministic remote CNOT under the standard entanglement-assisted LOCC setting. The local-gate count describes this construction, not a universal lower bound on every local implementation. A remote controlled-$Z$ follows from

$$\operatorname{CZ}_{ct} = (I_c\otimes H_t) \operatorname{CNOT}_{c\to t} (I_c\otimes H_t).$$

Classical communication is essential because CNOT can signal in either direction for suitable inputs. Alice can send a bit forward using $|0\rangle_c$ or $|1\rangle_c$ with target $|0\rangle_t$. Bob can send a bit backward using $|+\rangle_t$ or $|-\rangle_t$ with control $|+\rangle_c$: phase kickback gives Alice $|+\rangle_c$ or $|-\rangle_c$. Shared entanglement alone cannot implement these signaling effects.

Time runs left to right. Alice holds $c,a$; Bob holds $b,t$. The initial network qubits $a,b$ share $\Phi^+$. Dashed arrows carry the measurement bits $m,n$; they do not carry a quantum state. After the two corrections, the data qubits have undergone $\operatorname{CNOT}_{c\to t}$. The network qubits have been measured and consumed. A known Pauli frame can be propagated through later Clifford gates, but dependent operations must eventually use the correct frame.

Teledata versus Telegate

There is no universal winner. Consider a qubit at Alice that must control $k$ gates on Bob’s data and eventually return to Alice. A naive telegate lowering uses $k$ Bell pairs. Teledata can teleport the qubit to Bob, perform all $k$ gates locally, and teleport it back, using two Bell pairs. If the final state may remain at Bob, it uses only one.

This count is an orientation, not an optimizer. It omits:

• whether Bob has a free data and communication port;
• operations on Alice’s qubit that must occur between remote gates;
• Bell-pair fidelity, age, and directional classical latency;
• the cost of updating every later reference to the migrated logical qubit;
• parallel remote gates that telegate can execute while one teledata transfer serializes a path;
• fault-tolerant code deformation, decoding, or logical teleportation.

Repeated controlled operations can sometimes be packed into one entanglement-assisted distributing process. The cat-like remote-control state is retained across several compatible target operations and disentangled only afterward. Incompatible intervening gates or causality constraints break the packing. Counting every syntactically nonlocal CNOT as one ebit is therefore a constructive upper bound, not always the optimum.

An ebit-saving transformation can lose overall if it lengthens the critical path beyond memory lifetime or increases correlated errors. Compare Bell-pair consumption, local ancillas, communication rounds, runtime and error for the actual executable block.

Partitioning the Program

Weighted interaction graph

For a circuit on logical qubits $Q$, define a weighted interaction graph $G_C=(Q,E_C,w)$. A simple weight is the number of two-qubit gates between $q_i$ and $q_j$,

$$w_{ij} = \sum_{g\in\mathcal G_2} \mathbf 1 \left[ g\text{ acts on }(q_i,q_j) \right].$$

For a static placement $\pi:Q\to\{1,\ldots,M\}$, the naive cut cost is

$$C_{\rm cut}(\pi) = \sum_{(i,j)\in E_C} w_{ij} \mathbf 1[\pi(q_i)\ne\pi(q_j)].$$

Minimizing this cost subject to each QPU’s capacity is a useful first step. It is not the complete compilation problem. Gates have a causal order; Bell pairs can be packed or generated in parallel; links and network ports have unequal rate; QPUs have different native gates and error; and a low-cut partition can create a long serial bottleneck.

Why hypergraphs help

Several nonlocal controlled gates that share a control can sometimes use one distributed control state. Representing that group as a hyperedge captures a resource that pairwise edge counting misses. Andrés-Martínez and Heunen (2019) use hypergraph partitioning to group circuit structure while minimizing quantum communication. The hyperedge weight must still correspond to a realizable remote protocol; a combinatorial grouping is not itself a schedule.

Time-dependent placement

With teledata, the placement is $\pi_t(q)$ rather than a fixed map. Moving a qubit can make a future block local and a formerly local block remote. A time-expanded compiler can choose migrations, telegates, and local SWAPs while respecting QPU and link capacity.

A compiler can constrain error and deadlines while minimizing Bell pairs or runtime, rather than combining incomparable quantities in an unexplained weighted score. Its output must preserve the circuit’s dependency graph and the physical capacity of each processor and network port.

At runtime, an operation is ready only when its data, remote resources and required classical information are available. A migration changes the physical location associated with the logical qubit and its frame. Pauli corrections can sometimes remain symbolic through Clifford gates, but their bits must remain associated with the correct qubit. NetQASM (Dahlberg et al., 2022) illustrates an interface between hybrid programs and node operations; it does not remove hardware-specific timing and error constraints.

Latency, Throughput, and Backpressure

For one remote gate admitted only after a usable Bell pair exists, write

$$T_{\rm remote} = T_{\rm wait}^{\rm Bell} +T_{\rm local} +T_{\rm meas} +T_{\rm class} +T_{\rm ff}.$$

If a valid pair was generated proactively and reserved in advance, $T_{\rm wait}^{\rm Bell}$ can be hidden from that gate’s observed latency. It has not vanished from resource cost: the inventory occupies memories, decoheres, and may expire unused.

For an execution dependency graph $D=(O,E_D)$ with duration $d_o$ for each operation, the ideal makespan obeys the critical-path lower bound

$$T_{\rm run} \ge \max_{P\in\operatorname{Paths}(D)} \sum_{o\in P}d_o.$$

Resource contention can make the actual value larger. Two causally independent remote gates may still serialize on one network qubit, detector, switch, Bell source, or classical controller.

If an application consumes on average $\bar e$ accepted Bell pairs per run, then a basic steady-state constraint is

$$R_{\rm app} \le \frac{R_{\rm Bell}^{\rm accepted}}{\bar e}.$$

The accepted rate must use the application’s quality and age thresholds. A more complete bottleneck bound includes local gates, measurements, decoder capacity, and the narrowest network cut:

$$R_{\rm app} \le \min \left( \frac{R_{\rm Bell}}{\bar e}, \frac{R_{\rm local}}{\bar g}, \frac{R_{\rm meas}}{\bar m}, R_{\rm dec}, R_{\rm cut} \right).$$

Average demand is insufficient for bursty circuits. If a layer needs $b$ pairs nearly simultaneously but a module buffers only $m<b$, the scheduler must split the layer or change the primitive. Local QPUs then experience backpressure while waiting for network supply. Queueing delay lengthens memory exposure and can raise the number of pairs discarded by age cutoffs.

Noise and Correctness

Composing channel errors

A noisy remote operation includes Bell-state preparation, storage, local gates, measurements, classical decoding, and corrections. If each implemented component channel $\widetilde{\mathcal E}_j$ is compared with an ideal $\mathcal E_j$ by

$$\epsilon_j = \frac12 \left\| \widetilde{\mathcal E}_j-\mathcal E_j \right\|_\diamond,$$

then repeated triangle inequalities give the conservative compositional bound

$$\epsilon_{\rm remote} \le \sum_j\epsilon_j.$$

This bound assumes the actual execution is the stated composition of channels, including classical registers needed for adaptive control. If an unmodeled environment remembers earlier operations, separately measured marginal channels need not compose. One must include that memory in the model or use appropriate conditional worst-case bounds. Exercise 8 gives a simple counterexample. Within its premises, the bound has an operational meaning. Adding incompatible state fidelities as though they were independent error probabilities does not.

Heralded loss and false heralds

Loss before admission can be retried if failed attempts leave data intact. A false herald is more dangerous: the runtime admits a remote operation while the advertised resource is absent or wrong. Report conditional pair quality, false-herald probability, data disturbance during failed attempts, and the full wait distribution separately.

Correlated and non-Pauli errors

The same optical phase, clock, calibration, or controller can affect several remote gates. Leakage can persist between operations. Pair purification can correlate accepted resources through shared data. A stochastic independent Pauli model is useful only after its adequacy has been tested for the workload and decoder.

What “deterministic” means

For a single attempt with ordered events—resource prepared, gate admitted, gate completed and output accepted—the chain rule is

$$\Pr(R,A,G,O)=\Pr(R)\Pr(A\mid R)\Pr(G\mid A,R)\Pr(O\mid G,A,R).$$

No independence is assumed. An ideal gate can complete with probability one after admission while resource generation succeeds rarely per optical attempt. Retrying until a deadline changes the experiment and its time denominator. Postselected tomography introduces another condition. Neither a conditional gate probability nor the source clock is an application throughput.

Circuit Cutting and Classical Reconstruction

Circuit cutting reconstructs a specified expectation value from physically executable local experiments. Schematically write

$$\mu=\sum_{\lambda=1}^L a_\lambda m_\lambda,\qquad \gamma=\sum_\lambda|a_\lambda|,$$

where $m_\lambda$ is the mean of a scored local experiment, including any measurement outcomes and permitted classical communication. The precise decomposition matters: a signed sum of products of local trace-preserving channels is still nonsignaling and cannot represent an arbitrary signaling bipartite gate such as CNOT. Local instruments, outcome-dependent scores or classically coordinated operations supply the needed additional structure (Peng et al., 2020; Piveteau and Sutter, 2024).

If experiment $\lambda$ returns a score $x_\lambda\in[-1,1]$, sample it with probability $|a_\lambda|/\gamma$ and output

$$Y=\gamma\,\operatorname{sgn}(a_\lambda)x_\lambda.$$

Then $\mathbb E[Y]=\mu$ and $|Y|\le\gamma$. For independent shots, Hoeffding’s inequality gives the sufficient condition

$$N\ge\frac{2\gamma^2}{\epsilon^2}\ln\frac2\delta$$

for additive error at most $\epsilon$ except with probability $\delta$. This is an upper bound for this bounded estimator, not a universal lower bound on all reconstruction methods. Acceptance probabilities must remain in the scores; silently normalizing away discarded instrument outcomes changes the estimator.

Independent cut decompositions multiply their norms, so the sufficient shot bound can grow exponentially with cut count. Joint decompositions, structure in the observable and improved sampling can reduce the cost. A raw number of cut wires therefore does not specify the overhead.

Circuit cutting is attractive when:

• only selected observables or marginal probabilities are required;
• the circuit has a weak, low-rank boundary;
• subcircuits fit substantially better on available hardware;
• classical postprocessing and repeated shots are cheaper than a quantum link;
• noise reduction from smaller subcircuits outweighs reconstruction variance.

It is unattractive when many cuts multiply $\gamma$, the full output distribution is required, or a later quantum stage needs the joint output state. Report number and type of cuts, decomposition norm, term count, shots, classical postprocessing, error bars, and any noise-mitigation bias. “Ran a larger circuit” is incomplete if only one reconstructed observable was obtained.

Fault-Tolerant Distributed Computing

Physical remote gates are not enough for long algorithms. Fault-tolerant DQC must connect logical qubits while keeping link errors, waiting, and classical latency inside a correctable spacetime fault model.

Several architecture families are under study:

• purify noisy physical Bell pairs before injecting them into logical operations;
• prepare encoded Bell pairs and use logical teleportation;
• measure nonlocal logical parities through shared Bell resources and lattice surgery;
• apply transversal remote gates between compatible code blocks;
• build a distributed cluster or graph state and compute by measurements.

The network requirement is code- and schedule-dependent. “Bell fidelity above threshold” is not a standalone criterion. The operation may need a burst of many pairs per code cycle, correlated failures can defeat a decoder, and slow delivery can enlarge the spacetime volume exposed to memory error.

Code distance, block size and network-port count are different quantities. A transversal CNOT between two $[[n,1,d]]$ blocks applies $n$ physical cross-block CNOTs; implementing each by the one-ebit primitive uses $n$ physical Bell pairs, not $d$. Whether they must be available simultaneously depends on the chosen schedule and fault model. Logical teleportation, lattice surgery and other constructions can have different costs.

The analysis must include memory noise during waits, decoder latency, correlated link faults and the target logical error. Jiang et al. (2007) and Nickerson, Fitzsimons and Benjamin (2014) develop architectures that combine local processing with imperfect shared entanglement. Their conclusions depend on the assumed physical operations and error model; a large isolated Bell fidelity is not a universal threshold.

Workloads and When Distribution Helps

Distribution is most plausible when it relieves a binding physical constraint: fabrication yield, cryogenic wiring, optical access, local connectivity, control crosstalk, or maximum code-block size. It can also connect specialized modules such as data processors, memories, magic-state factories, and photonic interfaces.

The workload must have exploitable structure. Examples include:

• arithmetic with blocks that interact through narrow carry interfaces;
• Hamiltonian simulation with weakly coupled spatial or orbital fragments;
• algorithms whose control qubits can support packed remote controlled gates;
• fault-tolerant factories that feed several data modules;
• circuits whose interaction graph follows a sparse module graph;
• ensembles of subproblems whose classical outer loop is naturally parallel.

No generic complexity advantage follows from replacing one $n$-qubit QPU by two $n/2$-qubit QPUs. The joint Hilbert space has the same formal dimension only if the network operations preserve coherent access to it. Communication can dominate runtime, error, or qubit overhead. For classically separable workloads, independent QPUs may improve throughput without increasing the largest coherent problem size.

Geographic distance is often a disadvantage for tightly coupled computation because classical round trips enter the critical path. A modular machine under one scheduler and a federation across administrative domains may use the same remote-CNOT identity but have very different latency, trust, calibration, and failure contracts.

Trust and recovery

Distributed execution expands the trusted computing base. The system must authenticate program fragments, pair and request identifiers, measurement messages, calibration versions, and result provenance. A malicious QPU can return plausible but false outcomes; a compromised controller can alter placement or route sensitive metadata through an unauthorized domain.

Ordinary fault recovery and adversarial verification are different:

• a crash fault can trigger timeout, pair cleanup, and rescheduling if the program state has not been irreversibly consumed;
• a Byzantine or malicious fault requires cryptographic or quantum verification, often with substantial overhead;
• a straggler can hold entanglement and memory leases while other QPUs decohere;
• a partial commit can consume one side of a resource while another node retries unless operation identifiers and state transitions are atomic.

Blindness, verifiability, and secure multiparty computation require dedicated protocols. Entanglement alone does not hide a circuit, input, output, timing, or communication graph.

A remote gate is an important primitive, but a useful distributed program must invoke it with the required timing, preserve data between calls and produce the intended output. Comparisons should use the same task, accuracy and elapsed time. Network case studies discuss experimental examples; network verification explains statistical tests of the delivered operation. Privacy and fault tolerance require their own protocols and cannot be inferred from physical separation alone.

Exercises

1: Verify the remote CNOT

Start with

$$\lvert\psi\rangle_{ct} = \alpha\lvert00\rangle +\beta\lvert01\rangle +\gamma\lvert10\rangle +\delta\lvert11\rangle.$$

Using the protocol above, write the final state before Alice’s last $Z^n$ correction and then after it.

Solution

After the cat-entangler, Bob’s local CNOT, and his $X$-basis measurement with outcome $n$, the data state is

$$\lvert\psi_n\rangle_{ct} ={} \alpha\lvert00\rangle +\beta\lvert01\rangle +(-1)^n\gamma\lvert11\rangle +(-1)^n\delta\lvert10\rangle.$$

This is $Z_c^n\operatorname{CNOT}\lvert\psi\rangle$. Alice’s correction $Z_c^n$ cancels the phase, giving

$$\alpha\lvert00\rangle +\beta\lvert01\rangle +\gamma\lvert11\rangle +\delta\lvert10\rangle,$$

which is exactly $\operatorname{CNOT}_{c\to t}\lvert\psi\rangle$.

2: Teledata or telegate?

A qubit at $A$ must control five compatible gates on data at $B$ and then be used again at $A$. Compare the naive Bell-pair counts for telegate and for teledata. State two reasons the lower count need not minimize runtime.

Solution

Naive telegate lowering uses one Bell pair per remote controlled gate, for five pairs. Teledata sends the control to $B$, performs five local gates, and returns it to $A$, for two teleportations and therefore two Bell pairs. It also uses four classical bits in the teleportation directions.

The two-pair strategy can still be slower if the transfers serialize on a network port, while telegates could use parallel links or pregenerated pairs. It may also wait for a free destination data slot, incur more logical movement or code deformation, or disrupt operations at $A$. Conversely, compatible telegates might themselves be packed into fewer than five pairs, so the naive count is not optimal.

3: Weighted partition

Four logical qubits have interaction weights

$$w_{12}=8, \quad w_{23}=3, \quad w_{34}=8, \quad w_{14}=1, \quad w_{13}=2.$$

Two equal QPUs each hold two qubits. Compute the cut cost for the three distinct balanced partitions and choose the best under the naive objective.

Solution

For $\{1,2\}|\{3,4\}$, the crossing edges are $(2,3)$, $(1,4)$, and $(1,3)$, so

$$C_{\rm cut}=3+1+2=6.$$

For $\{1,4\}|\{2,3\}$, edges $(1,2)$, $(3,4)$, and $(1,3)$ cross, giving $8+8+2=18$. For $\{1,3\}|\{2,4\}$, edges $(1,2)$, $(2,3)$, $(3,4)$, and $(1,4)$ cross, giving $8+3+8+1=20$. The first partition is best under this static edge-count model. Rate, packing, port contention, and gate order can change the preferred executable schedule.

4: Hiding pair-generation latency

Accepted Bell-pair waiting time has mean $40\ \mathrm{ms}$, while local gates, measurement, classical messaging, and feed-forward take $1\ \mathrm{ms}$. Find the mean observed gate latency for reactive generation. If proactive inventory supplies a valid pair on arrival with probability $0.8$, and a miss then incurs the full reactive latency, find the simplified mean.

Solution

Reactive execution has mean

$$\mathbb E[T_{\rm reactive}] = 40+1 = 41\ \mathrm{ms}.$$

With an inventory hit, the gate takes $1\ \mathrm{ms}$; with a miss, it takes $41\ \mathrm{ms}$. Thus

$$\mathbb E[T_{\rm proactive}] = 0.8(1)+0.2(41) = 9\ \mathrm{ms}.$$

The improvement consumes memory time and generation capacity and ignores pair expiration, replacement policy, and correlations in demand.

5: Circuit-cutting overhead

Suppose each of four independent gate cuts has quasiprobability norm $\gamma_0=3$. Estimate the product norm and the relative shot-overhead factor $\gamma^2$ compared with an estimator of norm one.

Solution

Independent decompositions multiply:

$$\gamma = \gamma_0^4 = 3^4 =81.$$

The variance-driven shot factor is therefore

$$\gamma^2 = 81^2 =6561.$$

This illustrates exponential cut cost. A joint decomposition can have a lower norm, and real shot cost also depends on observable variance, allocation among terms, confidence, hardware noise, and postprocessing.

6: Compositional error bound

A remote gate has half-diamond-distance bounds $0.004$ for its Bell-resource preparation channel, $0.001$ for Alice’s local block, $0.002$ for Bob’s block, and $0.003$ for measurement and feed-forward. Give the conservative composed bound and explain why it need not predict measured average gate infidelity.

Solution

The triangle bound gives

$$\epsilon_{\rm remote} \le 0.004+0.001+0.002+0.003 =0.010.$$

Half-diamond distance is a worst-case channel metric, including reference-system entanglement. Average gate infidelity averages over inputs and has a dimension-dependent relation to channel distances. Coherent errors can also combine constructively or cancel. The number $0.010$ is a valid conservative bound under the component contracts, not a prediction that tomography must report one percent infidelity.

7: Logical Bell-pair supply

A chosen implementation of transversal CNOT between two $[[7,1,3]]$ Steane-code blocks consumes seven qualified physical Bell pairs simultaneously, with enough network ancillas to hold them. The workload requests $200$ such operations per second. What accepted pair rate and burst buffer are necessary before extra losses or retries? If purification yield is $0.20$, what raw pair rate is required in the simplified steady-state model?

Solution

The accepted demand is

$$R_{\rm Bell}^{\rm accepted} = 7\times200 =1400\ \mathrm{s}^{-1}.$$

At least seven compatible pairs must be available together for one operation, so a buffer of one or two pairs cannot sustain the stated primitive even if its long-term average rate is high. With yield $Y=0.20$,

$$R_{\rm Bell}^{\rm raw} = \frac{1400}{0.20} =7000\ \mathrm{s}^{-1}.$$

Actual provisioning must include failed logical operations, age cutoffs, quality correlations, and headroom for burst and outage statistics.

8: A shared noise bit defeats marginal composition

A control system samples a fair bit $b$ once and applies $Z^b$ to the same data qubit at each of two successive stages. Each stage separately looks like complete dephasing. Compare the actual two-stage operation with the composition of those two marginal channels. Use half of a Bell pair as input.

Solution

For either value of $b$, the actual product is $Z^bZ^b=I$, so the Bell pair is preserved. The marginal channel is $\mathcal D(\rho)=(\rho+Z\rho Z)/2$. Treating its occurrences as independent gives $\mathcal D\circ\mathcal D=\mathcal D$, whose Bell output is

$$\tfrac12|\Phi^+\rangle\langle\Phi^+|+\tfrac12|\Phi^-\rangle\langle\Phi^-|.$$

Its Bell overlap is $1/2$, whereas the actual output has overlap one. The shared classical bit is an environment memory. A product of marginal channels discards that memory and describes a different process. The example does not invalidate channel-composition bounds when their channel premise is satisfied; it explains why correlated errors require more than isolated component measurements.

References

• P. Andrés-Martínez and C. Heunen, “Automated distribution of quantum circuits via hypergraph partitioning,” Physical Review A 100, 032308 (2019), doi:10.1103/PhysRevA.100.032308.
• A. Dahlberg et al., “NetQASM—a low-level instruction set architecture for hybrid quantum–classical programs in a quantum internet,” Quantum Science and Technology 7, 035023 (2022), doi:10.1088/2058-9565/ac753f.
• J. Eisert, K. Jacobs, P. Papadopoulos, and M. B. Plenio, “Optimal local implementation of nonlocal quantum gates,” Physical Review A 62, 052317 (2000), doi:10.1103/PhysRevA.62.052317.
• L. Jiang, J. M. Taylor, A. S. Sørensen, and M. D. Lukin, “Distributed quantum computation based on small quantum registers,” Physical Review A 76, 062323 (2007), doi:10.1103/PhysRevA.76.062323.
• N. H. Nickerson, J. F. Fitzsimons, and S. C. Benjamin, “Freely scalable quantum technologies using cells of 5-to-50 qubits with very lossy and noisy photonic links,” Physical Review X 4, 041041 (2014), doi:10.1103/PhysRevX.4.041041.
• T. Peng, A. W. Harrow, M. Ozols, and X. Wu, “Simulating Large Quantum Circuits on a Small Quantum Computer,” Physical Review Letters 125, 150504 (2020), doi:10.1103/PhysRevLett.125.150504.
• C. Piveteau and D. Sutter, “Circuit Knitting With Classical Communication,” IEEE Transactions on Information Theory 70, 2734–2745 (2024), doi:10.1109/TIT.2023.3310797.