ITERATIVE CONSTRUCTION OF STATIONARY QUANTUM STATES USING QUANTUM COMPUTERS

Abstract

Methods, systems and apparatus for preparing a target quantum state of a quantum system, where the target quantum state is stationary with respect to a parameterized many-body qubit operator. In one aspect a method includes preparing an initial quantum state as an input state for a first iteration; iteratively evolving the initial quantum state and subsequent input quantum states as inputs for subsequent iterations until an approximation of the target stationary quantum state is obtained, comprising, for each iteration: computing, by quantum computation, parameter values of the many-body qubit operator for the iteration; computing, by quantum computation, an evolution time for the iteration, comprising evaluating changes in elements of a 2-RDM for the iteration; and evolving the initial quantum state or the subsequent input quantum state for the iteration using the computed parameter values and evolution time to generate a subsequent input quantum state for the subsequent iteration.

Description

BACKGROUND

This specification relates to quantum computing.

Classical computers have memories made up of bits, where each bit can represent either a zero or a one. Quantum computers maintain sequences of quantum bits, called qubits, where each quantum bit can represent a zero, one or any quantum superposition of zeros and ones. Quantum computers operate by setting qubits in an initial state and controlling the qubits, e.g., according to a sequence of quantum logic gates.

SUMMARY

This specification describes an iterative process for constructing stationary quantum states on a quantum computer.

In general, one innovative aspect of the subject matter described in this specification can be implemented in a method for preparing a target quantum state of a quantum system, wherein the target quantum state is stationary with respect to a parameterized many-body qubit operator, the method comprising: preparing an initial quantum state as an input state for a first iteration; iteratively evolving the initial quantum state and subsequent input quantum states as inputs for subsequent iterations until an approximation of the target stationary quantum state is obtained, comprising, for each iteration: computing, by quantum computation, parameter values of the many-body qubit operator for the iteration; computing, by quantum computation, an evolution time for the iteration, comprising evaluating changes in elements of a two-electron reduced density matrix for the iteration; and evolving the initial quantum state or the subsequent input quantum state for the iteration using the computed parameter values and evolution time to generate a subsequent input quantum state for the subsequent iteration.

Other implementations of these aspects include corresponding computer systems, apparatus, and computer programs recorded on one or more computer storage devices, each configured to perform the actions of the methods. A system of one or more classical and/or quantum computers can be configured to perform particular operations or actions by virtue of having software, firmware, hardware, or a combination thereof installed on the system that in operation causes or cause the system to perform the actions. One or more computer programs can be configured to perform particular operations or actions by virtue of including instructions that, when executed by data processing apparatus, cause the apparatus to perform the actions.

The foregoing and other implementations can each optionally include one or more of the following features, alone or in combination. In some implementations evaluating changes in elements of the two-electron reduced density matrix for the iteration comprises evaluating first order derivatives and second order derivatives of elements of a two-electron reduced density matrix for the iteration.

In some implementations computing, by quantum computation, an evolution time for the iteration comprises computing

${\lambda }_i=-\frac{\langle H❘D_i^{\prime }\rangle }{\langle H|D_i^{″}\rangle }$

where λ_i represents the evolution time for the iteration i, H represents a Hamiltonian characterizing the quantum system, D′_i represents a first order derivative of elements of the two-electron reduced density matrix for the iteration and D′_i represents a second order derivative of elements of the two-electron reduced density matrix for the iteration.

In some implementations evaluating first order derivatives and second order derivatives of elements of the two-electron reduced density matrix for the iteration comprises using cumulant expansions.

In some implementations computing, by quantum computation, parameter values of the many-body qubit operator for the iteration comprises performing measurements of a 3-RDM.

In some implementations-evolving the initial quantum state or a subsequent input quantum state for the iteration using the computed parameter values and evolution time to generate an input quantum state for the subsequent iteration comprises approximating time evolution of the many-body qubit operator at the computed parameter values using a low rank double-factor decomposition.

In some implementations the low rank decomposition is implemented on a linear lattice of qubits with linear depth.

In some implementations evolving the initial quantum state or a subsequent input quantum state for the iteration using the computed parameter values and evolution time to generate an input quantum state for the subsequent iteration comprises approximating time evolution of the many-body qubit operator at the computed parameter values using a unitary compression of the many-body qubit operator.

In some implementations the unitary compression of the many-body qubit operator expresses the many-body qubit operator at the computed parameter values in a sum-of-squares form.

In some implementations the target stationary quantum state comprises a ground or excited quantum state.

In some implementations the initial quantum state is non-orthogonal to the target quantum state.

In some implementations the target quantum state comprises a state of a quantum system characterized by a Hamiltonian, and wherein the target quantum state satisfies stationarity conditions given by

ψ|[G,H]|ψ=0,

where |ψ represents the target quantum state, H represents the Hamiltonian characterizing the quantum system, and G represents the parameterized many-body qubit operator.

In some implementations the stationarity condition comprises a first order stationarity condition of the energy with respect to variation of parameters of the many-body qubit operator.

In some implementations the parameterized many-body qubit operator comprises a fermionic two-body qubit operator.

In some implementations the fermionic two-body qubit operator is given by Θ=Σ_ijklθ_ijkla_i^†a_j^†a_k a_l, where i,j,k,l are indices representing quantum system orbitals, θ represent real valued coefficients and a_j^†, a_k represent creation and annihilation operators, and the associated energy is given by E(Θ)=ψ|e^−ΘHe^Θ|ψ, where |ψ represents the target quantum state, H represents the Hamiltonian characterizing the quantum system.

In some implementations the target quantum state is represented by a sequence of wavefunction transformations given by

|ψ_i=e^{iλi−1Ai−1}e^{iλi−2Ai−2}|ψ₀

where λ_i represents evolution time for iteration i, λ_i represents the many-body qubit operator with parameter values for iteration i, and |ψ₀ represents the initial quantum state. The subject matter described in this specification can be implemented in particular ways so as to realize one or more of the following advantages.

The presently described techniques can be used to construct quantum circuits that produce target stationary quantum states without the need for variational minimization. The target stationary quantum states can be ground states or excited states.

In addition, the quantum circuits can be compiled using low rank decompositions or unitary compression and therefore have a lower circuit depth, e.g., compared to conventional techniques that implement exact rotations to minimize energy. Accordingly, preparing target quantum states using the presently described techniques requires less computational resources and improves computational runtime. In addition, because of the reduction in circuit depth, the presently described techniques are particularly suitable for implementations that use near term quantum computing devices, e.g., noisy intermediate-scale quantum (NISQ) devices, where gate errors and T1 decay rate can cause long circuits to have noise that overwhelms any signal in the circuit.

In addition, a system implementing the presently described techniques can prepare target quantum states with improved accuracy, e.g., compared to conventional methods that are based on propagation of the anti-Hermitian contracted Schrödinger equation (ACSE) and suffer from non-exact 2-RDM evolution and an accumulation of error.

The details of one or more implementations of the subject matter of this specification are set forth in the accompanying drawings and the description below. Other features, aspects, and advantages of the subject matter will become apparent from the description, the drawings, and the claims.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram of an example quantum computing system that prepares stationary quantum states.

FIG. 2 is a flow diagram of an example process for preparing a target stationary quantum state using a quantum computing system.

FIG. 3 is a diagram of an example quantum computing system.

Like reference numbers and designations in the various drawings indicate like elements.

DETAILED DESCRIPTION

This specification describes techniques for constructing quantum circuits that produce a target quantum state that is stationary with respect to a parameterized many-body qubit operator. An initial quantum state is iteratively evolved until an approximation of the target stationary quantum state is obtained. At each iteration quantum computations are performed to compute parameter values of the many-body qubit operator for the iteration and an evolution time for the iteration. The evolution time is computed by evaluating changes in elements of a two-electron reduced density matrix for the iteration.

FIG. 1 is a block diagram of an example quantum computing system 100 for performing the presently described quantum state preparation techniques. The example quantum computing system 100 is an example of a system implemented as classical and quantum computer programs on one or more classical computers and quantum computing devices in one or more locations, in which the systems, components, and techniques described herein can be implemented.

The example quantum computing system 100 includes a control system 102 that is configured to operate quantum systems, e.g., qubits, included in the quantum computing system 100 and to perform classical subroutines or computations. For example, the control system 102 can be programmed to send control signals to qubits included in the quantum computing system, e.g. to implement a quantum circuit, and to receive readout signals from the qubits, e.g. as part of performing measurement operations. In FIG. 1, the control system 102 performs operations to prepare the quantum system 104 in a target quantum state |ψ. The target quantum state is a quantum state that is stationary with respect to a parameterized many-body qubit operator and can be a ground or excited quantum state. Example target quantum states, stationarity conditions and parameterized many-body qubit operators are described below with reference to FIG. 2.

To prepare the quantum system 104 in the target quantum state, at stage (A), the control system 102 performs operations to set the quantum system 104 in an initial quantum state |ψ₀, e.g., by resetting qubits included in the quantum system 104. The control system 102 then iteratively evolves the initial quantum state |ψ₀ until the target stationary quantum state |ψ₁ is obtained.

At each iteration, the control system 102 performs stages (B)-(D). At stage (B), the control system performs quantum computations to compute parameter values of the many-body qubit operator for the iteration. As described below with reference to Equations (5) and (6), the parameter values A_ijkl computed at stage (B) define an operator A that, when applied to the input quantum state for a time λ, evolves the input quantum state in such a way that minimizes the energy and approximately satisfies stationarity.

To compute the parameter values, the control system 102 performs quantum and classical computations. For example, for each parameter A_ijkl as defined in Equation (6) below, the control system 102 can prepare a copy of the input quantum state for the iteration. The control system 102 can then apply a quantum circuit 108 that effects a qubit encoding of an observable to be measured, e.g., a qubit encoding of the terms in the observable [H, a_i^†a_j^†a_ka_l] as defined in Equation (6) below, to the input quantum state. The control system 102 can then perform a measurement to obtain a respective measurement result. The control system 102 can repeat the state preparation, quantum circuit application, and measurement steps multiple times to obtain multiple measurement results. The control system 102 can then cause a classical processor 110 to post-process the measurement results and compute an expected value of the parameter value. The control system 102 can repeat this process for each parameter value until the many-body qubit operator A can be fully specified.

At stage (C), the control system performs quantum computations to compute an evolution time for the iteration. For example, the control system 102 can compute an evolution time A by computing first order derivatives and second order derivatives of elements of a two-electron reduced density matrix for the iteration, as described below with reference to Equations (9)-(13). To compute the derivatives, the control system 102 performs classical and quantum operations similar to those described above with reference to stage (B). For example, to compute a first order derivative of a 2-RDM element the control system 102 can prepare a copy of the input quantum state for the iteration. The control system 102 can then apply a quantum circuit that effects a qubit encoding of an observable to be measured, e.g., a qubit encoding of the terms in the observable. The control system 102 can then perform a measurement to obtain a respective measurement result. The control system 102 can repeat the state preparation, quantum circuit application, and measurement steps multiple times to obtain multiple measurement results. The control system 102 can then cause a classical processor 110 to post-process the measurement results and compute an expected value of the parameter value. The control system 102 can repeat this process for the terms in Equation (13) until the evolution time λ can be fully specified.

At stage (D), the control system 102 uses the computed parameter values and evolution time to evolve the input quantum state for the iteration. For example, the control system 102 can apply a unitary operator U=e^iAλ to the input quantum state for the iteration to evolve the input quantum state and generate a corresponding output quantum state. In some implementations the control system 102 can store data specifying the unitary operator for the iteration in a cache, e.g., to assist in preparing copies of the input quantum state as part of stages (B) and (C) in the next iteration.

If the iteration is a first iteration, the input quantum state is the initial quantum state |ψ₀ and the output quantum state is the evolved quantum state |ψ₁=e^iA1λ1|ψ₀. For a j-th subsequent iteration, the input quantum state is the output quantum state |ψ_j−1 for the previous (j−1)-th iteration and the output quantum state is a the evolved quantum state |ψ_j=e^iAjλj . . . e^iA2λ2e^iA1λ1|ψ₀. The control system 102 can iteratively perform stages (B)-(D) until a predetermined number of iterations have been completed or until the output quantum state converges to within a predetermined convergence threshold. The predetermined convergence threshold can vary based on a target accuracy of the final output state, e.g., smaller convergence thresholds can produce more accurate final output states.

When the iterative process terminates, the quantum computing system 100 can provide the target quantum state for use in subsequent quantum computations. In some implementations the quantum computing system 100 can store data representing the unitary operator used to evolve the initial quantum state to the target quantum state, e.g., the unitary operator defined in Equation (8) below. Then, when the quantum computing system 100 requires a copy of the target quantum state, e.g., to perform quantum computations, the quantum computing system can retrieve the data representing the unitary operator and apply the unitary operator to an initial quantum state.

Example Process for Preparing a Target Stationary Quantum State

FIG. 2 is a flow diagram of an example process 200 for preparing a target quantum state. For convenience, the process 200 will be described as being performed by a system that includes a classical computer and a quantum computer. For example, the system 100 of FIG. 1, appropriately programmed in accordance with this specification, can perform the process 200.

The target quantum state can be a ground state or excited state of a quantum system characterized by a Hamiltonian H. The target quantum state is a stationary quantum state. For example, the target quantum state can be stationary with respect to a parameterized many-body qubit operator (e.g. a generator of a rotation) and satisfy stationarity conditions given by

ψ|[G,H]|ψ=0  (1)

where |ψ represents the target quantum state, H represents the Hamiltonian characterizing the quantum system, and G represents the parameterized many-body qubit operator, i.e. that the expectation value of the commutator of the parameterized many-body qubit operator and the Hamiltonian for the target quantum state is zero. These stationarity conditions are first order stationarity conditions of the energy of the quantum system with respect to variation of parameters of the many-body qubit operator.

In some implementations the parameterized many-body qubit operator can be a fermionic two-body qubit operator. For example, the fermionic two-body qubit operator can be given by

Θ=Σ_ijklθ_ijkla_i^†a_j^†a_ka_l  (2)

where i,j,k,l are indices representing quantum system orbitals, θ represent real valued coefficients and a_k represent creation and annihilation operators. The associated energy can be given by

E(Θ)=ψ|e^−ΘHe^Θ|ψ  (3)

where |ψ represents the target quantum state, H represents the Hamiltonian characterizing the quantum system. Application of the Baker-Campbell-Hausdorff (BCH) expansion and differentiating at Θ=0 gives

$\begin{array}{cc}\frac{\partial E\left(\Theta \right)}{\partial {\theta }_{\mathrm{ijkl}}}❘\text{?}=\frac{\partial }{\partial {\theta }_{\mathrm{ijkl}}}❘\text{?}\left(\langle \psi ❘H❘\psi \rangle +\langle \psi ❘\left[H,G\right]❘\psi \rangle +\frac{1}{2}\langle \psi ❘\left[\left[H,G\right],G\right]❘\psi \rangle +\text{?}\right)=\langle \psi ❘\left[H,a_i^{†}{a}_j^{†}{a}_k{a}_l\right]❘\psi \rangle =0& \left(4\right)\end{array}$ $\text{?}\text{indicates text missing or illegible when filed}$

which shows the commutator relationship is a first order stationary condition.

In implementations of the present disclosure the parameterized many-body qubit operator can be represented by an operator A whose coefficients are dictated by the stationarity condition given some trial state |ψ_T as shown below

A=Σ _ijkl A _ijkl a _i ^† a _j ^† a _k a _l  (5)

A _ijkl=ψ_T|[H,a_i^†a_j^†a_ka_l]|ψ_T  (6)

As shown by the BCH expansion, this operator applied to the trial state for some time λ will evolve the state in such a way that minimizes the energy and approximately satisfies stationarity. This is because the BCH expansion can be viewed as a Taylor expansion of the expectation value with respect to the rotation parameters. Appropriately selecting λ will minimize the low-order Taylor expansion. Determining an amount of time λ to evolve the state for is an important step of example process 200.

For convenience, the remaining description of example process 200 is described with reference to the case of particle conserving fermionic generators (many-body qubit operators) where the stationarity equations given at Equation (1) are Brillouin conditions. In this case there are

$\left(\begin{array}{c}n\\ 2\end{array}\right)\times \left(\begin{array}{c}n\\ 2\end{array}\right)$

stationary conditions for a two-body fermionic generator with no restrictions on the coefficients, where n represents the number of spin-orbital basis functions. Example process 200 is used to construct a target quantum state |ψ_f that satisfies these conditions using a quantum computer. This can be accomplished by starting from an initial state |ψ_i, computing a gradient using Equation (4), and evolving for some time λ_i such that the next iteration |ψ_i+1 has a smaller residual value for the gradient, i.e. perform gradient descent on the wavefunction. Mathematically this sequence is expressed as

|ψ_i+1=e^−iλiAi|ψ_i  (7)

where A_i represents the many-body qubit operator evaluated using parameters for the current iteration i.

Because of the non-linear dependence of the objective function on the rotation angles, multiple evolution steps are required. That is, the i-th state |ψ_i is generated by transforming the i−1-th state |ψ_i−1, which is generated by transforming the the i−2-th state |ψ_i−2 etc. That is, the target quantum state is represented by a sequence of wavefunction transformations given by

|ψ_i=e^{−iλi−1Ai−1}e^{−iλi−2Ai−2} . . . |ψ₀  (8)

where λ_i represents evolution time for iteration i, A_i represents the many-body qubit operator with parameter values for iteration i, and |ψ₀ represents the initial quantum state.

At each iteration a gradient operator based on Equation (4) is obtained from the current iteration and the λ_i for the current iteration is determined. A conventional procedure is to perform a line search optimization solving for λ such that the energy is minimized. However, the variational search or line-search dependence can be removed by solving a second order BCH expansion by approximating the Hessian through short time propagation of the 2-RDM through cumulant reconstruction.

Equations (1)-(8) above track how the energy ψ_i|H|ψ_i evolved with respect to the operators given by Equation (4). However, through examination of how all n⁴ elements of the 2-RDM evolve, where n is the number of spin-orbital basis functions, a similar quadratic approximation to their values at the i-th wavefunction can be obtained through truncation of the BCH expansion to second order. For example, representing all n⁴ elements of the 2-RDM as D_i, the BCH expansion up to order 2 results in

D _i =D _i−1+λ_i−1D′_i−1+λ_i−1²D″_i−1  (9)

where the primes and double primes represent the derivatives with respect to λ_i−1. Each term in the 2-RDM term at i can be approximated by the BCH expansion

ψ_i|a_p^†a_q^†a_sa_r|ψ_i=ψ_i−1|a_p^†a_q^†a_sa_r|ψ_i−1+λ_i−1ψ_i−1|[a_p^†a_q^†a_sa_r]|ψ_i−1+O(λ_i−1²)   (10)

which dictates that first order derivative of all the 2-RDM elements have the form

$\begin{array}{cc}\frac{\partial D_{rs}^{pq}}{\partial {\lambda }_{i-1}}=\langle {\psi }_{i-1}❘\left[a_p^{†}{a}_q^{†}{a}_s{a}_r,A_{i-1}\right]❘{\psi }_{i-1}\rangle & \left(11\right)\end{array}$

Therefore, the task becomes that of minimizing a quadratic function and only depends on the gradient and approximate Hessian of the 2-RDM at step i−1.

$\begin{array}{cc}\frac{\partial E}{\partial ϵ}=0& \left(12\right)\end{array}$ $\begin{array}{cc}{\lambda }_{i-1}={ϵ}_{\mathrm{opt}}=-\frac{\langle H❘D_{i-1}^{\prime }\rangle }{\langle H❘D_{i-1}^{″}\rangle }& \left(13\right)\end{array}$

In Equation (13), represents the evolution time for the iteration i−1, H represents a Hamiltonian characterizing the quantum system, D_i−1′ represents a first order derivative of elements of the two-electron reduced density matrix for the iteration and D_i−1″ represents a second order derivative of elements of the two-electron reduced density matrix for the iteration. The inner products, H|D_i−1′ and H|D_i−1″, are Hilbert-Schmit inner products between a matrix representation of the Hamiltonian coefficient tensor and the 2-RDM first derivatives and second derivatives respectively. The evolution time step for the iteration i−1 is thus given by the negative of the Hilbert-Schmit inner product between the Hamiltonian and the first derivative of the 2-RDM, divided by the Hilbert-Schmit inner product between the Hamiltonian and the second derivative of the 2-RDM.

In other words, using the shorthand notation for D_i to represent all expectation values of the 2-RDM (i.e. equation (10)) formed into a matrix variable, the first and second derivatives of all 2-RDM elements are defined using equation (11) to be D_i−1′ and D_i−1″ respectively. These are matrices of all the coefficients corresponding to the first and second derivative of the corresponding 2-RDM element. Then the optimal time evolution step is determined from quadratic approximation to the similarity transformation of a 2-body operator can be expressed as Equation (13) where H|D_i−1′ and H|D_i−1″ are the Hilbert-Schmidt inner product between the matrix representation of the Hamiltonian coefficient tensor and the 2-RDM derivatives.

Determination of the optimal time step uses Hilbert-Schmit inner products between matrices of O(N{circumflex over ( )}4) size, which are not exponentially large quantum states. They can thus be determined efficiently.

Cumulant expansions can be used to evaluate the derivatives to obtain an approximation of the parameter λ_i−1 dictating how much to evolve along the gradient term A_i−1. A classical version of this theory propagates the anti-Hermitian contracted Schrödinger equation (ACSE), however this classical version suffers from non-exact 2-RDM evolution and accumulation of error. The presently described quantum version of this algorithm mitigates this problem.

In view of Equations (1)-(13) above, example process 200 can proceed as follows. The system prepares an initial quantum state |ψ₀, as described in Equation (8) above (step 202). The initial quantum state can be chosen to be non-orthogonal to the target quantum state. The system then iteratively evolves the initial quantum state and subsequent quantum states until an approximation of the target stationary quantum state is obtained (step 204). The accuracy of the approximation can depend on a predetermined acceptable accuracy, e.g., based on a predetermined convergence threshold.

At each iteration, the system performs quantum computations to compute parameter values of the many-body qubit operator for the iteration (step 204a). That is, the system computes values of the parameters A_ijkl given in Equation (6) to define the many-body qubit operator for the iteration A_i.

In addition, at each iteration, the system performs quantum computations to compute an evolution time for the iteration (step 204b). Computing the evolution time for the iteration includes evaluating first order derivatives and second order derivatives of elements of a two-electron reduced density matrix for the iteration, e.g., using cumulant expansions. That is, the system performs measurement operations to determine A, according to Equation (13) above.

Once the parameter values of the many-body qubit operator for the iteration A_i and the evolution time for the iteration λ_i have been computed, the system evolves the initial quantum state or a subsequent input quantum state for the iteration using the computed parameter values and evolution time to generate an input quantum state for the next iteration (step 204c). That is, the system evolves the initial quantum state or subsequent quantum state through Equation (7) above.

For a fully general A_i this is prohibitively expensive. As described above, there are

$\left(\begin{array}{c}n\\ 2\end{array}\right)\times \left(\begin{array}{c}n\\ 2\end{array}\right)$

terms in A_i. In general, the gradient will not be full rank and therefore in some implementations the time evolution under A_i can be approximated through a low rank double-factor decomposition of A_i, where a significant number of terms are truncated. This can drastically reduce the circuit depth required to implement evolution under A_i in comparison to exact two-body rotation that would minimize the energy. Each low-rank decomposition can be implemented on a linear lattice of qubits with linear depth. In some implementations, A will be low rank and therefore very few O(n) depth circuits will be required to implement a Trotterized form of A. Which also obeys spin blocking because A is constructed by examining rotations in each two-electron spin-sector {αα, ββ, αβ}. The highest l rank of each component can then be evolved through a low-rank decomposition scheme. Due to the low rank nature of A very few factors will need to be implemented.

In other implementations the system can approximate the time evolution under A_i by performing a unitary compression of the many-body qubit operator, where the unitary compression expresses the many-body qubit operator at the computed parameter values in a sum-of-squares form. Techniques for compressing many-body operators is described below.

Compressing Many-Body Operators with Sequential Orbital Optimization

A general tensor associated with a non-positive semidefinite operator can be decomposed into a sum-of-squares of normal operators and evolved with fermionic Gaussian unitaries and n² Ising interaction operators where the coefficient matrix for the Ising operator is rank one. The cost of implementing such an operator scales with the number of squared normal-operators are required to represent the operator. Conventional techniques attempt to lower this number by increasing the rank of the coefficient matrix for the Ising operator. In some cases a two-body operator being compressed is the Coulomb interaction term by a least-squares fitting. A drawback of this approach is the large number of free parameters and the large number of optimization steps required to fit the tensor.

The present disclosure generalizes to the case of generic two-body operators and provides a greedy approach that naturally leads to fewer variables. This is achieved through sequentially finding a single-particle basis such that A has large coefficients for n_in_j terms. This component is then removed, leaving a remainder tensor. The procedure is repeated until the remainder is numerically zero or the norm is below a preset threshold. This greedy approach is always guaranteed to converge. A byproduct of the procedure is the J_ij (l) matrix that is higher thank rank-1.

Consider a one-body transform of a generator. Given a two-body generator

{circumflex over (T)}=Σ _ijkl t _ij,kl a _i ^† a _j a _k ^† a _l,  (14)

the orbital rotated generator is represented below as

$\begin{array}{cc}\tilde{T}={\hat{U}}^{†}\left(\kappa \right)\hat{T}\hat{U}\left(\kappa \right)\tilde{T}=\sum _{\mathrm{pqrs}}{\tilde{t}}_{\mathrm{pq},\mathrm{rs}}{a}_i^{†}{a}_j{a}_k^{†}{a}_l{\tilde{t}}_{\mathrm{pq},\mathrm{rs}}=\sum _{\mathrm{pqrs}}{u}_{\mathrm{pi}}^{*}{u}_{\mathrm{qj}}{u}_{\mathrm{rk}}^{*}{u}_{\mathrm{sl}}& \left(15\right)\end{array}$

such that the objective of maximizing the coefficients of the n_in_j component of {tilde over (T)} can be expressed as

$\begin{array}{cc}\underset{\kappa }{\max }O\left(\kappa \right)O\left(\kappa \right)=\sum _{\mathrm{xy}}{❘{\tilde{t}}_{\mathrm{xx},\mathrm{yy}}\left(\kappa \right)❘}^2& \left(16\right)\end{array}$

To optimize, the gradient is taken which yields

$\begin{array}{cc}\frac{\partial O\left(\kappa \right)}{\partial {\kappa }_{a,b}}=\sum _{xy}2i{\tilde{t}}_{xx,yy}\frac{\partial {\tilde{t}}_{\mathrm{xx},\mathrm{yy}}}{\partial {\kappa }_{a,b}}& \left(17\right)\end{array}$

To calculate the partial derivative oft coefficients with respect to the parameters of the generator κ the form of

$\frac{\partial \tilde{T}}{\partial {\kappa }_{a,b}}$

is first derived

$\begin{array}{cc}\begin{array}{c}\frac{\partial \tilde{T}}{\partial k_{a,b}}=\sum _{\mathrm{ijkl}}{t}_{\mathrm{ij},\mathrm{kl}}\left(\frac{\partial {\hat{U}\left(\kappa \right)}^{†}}{{\kappa }_{\mathrm{ab}}}{a}_i^{†}{a}_j{a}_k^{†}{a}_l\hat{U}\left(\kappa \right)+{\hat{U}\left(\kappa \right)}^{†}{a}_i^{†}{a}_j{a}_k^{†}{a}_l\frac{\partial \hat{U}\left(\kappa \right)}{\partial {\kappa }_{a,b}}\right)\\ =\sum _{\mathrm{ijkl}}{t}_{\mathrm{ij},\mathrm{kl}}{\hat{U}\left(\kappa \right)}^{†}\left[a_i^{†}{a}_j{a}_k^{†}{a}_l,\sum _{\mathrm{mn}}{G}_{\mathrm{mn}}^{\mathrm{ab}}{a}_m^{†}{a}_n\right]\hat{U}\left(\kappa \right)\\ =\sum _{\mathrm{ijklr}}{t}_{\mathrm{ij},\mathrm{kl}}{\hat{U}\left(\kappa \right)}^{†}\left(-G_{\mathrm{ri}}^{\mathrm{ab}}\text{?}{a}_j{a}_k^{†}{a}_l+G_{\mathrm{jr}}^{\mathrm{ab}}{a}_i^{†}{a}_r{a}_l-G_{\mathrm{rk}}^{\mathrm{ab}}{a}_i^{†}{a}_j{a}_r^{†}{a}_l+G_{\mathrm{lr}}^{\mathrm{ab}}{a}_i^{†}{a}_j{a}_k^{†}{a}_r\right)\hat{U}\left(\kappa \right)\\ =\sum _{\mathrm{pqsi}}{V}_{\mathrm{pq},\mathrm{si}}{a}_p^{†}{a}_q{a}_s^{†}\text{?}\end{array}& \left(18\right)\end{array}$ $\text{?}\text{indicates text missing or illegible when filed}$

where G^ab is the anti-Hermitian operator obtained from Duhamel's (Wilcox) formula for differentiating with respect to parameter κ_a,b and

$\begin{array}{cc}\text{?}=\sum _{\mathrm{ijklr}}{t}_{\mathrm{ij},\mathrm{kl}}\left(-G_{\mathrm{ri}}^{\mathrm{ab}}{u}_{\mathrm{rp}}^{*}\text{?}+G_{\mathrm{jr}}^{\mathrm{ab}}{u}_{\mathrm{ip}}^{*}\text{?}-G_{\mathrm{rk}}^{\mathrm{ab}}{u}_{\mathrm{ip}}^{*}\text{?}+G_{\mathrm{lr}}^{\mathrm{ab}}{u}_{\mathrm{ip}}^{*}{u}_{\mathrm{jq}}\text{?}\right).& \left(19\right)\end{array}$ $\text{?}\text{indicates text missing or illegible when filed}$

which uses

$\begin{array}{cc}{U\left(\kappa \right)}^{†}{a}_i^{†}U\left(\kappa \right)=\sum _p\text{?}{a}_p^{†}=\sum _p{u}_{\mathrm{ip}}^{*}{a}_p^{†}{U\left(\kappa \right)}^{†}{a}_{i}U\left(\kappa \right)=\sum _p\text{?}{a}_p=\sum _p{u}_{\mathrm{ip}}\text{?}& \left(20\right)\end{array}$ $\mathrm{Therefore},$ $\begin{array}{cc}\text{?}=\sum _{\mathrm{ijklr}}{t}_{\mathrm{ij},\mathrm{kl}}\left(-G_{\mathrm{ri}}^{\mathrm{ab}}{u}_{\mathrm{rp}}^{*}{u}_{\mathrm{jq}}\text{?}+G_{\mathrm{jr}}^{\mathrm{ab}}{u}_{\mathrm{ip}}^{*}{u}_{\mathrm{rq}}\text{?}-G_{\mathrm{rk}}^{\mathrm{ab}}{u}_{\mathrm{ip}}^{*}{u}_{\mathrm{jq}}\text{?}+\text{?}{u}_{\mathrm{ip}}^{*}{u}_{\mathrm{jq}}\text{?}\right)& \left(21\right)\end{array}$ $\text{?}\text{indicates text missing or illegible when filed}$

which is a contraction that can be evaluated in O(n⁵) where n represents the number of spin-orbitals. There are a total of n²κ_ab terms when considering the real and imaginary components and thus the total derivative is obtained in naively O(n⁷) operations.

This method of obtaining the gradient is general and sufficient for any continuous cost function depending on {tilde over (t)}_pq,st. The general scaling can be reduced by considering the function that is being optimized and applying the chain rule. To see how this works consider differentiating Eq. (15) with respect to κ_ab

$\begin{array}{cc}\frac{\partial O\left(\kappa \right)}{\partial {\kappa }_{\mathrm{ab}}}=\sum _{\mathrm{cd}}\frac{\partial O\left(\kappa \right)}{\partial u_{\mathrm{cd}}}{\left(\frac{\partial u}{\partial {\kappa }_{\mathrm{ab}}}\right)}_{\mathrm{cd}}+\sum _{\mathrm{cd}}\frac{\partial O\left(\kappa \right)}{\partial u_{\mathrm{cd}}^{*}}{\left(\frac{\partial u^{*}}{\partial {\kappa }_{a,b}}\right)}_{\mathrm{cd}}& \left(22\right)\end{array}$ $\mathrm{where}$ $\begin{array}{cc}\frac{\partial O\left(\kappa \right)}{\partial u_{\mathrm{cd}}}=2i\sum _{\mathrm{xy}}{\tilde{t}}_{\mathrm{xx},\mathrm{yy}}\frac{\partial {\tilde{t}}_{\mathrm{xx},\mathrm{yy}}}{\partial u_{\mathrm{cd}}}=2i\sum _{\mathrm{yikl}}\text{?}{u}_{\mathrm{id}}^{*}\text{?}+2i\sum _{\mathrm{xijk}}\text{?}{u}_{\mathrm{ix}}^{*}{u}_{\mathrm{jx}}{u}_{\mathrm{kd}}^{*}{\tilde{t}}_{\mathrm{xx},\mathrm{dd}}& \left(23\right)\end{array}$ $\frac{\partial O\left(\kappa \right)}{\partial u_{\mathrm{cd}}^{*}}=2i\sum _{\mathrm{xy}}{\tilde{t}}_{\mathrm{xx},\mathrm{yy}}\frac{\partial {\tilde{t}}_{\mathrm{xx},\mathrm{yy}}}{\partial u_{\mathrm{cd}}^{*}}=2i\text{?}{u}_{\mathrm{ky}}^{*}\text{?}+2i\sum _{\mathrm{xijl}}\text{?}{u}_{\mathrm{ix}}^{*}{u}_{\mathrm{jx}}{u}_{\mathrm{ld}}{\tilde{t}}_{\mathrm{xx},\mathrm{dd}}$ $\text{?}\text{indicates text missing or illegible when filed}$

which for all {c, d} is obtained in O(n⁵) once per total derivative call. The n² intermediates are reused for each κ_ab derivative. Thus the overall scaling is O(n⁵). Using Duhamel's or Wilcox identity the partial derivative of the unitary or its Hermitian conjugate is

$\begin{array}{cc}{\left(\frac{\partial u}{\partial {\kappa }_{\mathrm{ab}}}\right)}_{\mathrm{cd}}=\sum _r\text{?}{u}_{\mathrm{rd}},& \left(24\right)\end{array}$ $\begin{array}{cc}{\left(\frac{\partial u^{*}}{\partial {\kappa }_{\mathrm{ab}}}\right)}_{\mathrm{cd}}=\sum _r-\text{?}.& \left(25\right)\end{array}$ $\text{?}\text{indicates text missing or illegible when filed}$

A check that this is all consistent with the O(n⁷) scaling method is multiplying Eq. (24) with

$\frac{\partial {\tilde{t}}_{\mathrm{xx},\mathrm{yy}}}{\partial u_{cd}}$

and summing over {c, d} which returns the appropriate terms in Eq. (21).

κ=0 Gradient Calculation

An example method to calculate the derivative is by updating the local basis of {circumflex over (T)} such that the gradient of {circumflex over (T)} with respect to κ_ab is always calculated around κ=0. To see this first Taylor expand {circumflex over (T)} around κ=0 using the BCH expansion

$\begin{array}{cc}\begin{array}{c}\tilde{T}=\text{?}\left(\kappa \right)\hat{T}\hat{U}\left(\kappa \right)\\ =\sum _{\mathrm{ijkl}}{t}_{\mathrm{ij},\mathrm{kl}}(a_i^{†}{a}_j{a}_k^{†}{a}_l+\sum _{\mathrm{mn}}{\kappa }_{\mathrm{mn}}\left[a_i^{†}{a}_j{a}_k^{†}{a}_l,a_m^{†}{a}_n\right]+𝒪\left({\kappa }^2\right)\end{array}& \left(26\right)\end{array}$ $\text{?}\text{indicates text missing or illegible when filed}$

now the derivative with respect to κ_ab results in Kronecker delta functions reducing the complexity of the sum from fourth order to third order

$\begin{array}{cc}\frac{\partial \tilde{T}}{{\kappa }_{\mathrm{ab}}}\text{?}=\sum _{\mathrm{ijk}}-\text{?}{a}_j{a}_k^{†}\text{?}+\text{?}{a}_i^{†}\text{?}{a}_k^{†}{a}_i+\text{?}{a}_i^{†}{a}_j{a}_a^{†}{a}_i+\sum _{\mathrm{ijk}}{t}_{\mathrm{ij},\mathrm{ka}}{a}_i^{†}{a}_j{a}_k^{†}\text{?}& \left(27\right)\end{array}$ $\text{?}\text{indicates text missing or illegible when filed}$

which translates to copying the appropriate t coefficients into a new tensor to represent the gradient. The Hessian can be computed a similar way after taking the BCH expansion to second order and evaluating the derivative yielding Kronecker delta functions.

Recursively Fitting a Two-Body Generator

The objective function and gradient for maximizing the n_in_j component of a two-body operator is described above. Using this infrastructure a recursive technique for generating the compressed two-body operator is introduced. Starting from the target operator T Equation (16) is maximized to obtain a basis such that the n_in_j coefficients are largest in magnitude. These coefficients are selected out and stored along with the K rotation. The operator represented by the diagonal coefficients is rotated back to the original basis with the K obtained from the optimization and then the tensor is subtracted from the original generating a remainder. This procedure is repeated until the norm of the subtraction remainder is small and below a predetermined threshold. Using this approach the cost of the optimization is never more than sequential orbital optimizations. If the optimization is seeded with the rotations generated from the Takagi decomposition the procedure is guaranteed to converge.

Example Operating Environment

FIG. 3 depicts an example classical/quantum computer 300 for performing some or all of the classical and quantum operations described in this specification. The example classical/quantum computer 300 includes an example quantum computing device 302. The quantum computing device 302 is intended to represent various forms of quantum computing devices. The components shown here, their connections and relationships, and their functions, are exemplary only, and do not limit implementations of the inventions described and/or claimed in this document.

The example quantum computing device 302 includes a qubit assembly 352 and a control and measurement system 304. The qubit assembly includes multiple qubits, e.g., qubit 306, that are used to perform algorithmic operations or quantum computations. While the qubits shown in FIG. 3 are arranged in a rectangular array, this is a schematic depiction and is not intended to be limiting. The qubit assembly 352 also includes adjustable coupling elements, e.g., coupler 308, that allow for interactions between coupled qubits. In the schematic depiction of FIG. 3, each qubit is adjustably coupled to each of its four adjacent qubits by means of respective coupling elements. However, this is an example arrangement of qubits and couplers and other arrangements are possible, including arrangements that are non-rectangular, arrangements that allow for coupling between non-adjacent qubits, and arrangements that include adjustable coupling between more than two qubits.

Each qubit can be a physical two-level quantum system or device having levels representing logical values of 0 and 1. The specific physical realization of the multiple qubits and how they interact with one another is dependent on a variety of factors including the type of the quantum computing device 302 included in the example computer 300 or the type of quantum computations that the quantum computing device is performing. For example, in an atomic quantum computer the qubits may be realized via atomic, molecular or solid-state quantum systems, e.g., hyperfine atomic states. As another example, in a superconducting quantum computer the qubits may be realized via superconducting qubits or semi-conducting qubits, e.g., superconducting transmon states. As another example, in a NMR quantum computer the qubits may be realized via nuclear spin states.

In some implementations a quantum computation can proceed by loading qubits, e.g., from a quantum memory, and applying a sequence of unitary operators to the qubits. Applying a unitary operator to the qubits can include applying a corresponding sequence of quantum logic gates to the qubits, e.g., to implement a quantum algorithm such as a quantum principle component algorithm. Example quantum logic gates include single-qubit gates, e.g., Pauli-X, Pauli-Y, Pauli-Z (also referred to as X, Y, Z), Hadamard gates, S gates, rotations, two-qubit gates, e.g., controlled-X, controlled-Y, controlled-Z (also referred to as CX, CY, CZ), controlled NOT gates (also referred to as CNOT) controlled swap gates (also referred to as CSWAP), and gates involving three or more qubits, e.g., Toffoli gates. The quantum logic gates can be implemented by applying control signals 310 generated by the control and measurement system 304 to the qubits and to the couplers.

For example, in some implementations the qubits in the qubit assembly 352 can be frequency tuneable. In these examples, each qubit can have associated operating frequencies that can be adjusted through application of voltage pulses via one or more drive-lines coupled to the qubit. Example operating frequencies include qubit idling frequencies, qubit interaction frequencies, and qubit readout frequencies. Different frequencies correspond to different operations that the qubit can perform. For example, setting the operating frequency to a corresponding idling frequency may put the qubit into a state where it does not strongly interact with other qubits, and where it may be used to perform single-qubit gates. As another example, in cases where qubits interact via couplers with fixed coupling, qubits can be configured to interact with one another by setting their respective operating frequencies at some gate-dependent frequency detuning from their common interaction frequency. In other cases, e.g., when the qubits interact via tuneable couplers, qubits can be configured to interact with one another by setting the parameters of their respective couplers to enable interactions between the qubits and then by setting the qubit's respective operating frequencies at some gate-dependent frequency detuning from their common interaction frequency. Such interactions may be performed in order to perform multi-qubit gates.

The type of control signals 310 used depends on the physical realizations of the qubits. For example, the control signals may include RF or microwave pulses in an NMR or superconducting quantum computer system, or optical pulses in an atomic quantum computer system.

A quantum computation can be completed by measuring the states of the qubits, e.g., using a quantum observable such as X or Z, using respective control signals 310. The measurements cause readout signals 312 representing measurement results to be communicated back to the measurement and control system 304. The readout signals 312 may include RF, microwave, or optical signals depending on the physical scheme for the quantum computing device and/or the qubits. For convenience, the control signals 310 and readout signals 312 shown in FIG. 3 are depicted as addressing only selected elements of the qubit assembly (i.e. the top and bottom rows), but during operation the control signals 310 and readout signals 312 can address each element in the qubit assembly 352.

The control and measurement system 304 is an example of a classical computer system that can be used to perform various operations on the qubit assembly 352, as described above, as well as other classical subroutines or computations. The control and measurement system 304 includes one or more classical processors, e.g., classical processor 314, one or more memories, e.g., memory 316, and one or more I/O units, e.g., I/O unit 318, connected by one or more data buses. The control and measurement system 304 can be programmed to send sequences of control signals 310 to the qubit assembly, e.g. to carry out a selected series of quantum gate operations, and to receive sequences of readout signals 312 from the qubit assembly, e.g. as part of performing measurement operations.

The processor 314 is configured to process instructions for execution within the control and measurement system 304. In some implementations, the processor 314 is a single-threaded processor. In other implementations, the processor 314 is a multi-threaded processor. The processor 314 is capable of processing instructions stored in the memory 316.

The memory 316 stores information within the control and measurement system 304. In some implementations, the memory 316 includes a computer-readable medium, a volatile memory unit, and/or a non-volatile memory unit. In some cases, the memory 316 can include storage devices capable of providing mass storage for the system 304, e.g. a hard disk device, an optical disk device, a storage device that is shared over a network by multiple computing devices (e.g., a cloud storage device), and/or some other large capacity storage device.

The input/output device 318 provides input/output operations for the control and measurement system 304. The input/output device 318 can include D/A converters, A/D converters, and RF/microwave/optical signal generators, transmitters, and receivers, whereby to send control signals 310 to and receive readout signals 312 from the qubit assembly, as appropriate for the physical scheme for the quantum computer. In some implementations, the input/output device 318 can also include one or more network interface devices, e.g., an Ethernet card, a serial communication device, e.g., an RS-222 port, and/or a wireless interface device, e.g., an 802.11 card. In some implementations, the input/output device 318 can include driver devices configured to receive input data and send output data to other external devices, e.g., keyboard, printer and display devices.

Although an example control and measurement system 304 has been depicted in FIG. 3, implementations of the subject matter and the functional operations described in this specification can be implemented in other types of digital electronic circuitry, or in computer software, firmware, or hardware, including the structures disclosed in this specification and their structural equivalents, or in combinations of one or more of them.

The example system 300 also includes an example classical processor 350. The classical processor 350 can be used to perform classical computation operations described in this specification according to some implementations.

Implementations of the subject matter and operations described in this specification can be implemented in digital electronic circuitry, analog electronic circuitry, suitable quantum circuitry or, more generally, quantum computational systems, in tangibly-embodied software or firmware, in computer hardware, including the structures disclosed in this specification and their structural equivalents, or in combinations of one or more of them. The term “quantum computational systems” may include, but is not limited to, quantum computers, quantum information processing systems, quantum cryptography systems, or quantum simulators.

Implementations of the subject matter described in this specification can be implemented as one or more computer programs, i.e., one or more modules of computer program instructions encoded on a tangible non-transitory storage medium for execution by, or to control the operation of, data processing apparatus. The computer storage medium can be a machine-readable storage device, a machine-readable storage substrate, a random or serial access memory device, one or more qubits, or a combination of one or more of them. Alternatively or in addition, the program instructions can be encoded on an artificially-generated propagated signal that is capable of encoding digital and/or quantum information, e.g., a machine-generated electrical, optical, or electromagnetic signal, that is generated to encode digital and/or quantum information for transmission to suitable receiver apparatus for execution by a data processing apparatus.

The terms quantum information and quantum data refer to information or data that is carried by, held or stored in quantum systems, where the smallest non-trivial system is a qubit, i.e., a system that defines the unit of quantum information. It is understood that the term “qubit” encompasses all quantum systems that may be suitably approximated as a two-level system in the corresponding context. Such quantum systems may include multi-level systems, e.g., with two or more levels. By way of example, such systems can include atoms, electrons, photons, ions or superconducting qubits. In many implementations the computational basis states are identified with the ground and first excited states, however it is understood that other setups where the computational states are identified with higher level excited states are possible.

The term “data processing apparatus” refers to digital and/or quantum data processing hardware and encompasses all kinds of apparatus, devices, and machines for processing digital and/or quantum data, including by way of example a programmable digital processor, a programmable quantum processor, a digital computer, a quantum computer, multiple digital and quantum processors or computers, and combinations thereof. The apparatus can also be, or further include, special purpose logic circuitry, e.g., an FPGA (field programmable gate array), an ASIC (application-specific integrated circuit), or a quantum simulator, i.e., a quantum data processing apparatus that is designed to simulate or produce information about a specific quantum system. In particular, a quantum simulator is a special purpose quantum computer that does not have the capability to perform universal quantum computation. The apparatus can optionally include, in addition to hardware, code that creates an execution environment for digital and/or quantum computer programs, e.g., code that constitutes processor firmware, a protocol stack, a database management system, an operating system, or a combination of one or more of them.

A digital computer program, which may also be referred to or described as a program, software, a software application, a module, a software module, a script, or code, can be written in any form of programming language, including compiled or interpreted languages, or declarative or procedural languages, and it can be deployed in any form, including as a stand-alone program or as a module, component, subroutine, or other unit suitable for use in a digital computing environment. A quantum computer program, which may also be referred to or described as a program, software, a software application, a module, a software module, a script, or code, can be written in any form of programming language, including compiled or interpreted languages, or declarative or procedural languages, and translated into a suitable quantum programming language, or can be written in a quantum programming language, e.g., QCL or Quipper.

A computer program may, but need not, correspond to a file in a file system. A program can be stored in a portion of a file that holds other programs or data, e.g., one or more scripts stored in a markup language document, in a single file dedicated to the program in question, or in multiple coordinated files, e.g., files that store one or more modules, sub-programs, or portions of code. A computer program can be deployed to be executed on one computer or on multiple computers that are located at one site or distributed across multiple sites and interconnected by a digital and/or quantum data communication network. A quantum data communication network is understood to be a network that may transmit quantum data using quantum systems, e.g. qubits. Generally, a digital data communication network cannot transmit quantum data, however a quantum data communication network may transmit both quantum data and digital data.

The processes and logic flows described in this specification can be performed by one or more programmable computers, operating with one or more processors, as appropriate, executing one or more computer programs to perform functions by operating on input data and generating output. The processes and logic flows can also be performed by, and apparatus can also be implemented as, special purpose logic circuitry, e.g., an FPGA or an ASIC, or a quantum simulator, or by a combination of special purpose logic circuitry or quantum simulators and one or more programmed digital and/or quantum computers.

For a system of one or more computers to be “configured to” perform particular operations or actions means that the system has installed on it software, firmware, hardware, or a combination of them that in operation cause the system to perform the operations or actions. For one or more computer programs to be configured to perform particular operations or actions means that the one or more programs include instructions that, when executed by data processing apparatus, cause the apparatus to perform the operations or actions. For example, a quantum computer may receive instructions from a digital computer that, when executed by the quantum computing apparatus, cause the apparatus to perform the operations or actions.

Computers suitable for the execution of a computer program can be based on general or special purpose processors, or any other kind of central processing unit. Generally, a central processing unit will receive instructions and data from a read-only memory, a random access memory, or quantum systems suitable for transmitting quantum data, e.g. photons, or combinations thereof.

The elements of a computer include a central processing unit for performing or executing instructions and one or more memory devices for storing instructions and digital, analog, and/or quantum data. The central processing unit and the memory can be supplemented by, or incorporated in, special purpose logic circuitry or quantum simulators. Generally, a computer will also include, or be operatively coupled to receive data from or transfer data to, or both, one or more mass storage devices for storing data, e.g., magnetic, magneto-optical disks, optical disks, or quantum systems suitable for storing quantum information. However, a computer need not have such devices.

Quantum circuit elements (also referred to as quantum computing circuit elements) include circuit elements for performing quantum processing operations. That is, the quantum circuit elements are configured to make use of quantum-mechanical phenomena, such as superposition and entanglement, to perform operations on data in a non-deterministic manner. Certain quantum circuit elements, such as qubits, can be configured to represent and operate on information in more than one state simultaneously. Examples of superconducting quantum circuit elements include circuit elements such as quantum LC oscillators, qubits (e.g., flux qubits, phase qubits, or charge qubits), and superconducting quantum interference devices (SQUIDs) (e.g., RF-SQUID or DC-SQUID), among others.

In contrast, classical circuit elements generally process data in a deterministic manner. Classical circuit elements can be configured to collectively carry out instructions of a computer program by performing basic arithmetical, logical, and/or input/output operations on data, in which the data is represented in analog or digital form. In some implementations, classical circuit elements can be used to transmit data to and/or receive data from the quantum circuit elements through electrical or electromagnetic connections. Examples of classical circuit elements include circuit elements based on CMOS circuitry, rapid single flux quantum (RSFQ) devices, reciprocal quantum logic (RQL) devices and ERSFQ devices, which are an energy-efficient version of RSFQ that does not use bias resistors.

In certain cases, some or all of the quantum and/or classical circuit elements may be implemented using, e.g., superconducting quantum and/or classical circuit elements. Fabrication of the superconducting circuit elements can entail the deposition of one or more materials, such as superconductors, dielectrics and/or metals. Depending on the selected material, these materials can be deposited using deposition processes such as chemical vapor deposition, physical vapor deposition (e.g., evaporation or sputtering), or epitaxial techniques, among other deposition processes. Processes for fabricating circuit elements described herein can entail the removal of one or more materials from a device during fabrication. Depending on the material to be removed, the removal process can include, e.g., wet etching techniques, dry etching techniques, or lift-off processes. The materials forming the circuit elements described herein can be patterned using known lithographic techniques (e.g., photolithography or e-beam lithography).

During operation of a quantum computational system that uses superconducting quantum circuit elements and/or superconducting classical circuit elements, such as the circuit elements described herein, the superconducting circuit elements are cooled down within a cryostat to temperatures that allow a superconductor material to exhibit superconducting properties. A superconductor (alternatively superconducting) material can be understood as material that exhibits superconducting properties at or below a superconducting critical temperature. Examples of superconducting material include aluminum (superconductive critical temperature of 1.2 kelvin) and niobium (superconducting critical temperature of 9.3 kelvin). Accordingly, superconducting structures, such as superconducting traces and superconducting ground planes, are formed from material that exhibits superconducting properties at or below a superconducting critical temperature.

In certain implementations, control signals for the quantum circuit elements (e.g., qubits and qubit couplers) may be provided using classical circuit elements that are electrically and/or electromagnetically coupled to the quantum circuit elements. The control signals may be provided in digital and/or analog form.

Computer-readable media suitable for storing computer program instructions and data include all forms of non-volatile digital and/or quantum memory, media and memory devices, including by way of example semiconductor memory devices, e.g., EPROM, EEPROM, and flash memory devices; magnetic disks, e.g., internal hard disks or removable disks; magneto-optical disks; CD-ROM and DVD-ROM disks; and quantum systems, e.g., trapped atoms or electrons. It is understood that quantum memories are devices that can store quantum data for a long time with high fidelity and efficiency, e.g., light-matter interfaces where light is used for transmission and matter for storing and preserving the quantum features of quantum data such as superposition or quantum coherence.

Control of the various systems described in this specification, or portions of them, can be implemented in a computer program product that includes instructions that are stored on one or more non-transitory machine-readable storage media, and that are executable on one or more processing devices. The systems described in this specification, or portions of them, can each be implemented as an apparatus, method, or system that may include one or more processing devices and memory to store executable instructions to perform the operations described in this specification.

While this specification contains many specific implementation details, these should not be construed as limitations on the scope of what may be claimed, but rather as descriptions of features that may be specific to particular implementations. Certain features that are described in this specification in the context of separate implementations can also be implemented in combination in a single implementation. Conversely, various features that are described in the context of a single implementation can also be implemented in multiple implementations separately or in any suitable sub-combination. Moreover, although features may be described above as acting in certain combinations and even initially claimed as such, one or more features from a claimed combination can in some cases be excised from the combination, and the claimed combination may be directed to a sub-combination or variation of a sub-combination.

Similarly, while operations are depicted in the drawings in a particular order, this should not be understood as requiring that such operations be performed in the particular order shown or in sequential order, or that all illustrated operations be performed, to achieve desirable results. In certain circumstances, multitasking and parallel processing may be advantageous. Moreover, the separation of various system modules and components in the implementations described above should not be understood as requiring such separation in all implementations, and it should be understood that the described program components and systems can generally be integrated together in a single software product or packaged into multiple software products.

Particular implementations of the subject matter have been described. Other implementations are within the scope of the following claims. For example, the actions recited in the claims can be performed in a different order and still achieve desirable results. As one example, the processes depicted in the accompanying figures do not necessarily require the particular order shown, or sequential order, to achieve desirable results. In some cases, multitasking and parallel processing may be advantageous.

Claims

1. A computer implemented method for preparing a target quantum state of a quantum system, wherein the target quantum state is stationary with respect to a parameterized many-body qubit operator, the method comprising: preparing an initial quantum state as an input state for a first iteration;iteratively evolving the initial quantum state and subsequent input quantum states as inputs for subsequent iterations until an approximation of the target stationary quantum state is obtained, comprising, for each iteration: computing, by quantum computation, parameter values of the many-body qubit operator for the iteration;computing, by quantum computation, an evolution time for the iteration, comprising evaluating changes in elements of a two-electron reduced density matrix for the iteration; andevolving the initial quantum state or the subsequent input quantum state for the iteration using the computed parameter values and evolution time to generate a subsequent input quantum state for the subsequent iteration.

2. The method of claim 1, wherein evaluating changes in elements of the two-electron reduced density matrix for the iteration comprises evaluating first order derivatives and second order derivatives of elements of a two-electron reduced density matrix for the iteration.

3. The method of claim 1, wherein computing, by quantum computation, an evolution time for the iteration comprises computing

4. The method of claim 2, wherein evaluating first order derivatives and second order derivatives of elements of the two-electron reduced density matrix for the iteration comprises using cumulant expansions.

5. The method of claim 1, wherein computing, by quantum computation, parameter values of the many-body qubit operator for the iteration comprises performing measurements of a 3-RDM.

6. The method of claim 1, wherein evolving the initial quantum state or a subsequent input quantum state for the iteration using the computed parameter values and evolution time to generate an input quantum state for the subsequent iteration comprises approximating time evolution of the many-body qubit operator at the computed parameter values using a low rank double-factor decomposition.

7. The method of claim 6, wherein the low rank decomposition is implemented on a linear lattice of qubits with linear depth.

8. The method of claim 1, wherein evolving the initial quantum state or a subsequent input quantum state for the iteration using the computed parameter values and evolution time to generate an input quantum state for the subsequent iteration comprises approximating time evolution of the many-body qubit operator at the computed parameter values using a unitary compression of the many-body qubit operator.

9. The method of claim 8, wherein the unitary compression of the many-body qubit operator expresses the many-body qubit operator at the computed parameter values in a sum-of-squares form.

10. The method of claim 1, wherein the target stationary quantum state comprises a ground or excited quantum state.

11. The method of claim 1, wherein the initial quantum state is non-orthogonal to the target quantum state.

12. The method of claim 1, wherein the target quantum state comprises a state of a quantum system characterized by a Hamiltonian, and wherein the target quantum state satisfies stationarity conditions given by ψ|[G,H]|ψ=0,

13. The method of claim 12, wherein the stationarity condition comprises a first order stationarity condition of the energy with respect to variation of parameters of the many-body qubit operator.

14. The method of claim 1, wherein the parameterized many-body qubit operator comprises a fermionic two-body qubit operator.

15. The method of claim 14, wherein the fermionic two-body qubit operator is given by Θ=Σijklθijklai†aj†ak al, where i,j,k,l are indices representing quantum system orbitals, θ represent real valued coefficients and aj†, ak represent creation and annihilation operators, and the associated energy is given by E(Θ)=ψ|e−ΘHeΘ|ψ, where |ψ represents the target quantum state, H represents the Hamiltonian characterizing the quantum system.

16. The method of claim 1, wherein the target quantum state is represented by a sequence of wavefunction transformations given by |ψi=e−iλi−1Ai−1e−iλi−2Ai−2 . . . |ψ0

17. A system for operating a quantum computer, the system comprising: one or more processors;one or more I/O devices coupled to the one or more processors and configured to send control signals to and receive readout signals from the quantum computer; andone or more memories having stored thereon computer readable instructions configured to cause the one more processors and the one or more I/O devices to carry out operations for preparing a target quantum state of a quantum system, wherein the target quantum state is stationary with respect to a parameterized many-body qubit operator, the operations comprising: preparing an initial quantum state as an input state for a first iteration;iteratively evolving the initial quantum state and subsequent input quantum states as inputs for subsequent iterations until an approximation of the target stationary quantum state is obtained, comprising, for each iteration: computing, by quantum computation, parameter values of the many-body qubit operator for the iteration;computing, by quantum computation, an evolution time for the iteration, comprising evaluating changes in elements of a two-electron reduced density matrix for the iteration; andevolving the initial quantum state or the subsequent input quantum state for the iteration using the computed parameter values and evolution time to generate a subsequent input quantum state for the subsequent iteration.

18. The system of claim 17, wherein the system further comprises the quantum computer.

19. The system of claim 17, wherein evaluating changes in elements of the two-electron reduced density matrix for the iteration comprises evaluating first order derivatives and second order derivatives of elements of a two-electron reduced density matrix for the iteration.

20. A non-transitory computer readable medium storing instructions for execution by one more or more computers configured to send control signals to and receive readout signals from a quantum computer, the instructions causing the one or more computers to carry out operations for preparing a target quantum state of a quantum system, wherein the target quantum state is stationary with respect to a parameterized many-body qubit operator, the operations comprising: preparing an initial quantum state as an input state for a first iteration;iteratively evolving the initial quantum state and subsequent input quantum states as inputs for subsequent iterations until an approximation of the target stationary quantum state is obtained, comprising, for each iteration: computing, by quantum computation, parameter values of the many-body qubit operator for the iteration;computing, by quantum computation, an evolution time for the iteration, comprising evaluating changes in elements of a two-electron reduced density matrix for the iteration; andevolving the initial quantum state or the subsequent input quantum state for the iteration using the computed parameter values and evolution time to generate a subsequent input quantum state for the subsequent iteration.