cirq-core 1.7.0.dev20250825174419__py3-none-any.whl → 1.7.0.dev20251203004401__py3-none-any.whl

cirq/ops/linear_combinations_test.py

@@ -975,10 +975,16 @@ def test_paulisum_validation() -> None:
     ps += cirq.I(cirq.LineQubit(0))
     assert ps == cirq.PauliSum(cirq.LinearDict({frozenset(): complex(1)}))
 
+    ps = cirq.I(cirq.LineQubit(0)) + cirq.PauliSum()
+    assert ps == cirq.PauliSum(cirq.LinearDict({frozenset(): complex(1)}))
+
     ps = cirq.PauliSum()
     ps -= cirq.I(cirq.LineQubit(0))
     assert ps == cirq.PauliSum(cirq.LinearDict({frozenset(): complex(-1)}))
 
+    ps = cirq.I(cirq.LineQubit(0)) - cirq.PauliSum()
+    assert ps == cirq.PauliSum(cirq.LinearDict({frozenset(): complex(1)}))
+
 
 def test_add_number_paulisum() -> None:
     q = cirq.LineQubit.range(2)
@@ -1008,6 +1014,22 @@ def test_add_number_paulistring() -> None:
         == cirq.PauliSum.from_pauli_strings([cirq.PauliString() * 2, cirq.PauliString({a: cirq.X})])
     )
 
+    assert (
+        cirq.X(a) - 2
+        == -2 + cirq.X(a)
+        == cirq.PauliSum.from_pauli_strings(
+            [cirq.PauliString() * -2, cirq.PauliString({a: cirq.X})]
+        )
+    )
+
+    assert (
+        2 - cirq.X(a)
+        == 2 + -cirq.X(a)
+        == cirq.PauliSum.from_pauli_strings(
+            [cirq.PauliString() * 2, -cirq.PauliString({a: cirq.X})]
+        )
+    )
+
 
 def test_pauli_sum_formatting() -> None:
     q = cirq.LineQubit.range(2)
@@ -1430,7 +1452,7 @@ def test_expectation_from_density_matrix_invalid_input() -> None:
     with pytest.raises(ValueError, match='shape'):
         psum.expectation_from_density_matrix(rho.reshape((8, 8, 1)), q_map)
     with pytest.raises(ValueError, match='shape'):
-        psum.expectation_from_density_matrix(rho.reshape((-1)), q_map)
+        psum.expectation_from_density_matrix(rho.reshape((-1,)), q_map)
 
 
 def test_expectation_from_density_matrix_check_preconditions() -> None:

cirq/ops/matrix_gates.py

@@ -16,7 +16,8 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterable, TYPE_CHECKING
+from collections.abc import Iterable
+from typing import Any, TYPE_CHECKING
 
 import numpy as np
 

cirq/ops/measure_util.py

@@ -14,12 +14,13 @@
 
 from __future__ import annotations
 
-from typing import Callable, Iterable, overload, TYPE_CHECKING
+from collections.abc import Callable, Iterable
+from typing import cast, overload, TYPE_CHECKING
 
 import numpy as np
 
 from cirq import protocols
-from cirq.ops import pauli_string, raw_types
+from cirq.ops import gate_operation, pauli_string, raw_types
 from cirq.ops.measurement_gate import MeasurementGate
 from cirq.ops.pauli_measurement_gate import PauliMeasurementGate
 
@@ -96,7 +97,7 @@ def measure(
     key: str | cirq.MeasurementKey | None = None,
     invert_mask: tuple[bool, ...] = (),
     confusion_map: dict[tuple[int, ...], np.ndarray] | None = None,
-) -> raw_types.Operation:
+) -> gate_operation.GateOperation:
     pass
 
 
@@ -107,7 +108,7 @@ def measure(
     key: str | cirq.MeasurementKey | None = None,
     invert_mask: tuple[bool, ...] = (),
     confusion_map: dict[tuple[int, ...], np.ndarray] | None = None,
-) -> raw_types.Operation:
+) -> gate_operation.GateOperation:
     pass
 
 
@@ -116,7 +117,7 @@ def measure(
     key: str | cirq.MeasurementKey | None = None,
     invert_mask: tuple[bool, ...] = (),
     confusion_map: dict[tuple[int, ...], np.ndarray] | None = None,
-) -> raw_types.Operation:
+) -> gate_operation.GateOperation:
     """Returns a single MeasurementGate applied to all the given qubits.
 
     The qubits are measured in the computational basis. This can also be
@@ -161,7 +162,8 @@ def measure(
     if key is None:
         key = _default_measurement_key(targets)
     qid_shape = protocols.qid_shape(targets)
-    return MeasurementGate(len(targets), key, invert_mask, qid_shape, confusion_map).on(*targets)
+    gate = MeasurementGate(len(targets), key, invert_mask, qid_shape, confusion_map)
+    return cast(gate_operation.GateOperation, gate.on(*targets))
 
 
 M = measure

cirq/ops/measurement_gate.py

@@ -14,7 +14,8 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterable, Mapping, Sequence, TYPE_CHECKING
+from collections.abc import Iterable, Mapping, Sequence
+from typing import Any, TYPE_CHECKING
 
 import numpy as np
 

cirq/ops/mixed_unitary_channel.py

@@ -2,7 +2,8 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterable, Mapping, TYPE_CHECKING
+from collections.abc import Iterable, Mapping
+from typing import Any, TYPE_CHECKING
 
 import numpy as np
 

cirq/ops/named_qubit.py

@@ -148,7 +148,7 @@ class NamedQid(_BaseNamedQid):
 
     @staticmethod
     def range(*args, prefix: str, dimension: int) -> list[NamedQid]:
-        """Returns a range of ``NamedQid``\\s.
+        """Returns a range of ``NamedQid``s.
 
         The range returned starts with the prefix, and followed by a qid for
         each number in the range, e.g.:
@@ -166,7 +166,7 @@ class NamedQid(_BaseNamedQid):
             dimension: The dimension of the qid's Hilbert space, i.e.
                 the number of quantum levels.
         Returns:
-            A list of ``NamedQid``\\s.
+            A list of ``NamedQid``s.
         """
         return [NamedQid(f"{prefix}{i}", dimension=dimension) for i in range(*args)]
 

cirq/ops/op_tree.py

@@ -16,7 +16,8 @@
 
 from __future__ import annotations
 
-from typing import Callable, Iterable, Iterator, NoReturn, TYPE_CHECKING
+from collections.abc import Callable, Iterable, Iterator
+from typing import NoReturn, TYPE_CHECKING
 
 from cirq._doc import document
 from cirq._import import LazyLoader

cirq/ops/parallel_gate.py

@@ -14,8 +14,9 @@
 
 from __future__ import annotations
 
+from collections.abc import Set
 from types import NotImplementedType
-from typing import AbstractSet, Any, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
 
 import numpy as np
 
@@ -90,7 +91,7 @@ class ParallelGate(raw_types.Gate):
     def _is_parameterized_(self) -> bool:
         return protocols.is_parameterized(self.sub_gate)
 
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         return protocols.parameter_names(self.sub_gate)
 
     def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> ParallelGate:

cirq/ops/parity_gates.py

@@ -16,7 +16,8 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterator, Self, Sequence, TYPE_CHECKING
+from collections.abc import Iterator, Sequence
+from typing import Any, Self, TYPE_CHECKING
 
 import numpy as np
 

cirq/ops/parity_gates_test.py

@@ -352,3 +352,38 @@ def test_clifford_protocols(
     else:
         assert not cirq.has_stabilizer_effect(gate)
         assert gate._decompose_into_clifford_with_qubits_(cirq.LineQubit.range(2)) is NotImplemented
+
+
+def test_parity_gate_multiplication():
+    q1, q2, q3 = cirq.LineQubit.range(3)
+
+    # XX gate
+    xx_12 = cirq.XX(q1, q2)
+    xx_23 = cirq.XX(q2, q3)
+    result = xx_12 * xx_23
+    expected = cirq.PauliString({q1: cirq.X, q3: cirq.X})
+    assert result == expected
+
+    # YY gate
+    yy_12 = cirq.YY(q1, q2)
+    yy_23 = cirq.YY(q2, q3)
+    result_yy = yy_12 * yy_23
+    expected_yy = cirq.PauliString({q1: cirq.Y, q3: cirq.Y})
+    assert result_yy == expected_yy
+
+    # ZZ gate
+    zz_12 = cirq.ZZ(q1, q2)
+    zz_23 = cirq.ZZ(q2, q3)
+    result_zz = zz_12 * zz_23
+    expected_zz = cirq.PauliString({q1: cirq.Z, q3: cirq.Z})
+    assert result_zz == expected_zz
+
+
+def test_parity_gate_multiplication_same_qubits():
+    q1, q2 = cirq.LineQubit.range(2)
+
+    # XX * XX should be identity
+    xx = cirq.XX(q1, q2)
+    result = xx * xx
+    expected = cirq.PauliString({q1: cirq.I, q2: cirq.I})
+    assert result == expected

cirq/ops/pauli_interaction_gate.py

@@ -14,7 +14,8 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterator, Sequence, TYPE_CHECKING
+from collections.abc import Iterator, Sequence
+from typing import Any, TYPE_CHECKING
 
 import numpy as np
 

cirq/ops/pauli_measurement_gate.py

@@ -14,7 +14,8 @@
 
 from __future__ import annotations
 
-from typing import Any, cast, Iterable, Iterator, Mapping, Sequence, TYPE_CHECKING
+from collections.abc import Iterable, Iterator, Mapping, Sequence
+from typing import Any, cast, TYPE_CHECKING
 
 from cirq import protocols, value
 from cirq.ops import (

cirq/ops/pauli_string.py

@@ -17,25 +17,19 @@ from __future__ import annotations
 import cmath
 import math
 import numbers
-from types import NotImplementedType
-from typing import (
-    AbstractSet,
-    Any,
+from collections.abc import (
     Callable,
-    cast,
-    Generic,
     ItemsView,
     Iterable,
     Iterator,
     KeysView,
     Mapping,
-    overload,
     Sequence,
-    TYPE_CHECKING,
-    TypeVar,
-    Union,
+    Set,
     ValuesView,
 )
+from types import NotImplementedType
+from typing import Any, cast, Generic, overload, TYPE_CHECKING, TypeVar, Union
 
 import numpy as np
 import sympy
@@ -266,16 +260,9 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         pass
 
     def __mul__(self, other):
-        known = False
-        if isinstance(other, raw_types.Operation) and isinstance(other.gate, identity.IdentityGate):
-            known = True
-        elif isinstance(other, (PauliString, numbers.Number)):
-            known = True
-        if known:
+        if isinstance(other, (PauliString, numbers.Number)):
             return PauliString(
-                cast(PAULI_STRING_LIKE, other),
-                qubit_pauli_map=self._qubit_pauli_map,
-                coefficient=self.coefficient,
+                other, qubit_pauli_map=self._qubit_pauli_map, coefficient=self.coefficient
             )
         return NotImplemented
 
@@ -295,9 +282,6 @@ class PauliString(raw_types.Operation, Generic[TKey]):
                 qubit_pauli_map=self._qubit_pauli_map, coefficient=self._coefficient * other
             )
 
-        if isinstance(other, raw_types.Operation) and isinstance(other.gate, identity.IdentityGate):
-            return self  # pragma: no cover
-
         # Note: PauliString case handled by __mul__.
         return NotImplemented
 
@@ -1008,7 +992,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         """
         return self.conjugated_by(ops)
 
-    @deprecated(deadline="v2.0", fix="Use conjuagetd_by()/before()/after() instead.")
+    @deprecated(deadline="v2.0", fix="Use conjugated_by(), before(), or after() instead.")
     def pass_operations_over(
         self, ops: Iterable[cirq.Operation], after_to_before: bool = False
     ) -> PauliString:  # pragma: no cover
@@ -1050,7 +1034,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
     def _is_parameterized_(self) -> bool:
         return protocols.is_parameterized(self.coefficient)
 
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         return protocols.parameter_names(self.coefficient)
 
     def _resolve_parameters_(
@@ -1100,21 +1084,33 @@ def _validate_qubit_mapping(
         )
 
 
-def _try_interpret_as_pauli_string(op: Any):
+def _try_interpret_as_pauli_string(op: Any) -> PauliString | None:
     """Return a reprepresentation of an operation as a pauli string, if it is possible."""
-    if isinstance(op, gate_operation.GateOperation):
-        gates = {
-            common_gates.XPowGate: pauli_gates.X,
-            common_gates.YPowGate: pauli_gates.Y,
-            common_gates.ZPowGate: pauli_gates.Z,
-        }
-        if (pauli := gates.get(type(op.gate), None)) is not None:
-            exponent = op.gate.exponent  # type: ignore
-            if exponent % 2 == 0:
-                return PauliString()
-            if exponent % 2 == 1:
-                return pauli.on(op.qubits[0])
-    return None
+    if not isinstance(op, raw_types.Operation):
+        return None
+
+    if isinstance(op, PauliString):
+        return op
+
+    # optimize for integer exponents of Pauli gates
+    cached_gates: dict[type[cirq.Gate | None], cirq.Pauli] = {
+        common_gates.XPowGate: pauli_gates.X,
+        common_gates.YPowGate: pauli_gates.Y,
+        common_gates.ZPowGate: pauli_gates.Z,
+    }
+    if (pauli := cached_gates.get(type(op.gate))) is not None:
+        exponent = op.gate.exponent  # type: ignore
+        if exponent % 2 == 0:
+            return PauliString()
+        if exponent % 2 == 1:
+            return pauli.on(op.qubits[0])
+        return None
+
+    pauli_expansion_op = protocols.pauli_expansion(op, default=None)
+    if pauli_expansion_op is None or len(pauli_expansion_op) != 1:
+        return None
+    gates, coef = next(iter(pauli_expansion_op.items()))
+    return PauliString(dict(zip(op.qubits, gates)), coefficient=coef)
 
 
 # Ignoring type because mypy believes `with_qubits` methods are incompatible.
@@ -1148,27 +1144,11 @@ class SingleQubitPauliStringGateOperation(  # type: ignore
         assert len(self.qubits) == 1
         return self.qubits[0]
 
-    def _as_pauli_string(self) -> PauliString:
-        return PauliString(qubit_pauli_map={self.qubit: self.pauli})
-
     def __mul__(self, other):
-        if isinstance(other, SingleQubitPauliStringGateOperation):
-            return self._as_pauli_string() * other._as_pauli_string()
-        if isinstance(other, (PauliString, numbers.Complex)):
-            return self._as_pauli_string() * other
-        if (as_pauli_string := _try_interpret_as_pauli_string(other)) is not None:
-            return self * as_pauli_string
-        return NotImplemented
+        return PauliString.__mul__(self, other)
 
     def __rmul__(self, other):
-        if isinstance(other, (PauliString, numbers.Complex)):
-            return other * self._as_pauli_string()
-        if (as_pauli_string := _try_interpret_as_pauli_string(other)) is not None:
-            return as_pauli_string * self
-        return NotImplemented
-
-    def __neg__(self):
-        return -self._as_pauli_string()
+        return PauliString.__rmul__(self, other)
 
     def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['pauli', 'qubit'])
@@ -1247,7 +1227,7 @@ class MutablePauliString(Generic[TKey]):
             return sign
         return -sign
 
-    def keys(self) -> AbstractSet[TKey]:
+    def keys(self) -> Set[TKey]:
         """Returns the sequence of qubits on which this pauli string acts."""
         return self.pauli_int_dict.keys()
 

cirq/ops/pauli_string_phasor.py

@@ -15,7 +15,8 @@
 from __future__ import annotations
 
 import numbers
-from typing import AbstractSet, cast, Iterable, Iterator, Sequence, TYPE_CHECKING
+from collections.abc import Iterable, Iterator, Sequence, Set
+from typing import cast, TYPE_CHECKING
 
 from cirq import protocols, value
 from cirq._compat import deprecated, proper_repr
@@ -73,9 +74,9 @@ class PauliStringPhasor(gate_operation.GateOperation):
                 `pauli_string` are acted upon by identity. The order of
                 these qubits must match the order in `pauli_string`.
             exponent_neg: How much to phase vectors in the negative eigenspace,
-                in the form of the t in (-1)**t = exp(i pi t).
+                in the form of the t in ``(-1)**t = exp(i*pi*t)``.
             exponent_pos: How much to phase vectors in the positive eigenspace,
-                in the form of the t in (-1)**t = exp(i pi t).
+                in the form of the t in ``(-1)**t = exp(i*pi*t)``.
 
         Raises:
             ValueError: If coefficient is not 1 or -1 or the qubits of
@@ -200,7 +201,7 @@ class PauliStringPhasor(gate_operation.GateOperation):
         pn = self.exponent_neg
         return PauliStringPhasor(new_pauli_string, exponent_pos=pp, exponent_neg=pn)
 
-    @deprecated(deadline="v2.0", fix="Use conjuagetd_by() instead.")
+    @deprecated(deadline="v2.0", fix="Use conjugated_by() instead.")
     def pass_operations_over(
         self, ops: Iterable[raw_types.Operation], after_to_before: bool = False
     ) -> PauliStringPhasor:  # pragma: no cover
@@ -388,7 +389,7 @@ class PauliStringPhasorGate(raw_types.Gate):
             self.exponent_pos
         )
 
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         return protocols.parameter_names(self.exponent_neg) | protocols.parameter_names(
             self.exponent_pos
         )

cirq/ops/pauli_string_raw_types.py

@@ -15,7 +15,8 @@
 from __future__ import annotations
 
 import abc
-from typing import Any, Self, Sequence, TYPE_CHECKING
+from collections.abc import Sequence
+from typing import Any, Self, TYPE_CHECKING
 
 from cirq import protocols
 from cirq.ops import pauli_string as ps, raw_types

cirq/ops/pauli_string_test.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import itertools
 import math
-from typing import Iterator
+from collections.abc import Iterator
 
 import numpy as np
 import pytest
@@ -323,6 +323,7 @@ def test_constructor_flexibility() -> None:
 @pytest.mark.parametrize('qubit_pauli_map', _sample_qubit_pauli_maps())
 def test_getitem(qubit_pauli_map) -> None:
     other = cirq.NamedQubit('other')
+    pauli_string: cirq.PauliString[cirq.NamedQubit]
     pauli_string = cirq.PauliString(qubit_pauli_map=qubit_pauli_map)
     for key in qubit_pauli_map:
         assert qubit_pauli_map[key] == pauli_string[key]
@@ -1190,7 +1191,7 @@ def test_expectation_from_density_matrix_invalid_input() -> None:
     with pytest.raises(ValueError, match='shape'):
         ps.expectation_from_density_matrix(rho.reshape((4, 4, 1)), q_map_2)
     with pytest.raises(ValueError, match='shape'):
-        ps.expectation_from_density_matrix(rho.reshape((-1)), q_map_2)
+        ps.expectation_from_density_matrix(rho.reshape((-1,)), q_map_2)
 
     # Correctly shaped state_vectors.
     with pytest.raises(ValueError, match='shape'):
@@ -2085,15 +2086,57 @@ def test_resolve(resolve_fn) -> None:
     ids=str,
 )
 def test_pauli_ops_identity_gate_operation(gate1: cirq.Pauli, gate2: cirq.Pauli) -> None:
-    # TODO: Issue #7280 - Support addition and subtraction of identity gate operations.
-    if gate1 == gate2 == cirq.I:
-        pytest.skip('Not yet implemented per #7280')
     q = cirq.LineQubit(0)
     pauli1, pauli2 = gate1.on(q), gate2.on(q)
-    unitary1, unitary2 = cirq.unitary(gate1), cirq.unitary(gate2)
+    if gate1 == gate2 == cirq.I:
+        # PauliSum swallows I qubits, so resulting unitaries are dimensionless
+        unitary1 = unitary2 = np.array([[1]])
+    else:
+        unitary1, unitary2 = cirq.unitary(gate1), cirq.unitary(gate2)
     addition = pauli1 + pauli2
     assert isinstance(addition, cirq.PauliSum)
     assert np.array_equal(addition.matrix(), unitary1 + unitary2)
     subtraction = pauli1 - pauli2
     assert isinstance(subtraction, cirq.PauliSum)
     assert np.array_equal(subtraction.matrix(), unitary1 - unitary2)
+
+
+def test_pauli_gate_multiplication_with_power() -> None:
+    q = cirq.LineQubit(0)
+
+    # Test all Pauli gates (X, Y, Z)
+    pauli_gates = [cirq.X, cirq.Y, cirq.Z]
+    for pauli_gate in pauli_gates:
+        gate = pauli_gate(q)
+
+        # Test multiplication
+        assert gate**2 * gate * gate * gate == gate**5
+        assert gate * gate**2 * gate * gate == gate**5
+        assert gate * gate * gate**2 * gate == gate**5
+        assert gate * gate * gate * gate**2 == gate**5
+
+        # Test with different powers
+        assert gate**0 * gate**5 == gate**5
+        assert gate**1 * gate**4 == gate**5
+        assert gate**2 * gate**3 == gate**5
+        assert gate**3 * gate**2 == gate**5
+        assert gate**4 * gate**1 == gate**5
+        assert gate**5 * gate**0 == gate**5
+
+
+def test_try_interpret_as_pauli_string() -> None:
+    from cirq.ops.pauli_string import _try_interpret_as_pauli_string
+
+    q = cirq.LineQubit(0)
+
+    # Pauli gate operation
+    x_gate = cirq.X(q)
+    assert _try_interpret_as_pauli_string(x_gate) == cirq.PauliString({q: cirq.X})
+
+    # powered gates
+    x_squared = x_gate**2
+    assert _try_interpret_as_pauli_string(x_squared) == cirq.PauliString({q: cirq.I})
+
+    # non-Pauli operation
+    h_gate = cirq.H(q)
+    assert _try_interpret_as_pauli_string(h_gate) is None

cirq/ops/pauli_sum_exponential.py

@@ -14,7 +14,8 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterator, TYPE_CHECKING
+from collections.abc import Iterator
+from typing import Any, TYPE_CHECKING
 
 import numpy as np
 

cirq/ops/permutation_gate.py

@@ -14,7 +14,8 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterator, Sequence, TYPE_CHECKING
+from collections.abc import Iterator, Sequence
+from typing import Any, TYPE_CHECKING
 
 from cirq import protocols, value
 from cirq.ops import raw_types, swap_gates

cirq/ops/phased_iswap_gate.py

@@ -15,7 +15,8 @@
 
 from __future__ import annotations
 
-from typing import AbstractSet, Any, cast, Iterator, Sequence
+from collections.abc import Iterator, Sequence, Set
+from typing import Any, cast
 
 import numpy as np
 import sympy
@@ -108,7 +109,7 @@ class PhasedISwapPowGate(eigen_gate.EigenGate):
             self._phase_exponent
         )
 
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         return protocols.parameter_names(self._iswap) | protocols.parameter_names(
             self._phase_exponent
         )

cirq/ops/phased_x_gate.py

@@ -18,8 +18,9 @@ from __future__ import annotations
 
 import math
 import numbers
+from collections.abc import Sequence, Set
 from types import NotImplementedType
-from typing import AbstractSet, Any, cast, Sequence
+from typing import Any, cast
 
 import numpy as np
 import sympy
@@ -166,7 +167,7 @@ class PhasedXPowGate(raw_types.Gate):
             self._phase_exponent
         )
 
-    def _parameter_names_(self) -> AbstractSet[str]:
+    def _parameter_names_(self) -> Set[str]:
         """See `cirq.SupportsParameterization`."""
         return protocols.parameter_names(self._exponent) | protocols.parameter_names(
             self._phase_exponent
@@ -176,12 +177,12 @@ class PhasedXPowGate(raw_types.Gate):
         """See `cirq.SupportsParameterization`."""
         phase_exponent = resolver.value_of(self._phase_exponent, recursive)
         exponent = resolver.value_of(self._exponent, recursive)
-        if isinstance(phase_exponent, numbers.Complex):
+        if not isinstance(phase_exponent, float) and isinstance(phase_exponent, numbers.Complex):
             if isinstance(phase_exponent, numbers.Real):
                 phase_exponent = float(phase_exponent)
             else:
                 raise ValueError(f'PhasedXPowGate does not support complex value {phase_exponent}')
-        if isinstance(exponent, numbers.Complex):
+        if not isinstance(exponent, float) and isinstance(exponent, numbers.Complex):
             if isinstance(exponent, numbers.Real):
                 exponent = float(exponent)
             else: