def test_rotations_pulse(self):
q0 = Transmon("q0", levels=2)
q1 = Transmon("q1", levels=3, kerr=-200e-3)
q0.gaussian_pulse.sigma = 40
q1.gaussian_pulse.sigma = 40
system = System("system", modes=[q0, q1])
init_state = system.fock()
for qubit in [q0, q1]:
for _ in range(1):
_ = tune_rabi(system,
init_state=init_state,
mode_name=qubit.name,
verify=False)
angles = np.linspace(-np.pi, np.pi, 5)
for angle in angles:
for qubit in [q0, q1]:
seq = get_sequence(system)
qubit.rotate_x(angle)
unitary = qubit.rotate_x(angle, unitary=True)
result = seq.run(init_state)
fidelity = qutip.fidelity(result.states[-1],
unitary * init_state)**2
self.assertGreater(fidelity, 1 - 1e-2)
seq = get_sequence(system)
qubit.rotate_y(angle)
unitary = qubit.rotate_y(angle, unitary=True)
result = seq.run(init_state)
fidelity = qutip.fidelity(result.states[-1],
unitary * init_state)**2
self.assertGreater(fidelity, 1 - 1e-2)
def setUpClass(cls):
qubit = Transmon("qubit", levels=2)
cavity = Cavity("cavity", levels=6)
system = System("system", modes=[qubit, cavity])
system.set_cross_kerr(qubit, cavity, -2e-3)
with system.use_modes([qubit]):
_ = tune_rabi(system, init_state=qubit.fock(0), verify=False)
cls.system = system
def setUpClass(cls):
q0 = Transmon("q0", levels=2)
q1 = Transmon("q1", levels=2)
system = System("system", modes=[q0, q1])
for qubit in [q0, q1]:
init_state = system.fock()
for _ in range(1):
_ = tune_rabi(
system, init_state=init_state, mode_name=qubit.name, verify=False
)
cls.system = system
def test_c_ops(self):
qubit = Transmon("qubit", levels=3, kerr=-200e-3)
cavity = Cavity("cavity", levels=10, kerr=-10e-6)
system = System("system", modes=[qubit, cavity])
# [
# qubit.decay, qubit.excitation, qubit.dephasing,
# cavity.decay, cavity.excitation, cavity.dephasing,
# ]
self.assertEqual(len(system.c_ops(clean=False)), 6)
self.assertEqual(len(system.c_ops(clean=True)), 0)
qubit.t1 = 100e3
cavity.t2 = 500e3
# [qubit.decay, cavity.dephasing]
self.assertEqual(len(system.c_ops(clean=True)), 2)
def setUpClass(cls):
n = 5
qubits = [
Transmon(
f"q{i}",
# levels=2,
# # comment out the above line and uncomment the
# # below line to use 3-level transmons with
# # various anharmonicities
levels=3,
kerr=-100e-3 * (i + 1),
)
for i in reversed(range(n))
]
qreg = System("qreg", modes=qubits)
# Tune pi pulses for all qubits
for i, qubit in enumerate(qubits):
# Use different sigmas so that pulses can be visually distinguished
qubit.gaussian_pulse.set(sigma=(10 + 2 * i), chop=4)
with qreg.use_modes([qubit]):
init_state = qubit.fock(0)
e_ops = [qubit.fock_dm(1)]
_ = tune_rabi(
qreg,
init_state,
e_ops=e_ops,
mode_name=qubit.name,
plot=False,
verify=False,
)
# # Below line is unnecessary if the qubits
# # only have two levels
_ = tune_drag(
qreg, init_state, e_ops=e_ops, mode_name=qubit.name, plot=False
)
def bell_state(qreg):
zeros = [0] * len(qreg.active_modes)
ones = [1] * len(qreg.active_modes)
return (qreg.logical_basis(*zeros) + qreg.logical_basis(*ones)).unit()
cls.ideal_state = bell_state(qreg)
cls.qreg = qreg
def test_order_modes(self):
qubit = Transmon("qubit", levels=3, kerr=-200e-3)
cavity = Cavity("cavity", levels=10, kerr=-10e-6)
system = System("system", modes=[qubit, cavity])
system.order_modes = True
system.active_modes = [qubit, cavity]
self.assertEqual(system.modes, [qubit, cavity])
self.assertEqual(system.active_modes, [qubit, cavity])
system.active_modes = [cavity, qubit]
self.assertEqual(system.modes, [qubit, cavity])
self.assertEqual(system.active_modes, [qubit, cavity])
system = System("system", modes=[qubit, cavity])
system.order_modes = False
system.active_modes = [qubit, cavity]
self.assertEqual(system.modes, [qubit, cavity])
self.assertEqual(system.active_modes, [qubit, cavity])
system.active_modes = [cavity, qubit]
self.assertEqual(system.modes, [qubit, cavity])
self.assertEqual(system.active_modes, [cavity, qubit])
def test_to_from_dict(self):
qubit = Transmon("qubit", levels=3, kerr=-200e-3)
cavity = Cavity("cavity", levels=10, kerr=-10e-6)
system = System("system", modes=[qubit, cavity])
system.set_cross_kerr(qubit, cavity, chi=-2e-3)
other_system = System.from_dict(system.as_dict())
self.assertEqual(system, other_system)
def test_coupling_terms(self):
qubit = Transmon("qubit", levels=3, kerr=-200e-3)
cavity = Cavity("cavity", levels=10, kerr=-10e-6)
system = System("system", modes=[qubit, cavity])
chi = -2e-3
key = frozenset([qubit.name, cavity.name])
system.coupling_terms[key].append(
CouplingTerm(qubit, "n", cavity, "n", strength=2 * np.pi * chi)
)
self.assertEqual(len(system.couplings()), 1)
self.assertEqual(system.couplings()[0], 2 * np.pi * chi * qubit.n * cavity.n)
system.set_cross_kerr(qubit, cavity, chi)
self.assertEqual(len(system.couplings()), 1)
self.assertEqual(system.couplings()[0], 2 * np.pi * chi * qubit.n * cavity.n)
def test_H0(self):
qubit = Transmon("qubit", levels=3, kerr=-200e-3)
cavity = Cavity("cavity", levels=10, kerr=-10e-6)
system = System("system", modes=[qubit, cavity])
system.set_cross_kerr(qubit, cavity, 0)
# [qubit.self_kerr, cavity.self_kerr]
self.assertEqual(len(system.H0(clean=True)), 2)
# [
# qubit.self_kerr, cavity.self_kerr,
# qubit.detuning, cavity.detuning,
# qubit-cavity cross-Kerr
# ]
self.assertEqual(len(system.H0(clean=False)), 5)
system.set_cross_kerr(qubit, cavity, -2e-3)
# [qubit.self_kerr, cavity.self_kerr, qubit-cavity cross-Kerr]
self.assertEqual(len(system.H0(clean=True)), 3)
def test_to_from_json_file(self):
qubit = Transmon("qubit", levels=3, kerr=-200e-3)
cavity = Cavity("cavity", levels=10, kerr=-10e-6)
system = System("system", modes=[qubit, cavity])
system.set_cross_kerr(qubit, cavity, chi=-2e-3)
with tempfile.TemporaryDirectory() as dirname:
json_path = os.path.join(dirname, "__test_to_from_json_file.json")
system.to_json(json_path=json_path)
other_system = System.from_json(json_path=json_path)
self.assertEqual(system, other_system)
def test_to_from_json_str(self):
qubit = Transmon("qubit", levels=3, kerr=-200e-3)
cavity = Cavity("cavity", levels=10, kerr=-10e-6)
system = System("system", modes=[qubit, cavity])
system.set_cross_kerr(qubit, cavity, chi=-2e-3)
json_str = system.to_json(dumps=True)
other_system = System.from_json(json_str=json_str)
self.assertEqual(system, other_system)
def test_rabi_two_levels(self):
qubit = Transmon("qubit", levels=2)
system = System("system", modes=[qubit])
for _ in range(2):
_, old_amp, new_amp = tune_rabi(system, qubit.fock(0))
self.assertLess(abs(old_amp - new_amp), 1e-7)
init = qubit.fock(0)
seq = get_sequence(system)
qubit.rotate_x(np.pi)
result = seq.run(init)
target = qubit.Rx(np.pi) * init
fidelity = qutip.fidelity(result.states[-1], target)**2
self.assertLess(abs(1 - fidelity), 1e-10)
def test_displacement(self):
c0 = Cavity("c0", levels=10, kerr=-10e-6)
c1 = Cavity("c1", levels=12, kerr=-10e-6)
system = System("system", modes=[c0, c1])
init_state = system.fock()
for cavity in [c0, c1]:
for _ in range(1):
_ = tune_displacement(system,
init_state,
mode_name=cavity.name,
verify=False)
for alpha in [0, 1, -1, 1j, -1j, 2, -2, 2j, -2j]:
ideal_state = cavity.tensor_with_zero(
qutip.coherent(cavity.levels, alpha))
seq = get_sequence(system)
unitary = cavity.displace(alpha, unitary=True)
cavity.displace(alpha)
result = seq.run(init_state)
unitary_fidelity = (qutip.fidelity(unitary * init_state,
ideal_state)**2)
pulse_fidelity = qutip.fidelity(result.states[-1],
ideal_state)**2
self.assertGreater(unitary_fidelity, 1 - 1e-4)
self.assertGreater(pulse_fidelity, 1 - 1e-4)
def test_displacement(self):
cavity = Cavity("cavity", levels=12)
system = System("system", modes=[cavity])
for _ in range(3):
_, old_amp, new_amp = tune_displacement(system, cavity.fock(0))
self.assertLess(abs(old_amp - new_amp), 1e-7)
init = cavity.fock(0)
seq = get_sequence(system)
cavity.displace(1 + 2j)
result = seq.run(init)
target = cavity.D(1 + 2j) * init
fidelity = qutip.fidelity(result.states[-1], target)**2
self.assertLess(abs(1 - fidelity), 1e-7)
def test_get_mode(self):
qubit = Transmon("qubit", levels=3, kerr=-200e-3)
cavity = Cavity("cavity", levels=10, kerr=-10e-6)
system = System("system", modes=[qubit, cavity])
self.assertIs(system.get_mode(qubit), qubit)
self.assertIs(system.get_mode("qubit"), qubit)
with self.assertRaises(ValueError):
system.get_mode("other_qubit")
def test_fock(self):
qubit = Transmon("qubit", levels=3, kerr=-200e-3)
cavity = Cavity("cavity", levels=10, kerr=-10e-6)
system = System("system", modes=[qubit, cavity])
with self.assertRaises(ValueError):
system.fock(0)
with self.assertRaises(ValueError):
system.fock(0, qubit=0)
def test_active_modes(self):
qubit = Transmon("qubit", levels=3, kerr=-200e-3)
cavity = Cavity("cavity", levels=10, kerr=-10e-6)
system = System("system", modes=[qubit])
system.active_modes = [qubit]
with self.assertRaises(ValueError):
system.active_modes = [qubit, cavity]
system.modes = [qubit, cavity]
system.active_modes = [qubit, cavity]
system.modes = [cavity]
with self.assertRaises(ValueError):
_ = system.active_modes
def test_drag(self):
qubit = Transmon("qubit", levels=3, kerr=-200e-3)
qubit.gaussian_pulse.sigma = 10
system = System("system", modes=[qubit])
for _ in range(3):
_, old_amp, new_amp = tune_rabi(system,
qubit.fock(0),
plot=False,
verify=False)
self.assertLess(abs(old_amp - new_amp), 1e-7)
_, old_drag, new_drag = tune_drag(system, qubit.fock(0), update=True)
self.assertNotAlmostEqual(new_drag, 0)
init = qubit.fock(0)
seq = get_sequence(system)
qubit.rotate_x(np.pi)
result = seq.run(init)
target = qubit.Rx(np.pi) * init
fidelity = qutip.fidelity(result.states[-1], target)**2
self.assertLess(abs(1 - fidelity), 1e-5)
def test_set_cross_kerr(self):
qubit = Transmon("qubit", levels=3, kerr=-200e-3)
cavity = Cavity("cavity", levels=10, kerr=-10e-6)
system = System("system", modes=[qubit, cavity])
with self.assertRaises(ValueError):
system.set_cross_kerr(qubit, qubit, -1e-3)
chi = -2e-3
system.set_cross_kerr(qubit, cavity, chi)
self.assertEqual(len(system.couplings()), 1)
self.assertEqual(system.couplings()[0], 2 * np.pi * chi * qubit.n * cavity.n)
system.set_cross_kerr(qubit, cavity, chi)
self.assertEqual(len(system.couplings()), 1)
self.assertEqual(system.couplings()[0], 2 * np.pi * chi * qubit.n * cavity.n)
system.set_cross_kerr(cavity, qubit, chi)
self.assertEqual(len(system.couplings()), 1)
self.assertEqual(system.couplings()[0], 2 * np.pi * chi * qubit.n * cavity.n)
def setUpClass(cls):
qubit1 = Transmon("q1", levels=2)
qubit2 = Transmon("q0", levels=2)
cls.system = System("system", modes=[qubit1, qubit2])
def test_use_modes(self):
qubit = Transmon("qubit", levels=3, kerr=-200e-3)
cavity = Cavity("cavity", levels=10, kerr=-10e-6)
system = System("system", modes=[qubit, cavity])
with system.use_modes([qubit]):
self.assertEqual(system.ground_state(), qubit.fock(0, full_space=False))
with system.use_modes([cavity]):
self.assertEqual(system.ground_state(), cavity.fock(0, full_space=False))
with system.use_modes([qubit, cavity]):
self.assertEqual(
system.ground_state(),
qutip.tensor(
qubit.fock(0, full_space=False), cavity.fock(0, full_space=False)
),
)
system.order_modes = False
with system.use_modes([cavity, qubit]):
self.assertEqual(
system.ground_state(),
qutip.tensor(
cavity.fock(0, full_space=False), qubit.fock(0, full_space=False)
),
)
def setUpClass(cls):
qubits = [Transmon(f"q{i}", levels=2) for i in range(5)][::-1]
cls.system = System("system", modes=qubits)
def test_coupling_terms_multimode(self):
qubit = Transmon("qubit", levels=3, kerr=-200e-3)
cavity1 = Cavity("cavity1", levels=10, kerr=-10e-6)
cavity2 = Cavity("cavity2", levels=6, kerr=-10e-6)
system = System("system", modes=[qubit, cavity2, cavity1])
system.set_cross_kerr(qubit, cavity1, -2e-3)
system.set_cross_kerr(qubit, cavity2, -1e-3)
system.set_cross_kerr(cavity1, cavity2, -5e-6)
self.assertEqual(len(system.couplings()), 3)
for modes in [[qubit, cavity1], [qubit, cavity1, cavity2]]:
with system.use_modes(modes):
self.assertEqual(
system.couplings()[0], 2 * np.pi * -2e-3 * qubit.n * cavity1.n
)
for i, modes in enumerate([[qubit, cavity2], [qubit, cavity1, cavity2]]):
with system.use_modes(modes):
self.assertEqual(
system.couplings()[i], 2 * np.pi * -1e-3 * qubit.n * cavity2.n
)
for i, modes in enumerate([[cavity2, cavity1], [qubit, cavity1, cavity2]]):
with system.use_modes(modes):
self.assertEqual(
system.couplings()[2 * i], 2 * np.pi * -5e-6 * cavity1.n * cavity2.n
)
def test_invalid_mode_type(self):
cavities = [Cavity(f"c{i}", levels=3, kerr=-2e-3) for i in range(5)]
_ = System("system", modes=cavities)
with self.assertRaises(TypeError):
_ = gates.x(*cavities, unitary=False)
