Katherine L. Brown

Using Quantum Computers for Quantum Simulation

Numerical simulation of quantum systems is crucial to further our understanding of natural phenomena. Many systems of key interest and importance, in areas such as superconducting materials and quantum chemistry, are thought to be described by models which we cannot solve with sufficient accuracy, neither analytically nor numerically with classical computers. Using a quantum computer to simulate such quantum systems has been viewed as a key application of quantum computation from the very beginning of the field in the 1980s. Moreover, useful results beyond the reach of classical computation are expected to be accessible with fewer than a hundred qubits, making quantum simulation potentially one of the earliest practical applications of quantum computers. In this paper we survey the theoretical and experimental development of quantum simulation using quantum computers, from the first ideas to the intense research efforts currently underway.

Ancilla-based quantum simulation

We consider the simulation of the Bardeen, Cooper and Schrieffer (BCS) Hamiltonian, a model of low-temperature superconductivity, on a quantum computer. In particular, we consider conducting the simulation on the qubus quantum computer, which uses a continuous variable ancilla to generate interactions between qubits. We demonstrate an O(N3) improvement over previous studies conducted on an NMR computer (Wu et al 2002 Phys. Rev. Lett. 89 057904 and Brown et al 2006 Phys. Rev. Lett. 97 050504) for the nearest-neighbour and completely general cases. We then proceed to show methods for minimizing the number of operations needed per time step using the qubus in three cases: the completely general case, the case of exponentially decaying interactions and the case of fixed range interactions. We make these results controlled on an ancilla qubit so that we can apply the phase estimation algorithm, and hence show that when N?5, our qubus simulation requires significantly fewer operations than a similar simulation conducted on an NMR computer.

Layer-by-layer generation of cluster states

Cluster states can be used to perform measurement-based quantum computation. The cluster state is a useful resource, because once it has been generated only local operations and measurements are needed to perform universal quantum computation. In this paper, we explore techniques for quickly and deterministically building a cluster state. In particular we consider generating cluster states on a qubus quantum computer, a computational architecture which uses a continuous variable ancilla to generate interactions between qubits. We explore several techniques for building the cluster, with the number of operations required depending on whether we allow the ability to destroy previously created controlled-phase links between qubits. In the case where we can not destroy these links, we show how to create an n x m cluster using just 3nm -2n -3m/2 + 3 operations. This gives more than a factor of 2 saving over a naive method. Further savings can be obtained if we include the ability to destroy links, in which case we only need (8nm-4n-4m-8)/3 operations. Unfortunately the latter scheme is more complicated so choosing the correct order to interact the qubits is considerably more difficult. A half way scheme, that keeps a modular generation but saves additional operations over never destroying links requires only 3nm-2n-2m+4 operations. The first scheme and the last scheme are the most practical for building a cluster state because they split up the generation into the repetition of simple sections.

Dynamical decoupling with tailored wave plates for long-distance communication using polarization qubits

We address the issue of dephasing effects in flying polarization qubits propagating through optical fiber by using the method of dynamical decoupling. The control pulses are implemented with half-wave plates suitably placed along the realistic lengths of the single-mode optical fiber. The effects of the finite widths of the wave plates on the polarization rotation are modeled using tailored refractive index profiles inside the wave plates. We show that dynamical decoupling is effective in preserving the input qubit state with the fidelity close to unity when the polarization qubit is subject to the random birefringent noise in the fiber, as well the rotational imperfections (flip-angle errors) due to the finite width of the wave plates.

Preserving photon qubits in an unknown quantum state with Knill dynamical decoupling: towards an all optical quantum memory

The implementation of polarization-based quantum communication is limited by signal loss and decoherence caused by the birefringence of a single-mode fiber. We investigate the Knill dynamical decoupling scheme, implemented using half-wave plates, to minimize decoherence and show that a fidelity greater than 99% can be achieved in absence of rotation error and fidelity greater than 96% can be achieved in presence of rotation error. Such a scheme can be used to preserve any quantum state with high fidelity and has potential application for constructing all optical quantum delay line, quantum memory, and quantum repeater.

Reducing the number of ancilla qubits and the gate count required for creating large controlled operations

In this paper, we show that it is possible to adapt a qudit scheme for creating a controlled-Toffoli created by Ralph et al. (Phys Rev A 75:022313, 2007) to be applicable to qubits. While this scheme requires more gates than standard schemes for creating large controlled gates, we show that with simple adaptations, it is directly equivalent to the standard scheme in the literature. This scheme is the most gate-efficient way of creating large controlled unitaries currently known; however, it is expensive in terms of the number of ancilla qubits used. We go on to show that using a combination of these standard techniques presented by Barenco et al. (Phys Rev A 52(5):3457, 1995), we can create an n-qubit version of the Toffoli using less gates and the same number of ancilla qubits as recent work using computer optimization. This would be useful in any architecture of quantum computing where gates are cheap but qubit initialization is expensive.

Improving photon detector efficiency using a high-fidelity optical controlled-not gate

A significant problem for optical quantum computing is inefficient, or inaccurate photo-detectors. It is possible to use CNOT gates to improve a detector by making a large cat state then measuring every qubit in that state. In this paper we develop a code that compares five different schemes for making multiple measurements, some of which are capable of detecting loss and some of which are not. We explore how each of these schemes performs in the presence of different errors, and derive a formula to find at what probability of qubit loss is it worth detecting loss, and at what probability does this just lead to further errors than the loss introduces.

Qubus ancilla-driven quantum computation

Hybrid matter-optical systems offer a robust, scalable path to quantum computation. Such systems have an ancilla which acts as a bus connecting the qubits. We demonstrate how using a continuous variable qubus as the ancilla provides savings in the total number of operations required when computing with many qubits.

Robust cluster state generation using ancilla-based systems

Efficient generation of cluster states is crucial for engineering large-scale measurement-based quantum computers. Hybrid matter-optical systems offer a robust, scalable path to this goal. Such systems have an ancilla which acts as a bus connecting the qubits. Ancilla-driven schemes are important for chip-based quantum computing architectures, where the flying ancilla mediates between static qubits. Hybrid architectures form a natural substrate for measurement-based quantum computing (MBQC) [1], one type of which (the topological model) has the best error threshold for quantum computing [2]. In this type of processing a highly-entangled cluster state is generated, and then computation performed by sequential qubit measurements. The quantum processing task is to generate the cluster state, after which it becomes a matter of measurement and classical communication. In physically-realizable implementations the cluster is prepared dynamically, a few layers at a time. As the cluster state is the fundamental quantum resource of a measurement-based computation, it becomes extremely important to make it as error-free as possible. Errors in constructing the cluster can propagate rapidly through a computation because of the highly-entangled nature of the state, leading to failure of the computation. Hybrid systems are susceptible to specific error types that other systems are not, because of the use of the mediating ancilla. In cases where the ancilla is not destroyed after each gate there is a nonzero probability of errors propagating through ancilla reuse. FIG. 1: A cluster of 4 bricks of length b = 5 qubits, each made using a different bus. We present the optimal scheme for dynamic fault-tolerant 2-D cluster state generation in hybrid systems where the mediating system can be used for more than a single gate operation without being reset. We divide the cluster state into “Lego bricks”, each of which uses a single bus. We give the optimal method for constructing the bricks, reducing the number of system-bus entanglements. We then show how to determine the block size based on the error threshold of the system being used. We find that, even when the probability of error in the system is high, this scheme can still deliver significant efficiency savings through bus reuse, enabling a larger cluster to be generated. By reducing the time required to prepare sections of the cluster, bus reuse more than doubles the size of the computational workspace that can be used before decoherence effects dominate [3]. A simple example of the bricks is shown in figure 1. They are always the same height (m direction), but have length b (n direction) determined by [3] 1 i1 − exp[−(6b + 4)γτ − 16bηβ2]¢ ≤ e. (1) 2 For a given set of experimental parameters γ, τ, η and β, and desired dephasing limit to e, this determines b. If we use one bus per CPhase gate to generate a brick, we have 1 i1 − exp[−16bγτ − 4ηβ2]¢ ≤ e. (2) 2 Comparing equations (1) and (2), we find our Lego scheme produces less qubit dephasing than using one bus per CPhase gate provided ηβ2 2. And even for b = 1, the reduction is O(5mn) compared to O(8mn), equivalent to the method of [4] for five qubits per bus. This will thus be the method of choice for any ancilla-based cluster generation that allows bus reuse. Our results are directly applicable to bus-based experimental production of cluster states, enabling the same FIG. 2: Dynamic generation using multiple ancillas. resources to produce dynamically-generated cluster states of twice the size compared to single-gate bus use, see fig. 2. For multi-bus dynamic schemes, fully scalable operation can be achieved with half the coherence time compared to single-gate buses, needing as few as 20 CPhase gates per bus. We thank Aram Harrow, Ashley Stephens and Simon Devitt for useful discussions. CH was supported by EU project QAP and the Bristol Centre for Nanoscience and Quantum Information. KLB is supported by a UK Engineering and Physical Sciences Research Council industrial CASE studentship from Hewlett-Packard, VMK is supported by a UK Royal Society University Research Fellowship and WJM acknowledges partial support from the EU project HIP and MEXT in Japan.