Circuit cutting, in depth

Cutting splits a circuit that is too wide (or too deep) for a device into smaller subcircuits and reconstructs expectation values classically, at the price of more shots. This chapter covers gate cuts, wire cuts, qubit reuse, the quasi-probability math and what the numbers in the Estimate card mean.

Why cut at all

Three reasons. (1) Width: a 6-qubit circuit cannot run on a 3-qubit device, or on a 127-qubit device whose good qubits form small islands. (2) Depth and SWAPs: splitting a circuit into pieces removes the long-range entangling gates that routing would turn into SWAP chains, so each piece is shallower and less noisy. (3) Parallelism: pieces run on several devices or several calibrated regions at once. The cost is sampling overhead: the total number of shots grows exponentially with the number of cuts.

Gate cut: replace a two-qubit gate by local operations

U_{CNOT} (ρ) = i = 1 \sum 6 c_{i}; (A_{i} \otimes B_{i}) (ρ), c_{i} \in {\pm \frac{1}{2}}

Quasi-probability decomposition (QPD, Mitarai & Fujii 2021): the CNOT channel equals a weighted sum of six products of single-qubit channels (Pauli rotations, projective measurements and preparations). Some weights are negative, so it is not a real probability distribution, hence 'quasi'. Each term is a separate experiment with no two-qubit gate between the halves.

γ = i \sum ∣ c_{i} ∣ = 3 \Rightarrow overhead = γ^{2} = 9 per CNOT cut, 9^{k} for k cuts

To estimate ⟨O⟩ with the same statistical error as the uncut circuit you need γ² times more shots. One cut: 9×; two cuts: 81×; three cuts: 729×. This is the 'Sampling overhead' in the Estimate card and why cuts must be few. A CZ or CP(λ) cut costs the same γ = 3; RZZ(θ) cuts are cheaper for small θ (γ = 1 + 2|sin θ|).

Wire cut: cut a qubit's time line

id (ρ) = \frac{1}{2} P \in {X, Y, Z} \sum [Tr (P ρ) P + Tr (ρ) I]; \Rightarrow; measure P here, prepare an eigenstate of P there, γ = 4

Instead of a gate, cut the wire itself: measure the qubit in the X, Y and Z bases at the cut point and, in the second half, prepare the corresponding eigenstates. The identity channel is rebuilt from eight measure-and-prepare pairs with γ = 4 (overhead 16). Wire cuts let the pieces be executed at different times, on different chips, or on the same physical qubit.

Qubit reuse: run a wide circuit on a narrow device

After a wire cut, the first half's qubit is measured and no longer needed. Reset it (|0⟩) and reuse the same physical qubit for the second half's prepared state. With enough wire cuts, a circuit of n logical qubits can run on far fewer physical qubits, trading width for depth and shots. Mid-circuit measurement and reset (the `reset` gate in the palette) are the hardware features that make this possible; IBM devices support both. qiskit-addon-cutting handles the bookkeeping: `cut_wires` inserts the move operations and `partition_problem` groups qubits that stay together.

The full workflow (what Submit cutting runs)

find_cuts(circuit, OptimizationParameters(seed), DeviceConstraints(qubits_per_subcircuit=w))
  -> cut circuit + {cuts: [('Gate Cut', idx), ...], sampling_overhead}
cut_wires(cut_circuit)                      # turn wire cuts into move ops
expand_observables(paulis, circuit, cut)    # observables follow the moved qubits
partition_problem(circuit, observables)     # subcircuits + subobservables
generate_cutting_experiments(..., num_samples=inf)  # all QPD terms, with coefficients
run each subexperiment with SamplerV2       # ideal Aer or a noisy fake backend
reconstruct_expectation_values(results, coefficients, subobservables)

'Knitting' is the last step: classical post-processing combines the subexperiment results with the QPD coefficients. It only yields expectation values ⟨P⟩ of Pauli observables, not full bitstring distributions; that is why the Cutting tab asks for observables like ZZII and compares them with the exact statevector value.

Estimate card field	Meaning	Good value
Cuts	number of gate + wire cuts found	1–2
Sampling overhead	Π γᵢ² (9 per CNOT, 16 per wire)	< 100× is practical
Depth before → subcircuits	each piece should be shallower than the original	pieces ≤ original
Shots suggested	4096 × overhead	fits your budget
minimum reached	optimizer proved no cheaper cut exists for this width	yes

Beyond the baseline

Research directions you can plug in through the CuttingStrategy interface (README): choosing cut locations with a cost model that includes device noise, not just γ; LO vs LOCC decompositions (classical communication between halves lowers γ for some gates); cutting for privacy or obfuscation, where the pieces reveal less about the whole circuit than the full one would (the idea behind Q-MaskCut); and combining cutting with error mitigation per subcircuit.

← Previous

Benchmark circuits: MQT Bench and QASMBench

The story of quantum computing

Circuit cutting, in depth

find_cuts(circuit, OptimizationParameters(seed), DeviceConstraints(qubits_per_subcircuit=w)) -> cut circuit + {cuts: [('Gate Cut', idx), ...], sampling_overhead} cut_wires(cut_circuit) # turn wire cuts into move ops expand_observables(paulis, circuit, cut) # observables follow the moved qubits partition_problem(circuit, observables) # subcircuits + subobservables generate_cutting_experiments(..., num_samples=inf) # all QPD terms, with coefficients run each subexperiment with SamplerV2 # ideal Aer or a noisy fake backend reconstruct_expectation_values(results, coefficients, subobservables)

Estimate card field

Meaning

Good value

Cuts

number of gate + wire cuts found

1–2

Sampling overhead

Π γᵢ² (9 per CNOT, 16 per wire)

< 100× is practical

Depth before → subcircuits

each piece should be shallower than the original

pieces ≤ original

Shots suggested

4096 × overhead

fits your budget

minimum reached

optimizer proved no cheaper cut exists for this width

yes