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, PI

n_qubits = 2

# CNOT gate
cnot_gate = CNOT(0, 1)

# CNOT decomposed
phi = PI
cnot_decomp = chain(H(1), CPHASE(0, 1, phi), H(1))

init_state = product_state("10")

sample from CNOT gate and 100 shots = [OrderedCounter({'11': 100})]
sample from decomposed CNOT gate and 100 shots = [OrderedCounter({'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 = [OrderedCounter({'11': 100})]
sample cnot_evo = [OrderedCounter({'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.000] 
│   └── KronBlock(0,1)
│       ├── N(1)
│       └── N(0)
├── [mul: 1.000] 
│   └── KronBlock(0,2)
│       ├── N(2)
│       └── N(0)
└── [mul: 1.000] 
    └── 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=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_7a7f1be9ae9a4216b3576638faf05b58 cluster_df5a3e9d4f3a4367b431dda9c8cca738 cluster_8a86ac804a524d26935ce6f9448d8558 cluster_3784e87acb23465d96507564cbe8ee80 cluster_92af3bda0bfc422c8716d72f6d48cc9d cluster_665969b5534b4381ba01b99bba08dbab cluster_6ad06403739741558718b128d22d5a72 682fc5985c1c426588dc3855e0e79307 0 847ed1ee95c74920ab5a6c2f4a919dcd HamEvo 682fc5985c1c426588dc3855e0e79307--847ed1ee95c74920ab5a6c2f4a919dcd c122caae44484b91aba52c24a237e3bd 1 b98c43b5bee149d1a02664222ff71496 HamEvo 847ed1ee95c74920ab5a6c2f4a919dcd--b98c43b5bee149d1a02664222ff71496 0fe7df02c19d4e99a2a75218c0828a17 HamEvo b98c43b5bee149d1a02664222ff71496--0fe7df02c19d4e99a2a75218c0828a17 b8b157b422154edb94c391e759b8dd4c X 0fe7df02c19d4e99a2a75218c0828a17--b8b157b422154edb94c391e759b8dd4c 4c72c7446aca476c89b726c2cbfe51f3 HamEvo b8b157b422154edb94c391e759b8dd4c--4c72c7446aca476c89b726c2cbfe51f3 b11116c539af472b8a232549bb938db3 HamEvo 4c72c7446aca476c89b726c2cbfe51f3--b11116c539af472b8a232549bb938db3 a1ad0a669cd3452b8f795d321cc372dc X b11116c539af472b8a232549bb938db3--a1ad0a669cd3452b8f795d321cc372dc 687e6c76dacc47f1bf823c19a9a43745 a1ad0a669cd3452b8f795d321cc372dc--687e6c76dacc47f1bf823c19a9a43745 bd2b53fb4d2a4489bfff6e7837677b6c HamEvo 687e6c76dacc47f1bf823c19a9a43745--bd2b53fb4d2a4489bfff6e7837677b6c 672f4af24da84b8490a8f3e570b4da2f HamEvo bd2b53fb4d2a4489bfff6e7837677b6c--672f4af24da84b8490a8f3e570b4da2f 7f7a35ea3f2c42b28a0635667ebbb1b5 672f4af24da84b8490a8f3e570b4da2f--7f7a35ea3f2c42b28a0635667ebbb1b5 fab4705ef3934f65991edba1603f55d4 7f7a35ea3f2c42b28a0635667ebbb1b5--fab4705ef3934f65991edba1603f55d4 3ea4cf83f6d340afbdf5191b929ce549 4e4e90e70d8a406db433368c5671e8b7 t = -3.14 c122caae44484b91aba52c24a237e3bd--4e4e90e70d8a406db433368c5671e8b7 384767f574ac44db9ee9ed3828b8aac1 2 a049dd3676004854b95187cc6c4e1832 t = 3.142 4e4e90e70d8a406db433368c5671e8b7--a049dd3676004854b95187cc6c4e1832 5dd624de933845c0b7d98fb651b389c4 t = -3.14 a049dd3676004854b95187cc6c4e1832--5dd624de933845c0b7d98fb651b389c4 8e8536c93bc9463db89c9197b8792200 5dd624de933845c0b7d98fb651b389c4--8e8536c93bc9463db89c9197b8792200 069d431e527c46ecbad62b41b3d31556 t = 1.571 8e8536c93bc9463db89c9197b8792200--069d431e527c46ecbad62b41b3d31556 050bb58df67a49c39bf09fe6837a9559 t = 1.571 069d431e527c46ecbad62b41b3d31556--050bb58df67a49c39bf09fe6837a9559 1b28a9fd6960416f943dc2c0d5372987 050bb58df67a49c39bf09fe6837a9559--1b28a9fd6960416f943dc2c0d5372987 d0b295d2c1ee45178c3fa0a7699c3361 X 1b28a9fd6960416f943dc2c0d5372987--d0b295d2c1ee45178c3fa0a7699c3361 1c84a594e524407aa4aad664f2012312 t = 1.571 d0b295d2c1ee45178c3fa0a7699c3361--1c84a594e524407aa4aad664f2012312 021b3159621a4912bd76f42c8ae00f1a t = 1.571 1c84a594e524407aa4aad664f2012312--021b3159621a4912bd76f42c8ae00f1a 9e6b8c37b0f64100b6b7bb7294188a48 X 021b3159621a4912bd76f42c8ae00f1a--9e6b8c37b0f64100b6b7bb7294188a48 9e6b8c37b0f64100b6b7bb7294188a48--3ea4cf83f6d340afbdf5191b929ce549 858558ca183e464b9b7c652231fab964 a7482b9aabbb47c889a51e819b711e35 384767f574ac44db9ee9ed3828b8aac1--a7482b9aabbb47c889a51e819b711e35 41cbe8b6cc48467393119d6c9076b2eb a7482b9aabbb47c889a51e819b711e35--41cbe8b6cc48467393119d6c9076b2eb 496a4af4e9be4d6891b488b3c2cf91a0 41cbe8b6cc48467393119d6c9076b2eb--496a4af4e9be4d6891b488b3c2cf91a0 4de7c84298294ec9881f32910ca2b69e X 496a4af4e9be4d6891b488b3c2cf91a0--4de7c84298294ec9881f32910ca2b69e 71099388bf234285ad3ddc9febcf48c2 4de7c84298294ec9881f32910ca2b69e--71099388bf234285ad3ddc9febcf48c2 fa9c65d6e7954e0dbfa87a973840acc4 71099388bf234285ad3ddc9febcf48c2--fa9c65d6e7954e0dbfa87a973840acc4 c02a4ac035a54b7ca48ba4fdd989fcdf X fa9c65d6e7954e0dbfa87a973840acc4--c02a4ac035a54b7ca48ba4fdd989fcdf 904974a9da764f24a4c491249f789c58 X c02a4ac035a54b7ca48ba4fdd989fcdf--904974a9da764f24a4c491249f789c58 383904350b55477fbd446c8cb6696370 904974a9da764f24a4c491249f789c58--383904350b55477fbd446c8cb6696370 6a20b6260dde48adb624c756ac298b06 383904350b55477fbd446c8cb6696370--6a20b6260dde48adb624c756ac298b06 f418adda467f4657804b7d42a7bc672f X 6a20b6260dde48adb624c756ac298b06--f418adda467f4657804b7d42a7bc672f f418adda467f4657804b7d42a7bc672f--858558ca183e464b9b7c652231fab964

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 = [OrderedCounter({'111': 100})]
sample cnot_dacq = [OrderedCounter({'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_effb150bef334a2bb95bb66f7e9bca3b cluster_4ef5a85947184a41a29203396f5d22f6 04997446484a4f35a0fef12dc16c0db7 0 8f0a801f162e4e99b624533a5cc9f115 X 04997446484a4f35a0fef12dc16c0db7--8f0a801f162e4e99b624533a5cc9f115 482bc2228edc40dbacb5e18a553d7848 1 b9effd34218b486288be29e5c086300c HamEvo 8f0a801f162e4e99b624533a5cc9f115--b9effd34218b486288be29e5c086300c 3b12441cedb24a72a521fcdb3d8e271e X b9effd34218b486288be29e5c086300c--3b12441cedb24a72a521fcdb3d8e271e 44ced4bae23343f59a42c67961683d4f 3b12441cedb24a72a521fcdb3d8e271e--44ced4bae23343f59a42c67961683d4f 9ae46f6b02e347c3815179729a1209f5 HamEvo 44ced4bae23343f59a42c67961683d4f--9ae46f6b02e347c3815179729a1209f5 7f8364e32dea4d309fb141cd7f5eb603 9ae46f6b02e347c3815179729a1209f5--7f8364e32dea4d309fb141cd7f5eb603 d958c3717d2d423d9be34c7ac8e3da49 7f8364e32dea4d309fb141cd7f5eb603--d958c3717d2d423d9be34c7ac8e3da49 7a50da9d352549389f9d5ae33b459c07 19417086b727480ebd5971c056404486 482bc2228edc40dbacb5e18a553d7848--19417086b727480ebd5971c056404486 400ec882316b4c62a4dd163157fdcfa8 2 cf8ad5f69438491b83d8d85953622b92 t = -0.50 19417086b727480ebd5971c056404486--cf8ad5f69438491b83d8d85953622b92 f1e42d5cb8504580b84d61cc661d7fab cf8ad5f69438491b83d8d85953622b92--f1e42d5cb8504580b84d61cc661d7fab 31e84404f263432a9940384894616ec2 X f1e42d5cb8504580b84d61cc661d7fab--31e84404f263432a9940384894616ec2 a683dfba9442425eb4887927daed73ab t = -0.50 31e84404f263432a9940384894616ec2--a683dfba9442425eb4887927daed73ab f20116d4876c4f75aaa2f6329586da2c X a683dfba9442425eb4887927daed73ab--f20116d4876c4f75aaa2f6329586da2c f20116d4876c4f75aaa2f6329586da2c--7a50da9d352549389f9d5ae33b459c07 5ba889ff2a8b44c1980dad9733e6de83 4af4f30886e54279819f6d3747b56275 X 400ec882316b4c62a4dd163157fdcfa8--4af4f30886e54279819f6d3747b56275 56aae244444241bbb895f7102c38a66e 4af4f30886e54279819f6d3747b56275--56aae244444241bbb895f7102c38a66e 8a97dc6bb8db44ef8eddc3bfd8a4179c X 56aae244444241bbb895f7102c38a66e--8a97dc6bb8db44ef8eddc3bfd8a4179c 083d577c2f924ef4b771718e734916b2 X 8a97dc6bb8db44ef8eddc3bfd8a4179c--083d577c2f924ef4b771718e734916b2 2a3c40a8fe4445ba8aec983753607844 083d577c2f924ef4b771718e734916b2--2a3c40a8fe4445ba8aec983753607844 2391b0201bce45c39509b96a72978fc0 X 2a3c40a8fe4445ba8aec983753607844--2391b0201bce45c39509b96a72978fc0 2391b0201bce45c39509b96a72978fc0--5ba889ff2a8b44c1980dad9733e6de83

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_b1a5f6ae18ab48f5be8459b2f4314b26 cluster_4ba1f0f804914a56a5b20ad0d8de3cd4 bd4a1bb35fb44166a631eb510e0df9be 0 cdeff0e6899040aca423c3c9a2acf5a1 X bd4a1bb35fb44166a631eb510e0df9be--cdeff0e6899040aca423c3c9a2acf5a1 d3975c85721d4363b11e49e2027a9517 1 67e36bd8d0474419bcf61de08471343e HamEvo cdeff0e6899040aca423c3c9a2acf5a1--67e36bd8d0474419bcf61de08471343e dd5913997c8d4e2f980bbc9b8f22acbf X 67e36bd8d0474419bcf61de08471343e--dd5913997c8d4e2f980bbc9b8f22acbf 101d7cab4d9a449b92c8b4c1590b5f73 dd5913997c8d4e2f980bbc9b8f22acbf--101d7cab4d9a449b92c8b4c1590b5f73 993b4afc449f41a58958048f15af54d5 HamEvo 101d7cab4d9a449b92c8b4c1590b5f73--993b4afc449f41a58958048f15af54d5 5e19e7c426bf4d8eb314ea8a2006e65b 993b4afc449f41a58958048f15af54d5--5e19e7c426bf4d8eb314ea8a2006e65b 2ffce0ca231e4727b98491ea618cc97a 5e19e7c426bf4d8eb314ea8a2006e65b--2ffce0ca231e4727b98491ea618cc97a 89e59f76eeb6415594456057c693da9e 2936d188d2e745459082a6e0467a9686 d3975c85721d4363b11e49e2027a9517--2936d188d2e745459082a6e0467a9686 eb6f457036324644914cabf70de17e6a 2 3d6072a4cc1e4c969784646924d4aa1e t = -500. 2936d188d2e745459082a6e0467a9686--3d6072a4cc1e4c969784646924d4aa1e 32b56d1e59fa4c738f1ac7212f91762c 3d6072a4cc1e4c969784646924d4aa1e--32b56d1e59fa4c738f1ac7212f91762c 046e4522b714418f8c4208fa3f80c375 X 32b56d1e59fa4c738f1ac7212f91762c--046e4522b714418f8c4208fa3f80c375 1101c05b47e447fd87c8e7361c85e582 t = -500. 046e4522b714418f8c4208fa3f80c375--1101c05b47e447fd87c8e7361c85e582 7b79e0b54dbf47428f9ecc89d9e7ce9e X 1101c05b47e447fd87c8e7361c85e582--7b79e0b54dbf47428f9ecc89d9e7ce9e 7b79e0b54dbf47428f9ecc89d9e7ce9e--89e59f76eeb6415594456057c693da9e afcd9f6e30d24209990757a13ea36ab9 b1ad676a18f8428aacf7c3a5e13c2b87 X eb6f457036324644914cabf70de17e6a--b1ad676a18f8428aacf7c3a5e13c2b87 554f5348bae240e785b2f504214d2911 b1ad676a18f8428aacf7c3a5e13c2b87--554f5348bae240e785b2f504214d2911 d0f7004503704d688d3e7ce981db1341 X 554f5348bae240e785b2f504214d2911--d0f7004503704d688d3e7ce981db1341 1f474f144a6a4ca1a5a61df96153d663 X d0f7004503704d688d3e7ce981db1341--1f474f144a6a4ca1a5a61df96153d663 9a90a3dc60ac43daaadfef5407b9ec73 1f474f144a6a4ca1a5a61df96153d663--9a90a3dc60ac43daaadfef5407b9ec73 3cca9cbf3f8d4c6c96aa6a891920da54 X 9a90a3dc60ac43daaadfef5407b9ec73--3cca9cbf3f8d4c6c96aa6a891920da54 3cca9cbf3f8d4c6c96aa6a891920da54--afcd9f6e30d24209990757a13ea36ab9

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). ↩↩↩