Python converted_gate_set Beispiele

Beispiel #1

Datei: clifford_optimize_test.py Projekt: zhiyuzh/Cirq

def test_optimize():
    q0, q1 = cirq.LineQubit.range(2)
    c_orig = cirq.Circuit.from_ops(
        cirq.X(q1)**0.5,
        cirq.CZ(q0, q1),
        cirq.Z(q0)**0.25,
        cirq.X(q1)**0.25,
        cirq.CZ(q0, q1),
        cirq.X(q1)**-0.5,
    )
    c_expected = converted_gate_set(
        cirq.Circuit.from_ops(
            cirq.CZ(q0, q1),
            cirq.Z(q0)**0.25,
            cirq.X(q1)**0.25,
            cirq.CZ(q0, q1),
        ))

    c_opt = clifford_optimized_circuit(c_orig)

    cirq.testing.assert_allclose_up_to_global_phase(
        c_orig.unitary(),
        c_opt.unitary(),
        atol=1e-7,
    )

    assert c_opt == c_expected

    cirq.testing.assert_has_diagram(
        c_opt, """
0: ───@───[Z]^0.25───@───
      │              │
1: ───@───[X]^0.25───@───
""")

Beispiel #2

Datei: clifford_optimize_test.py Projekt: zhiyuzh/Cirq

def test_with_measurements():
    q0, q1 = cirq.LineQubit.range(2)
    c_orig = cirq.Circuit.from_ops(
        cirq.X(q0),
        cirq.CZ(q0, q1),
        cirq.measure(q0, q1, key='m'),
    )
    c_expected = converted_gate_set(
        cirq.Circuit.from_ops(
            cirq.CZ(q0, q1),
            cirq.X(q0),
            cirq.Z(q1),
            cirq.measure(q0, q1, key='m'),
        ))

    c_opt = clifford_optimized_circuit(c_orig)

    cirq.testing.assert_allclose_up_to_global_phase(
        c_orig.unitary(),
        c_opt.unitary(),
        atol=1e-7,
    )

    assert c_opt == c_expected

    cirq.testing.assert_has_diagram(
        c_opt, """
0: ───@───X───M('m')───
      │       │
1: ───@───Z───M────────
""")

Beispiel #3

Datei: convert_gate_set_test.py Projekt: zhiyuzh/Cirq

def test_converts_large_circuit():
    q0, q1, q2 = cirq.LineQubit.range(3)

    before = cirq.Circuit.from_ops(
        cirq.X(q0),
        cirq.Y(q0),
        cirq.Z(q0),
        cirq.X(q0) ** 0.5,
        cirq.Y(q0) ** 0.5,
        cirq.Z(q0) ** 0.5,
        cirq.X(q0) ** -0.5,
        cirq.Y(q0) ** -0.5,
        cirq.Z(q0) ** -0.5,
        cirq.H(q0),
        cirq.CZ(q0, q1),
        cirq.CZ(q1, q2),
        cirq.X(q0) ** 0.25,
        cirq.Y(q0) ** 0.25,
        cirq.Z(q0) ** 0.25,
        cirq.CZ(q0, q1),
    )

    after = converted_gate_set(before)

    cirq.testing.assert_allclose_up_to_global_phase(before.unitary(),
                                                    after.unitary(),
                                                    atol=1e-7)

    cirq.testing.assert_has_diagram(after, '''
0: ───Y^0.5───@───[Z]^-0.304───[X]^(1/3)───[Z]^0.446───@───
              │                                        │
1: ───────────@───@────────────────────────────────────@───
                  │
2: ───────────────@────────────────────────────────────────
''')

Beispiel #4

Datei: convert_gate_set_test.py Projekt: zhoudaqing/Cirq

def test_converts_large_circuit():
    q0, q1, q2 = cirq.LineQubit.range(3)

    before = cirq.Circuit.from_ops(
        cirq.X(q0),
        cirq.Y(q0),
        cirq.Z(q0),
        cirq.X(q0)**0.5,
        cirq.Y(q0)**0.5,
        cirq.Z(q0)**0.5,
        cirq.X(q0)**-0.5,
        cirq.Y(q0)**-0.5,
        cirq.Z(q0)**-0.5,
        cirq.H(q0),
        cirq.CZ(q0, q1),
        cirq.CZ(q1, q2),
        cirq.X(q0)**0.25,
        cirq.Y(q0)**0.25,
        cirq.Z(q0)**0.25,
        cirq.CZ(q0, q1),
    )

    after = converted_gate_set(before)

    cirq.testing.assert_allclose_up_to_global_phase(before.to_unitary_matrix(),
                                                    after.to_unitary_matrix(),
                                                    atol=1e-7)

    assert after.to_text_diagram() == '''
0: ───Y^0.5───@───[Z]^-0.304───[X]^0.333───[Z]^0.304───@───[Z]^0.142───
              │                                        │
1: ───────────@───@────────────────────────────────────@───────────────
                  │
2: ───────────────@────────────────────────────────────────────────────
'''.strip()

Beispiel #5

Datei: pauli_string_optimize_test.py Projekt: dstrain115/Cirq-1

def test_optimize():
    q0, q1 = cirq.LineQubit.range(2)
    c_orig = cirq.Circuit(
        cirq.X(q0) ** 0.25, cirq.H(q0), cirq.CZ(q0, q1), cirq.H(q0), cirq.X(q0) ** 0.125
    )
    c_expected = converted_gate_set(
        cirq.Circuit(
            cirq.Y(q0) ** -0.5,
            cirq.CZ(q0, q1),
            cirq.Z(q0) ** -0.125,
            cirq.X(q0) ** 0.5,
            cirq.Z(q0) ** 0.5,
        ),
        no_clifford_gates=True,
    )

    c_opt = pauli_string_optimized_circuit(c_orig)

    cirq.testing.assert_allclose_up_to_global_phase(c_orig.unitary(), c_opt.unitary(), atol=1e-7)

    assert c_opt == c_expected

    cirq.testing.assert_has_diagram(
        c_opt,
        """
0: ───[Y]^-0.5───@───[Z]^(-1/8)───[X]^0.5───[Z]^0.5───
                 │
1: ──────────────@────────────────────────────────────
""",
    )

Beispiel #6

Datei: clifford_optimize_test.py Projekt: ybc1991/Cirq

def test_remove_staggered_czs():
    q0, q1, q2 = cirq.LineQubit.range(3)
    c_orig = cirq.Circuit(
        cirq.CZ(q0, q1),
        cirq.CZ(q1, q2),
        cirq.CZ(q0, q1),
    )
    c_expected = converted_gate_set(cirq.Circuit(cirq.CZ(q1, q2), ))

    c_opt = clifford_optimized_circuit(c_orig)

    cirq.testing.assert_allclose_up_to_global_phase(
        c_orig.unitary(),
        c_opt.unitary(qubits_that_should_be_present=(q0, q1, q2)),
        atol=1e-7,
    )

    assert c_opt == c_expected

    cirq.testing.assert_has_diagram(
        c_opt,
        """
1: ───@───
      │
2: ───@───
""",
    )

Beispiel #7

Datei: pauli_string_optimize_test.py Projekt: wfinigan/Cirq

def test_optimize():
    q0, q1 = cirq.LineQubit.range(2)
    c_orig = cirq.Circuit.from_ops(
        cirq.X(q0)**0.25,
        cirq.H(q0),
        cirq.CZ(q0, q1),
        cirq.H(q0),
        cirq.X(q0)**0.125,
    )
    c_expected = converted_gate_set(cirq.Circuit.from_ops(
        cirq.Y(q0)**-0.5,
        cirq.CZ(q0, q1),
        cirq.Z(q0)**-0.125,
        cirq.X(q0)**0.5,
        cirq.Z(q0)**0.5,
    ),
                                    no_clifford_gates=True)

    c_opt = pauli_string_optimized_circuit(c_orig)

    cirq.testing.assert_allclose_up_to_global_phase(
        c_orig.to_unitary_matrix(),
        c_opt.to_unitary_matrix(),
        atol=1e-7,
    )

    assert c_opt == c_expected

    assert c_opt.to_text_diagram() == """
0: ───[Y]^-0.5───@───[Z]^-0.125───[X]^0.5───[Z]^0.5───
                 │
1: ──────────────@────────────────────────────────────
""".strip()

Beispiel #8

Datei: convert_gate_set_test.py Projekt: dstrain115/Cirq-1

def test_converts_single_qubit_then_two():
    q0, q1 = cirq.LineQubit.range(2)

    before = cirq.Circuit(cirq.X(q0), cirq.Y(q0), cirq.CZ(q0, q1))

    after = converted_gate_set(before)
    cirq.testing.assert_allclose_up_to_global_phase(before.unitary(),
                                                    after.unitary(),
                                                    atol=1e-7)

Beispiel #9

def test_converts_various_ops(op, expected_ops):
    before = cirq.Circuit(op)
    expected = cirq.Circuit(expected_ops, strategy=cirq.InsertStrategy.EARLIEST)

    after = converted_gate_set(before)
    assert after == expected
    cirq.testing.assert_allclose_up_to_global_phase(
        before.unitary(),
        after.unitary(qubits_that_should_be_present=op.qubits),
        atol=1e-7)
    cirq.testing.assert_allclose_up_to_global_phase(
        after.unitary(qubits_that_should_be_present=op.qubits),
        expected.unitary(qubits_that_should_be_present=op.qubits),
        atol=1e-7)

Beispiel #10

Datei: convert_gate_set_test.py Projekt: google2013/Cirq

def test_converts_single_qubit_then_two():
    q0, q1 = cirq.LineQubit.range(2)

    before = cirq.Circuit.from_ops(
        cirq.X(q0),
        cirq.Y(q0),
        cirq.CZ(q0, q1),
    )

    after = converted_gate_set(before)
    cirq.testing.assert_allclose_up_to_global_phase(
            before.to_unitary_matrix(),
            after.to_unitary_matrix(),
            atol=1e-7)

Beispiel #11

Datei: convert_gate_set_test.py Projekt: google2013/Cirq

def test_converts_various_ops(op, expected_ops):
    before = cirq.Circuit.from_ops(op)
    expected = cirq.Circuit.from_ops(expected_ops,
                                     strategy=cirq.InsertStrategy.EARLIEST)

    after = converted_gate_set(before)
    assert after == expected
    cirq.testing.assert_allclose_up_to_global_phase(
            before.to_unitary_matrix(),
            after.to_unitary_matrix(qubits_that_should_be_present=op.qubits),
            atol=1e-7)
    cirq.testing.assert_allclose_up_to_global_phase(
            after.to_unitary_matrix(qubits_that_should_be_present=op.qubits),
            expected.to_unitary_matrix(qubits_that_should_be_present=op.qubits),
            atol=1e-7)

Beispiel #12

Datei: convert_gate_set_test.py Projekt: towynlin/Cirq

def test_degenerate_single_qubit_decompose():
    q0 = cirq.LineQubit(0)

    before = cirq.Circuit(
        cirq.Z(q0) ** 0.1,
        cirq.X(q0) ** 1.0000000001,
        cirq.Z(q0) ** 0.1,
    )
    expected = cirq.Circuit(
        cirq.SingleQubitCliffordGate.X(q0),
    )

    after = converted_gate_set(before)
    assert after == expected
    cirq.testing.assert_allclose_up_to_global_phase(before.unitary(), after.unitary(), atol=1e-7)
    cirq.testing.assert_allclose_up_to_global_phase(after.unitary(), expected.unitary(), atol=1e-7)

Beispiel #13

def test_remove_czs():
    q0, q1 = cirq.LineQubit.range(2)
    c_orig = cirq.Circuit(cirq.CZ(q0, q1), cirq.Z(q0)**0.5, cirq.CZ(q0, q1))
    c_expected = converted_gate_set(cirq.Circuit(cirq.Z(q0)**0.5))

    c_opt = clifford_optimized_circuit(c_orig)

    cirq.testing.assert_allclose_up_to_global_phase(
        c_orig.unitary(),
        c_opt.unitary(qubits_that_should_be_present=(q0, q1)),
        atol=1e-7)

    assert c_opt == c_expected

    cirq.testing.assert_has_diagram(
        c_opt,
        """
0: ───Z^0.5───
""",
    )

Beispiel #14

Datei: convert_gate_set_test.py Projekt: towynlin/Cirq

def test_converts_single_qubit_series():
    q0 = cirq.LineQubit(0)

    before = cirq.Circuit(
        cirq.X(q0),
        cirq.Y(q0),
        cirq.Z(q0),
        cirq.X(q0) ** 0.5,
        cirq.Y(q0) ** 0.5,
        cirq.Z(q0) ** 0.5,
        cirq.X(q0) ** -0.5,
        cirq.Y(q0) ** -0.5,
        cirq.Z(q0) ** -0.5,
        cirq.X(q0) ** 0.25,
        cirq.Y(q0) ** 0.25,
        cirq.Z(q0) ** 0.25,
    )

    after = converted_gate_set(before)
    cirq.testing.assert_allclose_up_to_global_phase(before.unitary(), after.unitary(), atol=1e-7)

Beispiel #15

Datei: convert_gate_set_test.py Projekt: google2013/Cirq

def test_degenerate_single_qubit_decompose():
    q0 = cirq.LineQubit(0)

    before = cirq.Circuit.from_ops(
        cirq.Z(q0) ** 0.1,
        cirq.X(q0) ** 1.0000000001,
        cirq.Z(q0) ** 0.1,
    )
    expected = cirq.Circuit.from_ops(
        cirq.CliffordGate.X(q0),
    )

    after = converted_gate_set(before)
    assert after == expected
    cirq.testing.assert_allclose_up_to_global_phase(
            before.to_unitary_matrix(),
            after.to_unitary_matrix(),
            atol=1e-7)
    cirq.testing.assert_allclose_up_to_global_phase(
            after.to_unitary_matrix(),
            expected.to_unitary_matrix(),
            atol=1e-7)

Beispiel #16

Datei: convert_gate_set_test.py Projekt: google2013/Cirq

def test_converts_single_qubit_series():
    q0 = cirq.LineQubit(0)

    before = cirq.Circuit.from_ops(
        cirq.X(q0),
        cirq.Y(q0),
        cirq.Z(q0),
        cirq.X(q0) ** 0.5,
        cirq.Y(q0) ** 0.5,
        cirq.Z(q0) ** 0.5,
        cirq.X(q0) ** -0.5,
        cirq.Y(q0) ** -0.5,
        cirq.Z(q0) ** -0.5,
        cirq.X(q0) ** 0.25,
        cirq.Y(q0) ** 0.25,
        cirq.Z(q0) ** 0.25,
    )

    after = converted_gate_set(before)
    cirq.testing.assert_allclose_up_to_global_phase(
            before.to_unitary_matrix(),
            after.to_unitary_matrix(),
            atol=1e-7)

Beispiel #17

Datei: convert_gate_set_test.py Projekt: google2013/Cirq

def test_converts_large_circuit():
    q0, q1, q2 = cirq.LineQubit.range(3)

    before = cirq.Circuit.from_ops(
        cirq.X(q0),
        cirq.Y(q0),
        cirq.Z(q0),
        cirq.X(q0) ** 0.5,
        cirq.Y(q0) ** 0.5,
        cirq.Z(q0) ** 0.5,
        cirq.X(q0) ** -0.5,
        cirq.Y(q0) ** -0.5,
        cirq.Z(q0) ** -0.5,
        cirq.H(q0),
        cirq.CZ(q0, q1),
        cirq.CZ(q1, q2),
        cirq.X(q0) ** 0.25,
        cirq.Y(q0) ** 0.25,
        cirq.Z(q0) ** 0.25,

        cirq.CZ(q0, q1),
    )

    after = converted_gate_set(before)

    cirq.testing.assert_allclose_up_to_global_phase(
            before.to_unitary_matrix(),
            after.to_unitary_matrix(),
            atol=1e-7)

    assert after.to_text_diagram() == '''
0: ───Y^0.5───@───[Z]^-0.304───[X]^0.333───[Z]^0.304───@───[Z]^0.142───
              │                                        │
1: ───────────@───@────────────────────────────────────@───────────────
                  │
2: ───────────────@────────────────────────────────────────────────────
'''.strip()