Phase Gadget Synthesis for Shallow Circuits

by   Alexander Cowtan, et al.

We give an overview of the circuit optimisation methods used by tket, a compiler system for quantum software developed by Cambridge Quantum Computing Ltd. We focus on a novel technique based around phase gadgets, a family of multi-qubit quantum operations which occur naturally in a wide range of quantum circuits of practical interest. The phase gadgets have a simple presentation in the ZX-calculus, which makes it easy to reason about them. Taking advantage of this, we present an efficient method to translate the phase gadgets back to CNOT gates and single qubit operations suitable for execution on a quantum computer with significant reductions in gate count and circuit depth. We demonstrate the effectiveness of these methods on a quantum chemistry benchmarking set based on variational circuits for ground state estimation of small molecules.



There are no comments yet.


page 1

page 2

page 3

page 4


Quantum Circuit Transformations with a Multi-Level Intermediate Representation Compiler

Quantum computing promises remarkable approaches for processing informat...

Quanto: Optimizing Quantum Circuits with Automatic Generation of Circuit Identities

Existing quantum compilers focus on mapping a logical quantum circuit to...

Deterministic Algorithms for Compiling Quantum Circuits with Recurrent Patterns

Current quantum processors are noisy, have limited coherence and imperfe...

Reducing the Depth of Quantum FLT-Based Inversion Circuit

Works on quantum computing and cryptanalysis has increased significantly...

On the qubit routing problem

We introduce a new architecture-agnostic methodology for mapping abstrac...

Optimisation-free Classification and Density Estimation with Quantum Circuits

We demonstrate the implementation of a novel machine learning framework ...

Relaxed Peephole Optimization: A Novel Compiler Optimization for Quantum Circuits

In this paper, we propose a novel quantum compiler optimization, named r...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Until fully fault-tolerant quantum computers are available, we must live with the so-called Noisy Intermediate-Scale Quantum (NISQ) devices and the severe restrictions which they impose on the circuits that can be run. Few qubits are available, but limited coherence time and gate fidelity also limit the depth of circuits which can complete before being overwhelmed by errors. Automated circuit optimisation techniques are therefore essential to extract the maximum value from these devices, and such optimisation routines are becoming a standard part of compilation frameworks for quantum software [28].

In this paper we give an overview of some circuit optimisation methods used in the retargetable compiler platform 111 can be installed as a python module via PyPI: can generate circuits which are executable on different quantum devices, solving the architectural constraints [17], and translating to the required gate set, whilst minimising the gate count and circuit depth. It is compatible with many common quantum software stacks, with current support for the Qiskit [22], Cirq [32], and PyQuil [30] frameworks.

Much work on circuit optimisation focuses on reducing -count [3, 9, 21, 25], a metric of some importance when considering fault-tolerant quantum computation. However, since we consider raw physical circuits, the metrics of interest for us are the total circuit depth and the number of two-qubit gates, since minimising these parameters serves as a good proxy for minimising total error rate in the circuit. The novel contribution is a new technique for circuit optimisation by exploiting symmetric structures for exponentials of Pauli strings, called Pauli gadgets, derived using phase gadget structures in the zx

-calculus. Pauli gadgets occur naturally in quantum simulations where a Hamiltonian is decomposed into a sum of Pauli tensors and Trotterised

[27]. Hence these techniques are specifically useful to optimise quantum circuits for quantum chemistry simulations [13].

Notation:  In the following, we will mix freely the usual quantum circuit notation and the scalar-free zx-calculus [14]. For both forms of diagram, we will follow a left-to-right convention. We will also adopt the same convention for composition of circuits in equations, i.e. means we apply first, followed by . A translation of common gates between the two formalisms is given in Figure 1. A brief introduction to the zx-calculus is found in [20]; for a complete treatment see [15]. For reasons of space we omit the zx-calculus inference rules, however we use the complete set of Vilmart [34].

Figure 1: Common circuit gates and their representations in the scalar-free zx-calculus

Remark:  Late during the preparation of this paper, it came to our attention that Litinski [26] has defined a notation for Pauli product operators essentially equivalent to the Pauli gadgets of Section 4. Since that work concerns computing under a surface code, this suggests applications of our approach beyond the near term quantum devices we focus on here. The use of zx-calculus for lattice surgery by de Beaudrap and Horsman [8] offers an obvious route.

2 Circuit Optimisations

Circuit optimisation is typically carried out by pattern replacement: recognising a subcircuit of specific form and replacing it with an equivalent. This is sometimes called peephole optimisation in analogy to local optimisation techniques in classical compilers; however in the case of quantum circuits any connected subcircuit can be replaced, including the entire circuit. Usually the replacement is cheaper with respect to some cost metric, but in a multi-pass optimiser like , the replacement may enable a more powerful later optimisation pass, rather than improving the circuit itself, or map the circuit onto a particular gate set supported by the target device.

In , circuits are represented internally as non-planar maps, a generalisation of directed graphs wherein the incident edges at each vertex are ordered, to admit non-commutative operations like the gate. Unlike operation lists or discrete time frames, this representation preserves only the connectivity of the operations, abstracting away qubit permutations and timing information. The optimiser consists of multiple rewriting strategies called passes which may be combined to achieve the desired circuit transformation222 We regret that at the time of writing this feature is not in the publicly available pytket release; it is planned for a future release. . The primitive rewriting steps are computed by the double pushout method [19], although the matching is usually achieved by a custom search algorithm for efficiency reasons.

Simple examples include merging adjacent rotation gates acting on the same basis, cancelling operation-inverse pairs, and applying commutation rules. Any sequence of single-qubit operations may be fused into a single unitary, for which an Euler decomposition can be computed. has the possibility to choose which basis of rotations to use for the Euler form – for example or – depending on local context, which can permit more commutations, or easy translation to a native gate set (for example, triples are useful to match the U3 gate supported in the Qiskit framework [22]).

If the circuit contains a long sequence of gates acting on the same two qubits, the (Cartan) decomposition [10, 33] may be applied. This gives a canonical form requiring at most three gates. Even when arbitrary rotations are permitted, realistic circuits include significant Clifford subcircuits. In particular, takes rules from [20] to reduce any pair of gates that are separated only by single-qubit Clifford gates. However there is a very wide literature on Clifford circuits which could be applied here [2, 18, 31]. In the following sections we describe a novel technique for optimising a new class of multi-qubit subcircuits, called phase gadgets and Pauli gadgets.

3 Phase Gadgets

In principle, local rewriting of gate sequences is sufficient for any circuit optimisation333This is a consequence of the completeness of the zx-calculus [34].. However, in practice, good results often require manipulation of large-scale structures in the quantum circuit. Phase gadgets are one such macroscopic structure that is easy to identify within circuits, easy to synthesise back into a circuit, and have a useful algebra of interactions with one another.

Definition 3.1.

The -phase gadgets are a family of unitary maps we define recursively as :

Remark 3.2.

We could equally define the -phase gadget as the colour dual of the -phase gadget, and the -phase gadget by conjugating the -phase gadget with rotations. Since we won’t needs these in this paper, we’ll refer to the -phase gadget simply as a phase gadget.

Lemma 3.3.

In zx-calculus notation we have:

Corollary 3.4.

We have the following laws for decomposition, commutation, and fusion of phase gadgets.

PhaseGadgetCNOT-lhs PhaseGadgetCNOT-lhs

The decomposition law gives the canonical way to synthesise a quantum circuit corresponding to a given phase gadget. However, from the zx-calculus form, it’s immediate that phase gadgets are invariant under permutation of their qubits, giving the compiler a lot of freedom to synthesise circuits which are amenable to optimisation. As a simple example, the naive ladder approach, shown in Figure 2, requires a -depth of to synthesise an -qubit phase gadget; replacing this with a balanced tree yields a depth of . Note that the quantity of gates used is still (and always will be) , but we can still obtain benefits with respect to depth.

Figure 2: Comparing the worst-case and best-case patterns for constructing phase gadgets with respect to depth. The left shows a ladder as produced within the Unitary Coupled Cluster generator in IBM Qiskit Aqua, and the right is the optimal balanced-tree form used by .

Further, in the balanced tree form more of the gates are “exposed” to the rest of the circuit, and could potentially be eliminated by a later optimisation pass. Note that this form is not unique, allowing synthesis informed by the circuit context in which the phase gadget occurs. For example, aligns the s between consecutive phase gadgets whenever possible.

Trotterised evolution operators, as commonly found in quantum chemistry simulations, have the general form of a sequence of phase gadgets, separated by a layer of single-qubit Clifford rotations. For each consecutive pair of gadgets, if the outermost s align then they can both be eliminated, or if there are some intervening Clifford gates then we can use Clifford optimisation techniques to remove at least one of the s.

4 Pauli Gadgets

In the language of matrix exponentials, the phase gadget corresponds to the operator . A consequence of Corollary 3.4 is that any circuit consisting entirely of -phase gadgets can be represented succinctly in the form:


for some Boolean linear functions . For comparison, phase-polynomial circuits (the class of circuits that can be built from [4]) can be represented as:


for Boolean linear functions and a linear reversible function . There is already a wide literature covering phase-polynomials and optimisations with them [3, 5, 28].

The correspondence between phase gadgets and matrix exponentials generalises to exponentials of any Pauli tensor , by conjugating the phase gadget with approriate Clifford operators as shown in Figure 3.

Definition 4.1.

Let be a word over the alphabet ; then the Pauli gadget is defined as where the unitary is defined by recursion over :

Do we need a base case for the empty string here?

Definition 4.1 can be easily extended to aribitrary strings over the Paulis (i.e. including the identity) by adding wires which the phase gadget does not act on. This is illustrated in Figure 3. Taking advantage of this we’ll generally assume that the Pauli gadget is the full width of the circuit, although it may not act on every qubit.

Figure 3: An example of the correspondence between Pauli evolution operators and phase gadgets. We introduce this notation on the right for a more succinct graphical representation. The green, red, and mixed-colour boxes respectively represent the Pauli gadget acting on a qubit in the , , and bases. These are formed by a phase gadget on the qubits (generating all interactions), then optionally conjugating the qubits with Hadamard gates for , or gates for . We omit trivial qubits () from the diagrammatic representation.

In general, Pauli gadgets present difficulties for phase-polynomial-based circuit optimisation methods, as not all pairs of Pauli evolution operators will commute (for the simplest example, consider for any non-degenerate choices of angles). We now generalise the results of the preceding section to consider interactions between Pauli gadgets. The following is easy to demonstrate using matrix exponentials.

Proposition 4.2.

Let and be Pauli tensors, then either (i) for all and ; or (ii) for all there exist such that


Note that the and are computed as the Euler-angle decompositions of a combined rotation. Taking and , Equation (4) is axiom (EU) of the ZX-calculus [34]444We note that this extremely powerful axiom was first proposed as rule (P) by Coecke and Wang [16].. We will give a zx-calculus proof of this theorem for Pauli gadgets, with an intermediate state giving a very compact circuit representation for any consecutive pair of Pauli gadgets.

The following lemmas have elementary proofs.

Lemma 4.3.

The commutation rules for Pauli gadgets and single-qubit Clifford gates, shown in Figure 4 are derivable in the zx-calculus.

Proof in appendix

Figure 4: Rules for passing Clifford gates through Pauli gadgets.
Lemma 4.4.

The commutation rules for Pauli gadgets and gates, shown in Figure 5 are derivable in the zx-calculus.

Proof in appendix

Figure 5: Rules for passing gates through Pauli gadgets.

Note that Figures 4 and 5 are not exhaustive, but they suffice for present purposes.

It will be useful to define some notation for working with strings of Paulis. For strings and we write their concatenation as ; denotes the th symbol of ; and denotes the length of . A string consisting entirely of is called trivial. We say that is a substring of when, for all , implies ; if in addition and is non-trivial then is proper substring. We write for the pointwise multiplication of Pauli strings (up to global phase); in particular if is a substring of then iff and is otherwise. The intersection of strings and is the set of indices satisfying and .

Lemma 4.5.

Let be a Pauli string; then for all there exists a Clifford unitary acting on qubits such that

Further, can be constructed in a canonical form which depends only on the string . It is still dependent on one symbol of - if the chosen qubit of is , then the ladder will commute through and eliminate


For simplicity of exposition we assume for all and . We construct in two layers. The first layer of gates corresponds to from Definition 4.1. By 4.3, these gates can pass through and cancel with their inverses from to give . Similarly, a gate on the first two qubits can pass through to give by Lemma 4.4. The second layer of is a chain of gates that repeats this to convert to . The final in this chain acts has its target on the th qubit, corresponding to . If , then the will commute through without extending it, so additional single qubit gates may be required around the to map to and back. Composing these layers gives a that can pass through and cancel with to leave . ∎

Remark 4.6.

As shown in 2, the part of may be more efficiently constructed as a balanced tree, or some other configuration which allows later gate cancellation.

Corollary 4.7.

Let be a proper substring of ; then there exists a unitary and a permutation such that

Corollary 4.8.

Let be a Pauli string; then for all and :

Lemma 4.9.

Let and be Pauli strings; then there exists a Clifford unitary such that

where and are Pauli strings with intersection at most 1.


Let denote the maximum common substring of and . Then by Corollary 4.7 we have


hence we will assume that and have no non-trivial common substring. Now suppose that and . Applying Lemma 4.3 we can replace with a node by conjugating with ; since rotations commute with nodes, this unitary can move outside the two gadgets.


The pairing of and can be treated the same way. Hence we can assume that the symbol does not occur in the intersection of and .

Now we proceed by induction on the size of the intersection. If the intersection is size 0 or 1 then we have the result. Otherwise consider two non-trivial qubits and in the intersection. Suppose and ; then by Lemma 4.4 we can reduce the size of the intersection by two as shown below:


The only other case to be considered is when and , in which case Lemma 4.3 gives the following reduction.


Hence the size of the intersection can be reduced to less than two. ∎

Theorem 4.10.

Let and be strings of Paulis. Either the corresponding gadgets commute:

or they satisfy the Euler equation:


By Lemma 4.9, we have , and such that

Where and have at most intersection 1. If their intersection is trivial, or if both gadgets act on their common qubit in the same basis (Corollary 4.8), then they commute, from which we have


Otherwise the gadgets need not commute, but the Euler equation holds. Without loss of generality assume that is all s and is all s. In the case where , we continue as follows:


This applies Lemma 4.4 to decompose Pauli gadgets and commute gates, followed by the (EU) rule and essentially reversing the procedure. This generalises to larger and by applying Lemma 4.5.


Synthesising a Pauli gadget in isolation requires gates, hence would usually require gates in total. Applying Equation 5 will reduce the total cost by for each qubit in the maximum common substring. Equation 7 uses two gates to reduce the gadgets by 1 qubit each, giving a net saving of gates per application. This reduces the total cost to gates where is the maximum common substring of and , and is the subset of the intersection of and that is not in . In the case where and act on the same set of qubits and , we can synthesise the pair using the same number of s as just . Performance with respect to depth is harder to assess analytically and will be left for future work.

5 Optimisation Example

The following example is a small region of a Unitary Coupled Cluster ansatz for analysing the ground state energy of . The parameters and are optimised by some variational method.


The ladders in this circuit correspond to phase gadgets, so we start by detecting these and resynthesising them optimally to reduce the depth and expose more of the s to the rest of the circuit.


Between the parametrised gates, there is a Clifford subcircuit, featuring some aligned pairs. The commutation and Clifford optimisation rules can further reduce the number of s here.


Between phase gadget resynthesis and Clifford optimisations, we have successfully reduced the two-qubit gate count of this circuit from 12 to 10, and the depth with respect to two-qubit gates from 12 to 7. However, we could have noted that the original circuit corresponds to the operation . These Pauli gadgets commute according to Theorem 4.10. Following the proof, we can reduce the Pauli gadgets by stripping away the common qubits (where they both act on the -basis) as in Equation 5, and then reducing the remaining pair to simple rotations on different qubits using Equation 7. This yields an equivalent circuit using 6 two-qubit gates which can be arranged into only 4 layers.


6 Results

Here we present some empirical results on the performance of these optimisation techniques on realistic quantum circuits. We compared the effectiveness of a few optimising compilers at reducing the number of two-qubit interactions ( or equivalent) in a circuit. For , we identified Pauli gadgets within the circuit and applied the aforementioned method for efficient pairwise synthesis, followed by Clifford subcircuit optimisation.

The test set used here consists of a small selection of circuits for Quantum Computational Chemistry. They correspond to variational circuits for estimating the ground state of small molecules (, LiH, , or ) by the Unitary Coupled Cluster approach [6, 7] using some choice of qubit mapping (Jordan-Wigner [23], Parity mapping [11], or Bravyi-Kitaev[12]) and chemical basis function (sto-3g, 6-31g, cc-pvDZ, or cc-pvTZ). The bulk of each circuit is generated by Trotterising some exponentiated operator, meaning many phase/Pauli gadgets will naturally occur. These circuits were all generated using the Qiskit Chemistry package [22] and the QASM files can be found online 555QASM files and the generating python script are available at:

Qiskit 0.10.1 PyZX
[ respect underscore, late after line=
, late after last line=, ]ChemBenchResults-full.csv 1=, 2=, 3=, 4=, 5=, 6=, 7=, 8=, 9=, 10=, 11=
Table 1: Comparison of two-qubit gate count and depth for Quantum Computational Chemistry circuits achieved by quantum compilers. Each circuit was generated using a Unitary Coupled Cluster ansatz for ground state estimation of small molecules. The names of circuits indicate the molecule (, LiH, , or ), the qubit mapping (Jordan-Wigner, Parity mapping, or Bravyi-Kitaev), and chemical basis function (sto-3g, 6-31g, cc-pvDZ, or cc-pvTZ). / denotes the two-qubit gate count/depth for the original circuits, and / are the corresponding quantities for the optimised circuits from each compiler. Values correspond to the Pauli gadget optimisation pass in , PyZX’s full_reduce procedure, and compilation with optimisation level 1 on Qiskit (at the time of writing, higher levels were found to not preserve the semantics of the circuit). Systems were allowed up to 10 hours of compute time for each circuit with timeouts indicated by blank cells.

All of the implementations suffered from runtime scaling issues, meaning results for some of the larger circuits were reasonably unobtainable. Overall, gained an average reduction of in count of the circuits, outperforming the from Qiskit and from PyZX. We find similar savings with respect to two-qubit gate depth, where has an average reduction of ( for Qiskit, for PyZX). This percentage is likely to improve as we start to look at even larger examples as the phase gadget structures are reduced from linearly-scaling ladders to the logarithmically-scaling balanced trees. We anticipate that incorporating the reduced form for adjacent Pauli gadgets will further cut down the count, especially given that rotations in the Unitary Coupled Cluster ansatz come from annihilation and creation operators, each generating a pair of rotations with very similar Pauli strings.

These empirical results were to compare pure circuit optimisation only, so no architectural constraints were imposed. It is left for future work to analyse how these techniques affect the ease of routing the circuit to conform to a given qubit connectivity map. This is non-trivial for the more macroscopic changes such as identifying and resynthesising phase gadgets which can change the interaction graph from a simple line to a tree. Recent work using Steiner trees [24, 29] could be useful for synthesising individual phase gadgets in an architecturally-aware manner.

As the quality of physical devices continues to improve, we can look forward to a future of fault-tolerant quantum computing. There has already been work making use of the structures discussed here in the domain of Clifford + T circuits. Notably, phase gadgets have found use recently for reducing the T-count of circuits [25]. Another recent paper [26] presents ways to usefully synthesise Clifford + T circuits in the realm of lattice surgery which use representations of rotations that are equivalent Pauli gadgets.


Appendix A Proof for Lemma 4.3


A number of the rules follow from the ability to commute green vertices through components of Pauli gadgets and red vertices through components using the spider fusion rule (S) and the colour-change rule (H) of the zx-calculus.


For the remaining -phase properties, we will also need to use the -copy/elimination rule (K1) and the phase-inversion rule (K2).


The rest of the rules for passing single qubit Clifford gates through Pauli gadgets can be obtained straighforwardly using these, as in the following example.


Appendix B Proof for Lemma 4.4


The control of a can commute through a component of a Pauli gadget using just the spider fusion rule (S) of the zx-calculus.


To prove the extension of Pauli gadget from a component, we remove Hadamard gates from the path with the colour-change rule (H) and introduce a pair of s using the identity (I) and Hopf (Hopf) rules. The rest follows from the bialgebra rule (B) and tidying up.


For the equivelent rule for , we spawn additional green phase vertices to allow us to introduce Hadamard gates via the Hadamard decomposition rule (HD), and reduce it to the case.


The remaining rules follow similarly. ∎