cirq-core 1.5.0.dev20240823014143__py3-none-any.whl → 1.5.0.dev20240830211827__py3-none-any.whl

cirq/sim/state_vector_test.py

@@ -14,16 +14,24 @@
 """Tests for state_vector.py"""
 
 import itertools
-from typing import Optional
-import pytest
+from typing import Iterator, Optional
+from unittest import mock
 
 import numpy as np
+import pytest
 
 import cirq
 import cirq.testing
 from cirq import linalg
 
 
+@pytest.fixture
+def use_np_transpose(request) -> Iterator[bool]:
+    value: bool = request.param
+    with mock.patch.object(linalg, 'can_numpy_support_shape', lambda shape: value):
+        yield value
+
+
 def test_state_mixin():
     class TestClass(cirq.StateVectorMixin):
         def state_vector(self, copy: Optional[bool] = None) -> np.ndarray:
@@ -173,9 +181,10 @@ def test_sample_no_indices_repetitions():
     )
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_computational_basis(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
+    # verify patching of can_numpy_support_shape in the use_np_transpose fixture
+    assert linalg.can_numpy_support_shape([1]) is use_np_transpose
     results = []
     for x in range(8):
         initial_state = cirq.to_valid_state_vector(x, 3)
@@ -186,9 +195,8 @@ def test_measure_state_computational_basis(use_np_transpose: bool):
     assert results == expected
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_reshape(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     results = []
     for x in range(8):
         initial_state = np.reshape(cirq.to_valid_state_vector(x, 3), [2] * 3)
@@ -199,9 +207,8 @@ def test_measure_state_reshape(use_np_transpose: bool):
     assert results == expected
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_partial_indices(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     for index in range(3):
         for x in range(8):
             initial_state = cirq.to_valid_state_vector(x, 3)
@@ -210,9 +217,8 @@ def test_measure_state_partial_indices(use_np_transpose: bool):
             assert bits == [bool(1 & (x >> (2 - index)))]
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_partial_indices_order(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     for x in range(8):
         initial_state = cirq.to_valid_state_vector(x, 3)
         bits, state = cirq.measure_state_vector(initial_state, [2, 1])
@@ -220,9 +226,8 @@ def test_measure_state_partial_indices_order(use_np_transpose: bool):
         assert bits == [bool(1 & (x >> 0)), bool(1 & (x >> 1))]
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_partial_indices_all_orders(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     for perm in itertools.permutations([0, 1, 2]):
         for x in range(8):
             initial_state = cirq.to_valid_state_vector(x, 3)
@@ -231,9 +236,8 @@ def test_measure_state_partial_indices_all_orders(use_np_transpose: bool):
             assert bits == [bool(1 & (x >> (2 - p))) for p in perm]
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_collapse(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     initial_state = np.zeros(8, dtype=np.complex64)
     initial_state[0] = 1 / np.sqrt(2)
     initial_state[2] = 1 / np.sqrt(2)
@@ -256,9 +260,8 @@ def test_measure_state_collapse(use_np_transpose: bool):
         assert bits == [False]
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_seed(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     n = 10
     initial_state = np.ones(2**n) / 2 ** (n / 2)
 
@@ -277,9 +280,8 @@ def test_measure_state_seed(use_np_transpose: bool):
     np.testing.assert_allclose(state1, state2)
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_out_is_state(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     initial_state = np.zeros(8, dtype=np.complex64)
     initial_state[0] = 1 / np.sqrt(2)
     initial_state[2] = 1 / np.sqrt(2)
@@ -290,9 +292,8 @@ def test_measure_state_out_is_state(use_np_transpose: bool):
     assert state is initial_state
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_out_is_not_state(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     initial_state = np.zeros(8, dtype=np.complex64)
     initial_state[0] = 1 / np.sqrt(2)
     initial_state[2] = 1 / np.sqrt(2)
@@ -302,18 +303,16 @@ def test_measure_state_out_is_not_state(use_np_transpose: bool):
     assert out is state
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_not_power_of_two(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     with pytest.raises(ValueError, match='3'):
         _, _ = cirq.measure_state_vector(np.array([1, 0, 0]), [1])
     with pytest.raises(ValueError, match='5'):
         cirq.measure_state_vector(np.array([0, 1, 0, 0, 0]), [1])
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_index_out_of_range(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     state = cirq.to_valid_state_vector(0, 3)
     with pytest.raises(IndexError, match='-2'):
         cirq.measure_state_vector(state, [-2])
@@ -321,18 +320,16 @@ def test_measure_state_index_out_of_range(use_np_transpose: bool):
         cirq.measure_state_vector(state, [3])
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_no_indices(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     initial_state = cirq.to_valid_state_vector(0, 3)
     bits, state = cirq.measure_state_vector(initial_state, [])
     assert [] == bits
     np.testing.assert_almost_equal(state, initial_state)
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_no_indices_out_is_state(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     initial_state = cirq.to_valid_state_vector(0, 3)
     bits, state = cirq.measure_state_vector(initial_state, [], out=initial_state)
     assert [] == bits
@@ -340,9 +337,8 @@ def test_measure_state_no_indices_out_is_state(use_np_transpose: bool):
     assert state is initial_state
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_no_indices_out_is_not_state(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     initial_state = cirq.to_valid_state_vector(0, 3)
     out = np.zeros_like(initial_state)
     bits, state = cirq.measure_state_vector(initial_state, [], out=out)
@@ -352,9 +348,8 @@ def test_measure_state_no_indices_out_is_not_state(use_np_transpose: bool):
     assert out is not initial_state
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_empty_state(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     initial_state = np.array([1.0])
     bits, state = cirq.measure_state_vector(initial_state, [])
     assert [] == bits

cirq/transformers/eject_phased_paulis.py

@@ -14,7 +14,7 @@
 
 """Transformer pass that pushes 180° rotations around axes in the XY plane later in the circuit."""
 
-from typing import Optional, cast, TYPE_CHECKING, Iterable, Tuple, Dict
+from typing import Optional, cast, TYPE_CHECKING, Iterable, Iterator, Tuple, Dict
 import sympy
 import numpy as np
 
@@ -127,7 +127,7 @@ def _absorb_z_into_w(
 
 def _dump_held(
     qubits: Iterable[ops.Qid], held_w_phases: Dict[ops.Qid, value.TParamVal]
-) -> 'cirq.OP_TREE':
+) -> Iterator['cirq.OP_TREE']:
     # Note: sorting is to avoid non-determinism in the insertion order.
     for q in sorted(qubits):
         p = held_w_phases.get(q)

cirq/transformers/eject_z.py

@@ -14,7 +14,7 @@
 
 """Transformer pass that pushes Z gates later and later in the circuit."""
 
-from typing import Dict, Iterable, Optional, Tuple, TYPE_CHECKING
+from typing import Dict, Iterable, Iterator, Optional, Tuple, TYPE_CHECKING
 from collections import defaultdict
 import numpy as np
 
@@ -76,7 +76,7 @@ def eject_z(
         lambda: None
     )
 
-    def dump_tracked_phase(qubits: Iterable[ops.Qid]) -> 'cirq.OP_TREE':
+    def dump_tracked_phase(qubits: Iterable[ops.Qid]) -> Iterator['cirq.OP_TREE']:
         """Zeroes qubit_phase entries by emitting Z gates."""
         for q in qubits:
             p, key = qubit_phase[q], last_phased_xz_op[q]

cirq/transformers/noise_adding.py

@@ -26,7 +26,7 @@ def _gate_in_moment(gate: ops.Gate, moment: circuits.Moment) -> bool:
 
 
 @transformer_api.transformer
-class DepolerizingNoiseTransformer:
+class DepolarizingNoiseTransformer:
     """Add local depolarizing noise after two-qubit gates in a specified circuit. More specifically,
     with probability p, append a random non-identity two-qubit Pauli operator after each specified
     two-qubit gate.

cirq/transformers/noise_adding_test.py

@@ -23,16 +23,16 @@ def test_noise_adding():
     circuit = one_layer * 10
 
     # test that p=0 does nothing
-    transformed_circuit_p0 = na.DepolerizingNoiseTransformer(0.0)(circuit)
+    transformed_circuit_p0 = na.DepolarizingNoiseTransformer(0.0)(circuit)
     assert transformed_circuit_p0 == circuit
 
     # test that p=1 doubles the circuit depth
-    transformed_circuit_p1 = na.DepolerizingNoiseTransformer(1.0)(circuit)
+    transformed_circuit_p1 = na.DepolarizingNoiseTransformer(1.0)(circuit)
     assert len(transformed_circuit_p1) == 20
 
     # test that we get a deterministic result when using a specific rng
     rng = np.random.default_rng(0)
-    transformed_circuit_p0_03 = na.DepolerizingNoiseTransformer(0.03)(circuit, rng=rng)
+    transformed_circuit_p0_03 = na.DepolarizingNoiseTransformer(0.03)(circuit, rng=rng)
     expected_circuit = (
         one_layer * 2
         + circuits.Circuit(ops.I(qubits[2]), ops.Z(qubits[3]))
@@ -44,7 +44,7 @@ def test_noise_adding():
     assert transformed_circuit_p0_03 == expected_circuit
 
     # test that supplying a dictionary for p works
-    transformed_circuit_p_dict = na.DepolerizingNoiseTransformer(
+    transformed_circuit_p_dict = na.DepolarizingNoiseTransformer(
         {tuple(qubits[:2]): 1.0, tuple(qubits[2:]): 0.0}
     )(circuit)
     assert len(transformed_circuit_p_dict) == 20  # depth should be doubled

cirq/transformers/transformer_primitives_test.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Optional, List
+from typing import Iterator, List, Optional
 import pytest
 
 import cirq
@@ -64,7 +64,7 @@ def test_map_operations_does_not_insert_too_many_moments():
     q = cirq.LineQubit.range(5)
     c_orig = cirq.Circuit(cirq.CX(q[0], q[1]), cirq.CX(q[3], q[2]), cirq.CX(q[3], q[4]))
 
-    def map_func(op: cirq.Operation, _: int) -> cirq.OP_TREE:
+    def map_func(op: cirq.Operation, _: int) -> Iterator[cirq.OP_TREE]:
         yield cirq.Z.on_each(*op.qubits)
         yield cirq.CX(*op.qubits)
         yield cirq.Z.on_each(*op.qubits)
@@ -130,7 +130,7 @@ def test_map_operations_deep_subcircuits():
         .with_tags("external")
     )
 
-    def map_func(op: cirq.Operation, _: int) -> cirq.OP_TREE:
+    def map_func(op: cirq.Operation, _: int) -> Iterator[cirq.OP_TREE]:
         yield (
             [cirq.Z.on_each(*op.qubits), cirq.CX(*op.qubits), cirq.Z.on_each(*op.qubits)]
             if op.gate == cirq.CX

cirq/value/linear_dict.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 """Linear combination represented as mapping of things to coefficients."""
-import numbers
+
 from typing import (
     Any,
     Callable,
@@ -34,7 +34,9 @@ from typing import (
 )
 from typing_extensions import Self
 
-Scalar = Union[complex, float, numbers.Complex]
+import numpy as np
+
+Scalar = Union[complex, np.number]
 TVector = TypeVar('TVector')
 
 TDefault = TypeVar('TDefault')
@@ -124,7 +126,7 @@ 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(c) <= atol]  # type: ignore[operator]
+        negligible = [v for v, c in self._terms.items() if abs(complex(c)) <= atol]
         for v in negligible:
             del self._terms[v]
         return self
@@ -245,7 +247,7 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, Scalar]):
         result *= a
         return result
 
-    def __rmul__(self, a: Scalar) -> Self:
+    def __rmul__(self, a: Scalar) -> Self:  # type: ignore
         return self.__mul__(a)
 
     def __truediv__(self, a: Scalar) -> Self:

cirq/vis/heatmap.py

@@ -11,6 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from __future__ import annotations
+
 import copy
 from dataclasses import astuple, dataclass
 from typing import (
@@ -25,6 +28,7 @@ from typing import (
     SupportsFloat,
     Tuple,
     Union,
+    TYPE_CHECKING,
 )
 
 import matplotlib as mpl
@@ -36,6 +40,9 @@ from mpl_toolkits import axes_grid1
 from cirq.devices import grid_qubit
 from cirq.vis import vis_utils
 
+if TYPE_CHECKING:
+    from numpy.typing import ArrayLike
+
 QubitTuple = Tuple[grid_qubit.GridQubit, ...]
 
 Polygon = Sequence[Tuple[float, float]]
@@ -233,13 +240,14 @@ class Heatmap:
         ax: plt.Axes,
     ) -> None:
         """Writes annotations to the center of cells. Internal."""
+        facecolor: ArrayLike
         for (center, annotation), facecolor in zip(centers_and_annot, collection.get_facecolor()):
             # Calculate the center of the cell, assuming that it is a square
             # centered at (x=col, y=row).
             if not annotation:
                 continue
             x, y = center
-            face_luminance = vis_utils.relative_luminance(facecolor)  # type: ignore
+            face_luminance = vis_utils.relative_luminance(facecolor)
             text_color = 'black' if face_luminance > 0.4 else 'white'
             text_kwargs: Dict[str, Any] = dict(color=text_color, ha="center", va="center")
             text_kwargs.update(self._config.get('annotation_text_kwargs', {}))

cirq/vis/state_histogram.py

@@ -90,7 +90,8 @@ def plot_state_histogram(
     if isinstance(data, result.Result):
         values = get_state_histogram(data)
     elif isinstance(data, collections.Counter):
-        tick_label, values = zip(*sorted(data.items()))
+        tick_label, counts = zip(*sorted(data.items()))
+        values = np.asarray(counts)
     else:
         values = np.array(data)
     if tick_label is None:

{cirq_core-1.5.0.dev20240823014143.dist-info → cirq_core-1.5.0.dev20240830211827.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.5.0.dev20240823014143
+Version: 1.5.0.dev20240830211827
 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