cirq-core 1.6.0.dev20250505215959__py3-none-any.whl → 1.6.0.dev20250507223949__py3-none-any.whl

cirq/ops/pauli_string_test.py

@@ -14,7 +14,6 @@
 
 import itertools
 import math
-from typing import List
 
 import numpy as np
 import pytest
@@ -723,118 +722,6 @@ def test_to_z_basis_ops_product_state():
     )
 
 
-def _assert_pass_over(ops: List[cirq.Operation], before: cirq.PauliString, after: cirq.PauliString):
-    assert before.pass_operations_over(ops[::-1]) == after
-    assert after.pass_operations_over(ops, after_to_before=True) == before
-
-
-@pytest.mark.parametrize('shift,sign', itertools.product(range(3), (-1, +1)))
-def test_pass_operations_over_single(shift: int, sign: int):
-    q0, q1 = _make_qubits(2)
-    X, Y, Z = (cirq.Pauli.by_relative_index(pauli, shift) for pauli in (cirq.X, cirq.Y, cirq.Z))
-
-    op0 = cirq.SingleQubitCliffordGate.from_pauli(Y)(q1)
-    ps_before: cirq.PauliString[cirq.Qid] = cirq.PauliString({q0: X}, sign)
-    ps_after = ps_before
-    _assert_pass_over([op0], ps_before, ps_after)
-
-    op0 = cirq.SingleQubitCliffordGate.from_pauli(X)(q0)
-    op1 = cirq.SingleQubitCliffordGate.from_pauli(Y)(q1)
-    ps_before = cirq.PauliString({q0: X, q1: Y}, sign)
-    ps_after = ps_before
-    _assert_pass_over([op0, op1], ps_before, ps_after)
-
-    op0 = cirq.SingleQubitCliffordGate.from_double_map({Z: (X, False), X: (Z, False)})(q0)
-    ps_before = cirq.PauliString({q0: X, q1: Y}, sign)
-    ps_after = cirq.PauliString({q0: Z, q1: Y}, sign)
-    _assert_pass_over([op0], ps_before, ps_after)
-
-    op1 = cirq.SingleQubitCliffordGate.from_pauli(X)(q1)
-    ps_before = cirq.PauliString({q0: X, q1: Y}, sign)
-    ps_after = -ps_before
-    _assert_pass_over([op1], ps_before, ps_after)
-
-    ps_after = cirq.PauliString({q0: Z, q1: Y}, -sign)
-    _assert_pass_over([op0, op1], ps_before, ps_after)
-
-    op0 = cirq.SingleQubitCliffordGate.from_pauli(Z, True)(q0)
-    op1 = cirq.SingleQubitCliffordGate.from_pauli(X, True)(q0)
-    ps_before = cirq.PauliString({q0: X}, sign)
-    ps_after = cirq.PauliString({q0: Y}, -sign)
-    _assert_pass_over([op0, op1], ps_before, ps_after)
-
-
-@pytest.mark.parametrize(
-    'shift,t_or_f1, t_or_f2,neg', itertools.product(range(3), *((True, False),) * 3)
-)
-def test_pass_operations_over_double(shift: int, t_or_f1: bool, t_or_f2: bool, neg: bool):
-    sign = -1 if neg else +1
-    q0, q1, q2 = _make_qubits(3)
-    X, Y, Z = (cirq.Pauli.by_relative_index(pauli, shift) for pauli in (cirq.X, cirq.Y, cirq.Z))
-
-    op0 = cirq.PauliInteractionGate(Z, t_or_f1, X, t_or_f2)(q0, q1)
-    ps_before = cirq.PauliString(qubit_pauli_map={q0: Z, q2: Y}, coefficient=sign)
-    ps_after = cirq.PauliString(qubit_pauli_map={q0: Z, q2: Y}, coefficient=sign)
-    assert_conjugation(ps_before, op0, ps_after, True)
-    _assert_pass_over([op0], ps_before, ps_after)
-
-    op0 = cirq.PauliInteractionGate(Y, t_or_f1, X, t_or_f2)(q0, q1)
-    ps_before = cirq.PauliString({q0: Z, q2: Y}, sign)
-    ps_after = cirq.PauliString({q0: Z, q2: Y, q1: X}, -sign if t_or_f2 else sign)
-    assert_conjugation(ps_before, op0, ps_after, True)
-    _assert_pass_over([op0], ps_before, ps_after)
-
-    op0 = cirq.PauliInteractionGate(Z, t_or_f1, X, t_or_f2)(q0, q1)
-    ps_before = cirq.PauliString({q0: Z, q1: Y}, sign)
-    ps_after = cirq.PauliString({q1: Y}, -sign if t_or_f1 else sign)
-    assert_conjugation(ps_before, op0, ps_after, True)
-    _assert_pass_over([op0], ps_before, ps_after)
-
-    op0 = cirq.PauliInteractionGate(Y, t_or_f1, X, t_or_f2)(q0, q1)
-    ps_before = cirq.PauliString({q0: Z, q1: Y}, sign)
-    ps_after = cirq.PauliString({q0: X, q1: Z}, -1 if neg ^ t_or_f1 ^ t_or_f2 else +1)
-    assert_conjugation(ps_before, op0, ps_after, True)
-    _assert_pass_over([op0], ps_before, ps_after)
-
-    op0 = cirq.PauliInteractionGate(X, t_or_f1, X, t_or_f2)(q0, q1)
-    ps_before = cirq.PauliString({q0: Z, q1: Y}, sign)
-    ps_after = cirq.PauliString({q0: Y, q1: Z}, +1 if neg ^ t_or_f1 ^ t_or_f2 else -1)
-    assert_conjugation(ps_before, op0, ps_after, True)
-    _assert_pass_over([op0], ps_before, ps_after)
-
-
-def test_pass_operations_over_cz():
-    q0, q1 = _make_qubits(2)
-    op0 = cirq.CZ(q0, q1)
-    ps_before = cirq.PauliString({q0: cirq.Z, q1: cirq.Y})
-    ps_after = cirq.PauliString({q1: cirq.Y})
-    _assert_pass_over([op0], ps_before, ps_after)
-
-
-def test_pass_operations_over_no_common_qubits():
-    class ExampleGate(cirq.testing.SingleQubitGate):
-
-        def _decompose_(self, qubits):
-            return cirq.X(qubits[0])
-
-    q0, q1 = _make_qubits(2)
-    op0 = ExampleGate()(q1)
-    ps_before = cirq.PauliString({q0: cirq.Z})
-    ps_after = cirq.PauliString({q0: cirq.Z})
-    _assert_pass_over([op0], ps_before, ps_after)
-
-
-def test_pass_unsupported_operations_over():
-    (q0,) = _make_qubits(1)
-    pauli_string = cirq.PauliString({q0: cirq.X})
-    with pytest.raises(
-        ValueError,
-        match='Clifford Gate can only be constructed from the operations'
-        ' that has stabilizer effect.',
-    ):
-        pauli_string.pass_operations_over([cirq.T(q0)])
-
-
 def test_with_qubits():
     old_qubits = cirq.LineQubit.range(9)
     new_qubits = cirq.LineQubit.range(9, 18)
@@ -1637,40 +1524,6 @@ def test_conjugated_by_ordering():
     assert out1 == out2 == cirq.X(a) * cirq.Z(b)
 
 
-def test_pass_operations_over_ordering():
-    class OrderSensitiveGate(cirq.Gate):
-        def num_qubits(self):
-            return 2
-
-        def _decompose_(self, qubits):
-            return [cirq.Y(qubits[0]) ** -0.5, cirq.CNOT(*qubits)]
-
-    a, b = cirq.LineQubit.range(2)
-    inp = cirq.Z(b)
-    out1 = inp.pass_operations_over(OrderSensitiveGate().on(a, b))
-    out2 = inp.pass_operations_over([cirq.CNOT(a, b), cirq.Y(a) ** -0.5])
-    out3 = inp.pass_operations_over([cirq.CNOT(a, b)]).pass_operations_over([cirq.Y(a) ** -0.5])
-    assert out1 == out2 == out3 == cirq.X(a) * cirq.Z(b)
-
-
-def test_pass_operations_over_ordering_reversed():
-    class OrderSensitiveGate(cirq.Gate):
-        def num_qubits(self):
-            return 2
-
-        def _decompose_(self, qubits):
-            return [cirq.Y(qubits[0]) ** -0.5, cirq.CNOT(*qubits)]
-
-    a, b = cirq.LineQubit.range(2)
-    inp = cirq.X(a) * cirq.Z(b)
-    out1 = inp.pass_operations_over(OrderSensitiveGate().on(a, b), after_to_before=True)
-    out2 = inp.pass_operations_over([cirq.Y(a) ** -0.5, cirq.CNOT(a, b)], after_to_before=True)
-    out3 = inp.pass_operations_over([cirq.Y(a) ** -0.5], after_to_before=True).pass_operations_over(
-        [cirq.CNOT(a, b)], after_to_before=True
-    )
-    assert out1 == out2 == out3 == cirq.Z(b)
-
-
 def test_pretty_print():
     a, b, c = cirq.LineQubit.range(3)
     result = cirq.PauliString({a: 'x', b: 'y', c: 'z'})

cirq/ops/projector.py

@@ -1,13 +1,18 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+
+from __future__ import annotations
+
 import itertools
 import math
-from typing import Any, Dict, Iterable, List, Mapping, Optional
+from typing import Any, Dict, Iterable, List, Mapping, Optional, TYPE_CHECKING
 
 import numpy as np
 from scipy.sparse import csr_matrix
 
 from cirq import value
-from cirq.ops import raw_types
+
+if TYPE_CHECKING:
+    import cirq
 
 
 def _check_qids_dimension(qids):
@@ -21,7 +26,7 @@ def _check_qids_dimension(qids):
 class ProjectorString:
     """Mapping of `cirq.Qid` to measurement values (with a coefficient) representing a projector."""
 
-    def __init__(self, projector_dict: Dict[raw_types.Qid, int], coefficient: complex = 1):
+    def __init__(self, projector_dict: Dict[cirq.Qid, int], coefficient: complex = 1):
         """Constructor for ProjectorString
 
         Args:
@@ -34,14 +39,14 @@ class ProjectorString:
         self._coefficient = complex(coefficient)
 
     @property
-    def projector_dict(self) -> Dict[raw_types.Qid, int]:
+    def projector_dict(self) -> Dict[cirq.Qid, int]:
         return self._projector_dict
 
     @property
     def coefficient(self) -> complex:
         return self._coefficient
 
-    def matrix(self, projector_qids: Optional[Iterable[raw_types.Qid]] = None) -> csr_matrix:
+    def matrix(self, projector_qids: Optional[Iterable[cirq.Qid]] = None) -> csr_matrix:
         """Returns the matrix of self in computational basis of qubits.
 
         Args:
@@ -75,7 +80,7 @@ class ProjectorString:
             ([self._coefficient] * len(ones_idx), (ones_idx, ones_idx)), shape=(total_d, total_d)
         )
 
-    def _get_idx_to_keep(self, qid_map: Mapping[raw_types.Qid, int]):
+    def _get_idx_to_keep(self, qid_map: Mapping[cirq.Qid, int]):
         num_qubits = len(qid_map)
         idx_to_keep: List[Any] = [slice(0, 2)] * num_qubits
         for q in self.projector_dict.keys():
@@ -83,7 +88,7 @@ class ProjectorString:
         return tuple(idx_to_keep)
 
     def expectation_from_state_vector(
-        self, state_vector: np.ndarray, qid_map: Mapping[raw_types.Qid, int]
+        self, state_vector: np.ndarray, qid_map: Mapping[cirq.Qid, int]
     ) -> complex:
         """Expectation of the projection from a state vector.
 
@@ -105,7 +110,7 @@ class ProjectorString:
         )
 
     def expectation_from_density_matrix(
-        self, state: np.ndarray, qid_map: Mapping[raw_types.Qid, int]
+        self, state: np.ndarray, qid_map: Mapping[cirq.Qid, int]
     ) -> complex:
         """Expectation of the projection from a density matrix.
 

cirq/transformers/gauge_compiling/cphase_gauge.py

@@ -14,6 +14,8 @@
 
 """A Gauge Transformer for the cphase gate."""
 
+from __future__ import annotations
+
 import numpy as np
 
 import cirq.transformers.gauge_compiling.sqrt_cz_gauge as sqrt_cz_gauge

cirq/vis/heatmap.py

@@ -173,7 +173,7 @@ class Heatmap:
             invalid_args = ", ".join([k for k in kwargs if k not in valid_kwargs])
             raise ValueError(f"Received invalid argument(s): {invalid_args}")
 
-    def update_config(self, **kwargs) -> 'Heatmap':
+    def update_config(self, **kwargs) -> Heatmap:
         """Add/Modify **kwargs args passed during initialisation."""
         self._validate_kwargs(kwargs)
         self._config.update(kwargs)

cirq/work/sampler.py

@@ -11,8 +11,11 @@
 # 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.
+
 """Abstract base class for things sampling quantum circuits."""
 
+from __future__ import annotations
+
 import collections
 from typing import Dict, FrozenSet, List, Optional, Sequence, Tuple, TYPE_CHECKING, TypeVar, Union
 
@@ -38,10 +41,10 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
 
     def run(
         self,
-        program: 'cirq.AbstractCircuit',
-        param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
+        program: cirq.AbstractCircuit,
+        param_resolver: cirq.ParamResolverOrSimilarType = None,
         repetitions: int = 1,
-    ) -> 'cirq.Result':
+    ) -> cirq.Result:
         """Samples from the given `Circuit`.
 
         This mode of operation for a sampler will provide results
@@ -66,10 +69,10 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
 
     async def run_async(
         self,
-        program: 'cirq.AbstractCircuit',
-        param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
+        program: cirq.AbstractCircuit,
+        param_resolver: cirq.ParamResolverOrSimilarType = None,
         repetitions: int = 1,
-    ) -> 'cirq.Result':
+    ) -> cirq.Result:
         """Asynchronously samples from the given Circuit.
 
         Provides measurement outcomes as a `cirq.Result` object.  This
@@ -88,12 +91,8 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
         return results[0]
 
     def sample(
-        self,
-        program: 'cirq.AbstractCircuit',
-        *,
-        repetitions: int = 1,
-        params: 'cirq.Sweepable' = None,
-    ) -> 'pd.DataFrame':
+        self, program: cirq.AbstractCircuit, *, repetitions: int = 1, params: cirq.Sweepable = None
+    ) -> pd.DataFrame:
         """Samples the given Circuit, producing a pandas data frame.
 
         This interface will operate in a similar way to the `run` method
@@ -180,21 +179,21 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
         return pd.concat(results)
 
     def _run_sweep_impl(
-        self, program: 'cirq.AbstractCircuit', params: 'cirq.Sweepable', repetitions: int = 1
-    ) -> Sequence['cirq.Result']:
+        self, program: cirq.AbstractCircuit, params: cirq.Sweepable, repetitions: int = 1
+    ) -> Sequence[cirq.Result]:
         """Implements run_sweep using run_sweep_async"""
         return duet.run(self.run_sweep_async, program, params, repetitions)
 
     async def _run_sweep_async_impl(
-        self, program: 'cirq.AbstractCircuit', params: 'cirq.Sweepable', repetitions: int = 1
-    ) -> Sequence['cirq.Result']:
+        self, program: cirq.AbstractCircuit, params: cirq.Sweepable, repetitions: int = 1
+    ) -> Sequence[cirq.Result]:
         """Implements run_sweep_async using run_sweep"""
         return self.run_sweep(program, params=params, repetitions=repetitions)
 
     @value.alternative(requires='run_sweep_async', implementation=_run_sweep_impl)
     def run_sweep(
-        self, program: 'cirq.AbstractCircuit', params: 'cirq.Sweepable', repetitions: int = 1
-    ) -> Sequence['cirq.Result']:
+        self, program: cirq.AbstractCircuit, params: cirq.Sweepable, repetitions: int = 1
+    ) -> Sequence[cirq.Result]:
         """Samples from the given Circuit.
 
         This allows for sweeping over different parameter values,
@@ -217,8 +216,8 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
 
     @value.alternative(requires='run_sweep', implementation=_run_sweep_async_impl)
     async def run_sweep_async(
-        self, program: 'cirq.AbstractCircuit', params: 'cirq.Sweepable', repetitions: int = 1
-    ) -> Sequence['cirq.Result']:
+        self, program: cirq.AbstractCircuit, params: cirq.Sweepable, repetitions: int = 1
+    ) -> Sequence[cirq.Result]:
         """Asynchronously samples from the given Circuit.
 
         By default, this method invokes `run_sweep` synchronously and simply
@@ -237,10 +236,10 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
 
     async def run_batch_async(
         self,
-        programs: Sequence['cirq.AbstractCircuit'],
-        params_list: Optional[Sequence['cirq.Sweepable']] = None,
+        programs: Sequence[cirq.AbstractCircuit],
+        params_list: Optional[Sequence[cirq.Sweepable]] = None,
         repetitions: Union[int, Sequence[int]] = 1,
-    ) -> Sequence[Sequence['cirq.Result']]:
+    ) -> Sequence[Sequence[cirq.Result]]:
         """Runs the supplied circuits asynchronously.
 
         Each circuit provided in `programs` will pair with the optional
@@ -288,10 +287,10 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
 
     def _normalize_batch_args(
         self,
-        programs: Sequence['cirq.AbstractCircuit'],
-        params_list: Optional[Sequence['cirq.Sweepable']] = None,
+        programs: Sequence[cirq.AbstractCircuit],
+        params_list: Optional[Sequence[cirq.Sweepable]] = None,
         repetitions: Union[int, Sequence[int]] = 1,
-    ) -> Tuple[Sequence['cirq.Sweepable'], Sequence[int]]:
+    ) -> Tuple[Sequence[cirq.Sweepable], Sequence[int]]:
         if params_list is None:
             params_list = [None] * len(programs)
         if len(programs) != len(params_list):
@@ -310,11 +309,11 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
 
     def sample_expectation_values(
         self,
-        program: 'cirq.AbstractCircuit',
-        observables: Union['cirq.PauliSumLike', List['cirq.PauliSumLike']],
+        program: cirq.AbstractCircuit,
+        observables: Union[cirq.PauliSumLike, List[cirq.PauliSumLike]],
         *,
         num_samples: int,
-        params: 'cirq.Sweepable' = None,
+        params: cirq.Sweepable = None,
         permit_terminal_measurements: bool = False,
     ) -> Sequence[Sequence[float]]:
         """Calculates estimated expectation values from samples of a circuit.
@@ -360,7 +359,7 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
             )
 
         # Wrap input into a list of pauli sum
-        pauli_sums: List['cirq.PauliSum'] = (
+        pauli_sums: List[cirq.PauliSum] = (
             [ops.PauliSum.wrap(o) for o in observables]
             if isinstance(observables, List)
             else [ops.PauliSum.wrap(observables)]
@@ -369,8 +368,8 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
 
         # Flatten Pauli Sum into one big list of Pauli String
         # Keep track of which Pauli Sum each one was from.
-        flat_pstrings: List['cirq.PauliString'] = []
-        pstring_to_psum_i: Dict['cirq.PauliString', int] = {}
+        flat_pstrings: List[cirq.PauliString] = []
+        pstring_to_psum_i: Dict[cirq.PauliString, int] = {}
         for psum_i, pauli_sum in enumerate(pauli_sums):
             for pstring in pauli_sum:
                 flat_pstrings.append(pstring)
@@ -378,7 +377,7 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
 
         # Flatten Circuit Sweep into one big list of Params.
         # Keep track of their indices so we can map back.
-        flat_params: List['cirq.ParamMappingType'] = [
+        flat_params: List[cirq.ParamMappingType] = [
             pr.param_dict for pr in study.to_resolvers(params)
         ]
         circuit_param_to_sweep_i: Dict[FrozenSet[Tuple[str, Union[int, Tuple[int, int]]]], int] = {
@@ -409,7 +408,7 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
 
     @staticmethod
     def _get_measurement_shapes(
-        circuit: 'cirq.AbstractCircuit',
+        circuit: cirq.AbstractCircuit,
     ) -> Dict[str, Tuple[int, Tuple[int, ...]]]:
         """Gets the shapes of measurements in the given circuit.
 

cirq/work/sampler_test.py

@@ -11,7 +11,11 @@
 # 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.
+
 """Tests for cirq.Sampler."""
+
+from __future__ import annotations
+
 from typing import Sequence
 
 import duet
@@ -285,8 +289,8 @@ def test_sampler_sample_expectation_values_calculation():
         """
 
         def run_sweep(
-            self, program: 'cirq.AbstractCircuit', params: 'cirq.Sweepable', repetitions: int = 1
-        ) -> Sequence['cirq.Result']:
+            self, program: cirq.AbstractCircuit, params: cirq.Sweepable, repetitions: int = 1
+        ) -> Sequence[cirq.Result]:
             results = np.zeros((repetitions, 1), dtype=bool)
             for idx in range(repetitions // 4):
                 results[idx][0] = 1

cirq/work/zeros_sampler.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import abc
 from typing import List, Optional, TYPE_CHECKING
 
@@ -36,7 +38,7 @@ class ZerosSampler(work.Sampler, metaclass=abc.ABCMeta):
         self.device = device
 
     def run_sweep(
-        self, program: 'cirq.AbstractCircuit', params: study.Sweepable, repetitions: int = 1
+        self, program: cirq.AbstractCircuit, params: study.Sweepable, repetitions: int = 1
     ) -> List[study.Result]:
         """Samples circuit as if every measurement resulted in zero.
 

cirq/work/zeros_sampler_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numpy as np
 import pytest
 import sympy
@@ -72,7 +74,7 @@ def test_repeated_keys():
 
 
 class OnlyMeasurementsDevice(cirq.Device):
-    def validate_operation(self, operation: 'cirq.Operation') -> None:
+    def validate_operation(self, operation: cirq.Operation) -> None:
         if not cirq.is_measurement(operation):
             raise ValueError(f'{operation} is not a measurement and this device only measures!')
 

{cirq_core-1.6.0.dev20250505215959.dist-info → cirq_core-1.6.0.dev20250507223949.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cirq-core
-Version: 1.6.0.dev20250505215959
+Version: 1.6.0.dev20250507223949
 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