LAYOUTS FOR FAULT-TOLERANT QUANTUM COMPUTERS

Abstract

Disclosed herein are example layouts and layout generation techniques for fault-tolerant quantum computers. Example embodiments comprise methods for performing a layout reduction technique for fault-tolerant quantum computing. In certain embodiments, a layout of an arbitrary quantum circuit is reduced to a layout of exponents of a multiple qubit Pauli matrix and measurements of a multiple qubit Pauli matrix. In certain embodiments, qubits are marked as one of a data, interface, or ancilla qubit for a 2D nearest neighbor graph of qubit connectivity, and an ancilla-path is provided from a respective data qubit to a respective interface qubit.

Description

SUMMARY

Disclosed herein are example layouts and layout generation techniques for fault-tolerant quantum computers. The particular embodiments described should not be construed as limiting, as the disclosed method acts can be performed alone, in different orders, or at least partially simultaneously with one another. Further, any of the disclosed methods or method acts can be performed with any other methods or method acts disclosed herein. Likewise, the disclosed combinations of features can include rearrangements of any novel or nonobvious combination or subcombination of features.

One example embodiment comprises a method for performing a layout reduction technique for fault-tolerant quantum computing. In particular embodiments, the method is performed by one or more classical computing devices, at least some of which are in a configuration that can operate a quantum computer. In certain embodiments, a layout of an arbitrary quantum circuit is reduced to a layout of exponents of a multiple qubit Pauli matrix and measurements of a multiple qubit Pauli matrix; and a quantum computer is configured to implement the reduced layout. In particular implementations, qubits of the quantum computer comprise data qubits, interface qubits, and ancilla qubits. In further implementations, a graph of qubit connectivity satisfies a condition of providing an ancilla-path from one or more data qubits to the interface qubits.

Another example embodiment comprises another method for performing a layout technique for fault-tolerant quantum computing. In particular embodiments, the method is performed by one or more classical computing devices, at least some of which are in a configuration that can operate a quantum computer. In certain embodiments, qubits are marked as one of a data, interface, or ancilla qubit for a 2D nearest neighbor graph of qubit connectivity; an ancilla-path is provided from a respective data qubit to a respective interface qubit; and a quantum computer is configured to implement the ancilia-path from a respective data qubit to a respective interface qubit. In certain implementations, the method accounts for and avoids any broken qubits and satisfies a condition of providing an ancilla-path from a data qubit to the interface qubits.

Any of the methods described above can be performed in a system, comprising a quantum computing device; and one or more classical-computing devices, at least some of the one or more classical computing devices being programmed to perform any of the disclosed methods.

Additionally, any of the methods described above can be implemented as one or more classical-computer-readable-media storing classical-computer-executable instructions, which when executed by a classical computer cause the classical computer to perform any of the disclosed methods.

Further embodiments comprise, a quantum circuit configured to apply an exponent of a multiple qubit Pauli matrix and measure a multiple qubit Pauli matrix. In some implementations, an ancilla-path is provided from data qubits to the interface qubits. In further implementations, the quantum circuit has a depth not depending on the number of vertexes. In some implementations, the quantum circuit uses single or low-depth multiple-target CNOT gates as a sub-circuits.

Some embodiments, comprise a quantum circuit configured to (a) provide a multi-target CNOT gate using a single-qubit and two-qubit Pauli measurements and single qubit Clifford gates; or (b) provide a multi-target CNOT gate using a single-qubit, Pauli measurements, single qubit Clifford gates and Controlled-Z gates. In some implementations, the quantum circuit provides a multi-target CNOT gate using a single-qubit and two-qubit Pauli measurements and single qubit Clifford gates, wherein the quantum circuit works with qubits for which a graph of qubit connectivity satisfies a condition of providing an ancilla-path from a target qubit to the control qubit. In further implementations, the quantum circuit provides a multi-target CNOT gate using a single-qubit and two-qubit Pauli measurements and single qubit Clifford gates, wherein the quantum circuit has a depth not depending on the number of vertexes. In some implementations, the quantum circuit is configured to provide a multi-target CNOT gate using a single-qubit, Pauli measurements, single qubit Clifford gates and Controlled-Z gates, and wherein the quantum circuit works with qubits for which graph of qubit connectivity satisfies a condition of providing an ancilla-path from a target qubit to the control qubit. In further implementations, the quantum circuit, is configured to provide a multi-target CNOT gate using a single-qubit, Pauli measurements, single qubit Clifford gates and Controlled-Z gates, wherein the quantum circuit has a depth not depending on the number of vertexes.

The foregoing and other objects, features, and advantages of the disclosed technology will become more apparent from the following detailed description, which proceeds with reference to the accompanying figures.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a schematic block diagram that represents the circuit realizing a CNOT gate between the top qubit and the bottom qubit.

FIG. 2 is a schematic block diagram showing an example of providing a multi-target CNOT gate by measurement.

FIG. 3 is a schematic block diagram illustrating a modified version of FIG. 2 after moving the purple measurement M_Z1Z4 to the left to parallelize the final red block between the ancillas and the targets.

FIG. 4 is a schematic block diagram illustrating further modifying the initial measurements to parallelize the purple block between the control qubit and the ancillas (The effect of this parallelization appears only when more than two targets are present).

FIG. 5 is a schematic block diagram of a further general circuit in accordance with an embodiment of the disclosed technology.

FIG. 6 is a schematic block diagram of an example circuit that propagates a Pauli operator X_C.

FIG. 7 is a block diagram representing the planar layout for the multi-target CNOT gate of FIG. 8.

FIG. 8 is a flow chart showing a general method for performing embodiments of the disclosed technology.

FIG. 9 is a flow chart showing a further general method for performing embodiments of the disclosed technology.

FIG. 10 illustrates a generalized example of a suitable classical computing environment in which aspects of the described embodiments can be implemented.

FIG. 11 shows an example of a possible network topology (e.g., a client-server network) for implementing a system according to the disclosed technology.

FIG. 12 shows another example of a possible network topology (e.g., a distributed computing environment) for implementing a system according to the disclosed technology.

FIG. 13 shows an exemplary system for implementing the disclosed quantum-computing technology.

DETAILED DESCRIPTION

1. General Consideration

As used in this application, the singular forms “a,” “an,” and “the” include the plural forms unless the context clearly dictates otherwise. Additionally, the term “includes” means “comprises.” Further, the term “coupled” does not exclude the presence of intermediate elements between the coupled items. Further, as used herein, the term “and/or” means any one item or combination of any items in the phrase.

Although the operations of some of the disclosed methods are described in a particular, sequential order for convenient presentation, it should be understood that this manner of description encompasses rearrangement, unless a particular ordering is required by specific language set forth below. For example, operations described sequentially may in some cases be rearranged or performed concurrently. Moreover, for the sake of simplicity, the attached figures may not show the various ways in which the disclosed systems, methods, and apparatus can be used in conjunction with other systems, methods, and apparatus. Additionally, the description sometimes uses terms like “produce” and “provide” to describe the disclosed methods. These terms are high-level abstractions of the actual operations that are performed. The actual operations that correspond to these terms will vary depending on the particular implementation and are readily discernible by one of ordinary skill in the art.

2. Quantum Computing Preliminaries and Notation

Let I, X, Y and Z denote single qubit Pauli matrices. All single qubit Pauli matrices are Hermitian matrices. Square of every Pauli matrix is equal to I. A multiple qubit Pauli matrix is a tensor product (denoted as ⊗) of single qubit Pauli matrices. Notation X_k, Y_k, Z_k refers to a multiple qubit Pauli matrix with X, Y and Z on qubit k and I on all other qubits. For example X₂ as 3 qubit Pauli matrix refers to the matrix:

I⊗X⊗I.

Multiple qubit Pauli matrices are also Hermitian and their square is the identity matrix. Below, the multiple qubit Pauli matrix will simply be called a Pauli matrix. I is used for the identity matrix on any number of qubits. The dimension of I will be clear from the context.

The notation P|_k is used for the k-th component of the multi-qubit Pauli matrix. For example, for P−X_aY_bZ_c, P|_a−X, P|_b−Y and P|_c−Z.

For any square matrix A, Tr(A) is the sum of the diagonal elements of A. For arbitrary square matrices A, B it is the case that Tr(AB)=Tr(BA). In addition, Tr(A⊗B)=Tr(A)·Tr(B).

Orthogonal projector is a Hermitian matrix C with property C²=C. Tr(C) is equal to the dimension of the subspace that C projects onto.

Matrices A and B commute if AB=BA. Matrices A and B anti-commute if AB=−BA. Any two Pauli matrices either commute or anti-commute.

Plus state |+is (|0+|1)/√{square root over (2)}.

H_k is the Hadamard gate on qubit k. It is equal to (X_k−Z_k)/√{square root over (2)}.

One-qubit Clifford gates are H=(X+Z)/√{square root over (2)}, S=(I−Z)/√{square root over (2)}, products HP, SP, HSP, SHP, HSHP where P is I, X, Y, Z. One-qubit Clifford gates also include Pauli matrix X, Y, Z.

CZ_ij is Controlled-Z gate on qubits i and j. It is equal to (I+Z_i+Z_j−Z_iZ_j).

Hermitian matrix M stabilizes state |ψ if the state |ψ is +1 eigenvector of M. In other words, M|ψ=|ψ.

n-qubit cat state is the state (|0^⊗n+|1^⊗n)/√{square root over (2)} also known as GHZ state.

Let U be some unitary and let Q=UPU^†, it will be said that U maps P to Q.

3. Quantum Circuit Layout Problem

In this section, example embodiments of algorithms that solve special cases of the following problem are disclosed:

Problem 3.1 (Layout problem for a graph). Let (V, E) be a graph and V_rot be a subset of V. Vertexes are qubits. Consider quantum computation that uses one and two qubits Clifford operations, single qubit rotations exp(iφZ) and single qubit measurements. Perform a quantum computation that produces the same measurement outcomes using:

• • one qubits measurements and one qubit Clifford unitaries,
  • either (A) controlled-Z gates or (B) two qubit measurements on qubits connected by an edge
  • single qubit rotations exp(iφZ) can only be performed on subset V_rot

Using two (e.g., only two) qubit measurements on every edge is more restrictive. Any two qubit measurement can always be performed using two Controlled-Z gates, one measurement, and a single qubit Clifford gate. However, it is not possible to perform a Controlled-Z gate on two qubits by only measuring these two qubits. Restricting the qubits on which single qubit rotations can be performed reflects the fact that performing these rotations on a fault-tolerant quantum computer typically uses resource states that are usually produced in a dedicated part of the computer. Subset V_rot represents qubits to which it is easy to deliver resource states needed to implement the rotations.

The above problem can also be reduced to the case where V_rot comprises one element r and (V, E) is a tree with the root r. Indeed, for any graph (V, E) one can compute a spanning tree with root r. First, the solution for this case is described.

The first part of an example solution is to transform quantum computation to a canonical from. Here, the notation M(a, P)=(I+aP)/2 is used for the measurement of any multiple qubit Pauli operator P with outcome a−±1. Suppose one has n qubit quantum computation described as:

C₂M(a, Z_r(2))C₁ exp(iφZ_i(1))C₀|0^⊗n   (1)

where C_k are some Clifford operators. Recall that for any Clifford operator C and Pauli matrix P, product CPC^† is a Pauli matrix. Recall also that exponents and measurement have the following property:

UM(a, P)U^†−M(a, UPU^†), U exp(iφP)U^†−exp(iφU PU^†)   (2)

One can rewrite quantum computation (1) as:

C₂C₁C₀((C₁C₀)^†M(a, Z_i(2))C₁C₀)(C₀^† exp(iφZ_i(1))C₀)|0^⊗n

Using properties of measurement and exponential (2) one can further rewrite computation as:

C′M(a, P₂)exp(iφP₁)|0^⊗n, where C′=C₂C₁C₀

One can transform any quantum computation to a sequence of exponentials and measurements of multiple-qubit Clifford operation and the Clifford gate in the end. The Clifford gate in the end does not need to be executed because information is not extracted from the quantum computer after executing it.

To perform an arbitrary computation under constraints described in Problem 3.1, it is sufficient to be able to perform measurements M(a, P) and exp(iφP) for arbitrary Pauli matrices supported on certain qubits V_data ⊂ V. The size of subset V_data determines a maximal number of qubits one can use for computation. It is sufficient to be able to perform a Clifford C and C^† such that CZ_rC^†=P under constraints on two qubit operations described in Problem 3.1. Such Clifford operations can be constructed using multi-target Controlled-Z gates as described in Section 4. Table 1 and Table 2 show the programs for such a Clifford C operation that uses multiple-target Controlled-Z gates. The program of Table 1 applies Controlled-Z gates on edges of the tree, and the program of Table 2 applies two qubit measurements. When using this construction for Clifford C, set V_data corresponds to all leaves of the tree except the root.

In Section 5, a description is provided as to how to construct a tree with a high ratio of the number of leaves to the number of vertexes in 2D nearest neighbor architecture. Also considered is the case when fraction of the qubits in 2D nearest neighbor architecture is broken. It was found that when the fraction of broken is above 90%, one can still utilize good amount of qubits for computation.

TABLE 1
Program for Pauli Mapper Using Controlled-Z Gates
# Input: V is the set of qubits, vertexes of a tree, E is the set of tree edges.
#| | | | Qubits with corresponding vertex degree > 1 are all in
the plus state.
#| | | | P is a Pauli operator supported on tree leaves excluding the root.
# Effect: Clifford that maps Z on the root vertex to P is performed
on tree leaves.
#| | | | | The rest of the vertexes (the ones with
#| | | | | degree >1) are return back to a plus state.
operation PauliMapper((V,E),P)
| Let r be a root of (V,E)
| Let Vtargets be subset of leaves v such that P|v ≠ I
| Let Vexcluded be leaves not in Vtargets ∪ {r}
| Let (V1,E1) be a sub-tree of (V,R) such that V1 ∩ Vexcluded = ∅
| Hr
| MultipleTargetControlledZ(V1,E1); see Table 6
| Hr
| Let v′ be a vertex from Vtargets
| Let (Vpath,Epath) be a sub-tree of (V,R) that only contains path
from r to v′
| Hv′,
| MultipleTargetControlledZ(Vpath,Epath); see Table 6
| Hv′
| foreach v in Vtargets
| | Apply single qubit Clifford that maps Pauli Z to P|v

4. Low Depth Multi-Target Controlled-Z Gates

This section describes two ways of performing low-depth multi-target Controlled-Z gates. One is suitable for an architecture that has native Controlled-Z gates. Another one is for the architecture with two qubit operations restricted to only measurements of two qubit Pauli matrices. Notable for both is low depth circuit for cat state preparation and low depth circuit for fanout gate. In the following, qubits are considered to be vertexes of a tree and two qubit operations are allowed only

TABLE 2
Example Program for Pauli Mapper Using Two Qubit Pauli Measurements
# Input: V is the set of qubits, vertexes of a tree, E is the set of tree edges.
#| | | | Qubits with corresponding vertex degree > 1 are all in
the plus state.
#| | | | P is a Pauli operator supported on tree leaves excluding the root.
# Effect: Clifford that maps Z on the root vertex to P is performed on
tree leaves.
#| | | | | The rest of the vertexes (the ones with
#| | | | | degree > 1) are returned back to a plus state.
operation PauliMapperMeasure((V,E) ,P)
| Let r be a root of (V,E)
| Let Vtargets be subset of leaves v such that P|v ≠ I
| Let Vexcluded be leaves not in Vtargets ∪ {r}
| Let (V1,E1) be a sub-tree of (V,R) such that V1 ∩ Vexcluded = ∅
| Let (V2,E2) be the result of removing all leaves except the root
from (V1,E1)
| Let L be a set of leaves of V2
| foreach v in L
| | Let (v,v′) be an edge in V1.
| | Add (v,v′) to (V2,E2)
| Hr
| MultipleTargetControlledZMeasure(V2,E2) ; see Table 7
| Hr
| foreach a in L
| | Let (t,a) be an edge in V2
| | Ht
| | foreach c in V such that (c,a) is an edge in V1 but not in V2
| | | ControlledZbyMeasurement(c,t,a) # See Proposition 4.5
| | Ht
| Let v′ be a vertex from Vtargets
| Let (Vpath,Epath) be a sub-tree of (V,R) that only contains path
from r to v′
| Hv′
| MultipleTargetControlledZMeasure(Vpath,Epath) ; see Table 7
| Hv′
| foreach v in Vtargets
| | Apply single qubit Clifford that maps Pauli Z to P|v

TABLE 3
Program for cat state (|0   ⊗n + |1   ⊗n)/{square root over (2)} preparation in low depth
# Input: V is the set of qubits, vertexes of a tree, E is the set of tree edges
#| | | | All qubits are is the plus state.
#| | | | Tree (V,E) is edge colored, w is a qubit in V
# Effect; All qubits are in cat state
operation CatStatePrep(V,E,w)
| foreach color c of the tree # number of colors is the largest vertex degree
| | foreach edge e = (u,v) of color c # body of this loop can be
done in depth 1
| | | Measure observable Z ⊗ Z on qubits u and v
| | | Label edge e by the measurement outcome
| | | Use label 0, when the outcome is +1 and label 1 otherwise
| Assign vertex w label 0, assign other vertexes label 0 or 1
| | such that for every edge e=(u,v)
| | label(e) = label(u) ⊕ label(v). # this can be done using tree traversal
| foreach vertex v # body of this loop can be done in depth 1
| | if label(v) = 1 then apply X to qubit v

between qubits connected by an edge. Recall that when one needs to perform Z⊗Z measurements of qubits a and b, it is equivalent to the following:

1 CNOTa,b # a is the control, b is the target
2 Measure Zb
3 CNOTa,b

The next proposition shows that the circuit depth required to prepare cat state on a tree does not depend on the number of tree vertexes.

Proposition 4.1 (Low depth cat state preparation). Let (V,E) be a tree. Vertexes of the tree correspond to qubits. All the qubits are in plus state. One can only apply the following operations:

• • measure observable Z⊗Z on qubits connected by an edge,
  • apply Pauli X to any of the qubits except chosen in advance qubit w

Then the cat state on qubits corresponding to vertexes can be prepared using |E|=|V|−1 of Z⊗Z measurements, in depth equal to the largest vertex degree. In addition, one requires at most |V|=1 Pauli X operations performed all in parallel. The pseudo-code for cat state preparation is given in Table 3.

Proof First, it will be shown that the procedure on Table 3 indeed prepares the cat state. Recall that cat state |ψ=(|0^⊗n+1^⊗n)/√{square root over (2)} on n=|V| can be uniquely described by the following constraints (up to the global phase):

$\prod _{v\in V}X_v\psi 〉=\psi 〉,Z_uZ_v\psi 〉=\psi 〉,\left(u,v\right)\in E$

Indeed, the above implies that |ψ is stabilized by the following projector:

$P=\frac{1}{2}\left(I+\prod _{v\in V}X_v\right)\prod _{\left(u,v\right)\in E}\frac{I+Z_uZ_v}{2}$

Next, expand the above product into sum of Pauli matrices. Use |E|=|V|−1 and that all non-identity Pauli matrices have trace zero to check that, Tr(P)−1. Conclude that P fixes one dimensional sub-space.

Initializing all qubits to |+ state ensures that their joint state is stabilized by Π_v∈V X_v. Measuring Z_uZ_v for (u, v) ∈ E ensures that the state is +1 or −1 peigenstate of Z_uZ_v. Note that because all constraints commute, adding a new one via measurement preserves all previous constraints. By the time all measurements were performed and the edges labeled, the state of the qubits |φ satisfies the following constraints:

$\prod _{v\in V}X_v\phi 〉=\phi 〉,Z_uZ_v\phi 〉={\left(-1\right)}^{\mathrm{label}\left(u,v\right)}\phi 〉,\left(u,v\right)\in E$

It remains to fix the −1 signs. This can be done by applying single qubit Pauli X operators to vertexes. One can label vertex with 0 if one does not apply X to it, and with 1 if one does. This changes the signs in the following way:

Z _u Z _v(X_u^aX_v^b|φ)=(−1)^{label(u,v)⊕a⊕b}(X_u^aX_v^b|φ), a=label(u), b=label(u), b=label(v), (u, v) ∈ E

The label assignment can be found by one tree traversal, for example, using a depth first search. The label of the tree root can be chosen to be zero. The label of each vertex is computed based on the label of the parent and the label of the edge connecting the vertex and its parent.

Finally note that edges of each color do not share vertexes. For this reason, measurements on corresponding qubits can all be performed in parallel. This implies that the depth of the measurement part of the cat state preparation is equal to the chromatic number of the tree which is the largest vertex degree plus one.

Given an n-qubit cat state it is sufficient to perform one two-qubit measurement to get a fanout gate

(α|0+β|1)⊗|+^⊗n−1α|0^⊗n+β|1^⊗n

from one to n+1 qubits. The next proposition gives some intuition how one two qubit measurement can help perform a partially specified unitary acting on n+1 qubits.

Proposition 4.2 (Unitary operations via measurement). Let |ψ be a multiple qubit state and P be a multiple qubit Pauli matrix that stabilizes |ψ (e.g.. P|ψ=|ψ). Let Q be another multiple qubit Pauli matrix that anti-commutes with P. Then the probability of measuring +1 for observable Q of |ψ is 1/2. Moreover, if the measurement outcome is −1, then applying P conditioned on the outcome −1 is equivalent to measuring −1. Under above conditions, one can always deterministically apply the following transformations to |ψ via measurement:

$\begin{array}{cc}\psi 〉\mapsto \frac{I+Q}{\sqrt{2}}\psi 〉=\exp \left(\frac{\pi }{4}\mathrm{QP}\right)\psi 〉& \left(3\right)\end{array}$

Proof First, the probability of measuring +1 is 1/2 6is shown. One can show this by showing the probabilities of measuring +1 and −1 are equal. Recall that the probability of measuring ±1 is

$\mathrm{Tr}(\frac{I\pm Q}{2}\psi 〉〈\psi ).$

Next stabilizes |ψ> and anti-commutativity or P,Q to check the following equalities:

$〈\psi \frac{I+Q}{2}\psi 〉=〈\psi P\frac{I+Q}{2}P\psi 〉=〈\psi \frac{I+\mathrm{PQP}}{2}\psi 〉=〈\psi \frac{I-Q}{2}\psi 〉$

One can see that when the measurement outcome is +1, the state is transformed according to (3). Next check that this is again the case when the measurement outcome is −1 and apply correction P.

TABLE 4
Program for MeasurePlusOne
operation MeasurePlusOne(Q/P)
| ~ Assert: measuring P must always result in +1 ~
| r ← MeasureObservable(Q) # a is 0 if measured +1, and a is 1 if
measured −1
| Pr # Applies P if measurement result is 1 and does nothing otherwise

If the measurement outcome was −1, one can apply correction P and the state becomes:

$P\frac{I-Q}{\sqrt{2}}\psi 〉=\frac{I+Q}{\sqrt{2}}P\psi 〉=\frac{I+Q}{\sqrt{2}}\psi 〉$

In the above, the anti-commutativity of P, Q was used and the fact that P stabilizes |ψ. Finally, one can note that (I+Q)|ψ−(I+QP)|ψ and use the fact that for any matrix A that squares to minus identity exp(φA)=I cos(φ)+A sin(φ).

It has been shown that under the conditions of Proposition 4.2 a measurement with classical feedback is equivalent to a unitary transformation. This is because QP is anti-hermitian matrix and exp

$\left(\frac{\pi }{4}\mathrm{QP}\right)$

is a unitary. Note that unitary operation performed includes pauli P. Even if Q acts only on a couple qubits, the result of operation can be equivalent to a unitary on big number of qubits. This happens when contraint P involves large number of qubits.

The above discussion motivates the introduction of operation MeasurePlusOne(Q/P) (see Table 4). It performs operation given by Equation (3), given the state to which it is applied stabilized by P. In other words, operation MeasurePlusOne always projects the state onto +1 eigensubspace of Q. One can call P a constraint on the state.

Now it is shown how MeasurePlusOne can be used to perform fanout gate.

Proposition 4.3 (Low depth fanout). Let (V, E) be a tree. Vertexes of the tree correspond to qubits. All qubits except the root of the tree are in |+ state. One can only apply the following operations:

• • measure observable Z⊗Z on qubits connected by an edge,
  • apply Pauli X to any of the qubits.

TABLE 5
Program for fanout gate
(α|0   + β|1   ) ⊗|+   ⊗n−1   α|0   ⊗n + β|1   ⊗n
# Input: V is the set of qubits, vertexes of a tree, E is the set of tree edges.
#| | | | All qubits except the root of the tree are in a plus state
# Effect: Fanout gate is performed from the root to all qubits
operation Fanout1(V,E) # Concise version of the fanout operation
used in the proof
| Let (V′,E′) be a tree that is the result of removing the root from (V,E)
| Let r be a root of (V,E) and (r,r′) be an edge
| CatStatePrep(V′,E′,r′) # Prepare the cat stats on the vertexes V′,
see Table 3
| | Let m be the result of measuring observable Z ⊗ Z between qubits
r and r′
| if m = −1 then
| | Apply Pauli X gates to all the qubits except the root of the tree
operation Fanout(V,E) # Depth optimized version of Fanout operation
| foreach color c of the tree # number of colors is the largest vertex
degree + 1
| | foreach edge e = (u,v) of color c # body of this loop can be done
in depth 1
| | | Measure observable Z ⊗ Z on qubits u and v
| | | Label edge e by the measurement outcome
| | | Use label 0, when the outcome is +1 and label 1 otherwise
| Let r be a root of (V,E) and (r,r′) be an edge
| Assign vertex r′ label 0, assign other vertexes label 0 or 1
| | such that for every edge e=(u,v)
| | label(e) = label(u) ⊕ label(v). # this can be done using tree traversal
| if label(r,r′) = 1, then
| | apply x   x ⊕ 1 to labels of all vertexes
| foreach vertex v except r # body of this loop can be done in depth 1
| | if label (v) = 1 then apply X to qubit v

The fanout gate from the root to all the qubits can be performed using |E|=|V|−1 of Z⊗Z measurements, in depth equal to the largest vertex degree. In addition, one requires at most |V|−1 Pauli X operations performed all in parallel. The pseudo-code for fanout gate is given in Table 5.

Proof. The correctness of operation Fanout 1 in Table 5 is first shown. Next, it is shown that it is equivalent to operation Fanout described on the same table. The claim of the proposition regarding depth of Z⊗Z measurements follows from the fact that the number of colors in the edge coloring of the tree is equal to the maximal vertex degree plus one.

Let state of the root vertex be α|0+β|1. According to Proposition 4.2, the last three lines of operation Fanout 1 on Table 4 deterministically project on +1 eigenspace of Z_rZ_r′. This is because cat state is stabilized by the product of X over all non-root vertexes of the tree and this product anti-commutes with Z_rZ_r′. Therefore after last three lines of Fanout 1 the state of all qubits becomes:

${{{\frac{I+Z_1Z_2}{\sqrt{2}}(\alpha 0〉+\beta 1〉)\otimes {(0〉}^{\otimes n}+1〉}^{\otimes n})/\sqrt{2}=\alpha 0〉}^{\otimes n}+\beta 1〉}^{\otimes n}$

This is because projector (I+Z₁Z₂)/2 selects computational basis states with first two bits equal:

(I−Z₁Z₂)|0|0^⊗n=2|0|0^⊗n, (I+Z₁Z₂)|0|1^⊗n=0.

Next, a check is made that the operations Fanout and Fanout 1 on Table 5 are equivalent. First, one can inline CatStatePrep. Next, one can observe that there is no X correction performed on vertex r′ before measuring Z_rZ_r′. Therefore measurement Z_rZ_r′ can be performed together with all other measurements. Finally, X corrections applied in the end of CatStatePrep are combined with application of the X corrections in the end of Fanout 1 operation.

Next, a description is provided as to how to use the fanout gate to perform multiple target Controlled-Z. One can start with the case that is more suitable for the architecture with native Controlled-Z gates.

Proposition 4.4 (Low depth multiple target Controlled-Z). Let (V,E) be a tree. Vertexes of the tree correspond to qubits. Qubits that are not tree leaves are in a plus state. Measurements of observable Z⊗Z and Controlled-Z gates can only be applied to qubits connected by an edge. Programs given on Table 6 perform multiple target Controlled-Z gate with tree root being control and the rest of the leaves being targets. The rest of the tree vertices are returned back to plus state.

The depth of joint measurements is at most the largest vertex degree. The depth of Controlled-Z gates is at most the largest vertex degree. The total number of joint measurements and Controlled-Z operations applied equals to the total number of edges. The depth of X measurements is one.

TABLE 5
Program for multi-target Controlled Z gate
# Input: V is the set of qubits, vertexes of a tree, E is the set of tree edges.
#| | | | Qubits with corresponding vertex degree >1 are all is the plus state.
# Effect: Multi-target controlled Z gate is performed with root of the tree
#being a control and the rest of the leaves being targets.
#The rest of the vertexes (the ones with degree > 1) are returned
#back to a plus state.
operation MultipleTargetControlledZ1(V,E) # Concise version used
in a proof
| Let (V′,E′) be a tree that is the result of removing all leaves
except the root
# from (V,E)
| Fanout (V′,E′) # Fanout gate from the root to the rest of the tree,
see Table 4
| foreach leave v of (V,E) except the root
| | Let (v,v′) be an edge in E
| | ControlledZ(v,v′)
| Let r be the root of V and V′
| foreach vertex v of (V′,E′) except the root
| | MeasurePlusOne(Xv/ZvZr)
operation MultipleTargetControlledZ(V,E) # Depth optimized version
| Let (V′,E′) be a tree that is the result of removing all leaves except
the root
| from (V,E)
| Fanout(V′,E′) # Fanout gate from the root to the rest of the tree,
see Table 5
| | foreach leave v of (V,E) except the root
| | Let (v,v′) be an edge in E
| | ControlledZ(v,v′)
| Let r be the root of V and V′
| foreach vertex v of (V′,E′) except the root # can be done in depth 1
| | Measure X on qubit v, label v with zero if measured +1 and with
1 otherwise
| Label root with the parity of all leaves except the root
| foreach vertex v of (V′,E′)
| | if label(v) is 1 then Apply Z to v

Proof. It is first shown that program MultipleTargetControlledZ1 on Table 6 performs multiple target, Controlled-Z gate and satisfies required postcondition. Next, it, is shown that, the program is equivalent to MultipleTargetControlledZ. Finally, the depth of the operations performed in MultipleTargetControlledZ are counted.

Recall that on computational basis states multiple-target Controlled-Z gate acts as following:

$c,t_1,\dots ,t_n〉=\underset{k=1}{\prod ^n}\mathrm{Controlled}\text{-}Z_{c,t_k}c,t_1,\dots ,t_n〉={\left(-1\right)}^{c\left(t_1\oplus \dots \oplus t_n\right)}c,t_1,\dots ,t_n〉$

Above the first qubit is control and the rest are targets. In this case, control and targets are leaves of the tree. One also has, say m, other qubits that are not leaves of the tree. Using fanout operation, the state transforms as:

|c, t₁, . . . , t_n⊗|+^⊗m_Fanout |c, t₁, . . . , t_n⊗|c^⊗m

After the first foreach loop the state becomes:

(−1)^{c((t3+ . . . +tm)}|c, t₁, . . . , t_u⊗|c^⊗m   (4)

This is because Controlled-Z gates are performed between each of the target qubits and some qubit that is not a leaf of the tree and is in state |c>. Note that the above state (4) is −1 eigenstate of all Z_rZ_v operators, where r is a tree root and control qubit and v are non-leaf qubits. For this reason, one can use MeasurePlusOne operations to set all non-leaf qubits back to plus state. It is important to note that setting one of the non-leaf qubits to plus state does not violate Z_rZ_v constraints on other qubits and therefore this can be done in parallel.

To obtain MultipleTargetControlledZ program, one can inline all calls to MeasurePlusOne. Next one can observe that all measurements can be performed first and the correction can be performed afterwards. As shown below, one can also collect together all the corrections applied to the root vertex so the correction can be applied once.

To count, the depth of Z⊗Z measurements, one can observe that, they are all performed within Fanout operation and the larges vertex degree of (V′, E′) is at most largest vertex degree of (V, E). The depth of Controlled-Z operations performed is at most number of edges that share a vertex that is the largest degree of a vertex.

The rest of this section is devoted to the architectures with two qubit measurements only. First recall how to perform Controlled-Z gate in this architectures using one extra qubit. It is convenient to use MeasurePlusOne(Q/P) to concisely express this result. This result will also help one to get the insight needed for multiple target Controlled-Z.

Proposition 4.5. Consider three qubits a, b, c, with qubit a in |+ state, then the operation:

operation ControlledZbyMeasurement(c,t,a)
| MeasurePlusOne (ZaZt/Xa)
| Ha
| MeasurePlusOne(ZaZc/ZtXa)
| MeasurePlusOne(Xa/ZaZc)

performs Controlled-Z gates between qubits t, c and returns qubit a to |+ state.

Proof. Let one first check that ail the MeasurePlusOne can be applied. The qubit a is in |+, therefore the input state is stabilized by X_a. After the first step, as the result of the measurement, the overall state commutes with Z_bZ_a. After applying the Hadamard to the second qubit, the state commutes with H_aZ_bZ_aH_a^† which is exactly Z_tX_a. After the third step, the state commutes with Z_aZ_c as required on the step 4.

Now it will be shown that the Controlled-Z gate was indeed performed. It is sufficient to consider the case when all three qubits are in a tensor product state. Suppose the qubit t is in state α_t|0>+β_t|1). After Step 1, the state of the qubits t,a becomes:

α_t|00+β_t|11

After Step 2 it is (up to normalization by √{square root over (2)}):

α_i|00+α_t|01+β_t|10−β_t|11

Suppose qubit c is in state α_c|0+β_c|1, then after Step 3, the state of all three qubits becomes:

α_tα_c|000+α_tβ_c|011−β_tα_c|100>−β_tβ_c|111.

Finally, measuring X_a transform the state into

α_tα_c|0+0+α_tβ_c|0+1−β_tα_c|1+0−β_tβ_c|+1.

One can see that the state of the second qubit is |+ and the joint state of the first and the third qubits is

α_tα_c|00−α_tβ_c|01+β_tα_c|10−β_tβ_c|11=CZ_tc((α_t|0+β_t|1)⊗(α_t|0+β_c|1)).

Let one compare above program for Controlled-Z via measurement to version of MultipleTargetControlledZ operation applied to a tree with three vertexes c, t, a and edges (c, a) and (a, t):

MeasurePlusOne (ZaZt/Xa) # Fanout call corresponds to one operation
Controlled-Za,c
MeasurePlusOne(Xa/ZaZt)

The difference is that Hadamard followed by MeasurePlusOne(Z_aZ_t/Z_rX_a) are in place of the call to Controlled-Z. It turns out that they perform a unitary similar to Controlled-Z.

Proposition 4.6. The following two operations H₂; MeasurePlusOne(Z₂Z₁/Z₁X₂) map computational basis states |aab> to (−1)^ab|abb) for a, b zero or one.

Proof Applying Hadamard gate transforms input state into:

$a〉\otimes \frac{0〉+{\left(-1\right)}^a1〉}{\sqrt{2}}\otimes b$

The result of MeasurePlusOne(Z₃Z₂/Z₁X₂) is:

$\frac{I+Z_2Z_3}{2}a〉\otimes (0〉+{\left(-1\right)}^a1〉)\otimes b〉={\left(-1\right)}^{\mathrm{ab}}\mathrm{abb}〉.$

This is because (I+Z₂Z₃)/2 projects on the span of |00, |11.

Using this operation, one can construct multi-target Controlled-Z gate that uses only joint measurements and single qubit operations.

TABLE 7
Program for Multi-Target Controlled Z Gate Via Measurement
# Input: V is the set of qubits, vertexes of a tree, E is the set of tree edges.
# | | | | Qubits with corresponding vertex degree > 1 are all in the
plus state.
# | | | | Two non-root leaves in (V,E) are never connected to the
same vertex.
#Effect; Multi-target controlled 2 gate is performed with root of the tree
# | | | | being a control and the rest of the leaves being targets.
# | | | | The rest of the vertexes (the ones with degree > 1) are
returned back
# | | | | to a plus state.
operation MultipleTargetControlledZMeasure(V,E)
| Let r be a root of V
| Let (V′,E′) be a tree that is the result of removing all leaves r from (V,E)
| Fanout(V′,E′) # Fanout gate from the root to the rest of the tree,
see Table 5
| foreach leave v of (V,E) except the root # this loop has measurement
depth 1
| | Let (v,v′) be an edge in E
| | Hv′
| | MeasurePlusOne(ZvZv′/ZrXv′)
| Two loops below can be performed in parallel in measurement depth 1
| foreach leaf v′ of (V′,E′) except the root
| | Let (v,v′) be an edge in E
| | MeasurePlusOne(Xv′/ZvZv′)
| foreach vertex v of (V′,E′) except the leaves
| | MeasurePlusOne(Xv/ZvZr)

Proposition 4.7 (Low depth multiple target Controlled-Z by measurement). Let (V,E) be a tree such that all it leaves except the root are connected to a vertex of degree two. In other words, non of these leaves connected to the same vertex. Vertexes correspond to qubits. All non-leaf qubits are in a plus state. The program. Multiple TargetControlledZMeasure in Table 7 performs multiple target controlled Z gate with root being control and the rest of the leaves being targets. The measurement depth is at most the largest vertex degree plus two.

Proof. Consider how MultipleTargetControlledZMeasure operation acts on inputs from computational basis. For each non-root leaf, in other words a target of control operations there is a unique vertex connected to it in a plus state. The state of such a pair in the beginning of the computation is |t₁|−. One can order qubits in the following way. First goes the control qubit, next pairs corresponding to each target qubit and the qubit connected to it, next the rest of the qubits. The state of all the qubits in the beginning of the computation is:

|c|t₁|+ . . . |t_n|+|+^⊗m.

After applying the fanout operation, the state becomes:

|c|t₁|c . . . |t_n|c|c^⊗m.

After the first foreach loop, according to Proposition 4.6, the state of the qubits becomes:

(−1)^{c(ci+ . . . +cn)}|c|t₁|t₁ . . . |t_n|t_n|c^⊗m.

Now one can see that all the constraints in MeasurePlusOne operations in the last two for each loops are satisfied by the state above. States |t_k|t_k satisfy Z_vZ_v′ constraint appearing in the second foreach loop and state |c|c satisfy constraints Z_vZ_r appearing in the third foreach loop. After applying last two foreach loops the state of the qubits becomes

(−1)^{c(c1+ . . . +cn)}|c|t₁|+ . . . |t_n|+|+^⊗m.

as required.

The last two foreach loops can be performed in parallel because they involve different, qubits. Each of foreach loops has measurement depth one. Therefore the overall measurement, depth is the measurement depth of fanout operation plus two.

5. Embedding a Tree into 2D Grid of Qubits

All data qubits should be connected to an interface qubit with a path of ancillas. Thus, only a fraction of all qubits can be data qubits, with the rest being used as ancillas for connectivity. Given a rectangular field of qubits with a nearest neighbor (each internal qubit has 4 neighbors) architecture, the most data qubits one can get is ⅔of the total number of qubits. This is because an ancilla (barring the edges) can have at most 2 data qubits attached to it with the other two connections being used up to attach to two other ancillas.

An ideal field configuration would be a 3×N grid of qubits where the center row consists of ancillas and top and bottom rows are data qubits. This would achieve a perfect 2/3 ratio of data qubits to total qubits.

Assuming N×N grid of qubits, the best configuration to achieve the highest data qubits ratio is a comb, where the second column and qubits 2 to N in every third row of qubits, starting from row #2, are ancillas. The first row is reserved for interface qubits, and the rest are data qubits. For the calculations here, interface qubits to be data qubits are counted. In this configuration the ratio of data qubits to total qubits is (2N−1)/3N, or 2/3−1/3N which is very close to 2/3.

The physical qubits have some probability of failure. Some of the qubits in a perfect rectangular grid may be dead (unsuitable for use). This not only decreases the number of available qubits, but also breaks connectivity between the remaining ones. For example, a path of ancillas may have a dead qubit in it, severing part of the line and breaking connectivity of the corresponding data qubits to the interface qubit.

An algorithm to create an optimal layout of qubits given an irregular qubit graph is desirable. However, such an algorithm will require non-polynomial execution time, making it impractical. In accordance with the disclosed technology, a heuristic-based algorithm is provided that is close to optimal.

Given a starting layout of a comb described above, the algorithm determines pieces of the graph disconnected from the interface qubits and tries to reconnect them enabling as many data qubits as possible. Starting from the interface qubit, one can mark continuous horizontal ancilla line segments as powered if they are connected to the interface. For each powered segment, one can queue all possible vertical routes that can extend from it. The routes that start at the ends of the segments go into the high-priority queue, and the rest into normal priority queue.

Then, for each queued route (starting with high priority ones), one can determine if this route connects a previously unpowered ancilla segment, and if yes, accept the route, mark ancilla segment as powered, and add more potential routes starting from the newly powered segment to the queues. Each route that was accepted, converts two data qubits into ancillas. This continues until the queues are empty. Routes at the ends of segments are preferable, because they provide power to one or two additional data qubits (next to the dead ancilla), while routes spawning from midsegments do not.

Each dead data qubit causes a loss of one data qubit in our ratio. Each dead ancilla causes two data qubits to be unpowered, and an ancilla segment to be detached. Reattaching the ancilla segment requires use of two data qubits and is likely to power back one of the disconnected qubits. Thus, each dead ancilla is likely to result in a loss of 3 data qubits.

6. Further Embodiments of Exemplary Multi-Target CNOT Gates

This section discloses further details for implementing multi-target CNOT gates in Majorana architectures as can be used in embodiments of the disclosed technology.

6.1. Introduction. In a measurement based architecture such as a lattice of Majorana qubits, a CNOT gate can implemented by a sequence of four measurements using an ancilla qubit. Applying this circuit sequentially, one can implement a mutli-target CNOT gate with m targets in time linear in m, in depth 4m. In this section, a constant depth implementation for a multi-target CNOT gate based on single-qubit, and two-qubit measurements is disclosed. The circuit has depth five in term of the number of levels of measurements (three two-qubit measurements and two single-qubit measurement). It requires one ancilla per target. This implementation is well suited for a grid of Majorana qubits.

The following circuits are made with single-qubit Pauli measurements and two-qubit Pauli measurements. Each measurement M is a followed by a Clifford update U(P) which means that the Clifford operation P is a classically controlled gate that is applied only if the outcome of the measurement M is 1. The update U(P) is represented in the circuit as a box identical to the preceding measurement box for M but it does not necessarily acts only on the support of M. We are particularly interested in the context of Majorana qubits. Then, single-qubit Clifford operations can be realized without any physical action on the qubits by a change of frame. In particular all Clifford updates are free. This is why the depth is considered as the number of levels of measurement.

6.2. CNOT gate by measurement. In this subsection, recall the implementation of a CNOT gate using single-qubit and two-qubit measurements and an ancilla qubit. FIG. 1 is a schematic block diagram 100 that represents the circuit realizing a CNOT gate between the top qubit and the bottom qubit. The middle qubit is an ancilla require for the CNOT gate. More specifically, the blue gates prepare the ancilla qubit, and the purple gates entangle it with the control qubit and the red gates act on the ancilla and the target qubits.

Denote by |ψ−α|0+β|1 the contol qubit (qubit 1) and let |φ−α′|0+β′|1) be the target qubit (qubit 3). One can check that the circuit of FIG. 1 realizes a CNOT gate. In order to simplify the calculation, one can show that without the II-conjugation on the last qubit, the circuit realizes the CZ-gate. Adding the two H gate provides the CNOT gate.

• • The first measurement M_X, followed by the update U(Z₂) in case of outcome 1, prepares the ancilla qubit in the state |+. The combined state of qubits 1 and 2 is then

|ψ₀=α|00+α|01+β|10+β|11.

• • Measuring Z₁Z₂ with outcome 0, projects the state of qubit 1 and 2 onto the state

|ψ₁−α|00+β|11.

• • If the outcome 1 is obtained, one gets the state α|01+β|10 that is mapped onto |ψ₁ by the update U(X₂).
  • The gate H₂ leads to |ψ₂=α|00+α|01+β|10+(−1)β|11 on the first two qubits, and (without considering H₃) the three-qubits state is then

φψ₂=αα′|000+αα′|010+βα′|100+(−1)βα′|110+αβ′|001+αβ′|011+ββ′|101+(−1)ββ′|111

• • If the outcome of M_Z2Z3 is 0, then the post-measurement state is

|ψ₃=αα′|000+βα′|100+αβ′|011z,65 +(−1)ββ′|111

If the outcome 1 is measured, the state after measurement is then

αα′|010+(−1)βα′|110+αβ′|001+ββ′|101

that one can map onto |ψ₃ by the update U(Z₁X₂).

• • Finally, get rid of the ancilla by measuring X. Assuming that the outcome is 0, one obtains the following state on qubit 1 and 3 after M_X.

|ψ₄=αα′|00+βα′|10+αβ′|01+(−1)ββ′|11

• • We recognize the control-Z gate applied to |ψ> and |φ>. If the outcome of M_X is 1, one gets the state

αα′|00+βα′|10+(−1)αβ′|01+ββ′|11.

• • A correction U(Z₃) is required to map it onto |ψ₄. In the CNOT gate, this correction is conjugated by H and becomes U(X₃).

This proves that the circuit of FIG. 1 realizes the CNOT gate.

6.3. Multi-target CNOT gate. A mutli-target CNOT gate applies a X gate to a set of m qubits g₁, . . . , q_m, controlled on the state of a unique control qubit q₀. Naively, it can be realized by a sequence of m CNOT gates, CNOT(q₀, q_i) for i=1, . . . , m. The depth of the multi-target CNOT gate is therefore at most linear in the number of targets. In this section, it is shown how to realize a multi-target gate in constant depth using one ancilla qubit for each target. While the same ancilla qubit can be reused for the sequential implementation of m CNOT gates, m ancillas are consumed for a, constant depth implementation.

The transformation of the sequential implementation used to reduce the depth of the circuit to a constant is shown in FIGS. 2-4 in the case of a two-targets CNOT gate.

FIG. 2 is a schematic block diagram 200 showing an example of providing a multi-target CNOT gate by measurement. In particular, block diagram 200 illustrates an example sequential application of the CNOT circuit. FIG. 3 is a schematic block diagram 300 illustrating a modified version of block diagram 200 after moving the purple measurement M_Z1Z4 to the left to parallelize the final red block between the ancillas and the targets. FIG. 4 is a schematic block diagram 400 illustrating further modifying the initial measurements to parallelize the purple block between the control qubit and the ancillas (The effect of this parallelization appears only when more than two targets are present).

As illustrated, this transformation can be performed in two steps. First, one moves the join measurement M_ZZ between the control qubit and the ancillas to the past. This allows one to parallelize the final block of the circuit acting on the ancillas and the targets. In the second step, one can replace the m measurements M_Zq0Zqi involving the control qubit by a single measurement involving the control qubit q₀ and m−1 measurements on the ancilla qubits that can be realized in depth two.

The general circuit, represented in schematic block diagram 500 of FIG. 5 for four targets works as follows:

• • (i) [Ancilla preparation (blue)] Prepare a m-qubits cat state |0 . . . 0+|1 . . . 1 over the m ancilla qubits α₁, . . . , α_m by measuring Z_α1Z_α2, Z_α2, Z_α2Z_α3, . . . , Z_αm−1Z_αm. This can be done in two layers of measurements (followed by updates).
  • (ii) [Control block (purple)] Entangle the ancillas with the control qubit q₀ by measurement of Z_q0Z_{di 1}. The update U(X_α1X_α2 . . . X_αm) is applied in case of non-zero outcome.
  • (iii) [Target block (red)] Apply the target block of the standard CNOT by measurement in parallel to all the targets.

In order to check that this circuit realizes the multi-target CNOT as claimed, it suffices to check that the circuit maps any Pauli operators onto the same Pauli operator as the multi-target CNOT gate. Given a Pauli matrix P, denote by P_C the Pauli operator acting as P on the control qubit and acting trivially on all other qubits. Similarly P_αi acts on the i-th ancilla and P_T, on the i-th target. The multi-target CNOT gate is fully characterized by its action on Pauli operators as follows:

$X_C\mapsto X_C\prod _{i=1}^mX_{T_i}$ $Z_C\mapsto Z_C$ $X_{T_i}\mapsto X_{T_i}$ $Z_{T_i}\mapsto Z_{T_i}Z_C$

One can easily check that the circuit satisfies these identities by propagating these Pauli operators through the circuit. For instance, one can propagate the operation X_C through the circuit in FIG. 6. In particular, FIG. 6 is a schematic block diagram 600 of a circuit that propagates the Pauli operator X_C through the circuit. One can check that the circuit maps X_C onto X_C Π_i=1^m X_Ti as expected

This proves that it implements the desired multi-target CNOT operation.

6.4. Two-dimensional layout. This multi-target CNOT gate can be implemented in a grid of Majorana qubits where all single-qubit measurement M_X, M_Z are available, as well as two-qubit measurement M_P1P2 of Pauli operators P₁P₂ between neighbors qubits.

For instance, one can consider a line of m ancilla qubits where the cat state is prepared, connected to the control qubit through one of its endpoints. Each ancilla can reach a target qubit placed directly below it. This allows for a local implementation of the mutli-target CNOT gate described in this note. FIG. 7 is a block diagram 700 representing the planar layout for the multi-target CNOT gate of FIG. 6.

7. Example Embodiments

In this section, example methods for performing aspects of the disclosed embodiments are disclosed. The particular embodiments described should not be construed as limiting, as the disclosed method acts can be performed alone, in different orders, or at least partially simultaneously with one another. Further, any of the disclosed methods or method acts can be performed with any other methods or method acts disclosed herein.

FIG. 8 is an example method for performing a layout reduction technique for fault-tolerant, quantum computing in accordance with an embodiment of the disclosed technology. In particular embodiments, the method is performed by one or more classical computing devices, at least some of which are in a configuration that can operate a quantum computer.

At 810, a layout of an arbitrary quantum circuit is reduced to a layout of exponents of a multiple qubit Pauli matrix and measurements of a multiple qubit Pauli matrix.

At 812, a quantum computer is configured to implement the reduced layout.

In particular implementations, qubits of the quantum computer comprise data qubits, interface qubits, and ancilla qubits. In further implementations, a graph of qubit connectivity satisfies a condition of providing an ancilla-path from one or more data qubits to the interface qubits.

FIG. 9 is an example method for performing a layout technique for fault-tolerant quantum computing in accordance with an embodiment of the disclosed technology. In particular embodiments, the method is performed by one or more classical computing devices, at least some of which are in a configuration that can operate a quantum computer.

At 910, qubits are marked as one of a data, interface, or ancilla qubit for a 2D nearest neighbor graph of qubit connectivity.

At 912, an ancilla-path is provided from a respective data qubit to a respective interface qubit.

At 914, a quantum computer is configured to implement the ancilla-path from a respective data qubit to a respective interface qubit.

In certain implementations, the method accounts for and avoids any broken qubits and satisfies a condition of providing an ancilla-path from a data qubit to the interface qubits.

Any of the methods described above can be performed in a system, comprising a quantum computing device; and one or more classical-computing devices, at least some of the one or more classical computing devices being programmed to perform any of the disclosed methods.

Additionally, any of the methods described above can be implemented as one or more classical-computer-readable-media storing classical-computer-executable instructions, which when executed by a classical computer cause the classical computer to perform any of the disclosed methods.

Further embodiments comprise, a quantum circuit configured to apply an exponent of a multiple qubit Pauli matrix and measure a multiple qubit Pauli matrix. In some implementations, an ancilla-path is provided from data qubits to the interface qubits. In further implementations, the quantum circuit has a depth not depending on the number of vertexes. In some implementations, the quantum circuit uses single or low-depth multiple-target CNOT gates as a sub-circuits.

Some embodiments, comprise a quantum circuit configured to (a) provide a multi-target CNOT gate using a single-qubit and two-qubit Pauli measurements and single qubit Clifford gates; or (b) provide a multi-target CNOT gate using a single-qubit, Pauli measurements, single qubit Clifford gates and Controlled-Z gates. In some implementations, the quantum circuit provides a multi-target CNOT gate using a single-qubit and two-qubit Pauli measurements and single qubit Clifford gates, wherein the quantum circuit works with qubits for which a graph of qubit connectivity satisfies a condition of providing an ancilla-path from a target qubit to the control qubit. In further implementations, the quantum circuit provides a multi-target CNOT gate using a single-qubit and two-qubit Pauli measurements and single qubit Clifford gates, wherein the quantum circuit, has a depth not depending on the number of vertexes. In some implementations, the quantum circuit is configured to provide a multi-target CNOT gate using a single-qubit, Pauli measurements, single qubit Clifford gates and Controlled-Z gates, and wherein the quantum circuit works with qubits for which graph of qubit connectivity satisfies a condition of providing an ancilla-path from a target qubit to the control qubit. In further implementations, the quantum circuit is configured to provide a multi-target CNOT gate using a single-qubit, Pauli measurements, single qubit Clifford gates and Controlled-Z gates, wherein the quantum circuit has a depth not depending on the number of vertexes.

A further embodiment is a method that comprises implementing a product of exponents of commuting multiple-qubit Pauli matrices in low depth where non-clifford gates can be executed in parallel.

An additional embodiment is a quantum circuit for providing a multi-target CNOT gate using a single-qubit and two-qubit Pauli measurements. In some implementations, the quantum circuit further comprises a 2-d nearest neighbor architecture. In certain implementations, the quantum circuit comprises a 3-N grid of qubits with a center row or center column of data qubits, each respective data qubit further being directly connected to two ancilla qubits. In some implementations, the quantum circuit comprises a comb architecture with a center row or center column of data qubits, each respective data qubit further being directly connected to one ancilla qubits to thereby form the comb architecture. In certain implementations, the quantum circuit is a low-constant-depth quantum circuit. In some implementations, the quantum circuit has a depth equal to a largest vertex degree of a tree describing the quantum circuit.

A further embodiment comprises a quantum circuit for computing an exponent of a multiple qubit Pauli matrix. In some implementations, the multiple qubit Pauli matrix is a two-qubit Pauli matrix. In certain implementations, the quantum circuit is a low-constant-depth quantum circuit. In further implementations, the quantum circuit has a depth equal to a largest vertex degree of a tree describing the quantum circuit.

An additional embodiment is a method comprising: reducing a layout of an arbitrary quantum circuit to a layout of exponents of a multiple qubit Pauli matrix.

A further embodiment is a method comprising implementing a product of exponents of commuting multiple-qubit Pauli matrices in low depth where non-clifford gates can be executed in parallel.

An additional embodiment is a computer-implemented method that builds a data/ancilla qubit layout for a given graph of qubit connectivity and satisfies a condition of providing an ancilla-path from every data qubit to the interface qubits. In some implementations, the method accounts for and avoids any broken qubits.

Again, any of the methods described above can be implemented as one or more classical-computer-readable-media storing classical-computer-executable instructions, which when executed by a classical computer cause the classical computer to perform any of the disclosed methods.

8. Example Computing Environments

FIG. 10 illustrates a generalized example of a suitable classical computing environment 1000 in which several of the described embodiments can be implemented. The computing environment 1000 is not, intended to suggest any limitation as to the scope of use or functionality of the disclosed technology, as the techniques and tools described herein can be implemented in diverse general-purpose or special-purpose environments that have computing hardware.

With reference to FIG. 10, the computing environment 1000 includes at least one processing device 1010 and memory 1020. In FIG. 10, this most basic configuration 1030 is included within a dashed line. The processing device 1010 (e.g., a CPU or microprocessor) executes computer-executable instructions. In a multi-processing system, multiple processing devices execute computer-executable instructions to increase processing power. The memory 1020 may be volatile memory (e.g., registers, cache, RAM, DRAM, SRAM), non-volatile memory (e.g., ROM, EEPROM, flash memory), or some combination of the two. The memory 1020 stores software 1080 implementing tools for performing any of the layout techniques for fault-tolerant quantum computers disclosed herein, using a classical computer and/or quantum computer. For example, the memory 1020 can store software for controlling a quantum circuit to implement an embodiment of the disclosed approximation technique. The memory 1020 can also store software 1080 for synthesizing, generating (or compiling), and/or controlling quantum circuits as described herein.

The computing environment can have additional features. For example, the computing environment 1000 includes storage 1040, one or more input devices 1050, one or more output devices 1060, and one or more communication connections 1070. An interconnection mechanism (not shown), such as a bus, controller, or network, interconnects the components of the computing environment 1000. Typically, operating system software (not shown) provides an operating environment for other software executing in the computing environment 1000, and coordinates activities of the components of the computing environment 1000.

The storage 1040 can be removable or non-removable, and includes one or more magnetic disks (e.g., hard drives), solid state drives (e.g., flash drives), magnetic tapes or cassettes, CD-ROMs, DVDs, or any other tangible non-volatile storage medium which can be used to store information and which can be accessed within the computing environment 1000. The storage 1040 can also store instructions for the software 1080 implementing tools for performing any of the layout techniques for fault-tolerant quantum computers disclosed herein using a classical computer and/or quantum computer. For example, the memory 1020 can store software for controlling a quantum circuit to implement an embodiment of the disclosed layout techniques. The storage 1040 can also store instructions for the software 1080 for synthesizing, generating (or compiling), and/or controlling quantum circuits as described herein.

The input device(s) 1050 can be a touch input device such as a keyboard, touchscreen, mouse, pen, trackball, a voice input device, a scanning device, or another device that provides input to the computing environment 1000. The output device(s) 1060 can be a display device (e.g., a computer monitor, laptop display, smartphone display, tablet display, netbook display, or touchscreen), printer, speaker, or another device that provides output from the computing environment 1000.

The communication connection(s) 1070 enable communication over a communication medium to another computing entity. The communication medium conveys information such as computer-executable instructions or other data in a modulated data signal. A modulated data signal is a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media include wired or wireless techniques implemented with an electrical, optical, RF, infrared, acoustic, or other carrier.

As noted, the various methods, quantum circuit control techniques, or compilation/synthesis techniques can be described in the general context of computer-readable instructions stored on one or more computer-readable media. Computer-readable media are any available media (e.g., memory or storage device) that can be accessed within or by a computing environment. Computer-readable media include tangible computer-readable memory or storage devices, such as memory 1020 and/or storage 1040, and do not include propagating carrier waves or signals per se (tangible computer-readable memory or storage devices do not include propagating carrier waves or signals per se).

Various embodiments of the methods disclosed herein can also be described in the general context of computer-executable instructions (such as those included in program modules) being executed in a computing environment by a processor. Generally, program modules include routines, programs, libraries, objects, classes, components, data structures, and so on, that, perform particular tasks or implement particular abstract data types. The functionality of the program modules may be combined or split between program modules as desired in various embodiments. Computer-executable instructions for program modules may be executed within a local or distributed computing environment.

An example of a possible network topology 1100 (e.g., a client-server network) for implementing a system according to the disclosed technology is depicted in FIG. 11. Networked computing device 1120 can be, for example, a computer running a browser or other software connected to a network 1112. The computing device 1120 can have a computer architecture as shown in FIG. 10 and discussed above. The computing device 1120 is not limited to a traditional personal computer but can comprise other computing hardware configured to connect to and communicate with a network 1112 (e.g., smart phones, laptop computers, tablet, computers, or other mobile computing devices, servers, network devices, dedicated devices, and the like). Further, the computing device 1120 can comprise an FPGA or other programmable logic device. In the illustrated embodiment, the computing device 1120 is configured to communicate with a computing device 1130 (e.g., a remote server, such as a server in a cloud computing environment) via a network 1112. In the illustrated embodiment, the computing device 1120 is configured to transmit input, data to the computing device 1130, and the computing device 1130 is configured to implement, a quantum circuit control technique according to any of the disclosed embodiments and/or a circuit generation or compilation/synthesis methods for generating qunatum circuits for use with any of the techniques disclosed herein. The computing device 1130 can output results to the computing device 1120. Any of the data received from the computing device 1130 can be stored or displayed on the computing device 1120 (e.g., displayed as data on a graphical user interface or web page at the computing devices 1120). In the illustrated embodiment, the illustrated network 1112 can be implemented as a Local Area Network (LAN) using wired networking (e.g., the Ethernet IEEE standard 802.3 or other appropriate standard) or wireless networking (e.g. one of the IEEE standards 802.11a, 802.11b, 802.11g, or 802.11n or other appropriate standard). Alternatively, at least part of the network 1112 can be the Internet or a similar public network and operate using an appropriate protocol (e.g., the HTTP protocol).

Another example of a possible network topology 1200 (e.g., a distributed computing environment) for implementing a system according to the disclosed technology is depicted in FIG. 12. Networked computing device 1220 can be, for example, a computer running a browser or other software connected to a network 1212. The computing device 1220 can have a computer architecture as shown in FIG. 10 and discussed above. In the illustrated embodiment, the computing device 1220 is configured to communicate with multiple computing devices 1230, 1231, 1232 (e.g., remote servers or other distributed computing devices, such as one or more servers in a cloud computing environment) via the network 1212. In the illustrated embodiment, each of the computing devices 1230, 1231, 1232 in the computing environment 1200 is used to perform at least a portion of a quantum circuit control technique according to any of the disclosed embodiments and/or a circuit generation or compilation/synthesis methods for generating quantum circuits for use with any of the techniques disclosed herein. In other words, the computing devices 1230, 1231, 1232 form a distributed computing environment in which the quantum circuit control and/or generation/compilation/synthesis processes are shared across multiple computing devices. The computing device 1220 is configured to transmit input data to the computing devices 1230, 1231, 1232, which are configured to distributively implement such as process, including performance of any of the disclosed methods or creation of any of the disclosed circuits, and to provide results to the computing device 1220. Any of the data received from the computing devices 1230, 1231, 1232 can be stored or displayed on the computing device 1220 (e.g., displayed as data on a graphical user interface or web page at the computing devices 1220). The illustrated network 1212 can be any of the networks discussed above with respect to FIG. 11.

With reference to FIG. 13, an exemplary system for implementing the disclosed technology includes computing environment 1300. In computing environment 1300, a compiled quantum computer circuit description (including quantum circuits generated by any of the disclosed layout techniques) can be used to program (or configure) one or more quantum processing units such that the quantum processing unit(s) implement the circuit, described by the quantum computer circuit, description.

The environment 1300 includes one or more quantum processing units 1302 and one or more readout device(s) 1308. The quantum processing unit(s) execute quantum circuits that are precompiled and described by the quantum computer circuit description. The quantum processing unit(s) can be one or more of, but are not limited to: (a) a superconducting quantum computer; (b) an ion trap quantum computer; (c) a fault-tolerant architecture for quantum computing; and/or (d) a topological quantum architecture (e.g., a topological quantum computing device using Majorana zero modes). The precompiled quantum circuits, including any of the disclosed circuits, can be sent into (or otherwise applied to) the quantum processing unit(s) via control lines 1306 at the control of quantum processor controller 1320. The quantum processor controller (QP controller) 1320 can operate in conjunction with a classical processor 1310 (e.g., having an architecture as described above with respect to FIG. 10) to implement the desired quantum computing process. In the illustrated example, the QP controller 1320 further implements the desired quantum computing process via one or more QP subcontrollers 1304 that are specially adapted to control a corresponding one of the quantum processor(s) 1302. For instance, in one example, the quantum controller 1320 facilitates implementation of the compiled quantum circuit by sending instructions to one or more memories (e.g., lower-temperature memories), which then pass the instructions to low-temperature control unit(s) (e.g., QP subcontroller(s) 1304) that transmit, for instance, pulse sequences representing the gates to the quantum processing unit(s) 1302 for implementation. In other examples, the QP controller(s) 1320 and QP subcontroller(s) 1304 operate to provide appropriate magnetic fields, encoded operations, or other such control signals to the quantum processor(s) to implement the operations of the compiled quantum computer circuit description. The quantum controlled s) can further interact with readout devices 1308 to help control and implement the desired quantum computing process (e.g., by reading or measuring out data results from the quantum processing units once available, etc.)

With reference to FIG. 13, compilation is the process of translating a high-level description of a quantum algorithm into a quantum computer circuit description comprising a sequence of quantum operations or gates, which can include the circuits as disclosed herein. The compilation can be performed by a compiler 1322 using a classical processor 1310 (e.g., as shown in FIG. 10) of the environment 1300 which loads the high-level description from memory or storage devices 1312 and stores the resulting quantum computer circuit description in the memory or storage devices 1312.

In other embodiments, compilation and/or verification can be performed remotely by a remote computer 1360 (e.g., a computer having a computing environment as described above with respect to FIG. 10) which stores the resulting quantum computer circuit description in one or more memory or storage devices 1362 and transmits the quantum computer circuit description to the computing environment 1300 for implementation in the quantum processing unit(s) 1302. Still further, the remote computer 1300 can store the high-level description in the memory or storage devices 1362 and transmit the high-level description to the computing environment 1300 for compilation and use with the quantum processor(s). In any of these scenarios, results from the computation performed by the quantum processor (s) can be communicated to the remote computer after and/or during the computation process. Still further, the remote computer can communicate with the QP controller(s) 1320 such that the quantum computing process (including any compilation, verification, and QP control procedures) can be remotely controlled by the remote computer 1360. In general, the remote computer 1360 communicates with the QP controller(s) 1320, compiler/synthesizer 1322, and/or verification tool 1323 via communication connections 1350.

In particular embodiments, the environment 1300 can be a cloud computing environment, which provides the quantum processing resources of the environment 1300 to one or more remote computers (such as remote computer 1360) over a suitable network (which can include the internet).

9. Concluding Remarks

Having described and illustrated the principles of the disclosed technology with reference to the illustrated embodiments, it will be recognized that the illustrated embodiments can be modified in arrangement and detail without departing from such principles. For instance, elements of the illustrated embodiments shown in software may be implemented in hardware and vice-versa. Also, the technologies from any example can be combined with the technologies described in any one or more of the other examples. It will be appreciated that procedures and functions such as those described with reference to the illustrated examples can be implemented in a single hardware or software module, or separate modules can be provided. The particular arrangements above are provided for convenient illustration, and other arrangements can be used.

Claims

1. A method performed by one or more classical computers, comprising: reducing a layout of an arbitrary quantum circuit to a layout of exponents of a multiple qubit Pauli matrix and measurements of a multiple qubit Pauli matrix; andconfiguring a quantum computer to implement the reduced layout.

2. A method of claim 1, wherein qubits of the quantum computer comprise data qubits, interface qubits, and ancilla qubits.

3. A method of claim 2, where a graph of qubit connectivity satisfies a condition of providing an ancilla-path from one or more data qubits to the interface qubits.

4. A system, comprising: a quantum computing device; andone or more classical-computing devices, at least some of the one or more classical computing devices being programmed to perform the method of claim 1.

5. One or more classical-computer-readable-media storing classical-computer-executable instructions, which when executed by a classical computer cause the classical computer to perform the method of claim 1.

6. A quantum circuit configured to apply an exponent of a multiple qubit Pauli matrix and measure a multiple qubit Pauli matrix.

7. The quantum circuit of claim 6, wherein an ancilla-path is provided from data qubits to the interface qubits.

8. The quantum circuit of claim 6, wherein the quantum circuit has a depth not depending on the number of vertexes.

9. The quantum circuit of claim 6, wherein the quantum circuit uses single or low-depth multiple-target CNOT gates as a sub-circuits.

10. A method performed by one or more classical computers, comprising: marking qubits as one of a data, interface, or ancilla qubit for a 2D nearest neighbor graph of qubit connectivity;providing an ancilla-path from a respective data qubit to a respective interface qubit; andconfiguring a quantum computer to implement the ancilla-path from a respective data qubit to a respective interface qubit.

11. The computer-implemented method of claim 10, wherein the method accounts for and avoids any broken qubits and satisfies a condition of providing an ancilla-path from a data qubit to the interface qubits.

12. A system, comprising: a quantum computing device; andone or more classical-computing devices, at least some of the one or more classical computing devices being programmed to perform the method of claim 10.

13. One or more classical-computer-readable-media storing classical-computer-executable instructions, which when executed by a classical computer cause the classical computer to perform the method of claim 10.

14. A quantum circuit configured to (a) provide a multi-target CNOT gate using a single-qubit and two-qubit Pauli measurements and single qubit Clifford gates; or (b) provide a multi-target CNOT gate using a single-qubit, Pauli measurements, single qubit, Clifford gates and Controlled-Z gates.

15. The quantum circuit of claim 14, wherein the quantum circuit provides a multi-target CNOT gate using a single-qubit and two-qubit Pauli measurements and single qubit Clifford gates, wherein the quantum circuit works with qubits for which a graph of qubit connectivity satisfies a condition of providing an ancilla-path from a target qubit to the control qubit.

16. The quantum circuit of claim 14, wherein the quantum circuit provides a multi-target CNOT gate using a single-qubit and two-qubit Pauli measurements and single qubit Clifford gates, wherein the quantum circuit has a depth not depending on the number of vertexes.

17. The quantum circuit of claim 14, wherein the quantum circuit is configured to provide a multi-target CNOT gate using a single-qubit, Pauli measurements, single qubit Clifford gates and Controlled-Z gates, and wherein the quantum circuit works with qubits for which graph of qubit connectivity satisfies a condition of providing an ancilla-path from a target qubit to the control qubit.

18. The quantum circuit of claim 14, wherein the quantum circuit is configured to provide a multi-target CNOT gate using a single-qubit, Pauli measurements, single qubit Clifford gates and Controlled-Z gates, wherein the quantum circuit has a depth not depending on the number of vertexes.