Merge branch 'master' into deprecate_device_decompose

Author: MichaelBroughton

cirq-core/cirq/__init__.py

@@ -358,6 +358,8 @@
     decompose_multi_controlled_x,
     decompose_multi_controlled_rotation,
     decompose_two_qubit_interaction_into_four_fsim_gates,
+    drop_empty_moments,
+    drop_negligible_operations,
     is_negligible_turn,
     map_moments,
     map_operations,
@@ -371,6 +373,7 @@
     single_qubit_matrix_to_phased_x_z,
     single_qubit_matrix_to_phxz,
     single_qubit_op_to_framed_phase_form,
+    synchronize_terminal_measurements,
     TRANSFORMER,
     TransformerContext,
     TransformerLogger,

cirq-core/cirq/circuits/circuit.py

@@ -2016,6 +2016,10 @@ def _pick_or_create_inserted_op_moment_index(
     def _can_add_op_at(self, moment_index: int, operation: 'cirq.Operation') -> bool:
         if not 0 <= moment_index < len(self._moments):
             return True
+
+        if self._device == cirq.UNCONSTRAINED_DEVICE:
+            return not self._moments[moment_index].operates_on(operation.qubits)
+
         return self._device.can_add_operation_into_moment(operation, self._moments[moment_index])
 
     def insert(
@@ -2120,19 +2124,28 @@ def insert_into_range(self, operations: 'cirq.OP_TREE', start: int, end: int) ->
 
         i = start
         op_index = 0
-        while op_index < len(flat_ops):
-            op = flat_ops[op_index]
-            while i < end and not self._device.can_add_operation_into_moment(op, self._moments[i]):
-                i += 1
-            if i >= end:
-                break
-            self._moments[i] = self._moments[i].with_operation(op)
-            op_index += 1
-
-        if op_index >= len(flat_ops):
-            return end
-
-        return self.insert(end, flat_ops[op_index:])
+        cannot_add_lambda = lambda a, b: b.operates_on(a.qubits)
+        if self._device != cirq.UNCONSTRAINED_DEVICE:
+            _compat._warn_or_error(
+                "In Cirq v0.15 device specific validation in "
+                "insert_into_range will no longer enforced."
+            )
+            cannot_add_lambda = lambda a, b: not self._device.can_add_operation_into_moment(a, b)
+
+        with _compat.block_overlapping_deprecation('can_add_operation_into_moment'):
+            while op_index < len(flat_ops):
+                op = flat_ops[op_index]
+                while i < end and cannot_add_lambda(op, self._moments[i]):
+                    i += 1
+                if i >= end:
+                    break
+                self._moments[i] = self._moments[i].with_operation(op)
+                op_index += 1
+
+            if op_index >= len(flat_ops):
+                return end
+
+            return self.insert(end, flat_ops[op_index:])
 
     def _push_frontier(
         self,

cirq-core/cirq/circuits/circuit_test.py

@@ -1178,6 +1178,14 @@ def optimization_at(
     )
 
 
+def test_insert_into_range_deprecated():
+    with cirq.testing.assert_deprecated('insert_into_range', deadline='v0.15'):
+        x, y = cirq.GridQubit.rect(1, 2)
+        c = cirq.Circuit([cirq.Moment([cirq.X(x)])] * 4)
+        c._device = FOXY
+        c.insert_into_range([cirq.Z(x), cirq.CZ(x, y)], 2, 2)
+
+
 def test_insert_into_range():
     x = cirq.NamedQubit('x')
     y = cirq.NamedQubit('y')

cirq-core/cirq/contrib/paulistring/convert_gate_set.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from cirq import circuits, optimizers
+from cirq import circuits, optimizers, transformers
 
 from cirq.contrib.paulistring.convert_to_pauli_string_phasors import ConvertToPauliStringPhasors
 
@@ -34,5 +34,4 @@ def converted_gate_set(
         keep_clifford=not no_clifford_gates,
         atol=atol,
     ).optimize_circuit(conv_circuit)
-    optimizers.DropEmptyMoments().optimize_circuit(conv_circuit)
-    return conv_circuit
+    return transformers.drop_empty_moments(conv_circuit)

cirq-core/cirq/contrib/quimb/Cirq-to-Tensor-Networks.ipynb

@@ -12,7 +12,7 @@
     "    import cirq\n",
     "except ImportError:\n",
     "    print(\"installing cirq...\")\n",
-    "    !pip install --quiet cirq\n",
+    "    !pip install --quiet cirq --pre\n",
     "    print(\"installed cirq.\")\n",
     "\n",
     "try:\n",
@@ -78,7 +78,7 @@
    "source": [
     "qubits = cirq.LineQubit.range(3)\n",
     "circuit = cirq.testing.random_circuit(qubits, n_moments=10, op_density=0.8, random_state=52)\n",
-    "cirq.DropEmptyMoments().optimize_circuit(circuit)\n",
+    "circuit = cirq.drop_empty_moments(circuit)\n",
     "SVGCircuit(circuit)"
    ]
   },
@@ -87,7 +87,9 @@
    "metadata": {},
    "source": [
     "### Circuit to Tensors\n",
-    "The circuit defines a tensor network representation. By default, the initial state is the `|0...0>` state (represented by the \"zero qubit\" operations labeled \"Q0\" in the legend. \"Q1\" are single qubit operations and \"Q2\" are two qubit operations. The open legs are the indices into the state vector and are of the form \"i{m}_q{n}\" where `m` is the time index (given by the returned `qubit_frontier` dictionary) and \"n\" is the qubit string."
+    "The circuit defines a tensor network representation. By default, the initial state is the `|0...0>` state (represented by the \"zero qubit\" operations labeled \"Q0\" in the legend. \"Q1\" are single qubit operations and \"Q2\" are two qubit operations. The open legs are the indices into the state vector and are of the form \"i{m}_q{n}\" where `m` is the time index (given by the returned `qubit_frontier` dictionary) and \"n\" is the qubit string.\n",
+    "\n",
+    "Note: this notebook relies on unreleased Cirq features. If you want to try these features, make sure you install cirq via `pip install cirq --pre`."
    ]
   },
   {
@@ -285,7 +287,7 @@
     "    circuit = cirq.testing.random_circuit(qubits, n_moments=n_moments, op_density=0.8)\n",
     "    noise_model = cirq.ConstantQubitNoiseModel(cirq.DepolarizingChannel(p=1e-3))\n",
     "    circuit = cirq.Circuit(noise_model.noisy_moments(circuit.moments, qubits))\n",
-    "    cirq.DropEmptyMoments().optimize_circuit(circuit)\n",
+    "    circuit = cirq.drop_empty_moments(circuit)\n",
     "    n_moments = len(circuit)\n",
     "    variables = {'circuit': circuit, 'qubits': qubits}\n",
     "\n",

cirq-core/cirq/contrib/quimb/Contract-a-Grid-Circuit.ipynb

@@ -12,7 +12,7 @@
     "    import cirq\n",
     "except ImportError:\n",
     "    print(\"installing cirq...\")\n",
-    "    !pip install --quiet cirq\n",
+    "    !pip install --quiet cirq --pre\n",
     "    print(\"installed cirq.\")\n",
     "\n",
     "try:\n",
@@ -28,7 +28,9 @@
    "metadata": {},
    "source": [
     "# Contract a Grid Circuit\n",
-    "Shallow circuits on a planar grid with low-weight observables permit easy contraction."
+    "Shallow circuits on a planar grid with low-weight observables permit easy contraction.\n",
+    "\n",
+    "Note: this notebook relies on unreleased Cirq features. If you want to try these features, make sure you install cirq via `pip install cirq --pre`."
    ]
   },
   {
@@ -207,8 +209,8 @@
     "ccq.MergeNQubitGates(n_qubits=2).optimize_circuit(compressed_c)\n",
     "ccq.MergeNQubitGates(n_qubits=1).optimize_circuit(compressed_c)\n",
     "\n",
-    "cirq.DropNegligible(tolerance=1e-6).optimize_circuit(compressed_c)\n",
-    "cirq.DropEmptyMoments().optimize_circuit(compressed_c)\n",
+    "compressed_c = cirq.drop_negligible_operations(compressed_c, atol=1e-6)\n",
+    "compressed_c = cirq.drop_empty_moments(compressed_c)\n",
     "print(len(list(compressed_c.all_operations())), len(compressed_c.all_qubits()))\n",
     "SVGCircuit(compressed_c)"
    ]

cirq-core/cirq/contrib/quimb/density_matrix_test.py

@@ -58,7 +58,7 @@ def test_tensor_density_matrix_3():
 def test_tensor_density_matrix_4():
     qubits = cirq.LineQubit.range(4)
     circuit = cirq.testing.random_circuit(qubits=qubits, n_moments=100, op_density=0.8)
-    cirq.DropEmptyMoments().optimize_circuit(circuit)
+    circuit = cirq.drop_empty_moments(circuit)
     noise_model = cirq.ConstantQubitNoiseModel(cirq.DepolarizingChannel(p=1e-3))
     circuit = cirq.Circuit(noise_model.noisy_moments(circuit.moments, qubits))
     rho1 = cirq.final_density_matrix(circuit, dtype=np.complex128)
@@ -69,7 +69,7 @@ def test_tensor_density_matrix_4():
 def test_tensor_density_matrix_gridqubit():
     qubits = cirq.GridQubit.rect(2, 2)
     circuit = cirq.testing.random_circuit(qubits=qubits, n_moments=10, op_density=0.8)
-    cirq.DropEmptyMoments().optimize_circuit(circuit)
+    circuit = cirq.drop_empty_moments(circuit)
     noise_model = cirq.ConstantQubitNoiseModel(cirq.DepolarizingChannel(p=1e-3))
     circuit = cirq.Circuit(noise_model.noisy_moments(circuit.moments, qubits))
     rho1 = cirq.final_density_matrix(circuit, dtype=np.complex128)

cirq-core/cirq/contrib/quimb/grid_circuits.py

@@ -137,10 +137,9 @@ def simplify_expectation_value_circuit(circuit_sand: cirq.Circuit):
     n_op = sum(1 for _ in circuit_sand.all_operations())
     while True:
         MergeNQubitGates(n_qubits=1).optimize_circuit(circuit_sand)
-        cirq.DropNegligible(tolerance=1e-6).optimize_circuit(circuit_sand)
+        circuit_sand = cirq.drop_negligible_operations(circuit_sand, atol=1e-6)
         MergeNQubitGates(n_qubits=2).optimize_circuit(circuit_sand)
-        cirq.DropNegligible(tolerance=1e-6)
-        cirq.DropEmptyMoments().optimize_circuit(circuit_sand)
+        circuit_sand = cirq.drop_empty_moments(circuit_sand)
         new_n_op = sum(1 for _ in circuit_sand.all_operations())
 
         if new_n_op < n_op:

cirq-core/cirq/devices/device.py

@@ -158,6 +158,11 @@ def validate_moment(self, moment: 'cirq.Moment') -> None:
         for operation in moment.operations:
             self.validate_operation(operation)
 
+    @_compat.deprecated(
+        deadline='v0.15',
+        fix='can_add_operation_into_moment will be removed in the future.'
+        ' Consider using device.validate_circuit instead.',
+    )
     def can_add_operation_into_moment(
         self, operation: 'cirq.Operation', moment: 'cirq.Moment'
     ) -> bool:

cirq-core/cirq/ion/ion_device_test.py

@@ -156,21 +156,22 @@ def num_qubits(self):
         d.validate_operation(NotImplementedOperation())
 
 
-def test_can_add_operation_into_moment():
-    d = ion_device(3)
-    q0 = cirq.LineQubit(0)
-    q1 = cirq.LineQubit(1)
-    q2 = cirq.LineQubit(2)
-    q3 = cirq.LineQubit(3)
-    circuit = cirq.Circuit()
-    circuit.append(cirq.XX(q0, q1))
-    for moment in circuit:
-        assert not d.can_add_operation_into_moment(cirq.XX(q2, q0), moment)
-        assert not d.can_add_operation_into_moment(cirq.XX(q1, q2), moment)
-        assert d.can_add_operation_into_moment(cirq.XX(q2, q3), moment)
-        assert d.can_add_operation_into_moment(cirq.Z(q3), moment)
-    circuit = cirq.Circuit([cirq.X(q0)])
-    assert d.can_add_operation_into_moment(cirq.XX(q1, q2), circuit[0])
+def test_can_add_operation_into_moment_device_deprecated():
+    with cirq.testing.assert_deprecated('can_add_operation_into_moment', deadline='v0.15', count=5):
+        d = ion_device(3)
+        q0 = cirq.LineQubit(0)
+        q1 = cirq.LineQubit(1)
+        q2 = cirq.LineQubit(2)
+        q3 = cirq.LineQubit(3)
+        circuit = cirq.Circuit()
+        circuit.append(cirq.XX(q0, q1))
+        for moment in circuit:
+            assert not d.can_add_operation_into_moment(cirq.XX(q2, q0), moment)
+            assert not d.can_add_operation_into_moment(cirq.XX(q1, q2), moment)
+            assert d.can_add_operation_into_moment(cirq.XX(q2, q3), moment)
+            assert d.can_add_operation_into_moment(cirq.Z(q3), moment)
+        circuit = cirq.Circuit([cirq.X(q0)])
+        assert d.can_add_operation_into_moment(cirq.XX(q1, q2), circuit[0])
 
 
 def test_ion_device_eq():

cirq-core/cirq/neutral_atoms/neutral_atom_devices_test.py

@@ -220,15 +220,16 @@ def test_validate_moment_errors():
         d2.validate_moment(m)
 
 
-def test_can_add_operation_into_moment_coverage():
-    d = square_device(2, 2)
-    q00 = cirq.GridQubit(0, 0)
-    q01 = cirq.GridQubit(0, 1)
-    q10 = cirq.GridQubit(1, 0)
-    m = cirq.Moment([cirq.X.on(q00)])
-    assert not d.can_add_operation_into_moment(cirq.X.on(q00), m)
-    assert not d.can_add_operation_into_moment(cirq.CZ.on(q01, q10), m)
-    assert d.can_add_operation_into_moment(cirq.Z.on(q01), m)
+def test_can_add_operation_into_moment_coverage_deprecated():
+    with cirq.testing.assert_deprecated('can_add_operation_into_moment', deadline='v0.15', count=3):
+        d = square_device(2, 2)
+        q00 = cirq.GridQubit(0, 0)
+        q01 = cirq.GridQubit(0, 1)
+        q10 = cirq.GridQubit(1, 0)
+        m = cirq.Moment([cirq.X.on(q00)])
+        assert not d.can_add_operation_into_moment(cirq.X.on(q00), m)
+        assert not d.can_add_operation_into_moment(cirq.CZ.on(q01, q10), m)
+        assert d.can_add_operation_into_moment(cirq.Z.on(q01), m)
 
 
 def test_validate_circuit_errors():

cirq-core/cirq/ops/pauli_string_phasor_test.py

@@ -250,8 +250,8 @@ def test_drop_negligible():
         cirq.PauliStringPhasor(cirq.PauliString({q0: cirq.Z})) ** 0.25,
         cirq.PauliStringPhasor(cirq.PauliString({q0: cirq.Z})) ** sym,
     )
-    cirq.DropNegligible().optimize_circuit(circuit)
-    cirq.DropEmptyMoments().optimize_circuit(circuit)
+    circuit = cirq.drop_negligible_operations(circuit)
+    circuit = cirq.drop_empty_moments(circuit)
     assert circuit == expected
 
 

cirq-core/cirq/optimizers/drop_empty_moments.py

@@ -16,8 +16,10 @@
 
 from cirq.circuits.circuit import Circuit
 from cirq.circuits import circuit as _circuit
+from cirq._compat import deprecated_class
 
 
+@deprecated_class(deadline='v1.0', fix='Use cirq.drop_empty_moments instead.')
 class DropEmptyMoments:
     """Removes empty moments from a circuit."""
 

cirq-core/cirq/optimizers/drop_empty_moments_test.py

@@ -16,9 +16,10 @@
 
 
 def assert_optimizes(before, after):
-    opt = cirq.DropEmptyMoments()
-    opt.optimize_circuit(before)
-    assert before == after
+    with cirq.testing.assert_deprecated("Use cirq.drop_empty_moments", deadline='v1.0'):
+        opt = cirq.DropEmptyMoments()
+        opt.optimize_circuit(before)
+        assert before == after
 
 
 def test_drop():

cirq-core/cirq/optimizers/drop_negligible.py

@@ -18,11 +18,13 @@
 
 from cirq import protocols
 from cirq.circuits import circuit as _circuit
+from cirq._compat import deprecated_class
 
 if TYPE_CHECKING:
     from cirq import ops
 
 
+@deprecated_class(deadline='v1.0', fix='Use cirq.drop_negligible_operations instead.')
 class DropNegligible:
     """An optimization pass that removes operations with tiny effects."""
 

cirq-core/cirq/optimizers/drop_negligible_test.py

@@ -15,28 +15,26 @@
 import cirq
 
 
-def assert_optimizes(optimizer, initial_circuit: cirq.Circuit, expected_circuit: cirq.Circuit):
-    circuit = cirq.Circuit(initial_circuit)
-    optimizer.optimize_circuit(circuit)
-    assert circuit == expected_circuit
+def assert_optimizes(atol: float, initial_circuit: cirq.Circuit, expected_circuit: cirq.Circuit):
+    with cirq.testing.assert_deprecated("Use cirq.drop_negligible_operations", deadline='v1.0'):
+        optimizer = cirq.DropNegligible(atol)
+        circuit = cirq.Circuit(initial_circuit)
+        optimizer.optimize_circuit(circuit)
+        assert circuit == expected_circuit
 
 
 def test_leaves_big():
-    drop = cirq.DropNegligible(0.001)
     a = cirq.NamedQubit('a')
     circuit = cirq.Circuit([cirq.Moment([cirq.Z(a) ** 0.1])])
 
-    assert_optimizes(optimizer=drop, initial_circuit=circuit, expected_circuit=circuit)
+    assert_optimizes(0.001, initial_circuit=circuit, expected_circuit=circuit)
 
 
 def test_clears_small():
-    drop = cirq.DropNegligible(0.001)
     a = cirq.NamedQubit('a')
     circuit = cirq.Circuit([cirq.Moment([cirq.Z(a) ** 0.000001])])
 
-    assert_optimizes(
-        optimizer=drop, initial_circuit=circuit, expected_circuit=cirq.Circuit([cirq.Moment()])
-    )
+    assert_optimizes(0.001, initial_circuit=circuit, expected_circuit=cirq.Circuit([cirq.Moment()]))
 
 
 def test_clears_known_empties_even_at_zero_tolerance():
@@ -45,12 +43,12 @@ def test_clears_known_empties_even_at_zero_tolerance():
         cirq.Z(a) ** 0, cirq.Y(a) ** 0.0000001, cirq.X(a) ** -0.0000001, cirq.CZ(a, b) ** 0
     )
     assert_optimizes(
-        optimizer=cirq.DropNegligible(tolerance=0.001),
+        0.001,
         initial_circuit=circuit,
         expected_circuit=cirq.Circuit([cirq.Moment()] * 4),
     )
     assert_optimizes(
-        optimizer=cirq.DropNegligible(tolerance=0),
+        0,
         initial_circuit=circuit,
         expected_circuit=cirq.Circuit(
             [