cirq-core 1.1.0.dev20221220224914__py3-none-any.whl → 1.2.0__py3-none-any.whl

cirq/ops/controlled_gate.py

@@ -28,7 +28,13 @@ from typing import (
 import numpy as np
 
 from cirq import protocols, value, _import
-from cirq.ops import raw_types, controlled_operation as cop, matrix_gates, control_values as cv
+from cirq.ops import (
+    raw_types,
+    controlled_operation as cop,
+    op_tree,
+    matrix_gates,
+    control_values as cv,
+)
 from cirq.type_workarounds import NotImplementedType
 
 if TYPE_CHECKING:
@@ -51,7 +57,7 @@ class ControlledGate(raw_types.Gate):
     def __init__(
         self,
         sub_gate: 'cirq.Gate',
-        num_controls: int = None,
+        num_controls: Optional[int] = None,
         control_values: Optional[
             Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
         ] = None,
@@ -143,7 +149,14 @@ class ControlledGate(raw_types.Gate):
     def _qid_shape_(self) -> Tuple[int, ...]:
         return self.control_qid_shape + protocols.qid_shape(self.sub_gate)
 
-    def _decompose_(self, qubits):
+    def _decompose_(
+        self, qubits: Tuple['cirq.Qid', ...]
+    ) -> Union[None, NotImplementedType, 'cirq.OP_TREE']:
+        return self._decompose_with_context_(qubits)
+
+    def _decompose_with_context_(
+        self, qubits: Tuple['cirq.Qid', ...], context: Optional['cirq.DecompositionContext'] = None
+    ) -> Union[None, NotImplementedType, 'cirq.OP_TREE']:
         if (
             protocols.has_unitary(self.sub_gate)
             and protocols.num_qubits(self.sub_gate) == 1
@@ -166,18 +179,27 @@ class ControlledGate(raw_types.Gate):
             z_sub_gate = common_gates.ZPowGate(
                 exponent=self.sub_gate.exponent, global_shift=self.sub_gate.global_shift
             )
-            kwargs = {
-                'num_controls': self.num_controls() + 1,
-                'control_values': self.control_values & cv.ProductOfSums(((1,),)),
-                'control_qid_shape': self.control_qid_shape + (2,),
-            }
+            num_controls = self.num_controls() + 1
+            control_values = self.control_values & cv.ProductOfSums(((1,),))
+            control_qid_shape = self.control_qid_shape + (2,)
             controlled_z = (
-                z_sub_gate.controlled(**kwargs)
+                z_sub_gate.controlled(
+                    num_controls=num_controls,
+                    control_values=control_values,
+                    control_qid_shape=control_qid_shape,
+                )
                 if protocols.is_parameterized(self)
-                else ControlledGate(z_sub_gate, **kwargs)
+                else ControlledGate(
+                    z_sub_gate,
+                    num_controls=num_controls,
+                    control_values=control_values,
+                    control_qid_shape=control_qid_shape,
+                )
             )
             if self != controlled_z:
-                return protocols.decompose_once_with_qubits(controlled_z, qubits, NotImplemented)
+                return protocols.decompose_once_with_qubits(
+                    controlled_z, qubits, NotImplemented, context=context
+                )
 
         if isinstance(self.sub_gate, matrix_gates.MatrixGate):
             # Default decompositions of 2/3 qubit `cirq.MatrixGate` ignores global phase, which is
@@ -185,17 +207,21 @@ class ControlledGate(raw_types.Gate):
             return NotImplemented
 
         result = protocols.decompose_once_with_qubits(
-            self.sub_gate, qubits[self.num_controls() :], NotImplemented
+            self.sub_gate,
+            qubits[self.num_controls() :],
+            NotImplemented,
+            flatten=False,
+            context=context,
         )
         if result is NotImplemented:
             return NotImplemented
 
-        decomposed: List['cirq.Operation'] = []
-        for op in result:
-            decomposed.append(
-                op.controlled_by(*qubits[: self.num_controls()], control_values=self.control_values)
-            )
-        return decomposed
+        return op_tree.transform_op_tree(
+            result,
+            lambda op: op.controlled_by(
+                *qubits[: self.num_controls()], control_values=self.control_values
+            ),
+        )
 
     def on(self, *qubits: 'cirq.Qid') -> cop.ControlledOperation:
         if len(qubits) == 0:

cirq/ops/controlled_operation.py

@@ -34,6 +34,7 @@ from cirq.ops import (
     eigen_gate,
     gate_operation,
     matrix_gates,
+    op_tree,
     raw_types,
     control_values as cv,
 )
@@ -145,7 +146,12 @@ class ControlledOperation(raw_types.Operation):
         )
 
     def _decompose_(self):
-        result = protocols.decompose_once_with_qubits(self.gate, self.qubits, NotImplemented)
+        return self._decompose_with_context_()
+
+    def _decompose_with_context_(self, context: Optional['cirq.DecompositionContext'] = None):
+        result = protocols.decompose_once_with_qubits(
+            self.gate, self.qubits, NotImplemented, flatten=False, context=context
+        )
         if result is not NotImplemented:
             return result
 
@@ -154,13 +160,15 @@ class ControlledOperation(raw_types.Operation):
             # local phase in the controlled variant and hence cannot be ignored.
             return NotImplemented
 
-        result = protocols.decompose_once(self.sub_operation, NotImplemented)
+        result = protocols.decompose_once(
+            self.sub_operation, NotImplemented, flatten=False, context=context
+        )
         if result is NotImplemented:
             return NotImplemented
 
-        return [
-            op.controlled_by(*self.controls, control_values=self.control_values) for op in result
-        ]
+        return op_tree.transform_op_tree(
+            result, lambda op: op.controlled_by(*self.controls, control_values=self.control_values)
+        )
 
     def _value_equality_values_(self):
         sorted_controls, expanded_cvals = tuple(

cirq/ops/dense_pauli_string.py

@@ -27,11 +27,10 @@ from typing import (
     overload,
     Sequence,
     Tuple,
-    Type,
     TYPE_CHECKING,
-    TypeVar,
     Union,
 )
+from typing_extensions import Self
 
 import numpy as np
 import sympy
@@ -53,8 +52,6 @@ PAULI_GATES: List[Union['cirq.Pauli', 'cirq.IdentityGate']] = [
     pauli_gates.Z,
 ]
 
-TCls = TypeVar('TCls', bound='BaseDensePauliString')
-
 
 @value.value_equality(approximate=True, distinct_child_types=True)
 class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
@@ -132,7 +129,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
         return self.coefficient, tuple(PAULI_CHARS[p] for p in self.pauli_mask)
 
     @classmethod
-    def one_hot(cls: Type[TCls], *, index: int, length: int, pauli: 'cirq.PAULI_GATE_LIKE') -> TCls:
+    def one_hot(cls, *, index: int, length: int, pauli: 'cirq.PAULI_GATE_LIKE') -> Self:
         """Creates a dense pauli string with only one non-identity Pauli.
 
         Args:
@@ -149,7 +146,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
         return concrete_cls(pauli_mask=mask)
 
     @classmethod
-    def eye(cls: Type[TCls], length: int) -> TCls:
+    def eye(cls, length: int) -> Self:
         """Creates a dense pauli string containing only identity gates.
 
         Args:
@@ -198,7 +195,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
     def _parameter_names_(self) -> AbstractSet[str]:
         return protocols.parameter_names(self.coefficient)
 
-    def _resolve_parameters_(self: TCls, resolver: 'cirq.ParamResolver', recursive: bool) -> TCls:
+    def _resolve_parameters_(self, resolver: 'cirq.ParamResolver', recursive: bool) -> Self:
         return self.copy(
             coefficient=protocols.resolve_parameters(self.coefficient, resolver, recursive)
         )
@@ -206,7 +203,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
     def __pos__(self):
         return self
 
-    def __pow__(self: TCls, power: Union[int, float]) -> Union[NotImplementedType, TCls]:
+    def __pow__(self, power: Union[int, float]) -> Union[NotImplementedType, Self]:
         concrete_class = type(self)
         if isinstance(power, int):
             i_group = [1, +1j, -1, -1j]
@@ -221,11 +218,11 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
         return NotImplemented
 
     @overload
-    def __getitem__(self: TCls, item: int) -> Union['cirq.Pauli', 'cirq.IdentityGate']:
+    def __getitem__(self, item: int) -> Union['cirq.Pauli', 'cirq.IdentityGate']:
         pass
 
     @overload
-    def __getitem__(self: TCls, item: slice) -> TCls:
+    def __getitem__(self, item: slice) -> Self:
         pass
 
     def __getitem__(self, item):
@@ -304,7 +301,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
 
         return NotImplemented
 
-    def tensor_product(self: TCls, other: 'BaseDensePauliString') -> TCls:
+    def tensor_product(self, other: 'BaseDensePauliString') -> Self:
         """Concatenates dense pauli strings and multiplies their coefficients.
 
         Args:
@@ -319,7 +316,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
             pauli_mask=np.concatenate([self.pauli_mask, other.pauli_mask]),
         )
 
-    def __abs__(self: TCls) -> TCls:
+    def __abs__(self) -> Self:
         coef = self.coefficient
         return type(self)(
             coefficient=sympy.Abs(coef) if isinstance(coef, sympy.Expr) else abs(coef),
@@ -405,10 +402,10 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
 
     @abc.abstractmethod
     def copy(
-        self: TCls,
+        self,
         coefficient: Optional[Union[sympy.Expr, int, float, complex]] = None,
         pauli_mask: Union[None, str, Iterable[int], np.ndarray] = None,
-    ) -> TCls:
+    ) -> Self:
         """Returns a copy with possibly modified contents.
 
         Args:
@@ -492,17 +489,15 @@ class MutableDensePauliString(BaseDensePauliString):
     """
 
     @overload
-    def __setitem__(
-        self: 'MutableDensePauliString', key: int, value: 'cirq.PAULI_GATE_LIKE'
-    ) -> 'MutableDensePauliString':
+    def __setitem__(self, key: int, value: 'cirq.PAULI_GATE_LIKE') -> Self:
         pass
 
     @overload
     def __setitem__(
-        self: 'MutableDensePauliString',
+        self,
         key: slice,
         value: Union[Iterable['cirq.PAULI_GATE_LIKE'], np.ndarray, BaseDensePauliString],
-    ) -> 'MutableDensePauliString':
+    ) -> Self:
         pass
 
     def __setitem__(self, key, value):

cirq/ops/diagonal_gate.py

@@ -147,7 +147,7 @@ class DiagonalGate(raw_types.Gate):
             diag_str += ', '.join(proper_repr(angle) for angle in rounded_angles[-2:])
             diag_str = f'diag({diag_str})'
         return protocols.CircuitDiagramInfo(
-            [diag_str] + ['#' + str(i) for i in range(2, self._num_qubits_() + 1)]
+            [diag_str] + [f"#{i}" for i in range(2, self._num_qubits_() + 1)]
         )
 
     def __pow__(self, exponent: Any) -> 'DiagonalGate':
@@ -213,6 +213,5 @@ class DiagonalGate(raw_types.Gate):
         return protocols.obj_to_dict_helper(self, attribute_names=["diag_angles_radians"])
 
     def __repr__(self) -> str:
-        return 'cirq.DiagonalGate([{}])'.format(
-            ','.join(proper_repr(angle) for angle in self._diag_angles_radians)
-        )
+        angles = ','.join(proper_repr(angle) for angle in self._diag_angles_radians)
+        return f'cirq.DiagonalGate([{angles}])'

cirq/ops/eigen_gate.py

@@ -11,7 +11,10 @@
 # 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 abc
 import fractions
+import math
+import numbers
 from typing import (
     AbstractSet,
     Any,
@@ -23,25 +26,20 @@ from typing import (
     Optional,
     Tuple,
     TYPE_CHECKING,
-    TypeVar,
     Union,
 )
-import abc
-import math
-import numbers
 
 import numpy as np
 import sympy
 
 from cirq import value, protocols
+from cirq.linalg import tolerance
 from cirq.ops import raw_types
 from cirq.type_workarounds import NotImplementedType
 
 if TYPE_CHECKING:
     import cirq
 
-TSelf = TypeVar('TSelf', bound='EigenGate')
-
 
 EigenComponent = NamedTuple(
     'EigenComponent',
@@ -135,7 +133,7 @@ class EigenGate(raw_types.Gate):
         return self._global_shift
 
     # virtual method
-    def _with_exponent(self: TSelf, exponent: value.TParamVal) -> 'EigenGate':
+    def _with_exponent(self, exponent: value.TParamVal) -> 'EigenGate':
         """Return the same kind of gate, but with a different exponent.
 
         Child classes should override this method if they have an __init__
@@ -301,7 +299,7 @@ class EigenGate(raw_types.Gate):
         real_periods = [abs(2 / e) for e in exponents if e != 0]
         return _approximate_common_period(real_periods)
 
-    def __pow__(self: TSelf, exponent: Union[float, sympy.Symbol]) -> 'EigenGate':
+    def __pow__(self, exponent: Union[float, sympy.Symbol]) -> 'EigenGate':
         new_exponent = protocols.mul(self._exponent, exponent, NotImplemented)
         if new_exponent is NotImplemented:
             return NotImplemented
@@ -388,8 +386,8 @@ class EigenGate(raw_types.Gate):
             return False
 
         period = self_without_phase._period()
-        canonical_diff = (exponents[0] - exponents[1]) % period
-        return np.isclose(canonical_diff, 0, atol=atol)
+        exponents_diff = exponents[0] - exponents[1]
+        return tolerance.near_zero_mod(exponents_diff, period, atol=atol)
 
     def _json_dict_(self) -> Dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['exponent', 'global_shift'])

cirq/ops/eigen_gate_test.py

@@ -363,6 +363,12 @@ class WeightedZPowGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
         (cirq.X, cirq.Y, False),
         (cirq.rz(np.pi), cirq.Z, True),
         (cirq.X**0.3, cirq.Z**0.3, False),
+        (cirq.Z, cirq.Z ** (1 - 1e-10), True),
+        (cirq.Z, cirq.Z ** (1 + 1e-10), True),
+        (cirq.Z, cirq.Z ** (3 - 1e-10), True),
+        (cirq.Z, cirq.Z ** (3 + 1e-10), True),
+        (cirq.Z**2, cirq.Z ** (4 - 1e-10), True),
+        (cirq.Z**2, cirq.Z ** (4 + 1e-10), True),
     ],
 )
 def test_equal_up_to_global_phase(gate1, gate2, eq_up_to_global_phase):

cirq/ops/gate_operation.py

@@ -31,6 +31,7 @@ from typing import (
     Union,
     List,
 )
+from typing_extensions import Self
 
 import numpy as np
 
@@ -42,9 +43,6 @@ if TYPE_CHECKING:
     import cirq
 
 
-TSelf = TypeVar('TSelf', bound='GateOperation')
-
-
 @value.value_equality(approximate=True)
 class GateOperation(raw_types.Operation):
     """An application of a gate to a sequence of qubits.
@@ -73,8 +71,8 @@ class GateOperation(raw_types.Operation):
         """The qubits targeted by the operation."""
         return self._qubits
 
-    def with_qubits(self: TSelf, *new_qubits: 'cirq.Qid') -> TSelf:
-        return cast(TSelf, self.gate.on(*new_qubits))
+    def with_qubits(self, *new_qubits: 'cirq.Qid') -> Self:
+        return cast(Self, self.gate.on(*new_qubits))
 
     def with_gate(self, new_gate: 'cirq.Gate') -> 'cirq.Operation':
         if self.gate is new_gate:
@@ -162,7 +160,14 @@ class GateOperation(raw_types.Operation):
         return len(self._qubits)
 
     def _decompose_(self) -> 'cirq.OP_TREE':
-        return protocols.decompose_once_with_qubits(self.gate, self.qubits, NotImplemented)
+        return self._decompose_with_context_()
+
+    def _decompose_with_context_(
+        self, context: Optional['cirq.DecompositionContext'] = None
+    ) -> 'cirq.OP_TREE':
+        return protocols.decompose_once_with_qubits(
+            self.gate, self.qubits, NotImplemented, flatten=False, context=context
+        )
 
     def _pauli_expansion_(self) -> value.LinearDict[str]:
         getter = getattr(self.gate, '_pauli_expansion_', None)

cirq/ops/gate_operation_test.py

@@ -41,10 +41,19 @@ def test_immutable():
     a, b = cirq.LineQubit.range(2)
     op = cirq.X(a)
 
-    with pytest.raises(AttributeError, match="can't set attribute"):
+    # Match one of two strings. The second one is message returned since python 3.11.
+    with pytest.raises(
+        AttributeError,
+        match="(can't set attribute)|"
+        "(property 'gate' of 'SingleQubitPauliStringGateOperation' object has no setter)",
+    ):
         op.gate = cirq.Y
 
-    with pytest.raises(AttributeError, match="can't set attribute"):
+    with pytest.raises(
+        AttributeError,
+        match="(can't set attribute)|"
+        "(property 'qubits' of 'SingleQubitPauliStringGateOperation' object has no setter)",
+    ):
         op.qubits = [b]
 
 

cirq/ops/gateset.py

@@ -257,11 +257,12 @@ class GateFamily:
 
     def _value_equality_values_(self) -> Any:
         # `isinstance` is used to ensure the a gate type and gate instance is not compared.
+        description = self.description if self.description != self._default_description() else None
         return (
             isinstance(self.gate, raw_types.Gate),
             self.gate,
             self.name,
-            self.description,
+            description,
             self._ignore_global_phase,
             self._tags_to_accept,
             self._tags_to_ignore,

cirq/ops/gateset_test.py

@@ -37,8 +37,10 @@ class CustomXPowGate(cirq.EigenGate):
             if self._exponent == 1:
                 return 'cirq.ops.gateset_test.CustomX'
             return f'(cirq.ops.gateset_test.CustomX**{proper_repr(self._exponent)})'
-        return 'cirq.ops.gateset_test.CustomXPowGate(exponent={}, global_shift={!r})'.format(
-            proper_repr(self._exponent), self._global_shift
+        return (
+            'cirq.ops.gateset_test.CustomXPowGate('
+            f'exponent={proper_repr(self._exponent)}, '
+            f'global_shift={self._global_shift!r})'
         )
 
     def _num_qubits_(self) -> int:
@@ -81,6 +83,27 @@ def test_gate_family_default_name_and_description(gate, tags_to_accept, tags_to_
     assert (ignored_match is None) == (tags_to_ignore == [])
 
 
+@pytest.mark.parametrize(
+    'tags_to_accept_fam1, tags_to_ignore_fam1, tags_to_accept_fam2, tags_to_ignore_fam2',
+    [
+        (tuple("ab"), tuple("cd"), tuple("ba"), tuple("dc")),
+        (tuple("ab"), [], tuple("ba"), []),
+        ([], tuple("ab"), [], tuple("ba")),
+    ],
+)
+def test_gate_family_equality_with_tags(
+    tags_to_accept_fam1, tags_to_ignore_fam1, tags_to_accept_fam2, tags_to_ignore_fam2
+):
+    gate_fam1 = cirq.GateFamily(
+        cirq.X, tags_to_accept=tags_to_accept_fam1, tags_to_ignore=tags_to_ignore_fam1
+    )
+    gate_fam2 = cirq.GateFamily(
+        cirq.X, tags_to_accept=tags_to_accept_fam2, tags_to_ignore=tags_to_ignore_fam2
+    )
+
+    assert gate_fam1 == gate_fam2
+
+
 def test_invalid_gate_family():
     with pytest.raises(ValueError, match='instance or subclass of `cirq.Gate`'):
         _ = cirq.GateFamily(gate=cirq.Operation)
@@ -94,11 +117,21 @@ def test_invalid_gate_family():
 
 def test_gate_family_immutable():
     g = cirq.GateFamily(CustomX)
-    with pytest.raises(AttributeError, match="can't set attribute"):
+    # Match one of two strings. The second one is message returned since python 3.11.
+    with pytest.raises(
+        AttributeError,
+        match="(can't set attribute)|(property 'gate' of 'GateFamily' object has no setter)",
+    ):
         g.gate = CustomXPowGate
-    with pytest.raises(AttributeError, match="can't set attribute"):
+    with pytest.raises(
+        AttributeError,
+        match="(can't set attribute)|(property 'name' of 'GateFamily' object has no setter)",
+    ):
         g.name = 'new name'
-    with pytest.raises(AttributeError, match="can't set attribute"):
+    with pytest.raises(
+        AttributeError,
+        match="(can't set attribute)|(property 'description' of 'GateFamily' object has no setter)",
+    ):
         g.description = 'new description'
 
 

cirq/ops/global_phase_op.py

@@ -13,14 +13,14 @@
 # limitations under the License.
 """A no-qubit global phase operation."""
 
-from typing import AbstractSet, Any, cast, Dict, Sequence, Tuple, Union
+from typing import AbstractSet, Any, cast, Dict, Sequence, Tuple, Union, Optional, Collection
 
 import numpy as np
 import sympy
 
 import cirq
 from cirq import value, protocols
-from cirq.ops import raw_types
+from cirq.ops import raw_types, controlled_gate, control_values as cv
 from cirq.type_workarounds import NotImplementedType
 
 
@@ -91,6 +91,32 @@ class GlobalPhaseGate(raw_types.Gate):
         coefficient = protocols.resolve_parameters(self.coefficient, resolver, recursive)
         return GlobalPhaseGate(coefficient=coefficient)
 
+    def controlled(
+        self,
+        num_controls: Optional[int] = None,
+        control_values: Optional[
+            Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
+        ] = None,
+        control_qid_shape: Optional[Tuple[int, ...]] = None,
+    ) -> raw_types.Gate:
+        result = super().controlled(num_controls, control_values, control_qid_shape)
+        if (
+            not self._is_parameterized_()
+            and isinstance(result, controlled_gate.ControlledGate)
+            and isinstance(result.control_values, cv.ProductOfSums)
+            and result.control_values[-1] == (1,)
+            and result.control_qid_shape[-1] == 2
+        ):
+            # A `GlobalPhaseGate` controlled on a qubit in state `|1>` is equivalent
+            # to applying a `ZPowGate`. This override ensures that `global_phase_gate.controlled()`
+            # returns a `ZPowGate` instead of a `ControlledGate(sub_gate=global_phase_gate)`.
+            coefficient = complex(self.coefficient)
+            exponent = float(np.angle(coefficient) / np.pi)
+            return cirq.ZPowGate(exponent=exponent).controlled(
+                result.num_controls() - 1, result.control_values[:-1], result.control_qid_shape[:-1]
+            )
+        return result
+
 
 def global_phase_operation(
     coefficient: 'cirq.TParamValComplex', atol: float = 1e-8

cirq/ops/global_phase_op_test.py

@@ -279,3 +279,24 @@ def test_resolve_error(resolve_fn):
     gpt = cirq.GlobalPhaseGate(coefficient=t)
     with pytest.raises(ValueError, match='Coefficient is not unitary'):
         resolve_fn(gpt, {'t': -2})
+
+
+@pytest.mark.parametrize(
+    'coeff, exp', [(-1, 1), (1j, 0.5), (-1j, -0.5), (1 / np.sqrt(2) * (1 + 1j), 0.25)]
+)
+def test_global_phase_gate_controlled(coeff, exp):
+    g = cirq.GlobalPhaseGate(coeff)
+    op = cirq.global_phase_operation(coeff)
+    q = cirq.LineQubit.range(3)
+    for num_controls, target_gate in zip(range(1, 4), [cirq.Z, cirq.CZ, cirq.CCZ]):
+        assert g.controlled(num_controls) == target_gate**exp
+        np.testing.assert_allclose(
+            cirq.unitary(cirq.ControlledGate(g, num_controls)),
+            cirq.unitary(g.controlled(num_controls)),
+        )
+        assert op.controlled_by(*q[:num_controls]) == target_gate(*q[:num_controls]) ** exp
+    assert g.controlled(control_values=[0]) == cirq.ControlledGate(g, control_values=[0])
+    xor_control_values = cirq.SumOfProducts(((0, 0), (1, 1)))
+    assert g.controlled(control_values=xor_control_values) == cirq.ControlledGate(
+        g, control_values=xor_control_values
+    )

cirq/ops/identity.py

@@ -42,7 +42,7 @@ class IdentityGate(raw_types.Gate):
         """Inits IdentityGate.
 
         Args:
-            num_qubits: The number of qubits for the idenity gate.
+            num_qubits: The number of qubits for the identity gate.
             qid_shape: Specifies the dimension of each qid the measurement
                 applies to.  The default is 2 for every qubit.
 

cirq/ops/kraus_channel_test.py

@@ -105,8 +105,8 @@ def test_kraus_channel_repr():
         repr(x_meas)
         == """\
 cirq.KrausChannel(kraus_ops=[\
-np.array([[(0.5+0j), (0.5+0j)], [(0.5+0j), (0.5+0j)]], dtype=np.complex64), \
-np.array([[(0.5+0j), (-0.5+0j)], [(-0.5+0j), (0.5+0j)]], dtype=np.complex64)], \
+np.array([[(0.5+0j), (0.5+0j)], [(0.5+0j), (0.5+0j)]], dtype=np.dtype('complex64')), \
+np.array([[(0.5+0j), (-0.5+0j)], [(-0.5+0j), (0.5+0j)]], dtype=np.dtype('complex64'))], \
 key='x_meas')"""
     )
 

cirq/ops/linear_combinations.py

@@ -11,6 +11,7 @@
 # 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 collections import defaultdict
 from typing import (
     AbstractSet,
@@ -440,7 +441,7 @@ class PauliSum:
     def wrap(val: PauliSumLike) -> 'PauliSum':
         """Convert a `cirq.PauliSumLike` object to a PauliSum
 
-        Attemps to convert an existing int, float, complex, `cirq.PauliString`,
+        Attempts to convert an existing int, float, complex, `cirq.PauliString`,
         `cirq.PauliSum` or `cirq.SingleQubitPauliStringGateOperation` into
         a `cirq.PauliSum` object. For example:
 
@@ -651,7 +652,7 @@ class PauliSum:
         if any(abs(p.coefficient.imag) > 0.0001 for p in self):
             raise NotImplementedError(
                 "Cannot compute expectation value of a non-Hermitian "
-                "PauliString <{}>. Coefficient must be real.".format(self)
+                f"PauliString <{self}>. Coefficient must be real."
             )
 
         # TODO: Avoid enforce specific complex type. This is necessary to
@@ -713,7 +714,7 @@ class PauliSum:
         if any(abs(p.coefficient.imag) > 0.0001 for p in self):
             raise NotImplementedError(
                 "Cannot compute expectation value of a non-Hermitian "
-                "PauliString <{}>. Coefficient must be real.".format(self)
+                f"PauliString <{self}>. Coefficient must be real."
             )
 
         # FIXME: Avoid enforce specific complex type. This is necessary to
@@ -839,10 +840,10 @@ class PauliSum:
         if exponent == 0:
             return PauliSum(value.LinearDict({frozenset(): 1 + 0j}))
         if exponent > 0:
-            base = self.copy()
+            result = self.copy()
             for _ in range(exponent - 1):
-                base *= base
-            return base
+                result *= self
+            return result
         return NotImplemented
 
     def __truediv__(self, a: value.Scalar):