betaFeedback

WorksComputer Science

Reducing 2-QuBit Gate Count for ZX-Calculus based Quantum Circuit Optimization

Abstract

In the near term, programming quantum computers will remain severely limited by low quantum volumes. Therefore, it is desirable to implement quantum circuits with the fewest resources possible. For the common Clifford+T circuits, most research is focused on reducing the number of T gates, since they are an order of magnitude more expensive than Clifford gates in quantum error corrected encoding schemes. However, this optimization sometimes leads to more 2-qubit gates, which, even though they are less expensive in terms of fault-tolerance, contribute significantly to the overall circuit cost. Approaches based on the ZX-calculus have recently gained some popularity in the field, but reduction of 2-qubit gates is not their focus. In this work, we present an alternative for improving 2-qubit gate count of a quantum circuit with the ZX-calculus by using heuristics in ZX-diagram simplification. Our approach maintains the good reduction of the T gate count provided by other strategies based on ZX-calculus, thus serving as an extension for other optimization algorithms. Our results show that combining the available ZX-calculus-based optimizations with our algorithms can reduce the number of 2-qubit gates by as much as 40% compared to current approaches using ZX-calculus. Additionally, we improve the results of the best currently available optimization technique of Nam et. al for some circuits by up to 15%.

Introduction

Many famous quantum algorithms, like Shor [26], HHL [13] or Grover [12], base upon techniques like Quantum Fourier Transformation, Quantum Phase Estimation or Amplification, respectively. Although these algorithms provide significant (sometimes even exponential) speed-ups, current quantum chips can only execute toy problems, mostly due to the low gate fidelity. Even for problems that can be easily solved on a state-of-the-art desktop PC, those algorithms require tens of thousands of gates, and are therefore infeasible to run on near-term quantum devices. However, applications in quantum simulation are supposed to achieve significant improvements in quantum chemistry, material sciences, or high-energy physics on near-term devices. With variational algorithms (e.g., QAOA [10] or VQE [25]), real-world applications like optimization problems on real quantum chips may become feasible. While the associated speed-up is unknown for many use cases, they require only few qubits and quantum gates to achieve promising results. Quantum Machine Learning (QML) is such an example: Here, the combination of clever encoding strategies, variational algorithms, and classical pre- and post-processing achieves high accurate classification rates with fewer qubits compared to classical bits. Still, even algorithms with smaller circuits cannot be executed on current devices and gate optimization is a vibrant research topic. While global optimization of arbitrary quantum circuits is generally QMA-hard [16], different algorithms like quantum optimal control [18] have been proposed to reduce the size of a quantum circuit. In this context the so-called ZX-calculus [6] is considered a promising tool. It provides an abstract graphical language for describing quantum systems and can be seen as an alternative to the predominant description in the Hilbert space. We can transform any quantum circuit into a ZX-diagram equivalent, apply the rules of the ZX-calculus to simplify the diagram, and re-extract a quantum circuit from it.

Scope of this work

Our work is based on optimizing circuits with ZX-calculus, where several optimization strategies have been proposed recently [9, 20, 27]. Currently, these strategies yield very good results for pure Clifford circuits, as well as for T gate elimination in Clifford+T circuits, which is worthwhile for fault-tolerant quantum computers with error-corrected gates. For such devices, the cost of a T gate is sometimes estimated to be up to a hundred times higher than the cost of a CNOT gate [24] (even though recent studies suggest lower rates [21]).

However, reducing 2-qubit gates is generally of interest for quantum hardware that is not error corrected (e.g., NISQ devices) or in which quantum states do not tend to interact easily, e.g., in Photonic Quantum computing [3]. A major drawback of the current ZX-calculus based strategies is that these gates in particular are not optimized very well; in fact, for many large Clifford+T circuits, the 2-qubit gate count even increases when using algorithms like the one in [9].

We propose new optimization approaches especially for reducing 2-qubit gates. To do so, we use heuristics for estimating the 2-qubit gate count in ZX-diagrams as cost functions for classical search algorithms like I.) random selection and II.) greedy algorithm. By combining them with existing optimization approaches, we maintain the T gate count reduction rate and improve the total gate count and the 2-qubit gate count for most given circuits. We evaluate the performance on circuits from the Tpar benchmark [1]. We find that our optimizations can outperform existing ZX-based approaches and can additionally be used to further improve already optimized circuits.

Background

Throughout this paper, we use the notation from [23] for quantum gates; the most essential ones are detailed in Table 1 by name and matrix-, gate- and ZX-calculus-representation. Every unitary operation can be decomposed into a combination of CNOTs and single-qubit gates [23]. A well-studied example for a minimal gate set with which to approximate any unitary operation is the so-called Clifford+T set, i.e., the gate set generated by {H,T,CNOT}\{H,T,CNOT\}. That is why many optimization algorithms target circuits generated with the Clifford+T set. The Clifford set generated by {H,S,CNOT}\{H,S,CNOT\} is also well-known and useful for quantum circuit simulations on classical computers, but not every unitary operation can be represented with it. For convenience, we abbreviate some gates in the Clifford+T set, namely X, Y, Z, S, and CZ (instead of writing, for example, Z=T⋅T⋅T⋅TZ = T \cdot T \cdot T \cdot T).

NameIdentityZZ-PhaseTXX-PhaseHCNOT
Matrix(1001)\begin{pmatrix}1&0\\0&1\end{pmatrix}(100−1)\begin{pmatrix}1&0\\0&-1\end{pmatrix}(100eiα)\begin{pmatrix}1&0\\0&e^{i\alpha}\end{pmatrix}(100eiπ4)\begin{pmatrix}1&0\\0&e^{i\frac{\pi}{4}}\end{pmatrix}(0110)\begin{pmatrix}0&1\\1&0\end{pmatrix}12(1+eiα1−eiα1−eiα1+eiα)\frac{1}{2}\begin{pmatrix}1+e^{i\alpha}&1-e^{i\alpha}\\1-e^{i\alpha}&1+e^{i\alpha}\end{pmatrix}12(111−1)\frac{1}{\sqrt{2}}\begin{pmatrix}1&1\\1&-1\end{pmatrix}(1000010000010010)\begin{pmatrix}1&0&0&0\\0&1&0&0\\0&0&0&1\\0&0&1&0\end{pmatrix}
GateIIZZRz(α)R_z(\alpha)TTXXRx(α)R_x(\alpha)HH
Spider/Wireπ\piα\alphaπ4\frac{\pi}{4}π\piα\alpha

Table 1. Overview of important quantum gates and the respective ZX-Spiders.

ZX-Calculus

Since ZX-calculus and its optimization strategies rely on graph theory, we provide some background in Appendix B. The ZX-calculus [7, 8] is a graphical language for expressing linear maps on qubits as

ZX-diagrams. Relations in multi-qubit systems are often difficult to understand in Dirac notation, since the matrix size doubles with every qubit and the complex number space quickly becomes confusing.

ZX-calculus provides a way to represent quantum circuits as 2-dimensional diagrams where nodes (spiders) and edges (wires) form an undirected graph. In contrast to quantum circuits, the number of input- and output wires does not have to match, hence the resulting transformations are not necessarily unitary. However, many important concepts in quantum mechanics follow very intuitively from this representation and we will briefly introduce the main principles.

Figure 1. Z-Spider and X-Spider.

Representing Quantum Circuits

Any transformation on a single qubit can be described as a rotation around the X and Z axes. Further, we can represent any quantum gate as a combination of X- (red) and Z-spiders (green) in ZX-diagrams (c.f. Eq. 1), of which the most important are shown in Table 1. We call the wires on the left- and rightmost the input and output of the graph, respectively. The three generators of the universal Clifford+T set are constructed with the H-wire, the Z-spider with phase π/4\pi/4, and a combination of an empty X- and Z-spiders (phase α=0\alpha= 0) representing a CNOT. In general, we can read a ZX-diagram in any direction since only the connectivity of the spiders matters, but for comparison with common quantum circuits it is convenient to read ZX-diagrams horizontally as shown in Eq. 2.

Quantum circuit and equivalent ZX-diagram

Figure 2.

Basic Rules

We introduce the most important transformation rules in the ZX language that are useful for optimization [6] in Figure 1. All ZX-rules can be applied in both directions and also apply with inverted colors.

Any two Clifford diagrams (i.e., diagrams only containing spiders with a Clifford phase α=k⋅π2\alpha= k \cdot\frac{\pi}{2}; k∈Zk \in\mathbb{Z}) that represent the same linear map can be transformed into each other by some combination of those rules. Recent developments have introduced rule sets where this is also possible for Clifford+T diagrams and for all ZX-diagrams [17, 28].

Figure 1 (PDF p. 4). The important rules in ZX-Calculus that can be used for optimization are: Identity- (i1,i2), Fusion- (f), Hadamard- (h), Bialgebra- (b), Pi- (π\pi), Copy- (c) and Hadamard-Decomposition (hd) rule. Each holds for all α,β∈[0,2π]\alpha,\beta\in[0,2\pi]. Due to (h) and (i2), all rules hold with the colours interchanged.

Circuit optimization with ZX-calculus

With the rules of ZX-calculus, the optimization of quantum circuits becomes a simplification problem on the ZX-diagram. By simplification we mean reducing the total number of either spiders or wires in a diagram in order to obtain a smaller diagram. The general process is as follows:

  1. Transform the circuit to a ZX-diagram

  2. (optional:) transform to a graph-like diagram, i.e.:

    • All spiders are Z-spiders.

    • All connections are Hadamard wires.

    • There are no loops.

    • Inputs and outputs are the only non-Hadamard wires and are connected to at most one spider. Every spider has at most one input and one output.

  3. Simplify the diagram using ZX-rules.

  4. Extract a quantum circuit out of the ZX-diagram.

This allows powerful optimization of circuits, which are not obvious at a first glance (we provide an intuitive example in Appendix § 11).

Diagram simplification

The presented ZX-rules allow many degrees of freedom, hence, simplification is still a difficult problem. The term “simplification of diagrams” has to be taken with a grain of salt since decreasing the number of spiders in a diagram can also lead to more complex extracted circuits. Since rules can be applied in both directions it is important to find terminating algorithms for diagram simplification. A common approach has been to only use ZX-rules which decrease the total number of spiders in a diagram with every application, thus ensuring termination. We present some common approaches, many of which are implemented in the PyZX-library [19].

Clifford spider simplification

The core of most strategies are two rules from graph theory – namely local complementation and pivoting – which work on diagrams that are graph-like. Both rules allow the elimination of interior Clifford spiders (phase 0,π/2,π0,\pi/2,\pi, or −π/2-\pi/2; not connected to an input or output) from ZX-diagrams.

Local complementation (lclc). In ZX-calculus, local complementation from Section B.1 is applicable on graph-like diagrams. If the spider aa in G⋆aG \star a has a phase of ±π/2\pm\pi/2, the phase is subtracted from those of the neighboring spiders and the spider is eliminated for simplification of the diagram as shown in Eq. (1).

αi↦αi∓π2,i=1,2,3(1)\alpha_i \mapsto\alpha_i \mp\frac{\pi}{2}, \qquad i=1,2,3 \tag*{(1)}

Pivoting (pp). Similarly we can eliminate a pair of spiders uvuv with phase 00 or π\pi by applying a graph-theoretic pivot G∧uvG \wedge uv (c.f. Section B.2) on the diagram as in the following example (j,k∈Z)(j,k \in\mathbb{Z}):

αi′=αi+kπβi′=βi+(j+k+1)πγi′=γi+jπ(2)\begin{aligned} \alpha_i' &= \alpha_i + k\pi\\ \beta_i' &= \beta_i + (j+k+1)\pi\\ \gamma_i' &= \gamma_i + j\pi \tag*{(2)} \end{aligned}

Clifford simplification algorithm

These rules allow constructing an algorithm for graph-like diagrams which removes most interior Clifford spiders [9]. The procedure is as follows:

  1. Eliminate empty spiders with two wires using the identity rule and subsequently fuse the adjacent spiders in order to maintain a graph-like diagram.

  2. Apply local complementation on every spider of phase ±π/2\pm\pi/2 and pivoting on every pair of connected spiders of phase 00 or π\pi as often as possible.

  3. If step 2 modified the diagram, start again with step 1, else stop the iteration.

That allows us to remove every interior spider with phase ±π/2\pm\pi/2 and every pair of connected spiders with phase 00 or π\pi. However, after simplification some interior Clifford spiders with phase 00 or π\pi may remain.

Phase gadget simplification (p2)

We can use phase gadgets to apply pivoting on a pair of spiders where one spider has a non-Clifford phase (≠0,π/2,π,−π/2\ne0,\pi/2,\pi,-\pi/2). A phase gadget as defined in [20] is a parameterized spider with only one wire connected via Hadamard edge to a phaseless spider as in Eq. (3).

phase gadget

phase gadget(3)\text{phase gadget} \tag*{(3)}

We can modify pivoting (Eq. (2)) to exchange the spider with a non-Clifford phase to a phase gadget:

σ′=(−1)jσβi′=βi+(j+1)πγi′=γi+jπ(4)\begin{aligned} \sigma' &= (-1)^j\sigma\\ \beta_i' &= \beta_i + (j+1)\pi\\ \gamma_i' &= \gamma_i + j\pi \tag*{(4)} \end{aligned}

With the additional rules in Appendix § 9, we can eliminate every interior Clifford spider in a diagram [20].

Circuit extraction

Extracting a quantum circuit from a simplified diagram can be challenging, since spiders with an arbitrary number of wires have no direct gate representation [2]. The most general circuit extraction routine makes use of so called “flow properties” originating in measurement-based quantum computing (MBQC). Graph-like ZX-diagrams can be seen as an extension of MBQC graph states where the phases of spiders represent measurements in either the XY, XZ or YZ plane of the Bloch sphere:

meas. plane: XY XZ YZ; meas. effect: ZX-diagram(5)\text{meas. plane: XY \quad XZ \quad YZ; \qquad meas. effect: ZX-diagram} \tag*{(5)}

Diagrams simplified with the Clifford simplification algorithm from [9] only contain spiders in the XY measurement plane and preserve a flow property called focused generalized flow (gflow). Those diagrams can be extracted by converting every spider with phase α\alpha to an Rz(α)R_z(\alpha) gate and a Hadamard wire as either a HH or CZCZ gate or a combination of CNOTCNOT gates. As an example consider the diagrams from Eq. (2). Extracting the diagram on the left hand side yields the following circuit:

circuit diagram containing Rz(α1),Rz(α2),Rz(jπ),Rz(kπ),Rz(β1),Rz(γ1),Rz(γ2),H, and controlled gates(6)\text{circuit diagram containing }R_z(\alpha_1),R_z(\alpha_2),R_z(j\pi),R_z(k\pi),R_z(\beta_1),R_z(\gamma_1),R_z(\gamma_2),H,\text{ and controlled gates} \tag*{(6)}

whereas extracting the diagram after rule application yields the equivalent smaller circuit:

equivalent smaller circuit containing Rz(α1′),Rz(α2′),Rz(β1′),Rz(γ1′),Rz(γ2′),H, and controlled gates(7)\text{equivalent smaller circuit containing }R_z(\alpha'_1),R_z(\alpha'_2),R_z(\beta'_1),R_z(\gamma'_1),R_z(\gamma'_2),H,\text{ and controlled gates} \tag*{(7)}

However, ZX-diagrams simplified with Eq. (4) may contain spiders in XZ and YZ plane as well. While it has been shown that those diagrams still preserve generalized flow (gflow), the circuit extraction routine has to convert those spiders back into XY spiders using either pivoting (YZ) or a combination of local complementation and pivoting (XZ) before extracting the diagram [2]. An algorithm to efficiently extract diagrams that do not admit the gflow property is yet to be discovered; however, recent findings suggest that such an algorithm may not exist for general ZX-diagrams [4]. Hence, even though the diagram may represent a unitary matrix, we cannot extract a quantum circuit from the diagram efficiently.

Enhancing reduction of 2-qubit gates

As seen in Eq. (6) and Eq. (7), a Hadamard wire gets extracted to H, CNOT or CZ gates. The number of Hadamard wires in a graph-like ZX-diagram therefore correlates with the number of 2-qubit gates in the extracted circuit. The diagram simplification algorithms shown in Section 3 focus on eliminating spiders while neglecting – or even increasing – the number of Hadamard wires. Hence, this section introduces methods which additionally minimize the amount of Hadamard wires (ref. as #wires in the following).

To do so, it is crucial to examine where and when local complementation and pivoting are applied. Both rules can either increase or decrease #wires, depending on the connectivity of the relevant neighbors. Eq. (1) and Eq. (2) show examples in which #wires decreases. However, as Eq. (4) shows it can also increase #wires and we easily construct extreme cases like the one shown in Eq. 10. Applying local complementation to the central spider with phase π/2\pi/2 yields a diagram containing one spider less but a significantly higher #wires. Extracting the left diagram with the current version of the PyZX-library produces a circuit with six 2-qubit gates, while the diagram on the right gets extracted as a circuit with 21 2-qubit gates. Generally, applying local complementation on a spider with nn unconnected neighbors leads to n(n+1)2−n\frac{n(n+1)}{2}-n new wires. As pivoting involves local complementation on two spiders, the effect usually even worsens for this rule.

To prevent such cases and to guide the simplification process towards a minimal #wires, we introduce cost functions for local complementation and pivoting allowing us to calculate #wires after rule applications. We take those as a heuristic for estimating how rule applications change the number of 2-qubit gates and implement decision strategies for diagram simpliciation based on the heuristics.

Pivoting and local complementation on spiders with arbitrary phases

In contrast to the Clifford simplification algorithm from Section 3, we can apply local complementation and pivoting on spiders with arbitrary phases. Similar to the Pivot Phase Gadget (p2) rule, we can change a spider with non-Clifford phase by a combination of the rules (f,i2,i1)(f,i2,i1) as in Eq. 11. With that we can apply local complementation on spiders with phase different from ±π/2\pm\pi/2 (this introduces one XZ-spider) and pivoting on pairs of spiders where one/no spider has a phase of 00 or π\pi (this introduces one/two YZ-spiders). Note that this does not change the gflow property (c.f. [2 Lemma 3.1]).

Diagram showing the transformation of a phased spider using the rules $(f,i2,i1)$

Figure 11.

Local Complementation Heuristic (LCH)

The costs for local complementation are calculated on the following proposition:

Proposition 4.1 Let G=(V,E)G=(V,E) be an open graph; u∈Vu \in V an arbitrary vertex with neighbors N(u)⊂VN(u) \subset V; n=∣N(u)∣n=|N(u)| the number of neighbors; and mm the number of edges between the neighbors, i.e.,

m=∣{(a,b)∈E∣a,b∈N(u)}∣.m = \lvert\{(a,b) \in E \mid a,b \in N(u)\}\rvert.

For G⋆uG \star u, nn remains the same, but mm changes to m′=△n−1−mm'=\triangle_{n-1}-m, where △n−1=n(n−1)2\triangle_{n-1}=\frac{n(n-1)}{2}.

Hence, the difference in the number of wires after application of the local complementation rule is:

(n+m)−(n+(△n−1−m))=2m−△n−1(8)(n+m)-(n+(\triangle_{n-1}-m))=2m-\triangle_{n-1} \tag*{(8)}

With respect to the phase φ(u)\varphi(u) of the spider uu, the graph changes as follows:

  • If φ(u)=±π/2\varphi(u)=\pm\pi/2: Remove uu from the graph and eliminate all wires between uu and N(u)N(u).

  • If φ(u)\varphi(u) is non-Clifford: All wires between uu and N(u)N(u) remain and we get an additional wire for the phase gadget.

  • If φ(u)\varphi(u) is 00 or π\pi: No phase gadget is needed and we can use the π\pi-copy rule.

The LCH is calculated as follows:

LCH(u)={2m−△n−1+nif φ(u)=±π22m−△n−1if φ(u)=k⋅π, k∈Z2m−△n−1−1otherwise(9)LCH(u)= \begin{cases} 2m-\triangle_{n-1}+n & \text{if }\varphi(u)=\pm\frac{\pi}{2}\\ 2m-\triangle_{n-1} & \text{if }\varphi(u)=k\cdot\pi,\ k\in\mathbb{Z}\\ 2m-\triangle_{n-1}-1 & \text{otherwise} \end{cases} \tag*{(9)}

Pivoting Heuristic (PH)

We calculate the upper bound of new connections with the sets A,B,CA,B,C (see Appendix § 10):

Cmax⁡=∣A∣⋅∣B∣+∣A∣⋅∣C∣+∣B∣⋅∣C∣(10)C_{\max} = |A| \cdot|B| + |A| \cdot|C| + |B| \cdot|C| \tag*{(10)}

We denote the number of neighbors of uu and vv by nu=∣N(u)∣n_u = |N(u)| and nv=∣N(v)∣n_v = |N(v)|, respectively, and the number of edges between neighbors of different sets as mm.

The changes of the graph GG to G∧uvG \wedge uv have the following cases (j,k∈Zj,k \in\mathbb{Z}):

(C1) φ(u)=j⋅π,φ(v)=k⋅π\varphi(u) = j \cdot\pi, \varphi(v) = k \cdot\pi: If both spiders have a phase of 0 or π\pi, all connections between {u,v}\{u,v\} and N(u)∪N(v)N(u) \cup N(v) are eliminated.

(C2) φ(u)=j⋅π,φ(v)≠k⋅π\varphi(u) = j \cdot\pi, \varphi(v) \ne k \cdot\pi: If vv becomes a phase gadget and uu gets eliminated, all neighbors of uu get connected to vv and we have an additional wire for the phase gadget.

(C3) φ(u)≠j⋅π,φ(v)=k⋅π\varphi(u) \ne j \cdot\pi, \varphi(v) = k \cdot\pi: If uu becomes a phase gadget and vv gets eliminated, all neighbors of vv get connected to uu and we have an additional wire for the phase gadget.

(C4) φ(u)≠j⋅π,φ(v)≠k⋅π\varphi(u) \ne j \cdot\pi, \varphi(v) \ne k \cdot\pi: If both spiders become phase gadgets, all neighbors of uu get connected to vv and all neighbors of vv get connected to uu. Furthermore, uu gets connected to vv again and we have two more wires for the phase gadgets.

With these conditions, the PHPH is calculated as follows:

PH(u,v)={2m−Cmax⁡+nu+nv−1for (C1)2m−Cmax⁡+nv−1for (C2)2m−Cmax⁡+nu−1for (C3)2m−Cmax⁡−2for (C4)(11)PH(u,v) = \begin{cases} 2m-C_{\max}+n_u+n_v-1 & \text{for (C1)} \\ 2m-C_{\max}+n_v-1 & \text{for (C2)} \\ 2m-C_{\max}+n_u-1 & \text{for (C3)} \\ 2m-C_{\max}-2 & \text{for (C4)} \end{cases} \tag*{(11)}

Decision strategies

With the two heuristics (LCH,PHLCH,PH) at hand we can now implement different strategies to decide where and when local complementation or pivoting are applied during the simplification. A single simplification step in our procedure consists of the following actions:

  1. Filter all possible rule applications of the current ZX-diagram.

  2. Select rule according to selection strategy (see below).

  3. Apply rule on the ZX-diagram.

For filtering rule applications we can specify a lower bound for the heuristic, e.g., LCHLCH or PH=−5PH = -5 says that we do not consider rule applications which increase #wires by more than five. We can also specify whether rule applications are allowed on boundary spiders (c.f. Appendix § 9) and whether rules are allowed on arbitrary phased spiders. For selecting a rule we implemented two different strategies:

  • Random selection: Rules are chosen by a random coin flip.

  • Greedy selection: Chooses the rule application which maximally decreases #wires.

Each algorithm terminates if we allow only rule applications with a LCH/PH>0LCH/PH > 0 and when there is no rule left that decreases #wires. They also terminate if we allow negative gains (LCH/PH≤0LCH/PH \le0) and restrict the matches to interior spiders that do not generate new spiders. This is the case in standard local complementation on a spider with phase ±π/2\pm\pi/2 and pivoting on a pair of spiders with phase 0 or π\pi. algorithm eliminates at least one spider in every step and terminates when neither interior spiders with phase ±π/2\pm\pi/2 nor pairs with phase 0 or π\pi are left.

On the other hand, allowing rule applications on spiders of arbitrary phases which increase #wires may result in loops and therefore no termination. For such cases we only allow rule applications which increase #wires on spiders present since the very beginning of our simplification procedure. On newly generated spiders only rules which decrease #wires are allowed.

New optimization rule: Neighbor Unfusion

As shown in Eq. (4), the application of local complementation (lclc) and pivoting (pp) on spiders with many neighbors can not only decrease but also increase #wires. The heuristics shown in § 4 may help to identify and prevent extreme cases as in Eq. 10. However, spiders that are measured in YZYZ- or XZXZ-plane (c.f. § 3.2) require special attention: When extracting a spider in YZYZ-plane (e.g., the empty spider of the phase gadget in Eq. (3) and Eq. (4)), pivoting has to be applied to maintain the focused gflow property. The same happens for spiders in XZXZ-plane, but they are resolved by local complementation [2]. This affects #wires after the simplification and a simplified diagram containing some spiders in YZYZ- and XZXZ-plane may result in an expensive circuit.

However, when applying either rule on diagrams with arbitrary spiders as discussed in § 4.1, spiders in YZYZ- or XZXZ-plane are generated. We introduce the neighbor unfusion (nunu) rule, which allows lclc and pp on such arbitrary-phase spiders without introducing spiders in YZYZ- or XZXZ-plane.

Neighbor unfusion combines the fusion (ff) and identity rules (i1,i2i1,i2) as shown in Eq. (12). If a spider with phase α\alpha is connected to a neighbor, we change its phase to an arbitrary phase γ\gamma by inserting an empty spider and a spider with phase α−γ\alpha-\gamma between the spider and its neighbor. It allows changing the phase of an arbitrary spider to γ=±π2\gamma=\pm\frac{\pi}{2} and thus local complementation and removal of spiders with arbitrary phases.

αβ→nuγα−γβ(12)\alpha\quad\beta\xrightarrow{nu} \gamma\quad\alpha-\gamma\quad\beta \tag*{(12)}

For illustration, we apply neighbor unfusion (nunu) to the example of Eq. 11. We can move the β\beta spider to any direction (in Eq. (13) towards α1\alpha_1), so it is then not affected by the application of local complementation (lclc). Comparing Eq. 11 and Eq. (13) we see that we not only reduce #wires, but also prevent the generation of a spider in XZXZ-plane. However, the neighbor unfusion rule sometimes leads to diagrams which do not have focused gflow property. This is due to the insertion of the empty spider and the spider with phase α−γ\alpha-\gamma in 16. We observed that this problem does not occur if the spiders with phase α\alpha and β\beta get extracted to the same qubit. Currently, we find such pairs of spiders by using the flow hierarchy of the maximally delayed gflow of the diagram (c.f. [2]), which is quite costly, because we need to recalculate the gflow at each simplification step. Therefore, diagram simplification with neighbor unfusion has a much higher runtime than the other simplification procedures. It is an open question whether neighbour unfusion can only destroy the focused gflow property, or also more general flow properties like gflow or Pauli flow.

βα1,α2,α3→nu,lcα3∓π2, α2∓π2, β∓π2(13)\beta\quad\alpha_1,\alpha_2,\alpha_3 \xrightarrow{nu,lc} \alpha_3\mp\frac{\pi}{2},\ \alpha_2\mp\frac{\pi}{2},\ \beta\mp\frac{\pi}{2} \tag*{(13)}

Evaluation

We evaluate our heuristic-based simplification algorithms on a set of circuits first used in [1]. They implement various arithmetic problems as quantum circuits and were used as a benchmark set for comparing different optimization strategies [20, 22]. We use it to compare our heuristic-based approaches with the Clifford simplification algorithm described in [9], and some of the best results reported for circuit optimizations with [20] and without using ZX-calculus [22]. We also investigate how ZX-calculus based approaches perform when using the TODD-algorithm [14] for additional T gate reduction.

Implementation

With the exception of [20] – which omits simplifying the diagram (step 3) and extraction (step 4) – we use the following pipeline for ZX-calculus based optimization algorithms:

  1. Optimize circuit using gate cancellation and commutation.

  2. Transform circuit to ZX-diagram and apply phase teleportation to reduce T-count (as in [20]).

  3. Simplify ZX-diagram (standard Clifford or heuristic-based simplification).

  4. Extract circuit from ZX-diagram.

  5. Optimize circuit as in step 1.

Since our heuristic-based algorithms do not reduce T gates, we always apply the phase teleportation in step 2 since this reduces T gates as far as currently possible with ZX-calculus. This ensures comparable results regarding the 2-qubit gate count against non-ZX-calculus based approaches that optimize all types of gates. We implemented our algorithms in a clone of the PyZX library which also contains our optimized circuits in the OpenQASM format1. All results were proven to be correct by checking whether the optimized circuit together with the adjoint of the original circuit can be reduced to the identity.

Results

For each circuit we compare the total gate count Σ\Sigma and the 2-qubit gate count 2Q2Q. The results are summarized in Table 2 and Table 3: Their columns show circuit name, metrics of the original circuit of the benchmark, metrics of one (or more) existing optimization algorithms and the metrics of the best performing heuristic-based algorithm. For the latter, we denote the simplification strategy achieving the best result in the last column: 1. Greedy, 2. Random, 3. Greedy with neighbor unfusion, 4. Random with neighbor unfusion.

CircuitOriginalClifford algorithmPyZX/tket\textsuperscript{⋆}Nam et al.Heuristic algorithmNam+Heuristic
Σ\Sigma2Q2QΣ\Sigma2Q2QΣ\Sigma2Q2QΣ\Sigma2Q2QΣ\Sigma2Q2QAlg.Σ\Sigma2Q2QAlg.
Mod 546328362124⋆12⋆512841232(-20)38233(1)
VBE-Adder3_3150701165910154895087423(1)87424(1)
CSLA-MUX3_317080177971567515570155743(-5)156673(1)
CSUM-MUX3_3420168455271327⋆158⋆2661403031503(1)2661401(1)
QCLA-Com7_74431863972233161482841322951384(-5)2751321(1)
QCLA-Mod7_7884382903475717324--7053114(-20)---
QCLA-Adder10_{10}5212335623054351993991834171934(-20)3981824(1)
Adder8_89004097794296753396062915972954(1)5142564(1)
RC-Adder6_620093206113393⋆164⋆14071159711(1)152711(1)
Mod-Red21_{21}2781052601302179318077196853(1)179761(1)
Mod-Mult55_{55}11948124749142914090401(1)90411(1)
Toff-Barenco3_35824502659⋆18⋆401846211(1)40183(-5)
Toff-NC3_3451841204016351436153(1)35141(1)
Toff-Barenco4_411448117609544723488404(1)72343(1)
Toff-NC4_4753086436526552257243(1)55221(1)
Toff-Barenco5_517072149861406610450122574(1)102483(1)
Toff-NC5_51054292429036753078333(1)75301(1)
Toff-Barenco10_{10}4501923921963651762641303251514(1)2521183(1)
Toff-NC10_{10}2551022371002158617570183783(1)175701(1)
GF(242^4)-Mult2259924514019399187991951012(1)180983(-5)
GF(252^5)-Mult3471543511973041542961543061561(1)2891554(-20)
GF(262^6)-Mult4952215453084222214032214182174(-5)3902183(-5)
GF(272^7)-Mult6693007364175733005553005722994(-5)5352924(-20)
GF(282^8)-Mult88340510156067454057124057454051(1)6913991(1)
Avg. reduction∼3%\sim3\%∼−22%\sim-22\%∼14%\sim14\%∼9%\sim9\%∼27%\sim27\%∼19%\sim19\%

Table 2. Circuit metrics for original benchmark circuits, Post-optimization metrics of the standard Clifford simplification [9], PyZX [20], Nam et al. [22], our heuristic-based simplification method, and the combined approach of Nam et al. and our heuristic-based methods. Only our best optimization is presented: 1) Greedy, 2) Random, 3) Greedy with neighbor unfusion, 4) Random with neighbor unfusion, the lower bound for the heuristics is denoted in brackets. If the best PyZX result is achieved by the t|ket|-library, the respective cell is marked with ⋆. The best results of each metric in each row are marked.

CircuitOriginal Σ\SigmaOriginal 2Q2QOriginal T\mathcal{T}PyZX+TODD Σ\SigmaPyZX+TODD 2Q2QPyZX+TODD T\mathcal{T}Heuristic+TODD Σ\SigmaHeuristic+TODD 2Q2QHeuristic+TODD T\mathcal{T}Alg.
CSLA-MUX3_3170807026217543257169432(1)
CSUM-MUX3_342016819657542874411261744(-5)
QCLA-Com7_744318620345427493389211934(1)
QCLA-Adder10_{10}5212332388005171436773911434(-20)
Mod-Mult55_{55}1194849107562710455274(-5)
GF(24^4)-Mult2259911229822152295220521(-5)
GF(25^5)-Mult34715417553842088524403883(1)
GF(26^6)-Mult4952212529437641349337501343(1)
GF(27^7)-Mult6693003431253103618012239931804(1)
GF(28^8)-Mult88340544817911521224178015072243(1)

Table 3. Circuit metrics for the original benchmark circuits, Post-optimization metrics for PyZX+TODD and of our heuristic-based algorithms+TODD.

As a very first result, the last column in the “Heuristic Algorithm” section of Table 2 prominently indicates the great value of neighbor unfusion (Alg. 3 and 4), as it achieves the best performance of our heuristics in >70%> 70\% of the cases.

We now compare our heuristic-based simplifications following against other ZX-calculus based optimizations in Table 2. For most circuits our heuristic-based simplification clearly outperforms the standard Clifford simplification [9], both in total and 2-qubit gate reduction. Moreover, while our approaches almost always decrease circuit metrics, the standard approach often yields circuits with higher metrics than the original circuit (e.g., “CSLA-MUX3_3”, “GF(26^6)-Mult”). Especially for 2-qubit gates our approaches decrease 2-qubit gate count by 16%, while the standard approach even increases the count by 22%. In a direct comparison our approaches have up to 33% (“Toff-NC4_4”) fewer total and 47% (“Mod-Mult55_{55}”) fewer 2-qubit gates than the standard Clifford approach.

Second, we compare against the best available PyZX implementation [20] and the recommended optimization pipeline of the t|ket⟩-library [27] with the routines PauliSimp and FullPeepholeOptimize, which use similar strategies. The column “PyZX/t|ket⟩” in Table 2 shows the best optimization results for both implementations and ⋆ indicates results from t|ket⟩. Except for two circuits (“Mod 54” and “Toff-Barenco3_3”), our algorithms outperform all ZX-calculus based algorithms in terms of total gate count and 2-qubit gate count.

Third, Table 2 also shows our result in comparison to the cutting-edge non-ZX-calculus based algorithm from Nam et al. [22]. It can be seen that the algorithm from [22] outperforms any ZX-calculus based algorithm for most circuits. Still, we were able to achieve better results for the circuits “VBE-Adder3_3” and “Mod-Mult55_{55}”. Note that we did not compare for the “QCLA-Mod7_7” circuit, because [15] reports that the optimized circuit from [22] does not correspond to the original.

Last, the rightmost columns of Table 2 show a combination of Nam et al’s approach with ours. We use the output circuits from the Nam et al. optimization as input for our algorithms and observe that we achieve equally good or better results for almost all circuits. The larger the circuit, the more significantly this combination improves the previous best known results. Most notably, we improve the total count of the “Adder”8_8 circuit by more than 15% and the 2-qubit gate count by more than 12%.

Apart from the 2-qubit gate count, the T gate count of a quantum circuit is an important metric, since T-gates are more complex to implement for an error-corrected quantum computer. Therefore, we compare our algorithms to the other ZX-calculus based approaches using the TODD algorithm as optimization step 1). It is designed to reduce T gate count by introducing ancilla qubits, but sometimes also reduces T-gates in the ancilla-free case. Table 3 shows those benchmarks circuits where the combination of TODD and a ZX-calculus based algorithm reduces T gate count even more compared to the best result in Table 2. We compare the best combination of our heuristic-based algorithm and TODD against the best combination of an existing ZX-calculus based algorithm and TODD.

While we observe a general increase in 2-qubit and total gates using TODD algorithm, our best algorithm yields better results than the existing ZX-calculus based algorithms in every case.

Conclusions and Future Work

In this work we introduce two functions, namely the Local Complementation Heuristic LCH (for the local complementation rule) and the Pivot Heuristic PH (for the pivot rule). The functions calculate the number of Hadamard wires that would be added or removed by applying the respective rule, thus serving as a heuristic for estimating the 2-qubit gate count of the underlying circuit. This allows us to develop a more sophisticated strategy for ZX-diagram simplification: First, dismiss the applicable rules that cost too much and then either select a rule randomly or select the rule with the best wire count decrease.

Notably, the T gate count remains unchanged throughout this process, which is why our approach and others that mainly decrease the T gate count complement each other well. Further, we introduce the new Neighbor Unfusion rule which combines the established fusion and identity rules. This rule allows introducing spiders with arbitrary phases into the circuit if needed, for example when the local complementation or pivot rule would be useful to reduce Hadamard wires. As a side note, we also formally describe how to use the local complementation and the pivoting rule on spiders with non-Clifford phases, which is a common implementation practice but has never been mentioned in theory.

We measure the impact of aligning the optimization strategy with the heuristics and adding the neighbor unfusion rule by comparing our algorithm to four other approaches, some based on ZX-calculus and some not, on a set of 24 well-established benchmark circuits. Our approaches show significant improvements compared to all other ZX-based approaches, especially in 2-qubit gate reduction. On their own, non-ZX-based approaches still yield slightly better results than our ZX-based approaches. However, when combining both we are able optimize circuits better than the previously best known result, which seems to be a promising field for further research.

Using heuristics for ZX-diagram simplification also provides many possibilities for future improvement. Regarding the selection of rules, both random and greedy strategy are non-optimal for finding a ZX-diagram with minimal number of wires. Instead, we propose using a metaheuristic selection strategy like simulated annealing for escaping local minima during simplification. Furthermore, since simplification with neighbor unfusion tends to yield the best results, we think it is important to further investigate in which cases neighbor unfusion generates XYXY spiders and if we can preserve valid ZX-diagrams when allowing unfusion on spiders which get extracted on different qubits.

Acknowledgment

This work is partially supported by the German Federal Ministry of Education and Research (BMBF) under the funding programme Quantum Technologies - From Basic Research to Market under contract number 13N16077.

Further rules

In addition to the rules in Section 3, additional rules have been developed to eliminate every interior Clifford spider.

Pivoting Boundary Spiders (p1)

The pivoting rule can also be applied if one of the spiders is a boundary spider, i.e., connected to an input or output, using the following transformation:

uv(i1,i2)uv(p)boundary spiders connected by a pivoting transformation(14)\begin{gathered} u\quad v \qquad(i_{1},i_{2}) \qquad u\quad v \qquad(p) \\ \text{boundary spiders connected by a pivoting transformation} \tag*{(14)} \end{gathered}

Here vv gets transformed to an interior spider and both uu and vv can be removed using the pivoting rule.

Gadget Fusion (gf):

An important feature of phase gadgets is that we can fuse two phase gadgets connected to the same neighbors by summing up their phases.

α+β(15)\alpha+\beta \tag*{(15)}

This rule is used for eliminating non-Clifford spiders in a diagram, for instance, two phase gadgets with phase π/4\pi/4 connected to the same set of neighbours can be fused into a single phase gadget with phase π/2\pi/2. Combining the Clifford simplification algorithm with those extended rules we can eliminate all interior Clifford spiders (in exchange for phase gadgets) and some interior non-Clifford spiders.

Graph Theory

Since ZX-calculus and its optimization strategies rely on graph operations on undirected graphs, we provide some background on it: An undirected graph is a tuple G=(V,E)G=(V,E) with vertices (or “nodes”) VV and edges E⊆V×VE\subseteq V\times V.

Local Complementation

The local complementation ⋆\star [5] of an undirected graph G=(V,E)G=(V,E) about a vertex uu is defined as follows (Δ\Delta is the symmetric set difference: AΔB:=(A∪B)∖(A∩B)A\mathbin{\Delta}B:=(A\cup B)\setminus(A\cap B)):

G⋆u:=(V,EΔ{(a,b)∣(a,u),(b,u)∈E,a≠b})(16)G\star u := \left(V,E\mathbin{\Delta}\{(a,b)\mid(a,u),(b,u)\in E,a\ne b\}\right) \tag*{(16)}

The following example shows a graph GG and its local complementation about aa. Intuitively, local complementation connects two neighbours of aa if they are not connected (e.g., b,cb,c) and disconnects them otherwise (e.g., c,dc,d).

Figure 21.

Pivoting Geelen.2009

Pivoting ∧\wedge rewrites an edge (u,v)∈E(u,v)\in E by triple local complementation:

G∧uv:=((G⋆u)⋆v)⋆u(17)G\wedge uv := ((G\star u)\star v)\star u \tag*{(17)}

To derive the new graph, we consider three disjoint sets (where the neighborhood of vertex xx is defined as N(x)={y∈V∣(x,y)∈E}N(x)=\{y\in V\mid(x,y)\in E\}):

  • A:=N(u)∩N(v)A:=N(u)\cap N(v): Vertices connected to uu and vv.

  • B:=N(u)∖N(v)B:=N(u)\setminus N(v): Vertices connected to uu and not to vv.

  • C:=N(v)∖N(u)C:=N(v)\setminus N(u): Vertices connected to vv and not to uu.

In a pivoted graph G∧uvG\wedge uv, two vertices from different sets A,BA,B or CC are connected if, and only if, the two are not connected in GG. Connections between vertices of the same set are not modified. As an example, consider the following graphs GG (left) and G∧uvG\wedge uv (right), where A={b},B={a,d},C={c,e}A=\{b\},B=\{a,d\},C=\{c,e\}. Intuitively, pivoting connects all vertices between A,B,CA,B,C that are not connected in GG (e.g., a,ba,b) and disconnects them otherwise (e.g., b,db,d):

Figure 23.

Example for ZX optimization

The following circuit can be optimized as follows:

A three-wire quantum circuit with two Z gates, two X gates, and three controlled-NOT connections, equal to a three-wire circuit with one X gate and two controlled-NOT connections.

Figure 24 (PDF p. 17).

We use the following rules2 (the affected spiders/wires to which a rule is applied are framed):

  1. Eliminate the two Z-gates using spider fusion (f):

ZX-calculus diagram showing spider fusion applied to eliminate two Z gates.

Figure 3 (PDF p. 17).

  1. Reduce from 3 to 2 CNOTs with fusion (f) and bialgebra rule (b):

ZX-calculus diagrams showing fusion and the bialgebra rule reducing three CNOTs to two.

Figure 4.

  1. Eliminate one X by the π\pi copy rule:

ZX-calculus diagrams showing the pi copy rule and fusion eliminating one X.

Figure 5.

References

  1. [1]Matthew Amy, Dmitri Maslov & Michele Mosca (2014): Polynomial-Time T-Depth Optimization of Clifford+T Circuits Via Matroid Partitioning. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 33(10), pp. 1476–1489, doi:10.1109/TCAD.2014.2341953.DOI
  2. [2]Miriam Backens, Hector Miller-Bakewell, Giovanni de Felice, Leo Lob ski & John van de Wetering (2021): There and back again: A circuit extraction tale. Quantum 5, p. 421, doi:10.22331/q-2021-03-25-421.DOI
  3. [3]Stefanie Barz (2015): Quantum computing with photons: introduction to the circuit model, the one-way quantum computer, and the fundamental principles of photonic experiments. Journal of Physics B: Atomic, Molecular and Optical Physics 48(8), p. 083001, doi:10.1088/0953-4075/48/8/083001.DOI
  4. [4]Niel de Beaudrap, Aleks Kissinger & John van de Wetering (2022): Circuit Extraction for ZX-Diagrams Can Be #P-Hard. doi:10.4230/LIPICS.ICALP.2022.119.DOI
  5. [5]André Bouchet (1988): Transforming trees by successive local complementations. Journal of Graph Theory 12(2), pp. 195–207, doi:10.1002/jgt.3190120210.DOI
  6. [6]Bob Coecke & Ross Duncan (2011): Interacting quantum observables: categorical algebra and diagrammatics. New Journal of Physics 13(4), p. 043016, doi:10.1088/1367-2630/13/4/043016.DOI
  7. [7]Bob Coecke, Dominic Horsman, Aleks Kissinger & Quanlong Wang (2022): Kindergarden quantum mechanics graduates ...or how I learned to stop slugging LEGO together and love the ZX-calculus. Theoretical Computer Science 897, pp. 1–22, doi:10.1016/j.tcs.2021.07.024.DOI
  8. [8]Bob Coecke & Aleks Kissinger (2018): Picturing quantum processes. In: International Conference on Theory and Application of Diagrams, Springer, pp. 28–31, doi:10.1007/978-3-319-91376-6_6.DOI
  9. [9]Ross Duncan, Aleks Kissinger, Simon Perdrix & John van de Wetering (2020): Graph-theoretic Simplification of Quantum Circuits with the ZX-calculus. Quantum 4, p. 279, doi:10.22331/q-2020-06-04-279.DOI
  10. [10]Edward Farhi, Jeffrey Goldstone & Sam Gutmann: A Quantum Approximate Optimization Algorithm, doi:10.48550/arXiv.1411.4028.
  11. [12]Lov K. Grover (1996): A fast quantum mechanical algorithm for database search. In Gary L. Miller, editor: Proceedings of the twenty-eighth annual ACM symposium on Theory of computing, ACM, New York, NY, pp. 212–219, doi:10.1145/237814.237866.DOI
  12. [13]Aram W. Harrow, Avinatan Hassidim & Seth Lloyd (2009): Quantum algorithm for solving linear systems of equations. Physical Review Letters 103(15), p. 1474, doi:10.1103/PhysRevLett.103.150502.DOI
  13. [14]Luke E Heyfron & Earl T Campbell (2018): An efficient quantum compiler that reduces T count. Quantum Science and Technology 4(1), p. 015004, doi:10.1088/2058-9565/aad604.DOI
  14. [15]Kesha Hietala, Robert Rand, Shih-Han Hung, Xiaodi Wu & Michael Hicks (2021): A Verified Optimizer for Quantum Circuits. Proc. ACM Program. Lang. 5(POPL), doi:10.1145/3434318.DOI
  15. [16]Dominik Janzing, Pawel Wocjan & Thomas Beth (2005): ”Non-Identity-Check” is QMA-complete. International Journal of Quantum Information 03(03), pp. 463–473, doi:10.1142/S0219749905001067.DOI
  16. [17]Emmanuel Jeandel, Simon Perdrix & Renaud Vilmart (2018): A Complete Axiomatisation of the ZX-Calculus for Clifford+T Quantum Mechanics. In: Proceedings of the 33rd Annual ACM/IEEE Symposium on Logic in Computer Science, LICS ’18, Association for Computing Machinery, New York, NY, USA, p. 559–568, doi:10.1145/3209108.3209131.
  17. [18]Navin Khaneja & Steffen J. Glaser (2001): Cartan decomposition of SU(2n) and control of spin systems. Chemical Physics 267(1-3), pp. 11–23, doi:10.1016/S0301-0104(01)00318-4.DOI
  18. [19]Aleks Kissinger & John van de Wetering (2020): PyZX: Large Scale Automated Diagrammatic Reasoning. In Bob Coecke & Matthew Leifer, editors: Proceedings 16th International Conference on Quantum Physics and Logic, Chapman University, Orange, CA, USA., 10-14 June 2019, Electronic Proceedings in Theoretical Computer Science 318, Open Publishing Association, pp. 229–241, doi:10.4204/EPTCS.318.14.DOI
  19. [20]Aleks Kissinger & John van de Wetering (2020): Reducing the number of non-Clifford gates in quantum circuits. Phys. Rev. A 102, p. 022406, doi:10.1103/PhysRevA.102.022406.DOI
  20. [21]Daniel Litinski (2019): Magic State Distillation: Not as Costly as You Think. Quantum 3, p. 205, doi:10.22331/q-2019-12-02-205.
  21. [22]Yunseong Nam, Neil J Ross, Yuan Su, Andrew M Childs & Dmitri Maslov (2018): Automated optimization of large quantum circuits with continuous parameters. npj Quantum Information 4(1), pp. 1–12, doi:10.1038/s41534-018-0072-4.DOI
  22. [23]Michael A. Nielsen & Isaac L. Chuang (2013): Quantum computation and quantum information, first south asia edition edition. Cambridge University Press, Cambridge, doi:10.1017/CBO9780511976667.DOI
  23. [24]Joe O’Gorman & Earl T. Campbell (2017): Quantum computation with realistic magic-state factories. Physical Review A 95(3), doi:10.1103/PhysRevA.95.032338.
  24. [25]Alberto Peruzzo, Jarrod McClean, Peter Shadbolt, Man-Hong Yung, Xiao-Qi Zhou, Peter J. Love, Alán Aspuru-Guzik & Jeremy L. O’Brien (2014): A variational eigenvalue solver on a photonic quantum processor. Nature Communications 5(1), p. 4213, doi:10.1038/ncomms5213.DOI
  25. [26]P. W. Shor (1994): Algorithms for quantum computation: Discrete logarithms and factoring. In Shafi Goldwasser, editor: Foundations of Computer Science, 35th Symposium on (FOCS ’94, IEEE Computer Society Press, pp. 124–134, doi:10.1109/SFCS.1994.365700.
  26. [27]Seyon Sivarajah, Silas Dilkes, Alexander Cowtan, Will Simmons, Alec Edgington & Ross Duncan (2020): |tket⟩: a retargetable compiler for NISQ devices. Quantum Science and Technology 6(1), p. 014003, doi:10.1088/2058-9565/ab8e92.DOI
  27. [28]Renaud Vilmart (2019): A Near-Minimal Axiomatisation of ZX-Calculus for Pure Qubit Quantum Mechanics. In: 2019 34th Annual ACM/IEEE Symposium on Logic in Computer Science (LICS), pp. 1–10, doi:10.1109/LICS.2019.8785765.DOI

Paper details

vlnc:W_pyj75z26
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 8

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents