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_MS_matrix():
s = np.sqrt(0.5)
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)
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.GridQubit(0, 0)
q1 = cirq.GridQubit(0, 1)
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)
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)
cirq.testing.assert_has_diagram(ion_circuit_1,
"""
(0, 0): ───X───────────────────MS(0.25π)───
│
(0, 1): ───Rx(π)───Ry(-0.5π)───MS(0.25π)───
""",
use_unicode_characters=True)
cirq.testing.assert_has_diagram(ion_circuit_2,
"""
(0, 0): ───X──────────MS(0.25π)───Rx(-0.5π)───────────────MS(0.25π)───
│ │
(0, 1): ───Ry(0.5π)───MS(0.25π)───Rx(-0.5π)───Ry(-0.5π)───MS(0.25π)───
""",
use_unicode_characters=True)
assert_ops_implement_unitary(q0, q1, ion_circuit_1,
cirq.unitary(clifford_circuit_1))
assert_ops_implement_unitary(q0, q1, ion_circuit_2,
cirq.unitary(clifford_circuit_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)
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.ion.MS(np.pi / 4).on(op.qubits[0], op.qubits[1]),
cirq.ops.Rx(-1 * np.pi / 2).on(op.qubits[0]),
cirq.ops.Rx(-1 * np.pi / 2).on(op.qubits[1]),
cirq.ops.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_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_MS_str():
assert str(cirq.MS(np.pi / 2)) == 'MS(π/2)'
assert str(cirq.MS(np.pi)) == 'MS(2.0π/2)'
def test_MS_arguments():
eq_tester = cirq.testing.EqualsTester()
eq_tester.add_equality_group(cirq.MS(np.pi / 2),
cirq.XXPowGate(global_shift=-0.5))
def assert_ms_depth_below(operations, threshold):
total_ms = 0
for op in operations:
assert len(op.qubits) <= 2
if len(op.qubits) == 2:
assert isinstance(op, cirq.GateOperation)
assert isinstance(op.gate, cirq.XXPowGate)
total_ms += abs(op.gate.exponent)
assert total_ms <= threshold
@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],
[0, -1j, 1, 0],
def test_deprecated_ms(rads):
assert np.all(cirq.unitary(cirq.ms(rads)) == cirq.unitary(cirq.MS(rads)))
def test_deprecated_ms(rads):
with capture_logging():
assert np.all(
cirq.unitary(cirq.ms(rads)) == cirq.unitary(cirq.MS(rads)))