def test_can_add_operation_into_moment():
d = square_virtual_device(control_r=1.0, num_qubits=2)
m1 = cirq.Moment([cirq.Z.on(TwoDQubit(0, 0))])
assert not d.can_add_operation_into_moment(cirq.X.on(TwoDQubit(0, 0)), m1)
assert not d.can_add_operation_into_moment(cirq.X.on(TwoDQubit(1, 1)), m1)
m2 = cirq.Moment([cirq.measure(*d.qubits[:-1])])
assert d.can_add_operation_into_moment(cirq.measure(TwoDQubit(1, 1)), m2)
def test_is_pasqal_device_op():
d = generic_device(2)
with pytest.raises(ValueError, match="Got unknown operation"):
d.is_pasqal_device_op(cirq.NamedQubit('q0'))
op = (cirq.ops.CZ).on(*(d.qubit_list()))
bad_op = cirq.ops.CNotPowGate(exponent=0.5)
assert d.is_pasqal_device_op(op)
assert d.is_pasqal_device_op(cirq.ops.X(cirq.NamedQubit('q0')))
assert not d.is_pasqal_device_op(
cirq.ops.CCX(cirq.NamedQubit('q0'), cirq.NamedQubit('q1'),
cirq.NamedQubit('q2'))**0.2)
assert not d.is_pasqal_device_op(
bad_op(cirq.NamedQubit('q0'), cirq.NamedQubit('q1')))
op1 = cirq.ops.CNotPowGate(exponent=1.0)
assert d.is_pasqal_device_op(
op1(cirq.NamedQubit('q0'), cirq.NamedQubit('q1')))
op2 = (cirq.ops.H**sympy.Symbol('exp')).on(d.qubit_list()[0])
assert not d.is_pasqal_device_op(op2)
decomp = d.decompose_operation(op2)
for op_ in decomp:
assert d.is_pasqal_device_op(op_)
d2 = square_virtual_device(control_r=1.1, num_qubits=3)
assert d.is_pasqal_device_op(cirq.ops.X(TwoDQubit(0, 0)))
assert not d2.is_pasqal_device_op(op1(TwoDQubit(0, 0), TwoDQubit(0, 1)))
def test_validate_operation_errors():
d = generic_device(3)
circuit = cirq.Circuit(device=d)
with pytest.raises(ValueError, match="Unsupported operation"):
d.validate_operation(cirq.NamedQubit('q0'))
with pytest.raises(ValueError, match="is not a supported gate"):
d.validate_operation((cirq.ops.H**0.2).on(cirq.NamedQubit('q0')))
with pytest.raises(ValueError,
match="is not a valid qubit for gate cirq.X"):
d.validate_operation(cirq.X.on(cirq.LineQubit(0)))
with pytest.raises(ValueError, match="is not part of the device."):
d.validate_operation(cirq.X.on(cirq.NamedQubit('q6')))
with pytest.raises(
NotImplementedError,
match="Measurements on Pasqal devices don't support invert_mask."):
circuit.append(
cirq.measure(*d.qubits, invert_mask=(True, False, False)))
d = square_virtual_device(control_r=1.0, num_qubits=3)
with pytest.raises(ValueError, match="are too far away"):
d.validate_operation(cirq.CZ.on(TwoDQubit(0, 0), TwoDQubit(2, 2)))
def test_value_equal():
dev = PasqalDevice(qubits=[cirq.NamedQubit('q1')])
assert PasqalDevice(qubits=[cirq.NamedQubit('q1')]) == dev
dev = PasqalVirtualDevice(control_radius=1.0, qubits=[TwoDQubit(0, 0)])
assert PasqalVirtualDevice(control_radius=1.0,
qubits=[TwoDQubit(0, 0)]) == dev
def test_square_2D():
assert TwoDQubit.square(2, x0=1, y0=1) == [
TwoDQubit(1, 1),
TwoDQubit(2, 1),
TwoDQubit(1, 2),
TwoDQubit(2, 2),
]
assert TwoDQubit.square(2) == [
TwoDQubit(0, 0),
TwoDQubit(1, 0),
TwoDQubit(0, 1),
TwoDQubit(1, 1),
]
def test_validate_moment():
d = square_virtual_device(control_r=1.0, num_qubits=2)
m1 = cirq.Moment(
[cirq.Z.on(TwoDQubit(0, 0)), (cirq.X).on(TwoDQubit(1, 1))])
m2 = cirq.Moment([cirq.Z.on(TwoDQubit(0, 0))])
m3 = cirq.Moment(
[cirq.measure(TwoDQubit(0, 0)),
cirq.measure(TwoDQubit(1, 1))])
with pytest.raises(ValueError, match="Cannot do simultaneous gates"):
d.validate_moment(m1)
d.validate_moment(m2)
d.validate_moment(m3)
def test_triangular_2D():
assert TwoDQubit.triangular_lattice(1) == [
TwoDQubit(0.0, 0.0),
TwoDQubit(0.5, 0.8660254037844386),
TwoDQubit(1.0, 0.0),
TwoDQubit(1.5, 0.8660254037844386),
]
assert TwoDQubit.triangular_lattice(1, x0=5.0, y0=6.1) == [
TwoDQubit(5.0, 6.1),
TwoDQubit(5.5, 6.966025403784438),
TwoDQubit(6.0, 6.1),
TwoDQubit(6.5, 6.966025403784438),
]
def test_init_errors():
line = cirq.devices.LineQubit.range(3)
with pytest.raises(TypeError, match="Unsupported qubit type"):
PasqalDevice(qubits=line)
with pytest.raises(ValueError, match="Too many qubits"):
generic_device(101)
with pytest.raises(TypeError, match="Unsupported qubit type"):
PasqalVirtualDevice(control_radius=1.0, qubits=[cirq.NamedQubit('q0')])
with pytest.raises(TypeError, match="All qubits must be of same type."):
PasqalVirtualDevice(control_radius=1.0,
qubits=[TwoDQubit(0, 0),
cirq.GridQubit(1, 0)])
with pytest.raises(
ValueError,
match="Control_radius needs to be a non-negative float"):
square_virtual_device(control_r=-1.0, num_qubits=2)
with pytest.raises(
ValueError,
match="Control_radius cannot be larger than "
"3 times the minimal distance between qubits.",
):
square_virtual_device(control_r=11.0, num_qubits=2)
def test_repr():
assert repr(generic_device(1)) == (
"pasqal.PasqalDevice(qubits=[cirq.NamedQubit('q0')])")
dev = PasqalVirtualDevice(control_radius=1.0, qubits=[TwoDQubit(0, 0)])
assert repr(dev) == (
"pasqal.PasqalVirtualDevice(control_radius=1.0, qubits=[pasqal.TwoDQubit(0, 0)])"
)
def test_rec_2D():
assert TwoDQubit.rect(1, 2, x0=5,
y0=6) == [TwoDQubit(5, 6),
TwoDQubit(5, 7)]
assert TwoDQubit.rect(2, 2) == [
TwoDQubit(0, 0),
TwoDQubit(1, 0),
TwoDQubit(0, 1),
TwoDQubit(1, 1),
]
def test_distance():
dev = square_virtual_device(control_r=1., num_qubits=2)
with pytest.raises(ValueError, match="Qubit not part of the device."):
dev.distance(TwoDQubit(0, 0), TwoDQubit(2, 2))
assert np.isclose(dev.distance(TwoDQubit(0, 0), TwoDQubit(1, 0)), 1.)
dev = PasqalVirtualDevice(control_radius=1.,
qubits=[cirq.LineQubit(0),
cirq.LineQubit(1)])
assert np.isclose(dev.distance(cirq.LineQubit(0), cirq.LineQubit(1)), 1.)
dev = PasqalVirtualDevice(
control_radius=1., qubits=[cirq.GridQubit(0, 0),
cirq.GridQubit(1, 0)])
assert np.isclose(dev.distance(cirq.GridQubit(0, 0), cirq.GridQubit(1, 0)),
1.)
def test_init():
d = generic_device(3)
q0 = cirq.NamedQubit('q0')
q1 = cirq.NamedQubit('q1')
q2 = cirq.NamedQubit('q2')
assert d.qubit_set() == {q0, q1, q2}
assert d.qubit_list() == [q0, q1, q2]
assert d.supported_qubit_type == (cirq.NamedQubit, )
d = square_virtual_device(control_r=1.0, num_qubits=1)
assert d.qubit_set() == {TwoDQubit(0, 0)}
assert d.qubit_list() == [TwoDQubit(0, 0)]
assert d.control_radius == 1.0
assert d.supported_qubit_type == (
ThreeDQubit,
TwoDQubit,
cirq.GridQubit,
cirq.LineQubit,
)
def test_qid_pairs():
dev = PasqalVirtualDevice(
1,
qubits=[
ThreeDQubit(0, 0, 0),
ThreeDQubit(1, 0, 0),
ThreeDQubit(0, 1, 0),
ThreeDQubit(1, 1, 0),
ThreeDQubit(1, 1, 1),
],
)
assert len(dev.qid_pairs()) == 5
dev1 = PasqalVirtualDevice(
5,
qubits=[
TwoDQubit(0, 0),
TwoDQubit(3, 2),
TwoDQubit(3, 4),
TwoDQubit(3, 6),
],
)
assert len(dev1.qid_pairs()) == 5
def test_to_json():
dev = PasqalDevice(qubits=[cirq.NamedQubit('q4')])
d = dev._json_dict_()
assert d == {
"cirq_type": "PasqalDevice",
"qubits": [cirq.NamedQubit('q4')]
}
vdev = PasqalVirtualDevice(control_radius=2, qubits=[TwoDQubit(0, 0)])
d = vdev._json_dict_()
assert d == {
"cirq_type": "PasqalVirtualDevice",
"control_radius": 2,
"qubits": [cirq.pasqal.TwoDQubit(0, 0)],
}
def test_to_json_():
q = ThreeDQubit(1.3, 1, 1)
d = q._json_dict_()
assert d == {
'cirq_type': 'ThreeDQubit',
'x': 1.3,
'y': 1,
'z': 1,
}
q = TwoDQubit(1.3, 1)
d = q._json_dict_()
assert d == {
'cirq_type': 'TwoDQubit',
'x': 1.3,
'y': 1,
}
def square_virtual_device(control_r, num_qubits) -> PasqalVirtualDevice:
return PasqalVirtualDevice(control_radius=control_r,
qubits=TwoDQubit.square(num_qubits))
def test_repr_():
assert repr(ThreeDQubit(4, -25, 109)) == 'pasqal.ThreeDQubit(4, -25, 109)'
assert repr(TwoDQubit(4, -25)) == 'pasqal.TwoDQubit(4, -25)'
def test_str_():
assert str(ThreeDQubit(4, -25, 109)) == '(4, -25, 109)'
assert str(TwoDQubit(4, -25)) == '(4, -25)'
