Quantum Circuit Transpiler: Gate Decomposition & Depth Optimization

Circuit

Playhead speed 1.0×

Zoom 1.0×

Highlight T / T† gates (T-count cost)

Live Stats

Gate count

Circuit depth

T-count (fault-tolerant cost)

T†

CNOT / CZ target

CNOT / CZ control

Toffoli (CCX) / SWAP

How it works

A quantum transpiler rewrites a circuit written with convenient high-level gates into the small "native" gate set a real device actually implements — here, {H, T, T†, CNOT}, which is universal for quantum computation.

Toffoli (CCX) → 15 native gates:
H(c) CNOT(b,c) T†(c) CNOT(a,c) T(c) CNOT(b,c)
T†(c) CNOT(a,c) T(b) T(c) CNOT(a,b) H(c)
T(a) T†(b) CNOT(a,b)

SWAP(a,b) → CNOT(a,b) CNOT(b,a) CNOT(a,b)
CZ(a,b)   → H(b) CNOT(a,b) H(b)

Decomposition alone can blow up gate count and depth. A real compiler follows it with an optimization pass that cancels adjacent gates which multiply to the identity on the exact same qubits with nothing scheduled between them:

H·H = I    X·X = I    CNOT·CNOT = I
T·T† = I   (T and T† are inverse phase gates)

The optimizer here re-scans the sequence to a fixed point, so a cancellation can expose a new adjacency and trigger another cancellation, exactly like a real peephole pass.

Depth is computed by ASAP (as-soon-as-possible) scheduling: each gate is placed in the earliest layer after every gate that already touched one of its qubits — the same greedy layering real schedulers use to estimate circuit latency. The histogram below the circuit shows how many gates land in each layer.

T-count matters because in fault-tolerant quantum computing, Clifford gates (H, CNOT) are cheap but T gates require expensive magic-state distillation — minimizing T-count is a real, active compiler-optimization target. The exact 15-gate Toffoli decomposition above was verified numerically against the true Toffoli unitary (matches up to global phase).

drag to pan · scroll to zoom