Add cirq.google.optimized_for_xmon() (#647)

- This is an all-in-one method for producing xmon-optimized circuits.

For example, it decomposes this:

```
0: ───iSwap───────────iSwap───M───
      │               │       │
1: ───iSwap───iSwap───iSwap───M───
              │               │
2: ───iSwap───iSwap───iSwap───M───
      │               │       │
3: ───iSwap───────────iSwap───M───
```

into this:

```
0: ───W(0.25)^-0.5───@───W(0.25)^0.5────@───W(0.75)^0.5──────────────────────────────────────────@───W(0.25)^-0.5───@───W(0.25)^0.5────M───
                     │                  │                                                        │                  │                  │
1: ───W(0.25)^0.5────@───W(0.25)^-0.5───@───W(0.75)^0.5────@───W(0.25)^0.5────@───W(0.75)^-0.5───@───W(0.25)^-0.5───@───W(0.25)^0.5────M───
                                                           │                  │                                                        │
2: ───W(0.25)^-0.5───@───W(0.25)^0.5────@───W(0.75)^-0.5───@───W(0.25)^-0.5───@───W(0.75)^0.5────@───W(0.25)^0.5────@───W(0.25)^-0.5───M───
                     │                  │                                                        │                  │                  │
3: ───W(0.25)^0.5────@───W(0.25)^-0.5───@───W(0.75)^-0.5─────────────────────────────────────────@───W(0.25)^0.5────@───W(0.25)^-0.5───M───
```

Obsoletes #488
Obsoletes #644
Obsoletes #645

Author: Strilanc

cirq/circuits/optimization_pass.py

@@ -115,12 +115,12 @@ def optimization_at(self,
         pass
 
     def optimize_circuit(self, circuit: Circuit):
-        walls = defaultdict(lambda: 0)  # type: Dict[QubitId, int]
+        frontier = defaultdict(lambda: 0)  # type: Dict[QubitId, int]
         i = 0
         while i < len(circuit):  # Note: circuit may mutate as we go.
             for op in circuit[i].operations:
                 # Don't touch stuff inserted by previous optimizations.
-                if any(walls[q] > i for q in op.qubits):
+                if any(frontier[q] > i for q in op.qubits):
                     continue
 
                 # Skip if an optimization removed the circuit underneath us.
@@ -138,7 +138,7 @@ def optimize_circuit(self, circuit: Circuit):
                 circuit.clear_operations_touching(
                     opt.clear_qubits,
                     [e for e in range(i, i + opt.clear_span)])
-                circuit.insert_at_frontier(opt.new_operations, i, walls)
+                circuit.insert_at_frontier(opt.new_operations, i, frontier)
 
             i += 1
 

cirq/google/__init__.py

@@ -44,6 +44,9 @@
 from cirq.google.xmon_gate_extensions import (
     xmon_gate_ext,
 )
+from cirq.google.optimize import (
+    optimized_for_xmon,
+)
 from cirq.google.xmon_gates import (
     Exp11Gate,
     ExpWGate,

cirq/google/optimize.py

@@ -0,0 +1,58 @@
+# Copyright 2018 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.
+
+"""A combination of several optimizations targeting XmonDevice."""
+
+from cirq import circuits
+from cirq.google import (
+    convert_to_xmon_gates,
+    merge_rotations,
+    merge_interactions,
+    eject_full_w,
+    eject_z,
+)
+
+_TOLERANCE = 1e-5
+
+_OPTIMIZERS = [
+    convert_to_xmon_gates.ConvertToXmonGates(),
+
+    merge_interactions.MergeInteractions(tolerance=_TOLERANCE),
+    merge_rotations.MergeRotations(tolerance=_TOLERANCE),
+    eject_full_w.EjectFullW(tolerance=_TOLERANCE),
+    eject_z.EjectZ(tolerance=_TOLERANCE),
+    circuits.DropNegligible(tolerance=_TOLERANCE),
+]
+
+
+def optimized_for_xmon(circuit: circuits.Circuit) -> circuits.Circuit:
+    """Optimizes a circuit with XmonDevice in mind.
+
+    Starts by converting the circuit's operations to the xmon gate set, then
+    begins merging interactions and rotations, ejecting pi-rotations and phasing
+    operations, dropping unnecessary operations, and pushing operations earlier.
+
+    Args:
+        circuit: The circuit to optimize.
+
+    Returns:
+        The optimized circuit.
+    """
+    copy = circuit.copy()
+    for optimizer in _OPTIMIZERS:
+        optimizer.optimize_circuit(copy)
+
+    return circuits.Circuit().from_ops(
+        copy.all_operations(),
+        strategy=circuits.InsertStrategy.EARLIEST)

cirq/google/optimize_test.py

@@ -0,0 +1,58 @@
+# Copyright 2018 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.
+
+import pytest
+
+import cirq
+import cirq.google as cg
+
+from cirq.testing import (
+    assert_circuits_with_terminal_measurements_are_equivalent,
+)
+
+
+@pytest.mark.parametrize('n,d', [
+    (3, 2),
+    (4, 3),
+    (4, 4),
+    (5, 4),
+    (22, 4),
+])
+def test_swap_field(n: int, d: int):
+    before = cirq.Circuit.from_ops(
+        cirq.ISWAP(cirq.LineQubit(j), cirq.LineQubit(j + 1))
+        for i in range(d)
+        for j in range(i % 2, n - 1, 2)
+    )
+    before.append(cirq.measure(*before.all_qubits()))
+
+    after = cg.optimized_for_xmon(before)
+
+    assert len(after) == d*4 + 2
+    if n <= 5:
+        assert_circuits_with_terminal_measurements_are_equivalent(
+            before, after, atol=1e-4)
+
+
+def test_ccz():
+    before = cirq.Circuit.from_ops(
+        cirq.CCZ(cirq.GridQubit(5, 5),
+                 cirq.GridQubit(5, 6),
+                 cirq.GridQubit(5, 7)))
+
+    after = cg.optimized_for_xmon(before)
+
+    assert len(after) <= 22
+    assert_circuits_with_terminal_measurements_are_equivalent(
+        before, after, atol=1e-4)