Remove decompose_operation deprecation from device.

cirq-core/cirq/devices/device.py

@@ -24,16 +24,6 @@
 class Device(metaclass=abc.ABCMeta):
     """Hardware constraints for validating circuits."""
 
-    @_compat.deprecated(deadline='v0.15', fix='Devices will no longer decompose operations.')
-    def decompose_operation(self, operation: 'cirq.Operation') -> 'cirq.OP_TREE':
-        """Returns a device-valid decomposition for the given operation.
-
-        This method is used when adding operations into circuits with a device
-        specified, to avoid spurious failures due to e.g. using a Hadamard gate
-        that must be decomposed into native gates.
-        """
-        return operation
-
     @property
     def metadata(self) -> Optional['DeviceMetadata']:
         """Returns the associated Metadata with the device if applicable.

cirq-core/cirq/devices/device_test.py

@@ -3,16 +3,6 @@
 import cirq
 
 
-def test_decompose_operation_deprecated():
-    q0 = cirq.GridQubit(0, 0)
-
-    class RawDevice(cirq.Device):
-        pass
-
-    with cirq.testing.assert_deprecated('decompose', deadline='v0.15'):
-        RawDevice().decompose_operation(cirq.H(q0))
-
-
 def test_device_metadata():
     class RawDevice(cirq.Device):
         pass

cirq-core/cirq/ion/ion_device.py

@@ -82,12 +82,6 @@ def metadata(self) -> devices.DeviceMetadata:
     def qubit_set(self) -> FrozenSet['cirq.LineQubit']:
         return self.qubits
 
-    @_compat.deprecated(
-        fix='Use cirq.ConvertToIonGates() instead to decompose operations.', deadline='v0.15'
-    )
-    def decompose_operation(self, operation: ops.Operation) -> ops.OP_TREE:
-        return convert_to_ion_gates.ConvertToIonGates().convert_one(operation)
-
     def decompose_circuit(self, circuit: circuits.Circuit) -> circuits.Circuit:
         return convert_to_ion_gates.ConvertToIonGates().convert_circuit(circuit)
 

cirq-core/cirq/ion/ion_device_test.py

@@ -89,24 +89,6 @@ def test_init_timedelta():
         _ = d.duration_of(cirq.testing.SingleQubitGate().on(q0))
 
 
-def test_decomposition_deprecated():
-    d = ion_device(3)
-    q0 = cirq.LineQubit(0)
-    q1 = cirq.LineQubit(1)
-    with cirq.testing.assert_deprecated('ConvertToIonGates', deadline='v0.15'):
-        assert d.decompose_operation(cirq.H(q0)) == [
-            cirq.rx(np.pi * 1.0).on(cirq.LineQubit(0)),
-            cirq.ry(np.pi * -0.5).on(cirq.LineQubit(0)),
-        ]
-    circuit = cirq.Circuit()
-    circuit.append([cirq.X(q0), cirq.CNOT(q0, q1)])
-    ion_circuit = d.decompose_circuit(circuit)
-    d.validate_circuit(ion_circuit)
-    cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
-        circuit, ion_circuit, atol=1e-6
-    )
-
-
 def test_repr():
     d = ion_device(3)
 

cirq-core/cirq/neutral_atoms/neutral_atom_devices.py

@@ -113,13 +113,6 @@ def qubit_set(self) -> FrozenSet['cirq.GridQubit']:
     def qubit_list(self):
         return [qubit for qubit in self.qubits]
 
-    @_compat.deprecated(
-        fix='Use cirq.ConvertToNeutralAtomGates() instead to decompose operations.',
-        deadline='v0.15',
-    )
-    def decompose_operation(self, operation: ops.Operation) -> ops.OP_TREE:
-        return ConvertToNeutralAtomGates().convert(operation)
-
     def duration_of(self, operation: ops.Operation):
         """Provides the duration of the given operation on this device.
 

cirq-core/cirq/neutral_atoms/neutral_atom_devices_test.py

@@ -112,13 +112,6 @@ def test_init_errors():
         )
 
 
-def test_decompose_error_deprecated():
-    d = square_device(2, 2, holes=[cirq.GridQubit(1, 1)])
-    with cirq.testing.assert_deprecated('ConvertToNeutralAtomGates', deadline='v0.15', count=2):
-        for op in d.decompose_operation((cirq.CCZ**1.5).on(*(d.qubit_list()))):
-            d.validate_operation(op)
-
-
 def test_validate_gate_errors():
     d = square_device(1, 1)
 

cirq-core/cirq/testing/devices.py

@@ -66,10 +66,5 @@ def validate_operation(self, operation: ops.Operation) -> None:
                 if not cast(devices.GridQubit, p).is_adjacent(q):
                     raise ValueError(f'Non-local interaction: {operation!r}.')
 
-    def decompose_operation(self, operation: 'ops.Operation') -> 'ops.OP_TREE':
-        if isinstance(operation.gate, self.auto_decompose_gates):
-            return protocols.decompose(operation)
-        return operation
-
     def __repr__(self):
         return self._repr

cirq-google/cirq_google/devices/xmon_device.py

@@ -68,20 +68,6 @@ def metadata(self) -> cirq.GridDeviceMetadata:
     def qubit_set(self) -> FrozenSet[cirq.GridQubit]:
         return self.qubits
 
-    @_compat.deprecated(
-        deadline='v0.15',
-        fix='XmonDevice.decompose_operation is deprecated. '
-        'Please use cirq.optimize_for_target_gateset() and cirq.CZTargetGateset.',
-    )
-    def decompose_operation(self, operation: cirq.Operation) -> cirq.OP_TREE:
-        if operation.gate is not None and self.is_supported_gate(operation.gate):
-            return operation
-        return [
-            cirq.optimize_for_target_gateset(
-                cirq.Circuit(operation), gateset=cirq.CZTargetGateset(allow_partial_czs=True)
-            ).all_operations()
-        ]
-
     def neighbors_of(self, qubit: cirq.GridQubit):
         """Returns the qubits that the given qubit can interact with."""
         possibles = [

cirq-google/cirq_google/devices/xmon_device_test.py

@@ -190,14 +190,6 @@ def test_validate_measurement_non_adjacent_qubits_ok():
     )
 
 
-@mock.patch.dict(os.environ, clear='CIRQ_TESTING')
-def test_decompose_operation_deprecated():
-    d = square_device(3, 3)
-
-    with cirq.testing.assert_deprecated('decompose', deadline='v0.15'):
-        _ = d.decompose_operation(cirq.H(cirq.GridQubit(1, 1)))
-
-
 @mock.patch.dict(os.environ, clear='CIRQ_TESTING')
 def test_validate_operation_existing_qubits():
     d = square_device(3, 3, holes=[cirq.GridQubit(1, 1)])

cirq-ionq/cirq_ionq/ionq_devices.py

@@ -90,12 +90,6 @@ def validate_operation(self, operation: cirq.Operation):
     def is_api_gate(self, operation: cirq.Operation) -> bool:
         return operation in _VALID_GATES
 
-    @_compat.deprecated(
-        fix='Use cirq_ionq.decompose_to_device operation instead.', deadline='v0.15'
-    )
-    def decompose_operation(self, operation: cirq.Operation) -> cirq.OP_TREE:
-        return decompose_to_device(operation)
-
 
 def decompose_to_device(operation: cirq.Operation, atol: float = 1e-8) -> cirq.OP_TREE:
     """Decompose operation to ionq native operations.

cirq-ionq/cirq_ionq/ionq_devices_test.py

@@ -120,15 +120,6 @@ def test_validate_circuit_valid():
         device.validate_circuit(circuit)
 
 
-@pytest.mark.parametrize('gate', VALID_GATES)
-def test_decompose_leaves_supported_alone_deprecated(gate):
-    qubits = cirq.LineQubit.range(gate.num_qubits())
-    device = ionq.IonQAPIDevice(qubits=qubits)
-    operation = gate(*qubits)
-    with cirq.testing.assert_deprecated('decompose_to_device', deadline='v0.15'):
-        assert device.decompose_operation(operation) == operation
-
-
 @pytest.mark.parametrize('gate', VALID_GATES)
 def test_decompose_leaves_supported_alone(gate):
     qubits = cirq.LineQubit.range(gate.num_qubits())
@@ -139,20 +130,6 @@ def test_decompose_leaves_supported_alone(gate):
 VALID_DECOMPOSED_GATES = cirq.Gateset(cirq.XPowGate, cirq.ZPowGate, cirq.CNOT)
 
 
-def test_decompose_single_qubit_matrix_gate_deprecated():
-    q = cirq.LineQubit(0)
-    device = ionq.IonQAPIDevice(qubits=[q])
-    for _ in range(100):
-        gate = cirq.MatrixGate(cirq.testing.random_unitary(2))
-        circuit = cirq.Circuit(gate(q))
-        with cirq.testing.assert_deprecated('decompose_to_device', deadline='v0.15'):
-            decomposed_circuit = cirq.Circuit(*device.decompose_operation(gate(q)))
-        cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
-            circuit, decomposed_circuit, atol=1e-8
-        )
-        assert VALID_DECOMPOSED_GATES.validate(decomposed_circuit)
-
-
 def test_decompose_single_qubit_matrix_gate():
     q = cirq.LineQubit(0)
     for _ in range(100):
@@ -165,20 +142,6 @@ def test_decompose_single_qubit_matrix_gate():
         assert VALID_DECOMPOSED_GATES.validate(decomposed_circuit)
 
 
-def test_decompose_two_qubit_matrix_gate_deprecated():
-    q0, q1 = cirq.LineQubit.range(2)
-    device = ionq.IonQAPIDevice(qubits=[q0, q1])
-    for _ in range(10):
-        gate = cirq.MatrixGate(cirq.testing.random_unitary(4))
-        circuit = cirq.Circuit(gate(q0, q1))
-        with cirq.testing.assert_deprecated('decompose_to_device', deadline='v0.15'):
-            decomposed_circuit = cirq.Circuit(*device.decompose_operation(gate(q0, q1)))
-        cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
-            circuit, decomposed_circuit, atol=1e-8
-        )
-        assert VALID_DECOMPOSED_GATES.validate(decomposed_circuit)
-
-
 def test_decompose_two_qubit_matrix_gate():
     q0, q1 = cirq.LineQubit.range(2)
     for _ in range(10):
@@ -191,15 +154,6 @@ def test_decompose_two_qubit_matrix_gate():
         assert VALID_DECOMPOSED_GATES.validate(decomposed_circuit)
 
 
-def test_decompose_unsupported_gate_deprecated():
-    q0, q1, q2 = cirq.LineQubit.range(3)
-    device = ionq.IonQAPIDevice(qubits=[q0, q1, q2])
-    op = cirq.CCZ(q0, q1, q2)
-    with pytest.raises(ValueError, match='not supported'):
-        with cirq.testing.assert_deprecated('decompose_to_device', deadline='v0.15'):
-            _ = device.decompose_operation(op)
-
-
 def test_decompose_unsupported_gate():
     q0, q1, q2 = cirq.LineQubit.range(3)
     op = cirq.CCZ(q0, q1, q2)

cirq-pasqal/cirq_pasqal/pasqal_device.py

@@ -102,24 +102,6 @@ def qubit_set(self) -> FrozenSet[cirq.Qid]:
     def qubit_list(self):
         return [qubit for qubit in self.qubits]
 
-    @_compat.deprecated(
-        fix='Use PasqalConverter() to decompose operation instead.', deadline='v0.15'
-    )
-    def decompose_operation(self, operation: cirq.Operation) -> 'cirq.OP_TREE':
-
-        decomposition = [operation]
-
-        if not isinstance(operation, cirq.GateOperation):
-            raise TypeError(f"{operation!r} is not a gate operation.")
-
-        # Try to decompose the operation into elementary device operations
-        if not self.is_pasqal_device_op(operation):
-            decomposition = PasqalConverter().pasqal_convert(
-                operation, keep=self.is_pasqal_device_op
-            )
-
-        return decomposition
-
     def is_pasqal_device_op(self, op: cirq.Operation) -> bool:
         if not isinstance(op, cirq.Operation):
             raise ValueError('Got unknown operation:', op)

cirq-pasqal/cirq_pasqal/pasqal_device_test.py

@@ -98,44 +98,6 @@ def test_is_pasqal_device_op():
     assert not d2.is_pasqal_device_op(op1(TwoDQubit(0, 0), TwoDQubit(0, 1)))
 
 
-def test_decompose_operation_deprecated():
-    d = generic_device(3)
-    with cirq.testing.assert_deprecated('decompose', deadline='v0.15', count=2):
-        for op in d.decompose_operation((cirq.CCZ**1.5).on(*(d.qubit_list()))):
-            d.validate_operation(op)
-
-    p_qubits = [cirq.LineQubit(3), cirq.LineQubit(4)]
-    d = PasqalVirtualDevice(1.0, p_qubits)
-    op = (cirq.ops.CNOT).on(*(d.qubit_list())) ** 2
-
-    with cirq.testing.assert_deprecated('decompose', deadline='v0.15', count=2):
-        assert d.decompose_operation(op) == []
-
-
-def test_pasqal_converter_deprecated():
-    q = cirq.NamedQubit.range(2, prefix='q')
-    g = cirq.testing.TwoQubitGate()
-
-    class FakeOperation(cirq.ops.GateOperation):
-        def __init__(self, gate, qubits):
-            self._gate = gate
-            self._qubits = qubits
-
-        @property
-        def qubits(self):
-            return self._qubits
-
-        def with_qubits(self, *new_qubits):
-            return FakeOperation(self._gate, new_qubits)
-
-    op = FakeOperation(g, q).with_qubits(*q)
-    d = PasqalDevice(q)
-
-    with pytest.raises(TypeError, match="Don't know how to work with"):
-        with cirq.testing.assert_deprecated('decompose', deadline='v0.15', count=2):
-            d.decompose_operation(op)
-
-
 def test_validate_operation_errors():
     d = generic_device(3)
 

docs/tutorials/educators/ion_device.ipynb

@@ -322,7 +322,7 @@
     "op = cirq.CNOT(ion_device.at(0), ion_device.at(1))\n",
     "\n",
     "# Decompose it for the IonDevice.\n",
-    "ion_device_ops = ion_device.decompose_operation(op)\n",
+    "ion_device_ops = cirq.ConvertToIonGates().decompose_operation(op)\n",
     "\n",
     "# Print the sequence of operations to implement a CNOT.\n",
     "print(\"Sequence of IonDevice operations for a CNOT:\\n\")\n",