The stabiliser formalism plays a central role in quantum computing, error correction, and fault tolerance. Conversions between and verifications of different specifications of stabiliser states and Clifford gates are important components of many classical algorithms in quantum information, e.g. for gate synthesis, circuit optimisation, and simulating quantum circuits. These core functions are also used in the numerical experiments critical to formulating and testing mathematical conjectures on the stabiliser formalism.We develop novel mathematical insights concerning stabiliser states and Clifford gates that significantly clarify their descriptions. We then utilise these to provide ten new fast algorithms which offer asymptotic advantages over any existing implementations. We show how to rapidly verify that a vector is a stabiliser state, and interconvert between its specification as amplitudes, a quadratic form, and a check matrix. These methods are leveraged to rapidly check if a given unitary matrix is a Clifford gate and to interconvert between the matrix of a Clifford gate and its compact specification as a stabiliser tableau.For example, we extract the stabiliser tableau of a 2n×2n matrix, promised to be a Clifford gate, in O(n2n) time. Remarkably, it is not necessary to read all the elements of a Clifford gate matrix to extract its stabiliser tableau. This is an asymptotic speedup over the best-known method that is exponential in the number of qubits.We provide implementations of our algorithms in Python and C++ that exhibit vastly improved practical performance over existing algorithms in the cases where they exist.
Stabilizer states and Clifford transformations constitute the tractable backbone of quantum information science, from error correction and fault tolerance to benchmarking and simulation. Although these objects admit compact classical descriptions, many physical and computational workflows still require their explicit dense forms such as a full wavefunction for a stabilizer state or a full matrix for a Clifford transformation. In such explicit output tasks, exponential scaling is unavoidable because the outputs themselves have sizes
2n and
4n. The fundamental question is therefore whether compact stabilizer and Clifford descriptions can be expanded with no additional polynomial overhead. Here we answer this question affirmatively. We present optimal algorithms that materialize an
n-qubit stabilizer state vector in
O(2n) time and a full dense Clifford matrix in
O(4n) time. The same framework also yields an optimal conversion from standard stabilizer check matrices to state vectors and, for every fixed odd prime qudit dimension
ℓ, gives
O(ℓn)-time materialization of qudit stabilizer states. As an additional compact-to-compact result, we design a sign-aware Four Russians method for converting stabilizer check matrices to quadratic forms faster than Gaussian elimination. These results close the asymptotic gap between compact descriptions of the stabilizer formalism and their dense representations.
The stabiliser formalism is a widely used and successful subtheory of quantum mechanics consisting of stabiliser states, Clifford unitaries and Pauli measurements. The power of the formalism comes from the description of its elements via simple group theory. Although the origins of the formalism lie in quantum error correction and fault-tolerant quantum computing, the utility of the formalism goes beyond that. The Gottesman-Knill theorem states that the dynamics of stabiliser states under Clifford unitaries and Pauli measurements can be efficiently simulated on a classical computer. This algorithm can be extended to arbitrary states and unitaries in multiple ways at the cost of an increased runtime. This runtime can be seen as a quantification of the non-stabiliser resources needed to implement a quantum circuit. Moreover, as non-stabiliser elements are necessary for universal quantum computing, the runtime provides a way to measure the “non-classicality” of a computation. This is particularly pronounced in the magic state model of quantum computing where the only non-stabiliser elements are given by magic states. Hence, in the resource theory of magic, resources are measured through magic monotones which are operationally linked to runtimes of classical simulation algorithms. In this thesis, I discuss different aspects of the resource theory of magic. The mentioned classical simulation algorithms require the computation of magic monotones which is in general a computationally intractable problem. However, I show that the computational complexity can be exponentially reduced for certain classes of symmetric states, such as copies of magic states. To this end, the symmetries of the convex hull of stabiliser states are characterised and linked to their properties as so-called designs. In addition, I study the recently introduced class of completely stabiliser-preserving channels (CSP), which is the class of quantum channels unable to generate magic resources. It is shown that this class is strictly larger than the class of stabiliser operations, composed of Clifford unitaries and Pauli measurements. This finding could have several interesting consequences. First, it implies that there is a class of efficiently simulable quantum channels beyond the Gottesman-Knill theorem. Second, it is possible that optimal magic state distillation rates cannot be achieved via stabiliser operations and this gap is in fact significant. Further applications of the stabiliser formalism come through design theory. A unitary t-design is an ensemble of unitaries which reproduce the first t moments of the Haar measure on the unitary group. Randomness in the form of Haar-random unitaries is an essential building block in many quantum information protocols. Implementing such Haar-random unitaries is however often impractical. Here, designs can exhibit considerably lower resource requirements while still being random enough for most applications. Some of the most prominent examples of such protocols concern the certification and characterisation of quantum systems, such as randomised benchmarking. Interestingly, the group of Clifford unitaries forms a unitary 3-design and is often the prime choice thanks to efficient group operations. In this thesis, I summarise my recent results obtained with collaborators in constructing approximate unitary t-designs from the Clifford group supplemented by only few non-Clifford gates. Intriguingly, this construction uses only O(t^4) single qubit non-Clifford gates and is independent of the number of qubits n. Overall, this yields a gate count which is a significant improvement over for the Brandao-Harrow- Horodecki construction based on local random circuits. To provide context for this result, I review the representation theory of the Clifford group and define the Clifford semigroup. In an attempt to generalise approximations results for the unitary group to the Clifford group, the Clifford semigroup is investigated for suitable approximations of the Clifford twirl.
Abstract Stabiliser states play a central role in the theory of quantum computation. For example, they are used to encode computational basis states in the most common quantum error correction schemes. Arbitrary quantum states admit many stabiliser decompositions: ways of being expressed as a superposition of stabiliser states. Understanding the structure of stabiliser decompositions has significant applications in verifying and simulating near-term quantum computers. We introduce and study the vector space of linear dependencies of n-qubit stabiliser states. These spaces have canonical bases containing vectors whose size grows exponentially in n. We construct elegant bases of linear dependencies of constant size three. Critically, our sparse bases can be computed without first compiling a dictionary of all n-qubit stabiliser states. We utilise them to explicitly compute the stabiliser extent of states of more qubits than is feasible with existing techniques. Finally, we delineate future applications to improving theoretical bounds on the stabiliser rank of magic states.
Despite the widespread belief that quantum computers cannot be efficiently simulated classically, efficient simulation is known to be possible in certain restricted regimes. In particular, the Gottesman-Knill theorem states that Clifford circuits can be efficiently simulated. We begin this thesis by reviewing and comparing several known techniques for efficient simulation of Clifford circuits: the stabilizer formalism, CH form, affine form, and the graph state formalism. We describe each simulation method and give four different proofs of the Gottesman-Knill theorem. \n \nNext we review a recent work [15], which shows that restricting the geometry of Clifford circuits can lead to a further speedup. We give an algorithm for simulating Pauli basis measurements on a planar graph state in time
widetildeO(nomega/2), where
omega<2.373 is the matrix multiplication exponent. This algorithm achieves a quadratic speedup over using Clifford simulation methods directly. As an application of this algorithm, we consider a depth-
d Clifford circuit whose two-qubit gates act along edges of a planar graph and describe how to sample from its output distribution or compute an output probability in time $\\widetilde{O}(n^{\\omega/2}d^\\omega)$. For
d=O(logn), both of these results are quadratic speedups over using Clifford simulation methods directly. \n \nFinally, we extend these simulation algorithms to universal circuits by using stabilizer rank methods. We follow a previously known gadgetization procedure [9] to show that given a depth-
d Clifford+
T circuit with
t T gates and whose two-qubit gates act along edges of a planar graph, we can sample from its output distribution in time
widetildeO(20.7926tn5/2t6d3) and can compute output probabilities in time
widetildeO(20.3963tn3/2t6d3). Previous work [9,6], applied to the case
d=O(logn), gives algorithms for sampling in time
O(20.3963tn6t6) and computation of output probabilities in time
O(20.3963tn3t3). Our sampling algorithm offers improved scaling in
n but poorer scaling in the exponential term, while our algorithm for computing output probabilities offers improved scaling in
n with identical scaling in the exponential term.
Quantum computers are expected to have advantages over classical computers in solving a range of high impact problems, but they are highly susceptible to errors due to environmental noise. The Pauli Stabiliser formalism generalises classical error-correction methods and makes use of quantum error correction codes to protect quantum information. In this thesis, we introduce the XP stabiliser formalism, which is a generalisation of the Pauli stabiliser formalism with a number of useful applications. Quantum algorithms are typically written in terms of quantum circuits which involve a series of unitary gates followed by measurements which form the output of the computation. To implement quantum algorithms reliably, we need to perform unitary gates fault-tolerantly so that errors do not propagate in an uncontrolled way. Transversal logical operators are one way of applying unitary gates fault-tolerantly on Pauli stabiliser codes. Identifying transversal logical operators for a given Pauli stabiliser code is challenging, and existing methods have exponential complexity in one or more of the parameters of the code. Making use of the XP formalism, we present efficient algorithms which identify all transversal logical operators that are diagonal in the computational basis for any Pauli stabiliser code. We also show how to construct codes with a transversal implementation of any desired diagonal logical operator. The Pauli stabiliser formalism can also be used to efficiently represent certain quantum states, but many states of interest lie outside the formalism. In the XP formalism, a wider range of states can be represented than in the Pauli stabiliser formalism, including hypergraph states which have interesting non-local properties. The braiding of non-Abelian anyons is a proposed pathway to universal fault-tolerant quantum computation. Certain XP stabiliser codes are known to harbour non-Abelian anyons, and can be studied within the new formalism.
Approximating a given unitary operator into a discrete set of gates is of great importance in quantum computation. This problem can be seen as a source quantization problem where the unitary operator is considered as the source. Elements of the Clifford hierarchy can be implemented fault-tolerantly using quantum gate teleportation. This motivates the development of algorithms that quantize unitary operators into Clifford hierarchy elements. In this paper, we present a fast algorithm for approximating arbitrary n-qubit unitaries with Clifford matrices. The algorithm relies on the Clifford transvection decomposition of the Clifford group. The algorithm greedily applies Clifford transvections taking the input unitary closer to the identity matrix. To make the algorithm fast, we take advantage of the Pauli basis representation for unitary matrices to parallelize matrix distance computations. The complexity of the proposed algorithm is O(n 4n). Based on simulation results, the proposed algorithm outperforms the state of the art method.