Hybrid quantum computing with ancillas

In the quest to build a practical quantum computer, it is important to use efficient schemes for enacting the elementary quantum operations from which quantum computer programs are constructed. The opposing requirements of well-protected quantum data and fast quantum operations must be balanced to maintain the integrity of the quantum information throughout the computation. One important approach to quantum operations is to use an extra quantum system - an ancilla - to interact with the quantum data register. Ancillas can mediate interactions between separated quantum registers, and by using fresh ancillas for each quantum operation, data integrity can be preserved for longer. This review provides an overview of the basic concepts of the gate model quantum computer architecture, including the different possible forms of information encodings - from base two up to continuous variables - and a more detailed description of how the main types of ancilla-mediated quantum operations provide efficient quantum gates.


Introduction
The publication in 1994 of Shor's celebrated algorithm for efficient integer factoring using a quantum computer [1,2] has sparked an explosion of interest in building such a device.For large numbers, this seemingly innocuous problem has so far proved impossible to solve in a reasonable length of time on a classical computer.Indeed, the assumed impracticality of this task is behind the security of widely used public-key cryptography methods, such as RSA encryption [3].Although undermining current cryptography systems is little (if any!) motivation for undertaking the daunting tasking of actually building a quantum computer, since 1994 an expanding range of applications for such a device have been developed, including database searching [4], machinelearning tasks [5], and techniques for simulation of quantum systems [6] as envisaged in the 1980s by Feynmann [7].The degree to which quantum computers may enhance classical processing is a particularly interesting area of ongoing research: it is known that many tasks are not amenable to improved efficiency using a quantum computer [8][9][10].Nonetheless, the known enhancements cover a wide range of important computational processes, and it is likely that many more applications will become apparent if a fully-scalable quantum computer can be engineered.
What makes a quantum computer different from a classical computer?The overwhelming majority of modern classical computers are digital machines that encode information into a register of bits, which may each take the values 0 or 1.A quantum computer instead consists of qubits which may be in more general states which are neither definitely 0 nor 1 but in a wave-like superposition of both.More specifically, a state of a qubit is described by a vector (using Dirac notation |. for complex vectors) where |0 and |1 are orthonormal basis vectors and α and β are complex numbers with |α| 2 and |β| 2 the probabilities that the qubit is in the states |0 or |1 respectively when measured.The differences between a qubit and a classical bit are summarised in Fig. 1.
Figure 1.The state of a qubit Ψ Qubit = α|0 + β|1 for real α and β may be represented as a point on the unit circle (red arrow) as |α| 2 + |β| 2 = 1 for the probabilities to sum to unity.The possible states of a classical bit are equivalent to α = 1 or β = 1 (blue circles).A qubit is different to a bit with classical probabilities to be 0 or 1: such states would be parameterised by two positive numbers that sum to one (blue arrow and blue dashed line).
A classical computer stores data in a 'register' of bits: for N bits there are 2 N different possible states these bits may be in, so the register can represent up to 2 N different numbers.At each step of the computation the register is in one of these states, e.g., one possible classical state is R N -bits = (010100 . . .0).In stark contrast, a quantum register may encode any superposition of these classical states simultaneously.Mathematically, the general state of a quantum register can be written as where x 1 x 2 ...x N are the individual bits (zero or one) and the sum runs over all permutations thereof.The coefficients assign a complex probability amplitude to each permutation and satisfy the usual normalisation condition |α x1,x2,...,xN | 2 = 1.A quantum register can thus represent a superposition of all possible N -bit numbers at once.
A quantum computation consists of transformations between allowed quantum states and the transformations that do this are called unitary operators.Because a quantum computer may be in a superposition of all possible bit strings at once, it may seem like it has access to an unreasonable level of parallelism.However, the output of a computation is given by measuring the qubit register at the end of the computation, which produces a single bit string with the probability P (x 1 x 2 . . .x N ) = |α x1x2...xN | 2 .Hence, a quantum algorithm needs to intelligently make use of the allowed superpositions to enhance the probability of the desired result, illustrating the subtlety of quantum programming [8,11].To actually implement a given quantum computation described by some global N -qubit unitary, it must be decomposed into some physically available set of basic operations.Classical computations can be constructed from a small set of elementary logic operations that change the values of one or two bits at a time, e.g., negation (bit flip: 0 → 1 and 1 → 0) or AND (bit flip the second bit only if the first bit is a one).Similarly, there are small sets of elementary quantum gates that can generate all possible unitary operations, as will be discussed in Section 2.4.Why is a quantum computer proving so hard to build?The central challenge in turning a quantum computer from an abstract curiosity into a real-world device is in sufficiently protecting the fragile quantum states from decoherence and errors during the computation.Classical computers are designed with large error margins between their zero and one states, so mistakes are very rare and can be detected by simple data integrity 'checksums' and parity checks.At the level of a few quantum particles, large error margins are not possible, and robust error correction is essential for a scalable quantum computer [12,13] .In addition to active error correction, quantum computer architectures must be designed to minimise errors through precise controls when manipulating the qubits, and to maximise coherence times by choosing naturally well-isolated quantum systems, such as nuclear spins [14], for quantum data storage.Fast quantum operations are also desirable, to maximise the number of gates that can be applied before decoherence builds up.These two requirements are incompatible: well-isolated implies difficult to interact with, and vice versa, so compromises must be made.One practical method of engineering interactions between well-isolated systems is by using a third system to mediate the interaction.Such mediating systems are often called a quantum bus or an ancilla, and can have different properties that optimise them for interactions, in contrast with the well-isolated system qubits.Ancillas can be reset or discarded after a few gate operations, so they do not need to maintain coherence for the whole computation.By applying the more complex manipulations to the ancillas, then transferring the effects to the system qubits, the interactions with the system qubits can be simplified and minimised.These ideas are illustrated in the schematic diagram of Fig. 2. Ancillas are used in the gate designs of a wide range Figure 2.An ancilla or quantum bus may be used to implement the interactions required for a quantum computation.(a) A quantum bus could be a distinct physical system which qubits may couple to in turn (e.g., flux qubits coupling to a superconducting resonator [15][16][17]), denoted here by different colour arrows representing interations at different times.Alternatively, it might be a collective mode of several system qubits (e.g., vibrational modes of ions in an ion trap [18]).(b) Systems may interact via a 'flying' quantum bus which is sent between distant systems, for example atoms interacting via photons.
of promising physical systems being developed for qubit-based quantum computers.The main topic of this review article is schemes of this sort, with a particular emphasis on the underlying unifying ideas.There are also radically different quantum computer architectures that do not use quantum gates, e.g., adiabatic quantum computing [19], quantum annealing [20,21], and a range of special purpose designs, e.g., for quantum simulations [6].These have their own advantages in the quest to overcome decoherence, but are outside of the scope of this review.It is not essential to implement a quantum computer with 2-level systems (i.e., qubits).Indeed, most quantum systems have more than two dimensions and can thus in principle implement d-level logic or continuous information encoding.In Section 2, qudits and quantum continuous variables are described and quantum computation with these systems is discussed.The advantages and disadvantages of using such systems are then summarised, and the ideas of hybrid quantum computing introduced.This section may be read independently of the remainder of this paper as a basic introduction to the theory of quantum computing with these systems.It covers the ideas necessary for understanding the ancilla-based gate methods that are the subject of Section 3. A brief overview of experimental implementations of such schemes is provided in Section 4, and a summary of the key ideas concludes the paper in Section 5.

Quantum computing in any dimension
In this section we review the terminology and mathematical tools for quantum computation using quantum systems of any dimension.This allows the ideas of universal quantum computation to be explained in a unified manner and also highlights the advantages in using information encodings other than binary.
2.1.Qubits, qudits and quantum continuous variables Classical digital computers need not be formulated with bits but may instead utilise any d ∈ N base logic, and indeed, according to D. E. Knuth (balanced1 ) ternary logic is "perhaps the prettiest number system of all" [22].A d-dimensional classical unit is called a dit, and the equivalent quantum system is the d-dimensional qudit.The general state for the d = 2 qubit was given in Eq. (1).For a qudit of dimension d, the general state in Dirac notation can be written where the |q vectors are some 'computational basis' (with q|r = δ qr ), and where α q are complex numbers with is the probability to find the system in the state |q ).Rather than using Dirac notation, a qudit state may be given a perhaps more familiar and concrete representation in terms of an array of numbers, using the association The mathematics of finite-dimensional quantum theory (i.e., qudits) was initially developed by H. Weyl in the early decades of quantum mechanics [23] and in the light of its relevance to quantum information has since been extensively investigated, with Vourdas [24] providing an excellent technical review in a broader context.Only a basic understanding of qudit quantum mechanics is required to explain the fundamentals of quantum computation, which we now cover here.The d th root of unity ω = e i 2π d plays an important role, for which ω 0 + ω 1 + ω2 + • • •+ ω d−1 = 0 as illustrated in Fig. 3. Clearly, the value of d determines the precise form of ω (as is also the case for all the objects introduced below), but everything discussed here holds true and is presented independently of its particular value.There are more advanced topics which depend on d being prime (or a prime power), for example some phase space methods [24][25][26], that are not needed here.The basic operators in qudit quantum computation are the (generalised) Pauli operators denoted X and Z, which are the natural extension of two of the well-known qubit Pauli operators σ x = ( 0 1 1 0 ) and σ z = 1 0 0 −1 respectively.They may be defined (as can any operator) by their action on the computational basis states: where the addition is modulo d as on a clock with d hours, i.e., (d − 1) + 1 = 0.In terms of the more concrete column vector notation, they are the d × d matrices In fact, these operators pre-date quantum theory and were originally introduced by J. J. Sylvester in the 19 th century [27] and in other contexts are called the 'shift' and 'clock' matrices respectively.The X gate has a clear classic analogue which simply adds 1 modulo d to a dit and is the natural extension of a bit flip (0 → 1, 1 → 1 + 1 = 0 modulo 2).In contrast, the Z gate creates complex phase factors which do not have any obvious classical equivalent.These structures can be extended to continuous variables, which provide a quantum counterpart to classical analog computers.Classical analog computers predate the invention of the digital computer, and are based on continuous degrees of freedom which take values on the real line R (in the ideal case).The general theory of such machines was not developed until the work of Shannon in the mid-20 th century [28], which he based on J. Thompson's 19 th century mechanical differential analysers [29].In the formative years of the digital computer, analog computers were still superior for a variety of tasks.A quantum continuous variable (QCV) [30,31] has a general state where |q is some continuously parameterised state of the system, e.g., position in 1D, which again (in this context) is called the computational basis and ∞ −∞ dq |ψ(q)|2 = 1 as |ψ(q)| 2 is the probability density for q.The ψ(q) function is simply the quantum wavefunction familiar from elementary wave mechanics.The normalisation condition implies that the basis states themselves, i.e., the |q , are not physical as they are associated with a delta function ψ(q ′ ) = δ(q ′ − q) and the integral of |δ(q ′ − q)| 2 is divergent 2 .However, they can be approximated, for example by a Gaussian wave function centred on q with a narrow peak, known as a squeezed state [31].The basic operators in QCV quantum computation are again known as the Pauli operators and are given by X(q ′ )|q = q + q ′ , Z(q ′ )|q = e iqq ′ |q , where as before, the X gate has the natural classical analogue of addition.In certain contexts (especially quantum optics), these operators are often replaced by the entirely equivalent displacement operators, with the difference simply one of convention. 3The Pauli X and Z gates are more convenient for quantum computing because they are the natural notation for quantum error correction [12,13,32].While essential for practical quantum computers to mitigate the effects of decoherence on fragile quantum states, quantum error correction is beyond the scope of this review.It is clear that the basic structures for qubits, qudits and QCVs are all equivalent.This can be made particularly evident in the following way: for a qudit let X(q) ≡ X q , Z(q) ≡ Z q with integer q, and for a QCV define the dimensionality constant d to be d = 2π.Then in all cases the Pauli operators obey for q and q ′ restricted to integers for qudits and any real number for QCVs, as will be implicitly assumed from now on.Note that here we still have that ω 2πi/d .These ideas allow us to consider quantum computation in a largely dimension-independent fashion, which will be particularly useful when describing ancilla-based models in Section 3. The Pauli operators play a central role in quantum computation due to their many useful properties.One property that will be used later is that they commute up to a phase, specifically Confirming this is the case for qubits (ω = −1, q, q ′ are integers) via matrix multiplication of the ordinary 2×2 qubit Pauli gates is easily done, and for qudits and QCVs is still straightforward.This commutation relation is essential in the definition of the Pauli group and hence the Clifford group [33][34][35] which play a key role in, for example, the theory of error correction and fault tolerance [12,13], measurement-based quantum computation [36][37][38], and in understanding the fine line between universal quantum computation and efficiently classically simulatable quantum computation [33][34][35]39].

Translations in phase space
In order to provide an intuitive picture for the action of the Pauli operators, and as an essential ingredient in the ancilla-based models that are the main subject of this review, it will be helpful to introduce the Fourier transform gate F .As its name suggests, it is simply the unitary representation of discrete and continuous Fourier transforms for qudits and QCVs respectively.Hence, for a qudit it is given by and for a QCV the sum is replaced by an integral, with Note that for qubits, F = 1 1 1 −1 / √ 2, which is more commonly known as the Hadamard gate and often denoted H.For a QCV, it is a particularly natural operator in any system governed by the quantum harmonic oscillator Hamiltonian, e.g., a micro-mechanical resonator [40] or a single light mode [41,42].This operator is ubiquitous in quantum circuits, and its multi-system generalisation is a key ingredient in many quantum algorithms, e.g., Shor's algorithm [1,2].By applying the Fourier transform to the computational basis the conjugate basis states are obtained, denoted |+ q ≡ F |q .They are equal superpositions of all possible computational basis states, e.g., for a qudit |+ 1 is They are states of maximal uncertainty in terms of the outcomes of computational basis measurements (and vice versa) which is a property inherited directly from their relationship to a Fourier transform, and hence important in areas such as measurement-driven gates (as will be seen later) and teleportation [43].In the conjugate basis, the roles of the Pauli operators are reversed, more precisely The actions of the Pauli and Fourier transform operators can be intuitively summarised in phase space as shown in Fig. 4.
Figure 4. Powers of the Pauli operators may be represented as translations in phase space along computational basis and conjugate basis axes.The Fourier transform is a π/2 rotation in phase space.For a QCV the background phase space is the plane of real numbers and for a qudit it is a d × d discrete (and periodic) lattice.There is a wide range of rigorous and powerful phase space methods, e.g., quasi-probability distribution functions [44,45].However, here, phase space will be used only as an intuitive schematic aid.

Interactions between quantum systems
So far, all the operations described have applied to one quantum system -a qubit, qudit or QCV system.For quantum computing, there is one further crucial ingredient: interactions between two quantum systems.The quantum gate often considered is the sum gate (called cnot for qubits) given by as adding the value of two quantum variables is naturally a useful computational resource.It is clear that sum may entangle the two quantum systems as, for example, and for qubits this is ) which is one of the famous Bell-states, at the heart of many quantum information protocols (e.g., teleportation [43] and cryptography [46]) and the modern formulation of the hotly-debated Einstein-Podolski-Rosen paradox [47].The sum gate is a particular case of an important class of gates that are ubiquitous in quantum computation: the controlled-u gates, denoted Cu, with the action for some unitary u.Hence, sum = CX(1).Controlled-gates can be defined on hybrid variables (e.g., a 'control' qubit and a 'target' QCV, with u a gate that acts on a QCV), and such hybrid gates will be used throughout Section 3. Having reviewed the basics operations for qubits, qudits and QCVs we now turn our attention to quantum computation.

Universal quantum computation
A universal quantum computer consisting of qudits is a device which can implement any global unitary operation U on a prepared quantum input state of the qudits |Ψ input , and measure the result, The situation for QCVs is a little more subtle, and instead of needing to implement any unitary only a physically reasonable subset is considered.This technicality is ignored for now and is explained in more detail below.It turns out that, like classical digital and analog computation, any quantum computation can be implemented by a sequence of elementary operations.Moreover, the only basic gates that are required for universal quantum computation are any two-body entangling gate, combined with a choice of local gates sufficient to implement, or approximate, any other local gate [48,49] (a local gate is one that acts on a single subsystem, e.g., F ).This idea is summarised in the circuit diagram of Fig. 5.The gates so far introduced (sum, X(q), Z(q), F ) are not a sufficient set of gates to implement any quantum computation (implied by the Gottesman-Knill theorem and its extensions [33-35, 39, 50]).The simplest additional gate for qubits is the T gate, which adds a phase of π/8 to the |1 component of a qubit, and more generally gates which implement appropriate phases can elevate this set to universality in all dimensions [49,51,52].However, the choice of elementary gates is often determined by the most natural operations in the particular quantum system, see Section 4, and where it is possible to implement a larger range of local gates this will enable more efficient quantum programs.As already noted, for QCVs the computational basis contains a continuum of basis states.Hence, an arbitrary unitary transformation is defined by a continuum of parameters for QCVs, and cannot therefore be decomposed into a finite sequence of computational gates.An alternative definition of universal quantum computation for QCVs was give by Lloyd and Braunstein [49] in 1999.It works by constructing a physically reasonable set of unitaries from the bottom up: The Pauli operators for a QCV may be related to the Hermitian position and momentum operators x and p which obey the canonical commutation relation [x, p] = i, via X(q) = e −iq p and Z(q) = e iq x.The computational and conjugate basis are the eigenstates of x and p respectively.Using these operators, a good definition of a universal QCV computer is one which by composing its basic gates can implement any unitary of the form U = e ipoly(x1,p1,...,xN ,pN ) , where poly(x 1 , p1 , . . ., xN , pN ) is any real polynomial in the x and p operators of each of the N QCVs.For example, a possible polynomial for two QVCs is ax 3 1 + bp 2 1 p2 + cp 7 2 for real a, b and c.This set of unitaries is sufficient to implement useful quantum computations [49].
As we've now seen, the mathematics of quantum computation is pretty much the same whatever the dimension of the underlying quantum system.But qubits are clearly simplest, so there must be good reasons to consider using higher dimensional systems.One good physical motivation is that many quantum systems naturally allow for a qudit or QCV encoding, for example, atoms and ions have many electronic energy levels; coherent states of light or other electromagnetic radiation are the archetypal QCVs, and are some of the most straightforward experimental systems to prepare and manipulate: discussions of relevant proposals and experimental progress in this area are deferred to Section 4. And there are also more abstract advantages.For qudits, there is the potential for a log 2 (d) reduction in the number of gates and subsystems required for a computation, although this is countered by the increased complexity of each gate and any advantages would depend on the details of a given set-up [53,54].Moreover, a further advantage is that qudit algorithms have been shown to exhibit increased robustness and success probability [55][56][57] and particularly striking recent results show that qudit quantum error correcting codes possess remarkable improvements with increased qudit dimension [58][59][60][61][62][63].Turning to QCV, some problems are clearly most naturally encoded using continuous parameters.However, QCVs are potentially most suited to a type of hybrid quantum computation which uses different types of encoding simultaneously, e.g.qubits combined with QCVs.Such a device could have the advantages of discrete and continuous variables simultaneously and this has been used to construct simpler algorithms for finding eigensystems [64,65].A natural choice for a quantum bus is a QCV system, and there are diverse examples that have been proposed and implemented [15-18, 66, 67].The next section will explore the options for hybrid-and ancilla-based quantum computing in more detail.

Ancilla-based quantum computation
Implementing quantum computation on a register requires both isolating individual subsystems to minimise decoherence, and applying precisely controlled interactions between subsystems to implement the computation.The tension between these demands is one motivation for sidestepping direct interactions and instead mediating interaction gates via an ancillary system.This allows the register to be specifically tailored for long coherence times and interactions are only required with some physically distinct ancillary systems that naturally interact with the elements of the main register and which exhibit complementary properties, such as easy manipulation.Another big advantage is that the ancilla can mediate interactions between register subsystems that are not next to each other, thus avoiding the need to move subsystems around, or swap their states onto adjacent subsystems for direct interactions.Clearly, the register and ancillas need not be of the same type.Hence, this is a natural setting for hybrid quantum computation.Implementing universal quantum computation via ancillas may be summarised by the schematic circuit diagram of Fig. 6.

Main register
Ancillary register Figure 6.A circuit diagram illustrating the ideas of universal quantum computation via ancilla-mediated gates.The elements of a main computational register and ancillary register interact via some ancilla-register interaction gates (black connecting lines).Further computational resources that may be required are local gates on the main register (blue boxes), local gates on the ancilla (red boxes), ancilla measurements (black measuring devices) and ancilla state preparation (controlling the |Φ A states).
There are essentially two basic techniques that are used to implement gates via ancillas.The first is delocalising the quantum information in a register system across the system and an ancilla.To illustrate this for qubits: A general state of a register qubit is given by |Ψ = α|0 + β|1 , and by preparing an ancilla in the state |0 and interacting via cnot (the qubit sum gate) then The information encoded in the values of α and β then resides non-locally in both qubits and manipulations of the ancilla will affect the state of the logical qubit (α|0 + β|1 ) and can be used to entangle it with further register qubits.To complete a gate of this type, the logical qubit must be relocalised into the register (here this can be achieved by applying a second cnot gate).This technique is the basis of all of the gate methods reviewed in Sections 3.1 to 3.3 and much of Section 3.4.An alternative to delocalising the quantum information stored in a register systems is to transfer it completely into the ancillary system, i.e.,

|Ψ |Φ
defining the swap gate.Obviously, manipulations of the ancilla will then transform the logical |Ψ state, which must then be swapped back into the register to complete the gate.The swap gate cannot create entanglement, and hence cannot be used as the only two-body gate in quantum computation.Nevertheless, this technique may be utilised in a slightly more subtle fashion for resource-efficient ancilla gates, as will be seen in the latter part of Section 3.4.

Geometric phase gates
Register-controlled Pauli gates on ancillas may be used to construct a particularly useful class of ancilla gates: geometric phase gates.We will first illustrate this using qubits for the register and ancillas.Consider the gate sequence of Fig. 7. What is its action on the ancilla?Well, if the two register qubits are in the states |q 1 and |q 2 respectively, then using the definition of a controlled gate (see Eq. ( 6)) the operator applied to the ancilla is Hence, it has no net effect (i.e., an identity) on the ancilla, but regardless of the ancilla state adds a −1 phase if q 1 = q 2 = 1.This is exactly the action of the two-qubit entangling gate CZ on the two register qubits.Hence, by interacting each qubit with an ancilla twice, an entangling gate between the two register qubits has been mediated -this is precisely the idea of ancilla-based gates.This gate then facilitates universal quantum computation when augmented by a sufficient set of local gates.
: : This same basic scheme can mediate gates with register and ancilla of any (and possibly different) variable types using register-controlled Pauli gates on the ancilla: the only restriction is that if the register consists of QCVs the ancillas must also be QCVs as will be implicitely assumed in the following.This gate was originally proposed by Milburn [68] in the context of a QCV bus and a qubit register, and this idea has been further developed in [17,[69][70][71][72][73][74][75][76][77].In general, the Pauli gates commute up to a phase as was seen in Eq. ( 3), and that relation clearly implies that This may be understood pictorially in phase space as a closed loop creating an area-dependent phase as shown in Fig. 8. Global phases have no physical consequence in quantum mechanics, however, by repeating the qubit recipe above, this can be turned into a controlled geometric phase.This is achieved by acting these gates on an ancilla with the Z(•) Pauli gates controlled by one register system and X(•) Pauli gates controlled by a second register system.This implements an entangling gate between the two register systems as shown in the circuit diagram of Fig. 9. Specifically, for the register systems in the states |q 1 and |q 2 respectively, the action on the ancilla is which is a phase controlled by the state of the two register systems.Such a gate is in general called a controlled phase gate, denoted CR(θ) where R(θ)|q = e iθq |q is parameterised by the phase angle θ.The exact gate enacted on the register here has a parameter θ fixed by the gate variables p 1 and p 2 and the variable type of the ancilla (in general, θ = 2πp 1 p 2 /d).For clarity, we consider the three cases individually: • Qubit ancilla: θ = p 1 p 2 π with p 1 and p 2 integers.
In all cases, this is sufficient for universal quantum computation when augmented with local controls.However, the ancilla type restricts what controlled phase gates may be applied to the register, with less restriction as the dimension of the ancilla increases, e.g, a qubit ancilla can only implement ±1 phases.In the QCV ancilla case, the gate parameters may be chosen to implement a CZ gate for a register of any variable type as there is total freedom to pick the value of θ.In all cases, as the ancilla is left unchanged by the gate, it may be either reused, discarded or reset to remove any residual entanglement from imperfect operation.This analysis considers only the ideal case of perfect implementation, and in reality decoherence of the ancilla during gate implementation will be unavoidable in experimental settings, resulting in decoherence in the systems coupled to the ancilla and imperfect gate implementation.However it has been shown by Louis et al. [72] that for a photonic ancilla this gate method is sufficiently robust for low to medium decoherence.
Figure 9. Register systems may be entangled via an ancilla using register-controlled Pauli gates.This translates the ancilla around a closed phase space loop with the area dependent on the state of the register systems, and hence effects an entangling gate on the register.It will be seen later that the 'disentangling stage' may be replaced by a measurement of the ancilla.

Efficient gate compositions
The geometric phase gate described above is sufficient for universal quantum computation on the register (assuming the addition of local controls), and hence any gate sequence can be implemented by repeated application of such gates.Moreover, the gate can be adapted to implement some common gate sequences in a more efficient fashion.It is essentially trivial that Z(q N ) . . .Z(q 2 )Z(q 1 ) = Z(q N + • • • + q 2 + q 1 ), (9) and similarly for X(q) gates.Hence, consider the gate sequence in Fig. 10 in which many variables, separated into 'control' and 'target' registers of N and M variables respectively, interact in turn with an ancilla.If the j th variable in the control and target registers are in the state |c j and |t j respectively, then using Eq. ( 9) and then applying Eq. ( 8) it may be confirmed that this sequence maps the ancilla to Expanding the brackets shows that this is N × M controlled rotation gates: one between each of the systems in the control register and each of those in the target register.Hence this implements a number of gates that is quadratic in the number of target and control systems (N × M ) using only a linear number of operations (2N + 2M ), creating a substantial saving in the number of two-body interactions over a gate-by-gate method.However, the rotation parameters in the gates implemented cannot all be independent [75] -there are only N + M parameters in the ancillamediated gate sequence.Furthermore, the range of gates that can be implemented depends on the dimensionality of the ancilla (e.g., if it is a qubit all gates are either the identity or CZ as ω = −1) [70], with increasing freedom with increasing dimension.This illustrates the subtle nature of any advantages gained from using a higher-dimensional ancilla.In the context of a qubit register and QCV ancilla, this principle has been applied to design more intricate sequences of operations for increasing efficiencies in quantum simulation [75] and for making cluster states [74,76,78] with comparisons with what can be achieved using a qudit ancilla given in [70].Equivalent ideas directly carry over to a register of qudits although this has yet to be investigated in detail.Similar methods can be used for a highly efficient implementation of a generalised Toffoli gate on a register of qubits using a qudit bus [79].The generalised Toffoli gate has N control qubits and a single target qubit, and implements the unitary u on the target only if all the control qubits are in the state |1 , i.e. it is the map The Toffoli gate plays an important role in quantum computation, for example, it appears in many error correcting codes [80] and is a natural component in a variety of quantum algorithms [81].Hence efficient decompositions are of interest.The importance of the Toffoli gate is linked to the fact that the ordinary Toffoli gate (N = 2, u = X) is a valid classical 3-bit gate and alone is universal for classical reversible computation [81].The addition of only the Hadamard gate, or indeed any basis changing gate [82], is enough to make this universal classical set become universal for quantum computation.A very simple technique may be employed to efficiently implement this gate via a qudit ancilla: the ancilla is used to count the number of qubits in the |1 state.To write this value into the ancilla it is initialised to |−N (i.e., to d − N ≡ −N mod d) and the 'entangling' stage of Fig. 11 is applied, mapping Hence, the bus is in the state |0 when c 1 + • • • + c N = N , i.e., when all of the qubits are in the |1 state, as long as d > N (otherwise the modulo d nature of the addition will come into play).Therefore, if a gate is implemented on the target subsystem controlled on whether the ancilla is in the state |0 this implements the required u c1×•••×cN gate on the target.By inverting the counting stage, the gate is completed.This requires 2N + 1 gates, which is more efficient than any known scheme using qubits alone [83].A variation on this method has been demonstrated experimentally with photonic qubits [84].These ideas are not dependent on the register consisting of qubits and may be adapted to many-qudit gates, although as far as we are aware this has not been investigated.This idea also applies in principle for a QCV bus.However, in this case the scheme requires a gate which only implements u on the register if the bus is exactly in the state |0.000 . . .and such a gate is unphysical.Suitable approximations may be valid and useful, but have not so far been investigated.
Correlations between errors on different register systems can cause problems for quantum errorcorrection [13] and errors of this sort will be created if many systems are coupled simultaneously to a bus.There will then be a trade-off between reducing gate counts and introducing these problematic errors, and this optimisation has been considered by Horsman et al. [76] confirming that gate-count reductions of this sort may indeed prove useful in practice.
Ancilla gates use (in general) hybrid variables and hence are already hybrid quantum computation in one sense.However, the focus has been entirely on implementing gates on the register and has not considered whether some computation may also be implemented explicitly in the ancilla.Since many ancillas will be needed to implement gates in parallel: the computation will employ a main computation register and an ancillary register, as was shown in Fig. 6.Interestingly, the ancillaregister interaction gates considered so far (hybrid-variable controlled Paulis) along with local controls also allow universal quantum computation on both the main and the ancilla registers, i.e., may be used for truly hybrid computation [64].

Entangling gates using ancilla measurements
The geometric phase gate requires four ancilla-register interactions: two with each register system.This is because both register systems entangle with (or delocalise into) the ancilla; to disentangle them requires two further interactions.This may be particularly inconvenient if, for example, the register systems are distant and the bus is a light pulse sent between them.To avoid repeated interactions with the same ancilla requires going beyond unitary gates and using a measurement of the ancilla, see figure 12.
Figure 12.A schematic of two register systems interacting sequentially with a bus followed by a measurement of the bus.An entangling gate may be implemented on the register in this fashion.
Consider again register and ancilla qubits and the gate sequence of Fig. 7.If the ancilla is prepared in the state |+ 0 then for the register qubits in the states |q 1 and |q 2 respectively, the action on the ancilla from the first two gates is which may be confirmed from Eq. ( 4).As we have already seen, the remaining two gates in Fig. 7 may be used to disentangle the ancilla from the register.However, instead it may be disentangled by a measurement that is specifically chosen to reveal no information about the state of the register qubits.A suitable choice is a measurement which projects onto the computational basis states |0 and |1 with measurement outcomes 0 and 1 respectively, termed a computational basis measurement.This reveal no information about the register because the outcomes 0 and 1 each have a probability of a half regardless of the values of q 1 and q 2 .For measurement outcome m, the April 4, 2016 0: 16 Contemporary Physics Hybrid˙quantum˙computing˙with˙ancillas action on the register qubits is found by applying m|, using the relation m|q = (−1) qm / √ 2 and renormalising.The (−1) q1q2 phase creates a CZ exactly as with the unitary geometric phase method, however there is now an additional phase as though a Z(m) gate has also been applied to the first qubit (Z(m)|q = (−1) mq |q for qubits).Because the value of m is known, local controls may then be used to correct this error by applying Z(−m) to the first qubit.
This technique may be used to replace the 'disentangling' stage of all the gate methods considered so far with a measurement, and is valid with all the combinations of variable types for the register and ancilla we have considered.For any variable, a computational basis measurement is simply one which projects the ancilla onto |m with measurement outcome m.The measurement always creates an additional error gate (or gates) and when the register and ancilla variable types match this is Z(m), but in other cases it is not a Pauli gate and this is important later. 4In all cases, local controls may be used to remove this error.There are many variations on this basic measurementinduced gate method, including using different preparation states, interactions, and measurements, e.g., see [17,85], although all gates work on the principles outlined above.A further closely related technique is indirect measurements of photons (quantum non-demolition detectors) [17].

Implementing gates using minimal control
From a physical perspective, the implementation of a gate between an ancilla and register subsystem pair is achieved by evolving them via some interaction Hamiltonian Ĥint .In some cases, applying this interaction for a varying length of time may well be possible, allowing a continuously parameterised family of interaction gates U (t) = e −i Ĥintt/ .However, to implement additional interactions which are not of this form would require the engineering of more than one basic interaction (e.g, via varying a parameter in the Hamiltonian) and in general this may not be possible or may substantially complicate an experiment.For this reason, gate methods which require only a single fixed interaction Hamiltonian are preferable.Notably, this is the case with the geometric phase gate, and the measurement-based adaption discussed above.This is because CZ(p) gates with different p values can be achieved with one physical interaction via different interaction times.Furthermore, CX(p) gates can be generated via CZ(p) and local Fourier transforms as shown in Fig. 13.This may be easily confirmed from the relation X(−p) = F Z(p)F † and the definition of a controlled gate.= Figure 13.A controlled X gate can be generated using Fourier transforms and a controlled Z gate.
It is interesting to consider whether the required physical controls can be limited still further.In general, access to individual ancilla and register subsystems to apply local gates may not be straightforward or even possible, e.g., in scatting-based interactions [86], and limiting access to the register may be useful for further reducing sources of decoherence.Motivated by these ideas, methods to implement universal quantum computation on a register using only a single register-ancilla interaction gate along with ancilla-preparation [51,70] and in some cases ancilla measurement [51,87,88] have been developed.The idea behind these models is summarised in Fig. 14, and these gate methods are now explained.Ancilla-based gate schemes may be used to implement universal quantum computation on a register using only a single fixed interaction gate (red interactions) in conjunction with ancilla-preparation [51,70] and in some cases aided by measurments of the ancillas [51,87,88].
We first consider the ancilla-driven quantum computation model which was introduced by Anders et al. [87] for qubit computation.Recently, this has been extended to qudits [51] and QCVs [88].Interestingly, this model requires the ancilla and register systems to consist of the same variable type and size (same d for qudits).As the idea is to implement universal quantum computation using only one fixed unitary gate, it is clear that this must be carefully chosen.The simplest suitable choice is a controlled-Z gate followed by an F and F † gate on the register and ancilla subsystems respectively, as shown in Fig. 15 (a).(The three elementary gates are combined into a single two-system gate.)Interacting two register systems in turn with the ancilla using this gate, followed by a computational basis measurement of the ancilla, implements an entangling gate on the two register systems as shown in Fig. 15 (b).By considering the effect of this sequence on the ancilla, it can be confirmed that this is essentially identical to the measured adaption of the geometric phase gate considered in Section 3.3.As before, the measurement creates an error gate on the register, which is a Pauli gate as the ancilla and register are of the same variable type.The addition of a method for implementing a universal family of local gates (i.e., a set of local gates that can generate any local gate) on any register subsystems is sufficient to make this scheme a universal quantum computer.Applying a gate from such a set on a register subsystem is achieved by an interaction with an ancilla followed by measuring the ancilla, with the measurement fixed by which gate from the family is to be implemented.Again, the desired gate is implemented only up to a Pauli error.This gate method is shown schematically in Fig .15 (c).To be more explicit, we briefly consider the details of how this is achieved in the qubit case.For the register qubit in an arbitrary state α|0 + β|1 the fixed interaction gate maps By performing a measurement which projects the ancilla onto |θ m = R(−θ)|+ m with outcomes m = 0 or m = 1 the gate v(θ) = HR(θ) is implemented on the register qubit (followed by a Pauli error), which may easily be confirmed by applying θ m | to the above expression.By varying θ, the April 4, 2016 0: 16 Contemporary Physics Hybrid˙quantum˙computing˙with˙ancillas v(θ) gates are well-known to be sufficient to generate any single-qubit gate [81].The generalisation to other variable types is straightforward and simply requires a natural generalisation of R(θ), see [51,88], but for brevity we do not review it here.The measurement-induced errors might initially appear to be problematic as local controls have been assumed to be unavailable.However, these error gates can be commuted through to the end of the computation by changing some of the measurement basis parameters depending on preceding measurement outcomes along with some basic classical computations.The errors may then be absorbed into the final measurements of the register.This technique is often called classical feedforward and is used in cluster-state quantum computing [36].It works only because the errors are Pauli gates and is most easily understood in terms of the Clifford group (the entangling gate here is a Clifford gate) which is beyond the scope of this review.The classical computation required to keep track of the corrections is simple but non-trivial in how it contributes to the overall computation [89].
The ancilla-driven model has been intensely studied recently, including: an analysis of gate errors obtained from inaccurate measurements [90]; a investigation of the suitability of this model for secure quantum computation [91]; and adaptions to allow for both a greater range of interactions [92], and fixed measurements [51,93] which produce schemes which are universal only using probabilistic so-called repeat-until-success gate implementations.An interesting question is whether an interaction locally equivalent to CZ is the only gate that may be used to implement ancilla-driven quantum computation.It turns out that it is not: the alternative is based on a swap gate, as introduced in Eq. ( 7).Specifically, it utilises the interaction swap • CZ, and requires only minor changes to the model [51,87,94].
However, there is a perhaps more interesting way to implement quantum computation using ancillas and this swap-type interaction, by returning to globally unitary dynamics as were used in the geometric phase gates.The action of swap • CZ on the computational basis states is and hence if the ancilla (or the register) subsystem is in the |0 state it simply acts as a swap gate.By interacting with a second register subsystem, this then implements an entangling gate between the logical register subsystem residing in the ancilla and this second register subsystem (the gate is swap • CZ).A second interaction of the ancilla with the first register subsystem simply swaps the logical information back into the register and the overall effect is the application of swap • CZ to the two register systems [70,95].Local gates may easily be applied to a register subsystem by swapping it into the ancilla, applying the gate, and swapping it back out [95] as shown in Fig. 16.Conveniently, the same methods hold with a less restricted swap • CR(θ) interaction.
. An ancilla-register swap • CZ interaction gate (or the more general swap • CR(θ)) may be used to implement universal quantum computation in conjunction with local gates on the ancilla.Here the circuit shows how a local gate may be applied to a register subsystem by swapping the register subsystem into the ancilla, applying the gate, and swapping it back out.This is because CZ acts as the identity when either system is in the |0 state.The crossing wires represent swap.
The gate method for local gate on the register with the swap-type interaction described above has reverted to using unitary local controls (here of the ancilla).If we do not wish to rely on such controls, then with a minor adaption to the interaction it is possible to replace them with ancilla preparation in the different computational basis states, which then determines which local gates are applied to the register subsystem [51,96].For qubits, this is particularly simple: by appending an additional (fixed) local u gate on the ancilla to the interaction (after swap • CR(θ)), two interactions of a register qubit with an ancilla in the state |0 or |1 respectively implement u and R(θ)uR(θ) on the register qubit respectively [96].For qubits there are many choices such that this is a universal set for single-qubit gates (e.g., u = H, θ = π/4).This therefore provides a scheme for doing universal quantum computing, where the program is simply defined by the ordering of the fixed-type interactions between the ancillas and different register subsystems, and by the initial states of the ancillas.Finally, we note that the ancilla-based gate schemes outlined throughout this section have wider applications than just universal quantum computation, where they are very useful as building blocks for practical quantum computer architectures [97].They can also be adapted to prepare exotic quantum states, which are used as resources for many purposes in quantum information (e.g., quantum cryptography [46] or quantum sensing networks [98]), and are interesting from a fundamental perspective.For example, a qudit ancilla may be used to create highly entangled 'W ' and GHZ states using a similar construction [99] to the efficient Toffoli gate in Fig. 11, and so-called 'cat states' of a QCV may be created using a qubit ancilla [100].

Proposals and Implementations
Future designs for a universal, scalable and fault-tolerant quantum computer will likely be based around modular processing units entangled via ancillary systems, as illustrated in Fig. 17.A recent proposal of this type [97] forms the core objective of the Networked Quantum Information Technologies (NQIT) Quantum Technology Hub lead by Oxford University.NQIT aims to construct a scalable network of high fidelity quantum registers linked via more lossy optical ancillas.There are a variety of qubit register implementations that are suitable for this architecture, with one of the most advanced being ion trap technology [101].Promising recent experimental progress has been made in this direction [102].There are a wide range of basic gate implementations that employ ancillary systems.Quantum gates have been implemented by using photonic ancillas to entangle spin [103,104] or atomic [105,106] qubits.Superconducting flux qubits are usually entangled via a transmission line resonator bus [107].They have also been coupled to an ensemble of nitrogen-vacancy (NV) centres in diamond encoding a qubit [108].This may be suitable for linking a register of such NV ensemblebased qubits using ancillary flux qubits [109], with a related proposal in [110].This illustrates an obvious but important point, that any quantum system engineered for useful information processing properties can be considered for both register and ancilla roles, giving a very wide range of options for designing such devices.Spin-ensembles could serve as a long-coherence time register (often called a quantum memory) as such ensemble are naturally resilient to various forms of loss and decoherence [111].
These examples are all implemented or proposed as qubit-based architectures with qubit or QCV ancillas, but many have the potential to support qudit encodings as well, e.g., atoms have many energy levels and harmonic oscillators may encode qudits.The theoretical advantages of adopting April 4, 2016 0: 16 Contemporary Physics Hybrid˙quantum˙computing˙with˙ancillas such qudit-based platforms were discussed in Section 2, and further incentive to explore higherdimensional protocols is provided by a range of impressive experiments demonstrating quantum control of qudits, including superconducting [112], atomic [113] and photonic [114,115] systems.Finally, to relate this discussion to some concrete physics, we consider one particular Hamiltonian: the Jaynes-Cummings model [116], which is relevant for a large range of architectures for quantum computing.This is a canonical scheme which describes the coupling of a qubit to a harmonic oscillator.Mathematically, the Jaynes-Cummings Hamiltonian is given by ; ω is the frequency of the harmonic oscillator; ω 0 is the frequency of the qubit and g represents the qubit-oscillator coupling strength.The Jaynes-Cummings model finds application in describing a wide range of experimental systems including atom-cavity coupling [117], circuit QED [118] and for a variety of qubit types coupling to mechanical oscillators [119,120].A harmonic oscillator naturally lends itself to a QCV encoding, but by encoding a qudit as the first d energy eigenstates of a harmonic oscillator, the Jaynes-Cummings model can also be used to describe a qudit-qubit coupling [121].In the dispersive limit (g/(ω 0 −ω) ≪ 1) this interaction is approximately of the form Ĥeff = σ z â † â [118] (up to local terms) which with the QCV encoding may generate qubit-controlled phase-space rotations.These are an alternative type of ancilla-register gate to the controlled Pauli operators considered throughout Section 3, for which a variety of gate methods closely related to those discussed here have been developed, see e.g., [17,74].However, this interaction may be easily transformed into a controlled Pauli gate [69,73], and hence is also suitable for the gate methods reviewed in Section 3. A qudit-qudit or qudit-QCV hybrid device would require an alternative to the Jaynes-Cummings model, for example the generalised Jaynes-Cummings model, which describes the coupling of a many-level particle coupled to a harmonic oscillator [79], or coupled harmonic oscillators.

Summary
Binary encoding has become the standard for classical digital computers, but there is no a priori reason why binary should also be the best choice for quantum computers.Computation can equally well be carried out in any convenient basis, and with many quantum systems being higher dimensional, it is well worth asking which is the natural basis to use for each possible type of quantum hardware.There are some constraints: Blume-Kohout et al. [122] show that the dimension of the subsystems must not grow faster than logarithmically with the size of the problem in order for the quantum computer to be efficient and scalable, but for practical hybrid systems, subsystem scaling will not be a significant issue.
One good reason for the ubiquity of binary encoding in classical computation is undoubtedly simplicity.However, as we have seen in Section 2, for quantum systems the same formalisms carries over to higher dimensions with few changes: qudits and QCVs are not significantly harder to handle theoretically.There are advantages and trade-offs to using qudits instead of qubits: better performance of error correction [58][59][60][61][62][63], fewer gates [53,54], and more robust algorithms [55][56][57] are set against more complex gate operations and measurements.The problem itself may be more naturally encoded in qudits, or QCVs if the problems has continuous parameters, and this may lead to a simpler algorithm [65].Furthermore, using a heterogeneous architecture in which both qudits and QCVs are available for the same computation allows different components of the problem to April 4, 2016 0: 16 Contemporary Physics Hybrid˙quantum˙computing˙with˙ancillas be optimally encoded [64].
Using ancillas to enact qubit quantum gates was established in some of the earliest proposed implementations of quantum computation [18], and from the start the ancillas were of very different types to the register qubits.The formalism described in Section 2 allows ancilla-based quantum gates to be described in a similar framework for all dimensions of register and ancillas, as was presented in Section 3. To simplify the experimental requirements, schemes with a single, fixed interaction between register and ancillas are the most useful.This minimises the disturbance to the register qubits, preserving quantum coherence for longer.It is possible to minimise the interactions to the point where universal quantum computation can be performed by a sequence of ancillaregister interactions plus preparation of the ancillas in different computational basis states [51,96].
The tools presented here for describing quantum computation using ancillas to enact the basic quantum gates allow quantum engineers to take a fresh look at the possibilities for their preferred quantum systems, to choose combinations that optimise their best properties and hence deliver a scalable universal quantum computer with fewer quantum resources.

Figure 3 .
Figure 3.The d distinct d th roots of unity are integer powers of ω = e i2π/d and reside on the unit circle in the complex plane, illustrated here for d = 8.

Figure 7 .
Figure 7. Two register qubits may be entangled via CZ and CX (cnot) gates acting on an ancilla qubit.

Figure 8 .
Figure 8.A closed loop of Pauli operators creates an area-dependent geometric phase

Figure 10 .
Figure 10.Illustration of how gate sequences can be compressed for suitable sequences of gates.This enacts a controlled rotation between each control and target pair of register systems.

Figure 11 .
Figure 11.The N -qubit generalised Toffoli gate applies some given unitary u to a target qubit only if all n control qubits are in state |1 .This may be implemented using only 2N + 1 interactions with an ancillary qudit with dimension d > N using the sequence shown here for N = 3.The qudit controlled gate implements u on the register qubit when the qudit is the state |0 .

Figure 14 .
Figure 14.Ancilla-based gate schemes may be used to implement universal quantum computation on a register using only a single fixed interaction gate (red interactions) in conjunction with ancilla-preparation[51,70] and in some cases aided by measurments of the ancillas[51,87,88].

Figure 15 .
Figure 15.Universal quantum computation is achieved in the ancilla-driven model using only a fixed ancilla-register interaction gate and measurements of the ancilla using two gate methods.(a) The form of the fixed interaction, decomposed into local and entangling gates.(b) An entangling gate is implemented up to a Pauli error via two interactions and a measurement (specifically, Uent = (F ⊗ F ) • CZ).(c) A universal set of local gates may be implemented up to a Pauli error via an interaction and measurement which depends on the desired gate.The form of the measurment and the implemented gate v(θ) are specified for qubits in the main text.

Figure 17 .
Figure 17.Many proposals for universal, scalable and fault-tolerant quantum computer utilise fixed-sized registers, or quantum processing units (QPUs), entangled via ancilla or quantum communication buses[97,101].Here ancilla sent at different times are denoted by different coloured arrows.