⚡️ tzap

Installation · Using tzap  |  Qiskit integration · PennyLane integration

A super fast, Rust-based optimizer for large Clifford+T/Rz circuits, with optional conversion to optimized Pauli-based computation (PBC) circuits.

• tzap is state-of-the-art in speed, scalability, and gate-count reduction.
• tzap minimizes T-count with a new linear-time phase folding algorithm, based on this paper.
• tzap implements a new and fast superoptimization pass, based on this paper.
• A formally verified Lean port of tzap is available in lean.

tzap is multiple orders of magnitude faster than other optimizers—and linearly scales to millions of gates! Here's a runtime comparison to two powerful optimizers on increasingly larger circuits.

Installation

You can use tzap as a command-line utility or a library.

Install the binary

These options install the standalone native tzap executable.

Homebrew (macOS/Linux):

brew install qqq-wisc/tap/tzap

Prebuilt release binary (macOS/Linux):

curl -LsSf https://github.com/qqq-wisc/tzap/releases/latest/download/tzap-opt-installer.sh | sh

You can also build and install tzap from crates.io (cargo install tzap-opt) or build from source (cargo install --path .). You can also use tzap through the Rust API; see the Rust API documentation.

Integrations with Qiskit and PennyLane

You can also use tzap as a Python library and apply it as a Qiskit optimization pass or PennyLane transform. See the Qiskit API guide or PennyLane API guide for framework-specific setup.

Running tzap

The standard command-line workflow is described below.

Optimize a circuit

tzap input.qasm -o output.qasm

For example, using a benchmark in this repo:

$ tzap benchmarks/feynman/hwb12.qasm -o optimized.qasm
⚡️ tzap v0.7.0
  Parsed benchmarks/feynman/hwb12.qasm (5.5 MB) in 0.079s
	├─ 20 qubits · 514,412 gates
	└─ Circuit gates: {h, x, t, tdg, cx}
  Optimizing input circuit
  Loaded MURM in 0.039s
	└─ Synthesis basis: {h, x, z, s, sdg, t, tdg, cx}

  Converged after 6 rounds

  ┌─ Final result · 44.6% fewer gates · 1.379s ────────────────┐
  │ Gates    ━━━━━━━━━╸──────────── ↓44.6% · 514,412 → 284,848 │
  │ 2q gates ━━━━╸───────────────── ↓22.1% · 191,803 → 149,500 │
  │ T/Tdg    ━━━━━━━━━━╸─────────── ↓49.9% · 171,465 →  85,889 │
  │ Depth    ━━━━━━╸─────────────── ↓28.4% · 274,781 → 196,865 │
  └────────────────────────────────────────────────────────────┘
  wrote optimized.qasm

Optimization levels

tzap benchmarks/feynman/hwb12.qasm -O1 -o optimized.qasm

PhaseFoldPauli folds native P/RX/RY/RZ rotations across commuting operations. It retains exact pi fractions and declines numeric sums that add rounding.

Optional decomposition

CCX, CCZ, CZ, phase gates, and ordinary/controlled rotations stay native by default. To decompose them, use:

• --decompose-ccx to decompose CCX and CCZ
• --decompose-cz to decompose CZ into CX+H
• --decompose-rotations to decompose P, Rz/Rx/Ry, CP, and CRz/CRx/CRy via gridsynth (--decompose-rz remains a compatibility alias)

PBC circuits

Use --to-pbc to convert a circuit to PBC and optimize its Pauli rotations:

tzap input.qasm --to-pbc -o output.pbc

Use --decompose-rotations for phase gates and rotations before PBC conversion. Native Y/SX/SWAP/CY/CH/CSWAP and resets are unsupported by PBC. See the PBC guide for the format, options, and examples.

Circuit support

tzap supports a subset of OpenQASM 2.0:

• Gates: h, x, z, s, sdg, t, tdg, p (u1), y, sx, rx, ry, rz, swap, cx, cy, ch, cp (cu1), crx, cry, crz, cswap, ccx, ccz, cz, measure, reset
• Declarations: qreg, creg
• Not supported: classical conditionals (if), custom gate definitions (gate), barriers, include files (besides qelib1.inc, which is ignored)
• Unrecognized lines produce an error

Correctness

1. Fuzzing and equivalence verification on small random circuits and benchmark circuits.
2. Lean port: the core optimizer is implemented and proven sound in Lean 4 — see lean/.

The new native gate families and generalized rotation synthesis are currently implemented in Rust and Python; the Lean gate model has not been extended.

Citation

If you use tzap in your research, please cite the following papers:

@misc{albarghouthi2026tzap,
      title={Linear-Time T-Gate Optimization via Random Abstraction}, 
      author={Aws Albarghouthi},
      year={2026},
      eprint={2605.13929},
      archivePrefix={arXiv},
      primaryClass={cs.PL},
      url={https://arxiv.org/abs/2605.13929}, 
}

@misc{cryptoeprint:2026/2115,
      author = {Aws Albarghouthi},
      title = {Fast Quantum-Circuit Superoptimization},
      howpublished = {Cryptology {ePrint} Archive, Paper 2026/2115},
      year = {2026},
      url = {https://eprint.iacr.org/2026/2115}
}