Quantum circuit cutting lets you run a circuit that exceeds a device's usable qubit limit by dividing it into smaller subcircuits, executing those pieces, and reconstructing an estimate of the original circuit's observables. This guide explains how to choose cut locations, estimate the number of subcircuits and shots, organize a Python workflow, and decide whether the reconstruction cost is justified.
Overview
Quantum circuit cutting, also called circuit knitting, is a resource trade-off rather than a way to create a larger quantum processor. Instead of executing one circuit end to end, you replace selected connections between circuit fragments with a classical decomposition. Each fragment fits within the available hardware or simulator limit. Classical post-processing then combines the fragment results to estimate a target observable, such as an expectation value.
The technique is most useful when the circuit is only moderately larger than the device's practical capacity, or when the application needs a small number of observables rather than a complete output distribution. It is less attractive when you need every bitstring probability, when many cuts are required, or when noise and sampling uncertainty already dominate the result.
A typical workflow looks like this:
Original circuit
|
| choose cut locations and target observables
v
Partitioned circuit fragments
|
| generate local measurement or preparation settings
v
Execute fragments on a simulator or quantum backend
|
| collect counts, expectation values, and metadata
v
Classical reconstruction
|
v
Estimated observable + uncertainty + resource report
Circuit cutting should be evaluated alongside ordinary circuit optimization. First reduce unnecessary qubits, depth, and entangling gates with your SDK's compilation tools. A circuit that can be made to fit through better layout, decomposition, or active-qubit selection does not need cutting. For background, compare this process with the Qiskit transpiler pass manager guide and the quantum circuit resource estimation guide.
How to estimate
The central estimate is the total execution burden created by the cuts. Let:
- F be the number of circuit fragments.
- S be the number of settings or terms generated by the cutting decomposition.
- R be the number of repeated executions, if random sampling or repeated reconstruction is used.
- N be the shots assigned to each fragment-setting combination.
A simple first-pass estimate is:
Estimated circuit executions = S × F × R
Estimated shots = S × F × R × N
This is a planning formula, not a universal SDK rule. Some implementations batch fragment jobs, reuse compatible settings, or allocate shots unevenly. Still, it exposes the main scaling problem: every additional cut can increase the number of terms and amplify statistical error. A reconstruction may also have a sampling overhead factor, often represented conceptually as O. If an uncut estimate would require N effective samples, the cut experiment may need roughly:
Effective sample budget ≈ O × N
The value of O depends on the decomposition, cut placement, observable, estimator, and execution noise. Do not treat it as a fixed property of the hardware. Measure it for the specific circuit and reconstruction method whenever possible.
Choose cuts by impact, not only by location
Start by identifying wires or gates that connect otherwise separable regions. A cut through a low-interaction boundary is generally easier to manage than a cut through a dense layer of entangling gates. Record, for each candidate:
- Which fragments result and their maximum qubit counts.
- How many decomposition terms or settings are introduced.
- Which observables require the cut connection.
- Whether the fragments remain within the backend's connectivity and depth limits.
- How much sampling overhead the reconstruction is expected to add.
Prefer the smallest number of cuts that makes the fragments executable. A cut that reduces the largest fragment by one qubit may be preferable to several cuts that produce smaller but much more expensive fragments.
Use observable-focused reconstruction
Reconstructing one expectation value is usually a narrower task than reconstructing a full probability distribution. Define the target before generating subcircuits. For example, an energy estimate may require the expectation values of a list of Pauli terms, while a classification circuit may need only one output statistic. The required observable set directly affects the number of fragment measurements and the shot budget.
Keep a separate record of the original observable definition and the reconstructed value. This prevents a common implementation error: comparing a fragmented measurement basis with an uncut result that does not represent the same operator.
Inputs and assumptions
A useful circuit-cutting estimate starts with a small experiment manifest. Avoid relying on memory or on a job dashboard alone; reconstruction requires enough metadata to reproduce the calculation.
| Input | What to record | Why it matters |
|---|---|---|
| Original circuit | Logical qubits, depth, two-qubit gates, measurements | Defines the baseline and identifies bottlenecks |
| Cut plan | Wire or gate boundaries, fragment diagrams, decomposition method | Determines term count and reconstruction logic |
| Target observables | Operators, coefficients, required precision | Controls measurement settings and shot allocation |
| Backend limits | Usable qubits, connectivity, depth constraints, queue assumptions | Determines whether fragments are executable |
| Sampling plan | Shots per setting, repetitions, random seeds | Supports uncertainty estimates and reproducibility |
| Validation reference | Smaller equivalent circuit or classical simulation where feasible | Checks the reconstruction independently |
SDK interfaces change, so keep the cutting algorithm separate from provider-specific job submission. A portable Python design can use four layers:
circuit.py # original circuit and observable definitions
partition.py # cut locations and fragment generation
executor.py # simulator or hardware submission adapter
reconstruct.py # combine results and estimate uncertainty
A provider-neutral execution contract might look like this:
def execute_fragment(fragment, setting, shots, backend):
"""Return counts or expectation data plus execution metadata."""
result = backend.run(fragment, setting=setting, shots=shots)
return {
"value": result.expectation,
"shots": shots,
"setting": setting,
"backend": result.backend_name
}
def reconstruct(records, coefficients):
value = sum(coefficients[key] * records[key]["value"]
for key in coefficients)
return value
The exact call signatures differ across Qiskit, PennyLane, Cirq, and cloud services. Treat this as an architectural template rather than a drop-in API example. Pin SDK versions, test the decomposition on a simulator, and consult the installed package documentation before moving to hardware. The quantum SDK upgrade and API migration guide is useful when an implementation crosses SDK releases.
Worked examples
Example 1: A two-fragment split
Assume a 10-qubit circuit cannot be executed on a device with only 6 usable qubits. You identify one boundary that produces two fragments of 5 and 6 qubits after accounting for the cut representation. Suppose the chosen decomposition creates 8 settings, each fragment-setting pair receives 2,000 shots, and no additional repetition is planned.
The first-pass estimate is:
- Fragments: F = 2
- Settings: S = 8
- Repetitions: R = 1
- Shots per execution: N = 2,000
- Total fragment executions: 8 × 2 × 1 = 16
- Total requested shots: 8 × 2 × 1 × 2,000 = 32,000
This calculation does not prove that 32,000 shots will achieve the desired precision. It tells you the minimum planned workload before retries, calibration circuits, validation runs, or extra repetitions. Compare the reconstructed observable with an exact or high-shot simulator result first. If the error is too large, increase shots or revise the cut placement rather than assuming that more post-processing will fix the problem.
Example 2: Comparing two cut plans
Plan A uses one cut and creates 12 settings across two fragments. Plan B uses two cuts and creates 36 settings across three fragments. With 1,000 shots per fragment-setting pair, the rough totals are:
- Plan A: 12 × 2 × 1,000 = 24,000 shots.
- Plan B: 36 × 3 × 1,000 = 108,000 shots.
Plan B may still be worthwhile if Plan A leaves a fragment beyond the backend's practical depth or produces much higher noise. The decision should compare fit, reconstruction error, uncertainty, runtime, and provider constraints—not qubit count alone. For cloud planning, include queue behavior, batching, and provider limits as separate variables; see the quantum cloud job cost and runtime planning guide.
Validation checklist
- Run the original and cut workflows on a small simulator instance.
- Compare the same observable, basis convention, and sign convention.
- Repeat with increasing shot counts to see whether error decreases as expected.
- Report the reconstructed value with an uncertainty interval or an empirical error estimate.
- Test at least one alternative cut placement when the budget allows.
For measurement-specific validation techniques, the guide to interpreting quantum circuit results provides useful context on shots and statistical uncertainty.
When to recalculate
Recalculate the plan whenever an input that affects fragment execution or reconstruction changes. In practice, revisit it when:
- The target backend changes its usable qubit count, connectivity, queue assumptions, or execution limits.
- A transpiler or decomposition update changes fragment depth or gate count.
- You move a cut, add an observable, or change the desired precision.
- Shot allocation, batching behavior, or provider pricing inputs change.
- Hardware noise makes the previous validation error unacceptable.
- An SDK release changes circuit, measurement, or job-submission interfaces.
Before committing to a large run, use this decision checklist:
- Can optimization make the original circuit fit? If yes, optimize before cutting.
- Are the fragments comfortably within limits? Leave room for measurement, routing, and provider constraints.
- Is the observable set narrow enough? Circuit cutting is easier to justify for selected observables than for a full distribution.
- Is the estimated sampling burden acceptable? Include repeated validation and uncertainty, not only the first job.
- Can you validate the reconstruction? Keep a simulator or smaller reference case in the test suite.
Finally, save a comparison record containing the original circuit hash, cut plan, fragment count, settings, shots, backend identifier, SDK versions, reconstructed values, and validation results. When hardware access, pricing inputs, or software APIs change, this record lets you recalculate the decision instead of rebuilding the analysis from scratch. That discipline makes circuit cutting a measurable engineering technique rather than an opaque workaround.