Initial draft of ConvertToSycamore

cirq/google/optimizers/convert_to_sycamore_gates.py

@@ -0,0 +1,128 @@
+# Copyright 2019 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import List, cast
+
+import numpy as np
+
+from cirq import circuits, ops, protocols, optimizers
+from cirq.google import SycamoreGate
+from cirq.google.optimizers.textbook_gates_from_sycamore import (
+    known_two_q_operations_to_sycamore_operations, swap_rzz)
+
+
+class ConvertToSycamoreGates(circuits.PointOptimizer):
+    """Attempts to convert non-native gates into SycamoreGates.
+
+    First, checks if the given operation is already a native sycamore operation.
+
+    Second, checks if the operation has a known unitary. If so, and the gate
+        is a 1-qubit or 2-qubit gate, then performs circuit synthesis of the
+        operation.
+
+    Third, attempts to `cirq.decompose` to the operation.
+
+    Fourth, if ignore_failures is set, gives up and returns the gate unchanged.
+        Otherwise raises a TypeError.
+    """
+
+    def __init__(self, ignore_failures=False) -> None:
+        """
+        Args:
+            ignore_failures: If set, gates that fail to convert are forwarded
+                unchanged. If not set, conversion failures raise a TypeError.
+        """
+        super().__init__()
+        self.ignore_failures = ignore_failures
+
+    def _is_native_sycamore_op(self, op: ops.Operation) -> bool:
+        """Check if the given operation is native to a Sycamore device.
+
+        Args:
+            op: Input operation.
+
+        Returns:
+            True if the operation is native to the gmon, false otherwise.
+        """
+        return (isinstance(op, ops.GateOperation) and isinstance(
+            cast(ops.GateOperation, op).gate,
+            (SycamoreGate, ops.MeasurementGate, ops.PhasedXPowGate,
+             ops.XPowGate, ops.YPowGate, ops.ZPowGate)))
+
+    def _convert_one(self, op: ops.Operation) -> ops.OP_TREE:
+        """
+        Decomposer intercept:  Upon cirq.protocols.decompose catch and
+        return new OP_Tree
+
+        This should decompose based on number of qubits.
+        """
+        if len(op.qubits) == 1:
+            mat = protocols.unitary(op, None)
+            gates = optimizers.single_qubit_matrix_to_phased_x_z(mat)
+            return [g.on(op.qubits[0]) for g in gates]
+        elif len(op.qubits) == 2 and isinstance(op, ops.GateOperation):
+            return known_two_q_operations_to_sycamore_operations(
+                op.qubits[0], op.qubits[1], op)
+        return NotImplemented
+
+    def convert(self, op: ops.Operation) -> List[ops.Operation]:
+
+        def on_stuck_raise(bad):
+            return TypeError("Don't know how to work with {!r}. "
+                             "It isn't a native xmon operation, "
+                             "a 1 or 2 qubit gate with a known unitary, "
+                             "or composite.".format(bad))
+
+        return protocols.decompose(
+            op,
+            keep=self._is_native_sycamore_op,
+            intercepting_decomposer=self._convert_one,
+            on_stuck_raise=None if self.ignore_failures else on_stuck_raise)
+
+    def optimization_at(self, circuit, index, op):
+
+        if not isinstance(op, ops.GateOperation):
+            return None
+
+        gate = op.gate
+
+        # Check for a SWAP and ZZPowGate together
+        if isinstance(gate, ops.ZZPowGate) or gate == ops.SWAP:
+            gate2 = None
+            rads = None
+            next_index = circuit.next_moment_operating_on(op.qubits, index + 1)
+            if next_index is not None:
+                ops_in_front = list(
+                    {circuit.operation_at(q, next_index) for q in op.qubits})
+                if len(ops_in_front) == 1 and isinstance(
+                        ops_in_front[0], ops.GateOperation):
+                    gate2 = ops_in_front[0].gate
+
+            if (isinstance(gate, ops.SwapPowGate) and
+                    isinstance(gate2, ops.ZZPowGate)):
+                rads = gate2.exponent * np.pi / 2
+            if (isinstance(gate, ops.ZZPowGate) and gate2 == ops.SWAP):
+                rads = gate.exponent * np.pi / 2
+            if rads is not None:
+                return circuits.PointOptimizationSummary(
+                    clear_span=next_index - index + 1,
+                    clear_qubits=op.qubits,
+                    new_operations=swap_rzz(rads, op.qubits[0], op.qubits[1]))
+
+        converted = self.convert(op)
+        if len(converted) == 1 and converted[0] is op:
+            return None
+
+        return circuits.PointOptimizationSummary(clear_span=1,
+                                                 new_operations=converted,
+                                                 clear_qubits=op.qubits)

cirq/google/optimizers/convert_to_sycamore_gates_test.py

@@ -0,0 +1,201 @@
+import numpy as np
+import pytest
+
+import cirq
+import cirq.google.optimizers.convert_to_sycamore_gates as cgoc
+import cirq.google.optimizers.textbook_gates_from_sycamore as cgot
+
+
+def _assert_equivalent_op_tree(x: cirq.OP_TREE, y: cirq.OP_TREE):
+    a = list(cirq.flatten_op_tree(x))
+    b = list(cirq.flatten_op_tree(y))
+    assert a == b
+
+
+def test_known_two_q_operations_to_sycamore_operations_cz():
+    qubits = [cirq.NamedQubit('a'), cirq.NamedQubit('b')]
+    operation = cirq.CZ(qubits[0], qubits[1])
+    test_op_tree = cirq.Circuit(operation)
+    cgoc.ConvertToSycamoreGates().optimize_circuit(test_op_tree)
+    true_op_tree = cirq.Circuit(cgot.decompose_cz_into_syc(
+        qubits[0], qubits[1]))
+    _assert_equivalent_op_tree(test_op_tree, true_op_tree)
+
+
+def test_cz_unitary():
+    q = cirq.LineQubit.range(2)
+    circuit1 = cirq.Circuit(cirq.CZ(q[0], q[1]))
+    circuit2 = circuit1.copy()
+    cgoc.ConvertToSycamoreGates().optimize_circuit(circuit2)
+    assert cirq.allclose_up_to_global_phase(cirq.unitary(circuit1),
+                                            cirq.unitary(circuit2))
+
+
+def test_known_two_q_operations_to_sycamore_operations_cphase():
+    qubits = [cirq.NamedQubit('a'), cirq.NamedQubit('b')]
+    for phi in np.linspace(0, 2 * np.pi, 30):
+        operation = cirq.CZPowGate(exponent=phi / np.pi).on(
+            qubits[0], qubits[1])
+        test_op_tree = cirq.Circuit(operation)
+        cgoc.ConvertToSycamoreGates().optimize_circuit(test_op_tree)
+        true_op_tree = cirq.Circuit(cgot.cphase(phi, qubits[0], qubits[1]))
+        _assert_equivalent_op_tree(test_op_tree, true_op_tree)
+
+
+def test_cphase_unitary():
+    q = cirq.LineQubit.range(2)
+    for phi in np.linspace(0, 2 * np.pi, 30):
+        operation = cirq.CZPowGate(exponent=phi / np.pi).on(q[0], q[1])
+        circuit1 = cirq.Circuit(operation)
+        circuit2 = circuit1.copy()
+        cgoc.ConvertToSycamoreGates().optimize_circuit(circuit2)
+        assert cirq.allclose_up_to_global_phase(cirq.unitary(circuit1),
+                                                cirq.unitary(circuit2))
+
+
+def test_known_two_q_operations_to_sycamore_operations_zz():
+    qubits = [cirq.NamedQubit('a'), cirq.NamedQubit('b')]
+    for theta in np.linspace(0, 2 * np.pi, 30):
+        operation = cirq.ZZPowGate(exponent=2 * theta / np.pi).on(
+            qubits[0], qubits[1])
+        test_op_tree = cirq.Circuit(operation)
+        cgoc.ConvertToSycamoreGates().optimize_circuit(test_op_tree)
+        true_op_tree = cirq.Circuit(cgot.rzz(theta, qubits[0], qubits[1]))
+        _assert_equivalent_op_tree(test_op_tree, true_op_tree)
+
+
+def test_zz_unitary():
+    q = cirq.LineQubit.range(2)
+    for theta in np.linspace(0, 2 * np.pi, 30):
+        operation = cirq.ZZPowGate(exponent=2 * theta / np.pi).on(q[0], q[1])
+        circuit1 = cirq.Circuit(operation)
+        circuit2 = circuit1.copy()
+        cgoc.ConvertToSycamoreGates().optimize_circuit(circuit2)
+        assert cirq.allclose_up_to_global_phase(cirq.unitary(circuit1),
+                                                cirq.unitary(circuit2))
+
+
+def test_known_two_q_operations_to_sycamore_operations_swap():
+    qubits = [cirq.NamedQubit('a'), cirq.NamedQubit('b')]
+    operation = cirq.SWAP(qubits[0], qubits[1])
+    test_op_tree = cirq.Circuit(operation)
+    cgoc.ConvertToSycamoreGates().optimize_circuit(test_op_tree)
+    true_op_tree = cirq.Circuit(
+        cgot.decompose_swap_into_syc(qubits[0], qubits[1]))
+    _assert_equivalent_op_tree(test_op_tree, true_op_tree)
+
+
+def test_swap_unitary():
+    q = cirq.LineQubit.range(2)
+    circuit1 = cirq.Circuit(cirq.SWAP(q[0], q[1]))
+    circuit2 = circuit1.copy()
+    cgoc.ConvertToSycamoreGates().optimize_circuit(circuit2)
+    assert cirq.allclose_up_to_global_phase(cirq.unitary(circuit1),
+                                            cirq.unitary(circuit2))
+
+
+def test_known_two_q_operations_to_sycamore_operations_iswap():
+    qubits = [cirq.NamedQubit('a'), cirq.NamedQubit('b')]
+    operation = cirq.ISWAP(qubits[0], qubits[1])
+    test_op_tree = cirq.Circuit(operation)
+    cgoc.ConvertToSycamoreGates().optimize_circuit(test_op_tree)
+    true_op_tree = cirq.Circuit(
+        cgot.decompose_iswap_into_syc(qubits[0], qubits[1]))
+    _assert_equivalent_op_tree(test_op_tree, true_op_tree)
+
+
+def test_iswap_unitary():
+    q = cirq.LineQubit.range(2)
+    circuit1 = cirq.Circuit(cirq.ISWAP(q[0], q[1]))
+    circuit2 = circuit1.copy()
+    cgoc.ConvertToSycamoreGates().optimize_circuit(circuit2)
+    assert cirq.allclose_up_to_global_phase(cirq.unitary(circuit1),
+                                            cirq.unitary(circuit2))
+
+
+def test_convert_to_sycamore_gates_swap_zz():
+    qubits = cirq.LineQubit.range(3)
+
+    gamma = np.random.randn()
+    circuit1 = cirq.Circuit(cirq.SWAP(qubits[0], qubits[1]),
+                            cirq.Z(qubits[2]),
+                            cirq.ZZ(qubits[0], qubits[1])**gamma,
+                            strategy=cirq.InsertStrategy.NEW)
+    circuit2 = cirq.Circuit(cirq.ZZ(qubits[0], qubits[1])**gamma,
+                            cirq.Z(qubits[2]),
+                            cirq.SWAP(qubits[0], qubits[1]),
+                            strategy=cirq.InsertStrategy.NEW)
+
+    compiled_circuit1 = circuit1.copy()
+    cgoc.ConvertToSycamoreGates()(compiled_circuit1)
+    compiled_circuit2 = circuit2.copy()
+    cgoc.ConvertToSycamoreGates()(compiled_circuit2)
+
+    cirq.testing.assert_same_circuits(compiled_circuit1, compiled_circuit2)
+    assert len(
+        list(
+            compiled_circuit1.findall_operations_with_gate_type(
+                cirq.google.SycamoreGate))) == 3
+    cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
+        circuit1, compiled_circuit1, atol=1e-7)
+
+
+def test_single_qubit_gate():
+    q = cirq.LineQubit(0)
+    mat = cirq.testing.random_unitary(2)
+    gate = cirq.SingleQubitMatrixGate(mat)
+    circuit = cirq.Circuit(gate(q))
+    converted_circuit = circuit.copy()
+    cgoc.ConvertToSycamoreGates().optimize_circuit(converted_circuit)
+    for op in converted_circuit.all_operations():
+        gate = op.gate
+        assert isinstance(gate, (cirq.PhasedXPowGate, cirq.ZPowGate))
+    cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
+        circuit, converted_circuit, atol=1e-8)
+
+
+def test_unsupported_gate():
+
+    class UnknownGate(cirq.TwoQubitGate):
+        pass
+
+    q0 = cirq.LineQubit(0)
+    q1 = cirq.LineQubit(1)
+    circuit = cirq.Circuit(UnknownGate()(q0, q1))
+    with pytest.raises(ValueError, match='Unrecognized gate: '):
+        cgoc.ConvertToSycamoreGates().optimize_circuit(circuit)
+
+
+def test_non_gate_operation():
+
+    class UnknownOperation(cirq.Operation):
+
+        def __init__(self, qubits):
+            self._qubits = qubits
+
+        @property
+        def qubits(self):
+            return self._qubits
+
+        def with_qubits(self, *new_qubits):
+            # coverage: ignore
+            return UnknownOperation(self._qubits)
+
+    q0 = cirq.LineQubit(0)
+    circuit = cirq.Circuit(UnknownOperation([q0]))
+    converted_circuit = circuit.copy()
+    cgoc.ConvertToSycamoreGates().optimize_circuit(converted_circuit)
+    assert circuit == converted_circuit
+
+
+def test_three_qubit_gate():
+
+    class ThreeQubitGate(cirq.ThreeQubitGate):
+        pass
+
+    q0 = cirq.LineQubit(0)
+    q1 = cirq.LineQubit(1)
+    q2 = cirq.LineQubit(2)
+    circuit = cirq.Circuit(ThreeQubitGate()(q0, q1, q2))
+    with pytest.raises(TypeError):
+        cgoc.ConvertToSycamoreGates().optimize_circuit(circuit)