cirq-core 1.2.0.dev20230717232332__py3-none-any.whl → 1.3.0__py3-none-any.whl

cirq/qis/clifford_tableau.py

@@ -275,8 +275,7 @@ class CliffordTableau(StabilizerState):
 
     def __eq__(self, other):
         if not isinstance(other, type(self)):
-            # coverage: ignore
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         return (
             self.n == other.n
             and np.array_equal(self.rs, other.rs)
@@ -551,7 +550,7 @@ class CliffordTableau(StabilizerState):
         if exponent % 2 == 0:
             return
         if exponent % 0.5 != 0.0:
-            raise ValueError('X exponent must be half integer')  # coverage: ignore
+            raise ValueError('X exponent must be half integer')  # pragma: no cover
         effective_exponent = exponent % 2
         if effective_exponent == 0.5:
             self.xs[:, axis] ^= self.zs[:, axis]
@@ -566,7 +565,7 @@ class CliffordTableau(StabilizerState):
         if exponent % 2 == 0:
             return
         if exponent % 0.5 != 0.0:
-            raise ValueError('Y exponent must be half integer')  # coverage: ignore
+            raise ValueError('Y exponent must be half integer')  # pragma: no cover
         effective_exponent = exponent % 2
         if effective_exponent == 0.5:
             self.rs[:] ^= self.xs[:, axis] & (~self.zs[:, axis])
@@ -587,7 +586,7 @@ class CliffordTableau(StabilizerState):
         if exponent % 2 == 0:
             return
         if exponent % 0.5 != 0.0:
-            raise ValueError('Z exponent must be half integer')  # coverage: ignore
+            raise ValueError('Z exponent must be half integer')  # pragma: no cover
         effective_exponent = exponent % 2
         if effective_exponent == 0.5:
             self.rs[:] ^= self.xs[:, axis] & self.zs[:, axis]
@@ -602,7 +601,7 @@ class CliffordTableau(StabilizerState):
         if exponent % 2 == 0:
             return
         if exponent % 1 != 0:
-            raise ValueError('H exponent must be integer')  # coverage: ignore
+            raise ValueError('H exponent must be integer')  # pragma: no cover
         self.apply_y(axis, 0.5)
         self.apply_x(axis)
 
@@ -612,7 +611,7 @@ class CliffordTableau(StabilizerState):
         if exponent % 2 == 0:
             return
         if exponent % 1 != 0:
-            raise ValueError('CZ exponent must be integer')  # coverage: ignore
+            raise ValueError('CZ exponent must be integer')  # pragma: no cover
         (self.xs[:, target_axis], self.zs[:, target_axis]) = (
             self.zs[:, target_axis].copy(),
             self.xs[:, target_axis].copy(),
@@ -637,7 +636,7 @@ class CliffordTableau(StabilizerState):
         if exponent % 2 == 0:
             return
         if exponent % 1 != 0:
-            raise ValueError('CX exponent must be integer')  # coverage: ignore
+            raise ValueError('CX exponent must be integer')  # pragma: no cover
         self.rs[:] ^= (
             self.xs[:, control_axis]
             & self.zs[:, target_axis]

cirq/qis/measures.py

@@ -211,7 +211,7 @@ def _numpy_arrays_to_state_vectors_or_density_matrices(
             state2.shape[0] if state2.ndim == 2 else np.prod(state2.shape, dtype=np.int64).item()
         )
         if dim1 != dim2:
-            raise ValueError('Mismatched dimensions in given states: ' f'{dim1} and {dim2}.')
+            raise ValueError(f'Mismatched dimensions in given states: {dim1} and {dim2}.')
         if qid_shape is None:
             qid_shape = (dim1,)
         else:

cirq/qis/states.py

@@ -314,7 +314,7 @@ def density_matrix(
         ValueError: Invalid density matrix.
     """
     if state.ndim != 2 or state.shape[0] != state.shape[1]:
-        raise ValueError('A density matrix must be a square matrix. ' f'Got shape {state.shape}.')
+        raise ValueError(f'A density matrix must be a square matrix. Got shape {state.shape}.')
     dim, _ = state.shape
     if qid_shape is None:
         qid_shape = _infer_qid_shape_from_dimension(dim)
@@ -524,8 +524,7 @@ class _QidShapeSet:
                 'with the corresponding qudit dimensions being at least '
                 f'{self.min_qudit_dimensions}.'
             )
-        if len(self.explicit_qid_shapes) > 1:
-            # coverage: ignore
+        if len(self.explicit_qid_shapes) > 1:  # pragma: no cover
             raise ValueError(
                 f'Qid shape is ambiguous: Could be any one of {self.explicit_qid_shapes}.'
             )

cirq/sim/__init__.py

@@ -68,6 +68,8 @@ from cirq.sim.state_vector import measure_state_vector, sample_state_vector, Sta
 
 from cirq.sim.state_vector_simulation_state import StateVectorSimulationState
 
+from cirq.sim.classical_simulator import ClassicalStateSimulator
+
 from cirq.sim.state_vector_simulator import (
     SimulatesIntermediateStateVector,
     StateVectorStepResult,

cirq/sim/classical_simulator.py

@@ -0,0 +1,107 @@
+# Copyright 2023 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 Dict
+from collections import defaultdict
+from cirq.sim.simulator import SimulatesSamples
+from cirq import ops, protocols
+from cirq.study.resolver import ParamResolver
+from cirq.circuits.circuit import AbstractCircuit
+from cirq.ops.raw_types import Qid
+import numpy as np
+
+
+def _is_identity(op: ops.Operation) -> bool:
+    if isinstance(op.gate, (ops.XPowGate, ops.CXPowGate, ops.CCXPowGate, ops.SwapPowGate)):
+        return op.gate.exponent % 2 == 0
+    return False
+
+
+class ClassicalStateSimulator(SimulatesSamples):
+    """A simulator that accepts only gates with classical counterparts.
+
+    This simulator evolves a single state, using only gates that output a single state for each
+    input state. The simulator runs in linear time, at the cost of not supporting superposition.
+    It can be used to estimate costs and simulate circuits for simple non-quantum algorithms using
+    many more qubits than fully capable quantum simulators.
+
+    The supported gates are:
+        - cirq.X
+        - cirq.CNOT
+        - cirq.SWAP
+        - cirq.TOFFOLI
+        - cirq.measure
+
+    Args:
+        circuit: The circuit to simulate.
+        param_resolver: Parameters to run with the program.
+        repetitions: Number of times to repeat the run. It is expected that
+            this is validated greater than zero before calling this method.
+
+    Returns:
+        A dictionary mapping measurement keys to measurement results.
+
+    Raises:
+        ValueError: If
+            - one of the gates is not an X, CNOT, SWAP, TOFFOLI or a measurement.
+            - A measurement key is used for measurements on different numbers of qubits.
+    """
+
+    def _run(
+        self, circuit: AbstractCircuit, param_resolver: ParamResolver, repetitions: int
+    ) -> Dict[str, np.ndarray]:
+        results_dict: Dict[str, np.ndarray] = {}
+        values_dict: Dict[Qid, int] = defaultdict(int)
+        param_resolver = param_resolver or ParamResolver({})
+        resolved_circuit = protocols.resolve_parameters(circuit, param_resolver)
+
+        for moment in resolved_circuit:
+            for op in moment:
+                if _is_identity(op):
+                    continue
+                if op.gate == ops.X:
+                    (q,) = op.qubits
+                    values_dict[q] ^= 1
+                elif op.gate == ops.CNOT:
+                    c, q = op.qubits
+                    values_dict[q] ^= values_dict[c]
+                elif op.gate == ops.SWAP:
+                    a, b = op.qubits
+                    values_dict[a], values_dict[b] = values_dict[b], values_dict[a]
+                elif op.gate == ops.TOFFOLI:
+                    c1, c2, q = op.qubits
+                    values_dict[q] ^= values_dict[c1] & values_dict[c2]
+                elif protocols.is_measurement(op):
+                    measurement_values = np.array(
+                        [[[values_dict[q] for q in op.qubits]]] * repetitions, dtype=np.uint8
+                    )
+                    key = op.gate.key  # type: ignore
+                    if key in results_dict:
+                        if op._num_qubits_() != results_dict[key].shape[-1]:
+                            raise ValueError(
+                                f'Measurement shape {len(measurement_values)} does not match '
+                                f'{results_dict[key].shape[-1]} in {key}.'
+                            )
+                        results_dict[key] = np.concatenate(
+                            (results_dict[key], measurement_values), axis=1
+                        )
+                    else:
+                        results_dict[key] = measurement_values
+                else:
+                    raise ValueError(
+                        f'{op} is not one of cirq.X, cirq.CNOT, cirq.SWAP, '
+                        'cirq.CCNOT, or a measurement'
+                    )
+
+        return results_dict

cirq/sim/classical_simulator_test.py

@@ -0,0 +1,207 @@
+# Copyright 2023 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 numpy as np
+import pytest
+import cirq
+import sympy
+
+
+def test_x_gate():
+    q0, q1 = cirq.LineQubit.range(2)
+    circuit = cirq.Circuit()
+    circuit.append(cirq.X(q0))
+    circuit.append(cirq.X(q1))
+    circuit.append(cirq.X(q1))
+    circuit.append(cirq.measure((q0, q1), key='key'))
+    expected_results = {'key': np.array([[[1, 0]]], dtype=np.uint8)}
+    sim = cirq.ClassicalStateSimulator()
+    results = sim.run(circuit, param_resolver=None, repetitions=1).records
+    np.testing.assert_equal(results, expected_results)
+
+
+def test_CNOT():
+    q0, q1 = cirq.LineQubit.range(2)
+    circuit = cirq.Circuit()
+    circuit.append(cirq.X(q0))
+    circuit.append(cirq.CNOT(q0, q1))
+    circuit.append(cirq.measure(q1, key='key'))
+    expected_results = {'key': np.array([[[1]]], dtype=np.uint8)}
+    sim = cirq.ClassicalStateSimulator()
+    results = sim.run(circuit, param_resolver=None, repetitions=1).records
+    np.testing.assert_equal(results, expected_results)
+
+
+def test_Swap():
+    q0, q1 = cirq.LineQubit.range(2)
+    circuit = cirq.Circuit()
+    circuit.append(cirq.X(q0))
+    circuit.append(cirq.SWAP(q0, q1))
+    circuit.append(cirq.measure((q0, q1), key='key'))
+    expected_results = {'key': np.array([[[0, 1]]], dtype=np.uint8)}
+    sim = cirq.ClassicalStateSimulator()
+    results = sim.run(circuit, param_resolver=None, repetitions=1).records
+    np.testing.assert_equal(results, expected_results)
+
+
+def test_CCNOT():
+    q0, q1, q2 = cirq.LineQubit.range(3)
+    circuit = cirq.Circuit()
+    circuit.append(cirq.CCNOT(q0, q1, q2))
+    circuit.append(cirq.measure((q0, q1, q2), key='key'))
+    circuit.append(cirq.X(q0))
+    circuit.append(cirq.CCNOT(q0, q1, q2))
+    circuit.append(cirq.measure((q0, q1, q2), key='key'))
+    circuit.append(cirq.X(q1))
+    circuit.append(cirq.X(q0))
+    circuit.append(cirq.CCNOT(q0, q1, q2))
+    circuit.append(cirq.measure((q0, q1, q2), key='key'))
+    circuit.append(cirq.X(q0))
+    circuit.append(cirq.CCNOT(q0, q1, q2))
+    circuit.append(cirq.measure((q0, q1, q2), key='key'))
+    expected_results = {
+        'key': np.array([[[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 1]]], dtype=np.uint8)
+    }
+    sim = cirq.ClassicalStateSimulator()
+    results = sim.run(circuit, param_resolver=None, repetitions=1).records
+    np.testing.assert_equal(results, expected_results)
+
+
+def test_measurement_gate():
+    q0, q1 = cirq.LineQubit.range(2)
+    circuit = cirq.Circuit()
+    circuit.append(cirq.measure((q0, q1), key='key'))
+    expected_results = {'key': np.array([[[0, 0]]], dtype=np.uint8)}
+    sim = cirq.ClassicalStateSimulator()
+    results = sim.run(circuit, param_resolver=None, repetitions=1).records
+    np.testing.assert_equal(results, expected_results)
+
+
+def test_qubit_order():
+    q0, q1 = cirq.LineQubit.range(2)
+    circuit = cirq.Circuit()
+    circuit.append(cirq.CNOT(q0, q1))
+    circuit.append(cirq.X(q0))
+    circuit.append(cirq.measure((q0, q1), key='key'))
+    expected_results = {'key': np.array([[[1, 0]]], dtype=np.uint8)}
+    sim = cirq.ClassicalStateSimulator()
+    results = sim.run(circuit, param_resolver=None, repetitions=1).records
+    np.testing.assert_equal(results, expected_results)
+
+
+def test_same_key_instances():
+    q0, q1 = cirq.LineQubit.range(2)
+    circuit = cirq.Circuit()
+    circuit.append(cirq.measure((q0, q1), key='key'))
+    circuit.append(cirq.X(q0))
+    circuit.append(cirq.measure((q0, q1), key='key'))
+    expected_results = {'key': np.array([[[0, 0], [1, 0]]], dtype=np.uint8)}
+    sim = cirq.ClassicalStateSimulator()
+    results = sim.run(circuit, param_resolver=None, repetitions=1).records
+    np.testing.assert_equal(results, expected_results)
+
+
+def test_same_key_instances_order():
+    q0, q1 = cirq.LineQubit.range(2)
+    circuit = cirq.Circuit()
+    circuit.append(cirq.X(q0))
+    circuit.append(cirq.measure((q0, q1), key='key'))
+    circuit.append(cirq.X(q0))
+    circuit.append(cirq.measure((q1, q0), key='key'))
+    expected_results = {'key': np.array([[[1, 0], [0, 0]]], dtype=np.uint8)}
+    sim = cirq.ClassicalStateSimulator()
+    results = sim.run(circuit, param_resolver=None, repetitions=1).records
+    np.testing.assert_equal(results, expected_results)
+
+
+def test_repetitions():
+    q0 = cirq.LineQubit.range(1)
+    circuit = cirq.Circuit()
+    circuit.append(cirq.measure(q0, key='key'))
+    expected_results = {
+        'key': np.array(
+            [[[0]], [[0]], [[0]], [[0]], [[0]], [[0]], [[0]], [[0]], [[0]], [[0]]], dtype=np.uint8
+        )
+    }
+    sim = cirq.ClassicalStateSimulator()
+    results = sim.run(circuit, param_resolver=None, repetitions=10).records
+    np.testing.assert_equal(results, expected_results)
+
+
+def test_multiple_gates():
+    q0, q1 = cirq.LineQubit.range(2)
+    circuit = cirq.Circuit()
+    circuit.append(cirq.X(q0))
+    circuit.append(cirq.CNOT(q0, q1))
+    circuit.append(cirq.CNOT(q0, q1))
+    circuit.append(cirq.CNOT(q0, q1))
+    circuit.append(cirq.X(q1))
+    circuit.append(cirq.measure((q0, q1), key='key'))
+    expected_results = {'key': np.array([[[1, 0]]], dtype=np.uint8)}
+    sim = cirq.ClassicalStateSimulator()
+    results = sim.run(circuit, param_resolver=None, repetitions=1).records
+    np.testing.assert_equal(results, expected_results)
+
+
+def test_multiple_gates_order():
+    q0, q1 = cirq.LineQubit.range(2)
+    circuit = cirq.Circuit()
+    circuit.append(cirq.X(q0))
+    circuit.append(cirq.CNOT(q0, q1))
+    circuit.append(cirq.CNOT(q1, q0))
+    circuit.append(cirq.measure((q0, q1), key='key'))
+    expected_results = {'key': np.array([[[0, 1]]], dtype=np.uint8)}
+    sim = cirq.ClassicalStateSimulator()
+    results = sim.run(circuit, param_resolver=None, repetitions=1).records
+    np.testing.assert_equal(results, expected_results)
+
+
+def test_param_resolver():
+    gate = cirq.CNOT ** sympy.Symbol('t')
+    q0, q1 = cirq.LineQubit.range(2)
+    circuit = cirq.Circuit()
+    circuit.append(cirq.X(q0))
+    circuit.append(gate(q0, q1))
+    circuit.append(cirq.measure((q1), key='key'))
+    resolver = cirq.ParamResolver({'t': 0})
+    sim = cirq.ClassicalStateSimulator()
+    results_with_parameter_zero = sim.run(circuit, param_resolver=resolver, repetitions=1).records
+    resolver = cirq.ParamResolver({'t': 1})
+    results_with_parameter_one = sim.run(circuit, param_resolver=resolver, repetitions=1).records
+    np.testing.assert_equal(results_with_parameter_zero, {'key': np.array([[[0]]], dtype=np.uint8)})
+    np.testing.assert_equal(results_with_parameter_one, {'key': np.array([[[1]]], dtype=np.uint8)})
+
+
+def test_unknown_gates():
+    gate = cirq.Y
+    q = cirq.LineQubit(0)
+    circuit = cirq.Circuit(gate(q), cirq.measure((q), key='key'))
+    sim = cirq.ClassicalStateSimulator()
+    with pytest.raises(ValueError):
+        _ = sim.run(circuit).records
+
+
+def test_incompatible_measurements():
+    qs = cirq.LineQubit.range(2)
+    c = cirq.Circuit(cirq.measure(qs, key='key'), cirq.measure(qs[0], key='key'))
+    sim = cirq.ClassicalStateSimulator()
+    with pytest.raises(ValueError):
+        _ = sim.run(c)
+
+
+def test_compatible_measurement():
+    qs = cirq.LineQubit.range(2)
+    c = cirq.Circuit(cirq.measure(qs, key='key'), cirq.X.on_each(qs), cirq.measure(qs, key='key'))
+    sim = cirq.ClassicalStateSimulator()
+    res = sim.run(c, repetitions=3).records
+    np.testing.assert_equal(res['key'], np.array([[[0, 0], [1, 1]]] * 3, dtype=np.uint8))

cirq/sim/clifford/clifford_simulator_test.py

@@ -373,19 +373,19 @@ def test_clifford_circuit_2(qubits, split):
         x = np.random.randint(7)
 
         if x == 0:
-            circuit.append(cirq.X(np.random.choice(qubits)))  # coverage: ignore
+            circuit.append(cirq.X(np.random.choice(qubits)))  # pragma: no cover
         elif x == 1:
-            circuit.append(cirq.Z(np.random.choice(qubits)))  # coverage: ignore
+            circuit.append(cirq.Z(np.random.choice(qubits)))  # pragma: no cover
         elif x == 2:
-            circuit.append(cirq.Y(np.random.choice(qubits)))  # coverage: ignore
+            circuit.append(cirq.Y(np.random.choice(qubits)))  # pragma: no cover
         elif x == 3:
-            circuit.append(cirq.S(np.random.choice(qubits)))  # coverage: ignore
+            circuit.append(cirq.S(np.random.choice(qubits)))  # pragma: no cover
         elif x == 4:
-            circuit.append(cirq.H(np.random.choice(qubits)))  # coverage: ignore
+            circuit.append(cirq.H(np.random.choice(qubits)))  # pragma: no cover
         elif x == 5:
-            circuit.append(cirq.CNOT(qubits[0], qubits[1]))  # coverage: ignore
+            circuit.append(cirq.CNOT(qubits[0], qubits[1]))  # pragma: no cover
         elif x == 6:
-            circuit.append(cirq.CZ(qubits[0], qubits[1]))  # coverage: ignore
+            circuit.append(cirq.CZ(qubits[0], qubits[1]))  # pragma: no cover
 
     circuit.append(cirq.measure(qubits[0]))
     result = cirq.CliffordSimulator(split_untangled_states=split).run(circuit, repetitions=100)

cirq/sim/clifford/stabilizer_simulation_state.py

@@ -84,7 +84,7 @@ class StabilizerSimulationState(
     ):
         """Apply a SWAP gate"""
         if exponent % 1 != 0:
-            raise ValueError('Swap exponent must be integer')  # coverage: ignore
+            raise ValueError('Swap exponent must be integer')  # pragma: no cover
         self._state.apply_cx(control_axis, target_axis)
         self._state.apply_cx(target_axis, control_axis, exponent, global_shift)
         self._state.apply_cx(control_axis, target_axis)
@@ -122,7 +122,7 @@ class StabilizerSimulationState(
         if mixture is None:
             return NotImplemented
         if not all(linalg.is_unitary(m) for _, m in mixture):
-            return NotImplemented  # coverage: ignore
+            return NotImplemented  # pragma: no cover
         probabilities, unitaries = zip(*mixture)
         index = self.prng.choice(len(unitaries), p=probabilities)
         return self._strat_act_from_single_qubit_decompose(

cirq/sim/clifford/stabilizer_state_ch_form.py

@@ -54,7 +54,7 @@ class StabilizerStateChForm(qis.StabilizerState):
         self.omega: complex = 1
 
         # Apply X for every non-zero element of initial_state
-        for (i, val) in enumerate(
+        for i, val in enumerate(
             big_endian_int_to_digits(initial_state, digit_count=num_qubits, base=2)
         ):
             if val:
@@ -295,7 +295,7 @@ class StabilizerStateChForm(qis.StabilizerState):
     def apply_x(self, axis: int, exponent: float = 1, global_shift: float = 0):
         if exponent % 2 != 0:
             if exponent % 0.5 != 0.0:
-                raise ValueError('X exponent must be half integer')  # coverage: ignore
+                raise ValueError('X exponent must be half integer')  # pragma: no cover
             self.apply_h(axis)
             self.apply_z(axis, exponent)
             self.apply_h(axis)
@@ -303,7 +303,7 @@ class StabilizerStateChForm(qis.StabilizerState):
 
     def apply_y(self, axis: int, exponent: float = 1, global_shift: float = 0):
         if exponent % 0.5 != 0.0:
-            raise ValueError('Y exponent must be half integer')  # coverage: ignore
+            raise ValueError('Y exponent must be half integer')  # pragma: no cover
         shift = _phase(exponent, global_shift)
         if exponent % 2 == 0:
             self.omega *= shift
@@ -325,7 +325,7 @@ class StabilizerStateChForm(qis.StabilizerState):
     def apply_z(self, axis: int, exponent: float = 1, global_shift: float = 0):
         if exponent % 2 != 0:
             if exponent % 0.5 != 0.0:
-                raise ValueError('Z exponent must be half integer')  # coverage: ignore
+                raise ValueError('Z exponent must be half integer')  # pragma: no cover
             effective_exponent = exponent % 2
             for _ in range(int(effective_exponent * 2)):
                 # Prescription for S left multiplication.
@@ -337,7 +337,7 @@ class StabilizerStateChForm(qis.StabilizerState):
     def apply_h(self, axis: int, exponent: float = 1, global_shift: float = 0):
         if exponent % 2 != 0:
             if exponent % 1 != 0:
-                raise ValueError('H exponent must be integer')  # coverage: ignore
+                raise ValueError('H exponent must be integer')  # pragma: no cover
             # Prescription for H left multiplication
             # Reference: https://arxiv.org/abs/1808.00128
             # Equations 48, 49 and Proposition 4
@@ -357,7 +357,7 @@ class StabilizerStateChForm(qis.StabilizerState):
     ):
         if exponent % 2 != 0:
             if exponent % 1 != 0:
-                raise ValueError('CZ exponent must be integer')  # coverage: ignore
+                raise ValueError('CZ exponent must be integer')  # pragma: no cover
             # Prescription for CZ left multiplication.
             # Reference: https://arxiv.org/abs/1808.00128 Proposition 4 end
             self.M[control_axis, :] ^= self.G[target_axis, :]
@@ -369,7 +369,7 @@ class StabilizerStateChForm(qis.StabilizerState):
     ):
         if exponent % 2 != 0:
             if exponent % 1 != 0:
-                raise ValueError('CX exponent must be integer')  # coverage: ignore
+                raise ValueError('CX exponent must be integer')  # pragma: no cover
             # Prescription for CX left multiplication.
             # Reference: https://arxiv.org/abs/1808.00128 Proposition 4 end
             self.gamma[control_axis] = (

cirq/sim/density_matrix_simulation_state.py

@@ -47,8 +47,7 @@ class _BufferedDensityMatrix(qis.QuantumStateRepresentation):
         if buffer is None:
             buffer = [np.empty_like(density_matrix) for _ in range(3)]
         self._buffer = buffer
-        if len(density_matrix.shape) % 2 != 0:
-            # coverage: ignore
+        if len(density_matrix.shape) % 2 != 0:  # pragma: no cover
             raise ValueError('The dimension of target_tensor is not divisible by 2.')
         self._qid_shape = density_matrix.shape[: len(density_matrix.shape) // 2]
 
@@ -86,7 +85,7 @@ class _BufferedDensityMatrix(qis.QuantumStateRepresentation):
                     initial_state, len(qid_shape), qid_shape=qid_shape, dtype=dtype
                 ).reshape(qid_shape * 2)
             else:
-                density_matrix = initial_state  # coverage: ignore
+                density_matrix = initial_state  # pragma: no cover
             if np.may_share_memory(density_matrix, initial_state):
                 density_matrix = density_matrix.copy()
         density_matrix = density_matrix.astype(dtype, copy=False)
@@ -286,6 +285,22 @@ class DensityMatrixSimulationState(SimulationState[_BufferedDensityMatrix]):
         )
         super().__init__(state=state, prng=prng, qubits=qubits, classical_data=classical_data)
 
+    def add_qubits(self, qubits: Sequence['cirq.Qid']):
+        ret = super().add_qubits(qubits)
+        return (
+            self.kronecker_product(type(self)(qubits=qubits), inplace=True)
+            if ret is NotImplemented
+            else ret
+        )
+
+    def remove_qubits(self, qubits: Sequence['cirq.Qid']):
+        ret = super().remove_qubits(qubits)
+        if ret is not NotImplemented:
+            return ret
+        extracted, remainder = self.factor(qubits, inplace=True)
+        remainder._state._density_matrix *= extracted._state._density_matrix.reshape(-1)[0]
+        return remainder
+
     def _act_on_fallback_(
         self, action: Any, qubits: Sequence['cirq.Qid'], allow_decompose: bool = True
     ) -> bool:
@@ -299,7 +314,7 @@ class DensityMatrixSimulationState(SimulationState[_BufferedDensityMatrix]):
         for strat in strats:
             result = strat(action, self, qubits)
             if result is False:
-                break  # coverage: ignore
+                break  # pragma: no cover
             if result is True:
                 return True
             assert result is NotImplemented, str(result)

cirq/sim/density_matrix_simulator_test.py

@@ -139,8 +139,7 @@ def test_run_not_channel_op(dtype: Type[np.complexfloating], split: bool):
         def qubits(self):
             return self._qubits
 
-        def with_qubits(self, *new_qubits):
-            # coverage: ignore
+        def with_qubits(self, *new_qubits):  # pragma: no cover
             return BadOp(self._qubits)
 
     q0 = cirq.LineQubit(0)
@@ -1050,39 +1049,32 @@ def test_density_matrix_trial_result_repr():
 
 class XAsOp(cirq.Operation):
     def __init__(self, q):
-        # coverage: ignore
-        self.q = q
+        self.q = q  # pragma: no cover
 
     @property
     def qubits(self):
-        # coverage: ignore
-        return (self.q,)
+        return (self.q,)  # pragma: no cover
 
     def with_qubits(self, *new_qubits):
-        # coverage: ignore
-        return XAsOp(new_qubits[0])
+        return XAsOp(new_qubits[0])  # pragma: no cover
 
     def _kraus_(self):
-        # coverage: ignore
-        return cirq.kraus(cirq.X)
+        return cirq.kraus(cirq.X)  # pragma: no cover
 
 
 def test_works_on_operation():
     class XAsOp(cirq.Operation):
         def __init__(self, q):
-            # coverage: ignore
             self.q = q
 
         @property
         def qubits(self):
-            # coverage: ignore
             return (self.q,)
 
         def with_qubits(self, *new_qubits):
             raise NotImplementedError()
 
         def _kraus_(self):
-            # coverage: ignore
             return cirq.kraus(cirq.X)
 
     s = cirq.DensityMatrixSimulator()