def test_ms_repr():
assert repr(cirq.ms(np.pi / 2)) == 'cirq.ms(np.pi/2)'
assert repr(cirq.ms(np.pi / 4)) == 'cirq.ms(0.5*np.pi/2)'
cirq.testing.assert_equivalent_repr(cirq.ms(np.pi / 4))
ms = cirq.ms(np.pi / 2)
assert repr(ms ** 2) == 'cirq.ms(2.0*np.pi/2)'
assert repr(ms ** -0.5) == 'cirq.ms(-0.5*np.pi/2)'
def test_ms_str():
ms = cirq.ms(np.pi / 2)
assert str(ms) == 'MS(π/2)'
assert str(cirq.ms(np.pi)) == 'MS(2.0π/2)'
assert str(ms ** 0.5) == 'MS(0.5π/2)'
assert str(ms ** 2) == 'MS(2.0π/2)'
assert str(ms ** -1) == 'MS(-1.0π/2)'
def test_convert_to_ion_gates():
q0 = cirq.GridQubit(0, 0)
q1 = cirq.GridQubit(0, 1)
op = cirq.CNOT(q0, q1)
circuit = cirq.Circuit()
with pytest.raises(TypeError):
cirq.ion.ConvertToIonGates().convert_one(circuit)
with pytest.raises(TypeError):
cirq.ion.ConvertToIonGates().convert_one(NoUnitary().on(q0))
no_unitary_op = NoUnitary().on(q0)
assert cirq.ion.ConvertToIonGates(ignore_failures=True).convert_one(
no_unitary_op) == [no_unitary_op]
rx = cirq.ion.ConvertToIonGates().convert_one(OtherX().on(q0))
rop = cirq.ion.ConvertToIonGates().convert_one(op)
assert cirq.approx_eq(
rx, [cirq.PhasedXPowGate(phase_exponent=1.0).on(cirq.GridQubit(0, 0))])
assert cirq.approx_eq(rop, [
cirq.ry(np.pi / 2).on(op.qubits[0]),
cirq.ms(np.pi / 4).on(op.qubits[0], op.qubits[1]),
cirq.rx(-1 * np.pi / 2).on(op.qubits[0]),
cirq.rx(-1 * np.pi / 2).on(op.qubits[1]),
cirq.ry(-1 * np.pi / 2).on(op.qubits[0])
])
rcnot = cirq.ion.ConvertToIonGates().convert_one(OtherCNOT().on(q0, q1))
assert cirq.approx_eq([op for op in rcnot if len(op.qubits) > 1],
[cirq.ms(-0.5 * np.pi / 2).on(q0, q1)],
atol=1e-4)
assert cirq.allclose_up_to_global_phase(
cirq.unitary(cirq.Circuit(rcnot)), cirq.unitary(OtherCNOT().on(q0, q1)))
def test_convert_to_ion_circuit():
q0 = cirq.LineQubit(0)
q1 = cirq.LineQubit(1)
us = cirq.Duration(nanos=1000)
ion_device = cirq.IonDevice(us, us, us, [q0, q1])
clifford_circuit_1 = cirq.Circuit()
clifford_circuit_1.append(
[cirq.X(q0), cirq.H(q1),
cirq.ms(np.pi / 4).on(q0, q1)])
ion_circuit_1 = cirq.ion.ConvertToIonGates().convert_circuit(
clifford_circuit_1)
ion_device.validate_circuit(ion_circuit_1)
cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
clifford_circuit_1, ion_circuit_1, atol=1e-6)
clifford_circuit_2 = cirq.Circuit()
clifford_circuit_2.append(
[cirq.X(q0),
cirq.CNOT(q1, q0),
cirq.ms(np.pi / 4).on(q0, q1)])
ion_circuit_2 = cirq.ion.ConvertToIonGates().convert_circuit(
clifford_circuit_2)
ion_device.validate_circuit(ion_circuit_2)
cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
clifford_circuit_2, ion_circuit_2, atol=1e-6)
def test_json_serialization():
def custom_resolver(cirq_type: str):
if cirq_type == "MSGate":
return cirq.ops.MSGate
return None
assert cirq.read_json(
json_text=cirq.to_json(cirq.ms(np.pi / 2)), resolvers=[custom_resolver]
) == cirq.ms(np.pi / 2)
assert custom_resolver('X') is None
def test_json_serialization():
def custom_resolver(cirq_type: str) -> Union[Callable[..., cirq.Gate], None]:
if cirq_type == "MSGate":
return cirq.ion.ion_gates.MSGate
return None
assert cirq.read_json(
json_text=cirq.to_json(cirq.ms(np.pi / 2)), resolvers=[custom_resolver]
) == cirq.ms(np.pi / 2)
assert custom_resolver('X') is None
def test_ms_matrix():
s = np.sqrt(0.5)
# yapf: disable
np.testing.assert_allclose(cirq.unitary(cirq.ms(np.pi/4)),
np.array([[s, 0, 0, -1j*s],
[0, s, -1j*s, 0],
[0, -1j*s, s, 0],
[-1j*s, 0, 0, s]]),
atol=1e-8)
# yapf: enable
np.testing.assert_allclose(cirq.unitary(cirq.ms(np.pi)), np.diag([-1, -1, -1, -1]), atol=1e-8)
def test_ms_diagrams():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
circuit = cirq.Circuit(cirq.SWAP(a, b), cirq.X(a), cirq.Y(a),
cirq.ms(np.pi).on(a, b))
cirq.testing.assert_has_diagram(circuit, """
a: ───×───X───Y───MS(π)───
│ │
b: ───×───────────MS(π)───
""")
def test_convert_to_ion_circuit():
q0 = cirq.LineQubit(0)
q1 = cirq.LineQubit(1)
us = cirq.Duration(nanos=1000)
with cirq.testing.assert_deprecated("cirq_aqt.aqt_device.AQTDevice",
deadline='v0.16',
count=2):
ion_device = cirq.IonDevice(us, us, us, [q0, q1])
with cirq.testing.assert_deprecated("cirq_aqt.aqt_device.AQTTargetGateset",
deadline='v0.16',
count=None):
convert_to_ion_gates = cirq.ion.ConvertToIonGates()
clifford_circuit_1 = cirq.Circuit()
clifford_circuit_1.append(
[cirq.X(q0), cirq.H(q1),
cirq.ms(np.pi / 4).on(q0, q1)])
ion_circuit_1 = convert_to_ion_gates.convert_circuit(clifford_circuit_1)
ion_circuit_1_using_device = ion_device.decompose_circuit(
clifford_circuit_1)
ion_device.validate_circuit(ion_circuit_1)
ion_device.validate_circuit(ion_circuit_1_using_device)
cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
clifford_circuit_1, ion_circuit_1, atol=1e-6)
cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
clifford_circuit_1, ion_circuit_1_using_device, atol=1e-6)
clifford_circuit_2 = cirq.Circuit()
clifford_circuit_2.append(
[cirq.X(q0),
cirq.CNOT(q1, q0),
cirq.ms(np.pi / 4).on(q0, q1)])
ion_circuit_2 = convert_to_ion_gates.convert_circuit(clifford_circuit_2)
ion_circuit_2_using_device = ion_device.decompose_circuit(
clifford_circuit_2)
ion_device.validate_circuit(ion_circuit_2)
ion_device.validate_circuit(ion_circuit_2_using_device)
cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
clifford_circuit_2, ion_circuit_2, atol=1e-6)
cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
clifford_circuit_2, ion_circuit_2_using_device, atol=1e-6)
def test_convert_to_ion_gates():
q0 = cirq.GridQubit(0, 0)
q1 = cirq.GridQubit(0, 1)
op = cirq.CNOT(q0, q1)
circuit = cirq.Circuit()
with pytest.raises(TypeError):
cirq.ion.ConvertToIonGates().convert_one(circuit)
with pytest.raises(TypeError):
cirq.ion.ConvertToIonGates().convert_one(NoUnitary().on(q0))
no_unitary_op = NoUnitary().on(q0)
assert cirq.ion.ConvertToIonGates(
ignore_failures=True).convert_one(no_unitary_op) == [no_unitary_op]
rx = cirq.ion.ConvertToIonGates().convert_one(OtherX().on(q0))
rop = cirq.ion.ConvertToIonGates().convert_one(op)
rcnot = cirq.ion.ConvertToIonGates().convert_one(OtherCNOT().on(q0, q1))
assert rx == [
cirq.PhasedXPowGate(phase_exponent=1).on(cirq.GridQubit(0, 0))
]
assert rop == [
cirq.Ry(np.pi / 2).on(op.qubits[0]),
cirq.ms(np.pi / 4).on(op.qubits[0], op.qubits[1]),
cirq.Rx(-1 * np.pi / 2).on(op.qubits[0]),
cirq.Rx(-1 * np.pi / 2).on(op.qubits[1]),
cirq.Ry(-1 * np.pi / 2).on(op.qubits[0])
]
assert rcnot == [
cirq.PhasedXPowGate(phase_exponent=-0.75,
exponent=0.5).on(cirq.GridQubit(0, 0)),
cirq.PhasedXPowGate(phase_exponent=1,
exponent=0.25).on(cirq.GridQubit(0, 1)),
cirq.T.on(cirq.GridQubit(0, 0)),
cirq.ms(-0.5 * np.pi / 2).on(cirq.GridQubit(0,
0), cirq.GridQubit(0, 1)),
(cirq.Y**0.5).on(cirq.GridQubit(0, 0)),
cirq.PhasedXPowGate(phase_exponent=1,
exponent=0.25).on(cirq.GridQubit(0, 1)),
(cirq.Z**-0.75).on(cirq.GridQubit(0, 0))
]
def test_ms_str():
assert str(cirq.ms(np.pi / 2)) == 'MS(π/2)'
assert str(cirq.ms(np.pi)) == 'MS(2.0π/2)'
def test_convert_to_ion_gates():
q0 = cirq.GridQubit(0, 0)
q1 = cirq.GridQubit(0, 1)
op = cirq.CNOT(q0, q1)
circuit = cirq.Circuit()
ion_gateset = cirq.ion.ion_device._IonTargetGateset()
with cirq.testing.assert_deprecated("cirq_aqt.aqt_device.AQTTargetGateset",
deadline='v0.16',
count=None):
convert_to_ion_gates = cirq.ion.ConvertToIonGates()
with pytest.raises(TypeError):
convert_to_ion_gates.convert_one(circuit)
no_unitary_op = NoUnitary().on(q0)
with pytest.raises(TypeError):
convert_to_ion_gates.convert_one(no_unitary_op)
assert ion_gateset._decompose_single_qubit_operation(no_unitary_op,
0) is NotImplemented
with cirq.testing.assert_deprecated("cirq_aqt.aqt_device.AQTTargetGateset",
deadline='v0.16',
count=None):
assert cirq.ion.ConvertToIonGates(
ignore_failures=True).convert_one(no_unitary_op) == [
no_unitary_op
]
rx = convert_to_ion_gates.convert_one(OtherX().on(q0))
rx_via_gateset = ion_gateset._decompose_single_qubit_operation(
OtherX().on(q0), 0)
assert cirq.approx_eq(
rx, [cirq.PhasedXPowGate(phase_exponent=1.0).on(cirq.GridQubit(0, 0))])
assert cirq.approx_eq(
rx_via_gateset,
[cirq.PhasedXPowGate(phase_exponent=1.0).on(cirq.GridQubit(0, 0))])
rop = convert_to_ion_gates.convert_one(op)
rop_via_gateset = ion_gateset._decompose_two_qubit_operation(op, 0)
cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
cirq.Circuit(rop), cirq.Circuit(rop_via_gateset), atol=1e-6)
assert cirq.approx_eq(
rop,
[
cirq.ry(np.pi / 2).on(op.qubits[0]),
cirq.ms(np.pi / 4).on(op.qubits[0], op.qubits[1]),
cirq.rx(-1 * np.pi / 2).on(op.qubits[0]),
cirq.rx(-1 * np.pi / 2).on(op.qubits[1]),
cirq.ry(-1 * np.pi / 2).on(op.qubits[0]),
],
)
rcnot = convert_to_ion_gates.convert_one(OtherCNOT().on(q0, q1))
assert cirq.approx_eq(
[op for op in rcnot if len(op.qubits) > 1],
[cirq.ms(-0.5 * np.pi / 2).on(q0, q1)],
atol=1e-4,
)
assert cirq.allclose_up_to_global_phase(cirq.unitary(cirq.Circuit(rcnot)),
cirq.unitary(OtherCNOT().on(
q0, q1)),
atol=1e-7)
def test_ms_arguments():
eq_tester = cirq.testing.EqualsTester()
eq_tester.add_equality_group(cirq.ms(np.pi / 2), cirq.ion.ion_gates.MSGate(rads=np.pi / 2))
eq_tester.add_equality_group(cirq.XXPowGate(global_shift=-0.5))
assert isinstance(op, cirq.GateOperation)
assert isinstance(op.gate, cirq.XXPowGate)
total_ms += abs(op.gate.exponent)
assert total_ms <= threshold
# yapf: disable
@pytest.mark.parametrize('max_ms_depth,effect', [
(0, np.eye(4)),
(0, np.array([
[0, 0, 0, 1],
[0, 0, 1, 0],
[0, 1, 0, 0],
[1, 0, 0, 0j]
])),
(1, cirq.unitary(cirq.ms(np.pi/4))),
(0, cirq.unitary(cirq.CZ ** 0.00000001)),
(0.5, cirq.unitary(cirq.CZ ** 0.5)),
(1, cirq.unitary(cirq.CZ)),
(1, cirq.unitary(cirq.CNOT)),
(1, np.array([
[1, 0, 0, 1j],
[0, 1, 1j, 0],
[0, 1j, 1, 0],
[1j, 0, 0, 1],
]) * np.sqrt(0.5)),
(1, np.array([
[1, 0, 0, -1j],
[0, 1, -1j, 0],
def test_ms_repr():
assert repr(cirq.ms(np.pi / 2)) == 'cirq.ms(np.pi/2)'
assert repr(cirq.ms(np.pi / 4)) == 'cirq.ms(0.5*np.pi/2)'
cirq.testing.assert_equivalent_repr(cirq.ms(np.pi / 4))
def test_deprecated_ms(rads):
with capture_logging():
assert np.all(
cirq.unitary(cirq.ms(rads)) == cirq.unitary(cirq.MS(rads)))
def test_deprecated_ms(rads):
assert np.all(cirq.unitary(cirq.ms(rads)) == cirq.unitary(cirq.MS(rads)))
