cirq-core 1.5.0.dev20250403051212__py3-none-any.whl → 1.5.0.dev20250403142851__py3-none-any.whl

cirq/_import.py

@@ -132,7 +132,7 @@ def wrap_module_executions(
 
     def wrap(finder: Any) -> Any:
         if not hasattr(finder, 'find_spec'):
-            return finder
+            return finder  # pragma: no cover
         return InstrumentedFinder(finder, module_name, wrap_func, after_exec)
 
     new_meta_path = [wrap(finder) for finder in sys.meta_path]

cirq/_version.py

@@ -28,4 +28,4 @@ if sys.version_info < (3, 10, 0):  # pragma: no cover
         'of cirq (e.g. "python -m pip install cirq==1.1.*")'
     )
 
-__version__ = "1.5.0.dev20250403051212"
+__version__ = "1.5.0.dev20250403142851"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version():
-    assert cirq.__version__ == "1.5.0.dev20250403051212"
+    assert cirq.__version__ == "1.5.0.dev20250403142851"

cirq/circuits/circuit.py

@@ -1316,7 +1316,7 @@ class AbstractCircuit(abc.ABC):
                 changed = True
             resolved_moments.append(resolved_moment)
         if not changed:
-            return self
+            return self  # pragma: no cover
         return self._from_moments(resolved_moments)
 
     def _qasm_(self, args: Optional['cirq.QasmArgs'] = None) -> str:
@@ -2317,7 +2317,7 @@ class Circuit(AbstractCircuit):
             frontier = defaultdict(lambda: 0)
         flat_ops = tuple(ops.flatten_to_ops(operations))
         if not flat_ops:
-            return frontier
+            return frontier  # pragma: no cover
         qubits = set(q for op in flat_ops for q in op.qubits)
         if any(frontier[q] > start for q in qubits):
             raise ValueError(

cirq/circuits/circuit_test.py

@@ -55,19 +55,6 @@ if TYPE_CHECKING:
 q0, q1, q2, q3 = cirq.LineQubit.range(4)
 
 
-class _MomentAndOpTypeValidatingDeviceType(cirq.Device):
-    def validate_operation(self, operation):
-        if not isinstance(operation, cirq.Operation):
-            raise ValueError(f'not isinstance({operation!r}, {cirq.Operation!r})')
-
-    def validate_moment(self, moment):
-        if not isinstance(moment, cirq.Moment):
-            raise ValueError(f'not isinstance({moment!r}, {cirq.Moment!r})')
-
-
-moment_and_op_type_validating_device = _MomentAndOpTypeValidatingDeviceType()
-
-
 def test_from_moments():
     a, b, c, d = cirq.LineQubit.range(4)
     moment = cirq.Moment(cirq.Z(a), cirq.Z(b))

cirq/circuits/insert_strategy_test.py

@@ -21,6 +21,7 @@ import cirq
 
 def test_repr():
     assert repr(cirq.InsertStrategy.NEW) == 'cirq.InsertStrategy.NEW'
+    assert str(cirq.InsertStrategy.NEW) == 'NEW'
 
 
 @pytest.mark.parametrize(

cirq/circuits/optimization_pass.py

@@ -137,14 +137,14 @@ class PointOptimizer:
 
                 # Skip if an optimization removed the circuit underneath us.
                 if i >= len(circuit):
-                    continue
+                    continue  # pragma: no cover
                 # Skip if an optimization removed the op we're considering.
                 if op not in circuit[i].operations:
-                    continue
+                    continue  # pragma: no cover
                 opt = self.optimization_at(circuit, i, op)
                 # Skip if the optimization did nothing.
                 if opt is None:
-                    continue
+                    continue  # pragma: no cover
 
                 # Clear target area, and insert new operations.
                 circuit.clear_operations_touching(

cirq/circuits/qasm_output.py

@@ -349,7 +349,7 @@ class QasmOutput:
                 return NotImplemented
 
             if len(op.qubits) == 1:
-                return QasmUGate.from_matrix(mat).on(*op.qubits)
+                return QasmUGate.from_matrix(mat).on(*op.qubits)  # pragma: no cover
             return QasmTwoQubitGate.from_matrix(mat).on(*op.qubits)
 
         def on_stuck(bad_op):

cirq/circuits/qasm_output_test.py

@@ -53,6 +53,11 @@ def test_qasm_u_qubit_gate_unitary():
 
     cirq.testing.assert_implements_consistent_protocols(g)
 
+    u = cirq.unitary(cirq.Y)
+    g = QasmUGate.from_matrix(u)
+    cirq.testing.assert_allclose_up_to_global_phase(cirq.unitary(g), u, atol=1e-7)
+    cirq.testing.assert_implements_consistent_protocols(g)
+
 
 def test_qasm_two_qubit_gate_unitary():
     u = cirq.testing.random_unitary(4)

cirq/circuits/text_diagram_drawer.py

@@ -135,7 +135,7 @@ class TextDiagramDrawer:
 
         # Horizontal line?
         if any(line_y == y and x1 < x < x2 for line_y, x1, x2, _, _ in self.horizontal_lines):
-            return True
+            return True  # pragma: no cover
 
         return False
 

cirq/contrib/acquaintance/bipartite_test.py

@@ -339,3 +339,14 @@ def test_decomposition_permutation_consistency(part_size, subgraph):
     cca.update_mapping(mapping, gate._decompose_(qubits))
     permutation = gate.permutation()
     assert {qubits[i]: j for i, j in permutation.items()} == mapping
+
+
+def test_bad_number_of_qubits():
+    gate = cca.BipartiteSwapNetworkGate(cca.BipartiteGraphType.COMPLETE, 6)
+    qubits = cirq.LineQubit.range(6)
+    mapping = {q: i for i, q in enumerate(qubits)}
+    with pytest.raises(ValueError, match='len'):
+        cca.update_mapping(mapping, gate._decompose_(qubits))
+    gate.part_size = 5
+    with pytest.raises(ValueError, match='qubit_count'):
+        gate.permutation()

cirq/contrib/acquaintance/devices_test.py

@@ -27,3 +27,8 @@ def test_acquaintance_device():
     swap_network = cca.SwapNetworkGate((1, 2, 1))
     cca.UnconstrainedAcquaintanceDevice.validate_operation(cca.acquaint(*qubits[:2]))
     cca.UnconstrainedAcquaintanceDevice.validate_operation(swap_network(*qubits))
+
+
+def test_not_operation():
+    with pytest.raises(TypeError):
+        _ = cca.get_acquaintance_size(cirq.LineQubit(1))

cirq/contrib/acquaintance/executor_test.py

@@ -48,6 +48,7 @@ def test_executor_explicit():
     }
     initial_mapping = {q: i for i, q in enumerate(sorted(qubits))}
     execution_strategy = cca.GreedyExecutionStrategy(gates, initial_mapping)
+    assert execution_strategy.device == cirq.UNCONSTRAINED_DEVICE
 
     with pytest.raises(ValueError):
         executor = cca.StrategyExecutorTransformer(None)

cirq/contrib/acquaintance/inspection_utils_test.py

@@ -18,6 +18,7 @@ import pytest
 
 import cirq
 import cirq.contrib.acquaintance as cca
+import cirq.contrib.acquaintance.inspection_utils as inspection_utils
 
 
 @pytest.mark.parametrize('n_qubits, acquaintance_size', product(range(2, 6), range(2, 5)))
@@ -27,3 +28,7 @@ def test_get_logical_acquaintance_opportunities(n_qubits, acquaintance_size):
     initial_mapping = {q: i for i, q in enumerate(qubits)}
     opps = cca.get_logical_acquaintance_opportunities(acquaintance_strategy, initial_mapping)
     assert opps == set(frozenset(s) for s in combinations(range(n_qubits), acquaintance_size))
+
+
+def test_device():
+    assert inspection_utils.LogicalAnnotator({}).device == cirq.UNCONSTRAINED_DEVICE

cirq/contrib/acquaintance/shift.py

@@ -60,7 +60,7 @@ class CircularShiftGate(PermutationGate):
 
     def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs') -> Tuple[str, ...]:
         if args.known_qubit_count is None:
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         direction_symbols = ('╲', '╱') if args.use_unicode_characters else ('\\', '/')
         wire_symbols = tuple(
             direction_symbols[int(i >= self.shift)]

cirq/contrib/custom_simulators/custom_state_simulator_test.py

@@ -26,7 +26,7 @@ class ComputationalBasisState(cirq.qis.QuantumStateRepresentation):
         self.basis = initial_state
 
     def copy(self, deep_copy_buffers: bool = True) -> 'ComputationalBasisState':
-        return ComputationalBasisState(self.basis)
+        return ComputationalBasisState(self.basis)  # pragma: no cover
 
     def measure(self, axes: Sequence[int], seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None):
         return [self.basis[i] for i in axes]
@@ -149,11 +149,13 @@ class ComputationalBasisProductState(cirq.qis.QuantumStateRepresentation):
     def factor(
         self, axes: Sequence[int], *, validate=True, atol=1e-07
     ) -> Tuple['ComputationalBasisProductState', 'ComputationalBasisProductState']:
-        extracted = ComputationalBasisProductState([self.basis[i] for i in axes])
+        extracted = ComputationalBasisProductState(
+            [self.basis[i] for i in axes]
+        )  # pragma: no cover
         remainder = ComputationalBasisProductState(
             [self.basis[i] for i in range(len(self.basis)) if i not in axes]
-        )
-        return extracted, remainder
+        )  # pragma: no cover
+        return extracted, remainder  # pragma: no cover
 
     def reindex(self, axes: Sequence[int]) -> 'ComputationalBasisProductState':
         return ComputationalBasisProductState([self.basis[i] for i in axes])

cirq/contrib/graph_device/graph_device.py

@@ -28,11 +28,11 @@ class UndirectedGraphDeviceEdge(metaclass=abc.ABCMeta):
 
     @abc.abstractmethod
     def duration_of(self, operation: ops.Operation) -> value.Duration:
-        pass  # pragma: no cover
+        pass
 
     @abc.abstractmethod
     def validate_operation(self, operation: ops.Operation) -> None:
-        pass  # pragma: no cover
+        pass
 
 
 @value.value_equality
@@ -60,7 +60,7 @@ class _UnconstrainedUndirectedGraphDeviceEdge(UndirectedGraphDeviceEdge):
         return value.Duration(picos=0)
 
     def validate_operation(self, operation: ops.Operation) -> None:
-        pass  # pragma: no cover
+        pass
 
     def __eq__(self, other):
         return self.__class__ == other.__class__

cirq/contrib/paulistring/pauli_string_optimize.py

@@ -46,7 +46,9 @@ def pauli_string_optimized_circuit(
 def assert_no_multi_qubit_pauli_strings(circuit: circuits.Circuit) -> None:
     for op in circuit.all_operations():
         if isinstance(op, PauliStringGateOperation):
-            assert len(op.pauli_string) == 1, 'Multi qubit Pauli string left over'
+            assert (
+                len(op.pauli_string) == 1
+            ), 'Multi qubit Pauli string left over'  # pragma: no cover
 
 
 def merge_equal_strings(string_dag: circuitdag.CircuitDag) -> None:

cirq/contrib/paulistring/pauli_string_optimize_test.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
 import cirq
 from cirq.contrib.paulistring import CliffordTargetGateset, pauli_string_optimized_circuit
 

cirq/contrib/paulistring/recombine_test.py

@@ -23,7 +23,7 @@ from cirq.contrib.paulistring import (
 def _assert_no_multi_qubit_pauli_strings(circuit: cirq.Circuit) -> None:
     for op in circuit.all_operations():
         if isinstance(op, cirq.PauliStringGateOperation):
-            assert len(op.pauli_string) == 1
+            assert len(op.pauli_string) == 1  # pragma: no cover
 
 
 def test_move_non_clifford_into_clifford():

cirq/contrib/qcircuit/qcircuit_pdf.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# pragma: no cover
 
 import errno
 import os
@@ -30,6 +29,7 @@ def circuit_to_pdf_using_qcircuit_via_tex(
     qcircuit_kwargs=None,
     clean_ext=('dvi', 'ps'),
     documentclass='article',
+    prepare_only=False,
 ):
     """Compiles the QCircuit-based latex diagram of the given circuit.
 
@@ -43,6 +43,8 @@ def circuit_to_pdf_using_qcircuit_via_tex(
             default, latexmk is used with the '-pdfps' flag, which produces
             intermediary dvi and ps files.
         documentclass: The documentclass of the latex file.
+        prepare_only: If True, only prepare the document, do not generate PDF.
+            Used only for testing.
 
     Raises:
         OSError, IOError: If cleanup fails.
@@ -59,10 +61,11 @@ def circuit_to_pdf_using_qcircuit_via_tex(
     doc.packages.append(Package('qcircuit'))
     doc.preamble.append(Package('inputenc', options=['utf8']))
     doc.append(NoEscape(tex))
-    doc.generate_pdf(filepath, **pdf_kwargs)
-    for ext in clean_ext:
-        try:
-            os.remove(filepath + '.' + ext)
-        except (OSError, IOError) as e:
-            if e.errno != errno.ENOENT:
-                raise
+    if not prepare_only:  # pragma: nocover
+        doc.generate_pdf(filepath, **pdf_kwargs)
+        for ext in clean_ext:
+            try:
+                os.remove(filepath + '.' + ext)
+            except (OSError, IOError) as e:
+                if e.errno != errno.ENOENT:
+                    raise

cirq/contrib/qcircuit/qcircuit_pdf_test.py

@@ -0,0 +1,21 @@
+# Copyright 2025 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 cirq
+import cirq.contrib.qcircuit.qcircuit_pdf as qcircuit_pdf
+
+
+def test_qcircuit_pdf_prepare_only():
+    circuit = cirq.Circuit(cirq.X(cirq.q(0)), cirq.CZ(cirq.q(0), cirq.q(1)))
+    qcircuit_pdf.circuit_to_pdf_using_qcircuit_via_tex(circuit, "/tmp/test_file", prepare_only=True)

cirq/contrib/qcircuit/qcircuit_test.py

@@ -53,7 +53,7 @@ def test_fallback_diagram():
             self._qubits = qubits
 
         def with_qubits(self, *new_qubits):
-            return MagicOp(*new_qubits)
+            return MagicOp(*new_qubits)  # pragma: no cover
 
         @property
         def qubits(self):

cirq/contrib/quantum_volume/quantum_volume.py

@@ -4,7 +4,7 @@ https://arxiv.org/abs/1811.12926.
 """
 
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, List, Optional, Set, Tuple
+from typing import Callable, Dict, List, Optional, Set, Tuple
 
 import networkx as nx
 import numpy as np
@@ -416,11 +416,6 @@ def execute_circuits(
     return results
 
 
-def _get_device_graph(device_or_qubits: Any):
-    qubits = device_or_qubits if isinstance(device_or_qubits, list) else device_or_qubits.qubits
-    return ccr.gridqubits_to_graph_device(qubits)
-
-
 def calculate_quantum_volume(
     *,
     num_qubits: int,

cirq/contrib/quimb/mps_simulator.py

@@ -103,7 +103,7 @@ class MPSSimulator(
             MPSState args for simulating the Circuit.
         """
         if isinstance(initial_state, MPSState):
-            return initial_state
+            return initial_state  # pragma: no cover
 
         return MPSState(
             qubits=qubits,
@@ -460,7 +460,7 @@ class _MPSHandler(qis.QuantumStateRepresentation):
             raise ValueError('Can only handle 1 and 2 qubit operations')
         return True
 
-    def estimation_stats(self):
+    def estimation_stats(self):  # pragma: no cover
         """Returns some statistics about the memory usage and quality of the approximation."""
 
         num_coefs_used = sum([Mi.data.size for Mi in self._M])

cirq/contrib/quimb/mps_simulator_test.py

@@ -479,6 +479,11 @@ def test_simulation_state_initializer():
     )
     assert s.qubits == (cirq.LineQubit(0),)
     assert s.classical_data == expected_classical_data
+    assert s.estimation_stats() == {
+        'estimated_fidelity': 1.0,
+        'memory_bytes': 16,
+        'num_coefs_used': 2,
+    }
 
 
 def test_act_on_gate():

cirq/contrib/routing/greedy_test.py

@@ -45,7 +45,9 @@ def create_circuit_and_device():
 
 def create_hanging_routing_instance(circuit, device_graph):
     """Create a test problem instance."""
-    route_circuit_greedily(circuit, device_graph, max_search_radius=2, random_state=1)
+    route_circuit_greedily(  # pragma: no cover
+        circuit, device_graph, max_search_radius=2, random_state=1
+    )
 
 
 def test_router_hanging():

cirq/contrib/svg/svg.py

@@ -199,7 +199,7 @@ def tdd_to_svg(
             # qubits start at far left and their wires shall be blue
             stroke = QBLUE
         else:
-            stroke = 'black'
+            stroke = 'black'  # pragma: no cover
         t += f'<line x1="{x1}" x2="{x2}" y1="{y}" y2="{y}" stroke="{stroke}" stroke-width="1" />'
 
     for xi, yi1, yi2, _, _ in tdd.vertical_lines:

cirq/contrib/svg/svg_test.py

@@ -4,7 +4,7 @@ import numpy as np
 import pytest
 
 import cirq
-from cirq.contrib.svg import circuit_to_svg
+from cirq.contrib.svg import circuit_to_svg, SVGCircuit
 
 
 def test_svg():
@@ -82,7 +82,8 @@ def test_gate_with_less_greater_str(symbol, svg_symbol):
             return cirq.CircuitDiagramInfo(wire_symbols=[symbol])
 
     circuit = cirq.Circuit(CustomGate().on(cirq.LineQubit(0)))
-    svg = circuit_to_svg(circuit)
+    svg_circuit = SVGCircuit(circuit)
+    svg = svg_circuit._repr_svg_()
 
     _ = IPython.display.SVG(svg)
     assert svg_symbol in svg

cirq/devices/unconstrained_device_test.py

@@ -23,3 +23,9 @@ def test_infinitely_fast():
     assert cirq.UNCONSTRAINED_DEVICE.duration_of(cirq.X(cirq.NamedQubit('a'))) == cirq.Duration(
         picos=0
     )
+
+
+def test_any_qubit_works():
+    moment = cirq.Moment([cirq.X(cirq.LineQubit(987654321))])
+    cirq.UNCONSTRAINED_DEVICE.validate_moment(moment)
+    cirq.UNCONSTRAINED_DEVICE.validate_circuit(cirq.Circuit(moment))

cirq/experiments/qubit_characterizations.py

@@ -285,7 +285,9 @@ class TomographyResult:
         """
         return self._density_matrix
 
-    def plot(self, axes: Optional[List[plt.Axes]] = None, **plot_kwargs: Any) -> List[plt.Axes]:
+    def plot(
+        self, axes: Optional[List[plt.Axes]] = None, **plot_kwargs: Any
+    ) -> List[plt.Axes]:  # pragma: no cover
         """Plots the real and imaginary parts of the density matrix as two 3D bar plots.
 
         Args:
@@ -780,7 +782,7 @@ def _matrix_bar_plot(
     title: Optional[str] = None,
     ylim: Tuple[int, int] = (-1, 1),
     **bar3d_kwargs: Any,
-) -> None:
+) -> None:  # pragma: no cover
     num_rows, num_cols = mat.shape
     indices = np.meshgrid(range(num_cols), range(num_rows))
     x_indices = np.array(indices[1]).flatten()

cirq/experiments/random_quantum_circuit_generation.py

@@ -541,9 +541,8 @@ def get_grid_interaction_layer_circuit(
     moments = []
     for layer in pattern:
         pairs = sorted(_get_active_pairs(device_graph, layer))
-        if len(pairs) == 0:
-            continue
-        moments += [circuits.Moment(two_qubit_gate.on(*pair) for pair in pairs)]
+        if pairs:
+            moments += [circuits.Moment(two_qubit_gate.on(*pair) for pair in pairs)]
     return circuits.Circuit(moments)
 
 

cirq/experiments/readout_confusion_matrix.py

@@ -344,10 +344,10 @@ class TensoredConfusionMatrices:
             try:
                 idx = self.measure_qubits.index((qubit,))
             except:  # pragma: no cover
-                raise NotImplementedError(  # pragma: no cover
-                    "The response matrix must be a tensor product of single-qu"  # pragma: no cover
-                    + f"bit response matrices, including that of qubit {qubit}."  # pragma: no cover
-                )  # pragma: no cover
+                raise NotImplementedError(
+                    "The response matrix must be a tensor product of single-qu"
+                    + f"bit response matrices, including that of qubit {qubit}."
+                )
             cm_all.append(self.confusion_matrices[idx])
 
         # get the correction matrices, assuming uncorrelated readout:

cirq/linalg/combinators_test.py

@@ -104,6 +104,9 @@ def test_block_diag():
         ),
     )
 
+    with pytest.raises(ValueError, match='Blocks must be square'):
+        _ = cirq.block_diag(np.array([[1, 2, 3], [3, 4, 5]]))
+
 
 def test_block_diag_dtype():
     assert cirq.block_diag().dtype == np.complex128

cirq/linalg/decompositions_test.py

@@ -39,11 +39,6 @@ def assert_kronecker_factorization_within_tolerance(matrix, g, f1, f2):
     assert np.allclose(restored, matrix), "Can't factor kronecker product."
 
 
-def assert_kronecker_factorization_not_within_tolerance(matrix, g, f1, f2):
-    restored = g * cirq.linalg.combinators.kron(f1, f2)
-    assert np.any(np.isnan(restored) or not np.allclose(restored, matrix))
-
-
 def assert_magic_su2_within_tolerance(mat, a, b):
     recon = cirq.linalg.combinators.dot(MAGIC_CONJ_T, cirq.linalg.combinators.kron(a, b), MAGIC)
     assert np.allclose(recon, mat), "Failed to decompose within tolerance."

cirq/linalg/predicates.py

@@ -308,7 +308,7 @@ def slice_for_qubits_equal_to(
     else:
         if little_endian_qureg_value < 0 and not qid_shape_specified:
             # Allow negative binary numbers
-            little_endian_qureg_value &= (1 << len(target_shape)) - 1
+            little_endian_qureg_value &= (1 << len(target_shape)) - 1  # pragma: no cover
         digits = value.big_endian_int_to_digits(little_endian_qureg_value, base=target_shape[::-1])[
             ::-1
         ]

cirq/ops/clifford_gate.py

@@ -130,16 +130,6 @@ def _pad_tableau(
     return padded_tableau
 
 
-def _gate_tableau(num_qubits: int, gate: raw_types.Gate) -> 'cirq.CliffordTableau':
-    qubits = devices.LineQubit.range(num_qubits)
-    t = qis.CliffordTableau(num_qubits=num_qubits)
-    args = sim.CliffordTableauSimulationState(
-        tableau=t, qubits=qubits, prng=np.random.RandomState()
-    )
-    protocols.act_on(gate, args, qubits, allow_decompose=False)
-    return args.tableau
-
-
 class CommonCliffordGateMetaClass(value.ABCMetaImplementAnyOneOf):
     """A metaclass used to lazy initialize several common Clifford Gate as class attributes."""
 
@@ -405,7 +395,7 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
 
     def __pow__(self, exponent: float) -> 'CliffordGate':
         if exponent != int(exponent):
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         exponent = int(exponent)
 
         if exponent == -1:
@@ -448,7 +438,7 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
         # )
         # For example: X.then(Z) and Z.then(X) both return same tableau
         # it is because Clifford tableau ignores the global phase information.
-        return NotImplemented
+        return NotImplemented  # pragma: no cover
 
     def _decompose_(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE':
         return transformers.analytical_decompositions.decompose_clifford_tableau_to_operations(
@@ -477,7 +467,7 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
             # is aimed to fix that.
             return NotImplemented
 
-        return NotImplemented
+        return NotImplemented  # pragma: no cover
 
 
 @dataclass(frozen=True, init=False, eq=False, repr=False)
@@ -748,7 +738,8 @@ class SingleQubitCliffordGate(CliffordGate):
     def __pow__(self, exponent: float) -> 'SingleQubitCliffordGate':
         if int(exponent) == exponent:
             # The single qubit Clifford gates are a group of size 24
-            ret_gate = super().__pow__(int(exponent) % 24)
+            exp = int(exponent) % 24
+            ret_gate = super().__pow__(exp if exp != 23 else -1)
             return SingleQubitCliffordGate.from_clifford_tableau(ret_gate.clifford_tableau)
         elif int(2 * exponent) == 2 * exponent:
             # If exponent = k/2 for integer k, then we compute the k-th power of the square root