Further Reading: Circuit Optimization

Tagged Tier 1 (confident it exists and recommended) and Tier 2 (real and worth seeking, but verify the current version or URL).

The tool you are actually using

• Qiskit's transpiler documentation, especially the pages on the preset pass managers and on writing your own. The single highest-value item here, because §28.5's finding — that CommutativeCancellation alone did the whole job — is only actionable if you know what is in the box. Tier 1.
• The qiskit.transpiler.passes API listing. Read it once end to end. Most of the passes will never matter to you and knowing which three do is most of the skill. Tier 1.
• generate_preset_pass_manager and the PassManager composition API. How to build a custom pipeline, and how to inspect a preset one — which is how §28.4's pass lists were obtained. Tier 1.
• The approximation_degree documentation and the UnitarySynthesis pass. Read them before touching the parameter, and read §28.7's measured table alongside. Tier 1.

On the algorithms behind the passes

• Any treatment of KAK / Cartan decomposition of two-qubit unitaries. Every two-qubit block can be written with at most 3 CNOTs, and the exact/approximate versions of this are what TwoQubitPeepholeOptimization and approximation_degree are doing. The mathematical reason the approximation dial exists at all. Tier 1.
• Literature on template matching and peephole optimization for quantum circuits. The general form of CommutativeCancellation and InverseCancellation. Tier 2.
• ZX-calculus and PyZX (Kissinger and van de Wetering). A genuinely different approach: rewrite the circuit in a graphical calculus, simplify there, extract a circuit back out. Frequently beats peephole optimizers, especially on $T$ count, and it is the most interesting thing in this field. Tier 1.
• Nam, Ross, Su, Childs, and Maslov, "Automated optimization of large quantum circuits with continuous parameters" (2018), npj Quantum Information. A strong, well-benchmarked optimizer with published numbers on real algorithm circuits. Read it for how a serious optimization benchmark is reported — which is §28.3's complaint about how most are. Tier 1.

On T-count optimization

The metric the transpiler does not target, and the one that matters after Chapter 25.

• Amy, Maslov, and Mosca on $T$-count optimization, and the related work on $T$-par and matroid partitioning. The starting point for §28.8's last paragraph. Tier 1.
• Kissinger and van de Wetering on $T$-count reduction with ZX-calculus. Among the strongest results available, and a good demonstration that a different representation can beat a better search in the same representation. Tier 1.
• Chapter 15's resource estimator, re-run before and after a $T$-count optimization. The most direct way to see why this metric is the one that matters for fault tolerance. Tier 1.
• Chapter 22's rotationCount and rotationDepth, which are the estimator's interface to exactly this question.

On benchmarking optimizers honestly

This is §28.3's real subject, and the reading is mostly not quantum.

• Any treatment of statistical significance for A/B comparisons. §28.3's $+0.0028 \pm 0.0065$ is a standard two-sample comparison, and the discipline of reporting the interval rather than the sign of the mean is the whole lesson. Chapter 27's further reading covers the same ground. Tier 1.
• Literature on quantum circuit benchmark suites — QASMBench, MQT Bench, and similar. Standard circuit families to optimize against, which is better than inventing your own and accidentally choosing the ones that cannot distinguish your configurations (§28.4's correction). Tier 2.
• Anything on the pitfalls of proxy metrics in performance engineering. The classical literature on optimizing for benchmark scores rather than user-visible latency is directly transferable, and older. Tier 1.

Backward references

• Chapter 10 — what transpilation is, and the stages this chapter's optimization stage sits inside.
• Chapter 12 — the measured gate errors that make two-qubit count matter, and the 288× spread.
• Chapter 25 — the id noise slot barriers cannot save, and the threshold that limits what optimization can buy.
• Chapter 26 — Operator.from_circuit, and the $2^{127}$ wall this chapter runs into twice.

Forward references

• Chapter 29 — writing circuits that need less optimization, which beats optimizing them afterwards.
• Chapter 30 — measuring the device rather than the circuit, and where the error rates this chapter assumes come from.

Where to go next. If one thing: PyZX and the ZX-calculus literature. It is the only approach in this list that is doing something structurally different from the transpiler, it wins on the metric that will matter (§28.8's $T$ count), and it is unusually well explained by its authors.

If two: add Nam et al. (2018) — not primarily for the optimizer but for the benchmark methodology. It reports what its optimizations do to real algorithm circuits, with the baselines stated, which is the standard §28.3 argues most optimization reports fail to meet.

Then Chapter 29, where the cheapest optimization turns out to be not needing one.