Abstract
Simulating quantum circuits using classical computers lets us analyse the inner workings of quantum algorithms. The most complete type of simulation, strong simulation, is believed to be generally inefficient. Nevertheless, several efficient strong simulation techniques are known for restricted families of quantum circuits and we develop an additional technique in this article. Further, we show that strong simulation algorithms perform another fundamental task: solving search problems. Efficient strong simulation techniques allow solutions to a class of search problems to be counted and found efficiently. This enhances the utility of strong simulation methods, known or yet to be discovered and extends the class of search problems known to be efficiently simulable. Relating strong simulation to search problems also bounds the computational power of efficiently strongly simulable circuits; if they could solve all problems in P this would imply that all problems in NP and #P could be solved in polynomial time.
Introduction
Ever since Shor famously showed that a quantum computer can factorise numbers superpolynomially quicker than the fastest known classical algorithm^{1}, researchers have sought methods to efficiently simulate quantum circuits using classical computers. This is partly to narrow down where the power of quantum computers may arise and partly to understand the operation of quantum algorithms. Simulation is typically divided into two types, weak and strong^{2,3}. Weak simulations sample an outcome of a measurement on a quantum circuit with the correct probability distribution. Strong simulations, which we focus on, go further, precisely calculating probabilities in this distribution.
The strong simulation of an arbitrary quantum circuit is widely believed to be inefficient, even using a quantum computer; in the language of computational complexity, it is #Phard^{2}. However several efficient methods are known for strong simulation using a classical computer, provided the process to be simulated is sufficiently restricted^{3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24}. For example, Gottesman showed that stabiliser circuits acting on computational basis states admit efficient strong simulation if measurements are restricted to that basis^{4,5,6,7}. Valiant demonstrated a similar result for circuits comprising matchgates^{8}. This was later related to free Fermion systems and generalised to Gaussian circuits^{9,10,11,12,13}. Further, utilising techniques for contracting tensor networks, Markov and Shi developed a method for efficiently simulating circuits composed of arbitrary gates arranged in a treelike geometry^{22}.
In this article we exploit that every strong simulation of a quantum circuit is represented by the contraction of a tensor network. We discuss how individual gates are represented by tensors and the pattern of connections between the tensors follows directly from the circuit. Contracting the resulting tensor network returns the strong simulation result. An advantage of the tensor network representation is that it acts as a unifying language for strong simulation algorithms and we use it here to demonstrate that concatenations of treelike circuits followed by Gaussian or stabiliser circuits are efficiently strongly simulable. Another advantage of using the language of tensor network contraction is that it applies beyond quantum circuits, to classical Boolean circuits^{25} and their generalisation to stochastic circuits^{26}.
Strong simulation algorithms efficiently perform restricted forms of what is thought to be a generally inefficient task. It is then worth investigating whether they might efficiently solve subsets of other generally difficult problems. In this regard, Aaronson and Gottesman showed that solutions to problems in the class ⊕L (parityL)^{27} could be embedded in the probabilities of stabilisercircuit measurement outcomes and thus efficiently solved using methods to simulate such circuits^{5}. Moreover, following Valiant, it has been shown that matchgate circuit simulators and the related holographic algorithms, provide an efficient means to solve problems for which none were previously known^{28}.
This article is similarly motivated; we show that every efficient strong simulation technique provides a method for efficiently solving a class of search problems. We do this by constructing, for any given search problem, circuits that check solutions to the problem and whose strong simulation counts and reveals solutions to the problem. A search problem is then efficiently solvable if these strong simulations can be performed efficiently.
The importance of search problems stems from the wide variety of tasks that can be phrased in terms of them^{29}. Further, by connecting strong simulation to search problems we highlight the relationship between strong simulation and wellknown complexity classes: the problems decided by efficiently strongly simulable circuits must form a proper subset of P, otherwise P, NP and #P are all equally powerful.
Results
Search problems
A search problem is a collection of instances, each represented by a bitstring x and associated with a set of solutions S(x)^{29}. Each solution w ∈ S(x) is also represented by a bitstring. A search problem is efficiently solvable if, for every instance x, it is possible to find a solution w ∈ S(x) or determine none exists in a time ≤ p(x). Here p is some polynomial and x is the length of bitstring x. This is consistent with the general notion of efficient, meaning that a task can be completed in a time upperbounded by a polynomial in the size of its description. In what follows, we assume that solutions can be efficiently checked using a classical computer and efficiently described.
Searching by counting
Our approach relies on the reduction of a search problem to a counting problem^{29}. Each instance of the counting problem, described by (x, n, w′), is to calculate #(x, n, w′) the number of solutions to x that are of length n and end in some bit pattern w′.
The reduction, depicted in figure 1, is performed as follows. For a given x with Null the zerolength bitstring, calculate #(x, n, Null) for n = 1. Repeat this for n = 2, 3,… until either a nonzero value of #(x, n, Null) is obtained or n reaches some maximum value n_{max}. If n_{max} is reached without obtaining a nonzero value, then no solution exists. If instead a nonzero value is found for some n = w_{min} ≤ n_{max}, then a lengthw_{min} solution exists. To find one such solution, complete the following binary search. Evaluate #(x, w_{min}, 0). If this is nonzero, calculate #(x, w_{min}, 00). Otherwise, calculate #(x, w_{min}, 01). Continuing in this way, a lengthw_{min} solution to x is inferred after a total of 2w_{min} counts.
Since solutions are efficiently described, we may choose n_{max} ≤ p(x) and this results in two properties: first, x is solved by calculating #(x, n, w′) for ≤ p(x) values of n and w′; second, for these n and w′ we have (x, n, w′) ≤ p(x). It follows that if the counting problem is efficiently solvable then so is the search problem.
Counting by simulating
To highlight the computational difficulty (#Phardness) of strong simulation, researchers have constructed quantum processes with outcome probabilities encoding the solutions to hard counting problem instances^{2}. We encompass such approaches by constructing a quantum process whose outcome probabilities embed the solution to an arbitrary counting instance (x, n, w′). Our motivation, unlike in Ref. 2, is not to suggest the general inefficiency of strong simulation but to take specific cases in which it is efficient and transfer this efficiency to solving the embedded counting instance.
We now outline the quantum process, leaving the details of its construction to the methods section. The quantum process consists of an input state, a quantum circuit and a measurement. Each possible solution w of length n is represented by an Nqubit product input state
where {0〉, 1〉} is the computational basis. Input states are evolved according to a quantum circuit C_{x,n} comprising M gates, with each gate g_{k} acting on a bounded number of qubits. The unitary operator representing this circuit is
Finally, a measurement is performed, defined by some projectors with outcomes {yes, no}. Here we choose to project onto a computational basis state of the last qubit
The circuit C_{x,n} is devised such that if w ∈ S(x) then Ĉ_{x,n}w〉 is in the range of , otherwise it is in the range of . We call a circuit with this property a solutionchecking circuit: if w〉 is inputted into C_{x,n} then measuring the output returns yes with probability equal to unity if w ∈ S(x) and otherwise zero. Then, by linearity, inputting a superposition
into C_{x,n} returns yes with probability . Here W(n,w′) = {w″w′ : w″w′ = n} is the set of lengthn bitstrings with suffix w′, is a normalisation constant with n′ = w′ and .
We call this process a quantum counter since its outcome probabilities encode #(x, n, w′) and thus (x, n, w′) is solved by its strong simulation. It is essential that the simulation is strong, as the prefactor means that probabilities must be calculated to a precision exponential in n. Generally, an exponential number of weak simulations would be required to achieve this precision^{2,3}.
To ensure no inefficiencies are hidden in the construction of the counters, we insist that for every (x, n, w′) a description of the counter can be generated in a time ≤ p((x, n, w′)). A family of counters obeying this restriction is called (polynomialtime) uniform. The uniformity of a family of counters is ensured if we impose two conditions on the family {C_{x,n}} of solutionchecking circuits on which they are based: circuits in the family are of polynomial size, i.e. N, M ≤ p(n) for each C_{x,n} and the family is uniform, i.e. a description of each C_{x,n} can be generated in a time ≤ p(x, n). In this article all families of counters are uniform and all families of circuits are polynomiallysized and uniform.
Given these restrictions, a search problem is efficiently solvable if there is a family of counters that are also efficiently strongly simulable. An efficient strong simulation method will efficiently strongly simulate some families of counters and thus efficiently solve some counting and search problems. This is one of the main implications of our formulation.
In the remainder of this article we will identify counting and search problems efficiently solved by known and newlydevised strong simulation methods. However, we first describe the tensor network representation of strong simulation, which provides a convenient language for discussing these strong simulation methods.
Counting by contracting
The strong simulation of a quantum counter reduces to calculating the probability
The Nqubit states and operators appearing on the right hand side of equation (5) are made up of singlequbit states and operators acting on a bounded number of qubits, according to equations (2)–(4). As is common in quantum mechanics, we may represent these states and operators by vectors and matrices, respectively (see methods). In this way, the operation and each of the M operations that constitute Ĉ_{x,n} is described by a matrix of bounded size. Similarly, the initial product state W(n,w′)〉 is described by N vectors of bounded size. Thus there is a set of 2(M + N) + 1 tensors that together efficiently describe the quantum process. Contracting these tensors together in the correct arrangement to obtain equation (5) reveals #(x, n, w′). Hence we call the tensor network, illustrated in figure 2, a tensor counter.
A family of tensor counters constructed in this way inherits its uniformity from the family of quantum counters on which it is based. In this representation then, a search problem and its corresponding counting problem are efficiently solvable if there is a family of tensor counters that are efficiently contractable. This is ensured if each counter can be contracted in a time ≤ p(n).
Identifying efficiently solvable search problems
We now discuss cases in which counters of the type in figure 2 are efficiently contractable and thereby identify efficiently solvable counting and search problems. Since the other parts of the counters are fixed, the efficiency of their contraction depends only on the family {C_{x,n}} of solutionchecking circuits. This leads to the following result: a search problem is efficiently solvable if its solutions can be checked by restricted circuit families, specifically circuit families which correspond to efficiently contractable counters. Before we identify such circuit families, let us comment on the applicability of our results to various circuit types. We have so far outlined one approach to constructing a family of tensor counters of the form shown in figure 2, based on a family {C_{x,n}} of quantum solutionchecking circuits. However, as we show in the methods section, there are other equally valid approaches. As an example, we describe an explicit construction for a family of tensor counters based on a family {C_{x,n}} of classical Boolean solutionchecking circuits. Tensor counters can also be constructed from circuits {C_{x,n}} within other models of computation. For example, stochastic circuits^{26} and atemporal Boolean circuits^{25}, both of which are a generalisation of Boolean circuits.
Thus what follows applies to tensor counters built from solutionchecking circuits {C_{x,n}} within any such computational model. This increases the number of routes through which one may devise a family of efficiently contractible counters and demonstrate the efficiency of finding and counting solutions to a search problem. For notational convenience, we treat the solutionchecking circuit C_{x,n} and the tensor network representing it as synonymous, only making a distinction when needed for clarity. Methods for contracting tensor networks are divided into two types; geometric and algebraic.
Contracting geometrically
Geometric methods sequentially perform a contraction while carefully choosing the contraction sequence to avoid storing or manipulating large tensors. Accordingly, when discussing these methods, the only concern is with the structure of the counter. The counter inherits the same structure as C_{x,n} up to a bounded increase in the size of the tensors, as illustrated in figure 3(a). Therefore the efficiency of geometric methods depend solely on the geometries of {C_{x,n}}.
As an example of a geometric contraction strategy, consider the case where each of the circuits in {C_{x}_{,n}} has a simple tree structure. The counters can then be efficiently contracted by starting at the branch tips and moving inwards, as indicated in figure 3(a). Thus search problems are efficiently solvable if their solutions can be checked by a family {C_{x}_{,n}} of circuits whose gates are arranged in a simple tree structure. Markov and Shi generalised this contraction strategy by showing how to efficiently contract networks that are sufficiently treelike^{22}. Specifically, a family of networks is efficiently contractable if each network has a treewidth (a measure of how far a network is from being a tree) growing at most logarithmically in the number of tensors. It follows from our formalism that this same contraction strategy efficiently solves any search problem whose solutions are checked by a family {C_{x}_{,n}} of circuits with a treewidth growing at most logarithmically in n.
We can immediately apply this result to the problem of finding satisfying solutions to a restricted version of the Boolean satisfiability decision problem^{30}. For this search problem, each instance x describes a Boolean formula and each solution w ∈ S(x) is a lengthn bitstring representing a set of n Boolean variables which satisfy this formula. Provided we restrict ourselves to formulas represented by circuits {C_{x}_{,n}} with a treewidth growing at most logarithmically in n, solutions are checked using such restricted circuits. Hence such restricted SATbased counting and search problems are efficiently solvable using our approach.
Contracting algebraically
Other contraction strategies rely on algebraic relations to simplify or fully contract a tensor network; in this case it is not only the geometry of the network that is important, but also the components of the tensors. Two prominent examples are the methods of simulating stabiliser^{4,7} and Gaussian circuits^{12,13}, the latter of which encapsulates matchgate and free Fermion circuits^{8,9,10,11}. Each is based on a group of operators which, under the action of a restricted circuit, map to other operators in the group. Algebraic relations allow this mapping to be calculated efficiently.
Specifically, for either a stabiliser or Gaussian circuit C_{x}_{,n}, the evolved projection operator , appearing in the counter shown in figure 2, can be found in a time ≤ p(n)^{7,13}. This evolved projector is described by a particularly simple form of tensor network with ≤ p(n) tensors of bounded size arranged in a linear geometry (see methods). This network, called a matrix product operator^{31,32}, is illustrated in figure 3(b). Using the strategy suggested in this figure, the simple geometry of the matrix product operator allows the full counter to be contracted in a time ≤ p(n). Thus a search problem is efficiently solvable if its solutions can be checked by a family {C_{x}_{,n}} of stabiliser or Gaussian circuits.
For stabiliser circuits, this has a clear interpretation in terms of a known class of decision problems. A decision problem is defined as a collection of instances the solution to which is either yes or no. The problem is fully specified by the set of all yes instances, called the language and the bitstrings describing yes instances are words in this language. The class ⊕L contains every language for which it can be decided whether any word is a part of that language using a stabiliser circuit acting on computational basis states followed by a single measurement in that basis^{5,27}. Using our formalism, it is then efficient to count and find words from any language in ⊕L.
Our formalism also allows the efficient finding of words in languages decided by a Gaussian circuit followed by a computational basis measurement in a single qubit. It turns out that such languages are trivial; whether or not a word is part of the language can be decided by considering at most a single bit of the word^{33}.
Contracting a concatenation
Having presented several strong simulation methods in the unifying language of tensor networks, we now show that they can be combined. We have already shown that evolving by a stabiliser or Gaussian circuit returns a matrix product operator. In figure 3(c) we depict how a bounded matrix product operator evolved by another circuit leads to a network with the same geometry of but with a bounded increase in the size of the tensors. This means it is possible to contract each counter in figure 2 in a time ≤ p(n) if C_{x}_{,n} is a concatenation of a circuit with a treewidth growing at most logarithmically in n followed by a stabiliser or Gaussian circuit . Thus we have arrived at a key result: a search problem is efficiently solvable if its solutions are checked by a family {C_{x,n}} of such concatenated circuits. The class of search problems of this type was not previously known to be efficiently solvable.
Power of efficiently strongly simulable circuits
The above joint algebraic and geometric contraction strategy encapsulates each of the three strong simulation algorithms considered (stabiliser, Gaussian and treebased) and in their combination leads to a new class of efficiently simulable quantum circuits.
It is known that there is a sudden shift in computational power when a seemingly innocuous gate is added to the gatesets of either Gaussian or stabiliser circuits: Since they are efficiently simulable, (uniform and polynomiallysized) Gaussian or stabiliser circuits followed by a computational basis measurement cannot be used to decide, even with a bounded error, any languages outside the complexity class P, where P is the class of decision problems solved efficiently and without error using a classical computer. However, if SWAP^{13} or the π/8gate^{34}, respectively, are added to either gateset, then either can decide problems in BQP. This is the class of decision problems solved efficiently and with a bounded error using a quantum computer.
The shift is enhanced by both our concatenation of simulation techniques and our algorithm for searching by simulating. The former narrows down where the shift may take place: allowing boundedsize, but otherwise arbitrary gates, in a limited geometry before Gaussian or stabiliser circuits does allow the deciding of languages beyond P with bounded error. The latter highlights the size of the shift: we expect the languages that can be decided without error using Gaussian, stabiliser, treelike circuits, or their concatenation followed by a computational basis measurement not only to be a subset of P, but a proper subset. To see why this is expected, consider the opposite to be true. This would imply that all efficientlycheckable search problems can be checked using Gaussian, stabiliser, treelike circuits, or their concatenation followed by a computational basis measurement. Using our formulation, it would then be possible to efficiently count and find solutions to all efficientlycheckable search problems. Note that each instance of a problem in #P (NP) corresponds to counting the number of solutions (deciding whether there is a solution) to an instance of an efficientlycheckable search problem^{29}. Thus all problems in NP and #P would be solvable in polynomial time.
Discussion
Our results reveal a hitherto unknown consequence of algorithms that efficiently simulate quantum circuits; each allows for the efficient solving of a class of search problems. This applies to every strong simulation technique, implemented by any device, classical or quantum. For well understood methods such as stabiliser circuit simulation algorithms, this confirms what is already known. For methods whose computational power is less well understood, this demonstrates the efficient solubility of several classes of search problems based on how their solutions are checked. To our knowledge, this extends the class of counting and search problems known to be efficiently solvable. Further, the most general technique considered in this article corresponds to a novel combination of strong simulation methods. Hence this article widens the class of efficient strong simulation methods and adds to their applicability.
Methods
Generic quantum counters
Here we give an explicit approach to constructing a quantum solutionchecking circuit C_{x}_{,n} used to form a quantum counter.
For every instance x of an efficientlycheckable search problem a solution of length n can be checked in time ≤ p(x) using a classical computer. Thus there is a classical algorithm that decides the language in time ≤ p((x,w)). It is then possible to construct a family of Boolean circuits {C_{m}} with the following properties^{35}: each C_{m} takes inputs (x, w) with (x, w) = m and outputs logicalone if and otherwise logicalzero; it comprises ≤ p(m) AND, OR and NOT gates^{34}; and it is constructible in a time ≤ p(m). Hardwiring x into C_{m} leaves a Boolean solutionchecking circuit C_{x}_{,n} that takes bitstrings w of length n and outputs logicalone if w ∈ S(x) and otherwise logicalzero.
The Boolean circuit C_{x}_{,n} can be made reversible in time ≤ p(x, n) with only ≤ p(x, n) additional gates and ≤ p(x, n) additional ancilla bits, each initially set to zero^{36,37,38}. The standard mapping between reversible classical and unitary quantum circuits^{34} leads to a quantum circuit of the desired form. This circuit is generated in time ≤ p(x, n) and comprises ≤ p(x, n) gates. So the approach leads to polynomiallysized uniform families of quantum solutionchecking circuits and hence a uniform family of quantum counters for the search problem.
Tensor counters from quantum counters
Here we describe how the expression for the probability in equation (5) is replaced by the contraction of a uniform tensor network. Other descriptions of how to represent quantum circuits by tensor networks can be found in Refs. [15, 22].
To begin, insert equations (2)–(4) into equation (5) to obtain
To rewrite this as a tensor network contraction, first replace the states and operators 0〉, 1〉, +〉, and 1〉 〈1 appearing in equation (6) by their corresponding tensors [0], [1], [+], {[g_{k}]} and [1〉 〈1]. Specifically, represent each singlequbit state ψ〉 by the tensor [ψ] with 2 components labelled by an index i_{1} = {0, 1}. To represent the dual of a state, take the conjugate transpose. Further, represent each N′qubit operator by the tensor [O] with 2^{2N′} components
labelled by 2N′ indices, where o_{j} = {0, 1}. After this replacement, write a joint summation (contraction) over every pair of indices corresponding to an input and output connected by the expression in the right hand side of equation (6).
It follows from above that the mapping can be performed in a time ≤ p((x, n, w′)). Thus a uniform family of quantum counters maps to a uniform family of tensor counters.
Beyond quantum circuits
Here we describe conditions on the tensor network representing C_{x}_{,n}, which appears in the counter shown in figure 2. The only requirement needed to ensure the contraction of the counter returns the desired value of is
where [C_{x}_{,n}] is the tensor representing . In fact, it is not necessary for [C_{x}_{,n}] to have the same number N of output indices as input indices. This gives us the freedom to consider a tensor network that does not represent a quantum circuit, but nevertheless whose contraction returns a tensor [C_{x}_{,n}] satisfying equation (7).
Counters based on Boolean circuits
Here we give an explicit approach to constructing a tensor counter built from a classical Boolean circuit.
In our construction of a quantum counter, we showed how to construct a solutionchecking Boolean circuit C_{x}_{,n} for any solutionlength n and instance x of a given search problem. The circuit can be generated in a time ≤ p(x, n) and comprises ≤ p(x, n) boundedsize gates. It implements the binary switching function f_{x}_{,n} : {0, 1}^{n} → {0, 1} where f_{x}_{,n}(w) is 1 if w ∈ S(x) and otherwise 0.
To obtain a tensor network representing C_{x}_{,n}, first represent each gate implementing the binary function by a tensor with components where and similarly for o_{k}. Next connect the input and output indices of the tensors {[g_{k}]} in precisely the same arrangement as the circuit. The components of the tensor obtained by contracting this network are . Again we have used the shorthand . This tensor satisfies equation (7). Thus the network representing C_{x}_{,n} leads to a valid tensor counter of the form shown in figure 2. The counter is generated in a time ≤ p((x,n,w′)) and so counters constructed in this way form a uniform family.
Contracting algebraically
Using the Heisenberg picture, stabiliser circuits map a product of Pauli operators to another Pauli product^{7}. Such a product is represented by a particularly simple matrix product operator where each tensor is the standard matrix representing the corresponding Pauli operator and the internal indices have dimension χ = 1. With m the number of qubits, the projector is the sum of two Pauli products and therefore so is . Two matrix product states can be efficiently summed to make another where the dimension χ increases additively^{31,32}. Thus is represented by a χ = 2 matrix product operator.
Gaussian circuits map generators c_{µ} of a Clifford algebra to a linear combination where is calculable in a time ≤ p(m) and ν takes 2m values^{13}. Each c_{µ} may be represented by a Pauli product^{13} and so by a χ = 2m matrix product operator. A product of two generators c_{1}c_{2} is mapped to , represented by the product of two matrix product operators. The result is another matrix product operator where the dimension χ increases multiplicatively^{31,32}. In this case the result has dimension χ = (2m)^{2}. Finally, there is a choice of c_{1} and c_{2} such that ^{13}. Thus is represented by a χ = (2m)^{2} + 1 matrix product operator.
References
Shor, P. Algorithms for quantum computation: Discrete logarithms and factoring. SIAM J. Comput. 26, 1484–1509 (1997).
Van den Nest, M. Classical simulation of quantum computation, the GottesmanKnill theorem and slightly beyond. Quant. Inf. Comp. 10, 0258–0271 (2010).
Jozsa, R. & Linden, N. On the role of entanglement in quantumcomputational speedup. Proc. R. Soc. Lond. A 459, 2011–2032 (2003).
Gottesman, D. A theory of faulttolerant quantum computation. Phys. Rev. A 57, 127137 (1998).
Aaronson, S. & Gottesman, D. Improved simulation of stabilizer circuits. Phys. Rev. A 70, 052328 (2004).
Anders, S. & Briegel, H. J. Fast simulation of stabilizer circuits using a graphstate representation. Phys. Rev. A 73, 022334 (2006).
Clark, S., Jozsa, R. & Linden, N. Generalized Clifford groups and simulation of associated quantum circuits. Quant. Inf. Comp. 8, 0106–0126 (2008).
Valiant, L. G. Quantum computers that can be simulated classically in polynomial time. SIAM J. Comput. 31, 1229–1254 (2002).
Knill, E. Fermionic linear optics and matchgates. Preprint at <http://arxiv.org/abs/quantph/0108033> (2001)
Terhal, B. M. & DiVincenzo, D. P. Classical simulation of noninteractingfermion quantum circuits. Phys. Rev. A 65, 032325 (2002).
DiVincenzo, D. P. & Terhal, B. M. Fermionic linear optics revisited. Found. Phys. 35, 1967–1984 (2005).
Bravyi, S. Lagrangian representation for fermionic linear optics. Quantum Inf. Comp. 5, 216–238 (2005).
Jozsa, R. & Miyake, A. Matchgates and classical simulation of quantum circuits. Proc. R. Soc. A 464, 3089–3106 (2008).
Vidal, G. Efficient classical simulation of slightly entangled quantum computations. Phys. Rev. Lett. 91, 147902 (2003).
Jozsa, R. On the simulation of quantum circuits. Preprint at <http://arxiv.org/abs/quantph/0603163> (2006)
Shi, Y.Y., Duan, L.M. & Vidal, G. Classical simulation of quantum manybody systems with a tree tensor network. Phys. Rev. A 74, 022320 (2006).
Yoran, N. & Short, A. J. Classical simulation of limitedwidth clusterstate quantum computation. Phys. Rev. Lett. 96, 170503 (2006).
Yoran, N. & Short, A. J. Efficient classical simulation of the approximate quantum Fourier transform. Phys. Rev. A 76, 042321 (2007).
Browne, D. E. Efficient classical simulation of the quantum Fourier transform. New J. Phys. 9, 146 (2007).
Bravyi, S. & Raussendorf, R. On measurementbased quantum computation with the toric code states. Phys. Rev. A 76, 022304 (2007).
Van den Nest, M., Dür, W., Vidal, G. & Briegel, H. J. Classical simulation versus universality in measurementbased quantum computation. Phys. Rev. A 75, 012337 (2007).
Markov, I. L. & Shi, Y.Y. Simulating quantum computation by contracting tensor networks. SIAM J. Comput. 38, 963–981 (2008).
Bravyi, S. Contraction of matchgate tensor networks on nonplanar graphs. Contemporary Mathematics 482, 179–211 (2009).
Van den Nest, M., Dür, W., Raussendorf, R. & Briegel, H. J. Quantum algorithms for spin models and simulable gate sets for quantum computation. Phys. Rev. A 80, 052334 (2009).
Biamonte, J. D., Clark, S. R. & Jaksch, D. Categorical tensor network states. AIP Advances 1, 042172 (2011).
Johnson, T. H., Clark, S. R. & Jaksch, D. Dynamical simulations of classical stochastic systems using matrix product states. Phys. Rev. E 82, 036702 (2010).
Damm, C. Problems complete for ⊕L. Information Processing Letters 36, 247–250 (1990).
Cai, J.Y. & Lu, P. Holographic algorithms: From art to science. J. Comput. Syst. Sci. 77, 41–61 (2011).
Goldreich, O. P, NP and NPcompleteness: The basics of computational complexity, (Cambridge Univ. Press, 2010).
Freuder, E. C. A sufficient condition for backtrackbounded search. J. ACM 32, 755–761 (1985).
McCulloch, I. From densitymatrix renormalization group to matrix product states. J. Stat. Mech. P10014 (2007).
Clark, S. R., Prior, J., Hartmann, M. J., Jaksch, D. & Plenio, M. B. Exact matrix product solutions in the Heisenberg picture of an open quantum spin chain. New J. Phys. 12, 025005 (2010).
Van den Nest, M. Quantum matchgate computations and linear threshold gates. Proc. R. Soc. A 467, 821–840 (2011).
Nielsen, M. & Chuang, I. L. Quantum computation and quantum information, (Cambridge Univ. Press, 2000).
Arora, S. & Barak, B. Computational complexity: A modern approach, (Cambridge Univ. Press, 2009).
Bennett, C. H. Logical reversibility of computation. IBM J. Res. Develop. 17, 525–532 (1973).
Toffoli, T. Reversible computing. Automata, languages and programming, Seventh colloquium, Lecture notes in computer science 84, de Bakker, J. W. & van Leeuwen, J. eds., 632644. (Springer, 1980).
Saeedi, M. & Markov, I. L. Synthesis and optimization of reversible circuits  A Survey. <http://arxiv.org/abs/1110.2574> (2011).
Acknowledgements
THJ thanks Vlatko Vedral for helpful discussions, the Centre for Quantum Technologies in Singapore, where much of this work was completed and Federica Ferraris for help drawing the figures. All authors acknowledge support from the EPSRC via grant EP/J010529/1.
Author information
Authors and Affiliations
Contributions
All authors conceived the idea together, THJ and SRC derived the technical results, THJ prepared the manuscript with assistance from all authors.
Ethics declarations
Competing interests
The authors declare no competing financial interests.
Rights and permissions
This work is licensed under a Creative Commons AttributionNonCommercialNoDerivs 3.0 Unported License. To view a copy of this license, visit http://creativecommons.org/licenses/byncnd/3.0/
About this article
Cite this article
Johnson, T., Biamonte, J., Clark, S. et al. Solving search problems by strongly simulating quantum circuits. Sci Rep 3, 1235 (2013). https://doi.org/10.1038/srep01235
Received:
Accepted:
Published:
DOI: https://doi.org/10.1038/srep01235
This article is cited by

Probabilistic nonunitary gate in imaginary time evolution
Quantum Information Processing (2021)

Tensor Network Contractions for #SAT
Journal of Statistical Physics (2015)
Comments
By submitting a comment you agree to abide by our Terms and Community Guidelines. If you find something abusive or that does not comply with our terms or guidelines please flag it as inappropriate.