Circuit Optimization and the Quantum Transpilation Problem

Quantum transpilation is the step that turns the neat quantum circuit you write into one a real machine can actually run. Your circuit assumes any qubit can talk to any other and uses whatever gates you like, but a physical processor supports only a fixed set of native gates and a limited pattern of connections. Transpilation rewrites the circuit to respect those limits while trying to keep it as short and accurate as possible.

On today’s noisy hardware this step is not a formality, it often decides whether a result is usable or buried in error. This guide walks through what quantum transpilation does stage by stage, why inserting a single SWAP costs you three two-qubit gates, how the Qiskit optimization levels behave, and where the popular tools stand in 2026.

What transpilation actually is

Quantum transpilation is the process of rewriting a hardware-agnostic circuit into a logically equivalent one that a specific processor can execute. It has to honour three real constraints, the machine’s native gate set, its map of which qubits are physically connected, and its timing, while cutting the number of costly gates as far as it can. The output computes the same thing as the input, but it can look completely different.

The word compile is a good analogy, since transpilation is to a quantum circuit roughly what a compiler is to source code. The crucial point is that it preserves the result, up to a harmless global phase and a possible relabelling of qubits, and not the exact gates you wrote. Expecting your original gate sequence to survive untouched is the first misconception to drop.

Why transpilation decides if your result is usable

On the noisy processors available today, every gate carries a chance of error, and two-qubit gates are the worst offenders, typically failing somewhere between one in a thousand and one in a hundred times on production superconducting chips. Errors accumulate roughly with the number of two-qubit gates, so a circuit that runs a few hundred of them can decay into noise before it finishes.

This is why quantum transpilation matters so much. A clumsy compilation can double or triple the two-qubit gate count through unnecessary routing, while a good one keeps the circuit short enough to give a meaningful answer. On current hardware the quality of the transpile can be the difference between a usable result and a random-looking one, which is also why quantum error correction and careful compilation go hand in hand.

The stages a transpiler runs

A transpiler works in a sequence of stages, each solving one piece of the problem. First it translates the circuit into the hardware’s native gates, then it chooses a layout that maps the logical qubits onto physical ones, ideally so that qubits which interact start out close together. Next comes routing, where it inserts SWAP operations so that qubits needing a two-qubit gate become neighbours.

After routing, optimization passes clean up the circuit by cancelling gates that undo each other, fusing sequences of single-qubit gates, and simplifying two-qubit blocks. A final scheduling stage assigns timing and can add error-fighting tricks. The stages interact, since a smarter layout means less routing, which is why modern compilers try several layouts before committing.

Native gate sets and why your circuit gets rewritten

Every processor speaks only a small vocabulary of native gates, and any gate you write has to be rebuilt from that vocabulary. Superconducting machines usually offer a handful of single-qubit rotations plus one native two-qubit gate, which might be a controlled-NOT, an echoed cross-resonance gate, or on newer tunable-coupler devices a controlled-Z. Trapped-ion machines instead use a Molmer-Sorensen interaction as their native two-qubit gate.

One quiet detail matters a lot for cost. On superconducting hardware, one family of single-qubit rotations is applied virtually as a change of reference frame, so it is essentially free and error-less, while two-qubit gates are expensive. A good transpiler leans on the cheap operations and spends the expensive ones sparingly, which is a large part of what separates a fast circuit from a slow one.

Connectivity and the real cost of a SWAP

The most expensive part of quantum transpilation is usually routing, and the reason is physical. On a superconducting chip a qubit is only wired to a few neighbours, so if your circuit wants a gate between two qubits that are not connected, the compiler has to physically move one qubit’s state next to the other using SWAP operations. Each SWAP is built from three two-qubit gates, so every one you add pours more error into the circuit.

Finding the fewest SWAPs is an NP-hard problem, which means there is no known efficient way to guarantee the best answer. In practice compilers use clever heuristics, the best known being SABRE, which search for good routing without promising the optimal one. Because these searches involve randomness, the same circuit transpiled twice can differ, so fixing the random seed is how you get reproducible results.

Optimization levels and what they change

Most people meet quantum transpilation through Qiskit, where a single setting called the optimization level controls how hard the compiler tries. There are four levels, numbered 0 to 3. Level 0 does the bare minimum needed to run, while level 3 applies the most aggressive simplification, resynthesising two-qubit blocks and hunting for a better layout.

The default became level 2 in Qiskit 1.3, a sensible balance of speed and quality, and the 2.0 release in March 2025 moved much of the heavy lifting into a fast compiled core. A common trap is to assume level 3 is always best. Because the routing search is partly random, level 3 is slower and can occasionally produce a worse circuit than level 2, so the practical advice is to try a few random seeds and keep the best result.

The tools that do the work

Qiskit is the most widely used framework, and its modern approach builds a staged pass manager that runs layout, routing, translation, optimization and scheduling in order. A vendor-neutral alternative is tket, from Quantinuum, which is known for strong optimization and architecture-aware routing across different hardware. Both are mature and actively developed.

A newer development is machine-learning-assisted compilation. IBM offers an AI-powered transpiler service that uses reinforcement learning for layout, routing and synthesis, and the company reports an average reduction of around 42 percent in two-qubit gates on suitable circuits, a figure worth treating as a vendor benchmark rather than a universal guarantee. The broader point is that quantum transpilation is now an active research area in its own right, not a solved back-end detail. You can experiment with all of this on the machines listed in our quantum cloud providers guide.

Superconducting versus trapped ion

How much transpilation costs depends heavily on the hardware. Superconducting processors, the kind offered by IBM and Google, run gates very fast but wire each qubit to only a few neighbours, so they pay a heavy routing tax and a lot of the compiler’s effort goes into minimising SWAPs. You can compare the leading machines in our roundup of superconducting quantum computing companies.

Trapped-ion processors make the opposite trade. Within a register every ion can interact with every other, so connectivity is effectively all to all and routing almost vanishes, at the cost of slower gates. This is why the same circuit can transpile very differently on the two platforms, and it is a real consideration when choosing between trapped-ion machines and superconducting ones. For the wider context, see our guide to quantum computing, and the official Qiskit guide to quantum transpilation for hands-on detail.

Frequently asked questions