Skip to content

CNOT with interacting qubits

Digital-analog quantum computing focuses on using single qubit digital gates combined with more complex and device-dependent analog interactions to represent quantum programs. This paradigm has been shown to be universal for quantum computation1. However, while this approach may have advantages when adapting quantum programs to real devices, known quantum algorithms are very often expressed in a fully digital paradigm. As such, it is also important to have concrete ways to transform from one paradigm to another.

This tutorial will exemplify the DAQC transformation starting with the representation of a simple digital CNOT using the universality of the Ising Hamiltonian2.

CNOT with CPHASE

Let's look at a single example of how the digital-analog transformation can be used to perform a CNOT on two qubits inside a register of globally interacting qubits.

First, note that the CNOT can be decomposed with two Hadamard and a CPHASE gate with \(\phi=\pi\):

import torch
from qadence import chain, sample, product_state

from qadence.draw import display
from qadence import X, I, Z, H, N, CPHASE, CNOT, HamEvo

n_qubits = 2

# CNOT gate
cnot_gate = CNOT(0, 1)

# CNOT decomposed
phi = torch.pi
cnot_decomp = chain(H(1), CPHASE(0, 1, phi), H(1))

init_state = product_state("10")

sample from CNOT gate and 100 shots = [Counter({'11': 100})]
sample from decomposed CNOT gate and 100 shots = [Counter({'11': 100})]

The CPHASE matrix is diagonal, and can be implemented by exponentiating an Ising-like Hamiltonian, or generator,

\[\text{CPHASE}(i,j,\phi)=\text{exp}\left(-i\phi \mathcal{H}_\text{CP}(i, j)\right)\]
\[\begin{aligned} \mathcal{H}_\text{CP}&=-\frac{1}{4}(I_i-Z_i)(I_j-Z_j)\\ &=-N_iN_j \end{aligned}\]

where the number operator \(N_i = \frac{1}{2}(I_i-Z_i)=\hat{n}_i\) is used, leading to an Ising-like interaction \(\hat{n}_i\hat{n}_j\) realisable in neutral-atom systems. Let's rebuild the CNOT using this evolution.

from qadence import kron, block_to_tensor

# Hamiltonian for the CPHASE gate
h_cphase = (-1.0) * kron(N(0), N(1))

# Exponentiating and time-evolving the Hamiltonian until t=phi.
cphase_evo = HamEvo(h_cphase, phi)

# Check that we have the CPHASE gate:
cphase_matrix = block_to_tensor(CPHASE(0, 1, phi))
cphase_evo_matrix = block_to_tensor(cphase_evo)

cphase_matrix == cphase_evo_matrix: True

Now that the CPHASE generator is checked, it can be applied to the CNOT:

# CNOT with Hamiltonian Evolution
cnot_evo = chain(
    H(1),
    cphase_evo,
    H(1)
)

# Initialize state to check CNOTs sample outcomes.
init_state = product_state("10")

sample cnot_gate = [Counter({'11': 100})]
sample cnot_evo = [Counter({'11': 100})]

Thus, a CNOT gate can be created by combining a few single-qubit gates together with a two-qubit Ising interaction between the control and the target qubit which is the essence of the Ising transform proposed in the seminal DAQC paper2 for \(ZZ\) interactions. In Qadence, both \(ZZ\) and \(NN\) interactions are supported.

CNOT in an interacting system of three qubits

Consider a simple experimental setup with \(n=3\) interacting qubits laid out in a triangular grid. For the sake of simplicity, all qubits interact with each other with an \(NN\)-Ising interaction of constant strength \(g_\text{int}\). The Hamiltonian for the system can be written by summing interaction terms over all pairs:

\[\mathcal{H}_\text{sys}=\sum_{i=0}^{n}\sum_{j=0}^{i-1}g_\text{int}N_iN_j,\]

which in this case leads to only three interaction terms,

\[\mathcal{H}_\text{sys}=g_\text{int}(N_0N_1+N_1N_2+N_0N_2)\]

This generator can be easily built in Qadence:

from qadence import add, kron
n_qubits = 3

# Interaction strength.
g_int = 1.0

# Build a list of interactions.
interaction_list = []
for i in range(n_qubits):
    for j in range(i):
        interaction_list.append(g_int * kron(N(i), N(j)))

h_sys = add(*interaction_list)

h_sys = AddBlock(0,1,2)
├── [mul: 1.00000000000000] 
│   └── KronBlock(0,1)
│       ├── N(1)
│       └── N(0)
├── [mul: 1.00000000000000] 
│   └── KronBlock(0,2)
│       ├── N(2)
│       └── N(0)
└── [mul: 1.00000000000000] 
    └── KronBlock(1,2)
        ├── N(2)
        └── N(1)

Now let's consider that the experimental system is fixed, and qubits can not be isolated one from another. The options are:

  • Turn on or off the global system Hamiltonian.
  • Perform local single-qubit rotations.

To perform a fully digital CNOT(0,1), the interacting control on qubit 0 and target on qubit 1 must be isolated from the third one to implement the gate directly. While this can be achieved for a three-qubit system, it becomes experimentally untractable when scaling the qubit count.

However, this is not the case within the digital-analog paradigm. In fact, the two qubit Ising interaction required for the CNOT can be represented with a combination of the global system Hamiltonian and a specific set of single-qubit rotations. Full details about this transformation are to be found in the DAQC paper2 but a more succint yet in-depth description takes place in the next section. It is conveniently available in Qadence by calling the daqc_transform function.

In the most general sense, the daqc_transform function will return a circuit that represents the evolution of a target Hamiltonian \(\mathcal{H}_\text{target}\) (here the unitary of the gate) until a specified time \(t_f\) by using only the evolution of a build Hamiltonian \(\mathcal{H}_\text{build}\) (here \(\mathcal{H}_\text{sys}\)) together with local \(X\)-gates. In Qadence, daqc_transform is applicable for \(\mathcal{H}_\text{target}\) and \(\mathcal{H}_\text{build}\) composed only of \(ZZ\)- or \(NN\)-interactions. These generators are parsed by the daqc_transform function and the appropriate type is automatically determined together with the appropriate single-qubit detunings and global phases.

Let's apply it for the CNOT implementation:

from qadence import daqc_transform, Strategy

# Settings for the target CNOT operation
i = 0  # Control qubit
j = 1  # Target qubit
k = 2  # The extra qubit

# Define the target CNOT operation
# by composing with identity on the extra qubit.
cnot_target = kron(CNOT(i, j), I(k))

# The two-qubit NN-Ising interaction term for the CPHASE
h_int = (-1.0) * kron(N(i), N(j))

# Transforming the two-qubit Ising interaction using only our system Hamiltonian
transformed_ising = daqc_transform(
    n_qubits=3,        # Total number of qubits in the transformation
    gen_target=h_int,  # The target Ising generator
    t_f=torch.pi,      # The target evolution time
    gen_build=h_sys,   # The building block Ising generator to be used
    strategy=Strategy.SDAQC,   # Currently only sDAQC is implemented
    ignore_global_phases=False  # Global phases from mapping between Z and N
)

# display(transformed_ising)
%3 cluster_e061217bf248482c87a6d92dc054bef6 cluster_e52d9442142c436f83de456550cf43f5 cluster_812209e5106f4ab9bd78fb1a7c40a0be cluster_5d73ecc99bbd465986cb81602ff0be47 cluster_1dd45656162c4779bb28ed6179b5b9d8 cluster_0a5387cfc357472da4efabd60d5ff622 cluster_9b3c8e4e580943a780fafdec0059e47b b01963baddc14c98bda35d1950e31777 0 927d7d8bd2fe4d69b9eedd9c19b92b1e HamEvo b01963baddc14c98bda35d1950e31777--927d7d8bd2fe4d69b9eedd9c19b92b1e 7e2e3c8285e5473a9e771b90caab8a40 1 00f739b850e9451488fac1c1c1d6e36a HamEvo 927d7d8bd2fe4d69b9eedd9c19b92b1e--00f739b850e9451488fac1c1c1d6e36a 7277252dcac24bfdb460fabf9033d4fa HamEvo 00f739b850e9451488fac1c1c1d6e36a--7277252dcac24bfdb460fabf9033d4fa f3f6068388cf41c7bd0d9512872321ee X 7277252dcac24bfdb460fabf9033d4fa--f3f6068388cf41c7bd0d9512872321ee d826e6e6886d4c43b9387d14af826572 HamEvo f3f6068388cf41c7bd0d9512872321ee--d826e6e6886d4c43b9387d14af826572 005b253d84b94dc2a5aad29973ae44d3 HamEvo d826e6e6886d4c43b9387d14af826572--005b253d84b94dc2a5aad29973ae44d3 f2229401166a4153baec3481ae65ef8f X 005b253d84b94dc2a5aad29973ae44d3--f2229401166a4153baec3481ae65ef8f d613ce5130554027a039466f9ea5dc05 f2229401166a4153baec3481ae65ef8f--d613ce5130554027a039466f9ea5dc05 afc54bce9cab4bc9a68402c4cdf40477 HamEvo d613ce5130554027a039466f9ea5dc05--afc54bce9cab4bc9a68402c4cdf40477 0377808d78834f9c8dddfde1af81661a HamEvo afc54bce9cab4bc9a68402c4cdf40477--0377808d78834f9c8dddfde1af81661a f4e54a68c44f41b4a9da5b249bcdd1c0 0377808d78834f9c8dddfde1af81661a--f4e54a68c44f41b4a9da5b249bcdd1c0 b070d44024334c799fcf1a55a1db3618 f4e54a68c44f41b4a9da5b249bcdd1c0--b070d44024334c799fcf1a55a1db3618 b0734549bf354b888fe6122fe42db940 d0e8335db4a14602a01abeb6d9a91690 t = -3.142 7e2e3c8285e5473a9e771b90caab8a40--d0e8335db4a14602a01abeb6d9a91690 973ba4b448a84b58900bf470f61cd3b5 2 8c369256660f41b9a7385029ed99d74e t = 3.142 d0e8335db4a14602a01abeb6d9a91690--8c369256660f41b9a7385029ed99d74e 09f6e6b96e53433b8b6b08210302ca11 t = -3.142 8c369256660f41b9a7385029ed99d74e--09f6e6b96e53433b8b6b08210302ca11 9adfad882b2f441f9a132b63b26d7eb9 09f6e6b96e53433b8b6b08210302ca11--9adfad882b2f441f9a132b63b26d7eb9 611c4c7091e64c16b871e79e542f43bc t = 1.571 9adfad882b2f441f9a132b63b26d7eb9--611c4c7091e64c16b871e79e542f43bc d71f3375491f4e24b116e7209a632739 t = 1.571 611c4c7091e64c16b871e79e542f43bc--d71f3375491f4e24b116e7209a632739 47a9781b0583435585ad64c16fcb589f d71f3375491f4e24b116e7209a632739--47a9781b0583435585ad64c16fcb589f e3e53b8cc7fb4421a1fce3d924d87503 X 47a9781b0583435585ad64c16fcb589f--e3e53b8cc7fb4421a1fce3d924d87503 03dda32f6c274188a9a2cef84fd95d3e t = 1.571 e3e53b8cc7fb4421a1fce3d924d87503--03dda32f6c274188a9a2cef84fd95d3e e8bb192c2016405788029ae5f8b997eb t = 1.571 03dda32f6c274188a9a2cef84fd95d3e--e8bb192c2016405788029ae5f8b997eb 8284f49438574362b08ec5e465c52c1e X e8bb192c2016405788029ae5f8b997eb--8284f49438574362b08ec5e465c52c1e 8284f49438574362b08ec5e465c52c1e--b0734549bf354b888fe6122fe42db940 a4b00c0681e54eedbb61000736627bf4 7dab784ca7fc4299873c50a8c951dab9 973ba4b448a84b58900bf470f61cd3b5--7dab784ca7fc4299873c50a8c951dab9 0f4e84b069ff478d832b2834e4ded9ac 7dab784ca7fc4299873c50a8c951dab9--0f4e84b069ff478d832b2834e4ded9ac b584cd4c524d43748d4a3849fe0a893d 0f4e84b069ff478d832b2834e4ded9ac--b584cd4c524d43748d4a3849fe0a893d bb424477ea3940e7a894a511feffb950 X b584cd4c524d43748d4a3849fe0a893d--bb424477ea3940e7a894a511feffb950 a2fb193104934a45aa2ff7b0bef64034 bb424477ea3940e7a894a511feffb950--a2fb193104934a45aa2ff7b0bef64034 09324a3b5d6e4b46aa6d7461fbe68d93 a2fb193104934a45aa2ff7b0bef64034--09324a3b5d6e4b46aa6d7461fbe68d93 8365bc24fe00485482744a6eb69ac593 X 09324a3b5d6e4b46aa6d7461fbe68d93--8365bc24fe00485482744a6eb69ac593 d08937ebc3084c06ad023491182f2e24 X 8365bc24fe00485482744a6eb69ac593--d08937ebc3084c06ad023491182f2e24 8c6739710bcf4392ab7d81a8e6556cc2 d08937ebc3084c06ad023491182f2e24--8c6739710bcf4392ab7d81a8e6556cc2 b2417e6a43f44776996f9a4c98255d01 8c6739710bcf4392ab7d81a8e6556cc2--b2417e6a43f44776996f9a4c98255d01 b2f9d66f814f46c8b2acd2fc7ead2525 X b2417e6a43f44776996f9a4c98255d01--b2f9d66f814f46c8b2acd2fc7ead2525 b2f9d66f814f46c8b2acd2fc7ead2525--a4b00c0681e54eedbb61000736627bf4

The output circuit displays three groups of system Hamiltonian evolutions which account for global-phases and single-qubit detunings related to the mapping between the \(Z\) and \(N\) operators. Optionally, global phases can be ignored.

In general, the mapping of a \(n\)-qubit Ising Hamiltonian to another will require at most \(n(n-1)\) evolutions. The transformed circuit performs these evolutions for specific times that are computed from the solution of a linear system of equations involving the set of interactions in the target and build Hamiltonians.

In this case, the mapping is exact when using the step-wise DAQC strategy (Strategy.SDAQC) available in Qadence. In banged DAQC (Strategy.BDAQC) the mapping is approximate, but easier to implement on a physical device with always-on interactions such as neutral-atom systems.

Just as before, the transformed Ising circuit can be checked to exactly recover the CPHASE gate:

# CPHASE on (i, j), Identity on third qubit:
cphase_matrix = block_to_tensor(kron(CPHASE(i, j, phi), I(k)))

# CPHASE using the transformed circuit:
cphase_evo_matrix = block_to_tensor(transformed_ising)

# Check that it implements the CPHASE.
# Will fail if global phases are ignored.

cphase_matrix == cphase_evo_matrix : True

The CNOT gate can now finally be built:

from qadence import equivalent_state, run, sample

cnot_daqc = chain(
    H(j),
    transformed_ising,
    H(j)
)

# And finally apply the CNOT on a specific 3-qubit initial state:
init_state = product_state("101")

# Check we get an equivalent wavefunction
wf_cnot = run(n_qubits, block=cnot_target, state=init_state)
wf_daqc = run(n_qubits, block=cnot_daqc, state=init_state)

# Visualize the CNOT bit-flip in samples.

wf_cnot == wf_dacq : True
sample cnot_target = [Counter({'111': 100})]
sample cnot_dacq = [Counter({'111': 100})]

As one can see, a CNOT operation has been succesfully implemented on the desired target qubits by using only the global system as the building block Hamiltonian and single-qubit rotations. Decomposing a single digital gate into an Ising Hamiltonian serves as a proof of principle for the potential of this technique to represent universal quantum computation.

Technical details on the DAQC transformation

  • The mapping between target generator and final circuit is performed by solving a linear system of size \(n(n-1)\) where \(n\) is the number of qubits, so it can be computed efficiently (i.e., with a polynomial cost in the number of qubits).
  • The linear system to be solved is actually not invertible for \(n=4\) qubits. This is very specific edge case requiring a workaround, that is currently not yet implemented.
  • As mentioned, the final circuit has at most \(n(n-1)\) slices, so there is at most a quadratic overhead in circuit depth.

Finally, and most important to its usage:

  • The target Hamiltonian should be sufficiently represented in the building block Hamiltonian.

To illustrate this point, consider the following target and build Hamiltonians:

# Interaction between qubits 0 and 1
gen_target = 1.0 * (Z(0) @ Z(1))

# Fixed interaction between qubits 1 and 2, and customizable between 0 and 1
def gen_build(g_int):
    return g_int * (Z(0) @ Z(1)) + 1.0 * (Z(1) @ Z(2))

And now we perform the DAQC transform by setting g_int=1.0, exactly matching the target Hamiltonian:

transformed_ising = daqc_transform(
    n_qubits=3,
    gen_target=gen_target,
    t_f=1.0,
    gen_build=gen_build(g_int=1.0),
)

# display(transformed_ising)
%3 cluster_104c4122548f4555ab5c932d0a644b3c cluster_a1ac2effd2cf45428b1b761c037e2503 d40c26d0d63046d888dadfc0e68bd1a4 0 fd3735ac76bc4e8ebae911524cf0f1bf X d40c26d0d63046d888dadfc0e68bd1a4--fd3735ac76bc4e8ebae911524cf0f1bf 055d93ac256d4ac9a0587425ec7b517e 1 d3387f6d8ae64e39877950f9f36c3861 HamEvo fd3735ac76bc4e8ebae911524cf0f1bf--d3387f6d8ae64e39877950f9f36c3861 099bbd9cd1034c768b0aa35d66b29066 X d3387f6d8ae64e39877950f9f36c3861--099bbd9cd1034c768b0aa35d66b29066 0a6f4acd6ad749afa28e9cd2be44caaf 099bbd9cd1034c768b0aa35d66b29066--0a6f4acd6ad749afa28e9cd2be44caaf 615d671af9454e53a9890902ff3c635f HamEvo 0a6f4acd6ad749afa28e9cd2be44caaf--615d671af9454e53a9890902ff3c635f e23fa32420fc4bf49e3aeb70bad0d534 615d671af9454e53a9890902ff3c635f--e23fa32420fc4bf49e3aeb70bad0d534 7bf7eb85e7cf40e9b832fd9787225e27 e23fa32420fc4bf49e3aeb70bad0d534--7bf7eb85e7cf40e9b832fd9787225e27 942dd15135414074927e1d4666923af2 25f22626700843afbaa5a0f73f2c91f9 055d93ac256d4ac9a0587425ec7b517e--25f22626700843afbaa5a0f73f2c91f9 ae7deaf4055f4899aacb90872463dac1 2 a5395c8aeaaa4eb3989d7041e7670dce t = -0.500 25f22626700843afbaa5a0f73f2c91f9--a5395c8aeaaa4eb3989d7041e7670dce f60a190848634680a69e3e6f0f543809 a5395c8aeaaa4eb3989d7041e7670dce--f60a190848634680a69e3e6f0f543809 834aec1ac0b542d0922a75d5cea2bd85 X f60a190848634680a69e3e6f0f543809--834aec1ac0b542d0922a75d5cea2bd85 9da60afb51134bdd9dca17968d2641e8 t = -0.500 834aec1ac0b542d0922a75d5cea2bd85--9da60afb51134bdd9dca17968d2641e8 75ac9d79a0c74888913626c808557739 X 9da60afb51134bdd9dca17968d2641e8--75ac9d79a0c74888913626c808557739 75ac9d79a0c74888913626c808557739--942dd15135414074927e1d4666923af2 22a6fe5ffd7840269b773cc8b108562c d36de44e91ab49148267c8c20acfbdf5 X ae7deaf4055f4899aacb90872463dac1--d36de44e91ab49148267c8c20acfbdf5 92227471a45c457b8bf171436ef61392 d36de44e91ab49148267c8c20acfbdf5--92227471a45c457b8bf171436ef61392 d94e960d6f4a4b6dbe47b01090a004e0 X 92227471a45c457b8bf171436ef61392--d94e960d6f4a4b6dbe47b01090a004e0 1a63fbc4d44d478793fd8f6db4b3cfa2 X d94e960d6f4a4b6dbe47b01090a004e0--1a63fbc4d44d478793fd8f6db4b3cfa2 1a1db1eb05c6446f94a23a3eae485863 1a63fbc4d44d478793fd8f6db4b3cfa2--1a1db1eb05c6446f94a23a3eae485863 097a77b2de1545c689367c0bb7cec472 X 1a1db1eb05c6446f94a23a3eae485863--097a77b2de1545c689367c0bb7cec472 097a77b2de1545c689367c0bb7cec472--22a6fe5ffd7840269b773cc8b108562c

Now, if the interaction between qubits 0 and 1 is weakened in the build Hamiltonian:

transformed_ising = daqc_transform(
    n_qubits=3,
    gen_target=gen_target,
    t_f=1.0,
    gen_build=gen_build(g_int=0.001),
)

# display(transformed_ising)
%3 cluster_a8c49c8f7312460d9272024b1889cad2 cluster_ff2a6bc18abf4e6d8ced9bf0b0daa193 507973b2ae01464da4e40ebc6be56451 0 0dac5d7279094c1c8190061f1c6c0960 X 507973b2ae01464da4e40ebc6be56451--0dac5d7279094c1c8190061f1c6c0960 b774d063f69a4915b3a19c4744839c8a 1 64a5c25b0cc048c08cdfba85e6275b72 HamEvo 0dac5d7279094c1c8190061f1c6c0960--64a5c25b0cc048c08cdfba85e6275b72 b4885377abb24e64bd8b5a8ad5cbee00 X 64a5c25b0cc048c08cdfba85e6275b72--b4885377abb24e64bd8b5a8ad5cbee00 02354f611b174049ae2bc048ba590115 b4885377abb24e64bd8b5a8ad5cbee00--02354f611b174049ae2bc048ba590115 9409531a52d8438c8aa7e2b292af5121 HamEvo 02354f611b174049ae2bc048ba590115--9409531a52d8438c8aa7e2b292af5121 3cdc98c087a04ace808fdf4adb958a14 9409531a52d8438c8aa7e2b292af5121--3cdc98c087a04ace808fdf4adb958a14 592da8af1ee84a9784bf305671195554 3cdc98c087a04ace808fdf4adb958a14--592da8af1ee84a9784bf305671195554 614b7b3c8d704773ae55671f2dc79aec 10015766287b4b4db12cb60c9f6c319b b774d063f69a4915b3a19c4744839c8a--10015766287b4b4db12cb60c9f6c319b 5283241cd47744ac85f7c7499767e008 2 98270c7931284da7b1e739019a63a3ea t = -500.000000000000 10015766287b4b4db12cb60c9f6c319b--98270c7931284da7b1e739019a63a3ea 8370a119b2e649ffae91e43aaa337f85 98270c7931284da7b1e739019a63a3ea--8370a119b2e649ffae91e43aaa337f85 fa05068c1e3442a2b2d109ff7f0b7006 X 8370a119b2e649ffae91e43aaa337f85--fa05068c1e3442a2b2d109ff7f0b7006 86ea53a4f26c458f83f5511fa6a15099 t = -500.000000000000 fa05068c1e3442a2b2d109ff7f0b7006--86ea53a4f26c458f83f5511fa6a15099 fc7f2825aec3489ea9ff411e7962abf0 X 86ea53a4f26c458f83f5511fa6a15099--fc7f2825aec3489ea9ff411e7962abf0 fc7f2825aec3489ea9ff411e7962abf0--614b7b3c8d704773ae55671f2dc79aec 957f6f904886416bae1ab2e10f040cd7 62083a03ea32403a832d268334d034ca X 5283241cd47744ac85f7c7499767e008--62083a03ea32403a832d268334d034ca e8ea5e789f6f43368017637062b9ad31 62083a03ea32403a832d268334d034ca--e8ea5e789f6f43368017637062b9ad31 d605abe9c6024f0589b922fe71591e7e X e8ea5e789f6f43368017637062b9ad31--d605abe9c6024f0589b922fe71591e7e 0a323eadbfa34a8e8129d3ed3101db0e X d605abe9c6024f0589b922fe71591e7e--0a323eadbfa34a8e8129d3ed3101db0e b9648f7f14ee4b94b1124d56c4e4dcb0 0a323eadbfa34a8e8129d3ed3101db0e--b9648f7f14ee4b94b1124d56c4e4dcb0 1a03bf65a5834076860cd6a3a29688f2 X b9648f7f14ee4b94b1124d56c4e4dcb0--1a03bf65a5834076860cd6a3a29688f2 1a03bf65a5834076860cd6a3a29688f2--957f6f904886416bae1ab2e10f040cd7

The times slices using the build Hamiltonian need now to evolve for much longer to represent the same interaction since it is not sufficiently represented in the building block Hamiltonian.

In the limit where that interaction is not present, the transform will not work:

try:
    transformed_ising = daqc_transform(
        n_qubits=3,
        gen_target=gen_target,
        t_f=1.0,
        gen_build=gen_build(g_int = 0.0),
    )
except ValueError as error:
    print("Error:", error)

Error: Incompatible interactions between target and build Hamiltonians.

References

  1. Dodd et al., Universal quantum computation and simulation using any entangling Hamiltonian and local unitaries, PRA 65, 040301 (2002). ↩

  2. Parra-Rodriguez et al., Digital-Analog Quantum Computation, PRA 101, 022305 (2020). ↩↩↩