When a quantum circuit exceeds the qubit count, connectivity, or noise budget of available hardware, circuit cutting can turn one large experiment into a collection of smaller ones. This tutorial explains how to choose cut points, execute the resulting subcircuits, reconstruct observables, estimate sampling overhead, and decide whether circuit cutting is preferable to a full-circuit run or a tensor-network simulation.
Overview
Quantum circuit cutting, also called circuit fragmentation or circuit knitting, separates a circuit into fragments that can be run independently. Classical post-processing then combines the fragment results to estimate an observable from the original circuit. The approach is useful when the logical circuit is too wide or too poorly connected for the target device, but it does not create a free increase in computational capacity. The main tradeoff is usually a larger number of circuit executions and greater statistical uncertainty.
There are two broad forms:
- Wire cutting: Break a qubit wire between circuit regions. The state crossing the cut is represented through a set of preparations and measurements, allowing each side to run as a separate fragment.
- Gate cutting: Replace an operation that crosses a partition with a classical linear combination of operations that can be implemented within separate fragments.
The reconstructed result normally targets an expectation value, such as <Z0Z1>, rather than the complete probability distribution of the original circuit. This distinction matters: estimating one carefully chosen observable may be practical, while reconstructing every output bit string can require substantially more fragment measurements.
Circuit cutting is therefore best viewed as an experiment-design technique for constrained hardware. It can help answer a scientific or engineering question when a full circuit cannot run, but it does not reproduce the full state at the same cost as an ordinary execution.
How to estimate
Before writing code, define the quantity you want to estimate and count the work introduced by each cut. A useful first-order model is:
Total executions ≈ number of reconstructed terms × shots per term × repetitions or circuit variants.
For a reconstructed observable, write the estimator as:
E = Σi ciEi
Here, each Ei is an expectation value measured from a fragment configuration, and ci is its reconstruction coefficient. The coefficients are determined by the selected cutting decomposition. They may be positive or negative, so the estimator can combine several noisy measurements through cancellation.
A practical planning quantity is the coefficient weight:
W = Σi|ci|
As a planning rule, sampling effort often grows with the square of this weight when the goal is to maintain a fixed estimator precision. This is not a universal performance guarantee: variance also depends on the observable, fragment noise, allocation of shots, and correlations between measurements. Still, a decomposition with a large coefficient weight should be treated as expensive before it is submitted to hardware.
A repeatable workflow
- Choose the target observable. Express it as a Pauli term or a sum of Pauli terms. Limit the initial experiment to the quantities needed for the application.
- Map the hardware constraint. Record the available qubit count, coupling graph, native gate set, and any restrictions imposed by the execution platform.
- Select candidate cut points. Prefer cuts that separate dense portions of the circuit while avoiding unnecessary fragmentation. A cut through a lightly used wire may be cheaper than a cut through a high-entanglement region, but this must be tested rather than assumed.
- Generate fragment configurations. Each cut produces a defined set of state preparations, basis measurements, or replacement operations. Keep a machine-readable record linking every configuration to its reconstruction coefficient.
- Compile each fragment independently. Transpilation can change depth, connectivity, and measurement cost. Inspect the compiled fragments rather than estimating from the original circuit alone.
- Run a small pilot.** Use a modest shot budget to check that every fragment executes and that counts, measurement order, and observable signs are interpreted consistently.
- Allocate the production shot budget. Uniform allocation is simple, but terms with larger coefficients or higher variance may deserve more shots.
- Reconstruct and report uncertainty. Combine the fragment estimates with their coefficients and include confidence intervals, repeated-run variation, or another uncertainty estimate.
- Compare against a baseline. If possible, run the uncut circuit on a simulator or on a smaller equivalent instance. This separates reconstruction error from ordinary hardware noise and implementation mistakes.
SDK utilities can automate parts of this process, but their supported gates, decomposition conventions, measurement ordering, and result formats change across releases. Treat the generated fragment list and coefficients as experiment artifacts, and pin the software environment used to create them.
Inputs and assumptions
A circuit-cutting estimate is only as useful as the inputs behind it. Capture the following before comparing strategies:
| Input | Why it matters | What to record |
|---|---|---|
| Original circuit | Determines width, depth, entangling structure, and candidate partition points. | Logical qubits, two-qubit gates, depth, and target observables. |
| Partition | Controls fragment width and the number of cross-partition operations. | Which wires or gates are cut and the qubits assigned to each fragment. |
| Decomposition | Determines the number of configurations and reconstruction coefficients. | Term count, coefficient list, supported operation types, and coefficient weight. |
| Shot budget | Controls statistical precision and execution cost. | Shots per configuration, allocation method, and repeated batches. |
| Compilation | Changes depth and may add routing operations. | Compiled depth, native gates, measurement basis changes, and qubit mapping. |
| Noise model | Fragment results may have different error profiles from the original circuit. | Simulator noise assumptions or hardware calibration context, if available. |
Several assumptions deserve explicit attention. First, the fragments must preserve the intended boundary semantics. A qubit ordering mismatch or an incorrect Pauli sign can produce plausible-looking but invalid results. Second, each fragment may require different measurement bases. Count those settings separately when estimating execution volume. Third, the reconstruction estimator can have negative or large coefficients; ordinary averages of fragment values are not sufficient.
Do not compare only the number of qubits. Compare the complete workload: fragment count, measurement settings, shots, compilation time, queue or submission overhead where relevant, and the uncertainty of the final observable. A smaller fragment can still be the more expensive option if cutting creates many configurations.
Worked examples
Example 1: A six-qubit circuit split into two fragments
Assume a six-qubit circuit contains an interaction pattern that is difficult to place on a four-qubit device. You divide the circuit into a left fragment containing three qubits and a right fragment containing three qubits, with two wire cuts between them. The objective is one expectation value, not the full six-qubit output distribution.
Your cutting method produces 12 fragment configurations. You plan 2,000 shots for each configuration. The initial execution estimate is therefore:
12 configurations × 2,000 shots = 24,000 shots.
If the observable contains several Pauli terms, the 12 configurations may apply to each term or to a combined measurement grouping, depending on the implementation. Do not assume that one count applies to the whole observable until you inspect the generated measurement plan.
Suppose the reconstruction coefficients have a total absolute weight of 3. A rough planning interpretation is that preserving the precision of an uncutted estimator may require substantially more samples than the raw 24,000-shot count suggests. Run a pilot first, estimate the variance of each term, and then decide whether to increase shots or revise the partition.
Example 2: Choosing among four approaches
| Approach | Best fit | Main cost or limitation |
|---|---|---|
| Full-circuit execution | The device supports the width and connectivity, and the circuit is short enough to run directly. | May be blocked by qubit count, routing, depth, or noise. |
| Wire cutting | The circuit can be divided into regions connected by a manageable number of wire boundaries. | Introduces preparation and measurement configurations plus sampling overhead. |
| Gate cutting | A small number of cross-partition gates prevent an otherwise useful decomposition. | Each cut gate can expand into multiple terms and increase coefficient weight. |
| Tensor-network simulation | The circuit has structure such as limited entanglement or favorable connectivity for classical contraction. | Runtime and memory can grow quickly when contraction complexity is high; it is not a hardware execution. |
For this six-qubit example, begin with a simulator baseline, then compare a direct run on the largest available compatible device with the cut reconstruction. Evaluate the same observable, use comparable shot counts where possible, and report both the central estimate and its uncertainty. If the cut result is not accurate enough, changing the partition may help more than simply adding shots.
When to recalculate
Recalculate the circuit-cutting estimate whenever an input changes, not only when the circuit width changes. In particular, revisit it when you:
- Move a wire or gate cut to a different location.
- Change the target observable or add Pauli terms.
- Increase the required precision or confidence level.
- Change the shot budget, allocation strategy, or number of repeated batches.
- Target different hardware with another coupling graph or native gate set.
- Upgrade the quantum SDK or circuit-cutting utility and its decomposition or reconstruction API.
- Change compiler settings, optimization levels, measurement grouping, or qubit mapping.
- Move from an ideal simulator to a noisy simulator or real hardware.
A practical maintenance checklist is to regenerate the fragment circuits, verify the coefficient list, inspect compiled depth, rerun a small baseline, and compare uncertainty rather than central values alone. Keep the software versions and experiment configuration with the results so that a future update can distinguish a genuine hardware change from a changed decomposition.
For related decisions, pair this workflow with a comparison of quantum simulators, review quantum error-mitigation tradeoffs, and use the quantum circuit benchmarking checklist to define consistent baselines. If circuit cutting repeatedly produces an unacceptable sampling overhead, the result is useful: it may indicate that the circuit should be redesigned, the observable narrowed, or a simulator used instead of hardware for that experiment.
Start with one observable and one small partition. Measure the number of generated configurations, calculate the coefficient weight, run a pilot, and compare it with a full-circuit baseline. That repeatable process turns circuit cutting from a last-minute workaround into a measurable hardware-and-platform choice.