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_1282930239984e1b8e7efa331e2cf801 cluster_d34bdbc8f09243898464a3fdc83f4286 cluster_5a7ae64bca73474f85273bd0699be98c cluster_1e10596ec9634147948cfceab5858220 cluster_1a3dedd3ca424a119593c14a24c6177d cluster_bd006dd0696b42aaa00bb538276d3177 cluster_2b1d49552bb14432b741161204bb1742 9b3706aa6eb0406fa454afd03f646056 0 cdd2ac4a7538490c9569749c3778811d HamEvo 9b3706aa6eb0406fa454afd03f646056--cdd2ac4a7538490c9569749c3778811d 46e7675ec3fc4705aa6b652a1329d82e 1 dd3fad071663429d97f7dff7cf8d4b18 HamEvo cdd2ac4a7538490c9569749c3778811d--dd3fad071663429d97f7dff7cf8d4b18 744fe38e3d9f40a3a01996ceb61596a9 HamEvo dd3fad071663429d97f7dff7cf8d4b18--744fe38e3d9f40a3a01996ceb61596a9 4250e54f9b044dfe9f470e852bbbbd5e X 744fe38e3d9f40a3a01996ceb61596a9--4250e54f9b044dfe9f470e852bbbbd5e e7d9539a51ac4cee98fa3ee2ae58249c HamEvo 4250e54f9b044dfe9f470e852bbbbd5e--e7d9539a51ac4cee98fa3ee2ae58249c 6efbdad308f248a5bc0346c0ffc54586 HamEvo e7d9539a51ac4cee98fa3ee2ae58249c--6efbdad308f248a5bc0346c0ffc54586 14b6ff8ddccf4f9487974ba8c978e30b X 6efbdad308f248a5bc0346c0ffc54586--14b6ff8ddccf4f9487974ba8c978e30b 3bd1c4be2c65410c91a559bd2d09ceee 14b6ff8ddccf4f9487974ba8c978e30b--3bd1c4be2c65410c91a559bd2d09ceee b3a2b8c4a075483e99efea52765fc32e HamEvo 3bd1c4be2c65410c91a559bd2d09ceee--b3a2b8c4a075483e99efea52765fc32e 8c2769bb536d4fcb8af8e9899a98726f HamEvo b3a2b8c4a075483e99efea52765fc32e--8c2769bb536d4fcb8af8e9899a98726f 3be8e356b61e49178300cdc845c8d6c9 8c2769bb536d4fcb8af8e9899a98726f--3be8e356b61e49178300cdc845c8d6c9 827d2fe43b444aeb9008ce10edf21a73 3be8e356b61e49178300cdc845c8d6c9--827d2fe43b444aeb9008ce10edf21a73 0bd11ef2936e41afb8f720d5bc51f214 20e064fc20974f6186effcc427b1c73a t = -3.14 46e7675ec3fc4705aa6b652a1329d82e--20e064fc20974f6186effcc427b1c73a 517dc45b77c5476ea4d8fbc2562da8e0 2 48792def50e247d58e6d89e6fb2b9fa3 t = 3.142 20e064fc20974f6186effcc427b1c73a--48792def50e247d58e6d89e6fb2b9fa3 edfc75894a1741eaadfdcfd8cca507ca t = -3.14 48792def50e247d58e6d89e6fb2b9fa3--edfc75894a1741eaadfdcfd8cca507ca 1ec2aadae92a46d4968750e3eb7e92c4 edfc75894a1741eaadfdcfd8cca507ca--1ec2aadae92a46d4968750e3eb7e92c4 413d4e4cca0f4e92938aab92aa42f698 t = 1.571 1ec2aadae92a46d4968750e3eb7e92c4--413d4e4cca0f4e92938aab92aa42f698 6a7709a5669f49589253b7fef1732e7a t = 1.571 413d4e4cca0f4e92938aab92aa42f698--6a7709a5669f49589253b7fef1732e7a 95948213759c4ca9beb938014f74d014 6a7709a5669f49589253b7fef1732e7a--95948213759c4ca9beb938014f74d014 43b99eed0223425985d400e73eec9626 X 95948213759c4ca9beb938014f74d014--43b99eed0223425985d400e73eec9626 5427de4149d94ebdaeea5ce2e79c0c2a t = 1.571 43b99eed0223425985d400e73eec9626--5427de4149d94ebdaeea5ce2e79c0c2a 119cf17372d3436093cf0bcdbb4f2302 t = 1.571 5427de4149d94ebdaeea5ce2e79c0c2a--119cf17372d3436093cf0bcdbb4f2302 dd0f417cf8f44f0fb21abbfde9eae973 X 119cf17372d3436093cf0bcdbb4f2302--dd0f417cf8f44f0fb21abbfde9eae973 dd0f417cf8f44f0fb21abbfde9eae973--0bd11ef2936e41afb8f720d5bc51f214 5aa87ecd390a4159828884c56e5f068b 929ae12e4b284c268c5c8655612c16cf 517dc45b77c5476ea4d8fbc2562da8e0--929ae12e4b284c268c5c8655612c16cf 6a3ca9dcb59c4e608567eba528fda6a8 929ae12e4b284c268c5c8655612c16cf--6a3ca9dcb59c4e608567eba528fda6a8 e71060b290984b51ba22c590269b8fa4 6a3ca9dcb59c4e608567eba528fda6a8--e71060b290984b51ba22c590269b8fa4 2c80cbbbaccf4908b3be965ccab45722 X e71060b290984b51ba22c590269b8fa4--2c80cbbbaccf4908b3be965ccab45722 a5606815dc204e69a0ee487217a24cf6 2c80cbbbaccf4908b3be965ccab45722--a5606815dc204e69a0ee487217a24cf6 b13878563bf54f40a109b538e49fbe7b a5606815dc204e69a0ee487217a24cf6--b13878563bf54f40a109b538e49fbe7b bb96c0f3d55f44e3a79d23e92b08d05c X b13878563bf54f40a109b538e49fbe7b--bb96c0f3d55f44e3a79d23e92b08d05c b0ded15b2390409cbe3eaf103805f0b4 X bb96c0f3d55f44e3a79d23e92b08d05c--b0ded15b2390409cbe3eaf103805f0b4 858bc459c82442d98136cf5f94ad57fb b0ded15b2390409cbe3eaf103805f0b4--858bc459c82442d98136cf5f94ad57fb 60db20962d6249008489f9ca60de4d31 858bc459c82442d98136cf5f94ad57fb--60db20962d6249008489f9ca60de4d31 b813a17ddce8440c864675afea27149d X 60db20962d6249008489f9ca60de4d31--b813a17ddce8440c864675afea27149d b813a17ddce8440c864675afea27149d--5aa87ecd390a4159828884c56e5f068b

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_433bc913783e416498e77dc81a198df6 cluster_0aca72402b7644a2b9a8602d1afc65cb 9d3e5a9d5bfd464c9943aab47546065a 0 2847833113d446488b0b9e12f9f1ee63 X 9d3e5a9d5bfd464c9943aab47546065a--2847833113d446488b0b9e12f9f1ee63 62a8756d718549af82401a67024a48d4 1 b62ccc28aa714b4eab928d6f9d4cbe42 HamEvo 2847833113d446488b0b9e12f9f1ee63--b62ccc28aa714b4eab928d6f9d4cbe42 dda6c8540e764c5db2cb2ee2dcd000a6 X b62ccc28aa714b4eab928d6f9d4cbe42--dda6c8540e764c5db2cb2ee2dcd000a6 1fde3153342a4a41bd2e8f3fc8943455 dda6c8540e764c5db2cb2ee2dcd000a6--1fde3153342a4a41bd2e8f3fc8943455 ad65fb34259b475697907ef0ebcab6a1 HamEvo 1fde3153342a4a41bd2e8f3fc8943455--ad65fb34259b475697907ef0ebcab6a1 92481ff5333e4c29a29c3b72698a8075 ad65fb34259b475697907ef0ebcab6a1--92481ff5333e4c29a29c3b72698a8075 eee259b834f74feba3c049b2c5eb6eff 92481ff5333e4c29a29c3b72698a8075--eee259b834f74feba3c049b2c5eb6eff 97869fd68c2f4a32ad52a06c78a05e69 23aa6cb312f442b3861e1b3b31b663cc 62a8756d718549af82401a67024a48d4--23aa6cb312f442b3861e1b3b31b663cc ad7c9bcf860542c9bfd8858d09f7dd9f 2 db53a1edb6ad4fc88bf006df0d357387 t = -0.50 23aa6cb312f442b3861e1b3b31b663cc--db53a1edb6ad4fc88bf006df0d357387 2e37b91500724918a9974a7f29923d00 db53a1edb6ad4fc88bf006df0d357387--2e37b91500724918a9974a7f29923d00 b9da708c5b974e80ac9a7607ddae9a70 X 2e37b91500724918a9974a7f29923d00--b9da708c5b974e80ac9a7607ddae9a70 4f1b7b0c8eee429a93fbe3fda6af62b8 t = -0.50 b9da708c5b974e80ac9a7607ddae9a70--4f1b7b0c8eee429a93fbe3fda6af62b8 4a717ad8e3684fadb28c871de7428fb5 X 4f1b7b0c8eee429a93fbe3fda6af62b8--4a717ad8e3684fadb28c871de7428fb5 4a717ad8e3684fadb28c871de7428fb5--97869fd68c2f4a32ad52a06c78a05e69 6e5b44f3fa3f41adbbb3cbc85fef5372 bfebf2a78fc3492bb411cececb731d62 X ad7c9bcf860542c9bfd8858d09f7dd9f--bfebf2a78fc3492bb411cececb731d62 ce870a82a6e849458d1034e130998d8d bfebf2a78fc3492bb411cececb731d62--ce870a82a6e849458d1034e130998d8d f2f326edd9eb4328825860f01fb771d6 X ce870a82a6e849458d1034e130998d8d--f2f326edd9eb4328825860f01fb771d6 e48ed9de923b48629659198781e89a22 X f2f326edd9eb4328825860f01fb771d6--e48ed9de923b48629659198781e89a22 62e3aa3e2c224aa3b78cc822e276075b e48ed9de923b48629659198781e89a22--62e3aa3e2c224aa3b78cc822e276075b a79c07fa78fc42068105d802874ce487 X 62e3aa3e2c224aa3b78cc822e276075b--a79c07fa78fc42068105d802874ce487 a79c07fa78fc42068105d802874ce487--6e5b44f3fa3f41adbbb3cbc85fef5372

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_a154dbf28d1d40649f3e8c58f82c0645 cluster_9df4a00cc7ba478096620a0deefadf1a 3ef4e176798642ebb97e93714fe66de7 0 062104be6f724f81a97782d9147e550e X 3ef4e176798642ebb97e93714fe66de7--062104be6f724f81a97782d9147e550e 8586d7a3fe9b4ea9b9c6bdc0e55ab199 1 0f6be1b7b4994c95a4654cb9b88be1ee HamEvo 062104be6f724f81a97782d9147e550e--0f6be1b7b4994c95a4654cb9b88be1ee cf55d178951340e8b6232f710f17cc2d X 0f6be1b7b4994c95a4654cb9b88be1ee--cf55d178951340e8b6232f710f17cc2d 80207b74910140b4ba7043965bfef1ac cf55d178951340e8b6232f710f17cc2d--80207b74910140b4ba7043965bfef1ac 6719972b1c004136b6f56a981b05f55c HamEvo 80207b74910140b4ba7043965bfef1ac--6719972b1c004136b6f56a981b05f55c 7dcd594cc8ef42f8a8a70b5ddd551fb5 6719972b1c004136b6f56a981b05f55c--7dcd594cc8ef42f8a8a70b5ddd551fb5 b45f421139e8409a904eca4b24c62a71 7dcd594cc8ef42f8a8a70b5ddd551fb5--b45f421139e8409a904eca4b24c62a71 4bf580855d1048f88f835d00bf80c7fa bd47f27a75df487090d390dcf5521859 8586d7a3fe9b4ea9b9c6bdc0e55ab199--bd47f27a75df487090d390dcf5521859 0fafb6dd60ff43e9bc8ce84c92ecf6c3 2 b1a575f51d0947fa99df5869df036fc0 t = -500. bd47f27a75df487090d390dcf5521859--b1a575f51d0947fa99df5869df036fc0 78a72bf38b7945e9918fd98d4ce57b91 b1a575f51d0947fa99df5869df036fc0--78a72bf38b7945e9918fd98d4ce57b91 fa4f26b1ba5f41008554e453b6da8ec8 X 78a72bf38b7945e9918fd98d4ce57b91--fa4f26b1ba5f41008554e453b6da8ec8 2c3e51bfe2264e958aa91b4fd085528f t = -500. fa4f26b1ba5f41008554e453b6da8ec8--2c3e51bfe2264e958aa91b4fd085528f 5022bf44ced148eb9b935016750f6e8c X 2c3e51bfe2264e958aa91b4fd085528f--5022bf44ced148eb9b935016750f6e8c 5022bf44ced148eb9b935016750f6e8c--4bf580855d1048f88f835d00bf80c7fa 369e65bbc5634835b4c5aeddfbd570c5 c34d224433ff4e34b47665a9d57d82ac X 0fafb6dd60ff43e9bc8ce84c92ecf6c3--c34d224433ff4e34b47665a9d57d82ac 1d546839e44e431c93e7d52a91d6656b c34d224433ff4e34b47665a9d57d82ac--1d546839e44e431c93e7d52a91d6656b 4c62234c014a44ad91567257a13867c5 X 1d546839e44e431c93e7d52a91d6656b--4c62234c014a44ad91567257a13867c5 12174926f25e4dd294a0b75ea1c29856 X 4c62234c014a44ad91567257a13867c5--12174926f25e4dd294a0b75ea1c29856 65564220319e4462944f2e8426174698 12174926f25e4dd294a0b75ea1c29856--65564220319e4462944f2e8426174698 b0201d279f8b4db38c2685d381399352 X 65564220319e4462944f2e8426174698--b0201d279f8b4db38c2685d381399352 b0201d279f8b4db38c2685d381399352--369e65bbc5634835b4c5aeddfbd570c5

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