cirq-core 1.5.0.dev20250131224919__py3-none-any.whl → 1.5.0.dev20250205194253__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.dev20250131224919"
+__version__ = "1.5.0.dev20250205194253"

cirq/_version_test.py

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

cirq/contrib/acquaintance/gates.py

@@ -316,10 +316,12 @@ class SwapNetworkGate(PermutationGate):
                 parts_qubits = list(left_part + right_part)
                 parts[i] = parts_qubits[: len(right_part)]
                 parts[i + 1] = parts_qubits[len(right_part) :]
-            layers.prior_interstitial.sort(key=op_sort_key)  # type: ignore[arg-type]
+            if op_sort_key is not None:
+                layers.prior_interstitial.sort(key=op_sort_key)
             for l in ('prior_interstitial', 'pre', 'intra', 'post'):
                 yield getattr(layers, l)
-        layers.posterior_interstitial.sort(key=op_sort_key)  # type: ignore[arg-type]
+        if op_sort_key is not None:
+            layers.posterior_interstitial.sort(key=op_sort_key)
         yield layers.posterior_interstitial
 
         assert list(

cirq/contrib/qasm_import/_lexer.py

@@ -14,7 +14,6 @@
 
 import re
 from typing import Optional
-import numpy as np
 import ply.lex as lex
 
 from cirq.contrib.qasm_import.exception import QasmException
@@ -35,8 +34,7 @@ class QasmLexer:
         'reset': 'RESET',
         'gate': 'GATE',
         'if': 'IF',
-        '->': 'ARROW',
-        '==': 'EQ',
+        'pi': 'PI',
     }
 
     tokens = [
@@ -46,7 +44,8 @@ class QasmLexer:
         'STDGATESINC',
         'QELIBINC',
         'ID',
-        'PI',
+        'ARROW',
+        'EQ',
     ] + list(reserved.values())
 
     def t_newline(self, t):
@@ -55,11 +54,6 @@ class QasmLexer:
 
     t_ignore = ' \t'
 
-    def t_PI(self, t):
-        r"""pi"""
-        t.value = np.pi
-        return t
-
     # all numbers except NATURAL_NUMBERs:
     # it's useful to have this separation to be able to handle indices
     # separately. In case of the parameter expressions, we are "OR"-ing
@@ -97,38 +91,6 @@ class QasmLexer:
         r"""include(\s+)"stdgates.inc";"""
         return t
 
-    def t_QREG(self, t):
-        r"""qreg"""
-        return t
-
-    def t_QUBIT(self, t):
-        r"""qubit"""
-        return t
-
-    def t_CREG(self, t):
-        r"""creg"""
-        return t
-
-    def t_BIT(self, t):
-        r"""bit"""
-        return t
-
-    def t_MEASURE(self, t):
-        r"""measure"""
-        return t
-
-    def t_RESET(self, t):
-        r"""reset"""
-        return t
-
-    def t_GATE(self, t):
-        r"""gate"""
-        return t
-
-    def t_IF(self, t):
-        r"""if"""
-        return t
-
     def t_ARROW(self, t):
         """->"""
         return t
@@ -139,6 +101,8 @@ class QasmLexer:
 
     def t_ID(self, t):
         r"""[a-zA-Z][a-zA-Z\d_]*"""
+        if t.value in QasmLexer.reserved:
+            t.type = QasmLexer.reserved[t.value]
         return t
 
     def t_COMMENT(self, t):

cirq/contrib/qasm_import/_lexer_test.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 import pytest
-import numpy as np
 from cirq.contrib.qasm_import import QasmException
 from cirq.contrib.qasm_import._lexer import QasmLexer
 
@@ -103,12 +102,28 @@ def test_numbers(number: str):
     assert token.value == float(number)
 
 
-def test_pi():
+@pytest.mark.parametrize('token', QasmLexer.reserved.keys())
+def test_keywords(token):
     lexer = QasmLexer()
-    lexer.input('pi')
-    token = lexer.token()
-    assert token.type == "PI"
-    assert token.value == np.pi
+    identifier = f'{token} {token}'
+    lexer.input(identifier)
+    t = lexer.token()
+    assert t.type == QasmLexer.reserved[token]
+    assert t.value == token
+    t2 = lexer.token()
+    assert t2.type == QasmLexer.reserved[token]
+    assert t2.value == token
+
+
+@pytest.mark.parametrize('token', QasmLexer.reserved.keys())
+@pytest.mark.parametrize('separator', ['', '_'])
+def test_identifier_starts_or_ends_with_keyword(token, separator):
+    lexer = QasmLexer()
+    identifier = f'{token}{separator}{token}'
+    lexer.input(identifier)
+    t = lexer.token()
+    assert t.type == "ID"
+    assert t.value == identifier
 
 
 def test_qreg():

cirq/contrib/qasm_import/_parser.py

@@ -510,10 +510,13 @@ class QasmParser:
 
     def p_term(self, p):
         """term : NUMBER
-        | NATURAL_NUMBER
-        | PI"""
+        | NATURAL_NUMBER"""
         p[0] = p[1]
 
+    def p_pi(self, p):
+        """term : PI"""
+        p[0] = np.pi
+
     # qargs : qarg ',' qargs
     #      | qarg ';'
 

cirq/contrib/qasm_import/_parser_test.py

@@ -1499,3 +1499,22 @@ def _test_parse_exception(qasm: str, cirq_err: str, qiskit_err: str | None):
             "Skipped _test_qiskit_parse_exception because "
             "qiskit isn't installed to verify against."
         )
+
+
+def test_nested_custom_gate_has_keyword_in_name():
+    qasm = """OPENQASM 2.0;
+     include "qelib1.inc";
+     qreg q[1];
+     gate gateGate qb { x qb; }
+     gate qregGate qa { gateGate qa; }
+     qregGate q;
+    """
+    qb = cirq.NamedQubit('qb')
+    inner = cirq.FrozenCircuit(cirq.X(qb))
+    qa = cirq.NamedQubit('qa')
+    middle = cirq.FrozenCircuit(cirq.CircuitOperation(inner, qubit_map={qb: qa}))
+    q_0 = cirq.NamedQubit('q_0')
+    expected = cirq.Circuit(cirq.CircuitOperation(middle, qubit_map={qa: q_0}))
+    parser = QasmParser()
+    parsed_qasm = parser.parse(qasm)
+    assert parsed_qasm.circuit == expected

cirq/ops/common_gates.py

@@ -258,11 +258,12 @@ class XPowGate(eigen_gate.EigenGate):
         return result
 
     def _pauli_expansion_(self) -> value.LinearDict[str]:
-        if protocols.is_parameterized(self) or self._dimension != 2:
+        if self._dimension != 2:
             return NotImplemented
         phase = 1j ** (2 * self._exponent * (self._global_shift + 0.5))
-        angle = np.pi * self._exponent / 2
-        return value.LinearDict({'I': phase * np.cos(angle), 'X': -1j * phase * np.sin(angle)})
+        angle = _pi(self._exponent) * self._exponent / 2
+        lib = sympy if protocols.is_parameterized(self) else np
+        return value.LinearDict({'I': phase * lib.cos(angle), 'X': -1j * phase * lib.sin(angle)})
 
     def _circuit_diagram_info_(
         self, args: 'cirq.CircuitDiagramInfoArgs'
@@ -464,11 +465,10 @@ class YPowGate(eigen_gate.EigenGate):
         return abs(np.sin(self._exponent * 0.5 * np.pi))
 
     def _pauli_expansion_(self) -> value.LinearDict[str]:
-        if protocols.is_parameterized(self):
-            return NotImplemented
         phase = 1j ** (2 * self._exponent * (self._global_shift + 0.5))
-        angle = np.pi * self._exponent / 2
-        return value.LinearDict({'I': phase * np.cos(angle), 'Y': -1j * phase * np.sin(angle)})
+        angle = _pi(self._exponent) * self._exponent / 2
+        lib = sympy if protocols.is_parameterized(self) else np
+        return value.LinearDict({'I': phase * lib.cos(angle), 'Y': -1j * phase * lib.sin(angle)})
 
     def _circuit_diagram_info_(
         self, args: 'cirq.CircuitDiagramInfoArgs'
@@ -764,11 +764,12 @@ class ZPowGate(eigen_gate.EigenGate):
         return abs(np.sin(self._exponent * 0.5 * np.pi))
 
     def _pauli_expansion_(self) -> value.LinearDict[str]:
-        if protocols.is_parameterized(self) or self._dimension != 2:
+        if self._dimension != 2:
             return NotImplemented
         phase = 1j ** (2 * self._exponent * (self._global_shift + 0.5))
-        angle = np.pi * self._exponent / 2
-        return value.LinearDict({'I': phase * np.cos(angle), 'Z': -1j * phase * np.sin(angle)})
+        angle = _pi(self._exponent) * self._exponent / 2
+        lib = sympy if protocols.is_parameterized(self) else np
+        return value.LinearDict({'I': phase * lib.cos(angle), 'Z': -1j * phase * lib.sin(angle)})
 
     def _phase_by_(self, phase_turns: float, qubit_index: int):
         return self

cirq/ops/common_gates_test.py

@@ -1300,3 +1300,13 @@ def test_wrong_dims():
 
     with pytest.raises(ValueError, match='Wrong shape'):
         _ = cirq.Z.on(cirq.LineQid(0, dimension=3))
+
+
+@pytest.mark.parametrize('gate_type', [cirq.XPowGate, cirq.YPowGate, cirq.ZPowGate])
+@pytest.mark.parametrize('exponent', [sympy.Symbol('s'), sympy.Symbol('s') * 2])
+def test_parameterized_pauli_expansion(gate_type, exponent):
+    gate = gate_type(exponent=exponent)
+    pauli = cirq.pauli_expansion(gate)
+    gate_resolved = cirq.resolve_parameters(gate, {'s': 0.5})
+    pauli_resolved = cirq.resolve_parameters(pauli, {'s': 0.5})
+    assert cirq.approx_eq(pauli_resolved, cirq.pauli_expansion(gate_resolved))

cirq/transformers/analytical_decompositions/controlled_gate_decomposition_test.py

@@ -96,6 +96,7 @@ def test_decompose_random_unitary():
         _test_decompose(_random_unitary(), controls_count)
 
 
+@cirq.testing.retry_once_with_later_random_values
 def test_decompose_random_special_unitary():
     for controls_count in range(5):
         for _ in range(10):

cirq/value/linear_dict.py

@@ -15,6 +15,7 @@
 """Linear combination represented as mapping of things to coefficients."""
 
 from typing import (
+    AbstractSet,
     Any,
     Callable,
     Dict,
@@ -28,6 +29,7 @@ from typing import (
     Optional,
     overload,
     Tuple,
+    TYPE_CHECKING,
     TypeVar,
     Union,
     ValuesView,
@@ -35,6 +37,11 @@ from typing import (
 from typing_extensions import Self
 
 import numpy as np
+import sympy
+from cirq import protocols
+
+if TYPE_CHECKING:
+    import cirq
 
 Scalar = Union[complex, np.number]
 TVector = TypeVar('TVector')
@@ -42,7 +49,23 @@ TVector = TypeVar('TVector')
 TDefault = TypeVar('TDefault')
 
 
-def _format_coefficient(format_spec: str, coefficient: Scalar) -> str:
+class _SympyPrinter(sympy.printing.str.StrPrinter):
+    def __init__(self, format_spec: str):
+        super().__init__()
+        self._format_spec = format_spec
+
+    def _print(self, expr, **kwargs):
+        if expr.is_complex:
+            coefficient = complex(expr)
+            s = _format_coefficient(self._format_spec, coefficient)
+            return s[1:-1] if s.startswith('(') else s
+        return super()._print(expr, **kwargs)
+
+
+def _format_coefficient(format_spec: str, coefficient: 'cirq.TParamValComplex') -> str:
+    if isinstance(coefficient, sympy.Basic):
+        printer = _SympyPrinter(format_spec)
+        return printer.doprint(coefficient)
     coefficient = complex(coefficient)
     real_str = f'{coefficient.real:{format_spec}}'
     imag_str = f'{coefficient.imag:{format_spec}}'
@@ -59,7 +82,7 @@ def _format_coefficient(format_spec: str, coefficient: Scalar) -> str:
     return f'({real_str}+{imag_str}j)'
 
 
-def _format_term(format_spec: str, vector: TVector, coefficient: Scalar) -> str:
+def _format_term(format_spec: str, vector: TVector, coefficient: 'cirq.TParamValComplex') -> str:
     coefficient_str = _format_coefficient(format_spec, coefficient)
     if not coefficient_str:
         return coefficient_str
@@ -69,7 +92,7 @@ def _format_term(format_spec: str, vector: TVector, coefficient: Scalar) -> str:
     return '+' + result
 
 
-def _format_terms(terms: Iterable[Tuple[TVector, Scalar]], format_spec: str):
+def _format_terms(terms: Iterable[Tuple[TVector, 'cirq.TParamValComplex']], format_spec: str):
     formatted_terms = [_format_term(format_spec, vector, coeff) for vector, coeff in terms]
     s = ''.join(formatted_terms)
     if not s:
@@ -79,7 +102,7 @@ def _format_terms(terms: Iterable[Tuple[TVector, Scalar]], format_spec: str):
     return s
 
 
-class LinearDict(Generic[TVector], MutableMapping[TVector, Scalar]):
+class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComplex']):
     """Represents linear combination of things.
 
     LinearDict implements the basic linear algebraic operations of vector
@@ -96,7 +119,7 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, Scalar]):
 
     def __init__(
         self,
-        terms: Optional[Mapping[TVector, Scalar]] = None,
+        terms: Optional[Mapping[TVector, 'cirq.TParamValComplex']] = None,
         validator: Optional[Callable[[TVector], bool]] = None,
     ) -> None:
         """Initializes linear combination from a collection of terms.
@@ -112,13 +135,18 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, Scalar]):
         """
         self._has_validator = validator is not None
         self._is_valid = validator or (lambda x: True)
-        self._terms: Dict[TVector, Scalar] = {}
+        self._terms: Dict[TVector, 'cirq.TParamValComplex'] = {}
         if terms is not None:
             self.update(terms)
 
     @classmethod
     def fromkeys(cls, vectors, coefficient=0):
-        return LinearDict(dict.fromkeys(vectors, complex(coefficient)))
+        return LinearDict(
+            dict.fromkeys(
+                vectors,
+                coefficient if isinstance(coefficient, sympy.Basic) else complex(coefficient),
+            )
+        )
 
     def _check_vector_valid(self, vector: TVector) -> None:
         if not self._is_valid(vector):
@@ -126,7 +154,11 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, Scalar]):
 
     def clean(self, *, atol: float = 1e-9) -> Self:
         """Remove terms with coefficients of absolute value atol or less."""
-        negligible = [v for v, c in self._terms.items() if abs(complex(c)) <= atol]
+        negligible = [
+            v
+            for v, c in self._terms.items()
+            if not isinstance(c, sympy.Basic) and abs(complex(c)) <= atol
+        ]
         for v in negligible:
             del self._terms[v]
         return self
@@ -139,40 +171,50 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, Scalar]):
         snapshot = self.copy().clean(atol=0)
         return snapshot._terms.keys()
 
-    def values(self) -> ValuesView[Scalar]:
+    def values(self) -> ValuesView['cirq.TParamValComplex']:
         snapshot = self.copy().clean(atol=0)
         return snapshot._terms.values()
 
-    def items(self) -> ItemsView[TVector, Scalar]:
+    def items(self) -> ItemsView[TVector, 'cirq.TParamValComplex']:
         snapshot = self.copy().clean(atol=0)
         return snapshot._terms.items()
 
     # pylint: disable=function-redefined
     @overload
-    def update(self, other: Mapping[TVector, Scalar], **kwargs: Scalar) -> None:
+    def update(
+        self, other: Mapping[TVector, 'cirq.TParamValComplex'], **kwargs: 'cirq.TParamValComplex'
+    ) -> None:
         pass
 
     @overload
-    def update(self, other: Iterable[Tuple[TVector, Scalar]], **kwargs: Scalar) -> None:
+    def update(
+        self,
+        other: Iterable[Tuple[TVector, 'cirq.TParamValComplex']],
+        **kwargs: 'cirq.TParamValComplex',
+    ) -> None:
         pass
 
     @overload
-    def update(self, *args: Any, **kwargs: Scalar) -> None:
+    def update(self, *args: Any, **kwargs: 'cirq.TParamValComplex') -> None:
         pass
 
     def update(self, *args, **kwargs):
         terms = dict()
         terms.update(*args, **kwargs)
         for vector, coefficient in terms.items():
+            if isinstance(coefficient, sympy.Basic):
+                coefficient = sympy.simplify(coefficient)
+                if coefficient.is_complex:
+                    coefficient = complex(coefficient)
             self[vector] = coefficient
         self.clean(atol=0)
 
     @overload
-    def get(self, vector: TVector) -> Scalar:
+    def get(self, vector: TVector) -> 'cirq.TParamValComplex':
         pass
 
     @overload
-    def get(self, vector: TVector, default: TDefault) -> Union[Scalar, TDefault]:
+    def get(self, vector: TVector, default: TDefault) -> Union['cirq.TParamValComplex', TDefault]:
         pass
 
     def get(self, vector, default=0):
@@ -185,10 +227,10 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, Scalar]):
     def __contains__(self, vector: Any) -> bool:
         return vector in self._terms and self._terms[vector] != 0
 
-    def __getitem__(self, vector: TVector) -> Scalar:
+    def __getitem__(self, vector: TVector) -> 'cirq.TParamValComplex':
         return self._terms.get(vector, 0)
 
-    def __setitem__(self, vector: TVector, coefficient: Scalar) -> None:
+    def __setitem__(self, vector: TVector, coefficient: 'cirq.TParamValComplex') -> None:
         self._check_vector_valid(vector)
         if coefficient != 0:
             self._terms[vector] = coefficient
@@ -236,21 +278,21 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, Scalar]):
         factory = type(self)
         return factory({v: -c for v, c in self.items()})
 
-    def __imul__(self, a: Scalar) -> Self:
+    def __imul__(self, a: 'cirq.TParamValComplex') -> Self:
         for vector in self:
             self._terms[vector] *= a
         self.clean(atol=0)
         return self
 
-    def __mul__(self, a: Scalar) -> Self:
+    def __mul__(self, a: 'cirq.TParamValComplex') -> Self:
         result = self.copy()
         result *= a
-        return result
+        return result.copy()
 
-    def __rmul__(self, a: Scalar) -> Self:  # type: ignore
+    def __rmul__(self, a: 'cirq.TParamValComplex') -> Self:
         return self.__mul__(a)
 
-    def __truediv__(self, a: Scalar) -> Self:
+    def __truediv__(self, a: 'cirq.TParamValComplex') -> Self:
         return self.__mul__(1 / a)
 
     def __bool__(self) -> bool:
@@ -320,3 +362,19 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, Scalar]):
     @classmethod
     def _from_json_dict_(cls, keys, values, **kwargs):
         return cls(terms=dict(zip(keys, values)))
+
+    def _is_parameterized_(self) -> bool:
+        return any(protocols.is_parameterized(v) for v in self._terms.values())
+
+    def _parameter_names_(self) -> AbstractSet[str]:
+        return set(name for v in self._terms.values() for name in protocols.parameter_names(v))
+
+    def _resolve_parameters_(self, resolver: 'cirq.ParamResolver', recursive: bool) -> 'LinearDict':
+        result = self.copy()
+        result.update(
+            {
+                k: protocols.resolve_parameters(v, resolver, recursive)
+                for k, v in self._terms.items()
+            }
+        )
+        return result

cirq/value/linear_dict_test.py

@@ -14,6 +14,7 @@
 
 import numpy as np
 import pytest
+import sympy
 
 import cirq
 
@@ -24,6 +25,12 @@ def test_empty_init():
     assert not v
 
 
+sym = sympy.Symbol('sym')
+expr = sym * -(2 + 3j)
+symval = expr.subs({'sym': 5})
+symvalresolved = -10 - 15j
+
+
 @pytest.mark.parametrize(
     'keys, coefficient, terms_expected',
     (
@@ -31,6 +38,9 @@ def test_empty_init():
         (('X',), 2, {'X': 2}),
         (('a', 'b', 'c', 'd'), 0.5, {'a': 0.5, 'b': 0.5, 'c': 0.5, 'd': 0.5}),
         (('b', 'c', 'd', 'e'), -2j, {'b': -2j, 'c': -2j, 'd': -2j, 'e': -2j}),
+        (('b', 'c'), sym, {'b': sym, 'c': sym}),
+        (('b', 'c'), expr, {'b': expr, 'c': expr}),
+        (('b', 'c'), symval, {'b': symvalresolved, 'c': symvalresolved}),
     ),
 )
 def test_fromkeys(keys, coefficient, terms_expected):
@@ -273,6 +283,9 @@ def test_len(terms, expected_length):
         ({'X': 1}, {'Y': 2}, {'X': 1, 'Y': 2}),
         ({'X': 1}, {'X': 1}, {'X': 2}),
         ({'X': 1, 'Y': 2}, {'Y': -2}, {'X': 1}),
+        ({'X': 1}, {'X': sym}, {'X': sym + 1}),
+        ({'X': 1}, {'X': expr}, {'X': expr + 1}),
+        ({'X': 1}, {'X': symval}, {'X': symvalresolved + 1}),
     ),
 )
 def test_vector_addition(terms_1, terms_2, terms_expected):
@@ -297,6 +310,9 @@ def test_vector_addition(terms_1, terms_2, terms_expected):
         ({'X': 1}, {'X': 1}, {}),
         ({'X': 1, 'Y': 2}, {'Y': 2}, {'X': 1}),
         ({'X': 1, 'Y': 2}, {'Y': 3}, {'X': 1, 'Y': -1}),
+        ({'X': 1}, {'X': sym}, {'X': 1 - sym}),
+        ({'X': 1}, {'X': expr}, {'X': 1 - expr}),
+        ({'X': 1}, {'X': symval}, {'X': 1 - symvalresolved}),
     ),
 )
 def test_vector_subtraction(terms_1, terms_2, terms_expected):
@@ -313,7 +329,14 @@ def test_vector_subtraction(terms_1, terms_2, terms_expected):
 
 @pytest.mark.parametrize(
     'terms, terms_expected',
-    (({}, {}), ({'key': 1}, {'key': -1}), ({'1': 10, '2': -20}, {'1': -10, '2': 20})),
+    (
+        ({}, {}),
+        ({'key': 1}, {'key': -1}),
+        ({'1': 10, '2': -20}, {'1': -10, '2': 20}),
+        ({'key': sym}, {'key': -sym}),
+        ({'key': expr}, {'key': -expr}),
+        ({'key': symval}, {'key': -symvalresolved}),
+    ),
 )
 def test_vector_negation(terms, terms_expected):
     linear_dict = cirq.LinearDict(terms)
@@ -331,6 +354,12 @@ def test_vector_negation(terms, terms_expected):
         (0, {'abc': 10, 'def': 20}, {}),
         (1j, {'X': 4j}, {'X': -4}),
         (-1, {'a': 10, 'b': -20}, {'a': -10, 'b': 20}),
+        (2, {'X': sym}, {'X': 2 * sym}),
+        (2, {'X': expr}, {'X': 2 * expr}),
+        (2, {'X': symval}, {'X': 2 * symvalresolved}),
+        (sym, {'X': 2}, {'X': 2 * sym}),
+        (expr, {'X': 2}, {'X': 2 * expr}),
+        (symval, {'X': 2}, {'X': 2 * symvalresolved}),
     ),
 )
 def test_scalar_multiplication(scalar, terms, terms_expected):
@@ -350,6 +379,12 @@ def test_scalar_multiplication(scalar, terms, terms_expected):
         (2, {'X': 6, 'Y': -2}, {'X': 3, 'Y': -1}),
         (1j, {'X': 1, 'Y': 1j}, {'X': -1j, 'Y': 1}),
         (-1, {'a': 10, 'b': -20}, {'a': -10, 'b': 20}),
+        (2, {'X': sym}, {'X': 0.5 * sym}),
+        (2, {'X': expr}, {'X': 0.5 * expr}),
+        (2, {'X': symval}, {'X': 0.5 * symvalresolved}),
+        (sym, {'X': 2}, {'X': 2 / sym}),
+        (expr, {'X': 2}, {'X': 2 / expr}),
+        (symval, {'X': 2}, {'X': 2 / symvalresolved}),
     ),
 )
 def test_scalar_division(scalar, terms, terms_expected):
@@ -387,7 +422,13 @@ def test_bool(terms, bool_value):
 
 @pytest.mark.parametrize(
     'terms_1, terms_2',
-    (({}, {}), ({}, {'X': 0}), ({'X': 0.0}, {'Y': 0.0}), ({'a': 1}, {'a': 1, 'b': 0})),
+    (
+        ({}, {}),
+        ({}, {'X': 0}),
+        ({'X': 0.0}, {'Y': 0.0}),
+        ({'a': 1}, {'a': 1, 'b': 0}),
+        ({'X': sym}, {'X': sym}),
+    ),
 )
 def test_equal(terms_1, terms_2):
     linear_dict_1 = cirq.LinearDict(terms_1)
@@ -405,6 +446,7 @@ def test_equal(terms_1, terms_2):
         ({'X': 1e-12}, {'X': 0}),
         ({'X': 0.0}, {'Y': 0.1}),
         ({'X': 1}, {'X': 1, 'Z': 1e-12}),
+        ({'X': sym + 0.1}, {'X': sym}),
     ),
 )
 def test_unequal(terms_1, terms_2):
@@ -423,6 +465,7 @@ def test_unequal(terms_1, terms_2):
         ({'X': 1e-12}, {'X': 0}),
         ({'X': 5e-10}, {'Y': 2e-11}),
         ({'X': 1.000000001}, {'X': 1, 'Z': 0}),
+        ({'X': sym + 0.000000001}, {'X': sym}),
     ),
 )
 def test_approximately_equal(terms_1, terms_2):
@@ -476,7 +519,20 @@ def test_format(terms, fmt, expected_string):
     assert actual_string.replace(' ', '') == expected_string.replace(' ', '')
 
 
-@pytest.mark.parametrize('terms', (({}, {'X': 1}, {'X': 2, 'Y': 3}, {'X': 1.23456789e-12})))
+@pytest.mark.parametrize(
+    'terms',
+    (
+        (
+            {},
+            {'X': 1},
+            {'X': 2, 'Y': 3},
+            {'X': 1.23456789e-12},
+            {'X': sym},
+            ({'X': sym * 2}),
+            {'X': symval},
+        )
+    ),
+)
 def test_repr(terms):
     original = cirq.LinearDict(terms)
     recovered = eval(repr(original))
@@ -502,6 +558,10 @@ def test_repr(terms):
         ({'X': -2, 'Y': -3}, '-2.000*X-3.000*Y'),
         ({'X': -2j, 'Y': -3}, '-2.000j*X-3.000*Y'),
         ({'X': -2j, 'Y': -3j}, '-2.000j*X-3.000j*Y'),
+        ({'X': sym}, 'sym*X'),
+        ({'X': sym * 2}, '2.000*sym*X'),
+        ({'X': expr}, '-sym*(2.000+3.000j)*X'),
+        ({'X': symval}, '-(10.000+15.000j)*X'),
     ),
 )
 def test_str(terms, string):
@@ -547,3 +607,34 @@ def test_repr_pretty(terms):
 def test_json_fails_with_validator():
     with pytest.raises(ValueError, match='not json serializable'):
         _ = cirq.to_json(cirq.LinearDict({}, validator=lambda: True))
+
+
+@pytest.mark.parametrize(
+    'terms, names',
+    (
+        ({'X': sym}, {'sym'}),
+        ({'X': sym * sympy.Symbol('a')}, {'sym', 'a'}),
+        ({'X': expr}, {'sym'}),
+        ({'X': sym, 'Y': sympy.Symbol('a')}, {'sym', 'a'}),
+        ({'X': symval}, set()),
+    ),
+)
+def test_parameter_names(terms, names):
+    linear_dict = cirq.LinearDict(terms)
+    assert cirq.parameter_names(linear_dict) == names
+
+
+@pytest.mark.parametrize(
+    'terms, expected',
+    (
+        ({'X': sym}, {'X': 2}),
+        ({'X': sym * sympy.Symbol('a')}, {'X': 6}),
+        ({'X': expr}, {'X': -4 - 6j}),
+        ({'X': sym, 'Y': sympy.Symbol('a')}, {'X': 2, 'Y': 3}),
+        ({'X': symval}, {'X': symvalresolved}),
+    ),
+)
+def test_resolve_parameters(terms, expected):
+    linear_dict = cirq.LinearDict(terms)
+    expected_dict = cirq.LinearDict(expected)
+    assert cirq.resolve_parameters(linear_dict, {'sym': 2, 'a': 3}) == expected_dict

cirq/value/type_alias.py

@@ -14,10 +14,10 @@
 
 from typing import Union
 
+import numpy as np
 import sympy
 
 from cirq._doc import document
-from cirq.value import linear_dict
 
 """Supply aliases for commonly used types.
 """
@@ -28,5 +28,5 @@ document(TParamKey, """A parameter that a parameter resolver may map to a value.
 TParamVal = Union[float, sympy.Expr]
 document(TParamVal, """A value that a parameter resolver may return for a parameter.""")
 
-TParamValComplex = Union[linear_dict.Scalar, sympy.Expr]
+TParamValComplex = Union[complex, np.number, sympy.Expr]
 document(TParamValComplex, """A complex value that parameter resolvers may use for parameters.""")

cirq_core-1.5.0.dev20250205194253.dist-info/METADATA

@@ -0,0 +1,119 @@
+Metadata-Version: 2.1
+Name: cirq-core
+Version: 1.5.0.dev20250205194253
+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
+Author-email: cirq-dev@googlegroups.com
+Maintainer: The Quantum AI open-source software maintainers
+Maintainer-email: quantum-oss-maintainers@google.com
+License: Apache 2
+Keywords: algorithms,api,cirq,google,google quantum,nisq,python,quantum,quantum algorithms,quantum circuit,quantum circuit simulator,quantum computer simulator,quantum computing,quantum development kit,quantum information,quantum programming,quantum programming language,quantum simulation,sdk,simulation
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Quantum Computing
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: attrs>=21.3.0
+Requires-Dist: duet>=0.2.8
+Requires-Dist: matplotlib~=3.7
+Requires-Dist: networkx~=3.1
+Requires-Dist: numpy>=1.25
+Requires-Dist: pandas~=2.0
+Requires-Dist: sortedcontainers~=2.0
+Requires-Dist: scipy~=1.11
+Requires-Dist: sympy
+Requires-Dist: typing-extensions>=4.2
+Requires-Dist: tqdm
+Provides-Extra: contrib
+Requires-Dist: ply>=3.6; extra == "contrib"
+Requires-Dist: pylatex~=1.4; extra == "contrib"
+Requires-Dist: quimb>=1.8; extra == "contrib"
+Requires-Dist: opt-einsum; extra == "contrib"
+
+<div align='center' width='50%'>
+
+| ⚠️ WARNING |
+|:----------:|
+| **This is a development version of `cirq-core` and may be<br>unstable. For the latest stable release of `cirq-core`,<br>please visit** <https://pypi.org/project/cirq-core>.|
+
+</div>
+
+<div align="center">
+<img width="220px" alt="Cirq logo"
+src="https://raw.githubusercontent.com/quantumlib/Cirq/refs/heads/main/docs/images/Cirq_logo_color.svg">
+</div>
+
+# cirq-core
+
+[Cirq] is a Python package for writing, manipulating, and running [quantum
+circuits](https://en.wikipedia.org/wiki/Quantum_circuit) on quantum computers
+and simulators. Cirq provides useful abstractions for dealing with today’s
+[noisy intermediate-scale quantum](https://arxiv.org/abs/1801.00862) (NISQ)
+computers, where the details of quantum hardware are vital to achieving
+state-of-the-art results. For more information about Cirq, please visit the
+[Cirq documentation site].
+
+This Python module is `cirq-core`, which contains all the code you need to
+write quantum algorithms for NISQ devices and run them on the built-in Cirq
+simulators.
+
+To run algorithms on a given quantum computing platform, you will also need to
+install an appropriate Cirq hardware interface module. Please visit the
+[hardware section of the Cirq documentation
+site](https://quantumai.google/cirq/hardware) for information about the
+hardware interface modules currently available.
+
+[Cirq]: https://github.com/quantumlib/cirq
+[Cirq documentation site]: https://quantumai.google/cirq
+
+## Installation
+
+There are two installation options for the `cirq-core` module:
+
+*   To install the stable version of `cirq-core`, use
+
+    ```shell
+    pip install cirq-core
+    ```
+
+*   To install the latest pre-release version of `cirq-core`, use
+
+    ```shell
+    pip install cirq-core~=1.0.dev
+    ```
+
+    (The `~=` has a special meaning to `pip` of selecting the latest version
+    compatible with the `1.*` and `dev` in the name. Despite appearances,
+    this will not install an old version 1.0 release!)
+
+If you would like to install Cirq with all the optional modules, not just
+`cirq-core`, then instead of the above commands, use `pip install cirq` for the
+stable release or `pip install cirq~=1.0.dev` for the latest pre-release
+version.
+
+## Documentation
+
+To get started with using Cirq, please refer to the [Cirq documentation site].
+
+For more information about getting help, reporting bugs, and other matters
+related to Cirq and the Cirq-Core integration module, please visit the [Cirq
+repository on GitHub](https://github.com/quantumlib/Cirq).
+
+## Disclaimer
+
+Cirq is not an official Google product. Copyright 2019 The Cirq Developers.

{cirq_core-1.5.0.dev20250131224919.dist-info → cirq_core-1.5.0.dev20250205194253.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=Y-FgKqKJJ5vpudAfAqHMU_xit3pZ6QCYKXrq8pFdM3w,1206
-cirq/_version_test.py,sha256=LypYIuenDlEB56wYmDzV-_4Jpm-Eeb5VqQ0EB_GBwk0,147
+cirq/_version.py,sha256=gno6a2CDY4sCjlypTFIKWsy9N09lk98yTKvycQ5GjAg,1206
+cirq/_version_test.py,sha256=GHzN2Nz4dKpH8LxDN-lorBJIsoXHMSZSd_HhfTIklnk,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
@@ -42,7 +42,7 @@ cirq/contrib/acquaintance/devices.py,sha256=1hWW9_WF5TZQXFMu9-yXNTk3GfSETyjikNbo
 cirq/contrib/acquaintance/devices_test.py,sha256=icl_9SOp8PuZu7msfW5H7zP7_-zfTwTjyPPkajDu-w4,1088
 cirq/contrib/acquaintance/executor.py,sha256=ZGPWcEVYAdkqA9rvECsp7WFgxYC_wAvfE6HKNqzT7AM,8681
 cirq/contrib/acquaintance/executor_test.py,sha256=ir-LKuQTfHm5WCcjmLriJ8qCT89YnltLpFx89Q3bF_I,7837
-cirq/contrib/acquaintance/gates.py,sha256=YSsxvvyXQQOsEOr9lKdy0s00w6EAN7mWbu3Y0zjHEU8,13545
+cirq/contrib/acquaintance/gates.py,sha256=ZYEVM8CxY_jAuI7iuf8Fbn-rKHh9M8GFlUmA6AscnZE,13577
 cirq/contrib/acquaintance/gates_test.py,sha256=5FVX7zAtZSUqDPNsXk_Wm7LwDmHIApzgNhjAIX1IQBM,15010
 cirq/contrib/acquaintance/inspection_utils.py,sha256=-olAKpSZPm4Q9xhaQwAjT2ovUqZQd5zXAJ0ImkffOWk,2607
 cirq/contrib/acquaintance/inspection_utils_test.py,sha256=N5WyOkZaP7Vy0DRoiq6ZtQ1S99j5F7XyRPnyRLJqmtM,1250
@@ -103,10 +103,10 @@ cirq/contrib/paulistring/recombine_test.py,sha256=hJ083nR67JsIs38TfmCjmBLnhqyG0r
 cirq/contrib/paulistring/separate.py,sha256=2g4l78mXYJDR6xkv51VExZDb-rm5JEvhYrpMPgWa0Us,3961
 cirq/contrib/paulistring/separate_test.py,sha256=FzR78MSHDhNJxizbXreK6u3BeYhT7xn7W1QyHfEZ34E,1267
 cirq/contrib/qasm_import/__init__.py,sha256=RKX0vGDC2Pe5rH5rM4ClXdvtrAU16ePFImQpiJtJVNo,744
-cirq/contrib/qasm_import/_lexer.py,sha256=DFfDArOd8F46XNjmvGR3EW-TA2d8Tn3unSoQIg_krMw,3453
-cirq/contrib/qasm_import/_lexer_test.py,sha256=lFLgL-D_-tXJOQJjwg_49tzhUqFnikvbB_SwV_s8qOg,5655
-cirq/contrib/qasm_import/_parser.py,sha256=qyU4q9Fz-hJBlh9swcEeNCwJ8YUORrgMJoc-f9bbldA,25997
-cirq/contrib/qasm_import/_parser_test.py,sha256=gW1sk7EKUgQP79t-RtgeiCeI88Vtp-zqy2f-yEHU91E,39299
+cirq/contrib/qasm_import/_lexer.py,sha256=-72amAxuZbkybMH-xBynqYqx1-TnRVpl51Dd2qtjjCY,2928
+cirq/contrib/qasm_import/_lexer_test.py,sha256=mgzCMoXwngMOJ8JZYVqaSNRIiZEnnzpla_3jo9UMLjQ,6217
+cirq/contrib/qasm_import/_parser.py,sha256=S9Yme100Yp3Ye8wGoCm0MkAeweOvPI1uOV7UbbDoEDc,26053
+cirq/contrib/qasm_import/_parser_test.py,sha256=PL0Os1pZmvS8xg8kgXoeEng322lR9nlpBrlanKzmkyU,39925
 cirq/contrib/qasm_import/exception.py,sha256=Wm6cwUPIkNMPjkv-ELpQ-zSoXaiLOddOQ4iYybwuS6I,695
 cirq/contrib/qasm_import/qasm.py,sha256=CP444IWCw4zlDNA7HxsTJ2xIak4mZhQv62ZiLlUc2zo,914
 cirq/contrib/qasm_import/qasm_test.py,sha256=e5b7LVn_6FIFZ6kINqMzJFIjzgtTgutVhgXgX_DcTc0,1861
@@ -277,8 +277,8 @@ 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=9QAhME6hhj5UiW0xWpZ58ltII-h8t8DY1GoyMgeyMxo,58120
-cirq/ops/common_gates_test.py,sha256=XCVswZbd_k9Y2k5n-2TXnS8CnJoLoC3VmBQN0QijIKw,46218
+cirq/ops/common_gates.py,sha256=0kQPjqB5vZmjKyUiQj-B_08cZ5wxTfa8e_5wfu4ce50,58209
+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
 cirq/ops/controlled_gate.py,sha256=8ELuov5mOUp_cNwwrwMEjB4NwDph4Cpi7ezABx86W8Y,14261
@@ -1081,7 +1081,7 @@ cirq/transformers/analytical_decompositions/__init__.py,sha256=hMsoQSQtSvEn5mNoh
 cirq/transformers/analytical_decompositions/clifford_decomposition.py,sha256=DsuuP91pm2dX0CO4rWwmJAJyAfuXMcA1UJK0g8krp7k,6726
 cirq/transformers/analytical_decompositions/clifford_decomposition_test.py,sha256=AAZh_9vEb5f2E_EItPZTlMRNdv0d47AwqTn4BytX0UI,7102
 cirq/transformers/analytical_decompositions/controlled_gate_decomposition.py,sha256=iFF2vb5tI4PVQVHBOP_tuy8EKUtGg8aMDZSdK-74YMI,8675
-cirq/transformers/analytical_decompositions/controlled_gate_decomposition_test.py,sha256=oVr92Kdvent8x5xLpK3clT1a3OM0QTs2DmrsuJhV7ag,5000
+cirq/transformers/analytical_decompositions/controlled_gate_decomposition_test.py,sha256=sZ2eDF5foEyNhTDqSzTYKkug4CMY7QmF4NCN-FaA530,5050
 cirq/transformers/analytical_decompositions/cphase_to_fsim.py,sha256=RDg0wzYa_YXBJepCgloD_OIwTOwNco98dqGoe0UsnhI,9108
 cirq/transformers/analytical_decompositions/cphase_to_fsim_test.py,sha256=bwZa0BDclAd1sX3bD-GdNF2MO5DtH7mw2YLppEK0LG0,5568
 cirq/transformers/analytical_decompositions/pauli_string_decomposition.py,sha256=bU9IoY0igVZTmF_wsTdTxAfqPKWyqZ14Gt2AJoK5D_4,4524
@@ -1155,8 +1155,8 @@ cirq/value/digits.py,sha256=pUQi6PIA1FMbXUOWknefb6dBApCyLsTkpLFrhvNgE0Q,6024
 cirq/value/digits_test.py,sha256=evx-y619LfjSN_gUO1B6K7O80X5HJmxxBPl61RrOovo,3812
 cirq/value/duration.py,sha256=isNzA1TuKb5rSaAYy4JpgT91Zt9_5XLQBSmMkuWCtD4,10358
 cirq/value/duration_test.py,sha256=C7nwg7IlHoQOUhWa_aX8vy7_qp654ZIDtmnKF35UiqE,8244
-cirq/value/linear_dict.py,sha256=RyCxuUyoJCTUtTIw3vtVYd2TYKOmcMj7IKOSZcwgU0k,10635
-cirq/value/linear_dict_test.py,sha256=uEHbvobWV4EypOXQGe6B4xh6atLbQq8YSOomNHgv38o,17107
+cirq/value/linear_dict.py,sha256=KlyntK71PZOlozh35K6ZTIQoNxDnQ_i5z3wQSMhuCwU,12735
+cirq/value/linear_dict_test.py,sha256=H7-3yABo7J9T8HF8_orAE0DsIUrTjNIwArTkhgpQdsc,19872
 cirq/value/measurement_key.py,sha256=glvyn36NylWMdtHYLFsD72jPZJsnKpFqQXKh8XpOX4Q,5200
 cirq/value/measurement_key_test.py,sha256=GnEX5QdEVbmi0dR9URcgXQH23aqW7Y_PKmTb2eIdRCg,4466
 cirq/value/periodic_value.py,sha256=U_tYBgWNVblZ6XDSwbXZin67KA0jUZiDAPpz-w7bnhw,3956
@@ -1169,7 +1169,7 @@ cirq/value/random_state.py,sha256=SA4owzMPof8P5FLPhGUPN7ODfciKAIY24PgxfmnJ5AY,20
 cirq/value/random_state_test.py,sha256=0VyxtuBYgrbHsNCXFZtcgucd5KwI1obMjILH2ZTZ5BU,1348
 cirq/value/timestamp.py,sha256=u0v5FmnSF_o3NE7aF-xIfQ5cDAVZzaUb-ZMdrxWYg2Y,3649
 cirq/value/timestamp_test.py,sha256=eZt9LLVK6TQy-2Bo1djitUD4at7i7M4lN60bLCx9UPs,4029
-cirq/value/type_alias.py,sha256=YD5m-77rx-hatIEVi5Q5j5tZ2Ji3Mmg4jUY9GT3LscM,1144
+cirq/value/type_alias.py,sha256=bmKOnIIiHbjU4x62QBxAPyvdzsyv9fGyMEBz_ivwBo8,1128
 cirq/value/value_equality_attr.py,sha256=9tU54y5JUAGKsvNV9G1nCWJioP6gvTlYfGN7Pe3YebI,10545
 cirq/value/value_equality_attr_test.py,sha256=k_nl5hWxo4yMO6WNu0wU68wyeb-RN9Ua_Ix7s9UTfOE,6412
 cirq/vis/__init__.py,sha256=YzNrNjIyUiTxKHGzYw92qzOYzx8aXkm2y_1hkfVohtU,1171
@@ -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.dev20250131224919.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.5.0.dev20250131224919.dist-info/METADATA,sha256=cq8XYDnBIz3QiU-I-2_bzhTUm_DjMMhuGB_M00WbpHI,3239
-cirq_core-1.5.0.dev20250131224919.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-cirq_core-1.5.0.dev20250131224919.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.5.0.dev20250131224919.dist-info/RECORD,,
+cirq_core-1.5.0.dev20250205194253.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.5.0.dev20250205194253.dist-info/METADATA,sha256=ZcjzsLqI_LBiMpwCu_YAiXnqdYey1CzEiYqFp1Ul7qo,4811
+cirq_core-1.5.0.dev20250205194253.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+cirq_core-1.5.0.dev20250205194253.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.5.0.dev20250205194253.dist-info/RECORD,,

cirq_core-1.5.0.dev20250131224919.dist-info/METADATA

@@ -1,69 +0,0 @@
-Metadata-Version: 2.1
-Name: cirq-core
-Version: 1.5.0.dev20250131224919
-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
-Author-email: cirq-dev@googlegroups.com
-Maintainer: The Quantum AI open-source software maintainers
-Maintainer-email: quantum-oss-maintainers@google.com
-License: Apache 2
-Keywords: algorithms,api,cirq,google,google quantum,nisq,python,quantum,quantum algorithms,quantum circuit,quantum circuit simulator,quantum computer simulator,quantum computing,quantum development kit,quantum information,quantum programming,quantum programming language,quantum simulation,sdk,simulation
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Education
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: MacOS :: MacOS X
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Scientific/Engineering :: Quantum Computing
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Typing :: Typed
-Requires-Python: >=3.10.0
-License-File: LICENSE
-Requires-Dist: attrs>=21.3.0
-Requires-Dist: duet>=0.2.8
-Requires-Dist: matplotlib~=3.7
-Requires-Dist: networkx~=3.1
-Requires-Dist: numpy>=1.25
-Requires-Dist: pandas~=2.0
-Requires-Dist: sortedcontainers~=2.0
-Requires-Dist: scipy~=1.11
-Requires-Dist: sympy
-Requires-Dist: typing-extensions>=4.2
-Requires-Dist: tqdm
-Provides-Extra: contrib
-Requires-Dist: ply>=3.6; extra == "contrib"
-Requires-Dist: pylatex~=1.4; extra == "contrib"
-Requires-Dist: quimb>=1.8; extra == "contrib"
-Requires-Dist: opt-einsum; extra == "contrib"
-
-**This is a development version of Cirq-core and may be unstable.**
-
-**For the latest stable release of Cirq-core see**
-`here <https://pypi.org/project/cirq-core>`__.
-
-.. image:: https://raw.githubusercontent.com/quantumlib/Cirq/main/docs/images/Cirq_logo_color.png
-  :target: https://github.com/quantumlib/cirq
-  :alt: Cirq
-  :width: 500px
-
-Cirq is a Python library for writing, manipulating, and optimizing quantum
-circuits and running them against quantum computers and simulators.
-
-This module is **cirq-core**, which contains everything you'd need to write quantum algorithms for NISQ devices and run them on the built-in Cirq simulators.
-In order to run algorithms on a given quantum hardware platform, you'll have to install the right cirq module as well.
-
-Installation
-------------
-
-To install the stable version of only **cirq-core**, use `pip install cirq-core`.
-To install the pre-release version of only **cirq-core**, use `pip install cirq-core~=1.0.dev`.
-
-To get all the optional modules installed as well, you'll have to use `pip install cirq` or `pip install cirq~=1.0.dev` for the pre-release version.