cirq-core 1.5.0.dev20250205201333__py3-none-any.whl → 1.5.0.dev20250206124432__py3-none-any.whl

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.dev20250205201333"
+__version__ = "1.5.0.dev20250206124432"

cirq/_version_test.py

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

cirq/linalg/operator_spaces.py

@@ -13,13 +13,17 @@
 # limitations under the License.
 
 """Utilities for manipulating linear operators as elements of vector space."""
-from typing import Dict, Tuple
+from typing import Dict, Tuple, TYPE_CHECKING
 
 import numpy as np
+import sympy
 
 from cirq import value
 from cirq._doc import document
 
+if TYPE_CHECKING:
+    import cirq
+
 PAULI_BASIS = {
     'I': np.eye(2),
     'X': np.array([[0.0, 1.0], [1.0, 0.0]]),
@@ -78,8 +82,17 @@ def matrix_from_basis_coefficients(
 
 
 def pow_pauli_combination(
-    ai: value.Scalar, ax: value.Scalar, ay: value.Scalar, az: value.Scalar, exponent: int
-) -> Tuple[value.Scalar, value.Scalar, value.Scalar, value.Scalar]:
+    ai: 'cirq.TParamValComplex',
+    ax: 'cirq.TParamValComplex',
+    ay: 'cirq.TParamValComplex',
+    az: 'cirq.TParamValComplex',
+    exponent: int,
+) -> Tuple[
+    'cirq.TParamValComplex',
+    'cirq.TParamValComplex',
+    'cirq.TParamValComplex',
+    'cirq.TParamValComplex',
+]:
     """Computes non-negative integer power of single-qubit Pauli combination.
 
     Returns scalar coefficients bi, bx, by, bz such that
@@ -96,7 +109,10 @@ def pow_pauli_combination(
     if exponent == 0:
         return 1, 0, 0, 0
 
-    v = np.sqrt(ax * ax + ay * ay + az * az).item()
+    if any(isinstance(a, sympy.Basic) for a in [ax, ay, az]):
+        v = sympy.sqrt(ax * ax + ay * ay + az * az)
+    else:
+        v = np.sqrt(ax * ax + ay * ay + az * az).item()
     s = (ai + v) ** exponent
     t = (ai - v) ** exponent
 

cirq/linalg/operator_spaces_test.py

@@ -17,6 +17,7 @@ import itertools
 import numpy as np
 import pytest
 import scipy.linalg
+import sympy
 
 import cirq
 
@@ -287,11 +288,21 @@ def test_expand_is_inverse_of_reconstruct(m1, basis):
             (-1, -2, 3, 4),
             (1j, 2j, 3j, 4j),
             (1j, 2j, 3, 4),
+            (sympy.Symbol('i'), sympy.Symbol('x'), sympy.Symbol('y'), sympy.Symbol('z')),
+            (
+                sympy.Symbol('i') * 1j,
+                -sympy.Symbol('x'),
+                -sympy.Symbol('y') * 1j,
+                sympy.Symbol('z'),
+            ),
         ),
         (0, 1, 2, 3, 4, 5, 100, 101),
     ),
 )
 def test_pow_pauli_combination(coefficients, exponent):
+    is_symbolic = any(isinstance(a, sympy.Basic) for a in coefficients)
+    if is_symbolic and exponent > 2:
+        return  # too slow
     i = cirq.PAULI_BASIS['I']
     x = cirq.PAULI_BASIS['X']
     y = cirq.PAULI_BASIS['Y']
@@ -303,5 +314,7 @@ def test_pow_pauli_combination(coefficients, exponent):
 
     bi, bx, by, bz = cirq.pow_pauli_combination(ai, ax, ay, az, exponent)
     result = bi * i + bx * x + by * y + bz * z
-
-    assert np.allclose(result, expected_result)
+    if is_symbolic:
+        assert cirq.approx_eq(result, expected_result)
+    else:
+        assert np.allclose(result, expected_result)

cirq/ops/common_gates.py

@@ -261,8 +261,8 @@ class XPowGate(eigen_gate.EigenGate):
         if self._dimension != 2:
             return NotImplemented
         phase = 1j ** (2 * self._exponent * (self._global_shift + 0.5))
-        angle = _pi(self._exponent) * self._exponent / 2
         lib = sympy if protocols.is_parameterized(self) else np
+        angle = lib.pi * self._exponent / 2
         return value.LinearDict({'I': phase * lib.cos(angle), 'X': -1j * phase * lib.sin(angle)})
 
     def _circuit_diagram_info_(
@@ -466,8 +466,8 @@ class YPowGate(eigen_gate.EigenGate):
 
     def _pauli_expansion_(self) -> value.LinearDict[str]:
         phase = 1j ** (2 * self._exponent * (self._global_shift + 0.5))
-        angle = _pi(self._exponent) * self._exponent / 2
         lib = sympy if protocols.is_parameterized(self) else np
+        angle = lib.pi * self._exponent / 2
         return value.LinearDict({'I': phase * lib.cos(angle), 'Y': -1j * phase * lib.sin(angle)})
 
     def _circuit_diagram_info_(
@@ -767,8 +767,8 @@ class ZPowGate(eigen_gate.EigenGate):
         if self._dimension != 2:
             return NotImplemented
         phase = 1j ** (2 * self._exponent * (self._global_shift + 0.5))
-        angle = _pi(self._exponent) * self._exponent / 2
         lib = sympy if protocols.is_parameterized(self) else np
+        angle = lib.pi * self._exponent / 2
         return value.LinearDict({'I': phase * lib.cos(angle), 'Z': -1j * phase * lib.sin(angle)})
 
     def _phase_by_(self, phase_turns: float, qubit_index: int):

cirq/ops/linear_combinations.py

@@ -81,7 +81,7 @@ class LinearCombinationOfGates(value.LinearDict[raw_types.Gate]):
         2 * cirq.X - 2 * cirq.Z
     """
 
-    def __init__(self, terms: Mapping[raw_types.Gate, value.Scalar]) -> None:
+    def __init__(self, terms: Mapping[raw_types.Gate, 'cirq.TParamValComplex']) -> None:
         """Initializes linear combination from a collection of terms.
 
         Args:
@@ -149,17 +149,19 @@ class LinearCombinationOfGates(value.LinearDict[raw_types.Gate]):
         )
 
     def _is_parameterized_(self) -> bool:
-        return any(protocols.is_parameterized(gate) for gate in self.keys())
+        return any(protocols.is_parameterized(item) for item in self.items())
 
     def _parameter_names_(self) -> AbstractSet[str]:
-        return {name for gate in self.keys() for name in protocols.parameter_names(gate)}
+        return {name for item in self.items() for name in protocols.parameter_names(item)}
 
     def _resolve_parameters_(
         self, resolver: 'cirq.ParamResolver', recursive: bool
     ) -> 'LinearCombinationOfGates':
         return self.__class__(
             {
-                protocols.resolve_parameters(gate, resolver, recursive): coeff
+                protocols.resolve_parameters(
+                    gate, resolver, recursive
+                ): protocols.resolve_parameters(coeff, resolver, recursive)
                 for gate, coeff in self.items()
             }
         )
@@ -222,7 +224,7 @@ class LinearCombinationOfOperations(value.LinearDict[raw_types.Operation]):
     by the identity operator. Note that A may not be unitary or even normal.
     """
 
-    def __init__(self, terms: Mapping[raw_types.Operation, value.Scalar]) -> None:
+    def __init__(self, terms: Mapping[raw_types.Operation, 'cirq.TParamValComplex']) -> None:
         """Initializes linear combination from a collection of terms.
 
         Args:
@@ -264,17 +266,19 @@ class LinearCombinationOfOperations(value.LinearDict[raw_types.Operation]):
         return LinearCombinationOfOperations({i: bi, x: bx, y: by, z: bz})
 
     def _is_parameterized_(self) -> bool:
-        return any(protocols.is_parameterized(op) for op in self.keys())
+        return any(protocols.is_parameterized(item) for item in self.items())
 
     def _parameter_names_(self) -> AbstractSet[str]:
-        return {name for op in self.keys() for name in protocols.parameter_names(op)}
+        return {name for item in self.items() for name in protocols.parameter_names(item)}
 
     def _resolve_parameters_(
         self, resolver: 'cirq.ParamResolver', recursive: bool
     ) -> 'LinearCombinationOfOperations':
         return self.__class__(
             {
-                protocols.resolve_parameters(op, resolver, recursive): coeff
+                protocols.resolve_parameters(op, resolver, recursive): protocols.resolve_parameters(
+                    coeff, resolver, recursive
+                )
                 for op, coeff in self.items()
             }
         )
@@ -353,7 +357,9 @@ def _is_linear_dict_of_unit_pauli_string(linear_dict: value.LinearDict[UnitPauli
     return True
 
 
-def _pauli_string_from_unit(unit: UnitPauliStringT, coefficient: Union[int, float, complex] = 1):
+def _pauli_string_from_unit(
+    unit: UnitPauliStringT, coefficient: Union[int, float, 'cirq.TParamValComplex'] = 1
+):
     return PauliString(qubit_pauli_map=dict(unit), coefficient=coefficient)
 
 

cirq/ops/linear_combinations_test.py

@@ -153,6 +153,10 @@ def test_non_unitary_linear_combination_of_gates_has_no_unitary(terms):
         ),
         ({cirq.X: 2, cirq.H: 1}, {'X': 2 + np.sqrt(0.5), 'Z': np.sqrt(0.5)}),
         ({cirq.XX: -2, cirq.YY: 3j, cirq.ZZ: 4}, {'XX': -2, 'YY': 3j, 'ZZ': 4}),
+        (
+            {cirq.X: sympy.Symbol('x'), cirq.Y: -sympy.Symbol('y')},
+            {'X': sympy.Symbol('x'), 'Y': -sympy.Symbol('y')},
+        ),
     ),
 )
 def test_linear_combination_of_gates_has_correct_pauli_expansion(terms, expected_expansion):
@@ -206,7 +210,11 @@ def test_linear_combinations_of_gates_invalid_powers(terms, exponent):
 
 @pytest.mark.parametrize(
     'terms, is_parameterized, parameter_names',
-    [({cirq.H: 1}, False, set()), ({cirq.X ** sympy.Symbol('t'): 1}, True, {'t'})],
+    [
+        ({cirq.H: 1}, False, set()),
+        ({cirq.X ** sympy.Symbol('t'): 1}, True, {'t'}),
+        ({cirq.X: sympy.Symbol('t')}, True, {'t'}),
+    ],
 )
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
 def test_parameterized_linear_combination_of_gates(
@@ -225,7 +233,7 @@ def get_matrix(
         cirq.GateOperation,
         cirq.LinearCombinationOfGates,
         cirq.LinearCombinationOfOperations,
-    ]
+    ],
 ) -> np.ndarray:
     if isinstance(operator, (cirq.LinearCombinationOfGates, cirq.LinearCombinationOfOperations)):
         return operator.matrix()
@@ -243,13 +251,13 @@ def assert_linear_combinations_are_equal(
 
     actual_matrix = get_matrix(actual)
     expected_matrix = get_matrix(expected)
-    assert np.allclose(actual_matrix, expected_matrix)
+    assert cirq.approx_eq(actual_matrix, expected_matrix)
 
     actual_expansion = cirq.pauli_expansion(actual)
     expected_expansion = cirq.pauli_expansion(expected)
     assert set(actual_expansion.keys()) == set(expected_expansion.keys())
     for name in actual_expansion.keys():
-        assert abs(actual_expansion[name] - expected_expansion[name]) < 1e-12
+        assert cirq.approx_eq(actual_expansion[name], expected_expansion[name])
 
 
 @pytest.mark.parametrize(
@@ -279,6 +287,8 @@ def assert_linear_combinations_are_equal(
         ),
         ((cirq.X + cirq.Y + cirq.Z) ** 0, cirq.I),
         ((cirq.X - 1j * cirq.Y) ** 0, cirq.I),
+        (cirq.Y - sympy.Symbol('s') * cirq.Y, (1 - sympy.Symbol('s')) * cirq.Y),
+        ((cirq.X + cirq.Z) * sympy.Symbol('s') / np.sqrt(2), cirq.H * sympy.Symbol('s')),
     ),
 )
 def test_gate_expressions(expression, expected_result):
@@ -659,6 +669,10 @@ def test_non_unitary_linear_combination_of_operations_has_no_unitary(terms):
             {'IIZI': 1, 'IZII': 1, 'IZZI': -1},
         ),
         ({cirq.CNOT(q0, q1): 2, cirq.Z(q0): -1, cirq.X(q1): -1}, {'II': 1, 'ZX': -1}),
+        (
+            {cirq.X(q0): -sympy.Symbol('x'), cirq.Y(q0): sympy.Symbol('y')},
+            {'X': -sympy.Symbol('x'), 'Y': sympy.Symbol('y')},
+        ),
     ),
 )
 def test_linear_combination_of_operations_has_correct_pauli_expansion(terms, expected_expansion):
@@ -716,6 +730,7 @@ def test_linear_combinations_of_operations_invalid_powers(terms, exponent):
     [
         ({cirq.H(cirq.LineQubit(0)): 1}, False, set()),
         ({cirq.X(cirq.LineQubit(0)) ** sympy.Symbol('t'): 1}, True, {'t'}),
+        ({cirq.X(cirq.LineQubit(0)): sympy.Symbol('t')}, True, {'t'}),
     ],
 )
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
@@ -788,6 +803,10 @@ def test_parameterized_linear_combination_of_ops(
             cirq.LinearCombinationOfOperations({cirq.X(q1): 2, cirq.Z(q1): 3}) ** 0,
             cirq.LinearCombinationOfOperations({cirq.I(q1): 1}),
         ),
+        (
+            cirq.LinearCombinationOfOperations({cirq.X(q0): sympy.Symbol('s')}) ** 2,
+            cirq.LinearCombinationOfOperations({cirq.I(q0): sympy.Symbol('s') ** 2}),
+        ),
     ),
 )
 def test_operation_expressions(expression, expected_result):

cirq/ops/raw_types.py

@@ -306,7 +306,7 @@ class Gate(metaclass=value.ABCMetaImplementAnyOneOf):
         return operations
 
     def wrap_in_linear_combination(
-        self, coefficient: Union[complex, float, int] = 1
+        self, coefficient: 'cirq.TParamValComplex' = 1
     ) -> 'cirq.LinearCombinationOfGates':
         """Returns a LinearCombinationOfGates with this gate.
 

cirq/ops/raw_types_test.py

@@ -258,6 +258,7 @@ def test_default_qudit_inverse():
         (cirq.CZ * 1, cirq.CZ / 1),
         (-cirq.CSWAP * 1j, cirq.CSWAP / 1j),
         (cirq.TOFFOLI * 0.5, cirq.TOFFOLI / 2),
+        (-cirq.X * sympy.Symbol('s'), -sympy.Symbol('s') * cirq.X),
     ),
 )
 def test_gate_algebra(expression, expected_result):

{cirq_core-1.5.0.dev20250205201333.dist-info → cirq_core-1.5.0.dev20250206124432.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.5.0.dev20250205201333
+Version: 1.5.0.dev20250206124432
 Summary: A framework for creating, editing, and invoking Noisy Intermediate Scale Quantum (NISQ) circuits.
 Home-page: http://github.com/quantumlib/cirq
 Author: The Cirq Developers

{cirq_core-1.5.0.dev20250205201333.dist-info → cirq_core-1.5.0.dev20250206124432.dist-info}/RECORD

@@ -4,8 +4,8 @@ cirq/_compat_test.py,sha256=Qq3ZcfgD-Nb81cEppQdJqhAyrVqXKtfXZYGXT0p-Wh0,34718
 cirq/_doc.py,sha256=yDyWUD_2JDS0gShfGRb-rdqRt9-WeL7DhkqX7np0Nko,2879
 cirq/_import.py,sha256=p9gMHJscbtDDkfHOaulvd3Aer0pwUF5AXpL89XR8dNw,8402
 cirq/_import_test.py,sha256=6K_v0riZJXOXUphHNkGA8MY-JcmGlezFaGmvrNhm3OQ,1015
-cirq/_version.py,sha256=nDewyRfDawPbE40P0oO2mCpVpZ-2r-kE4o5C99s5Rmg,1206
-cirq/_version_test.py,sha256=0NMzzNDtTGQIDw2S2p21thzaUGEWUpfMj0zQj31px2w,147
+cirq/_version.py,sha256=RrxFnjOvRlvSDNy8tiocma47nefokXK8ADwpkEJGTK8,1206
+cirq/_version_test.py,sha256=95VtVDUQWBslOEZgovv8oHCbiJmAag9AyBj1y9Xtfv8,147
 cirq/conftest.py,sha256=X7yLFL8GLhg2CjPw0hp5e_dGASfvHx1-QT03aUbhKJw,1168
 cirq/json_resolver_cache.py,sha256=p-vEOa-8GQ2cFIAdze-kd6C1un1uRvtujVPljVKaHBg,13557
 cirq/py.typed,sha256=VFSlmh_lNwnaXzwY-ZuW-C2Ws5PkuDoVgBdNCs0jXJE,63
@@ -252,8 +252,8 @@ cirq/linalg/decompositions.py,sha256=cNIcKylK4tnGgIreO7X4cpsRmwvOycKRSS8xf9gaIG0
 cirq/linalg/decompositions_test.py,sha256=S6p9AJO_9wwQdmNHYTAgBK4TL6_lz1U93sLNNuUJmBw,25840
 cirq/linalg/diagonalize.py,sha256=Ym7C0JTAC9xfRQDYI72U6NxMYg0DfchjfXcbdg_92QE,10051
 cirq/linalg/diagonalize_test.py,sha256=H-JcLvcCBdN-DrKo2o1Gs7B8Q9SU70oAZmdT4yTLAi4,9089
-cirq/linalg/operator_spaces.py,sha256=uZSc9154p63R2UqFw6pniuWcUo20epe5RK6bL3tpkbM,3813
-cirq/linalg/operator_spaces_test.py,sha256=k2aVBYuU6ehXx_6puApE-sFxEBrOki0t0KeNbBK94hs,10097
+cirq/linalg/operator_spaces.py,sha256=-i5DEAW-b_sgmfZKXFf37XzX5h7cZ7R6EeW7RcFNeE0,4128
+cirq/linalg/operator_spaces_test.py,sha256=Hbm8e4kGbGw9c4O3v5o0kYbcikwDkdIoAy3V8EofJr4,10605
 cirq/linalg/predicates.py,sha256=Q8BTlR4EvPg2KP9VodK78UEWYJbSCOTqRahn1DnFmSc,12056
 cirq/linalg/predicates_test.py,sha256=UVDkNH2ujI80JwJwsDjbTgyALZUQJAVVCoFN1T_LLf0,21503
 cirq/linalg/tolerance.py,sha256=ZBZOc5h7UgrKzyOStlcTRwupkjVzQu9-AwjNCCz1ZKE,1879
@@ -277,7 +277,7 @@ cirq/ops/common_channels.py,sha256=go4yhaRw0XNAr3TUBJ59SOhn2SKxf6bHmmrOHPbBYCY,3
 cirq/ops/common_channels_test.py,sha256=nQsSSxu7vtedb3ZUuw4hNKIX7MYI4x8lxvLyWMZNt10,30079
 cirq/ops/common_gate_families.py,sha256=e5M8wlDYtdrpWBrhdns6iizIvSqzfxDyIsBdxt8hVMc,8611
 cirq/ops/common_gate_families_test.py,sha256=Oo3C7BPO3gt3ePuqwsI_lx_lY38et8Ps4AuVydX2Aww,5275
-cirq/ops/common_gates.py,sha256=0kQPjqB5vZmjKyUiQj-B_08cZ5wxTfa8e_5wfu4ce50,58209
+cirq/ops/common_gates.py,sha256=izKH25lp0i_1Vrx9gwGzOIk1PxzOmMnq4MlFu4da4Vk,58170
 cirq/ops/common_gates_test.py,sha256=tNymwCOXCgVe6JnrHSq7kwzCO-ucQZYHdBF9cvdZRMo,46731
 cirq/ops/control_values.py,sha256=nNDN6pgz_aWkUfrpOZ9zHHD42AGFaplWhVQj9rmJwbQ,13410
 cirq/ops/control_values_test.py,sha256=iDtdQjL39u80MaR16XLp00LRZqWgJqC54cIeADWf0IY,12906
@@ -309,8 +309,8 @@ cirq/ops/identity.py,sha256=FtsDwxqmnHenOD0H1H5p6TGgDQ76LZfk3Z_2vpijNDY,5887
 cirq/ops/identity_test.py,sha256=OIrm8v4wBVq8bbAGZ-f5TERt8Hl6aD1bL8iHCOEhzNo,7939
 cirq/ops/kraus_channel.py,sha256=tCPAEzr_GAL5vTwI43rBoiOnT04l-ebZanuuEuYWDo8,5085
 cirq/ops/kraus_channel_test.py,sha256=qH2Y9cngXzKCabd-Mq5xBYcM_wyL8c6KkrXw8kZr7Dc,4726
-cirq/ops/linear_combinations.py,sha256=WqQ2STxGpgO6KUj4yc6LfSI9OWCdzlmWMt6BkTkf2wA,39694
-cirq/ops/linear_combinations_test.py,sha256=qpzRo53mJtcidYE11loKMP2b9guKMGtzrKWQ_u0jr4Y,66387
+cirq/ops/linear_combinations.py,sha256=fxguoESKkiVxeDMUj4vcgZs9JgQkBg42hy3U4Txobo8,39928
+cirq/ops/linear_combinations_test.py,sha256=ip-wN8T8nUQviD3ql42eet7k_MQ6DVUfIK8aX-_ygOs,67217
 cirq/ops/matrix_gates.py,sha256=inBhKPsNx7ZeejNpmbPEGl5hgyrTqmA852BVlKMUZmg,9297
 cirq/ops/matrix_gates_test.py,sha256=m5rMwq_sqVvsmkc5opVr3Ikd1ERuULmSRNAvGZUg7ds,14224
 cirq/ops/measure_util.py,sha256=wkT0XC6rIddOkqNGwkvI-m7Ncr8j5QPN_evwecc6nrw,7390
@@ -360,8 +360,8 @@ cirq/ops/qubit_order_or_list.py,sha256=WVnhQcOYCgAhiB4t47Kji-pN1tnvs--X5deCQwwGV
 cirq/ops/qubit_order_test.py,sha256=B9xMIxlaI7YjRUNA6AkHJuUCFejGYw-lT7ZaSl31yTU,4238
 cirq/ops/random_gate_channel.py,sha256=gKDqZa6AwdCIuuh2UOvO5oxCdGRDOInA7fI3ZLQ-LTY,5121
 cirq/ops/random_gate_channel_test.py,sha256=U3EAaAlCZkgFIYxqwcSkPsaVGrKA2PSeG_DK2ou--AE,8606
-cirq/ops/raw_types.py,sha256=n_v0flAXTxHFVNOKrOZRcOIPx1LIZ3F7wYfGJiAF9qk,42176
-cirq/ops/raw_types_test.py,sha256=AtcaAgu50IK_bsMXo4MkM_fjWQj9EQrkn9ved0_cJoo,33872
+cirq/ops/raw_types.py,sha256=nhbEjkR0mKqNMQ9j_2TokAZ4u14CGPXEYjjicd6XuEM,42173
+cirq/ops/raw_types_test.py,sha256=U2sAzc6DjpOmgHafGv94VJXqZHm7J898khmJoHAawHQ,33940
 cirq/ops/state_preparation_channel.py,sha256=PjVtoLbjBAy_XqnFAY40Am-NifeuCFVVLW6RJxph5sQ,4778
 cirq/ops/state_preparation_channel_test.py,sha256=yKUvLw_ft6cvIgRJcFQ779wZS-V6V-pzQq-rZRWdCmU,5922
 cirq/ops/swap_gates.py,sha256=8DrW7Hn-m0dx0e57FUPfjggRF0zC_HGbr3Eomm54jfE,11634
@@ -1202,8 +1202,8 @@ cirq/work/sampler.py,sha256=bE5tmVkcR6cZZMLETxDfHehdsYUMbx2RvBeIBetehI4,19187
 cirq/work/sampler_test.py,sha256=hL2UWx3dz2ukZVNxWftiKVvJcQoLplLZdQm-k1QcA40,13282
 cirq/work/zeros_sampler.py,sha256=x1C7cup66a43n-3tm8QjhiqJa07qcJW10FxNp9jJ59Q,2356
 cirq/work/zeros_sampler_test.py,sha256=JIkpBBFPJe5Ba4142vzogyWyboG1Q1ZAm0UVGgOoZn8,3279
-cirq_core-1.5.0.dev20250205201333.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.5.0.dev20250205201333.dist-info/METADATA,sha256=Ji0iuB7GwJ49DlicolSpOULUknuqSLy7ZRINdeanHw8,4811
-cirq_core-1.5.0.dev20250205201333.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-cirq_core-1.5.0.dev20250205201333.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.5.0.dev20250205201333.dist-info/RECORD,,
+cirq_core-1.5.0.dev20250206124432.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.5.0.dev20250206124432.dist-info/METADATA,sha256=z8b9XO0wOI_PL60u53I7Xc78WPZmTTJuKl5MMBmRMoU,4811
+cirq_core-1.5.0.dev20250206124432.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+cirq_core-1.5.0.dev20250206124432.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.5.0.dev20250206124432.dist-info/RECORD,,