Polish line placement example (#705)

- Fix Circuit.insert not commuting xmon CZs past other xmon CZs when there is space available (instead of stopping at the first sign of a blockage)
- Fix W(~=1.0)^t not being displayed as X^-t
- Add new_device and qubit_map parameters to optimized_for_xmon
- Rename from 'line_placement.py' to 'place_on_bristlecone.py'
- 'line_on_device' now just returns a tuple of qubits with a souped-up __str__
- Extend example to include creating a circuit and optimizing it
- Refactor LineSequence class into a List[GridQubit] type declaration
- Refactor LinePlacement class into GridQubitLineTuple, which is just a tuple with a special __str__
- Modify several line placement tests to check results instead of the way they were achieved
- Combine 'line_placement_on_device' and 'line_on_device'

Fixes #463

Author: Strilanc

cirq/circuits/circuit.py

@@ -234,8 +234,8 @@ def __repr__(self):
         moment_lines = ('\n    ' + repr(moment) for moment in self._moments)
         if self._device == devices.UnconstrainedDevice:
             return 'Circuit([{}])'.format(','.join(moment_lines))
-        return 'Circuit([{}], device={})'.format(','.join(moment_lines),
-                                                 self._device)
+        return 'Circuit([{}], device={!r})'.format(','.join(moment_lines),
+                                                   self._device)
 
     def __str__(self):
         return self.to_text_diagram()
@@ -386,19 +386,19 @@ def prev_moment_operating_on(
                                                (end_moment_index - k - 1
                                                 for k in range(max_distance)))
 
-    def _prev_moment_blocking(
+    def _prev_moment_available(
             self,
             op: ops.Operation,
             end_moment_index: int) -> Optional[int]:
-        if not self._moments:
-            return None
-
+        last_available = end_moment_index
         k = end_moment_index
         while k > 0:
             k -= 1
-            if not self._can_add_op_at(k, op):
-                return k
-        return None
+            if not self._can_commute_past(k, op):
+                return last_available
+            if self._can_add_op_at(k, op):
+                last_available = k
+        return last_available
 
     def operation_at(self,
                      qubit: ops.QubitId,
@@ -493,17 +493,17 @@ def _pick_or_create_inserted_op_moment_index(
             return splitter_index
 
         if strategy is InsertStrategy.INLINE:
-            if (self._can_add_op_at(splitter_index - 1, op) and
-                    0 <= splitter_index - 1 < len(self._moments)):
+            if (0 <= splitter_index - 1 < len(self._moments) and
+                    self._can_add_op_at(splitter_index - 1, op)):
                 return splitter_index - 1
 
             return self._pick_or_create_inserted_op_moment_index(
                 splitter_index, op, InsertStrategy.NEW)
 
         if strategy is InsertStrategy.EARLIEST:
             if self._can_add_op_at(splitter_index, op):
-                p = self._prev_moment_blocking(op, splitter_index)
-                return p + 1 if p is not None else 0
+                p = self._prev_moment_available(op, splitter_index)
+                return p or 0
 
             return self._pick_or_create_inserted_op_moment_index(
                 splitter_index, op, InsertStrategy.INLINE)
@@ -525,6 +525,11 @@ def _can_add_op_at(self,
             operation,
             self._moments[moment_index])
 
+    def _can_commute_past(self,
+                          moment_index: int,
+                          operation: ops.Operation) -> bool:
+        return not self._moments[moment_index].operates_on(operation.qubits)
+
     def insert(
             self,
             index: int,

cirq/circuits/circuit_test.py

@@ -1978,15 +1978,35 @@ def test_validates_while_editing():
 def test_respects_additional_adjacency_constraints():
     c = cirq.Circuit(device=cg.Foxtail)
     c.append(cg.Exp11Gate().on(cirq.GridQubit(0, 0),
-                                        cirq.GridQubit(0, 1)))
+                               cirq.GridQubit(0, 1)))
     c.append(cg.Exp11Gate().on(cirq.GridQubit(1, 0),
-                                        cirq.GridQubit(1, 1)),
+                               cirq.GridQubit(1, 1)),
              strategy=cirq.InsertStrategy.EARLIEST)
     assert c == cirq.Circuit([
         cirq.Moment([cg.Exp11Gate().on(cirq.GridQubit(0, 0),
-                                                cirq.GridQubit(0, 1))]),
+                                       cirq.GridQubit(0, 1))]),
         cirq.Moment([cg.Exp11Gate().on(cirq.GridQubit(1, 0),
-                                                cirq.GridQubit(1, 1))]),
+                                       cirq.GridQubit(1, 1))]),
+    ], device=cg.Foxtail)
+
+
+def test_commutes_past_adjacency_constraints():
+    c = cirq.Circuit([
+            cirq.Moment(),
+            cirq.Moment(),
+            cirq.Moment([
+                cg.Exp11Gate().on(cirq.GridQubit(0, 0), cirq.GridQubit(0, 1))])
+        ],
+        device=cg.Foxtail)
+    c.append(cg.Exp11Gate().on(cirq.GridQubit(1, 0),
+                               cirq.GridQubit(1, 1)),
+             strategy=cirq.InsertStrategy.EARLIEST)
+    assert c == cirq.Circuit([
+        cirq.Moment([cg.Exp11Gate().on(cirq.GridQubit(1, 0),
+                                       cirq.GridQubit(1, 1))]),
+        cirq.Moment(),
+        cirq.Moment([cg.Exp11Gate().on(cirq.GridQubit(0, 0),
+                                       cirq.GridQubit(0, 1))]),
     ], device=cg.Foxtail)
 
 

cirq/google/optimize.py

@@ -13,30 +13,37 @@
 # limitations under the License.
 
 """A combination of several optimizations targeting XmonDevice."""
+from typing import Optional, Callable, cast
 
-from cirq import circuits
+from cirq import circuits, ops, devices
 from cirq.google import (
     convert_to_xmon_gates,
     merge_rotations,
     merge_interactions,
     eject_full_w,
     eject_z,
-)
+    xmon_device)
 
 _TOLERANCE = 1e-5
 
 _OPTIMIZERS = [
     convert_to_xmon_gates.ConvertToXmonGates(),
 
-    merge_interactions.MergeInteractions(tolerance=_TOLERANCE),
+    merge_interactions.MergeInteractions(tolerance=_TOLERANCE,
+                                         allow_partial_czs=False),
     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:
+def optimized_for_xmon(
+        circuit: circuits.Circuit,
+        new_device: Optional[xmon_device.XmonDevice] = None,
+        qubit_map: Callable[[ops.QubitId], devices.GridQubit] =
+        lambda e: cast(devices.GridQubit, e),
+) -> circuits.Circuit:
     """Optimizes a circuit with XmonDevice in mind.
 
     Starts by converting the circuit's operations to the xmon gate set, then
@@ -45,6 +52,9 @@ def optimized_for_xmon(circuit: circuits.Circuit) -> circuits.Circuit:
 
     Args:
         circuit: The circuit to optimize.
+        new_device: The device the optimized circuit should be targeted at. If
+            set to None, the circuit's current device is used.
+        qubit_map: Transforms the qubits (e.g. so that they are GridQubits).
 
     Returns:
         The optimized circuit.
@@ -53,6 +63,7 @@ def optimized_for_xmon(circuit: circuits.Circuit) -> circuits.Circuit:
     for optimizer in _OPTIMIZERS:
         optimizer.optimize_circuit(copy)
 
-    return circuits.Circuit().from_ops(
-        copy.all_operations(),
-        strategy=circuits.InsertStrategy.EARLIEST)
+    return circuits.Circuit.from_ops(
+        (op.transform_qubits(qubit_map) for op in copy.all_operations()),
+        strategy=circuits.InsertStrategy.EARLIEST,
+        device=new_device or copy.device)

cirq/google/optimize_test.py

@@ -56,3 +56,33 @@ def test_ccz():
     assert len(after) <= 22
     assert_circuits_with_terminal_measurements_are_equivalent(
         before, after, atol=1e-4)
+
+
+def test_adjacent_cz_get_split_apart():
+    before = cirq.Circuit([cirq.Moment([
+        cirq.CZ(cirq.GridQubit(0, 0), cirq.GridQubit(0, 1)),
+        cirq.CZ(cirq.GridQubit(1, 0), cirq.GridQubit(1, 1))])])
+
+    after = cg.optimized_for_xmon(before,
+                                  new_device=cg.Foxtail)
+
+    assert after == cirq.Circuit([
+        cirq.Moment([
+            cg.Exp11Gate().on(cirq.GridQubit(0, 0), cirq.GridQubit(0, 1))]),
+        cirq.Moment([
+            cg.Exp11Gate().on(cirq.GridQubit(1, 0), cirq.GridQubit(1, 1))])],
+        device=cg.Foxtail)
+
+
+def test_remap_qubits():
+    before = cirq.Circuit([cirq.Moment([
+        cirq.CZ(cirq.LineQubit(0), cirq.LineQubit(1))])])
+
+    after = cg.optimized_for_xmon(before,
+                                  new_device=cg.Foxtail,
+                                  qubit_map=lambda q: cirq.GridQubit(q.x, 0))
+
+    assert after == cirq.Circuit([
+        cirq.Moment([
+            cg.Exp11Gate().on(cirq.GridQubit(0, 0), cirq.GridQubit(1, 0))])],
+        device=cg.Foxtail)

cirq/google/xmon_gates.py

@@ -353,30 +353,33 @@ def trace_distance_bound(self):
             return 1
         return abs(self.half_turns) * 3.5
 
-    def _text_symbol(self, args: ops.TextDiagramInfoArgs) -> str:
+    def text_diagram_info(self, args: ops.TextDiagramInfoArgs
+                          ) -> ops.TextDiagramInfo:
         e = 0 if args.precision is None else 10**-args.precision
+        half_turns = self.half_turns
         if isinstance(self.axis_half_turns, value.Symbol):
-            return 'W({})'.format(self.axis_half_turns)
-        if abs(self.axis_half_turns) <= e:
-            return 'X'
-        if abs(self.axis_half_turns - 0.5) <= e:
-            return 'Y'
-        if args.precision is not None:
-            return 'W({{:.{}}})'.format(args.precision).format(
+            s = 'W({})'.format(self.axis_half_turns)
+        elif abs(self.axis_half_turns) <= e:
+            s = 'X'
+        elif (abs(self.axis_half_turns - 1) <= e and
+              isinstance(half_turns, float)):
+            s = 'X'
+            half_turns = -half_turns
+        elif abs(self.axis_half_turns - 0.5) <= e:
+            s = 'Y'
+        elif args.precision is not None:
+            s = 'W({{:.{}}})'.format(args.precision).format(
                 self.axis_half_turns)
         else:
-            return 'W({})'.format(self.axis_half_turns)
-
-    def text_diagram_info(self, args: ops.TextDiagramInfoArgs
-                          ) -> ops.TextDiagramInfo:
-        return ops.TextDiagramInfo((self._text_symbol(args),),
-                                   self.half_turns)
+            s = 'W({})'.format(self.axis_half_turns)
+        return ops.TextDiagramInfo((s,), half_turns)
 
     def __str__(self):
-        base = self._text_symbol(ops.TextDiagramInfoArgs.UNINFORMED_DEFAULT)
-        if self.half_turns == 1:
-            return base
-        return '{}^{}'.format(base, self.half_turns)
+        info = self.text_diagram_info(
+            ops.TextDiagramInfoArgs.UNINFORMED_DEFAULT)
+        if info.exponent == 1:
+            return info.wire_symbols[0]
+        return '{}^{}'.format(info.wire_symbols[0], info.exponent)
 
     def __repr__(self):
         return ('ExpWGate(half_turns={}, axis_half_turns={})'.format(

cirq/google/xmon_gates_test.py

@@ -287,6 +287,15 @@ def test_w_eq():
         cg.ExpWGate(half_turns=7.75, axis_half_turns=11.25))
 
 
+def test_w_str():
+    assert str(cg.ExpWGate()) == 'X'
+    assert str(cg.ExpWGate(axis_half_turns=0.99999, half_turns=0.5)) == 'X^-0.5'
+    assert str(cg.ExpWGate(axis_half_turns=0.5, half_turns=0.25)) == 'Y^0.25'
+    assert str(cg.ExpWGate(axis_half_turns=0.25,
+                           half_turns=0.5)) == 'W(0.25)^0.5'
+
+
+
 def test_w_to_proto():
     assert proto_matches_text(
         cg.ExpWGate(half_turns=Symbol('k'),

cirq/line/placement/__init__.py

@@ -22,9 +22,8 @@
     LinePlacementStrategy,
 )
 from cirq.line.placement.sequence import (
-    LinePlacement,
+    GridQubitLineTuple,
 )
 from cirq.line.placement.line import (
-    line_placement_on_device,
     line_on_device,
 )

cirq/line/placement/anneal.py

@@ -26,7 +26,7 @@
     EDGE,
 )
 from cirq.line.placement.sequence import (
-    LinePlacement,
+    GridQubitLineTuple,
     LineSequence
 )
 from cirq.contrib import optimization
@@ -52,8 +52,8 @@ def __init__(self, device: XmonDevice, seed=None) -> None:
     def search(
             self,
             trace_func: Callable[
-                [List[List[GridQubit]], float, float, float, bool],
-                None] = None) -> List[List[GridQubit]]:
+                [List[LineSequence], float, float, float, bool],
+                None] = None) -> List[LineSequence]:
         """Issues new linear sequence search.
 
         Each call to this method starts new search.
@@ -340,8 +340,12 @@ class AnnealSequenceSearchStrategy(place_strategy.LinePlacementStrategy):
     efficiency improvements.
     """
 
-    def __init__(self, trace_func: Callable[
-        [List[List[GridQubit]], float, float, float, bool], None] = None,
+    def __init__(self,
+                 trace_func: Callable[[List[LineSequence],
+                                       float,
+                                       float,
+                                       float,
+                                       bool], None] = None,
                  seed: int = None) -> None:
         """Linearized sequence search using simulated annealing method.
 
@@ -361,7 +365,7 @@ def __init__(self, trace_func: Callable[
         self.trace_func = trace_func
         self.seed = seed
 
-    def place_line(self, device: XmonDevice, length: int) -> LinePlacement:
+    def place_line(self, device: XmonDevice, length: int) -> GridQubitLineTuple:
         """Runs line sequence search.
 
         Args:
@@ -373,8 +377,7 @@ def place_line(self, device: XmonDevice, length: int) -> LinePlacement:
             method.
         """
         seqs = AnnealSequenceSearch(device, self.seed).search(self.trace_func)
-        return LinePlacement(device, length,
-                             [LineSequence(seq) for seq in seqs])
+        return GridQubitLineTuple.best_of(seqs, length)
 
 
 def index_2d(seqs: List[List[Any]], target: Any) -> Tuple[int, int]:

cirq/line/placement/anneal_test.py

@@ -386,19 +386,14 @@ def _verify_valid_state(qubits: List[GridQubit], state: _STATE):
     assert not c_set
 
 
-@mock.patch('cirq.line.placement.anneal.AnnealSequenceSearch')
-def test_anneal_search_method_calls(search):
+def test_anneal_search_method_calls():
     q00, q01 = GridQubit(0, 0), GridQubit(0, 1)
     device = _create_device([q00, q01])
     length = 1
     seed = 1
-    search_instance = search.return_value
 
     method = AnnealSequenceSearchStrategy(None, seed)
-    method.place_line(device, length)
-
-    search.assert_called_once_with(device, seed)
-    search_instance.search.assert_called_once_with(None)
+    assert len(method.place_line(device, length)) == length
 
 
 def test_index_2d():