cirq-core 1.3.0.dev20231201164435__py3-none-any.whl → 1.4.0__py3-none-any.whl

cirq/experiments/two_qubit_xeb_test.py

@@ -0,0 +1,304 @@
+# Copyright 2024 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.
+"""Wraps Parallel Two Qubit XEB into a few convenience methods."""
+from typing import Optional, Sequence, Dict
+import itertools
+import io
+
+import matplotlib.pyplot as plt
+
+import numpy as np
+import networkx as nx
+import pandas as pd
+import pytest
+
+import cirq
+from cirq.experiments.qubit_characterizations import ParallelRandomizedBenchmarkingResult
+
+
+def _manhattan_distance(qubit1: 'cirq.GridQubit', qubit2: 'cirq.GridQubit') -> int:
+    return abs(qubit1.row - qubit2.row) + abs(qubit1.col - qubit2.col)
+
+
+class MockDevice(cirq.Device):
+    @property
+    def metadata(self):
+        qubits = cirq.GridQubit.rect(3, 2, 4, 3)
+        graph = nx.Graph(
+            pair for pair in itertools.combinations(qubits, 2) if _manhattan_distance(*pair) == 1
+        )
+        return cirq.DeviceMetadata(qubits, graph)
+
+
+class MockProcessor:
+    def get_device(self):
+        return MockDevice()
+
+
+class DensityMatrixSimulatorWithProcessor(cirq.DensityMatrixSimulator):
+    @property
+    def processor(self):
+        return MockProcessor()
+
+
+def test_parallel_two_qubit_xeb_simulator_without_processor_fails():
+    sampler = (
+        cirq.DensityMatrixSimulator(
+            seed=0, noise=cirq.ConstantQubitNoiseModel(cirq.amplitude_damp(0.1))
+        ),
+    )
+
+    with pytest.raises(ValueError):
+        _ = cirq.experiments.parallel_two_qubit_xeb(
+            sampler=sampler,
+            n_repetitions=1,
+            n_combinations=1,
+            n_circuits=1,
+            cycle_depths=[3, 4, 5],
+            random_state=0,
+        )
+
+
+@pytest.mark.parametrize(
+    'sampler,qubits',
+    [
+        (
+            cirq.DensityMatrixSimulator(
+                seed=0, noise=cirq.ConstantQubitNoiseModel(cirq.amplitude_damp(0.1))
+            ),
+            cirq.GridQubit.rect(3, 2, 4, 3),
+        ),
+        (
+            DensityMatrixSimulatorWithProcessor(
+                seed=0, noise=cirq.ConstantQubitNoiseModel(cirq.amplitude_damp(0.1))
+            ),
+            None,
+        ),
+    ],
+)
+def test_parallel_two_qubit_xeb(sampler: cirq.Sampler, qubits: Optional[Sequence[cirq.GridQubit]]):
+    res = cirq.experiments.parallel_two_qubit_xeb(
+        sampler=sampler,
+        qubits=qubits,
+        n_repetitions=100,
+        n_combinations=1,
+        n_circuits=1,
+        cycle_depths=[3, 4, 5],
+        random_state=0,
+    )
+
+    got = [res.xeb_error(*reversed(pair)) for pair in res.all_qubit_pairs]
+    np.testing.assert_allclose(got, 0.1, atol=1e-1)
+
+
+@pytest.mark.usefixtures('closefigures')
+@pytest.mark.parametrize(
+    'sampler,qubits',
+    [
+        (cirq.DensityMatrixSimulator(seed=0), cirq.GridQubit.rect(3, 2, 4, 3)),
+        (DensityMatrixSimulatorWithProcessor(seed=0), None),
+    ],
+)
+@pytest.mark.parametrize('ax', [None, plt.subplots(1, 1, figsize=(8, 8))[1]])
+def test_plotting(sampler, qubits, ax):
+    res = cirq.experiments.parallel_two_qubit_xeb(
+        sampler=sampler,
+        qubits=qubits,
+        n_repetitions=1,
+        n_combinations=1,
+        n_circuits=1,
+        cycle_depths=[3, 4, 5],
+        random_state=0,
+        ax=ax,
+    )
+    res.plot_heatmap(ax=ax)
+    res.plot_fitted_exponential(cirq.GridQubit(4, 4), cirq.GridQubit(4, 3), ax=ax)
+    res.plot_histogram(ax=ax)
+
+
+_TEST_RESULT = cirq.experiments.TwoQubitXEBResult(
+    pd.read_csv(
+        io.StringIO(
+            """layer_i,pair_i,pair,a,layer_fid,cycle_depths,fidelities,a_std,layer_fid_std
+0,0,"(cirq.GridQubit(4, 4), cirq.GridQubit(5, 4))",,0.9,[],[],,
+0,1,"(cirq.GridQubit(5, 3), cirq.GridQubit(6, 3))",,0.8,[],[],,
+1,0,"(cirq.GridQubit(4, 3), cirq.GridQubit(5, 3))",,0.3,[],[],,
+1,1,"(cirq.GridQubit(5, 4), cirq.GridQubit(6, 4))",,0.2,[],[],,
+2,0,"(cirq.GridQubit(4, 3), cirq.GridQubit(4, 4))",,0.1,[],[],,
+2,1,"(cirq.GridQubit(6, 3), cirq.GridQubit(6, 4))",,0.5,[],[],,
+3,0,"(cirq.GridQubit(5, 3), cirq.GridQubit(5, 4))",,0.4,[],[],"""
+        ),
+        index_col=[0, 1, 2],
+        converters={2: lambda s: eval(s)},
+    )
+)
+
+
+@pytest.mark.parametrize(
+    'q0,q1,pauli',
+    [
+        (cirq.GridQubit(4, 4), cirq.GridQubit(5, 4), 1 / 8),
+        (cirq.GridQubit(5, 3), cirq.GridQubit(6, 3), 1 / 4),
+        (cirq.GridQubit(4, 3), cirq.GridQubit(5, 3), 0.8 + 3 / 40),
+        (cirq.GridQubit(6, 3), cirq.GridQubit(6, 4), 5 / 8),
+    ],
+)
+def test_pauli_error(q0: cirq.GridQubit, q1: cirq.GridQubit, pauli: float):
+    assert _TEST_RESULT.pauli_error()[(q0, q1)] == pytest.approx(pauli)
+
+
+class MockParallelRandomizedBenchmarkingResult(ParallelRandomizedBenchmarkingResult):
+    def pauli_error(self) -> Dict[cirq.Qid, float]:
+        return {
+            cirq.GridQubit(4, 4): 0.01,
+            cirq.GridQubit(5, 4): 0.02,
+            cirq.GridQubit(5, 3): 0.03,
+            cirq.GridQubit(5, 6): 0.04,
+            cirq.GridQubit(4, 3): 0.05,
+            cirq.GridQubit(6, 3): 0.06,
+            cirq.GridQubit(6, 4): 0.07,
+        }
+
+
+@pytest.mark.parametrize(
+    'q0,q1,pauli',
+    [
+        (cirq.GridQubit(4, 4), cirq.GridQubit(5, 4), 1 / 8 - 0.03),
+        (cirq.GridQubit(5, 3), cirq.GridQubit(6, 3), 1 / 4 - 0.09),
+        (cirq.GridQubit(4, 3), cirq.GridQubit(5, 3), 0.8 + 3 / 40 - 0.08),
+        (cirq.GridQubit(6, 3), cirq.GridQubit(6, 4), 5 / 8 - 0.13),
+    ],
+)
+def test_inferred_pauli_error(q0: cirq.GridQubit, q1: cirq.GridQubit, pauli: float):
+    combined_results = cirq.experiments.InferredXEBResult(
+        rb_result=MockParallelRandomizedBenchmarkingResult({}), xeb_result=_TEST_RESULT
+    )
+
+    assert combined_results.inferred_pauli_error()[(q0, q1)] == pytest.approx(pauli)
+
+
+@pytest.mark.parametrize(
+    'q0,q1,xeb',
+    [
+        (cirq.GridQubit(4, 4), cirq.GridQubit(5, 4), 0.076),
+        (cirq.GridQubit(5, 3), cirq.GridQubit(6, 3), 0.128),
+        (cirq.GridQubit(4, 3), cirq.GridQubit(5, 3), 0.636),
+        (cirq.GridQubit(6, 3), cirq.GridQubit(6, 4), 0.396),
+    ],
+)
+def test_inferred_xeb_error(q0: cirq.GridQubit, q1: cirq.GridQubit, xeb: float):
+    combined_results = cirq.experiments.InferredXEBResult(
+        rb_result=MockParallelRandomizedBenchmarkingResult({}), xeb_result=_TEST_RESULT
+    )
+
+    assert combined_results.inferred_xeb_error()[(q0, q1)] == pytest.approx(xeb)
+
+
+def test_inferred_single_qubit_pauli():
+    combined_results = cirq.experiments.InferredXEBResult(
+        rb_result=MockParallelRandomizedBenchmarkingResult({}), xeb_result=_TEST_RESULT
+    )
+
+    assert combined_results.single_qubit_pauli_error() == {
+        cirq.GridQubit(4, 4): 0.01,
+        cirq.GridQubit(5, 4): 0.02,
+        cirq.GridQubit(5, 3): 0.03,
+        cirq.GridQubit(5, 6): 0.04,
+        cirq.GridQubit(4, 3): 0.05,
+        cirq.GridQubit(6, 3): 0.06,
+        cirq.GridQubit(6, 4): 0.07,
+    }
+
+
+@pytest.mark.parametrize(
+    'q0,q1,pauli',
+    [
+        (cirq.GridQubit(4, 4), cirq.GridQubit(5, 4), 1 / 8),
+        (cirq.GridQubit(5, 3), cirq.GridQubit(6, 3), 1 / 4),
+        (cirq.GridQubit(4, 3), cirq.GridQubit(5, 3), 0.8 + 3 / 40),
+        (cirq.GridQubit(6, 3), cirq.GridQubit(6, 4), 5 / 8),
+    ],
+)
+def test_inferred_two_qubit_pauli(q0: cirq.GridQubit, q1: cirq.GridQubit, pauli: float):
+    combined_results = cirq.experiments.InferredXEBResult(
+        rb_result=MockParallelRandomizedBenchmarkingResult({}), xeb_result=_TEST_RESULT
+    )
+    assert combined_results.two_qubit_pauli_error()[(q0, q1)] == pytest.approx(pauli)
+
+
+@pytest.mark.parametrize('ax', [None, plt.subplots(1, 1, figsize=(8, 8))[1]])
+@pytest.mark.parametrize('target_error', ['pauli', 'xeb', 'decay_constant'])
+@pytest.mark.parametrize('kind', ['single_qubit', 'two_qubit', 'both', ''])
+def test_inferred_plots(ax, target_error, kind):
+    combined_results = cirq.experiments.InferredXEBResult(
+        rb_result=MockParallelRandomizedBenchmarkingResult({}), xeb_result=_TEST_RESULT
+    )
+
+    combined_results.plot_heatmap(target_error=target_error, ax=ax)
+
+    raise_error = False
+    if kind not in ('single_qubit', 'two_qubit', 'both'):
+        raise_error = True
+    if kind != 'two_qubit' and target_error != 'pauli':
+        raise_error = True
+
+    if raise_error:
+        with pytest.raises(ValueError):
+            combined_results.plot_histogram(target_error=target_error, kind=kind, ax=ax)
+    else:
+        combined_results.plot_histogram(target_error=target_error, kind=kind, ax=ax)
+
+
+@pytest.mark.parametrize(
+    'sampler,qubits',
+    [
+        (
+            cirq.DensityMatrixSimulator(
+                seed=0, noise=cirq.ConstantQubitNoiseModel(cirq.amplitude_damp(0.1))
+            ),
+            cirq.GridQubit.rect(3, 2, 4, 3),
+        ),
+        (
+            DensityMatrixSimulatorWithProcessor(
+                seed=0, noise=cirq.ConstantQubitNoiseModel(cirq.amplitude_damp(0.1))
+            ),
+            None,
+        ),
+    ],
+)
+def test_run_rb_and_xeb(sampler: cirq.Sampler, qubits: Optional[Sequence[cirq.GridQubit]]):
+    res = cirq.experiments.run_rb_and_xeb(
+        sampler=sampler,
+        qubits=qubits,
+        repetitions=100,
+        num_clifford_range=tuple(np.arange(3, 10, 1)),
+        xeb_combinations=1,
+        num_circuits=1,
+        depths_xeb=(3, 4, 5),
+        random_state=0,
+    )
+    np.testing.assert_allclose(
+        [res.xeb_result.xeb_error(*pair) for pair in res.all_qubit_pairs], 0.1, atol=1e-1
+    )
+
+
+def test_run_rb_and_xeb_without_processor_fails():
+    sampler = (
+        cirq.DensityMatrixSimulator(
+            seed=0, noise=cirq.ConstantQubitNoiseModel(cirq.amplitude_damp(0.1))
+        ),
+    )
+
+    with pytest.raises(ValueError):
+        _ = cirq.experiments.run_rb_and_xeb(sampler=sampler)

cirq/json_resolver_cache.py

@@ -157,6 +157,7 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
         'LineTopology': cirq.LineTopology,
         'Linspace': cirq.Linspace,
         'ListSweep': cirq.ListSweep,
+        'cirq.MSGate': cirq.MSGate,
         'MatrixGate': cirq.MatrixGate,
         'MixedUnitaryChannel': cirq.MixedUnitaryChannel,
         'MeasurementKey': cirq.MeasurementKey,
@@ -246,6 +247,7 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
         'ZipLongest': cirq.ZipLongest,
         'ZPowGate': cirq.ZPowGate,
         'ZZPowGate': cirq.ZZPowGate,
+        'UniformSuperpositionGate': cirq.UniformSuperpositionGate,
         # Old types, only supported for backwards-compatibility
         'BooleanHamiltonian': _boolean_hamiltonian_gate_op,  # Removed in v0.15
         'CrossEntropyResult': _cross_entropy_result,  # Removed in v0.16

cirq/linalg/decompositions.py

@@ -222,8 +222,9 @@ def kron_factor_4x4_to_2x2s(matrix: np.ndarray) -> Tuple[complex, np.ndarray, np
             f2[(a & 1) ^ i, (b & 1) ^ j] = matrix[a ^ i, b ^ j]
 
     # Rescale factors to have unit determinants.
-    f1 /= np.sqrt(np.linalg.det(f1)) or 1
-    f2 /= np.sqrt(np.linalg.det(f2)) or 1
+    with np.errstate(divide="ignore", invalid="ignore"):
+        f1 /= np.sqrt(np.linalg.det(f1)) or 1
+        f2 /= np.sqrt(np.linalg.det(f2)) or 1
 
     # Determine global phase.
     g = matrix[a, b] / (f1[a >> 1, b >> 1] * f2[a & 1, b & 1])
@@ -451,18 +452,14 @@ class KakDecomposition:
             single_qubit_operations_after: a0, a1 from the above equation.
         """
         self.global_phase: complex = global_phase
-        self.single_qubit_operations_before: Tuple[
-            np.ndarray, np.ndarray
-        ] = single_qubit_operations_before or (
-            np.eye(2, dtype=np.complex64),
-            np.eye(2, dtype=np.complex64),
+        self.single_qubit_operations_before: Tuple[np.ndarray, np.ndarray] = (
+            single_qubit_operations_before
+            or (np.eye(2, dtype=np.complex64), np.eye(2, dtype=np.complex64))
         )
         self.interaction_coefficients = interaction_coefficients
-        self.single_qubit_operations_after: Tuple[
-            np.ndarray, np.ndarray
-        ] = single_qubit_operations_after or (
-            np.eye(2, dtype=np.complex64),
-            np.eye(2, dtype=np.complex64),
+        self.single_qubit_operations_after: Tuple[np.ndarray, np.ndarray] = (
+            single_qubit_operations_after
+            or (np.eye(2, dtype=np.complex64), np.eye(2, dtype=np.complex64))
         )
 
     def _value_equality_values_(self) -> Any:
@@ -969,7 +966,8 @@ def kak_vector(
     # The algorithm in the appendix mentioned above is slightly incorrect in
     # that it only works for elements of SU(4). A phase correction must be
     # added to deal with U(4).
-    phases = np.log(-1j * np.linalg.det(unitary)).imag + np.pi / 2
+    with np.errstate(divide="ignore", invalid="ignore"):
+        phases = np.log(-1j * np.linalg.det(unitary)).imag + np.pi / 2
     evals *= np.exp(-1j * phases / 2)[..., np.newaxis]
 
     # The following steps follow the appendix exactly.

cirq/linalg/decompositions_test.py

@@ -422,9 +422,7 @@ def test_axis_angle_decomposition_str():
     assert (
         str(
             cirq.axis_angle(
-                cirq.unitary(cirq.X**0.25)
-                @ cirq.unitary(cirq.Y**0.25)
-                @ cirq.unitary(cirq.Z**0.25)
+                cirq.unitary(cirq.X**0.25) @ cirq.unitary(cirq.Y**0.25) @ cirq.unitary(cirq.Z**0.25)
             )
         )
         == '0.477*π around 0.679*X+0.281*Y+0.679*Z'

cirq/linalg/diagonalize.py

@@ -255,10 +255,11 @@ def bidiagonalize_unitary_with_special_orthogonals(
     )
 
     # Convert to special orthogonal w/o breaking diagonalization.
-    if np.linalg.det(left) < 0:
-        left[0, :] *= -1
-    if np.linalg.det(right) < 0:
-        right[:, 0] *= -1
+    with np.errstate(divide="ignore", invalid="ignore"):
+        if np.linalg.det(left) < 0:
+            left[0, :] *= -1
+        if np.linalg.det(right) < 0:
+            right[:, 0] *= -1
 
     diag = combinators.dot(left, mat, right)
 

cirq/linalg/predicates.py

@@ -91,9 +91,10 @@ def is_special_orthogonal(matrix: np.ndarray, *, rtol: float = 1e-5, atol: float
     Returns:
         Whether the matrix is special orthogonal within the given tolerance.
     """
-    return is_orthogonal(matrix, rtol=rtol, atol=atol) and (
-        matrix.shape[0] == 0 or np.allclose(np.linalg.det(matrix), 1, rtol=rtol, atol=atol)
-    )
+    with np.errstate(divide="ignore", invalid="ignore"):
+        return is_orthogonal(matrix, rtol=rtol, atol=atol) and (
+            matrix.shape[0] == 0 or np.allclose(np.linalg.det(matrix), 1, rtol=rtol, atol=atol)
+        )
 
 
 def is_unitary(matrix: np.ndarray, *, rtol: float = 1e-5, atol: float = 1e-8) -> bool:
@@ -128,9 +129,10 @@ def is_special_unitary(matrix: np.ndarray, *, rtol: float = 1e-5, atol: float =
         Whether the matrix is unitary with unit determinant within the given
         tolerance.
     """
-    return is_unitary(matrix, rtol=rtol, atol=atol) and (
-        matrix.shape[0] == 0 or np.allclose(np.linalg.det(matrix), 1, rtol=rtol, atol=atol)
-    )
+    with np.errstate(divide="ignore", invalid="ignore"):
+        return is_unitary(matrix, rtol=rtol, atol=atol) and (
+            matrix.shape[0] == 0 or np.allclose(np.linalg.det(matrix), 1, rtol=rtol, atol=atol)
+        )
 
 
 def is_normal(matrix: np.ndarray, *, rtol: float = 1e-5, atol: float = 1e-8) -> bool:

cirq/linalg/transformations.py

@@ -592,7 +592,8 @@ def to_special(u: np.ndarray) -> np.ndarray:
     Returns:
         the special unitary matrix
     """
-    return u * (np.linalg.det(u) ** (-1 / len(u)))
+    with np.errstate(divide="ignore", invalid="ignore"):
+        return u * (np.linalg.det(u) ** (-1 / len(u)))
 
 
 def state_vector_kronecker_product(t1: np.ndarray, t2: np.ndarray) -> np.ndarray:

cirq/linalg/transformations_test.py

@@ -584,7 +584,7 @@ def test_partial_trace_of_state_vector_as_mixture_mixed_result():
         (0.5, np.array([1, 0, 0, 0]).reshape((2, 2))),
         (0.5, np.array([0, 0, 0, 1]).reshape((2, 2))),
     )
-    for (q1, q2) in [(0, 1), (0, 2), (1, 2)]:
+    for q1, q2 in [(0, 1), (0, 2), (1, 2)]:
         mixture = cirq.partial_trace_of_state_vector_as_mixture(state, [q1, q2], atol=1e-8)
         assert mixtures_equal(mixture, truth)
 

cirq/ops/__init__.py

@@ -217,3 +217,5 @@ from cirq.ops.wait_gate import wait, WaitGate
 from cirq.ops.state_preparation_channel import StatePreparationChannel
 
 from cirq.ops.control_values import AbstractControlValues, ProductOfSums, SumOfProducts
+
+from cirq.ops.uniform_superposition_gate import UniformSuperpositionGate

cirq/ops/clifford_gate.py

@@ -14,11 +14,13 @@
 
 from typing import Any, Dict, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
 
-
+import functools
+from dataclasses import dataclass
 import numpy as np
 
 from cirq import protocols, value, linalg, qis
 from cirq._import import LazyLoader
+from cirq._compat import cached_method
 from cirq.ops import common_gates, named_qubit, raw_types, pauli_gates, phased_x_z_gate
 from cirq.ops.pauli_gates import Pauli
 from cirq.type_workarounds import NotImplementedType
@@ -356,6 +358,8 @@ class CommonCliffordGates(metaclass=CommonCliffordGateMetaClass):
 class CliffordGate(raw_types.Gate, CommonCliffordGates):
     """Clifford rotation for N-qubit."""
 
+    _clifford_tableau: qis.CliffordTableau
+
     def __init__(self, *, _clifford_tableau: qis.CliffordTableau) -> None:
         # We use the Clifford tableau to represent a Clifford gate.
         # It is crucial to note that the meaning of tableau here is different
@@ -376,7 +380,7 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
         # more precisely the conjugate transformation of ZI by this gate, becomes -ZI.
         # (Note the real clifford tableau has to satify the Symplectic property.
         # here is just for illustration)
-        self._clifford_tableau = _clifford_tableau.copy()
+        object.__setattr__(self, '_clifford_tableau', _clifford_tableau.copy())
 
     @property
     def clifford_tableau(self):
@@ -396,21 +400,37 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
         # By definition, Clifford Gate should always return True.
         return True
 
-    def __pow__(self, exponent) -> 'CliffordGate':
+    def __pow__(self, exponent: float) -> 'CliffordGate':
+        if exponent != int(exponent):
+            return NotImplemented
+        exponent = int(exponent)
+
         if exponent == -1:
             return CliffordGate.from_clifford_tableau(self.clifford_tableau.inverse())
-        if exponent > 0 and int(exponent) == exponent:
-            base_tableau = self.clifford_tableau.copy()
-            for _ in range(int(exponent) - 1):
-                base_tableau = base_tableau.then(self.clifford_tableau)
-            return CliffordGate.from_clifford_tableau(base_tableau)
-        if exponent < 0 and int(exponent) == exponent:
-            base_tableau = self.clifford_tableau.copy()
-            for _ in range(int(-exponent) - 1):
-                base_tableau = base_tableau.then(self.clifford_tableau)
-            return CliffordGate.from_clifford_tableau(base_tableau.inverse())
-
-        return NotImplemented
+        if exponent == 0:
+            return CliffordGate.from_clifford_tableau(
+                qis.CliffordTableau(num_qubits=self._num_qubits_())
+            )
+        if exponent == 1:
+            return self
+
+        base_tableau = self.clifford_tableau.copy()
+        if exponent < 0:
+            base_tableau = base_tableau.inverse()
+            exponent = abs(exponent)
+
+        # https://cp-algorithms.com/algebra/binary-exp.html
+        aux = qis.CliffordTableau(
+            num_qubits=self.clifford_tableau.n
+        )  # this tableau collects the odd terms
+        while exponent > 1:
+            if exponent & 1:
+                aux = aux.then(base_tableau)
+            base_tableau = base_tableau.then(base_tableau)
+            exponent >>= 1
+
+        base_tableau = base_tableau.then(aux)
+        return CliffordGate.from_clifford_tableau(base_tableau)
 
     def __repr__(self) -> str:
         return f"Clifford Gate with Tableau:\n {self.clifford_tableau._str_full_()}"
@@ -457,6 +477,7 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
         return NotImplemented
 
 
+@dataclass(frozen=True, init=False, eq=False, repr=False)
 @value.value_equality(manual_cls=True)
 class SingleQubitCliffordGate(CliffordGate):
     """Any single qubit Clifford rotation."""
@@ -468,6 +489,7 @@ class SingleQubitCliffordGate(CliffordGate):
         return 1
 
     @staticmethod
+    @functools.cache
     def from_clifford_tableau(tableau: qis.CliffordTableau) -> 'SingleQubitCliffordGate':
         if not isinstance(tableau, qis.CliffordTableau):
             raise ValueError('Input argument has to be a CliffordTableau instance.')
@@ -679,6 +701,10 @@ class SingleQubitCliffordGate(CliffordGate):
             * {middle point of xyz in 4 Quadrant} * 120 is [[0, 1], [1, 1]]
             * {middle point of xyz in 4 Quadrant} * 240 is [[1, 1], [1, 0]]
         """
+        return self._to_phased_xz_gate
+
+    @functools.cached_property
+    def _to_phased_xz_gate(self) -> phased_x_z_gate.PhasedXZGate:
         x_to_flip, z_to_flip = self.clifford_tableau.rs
         flip_index = int(z_to_flip) * 2 + x_to_flip
         a, x, z = 0.0, 0.0, 0.0
@@ -716,7 +742,7 @@ class SingleQubitCliffordGate(CliffordGate):
             z = -0.5 if x_to_flip else 0.5
         return phased_x_z_gate.PhasedXZGate(x_exponent=x, z_exponent=z, axis_phase_exponent=a)
 
-    def __pow__(self, exponent) -> 'SingleQubitCliffordGate':
+    def __pow__(self, exponent: Union[float, int]) -> 'SingleQubitCliffordGate':
         # First to check if we can get the sqrt and negative sqrt Clifford.
         if self._get_sqrt_map().get(exponent, None):
             pow_gate = self._get_sqrt_map()[exponent].get(self, None)
@@ -761,6 +787,7 @@ class SingleQubitCliffordGate(CliffordGate):
         to, flip = self.pauli_tuple(pauli)
         return to == pauli and not flip
 
+    @cached_method
     def merged_with(self, second: 'SingleQubitCliffordGate') -> 'SingleQubitCliffordGate':
         """Returns a SingleQubitCliffordGate such that the circuits
             --output-- and --self--second--
@@ -773,6 +800,10 @@ class SingleQubitCliffordGate(CliffordGate):
         return True
 
     def _unitary_(self) -> np.ndarray:
+        return self._unitary
+
+    @functools.cached_property
+    def _unitary(self) -> np.ndarray:
         mat = np.eye(2)
         qubit = named_qubit.NamedQubit('arbitrary')
         for op in protocols.decompose_once_with_qubits(self, (qubit,)):
@@ -787,6 +818,10 @@ class SingleQubitCliffordGate(CliffordGate):
             clifford gate if applied in order. This decomposition agrees with
             cirq.unitary(self), including global phase.
         """
+        return self._decompose_gate
+
+    @functools.cached_property
+    def _decompose_gate(self) -> Sequence['cirq.Gate']:
         if self == SingleQubitCliffordGate.H:
             return [common_gates.H]
         rotations = self.decompose_rotation()
@@ -802,6 +837,10 @@ class SingleQubitCliffordGate(CliffordGate):
         Note that the combined unitary effect of these rotations may
         differ from cirq.unitary(self) by a global phase.
         """
+        return self._decompose_rotation
+
+    @functools.cached_property
+    def _decompose_rotation(self) -> Sequence[Tuple[Pauli, int]]:
         x_rot = self.pauli_tuple(pauli_gates.X)
         y_rot = self.pauli_tuple(pauli_gates.Y)
         z_rot = self.pauli_tuple(pauli_gates.Z)
@@ -895,6 +934,10 @@ class SingleQubitCliffordGate(CliffordGate):
         )
 
     def _value_equality_values_(self):
+        return self._value_equality_values
+
+    @functools.cached_property
+    def _value_equality_values(self):
         return self._clifford_tableau.matrix().tobytes() + self._clifford_tableau.rs.tobytes()
 
     def _value_equality_values_cls_(self):

cirq/ops/common_gates_test.py

@@ -87,8 +87,7 @@ def test_cz_unitary():
     )
 
     assert np.allclose(
-        cirq.unitary(cirq.CZ**0),
-        np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]),
+        cirq.unitary(cirq.CZ**0), np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])
     )
 
     assert np.allclose(

cirq/ops/control_values.py

@@ -12,10 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import abc
+from functools import cached_property
 from typing import Collection, Tuple, TYPE_CHECKING, Any, Dict, Iterator, Optional, Sequence, Union
 import itertools
 
-from cirq import protocols, value, _compat
+from cirq import protocols, value
 
 if TYPE_CHECKING:
     import cirq
@@ -144,7 +145,7 @@ class ProductOfSums(AbstractControlValues):
             (cv,) if isinstance(cv, int) else tuple(sorted(set(cv))) for cv in data
         )
 
-    @_compat.cached_property
+    @cached_property
     def is_trivial(self) -> bool:
         return self._qubit_sums == ((1,),) * self._num_qubits_()
 
@@ -252,7 +253,7 @@ class SumOfProducts(AbstractControlValues):
         if not all(len(p) == num_qubits for p in self._conjunctions):
             raise ValueError(f'Each term of {self._conjunctions} should be of length {num_qubits}.')
 
-    @_compat.cached_property
+    @cached_property
     def is_trivial(self) -> bool:
         return self._conjunctions == ((1,) * self._num_qubits_(),)
 

cirq/ops/controlled_gate_test.py

@@ -452,9 +452,7 @@ def test_extrapolatable_effect():
 
     assert cirq.ControlledGate(cirq.Z) ** 0.5 == cirq.ControlledGate(cirq.Z**0.5)
 
-    assert cirq.ControlledGate(cirq.Z).on(a, b) ** 0.5 == cirq.ControlledGate(cirq.Z**0.5).on(
-        a, b
-    )
+    assert cirq.ControlledGate(cirq.Z).on(a, b) ** 0.5 == cirq.ControlledGate(cirq.Z**0.5).on(a, b)
 
     assert cirq.ControlledGate(cirq.Z) ** 0.5 == cirq.ControlledGate(cirq.Z**0.5)