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 = [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.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_3066a438f3d8496aa1b99876851421b1 cluster_6bfe77705e524147a9f2815de5330091 cluster_6c8f5fc82cb24a5fb8d38bf3299f8913 cluster_a2b2a15a6665460a8a4e79b27a1a6f26 cluster_ca2391378e92408dae0f458c9c8ba6d0 cluster_ca2b3b653f224a3ab36c540af140b9ba cluster_7d167df4e4d9458abcd313bebb6fcb67 df5395e740194d7087e615c973f332b9 0 50f4f80939544cfdb55fbe87e48d5884 HamEvo df5395e740194d7087e615c973f332b9--50f4f80939544cfdb55fbe87e48d5884 b4a04d68a3ae413082aea7be0321d2c0 1 a17db3fc3d0045ab9595d25a5afa841f HamEvo 50f4f80939544cfdb55fbe87e48d5884--a17db3fc3d0045ab9595d25a5afa841f 75d8ffc738b74c3399f39041ad980e45 HamEvo a17db3fc3d0045ab9595d25a5afa841f--75d8ffc738b74c3399f39041ad980e45 a00468d119db40709b7b6e9baa4810a4 X 75d8ffc738b74c3399f39041ad980e45--a00468d119db40709b7b6e9baa4810a4 ca23113eaf534c0ea111f3d967d562d8 HamEvo a00468d119db40709b7b6e9baa4810a4--ca23113eaf534c0ea111f3d967d562d8 8290072f806a4cb19d361ac0c5e991ce HamEvo ca23113eaf534c0ea111f3d967d562d8--8290072f806a4cb19d361ac0c5e991ce 1260bb32decb44c9a11a2ddf02fcffc3 X 8290072f806a4cb19d361ac0c5e991ce--1260bb32decb44c9a11a2ddf02fcffc3 7f7243cc744f41208d90ee6c957eba13 1260bb32decb44c9a11a2ddf02fcffc3--7f7243cc744f41208d90ee6c957eba13 5b5731c78c41490a8b98007fe489b3aa HamEvo 7f7243cc744f41208d90ee6c957eba13--5b5731c78c41490a8b98007fe489b3aa 32447f1cd14b4faebf20c8d8465c9a8d HamEvo 5b5731c78c41490a8b98007fe489b3aa--32447f1cd14b4faebf20c8d8465c9a8d e2bdaae0c5f6418aa2aa89898c6c13e7 32447f1cd14b4faebf20c8d8465c9a8d--e2bdaae0c5f6418aa2aa89898c6c13e7 3a60bceda74a425ca20f34f998f3f79c e2bdaae0c5f6418aa2aa89898c6c13e7--3a60bceda74a425ca20f34f998f3f79c 052686ca8f9444fa983a70ed2951b29f 8bbc46f1feed4723a633dae366919559 t = -3.14 b4a04d68a3ae413082aea7be0321d2c0--8bbc46f1feed4723a633dae366919559 3bf3640fdf544a8ab0b5befc7cb476bb 2 63fc6ea5e6c24130a9c16c60eb548260 t = 3.142 8bbc46f1feed4723a633dae366919559--63fc6ea5e6c24130a9c16c60eb548260 8289c99aa07e41928e91b142420f1ab7 t = -3.14 63fc6ea5e6c24130a9c16c60eb548260--8289c99aa07e41928e91b142420f1ab7 de01073b1dd54840bdca0902f09cce96 8289c99aa07e41928e91b142420f1ab7--de01073b1dd54840bdca0902f09cce96 dc4b93aeb5aa47f98f44bcac765965b2 t = 1.571 de01073b1dd54840bdca0902f09cce96--dc4b93aeb5aa47f98f44bcac765965b2 89e19d76caf34592ae4812cd000b00e7 t = 1.571 dc4b93aeb5aa47f98f44bcac765965b2--89e19d76caf34592ae4812cd000b00e7 c1104ba3170d401cba77596713f36358 89e19d76caf34592ae4812cd000b00e7--c1104ba3170d401cba77596713f36358 5f42a4efe61241d1a5eba3422a416328 X c1104ba3170d401cba77596713f36358--5f42a4efe61241d1a5eba3422a416328 f3f8af8fdaae49409244d232f6484289 t = 1.571 5f42a4efe61241d1a5eba3422a416328--f3f8af8fdaae49409244d232f6484289 130416a92dee4e27853c7d18a268f361 t = 1.571 f3f8af8fdaae49409244d232f6484289--130416a92dee4e27853c7d18a268f361 8bcb77f2454b4b0289460744ff0a77ef X 130416a92dee4e27853c7d18a268f361--8bcb77f2454b4b0289460744ff0a77ef 8bcb77f2454b4b0289460744ff0a77ef--052686ca8f9444fa983a70ed2951b29f 7ca4ca25e4e646669edd553dffcd2a6a f26753914b8d4e0ea4d1573d38f32711 3bf3640fdf544a8ab0b5befc7cb476bb--f26753914b8d4e0ea4d1573d38f32711 a521c71c77234f93b58a8b069653fa8a f26753914b8d4e0ea4d1573d38f32711--a521c71c77234f93b58a8b069653fa8a c2bb469af98a4af0b8c9800d63766451 a521c71c77234f93b58a8b069653fa8a--c2bb469af98a4af0b8c9800d63766451 e6148c2dba18467a8cfd5693c929e722 X c2bb469af98a4af0b8c9800d63766451--e6148c2dba18467a8cfd5693c929e722 70581efb624446f78c35de4f0c66559b e6148c2dba18467a8cfd5693c929e722--70581efb624446f78c35de4f0c66559b f47144d5d9a542c4a7e26a7b844b5dc4 70581efb624446f78c35de4f0c66559b--f47144d5d9a542c4a7e26a7b844b5dc4 9892f904073e483298beb4b9a7c6a44d X f47144d5d9a542c4a7e26a7b844b5dc4--9892f904073e483298beb4b9a7c6a44d a647d51fd9ec4b4ea171e694b26af294 X 9892f904073e483298beb4b9a7c6a44d--a647d51fd9ec4b4ea171e694b26af294 73651967fe894ba791b65ae0809343c0 a647d51fd9ec4b4ea171e694b26af294--73651967fe894ba791b65ae0809343c0 88a98ccc5838432ea411666a0233220a 73651967fe894ba791b65ae0809343c0--88a98ccc5838432ea411666a0233220a 65ee07a2823640a68c6fd31824e5c781 X 88a98ccc5838432ea411666a0233220a--65ee07a2823640a68c6fd31824e5c781 65ee07a2823640a68c6fd31824e5c781--7ca4ca25e4e646669edd553dffcd2a6a

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_ff4dd9c38b644b5d9dc5c686cfee46d2 cluster_8ff9532170474838ad46aef5a2c26bbe f1bbe854ee084a99a670799cb60cf37a 0 6545be8d6ebb4e1da92887df4b748a0a X f1bbe854ee084a99a670799cb60cf37a--6545be8d6ebb4e1da92887df4b748a0a e63b78e2c0fd43ba9970f82facbd1fe9 1 f9c9909ba3604b6293d0382fb49b9a7e HamEvo 6545be8d6ebb4e1da92887df4b748a0a--f9c9909ba3604b6293d0382fb49b9a7e 46dded4158f0426997a66faf09995a64 X f9c9909ba3604b6293d0382fb49b9a7e--46dded4158f0426997a66faf09995a64 ea5bdca338c2432285cc70c39d49ab4e 46dded4158f0426997a66faf09995a64--ea5bdca338c2432285cc70c39d49ab4e f177985b1635480ca1ce66afd8947fa8 HamEvo ea5bdca338c2432285cc70c39d49ab4e--f177985b1635480ca1ce66afd8947fa8 7533db29db4b48b191124b4aaf42125e f177985b1635480ca1ce66afd8947fa8--7533db29db4b48b191124b4aaf42125e 6703f8e05575428a8bbd4ab866253299 7533db29db4b48b191124b4aaf42125e--6703f8e05575428a8bbd4ab866253299 a8ddba9076e1405a915f6a000eb9f84d 7af615be63ca430184b4080fd1a5c855 e63b78e2c0fd43ba9970f82facbd1fe9--7af615be63ca430184b4080fd1a5c855 1a488307f2ff4669995e5b19928a4982 2 5d20e9678317403795bff47e5ac44e40 t = -0.50 7af615be63ca430184b4080fd1a5c855--5d20e9678317403795bff47e5ac44e40 a53524feade3426e9b2baadbbaa99538 5d20e9678317403795bff47e5ac44e40--a53524feade3426e9b2baadbbaa99538 5995f790e9544faca6de9a310f9c9424 X a53524feade3426e9b2baadbbaa99538--5995f790e9544faca6de9a310f9c9424 b9f04499bd7e4644aae560f2fb2f3ce8 t = -0.50 5995f790e9544faca6de9a310f9c9424--b9f04499bd7e4644aae560f2fb2f3ce8 a22dece928c44f9aa7b43cd2e4e75327 X b9f04499bd7e4644aae560f2fb2f3ce8--a22dece928c44f9aa7b43cd2e4e75327 a22dece928c44f9aa7b43cd2e4e75327--a8ddba9076e1405a915f6a000eb9f84d 33e95cce556b4efda35520ae4bfe66f3 deda9e69c6f5440c9223c9439ca686da X 1a488307f2ff4669995e5b19928a4982--deda9e69c6f5440c9223c9439ca686da b40d7e11e36f428b8e581e15b38a5528 deda9e69c6f5440c9223c9439ca686da--b40d7e11e36f428b8e581e15b38a5528 712367f21556428cb310088d59635635 X b40d7e11e36f428b8e581e15b38a5528--712367f21556428cb310088d59635635 76ec193b32c24676a09b9d370ba47238 X 712367f21556428cb310088d59635635--76ec193b32c24676a09b9d370ba47238 eaaefa30ec77442fab2e4b8c43295a72 76ec193b32c24676a09b9d370ba47238--eaaefa30ec77442fab2e4b8c43295a72 d7296e34e676473691c0fee6f6e34670 X eaaefa30ec77442fab2e4b8c43295a72--d7296e34e676473691c0fee6f6e34670 d7296e34e676473691c0fee6f6e34670--33e95cce556b4efda35520ae4bfe66f3

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_cc6f34be93494a5eb37d88a3fa6bcf0c cluster_7c5ba9a69ffe4c819941c754572f416e 6a98704c41cd4a23a193e9fd1804509a 0 51fac02d8a0f48b6b6fb364650f42a06 X 6a98704c41cd4a23a193e9fd1804509a--51fac02d8a0f48b6b6fb364650f42a06 a99f0d3f461c4720b28311db554f5472 1 ccb7292f562048749eac6072e8cfe8d9 HamEvo 51fac02d8a0f48b6b6fb364650f42a06--ccb7292f562048749eac6072e8cfe8d9 470d59b66eb8440db722f56996ef3532 X ccb7292f562048749eac6072e8cfe8d9--470d59b66eb8440db722f56996ef3532 82374affd8dc4e05a32e1a6aa3f63c83 470d59b66eb8440db722f56996ef3532--82374affd8dc4e05a32e1a6aa3f63c83 afaf5e4c0cd94c46abd4fe684a83484e HamEvo 82374affd8dc4e05a32e1a6aa3f63c83--afaf5e4c0cd94c46abd4fe684a83484e 64ec0b47926c4677af97e0aa2f6b8848 afaf5e4c0cd94c46abd4fe684a83484e--64ec0b47926c4677af97e0aa2f6b8848 df01a4c72ad640049940c20996b4c406 64ec0b47926c4677af97e0aa2f6b8848--df01a4c72ad640049940c20996b4c406 e01e0fa4e4ac4350b15b7980fb6af280 6b60a606e17b4566925bae7b684445ba a99f0d3f461c4720b28311db554f5472--6b60a606e17b4566925bae7b684445ba db97eea663844cb3a49e7fa857252a9d 2 9ad0eceb3fd140a3baa3dda72c5d4f16 t = -500. 6b60a606e17b4566925bae7b684445ba--9ad0eceb3fd140a3baa3dda72c5d4f16 0186e382712e4d1a88faeb1244056767 9ad0eceb3fd140a3baa3dda72c5d4f16--0186e382712e4d1a88faeb1244056767 8f48c24772ae4cdf9ebcf2d48a5b6a3f X 0186e382712e4d1a88faeb1244056767--8f48c24772ae4cdf9ebcf2d48a5b6a3f 2a5f62eb0a3a4bcebdf4e5cfac369ee9 t = -500. 8f48c24772ae4cdf9ebcf2d48a5b6a3f--2a5f62eb0a3a4bcebdf4e5cfac369ee9 adbb92129c3a4e739001ab01acedb8ae X 2a5f62eb0a3a4bcebdf4e5cfac369ee9--adbb92129c3a4e739001ab01acedb8ae adbb92129c3a4e739001ab01acedb8ae--e01e0fa4e4ac4350b15b7980fb6af280 83b6aad1f64b4f67a6faa9499bebccb6 d6235be86a414bf18e60f2a455bfd0e6 X db97eea663844cb3a49e7fa857252a9d--d6235be86a414bf18e60f2a455bfd0e6 2aee0a4c4f1b486594f843fc99f6831d d6235be86a414bf18e60f2a455bfd0e6--2aee0a4c4f1b486594f843fc99f6831d e927ac9ce8d44e68a1bedc840fcec812 X 2aee0a4c4f1b486594f843fc99f6831d--e927ac9ce8d44e68a1bedc840fcec812 28259013dc9e4c6eb00a1153f6a821a9 X e927ac9ce8d44e68a1bedc840fcec812--28259013dc9e4c6eb00a1153f6a821a9 4cd54bc25d3146b9ac7314e63bd1c09a 28259013dc9e4c6eb00a1153f6a821a9--4cd54bc25d3146b9ac7314e63bd1c09a 165f1767440649ffbb8386947e9a7a3b X 4cd54bc25d3146b9ac7314e63bd1c09a--165f1767440649ffbb8386947e9a7a3b 165f1767440649ffbb8386947e9a7a3b--83b6aad1f64b4f67a6faa9499bebccb6

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