Robust universal Hamiltonian quantum computing using two-body interactions

A general approach to reducing the effect of noise on any system is to introduce redundancy, in such a way that the larger system is more protected against the noise. Quantum codes capable of detecting the presence of a targeted set of errors provide a systematic way of encoding an arbitrary system into a larger system which is protected against errors.

A scheme to use quantum codes to protect a Hamiltonian-based quantum computation aharonov_adiabatic_2007 ; albash2018adiabatic was introduced by Jordan, Farhi, and Shor jordan2006error . In this scheme, a quantum code that can detect the action of the system-bath interaction Hamiltonian on the system is chosen. Then, using the stabilizers of the code a penalty Hamiltonian whose ground subspace is protected against the induced errors is constructed. By construction, logical operators of any stabilizer quantum code commute with the stabilizer operators and hence with the penalty Hamiltonian. Therefore the structure of the code allows using logical operators of the code to perform arbitrary computation in the ground subspace of the penalty Hamiltonian, which penalizes any excitation out of the codespace. This approach has been generalized and its performance in non-Markovian Bookatz:2014uq and Markovian marvian2017error ; lidar2019arbitrary environments have been studied.

However, the experimental feasibility of any such scheme is heavily dependent on the required extra resources. In addition to the extra qubits, an important consideration is the type of interactions, such as locality of the interactions that need to be implemented. Even if the dominant errors on the system are one-local, a penalty Hamiltonian that is constructed using any (subspace) stabilizer codes requires at least four-local interactions jordan2006error . More generally, any commuting Hamiltonian with a ground subspace protected against one-local errors cannot be implemented using two-body interactions Marvian:2014nr . As strong controllable high-weight interactions are hard to engineer, it is important to know whether error suppression is possible using lower-weight interactions.

Going beyond commuting Hamiltonians, recently it has been shown that using subsystem codes one can construct a non-commuting two-body Hamiltonian capable of suppressing general one-local errors Jiang:2015kx ; Marvian-Lidar:16 . This reduction in the locality of the penalty Hamiltonian makes them experimentally more feasible. For example, using Josephson phase-slip qubits implementation of such a penalty Hamiltonians, with strong static two-body interactions and no local fields, can increase the effective coherence time of qubits considerably kerman2019superconducting . Keeping the penalty Hamiltonian two-local, we can ask what is the minimum locality of an encoded computational Hamiltonian. Any logical operator has to be at least two-local to be different from one-local errors. Therefore, encoding a Hamiltonian by individually replacing each qubit with its logical counterpart (block encoding), would encode a two-local interaction into a four-local interaction. Two-local constructions to embed Hamiltonians while suppressing general one-local errors have been found for limited Hamiltonians, such as an Ising chain in a transverse field Marvian-Lidar:16 .

The ground-state computation using the Ising chain in a transverse field is unlikely to be universal, but with a fast control of local fields, and therefore going out of the ground space, the chain is already powerful enough to simulate any other Hamiltonian and hence is computationally universal Benjamin:01 ; lloyd2018quantum . Until now, it has been left open whether a non-perturbative two-local construction that can encode a universal adiabatic quantum computation while suppressing one-local errors is possible. Here we answer this question affirmatively.

Here we present a subsystem code whose gauge operators, single qubit logical operators, and products of two logical operators of the same type (up to a gauge operator) are all two-local operators. Then we show how this code can be used to encode universal adiabatic quantum computations while suppressing one-local errors. Unlike previous constructions, the penalty Hamiltonians and the encoded Hamiltonians do not necessarily commute, but we will show that for our construction the undesirable effect of the penalty Hamiltonian on the computation can be compensated by a simple modification of the implemented Hamiltonians. In addition, in a no-go theorem, we show that requiring the penalty Hamiltonian to commute with the encoded Hamiltonian limits the geometry of the Hamiltonians that can be protected. In particular, we show that, using general all-two-local CSS-type subsystem codes, it is not possible to protect Hamiltonians beyond an Ising chain in a transverse field.

Introduction to subsystem codes– We first briefly review subsystem stabilizer codes poulin_stabilizer_2005 which are the generalization of subspace stabilizer codes Gottesman:1996fk . In short, subsystem stabilizer codes can be thought as subspace stabilizer codes where some of the logical qubits are not used to store information, ignoring the errors that occur on these logical qubits.

More formally, any subspace stabilizer code is defined by an Abelian group $\mathcal{S}$ of Pauli operators, where the codespace is the simultaneous +1 eigenstates of the group elements. The set of operators that are included in $\mathcal{S}$ determine the error-detecting properties of the code. Any Pauli error that anti-commutes with at least one element of $\mathcal{S}$ takes a codestate to a state out of the codespace and hence is a detectable error. The set of Pauli operators that are not in $\mathcal{S}$ but keep it invariant, $\mathcal{C}(\mathcal{S})/\mathcal{S}$, perform logical operations in the codespace. In subsystem codes, these operators are partitioned into two commuting set of Pauli operators: set of gauge operators $\mathcal{A}$ and set of logical operators $\mathcal{L}$. This partitioning induces a subsystem structure in the codespace ZLL:04 .

The (non-Abelian) gauge group is defined as $\mathcal{G}=\braket{\mathcal{S},\mathcal{A}}$. Logical operators that preserve the codespace and act trivially on the gauge subsystem are called bare-logical operators, as opposed to dressed-logical operators that also preserve the codespace but can act non-trivially in the gauge subsystem.

The relaxed criterion, allowing errors to act on the gauge subsystem in the codespace, makes subsystem codes more powerful in some cases. Subsystem codes such as the Bacon-Shor code bacon2006operator ; shor1995scheme require simpler syndrome measurements, leading to surprisingly good error correction performances aliferis2007subsystem ; Napp:2013 ; li2018direct . Furthermore, it has been shown that under the locality constraint, subsystem codes can encode more information comparing to subspace codes PhysRevA.83.012320 .

To protect a given computational Hamiltonian $H_{s}$ against a set of errors, we choose a subsystem code that can detect the errors. Then a (non-commuting) penalty Hamiltonian is constructed using the elements of the gauge group of the code:

By construction, the ground subspace of $H_{p}$ is protected against the targeted set of errors. To perform the desired computation, an encoded computational Hamiltonian $\bar{H}_{s}$ is constructed by replacing each operator in $H_{s}$ with the corresponding logical operator of the code. $\bar{H}_{s}$ performs the desired computation in the ground subspace of the penalty Hamiltonians, which is a protected subspace against errors.

Encoding $\bar{H}_{s}$ using bare-logical operators of a code guarantees that it commutes with the penalty Hamiltonian $H_{p}$, and hence the penalty Hamiltonian does not interfere with the computation. Constructing $\bar{H}_{s}+E_{p}H_{p}$ using subsystem codes, in Ref. Marvian-Lidar:16 general conditions guaranteeing protection against errors and also performance bounds have been derived. In addition, some examples of two-local Hamiltonians capable of suppressing one-local errors were introduced. One of the examples is Ising chain (without local field) in a transverse field. It was left open whether it is possible to extend such a two-local construction to encode universal Hamiltonian computation while suppressing local errors.

We first show that using bare-logical operators of any CSS subsystem code whose gauge group can be generated using two-local interactions, including the generalized Bacon-Shor subsystem codes PhysRevA.83.012320 ; yoder2019optimal , one cannot encode systems beyond the transverse field Ising chain introduced in Ref. Marvian-Lidar:16 .

For example, consider a subsystem code which has a set of weight-two gauge group generators, and has weight-two bare-logical operators $\{\bar{Z}_{1},\bar{Z}_{1}\bar{Z}_{2},\bar{Z}_{1}\bar{Z}_{3}\}$. Then $\bar{X}_{1}$ has to be at least three-local. Therefore even to generate bare-logical operations equivalent to a simple set of interactions such as $\{\bar{Z}_{1},\bar{Z}_{1}\bar{Z}_{2},\bar{Z}_{1}\bar{Z}_{3},\bar{X}_{1}\}$ or $\{\bar{Z}_{1}\bar{Z}_{2},\bar{Z}_{1}\bar{Z}_{3},\bar{Z}_{1}\bar{Z}_{4},\bar{X}_{1}\}$, physical interactions with a weight larger than two are required. From this we conclude that using this scheme with bare-logical encoding, one cannot go beyond the encoding of an Ising chain in a transverse field as constructed in Ref. Marvian-Lidar:16 .

Ising chain in a transverse field, with fast control on the transverse field, is already powerful enough to simulate any other Hamiltonian and hence is computationally universal Benjamin:01 ; lloyd2018quantum . But ground-state computation using the Ising chain in a transverse field is unlikely to be universal Cubitt:2016vl .¹¹1Since, for example, any Ising chain with transverse field can be efficiently converted to a stoquastic Hamiltonian.

To circumvent this limitation, we consider encoding using dressed logical operators.

A fully two-local code– Here we present a $[[6k,2k,2]]$ quantum subsystem code (it encodes $2k$ logical qubits into $6k$ physical qubits and can detect arbitrary 1-local errors) with the property that a complete set of its gauge group generators, single qubit logical operators $\{\bar{X}_{i},\bar{Z}_{i}\}$, and also the product of any two logical operators of the same type $\{\bar{X}_{i}\bar{X}_{j},\bar{Z}_{i}\bar{Z}_{j},\bar{Y}_{i}\bar{Y}_{j}\}$ (up to a gauge operator) can all be implemented using two-body interactions. In Figure 1, the defining properties of this code are presented. In particular, the gauge group of the code is the group generated by

where $1\leq i\leq 2k$. Single-qubit logical operators can be defined as $\bar{X}_{i}=X_{B_{i}}X_{L_{i}}$ and $\bar{Z}_{i}=Z_{B_{i}}Z_{R_{i}}$. Product of two logical operators $\bar{X}_{i}$ and $\bar{X}_{j}$ becomes $X_{B_{i}}X_{L_{i}}X_{B_{j}}X_{L_{j}}$. Since $X_{L_{i}}X_{L_{j}}$ is an element of the gauge group, the two-body interaction $X_{B_{i}}X_{B_{j}}$ implements $\bar{X}_{i}\bar{X}_{j}$ up-to a gauge operator. Similarly $\bar{Z}_{i}\bar{Z}_{j}$ and $\bar{Y}_{i}\bar{Y}_{j}$ can be implemented using two-body interactions, up-to a gauge operator. This code can be understood as an example of Bravyi’s generalization of Bacon-Shor code  PhysRevA.83.012320 (see the SM for details), also it can be interpreted as a subsystem version of the code introduced in Ref. ganti2014family .

Encoding– Suppose we want to encode the following universal Hamiltonian:

If we replace each operator in this Hamiltonian with the corresponding bare-logical operators of the introduced code, the resulting Hamiltonian,

would be at least four-local. (Implementing $\bar{X}_{i}\bar{X}_{j}$ and $\bar{Z}_{i}\bar{Z}_{j}$ require at least four-body interactions.) Instead, we implement the following two-body physical Hamiltonian:

where the notation of Fig. 1 is used. Later, we discuss how to choose $c^{\prime}_{ij}$ and $d^{\prime}_{ij}$. Re-writing this Hamiltonian using the logical and gauge operators, we have

In other words, this physical two-local Hamiltonian implements our desired computational Hamiltonian (up to some gauge operators) using dressed-logical operators of the code. Using dressed-logical operators, as opposed to bare-logical operators, we can avoid the no-go theorem.

In general, the dressed-logical operators $\bar{Z}_{i}\bar{Z}_{j}g^{z}_{ij}$ and $\bar{X}_{i}\bar{X}_{j}g^{x}_{ij}$ can couple the gauge subsystem and the information subsystem. Since $[\hat{H}_{s}(t),H_{p}]\neq 0$, the penalty Hamiltonian can interfere with our desired computation. But surprisingly, in what follows we show that in the large penalty limit this coupling effect can be easily compensated with a simple rescaling of the coefficients $c_{ij}$ and $d_{ij}$.

Although in Figure 1 the qubits appear to be on a chain, the encoding described here works for Hamiltonians on a 2D lattice (see the SM). It is important to note that this scheme encodes a geometrically local Hamiltonian into geometrically local Hamiltonian.

Also note that all the constructions and derivations presented here can be extended to the case where $H_{s}$ in Eq. 2, the Hamiltonian we want to protect, includes $Y_{i}Y_{j}$ interactions as well. This is a result of the fact that a logical $\bar{Y}_{i}\bar{Y}_{j}$ interaction can be implemented using $Y_{B_{i}}Y_{B_{j}}$ physical interactions.

Large penalty limit– In this section, we prove that in the large energy penalty limit, not only the system becomes decoupled from the bath, but it also faithfully performs the computation we encode. More precisely, in the Supplementary Material –without using perturbation theory– we prove that by increasing the energy penalty $E_{p}$ the evolution generated by $\hat{H}_{s}(t)+E_{p}H_{p}+H_{B}+H_{SB}$ becomes arbitrary close to the decoupled evolution generated by $\bar{H}_{s}(t)+H_{B}+E_{p}H_{p}$. But here it is instructive to study the effective Hamiltonian in the limit of large $E_{p}$, using first order perturbation theory. Denoting the ground subspace of the penalty Hamiltonians $H_{p}$ by $\Pi_{0}$, and assuming that the initial state is prepared in this subspace, $\hat{H}_{s}(t)+E_{p}H_{p}+H_{B}+H_{SB}$ in the large $E_{p}$ limit effectively becomes $\Pi_{0}(\hat{H}_{s}(t)+H_{B}+H_{SB})\Pi_{0}$.

Since $H_{p}$ acts non-trivially only on the system, clearly the bath Hamiltonian $H_{B}$ commutes with $\Pi_{0}$. In what follows we will show that $\Pi_{0}H_{SB}\Pi_{0}=0$ and $\Pi_{0}\hat{H}_{s}(t)\Pi_{0}=\Pi_{0}\bar{H}_{s}(t)\Pi_{0}=\Pi_{0}\bar{H}_{s}(t)$. Combing these confirms that the effective Hamiltonian becomes $\Pi_{0}(\bar{H}_{s}(t)+H_{B})$ which is the desired computation decoupled from the environment.

The rest of this section is devoted to prove that $\Pi_{0}H_{SB}\Pi_{0}=0$ and $\Pi_{0}\hat{H}_{s}(t)\Pi_{0}=\Pi_{0}\bar{H}_{s}(t)$. These two properties are consequences of the specific form of the penalty Hamiltonian, i.e., the fact that the penalty Hamiltonian does not have positive off-diagonal elements and also includes a complete set of gauge group generators.

The first part of the Lemma guarantees that the ground subspace of the penalty Hamiltonian is in the codespace and hence can detect any local error $\sigma_{\alpha}$, i.e. $\Pi_{0}\sigma_{\alpha}\Pi_{0}=0$. By assumption, the system part of the interaction Hamiltonian is one-local, i.e. $H_{SB}=\sum\sigma_{\alpha}\otimes B_{\alpha}$, and therefore

To simplify $\Pi_{0}\hat{H}_{s}(t)\Pi_{0}$, we note that by definition, bare-logical operators leave the ground subspace of the penalty Hamiltonian invariant, i.e., we have $[\bar{X}_{i},\Pi_{0}]=[\bar{Z}_{i},\Pi_{0}]=0$, and therefore

The second part of Lemma 1.1 states that the effect of gauge operators in ground subspace of the penalty Hamiltonian is just a trivial energy shift: $\Pi_{0}g_{ij}\Pi_{0}=\alpha_{ij}\Pi_{0}$, where $\alpha_{ij}$ is a scalar. Therefore, we have

Choosing $c^{\prime}_{ij}=\frac{c_{ij}}{\alpha^{x}_{ij}}$ and $d^{\prime}_{ij}=\frac{d_{ij}}{\alpha^{z}_{ij}}$ we get $\Pi_{0}\hat{H}_{s}(t)\Pi_{0}=\Pi_{0}\bar{H}_{s}(t)\Pi_{0}$, i.e., the effective Hamiltonian is identical to the desired Hamiltonian of Equation 3.

It is crucial that the rescaling ratios $\alpha_{ij}$ are independent of the computation; they only depend on the penalty Hamiltonian. For any penalty Hamiltonian these rescaling ratios can be measured (and stored) as part of a one-time calibration process. Also these coefficient are expected to be non-vanishing (see the SM), for example for the symmetric compass model, a quantum model closely related to the Bacon-Shor code li20192d , this ratio is around 0.5 brzezicki2013symmetry .

Note that the penalty Hamiltonian can be gapless, i.e., energy gap protection against errors decreases with increasing the system size. Therefore to maintain the same level of protection, we have to scale up the interactions of the penalty Hamiltonian. For the transverse field Ising spin Chain, the gap decreases linearly with the number of qubits Marvian-Lidar:16 and for the full compass model it exhibits a power-law behavior brzezicki2013symmetry . Nevertheless, in general, the minimum gap of the computational Hamiltonian can decrease exponentially. (For example, for an adiabatic quantum optimizer with a final Hamiltonian that encodes an NP-hard problem farhi_quantum_2000 .) Therefore the polynomially decreasing gap of the penalty Hamiltonian can provide significant protection against error for a large range of system sizes.

Discussions.– Adiabatic quantum computation offers some intrinsic robustness against noise due to the energy gap in the system childs_robustness_2001 ; aharonov_adiabatic_2007 ; Lloyd:2008zr . The Hamiltonians constructed to solve NP-hard problems, such as the quantum adiabatic optimization algorithms farhi_quantum_2000 , have exponentially decreasing gaps and therefore additional methods of error suppression are desirable. In this work, we have shown how to embed and protect universal Hamiltonians against local errors, using two-body interactions. For this purpose, we introduced a new error detecting code whose logical operators capable of universal AQC have a minimum weight. Since stable two-body interactions are experimentally more accessible than higher-local interactions, we expect an immediate application of our scheme in near-term quantum devices. Furthermore, our approach shows how to use simpler two-body interactions to effectively generate protected logical interactions with higher locality, and therefore we expect our approach to be useful in developing noise-resilient perturbative gadgets.

Note added: A result similar to Theorem 1, but limited to Bravyi’s generalization of Bacon-Shor code, has been independently derived by P. Lisonek, A. Roy, and S. Trandafir using a different approach.

Acknowledgments.– We thank Daniel Lidar and Andrew Kerman for their comments on earlier versions of this manuscript. We thank Sergey Bravyi and Theodore J. Yoder for useful discussions. The research is based upon work (partially) supported by the Office of the Director of National Intelligence (ODNI), Intelligence Advanced Re- search Projects Activity (IARPA), via the U.S. Army Research Office contract W911NF-17-C-0050. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies or endorsements, either expressed or implied, of the ODNI, IARPA, or the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for Governmental purposes notwithstanding any copyright annotation thereon.