cirq-core 1.4.1__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/qis/clifford_tableau.py

@@ -14,10 +14,11 @@
 
 import abc
 from typing import Any, Dict, List, Optional, Sequence, TYPE_CHECKING
+
 import numpy as np
 
 from cirq import protocols
-from cirq._compat import proper_repr, cached_method
+from cirq._compat import _method_cache_name, cached_method, proper_repr
 from cirq.qis import quantum_state_representation
 from cirq.value import big_endian_int_to_digits, linear_dict, random_state
 
@@ -326,32 +327,42 @@ class CliffordTableau(StabilizerState):
         return string
 
     def _str_full_(self) -> str:
-        string = ''
-
-        string += 'stable' + ' ' * max(self.n * 2 - 3, 1)
-        string += '| destable\n'
-        string += '-' * max(7, self.n * 2 + 3) + '+' + '-' * max(10, self.n * 2 + 4) + '\n'
-
-        for j in range(self.n):
-            for i in [j + self.n, j]:
-                string += '- ' if self.rs[i] else '+ '
-
-                for k in range(self.n):
-                    if self.xs[i, k] & (not self.zs[i, k]):
-                        string += f'X{k}'
-                    elif (not self.xs[i, k]) & self.zs[i, k]:
-                        string += f'Z{k}'
-                    elif self.xs[i, k] & self.zs[i, k]:
-                        string += f'Y{k}'
-                    else:
-                        string += '  '
-
-                if i == j + self.n:
-                    string += ' ' * max(0, 4 - self.n * 2) + ' | '
-
-            string += '\n'
+        left_col_width = max(7, self.n * 2 + 3)
+        right_col_width = max(10, self.n * 2 + 4)
+
+        def _fill_row(left: str, right: str, mid='|', fill=' ') -> str:
+            """Builds a left-aligned fixed-width row with 2 columns."""
+            return f"{left:{fill}<{left_col_width}}{mid}{right:{fill}<{right_col_width}}".rstrip()
+
+        def _pauli_from_matrix(r: int, c: int) -> str:
+            match (bool(self.xs[r, c]), bool(self.zs[r, c])):
+                case (True, False):
+                    return f'X{c}'
+                case (False, True):
+                    return f'Z{c}'
+                case (True, True):
+                    return f'Y{c}'
+                case _:
+                    # (False, False) is the only leftover option
+                    return '  '
+
+        title_row = _fill_row('stable', ' destable')
+        divider = _fill_row('', '', mid='+', fill='-')
+        contents = [
+            _fill_row(
+                left=(
+                    f"{'-' if self.rs[i + self.n] else '+'} "
+                    f"{''.join(_pauli_from_matrix(i + self.n, j) for j in range(self.n))}"
+                ),
+                right=(
+                    f" {'-' if self.rs[i] else '+'} "
+                    f"{''.join(_pauli_from_matrix(i, j) for j in range(self.n))}"
+                ),
+            )
+            for i in range(self.n)
+        ]
 
-        return string
+        return '\n'.join([title_row, divider, *contents]) + '\n'
 
     def then(self, second: 'CliffordTableau') -> 'CliffordTableau':
         """Returns a composed CliffordTableau of this tableau and the second tableau.
@@ -658,3 +669,12 @@ class CliffordTableau(StabilizerState):
     @cached_method
     def __hash__(self) -> int:
         return hash(self.matrix().tobytes() + self.rs.tobytes())
+
+    def __getstate__(self) -> Dict[str, Any]:
+        # clear cached hash value when pickling, see #6674
+        state = self.__dict__
+        hash_attr = _method_cache_name(self.__hash__)
+        if hash_attr in state:
+            state = state.copy()
+            del state[hash_attr]
+        return state

cirq/qis/clifford_tableau_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 """Tests for clifford tableau."""
+
 import numpy as np
 import pytest
 
@@ -308,7 +309,7 @@ def test_str_full():
     t = cirq.CliffordTableau(num_qubits=2)
     expected_str = r"""stable | destable
 -------+----------
-+ Z0   | + X0  
++ Z0   | + X0
 +   Z1 | +   X1
 """
     assert t._str_full_() == expected_str

cirq/qis/entropy.py

@@ -0,0 +1,115 @@
+# Copyright 2024 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 collections.abc import Sequence
+from concurrent.futures import ThreadPoolExecutor
+from itertools import product
+from typing import Any, Optional
+
+import numpy as np
+import numpy.typing as npt
+
+
+def _get_hamming_distance(
+    bitstring_1: npt.NDArray[np.int8], bitstring_2: npt.NDArray[np.int8]
+) -> int:
+    """Calculates the Hamming distance between two bitstrings.
+    Args:
+        bitstring_1: Bitstring 1
+        bitstring_2: Bitstring 2
+    Returns: The Hamming distance
+    """
+    return (bitstring_1 ^ bitstring_2).sum().item()
+
+
+def _bitstrings_to_probs(
+    bitstrings: npt.NDArray[np.int8],
+) -> tuple[npt.NDArray[np.int8], npt.NDArray[Any]]:
+    """Given a list of bitstrings from different measurements returns a probability distribution.
+    Args:
+        bitstrings: The bitstring
+    Returns:
+        A tuple of bitstrings and their corresponding probabilities.
+    """
+
+    num_shots = bitstrings.shape[0]
+    unique_bitstrings, counts = np.unique(bitstrings, return_counts=True, axis=0)
+    probs = counts / num_shots
+
+    return (unique_bitstrings, probs)
+
+
+def _bitstring_format_helper(
+    measured_bitstrings: npt.NDArray[np.int8], subsystem: Sequence[int] | None = None
+) -> npt.NDArray[np.int8]:
+    """Formats the bitstring for analysis based on the selected subsystem.
+    Args:
+        measured_bitstrings: List of sampled measurement outcomes as a numpy array of bitstrings.
+        subsystem: Subsystem of interest
+    Returns: The bitstring string for the subsystem
+    """
+    if subsystem is None:
+        return measured_bitstrings
+
+    return measured_bitstrings[:, :, subsystem]
+
+
+def _compute_bitstrings_contribution_to_purity(bitstrings: npt.NDArray[np.int8]) -> float:
+    """Computes the contribution to the purity of the bitstrings.
+    Args:
+        bitstrings: The bitstrings measured using the same unitary operators
+    Returns: The purity of the bitstring
+    """
+
+    bitstrings, probs = _bitstrings_to_probs(bitstrings)
+    purity = 0
+    for (s, p), (s_prime, p_prime) in product(zip(bitstrings, probs), repeat=2):
+        purity += (-2.0) ** float(-_get_hamming_distance(s, s_prime)) * p * p_prime
+
+    return purity * 2 ** (bitstrings.shape[-1])
+
+
+def process_renyi_entropy_from_bitstrings(
+    measured_bitstrings: npt.NDArray[np.int8],
+    subsystem: tuple[int] | None = None,
+    pool: Optional[ThreadPoolExecutor] = None,
+) -> float:
+    """Compute the Rényi entropy of an array of bitstrings.
+    Args:
+        measured_bitstrings: List of sampled measurement outcomes as a numpy array of bitstrings.
+        subsystem: Subsystem of interest
+        pool: ThreadPoolExecutor used to paralelleize the computation.
+
+    Returns:
+        A float indicating the computed entropy.
+    """
+    bitstrings = _bitstring_format_helper(measured_bitstrings, subsystem)
+    num_shots = bitstrings.shape[1]
+    num_qubits = bitstrings.shape[-1]
+
+    if num_shots == 1:
+        return 0
+
+    if pool is not None:
+        purities = list(pool.map(_compute_bitstrings_contribution_to_purity, list(bitstrings)))
+        purity = np.mean(purities)
+
+    else:
+        purity = np.mean(
+            [_compute_bitstrings_contribution_to_purity(bitstring) for bitstring in bitstrings]
+        )
+
+    purity_unbiased = purity * num_shots / (num_shots - 1) - (2**num_qubits) / (num_shots - 1)
+
+    return -np.log2(purity_unbiased)

cirq/qis/entropy_test.py

@@ -0,0 +1,43 @@
+# Copyright 2024 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 concurrent.futures import ThreadPoolExecutor
+
+import numpy as np
+import pytest
+
+from cirq.qis.entropy import process_renyi_entropy_from_bitstrings
+
+
+@pytest.mark.parametrize('pool', [None, ThreadPoolExecutor(max_workers=1)])
+def test_process_renyi_entropy_from_bitstrings(pool):
+    bitstrings = np.array(
+        [
+            [[0, 1, 1, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 1, 1, 1]],
+            [[0, 1, 1, 0], [0, 1, 1, 0], [1, 1, 0, 0], [1, 1, 0, 1]],
+            [[0, 0, 1, 1], [0, 0, 0, 0], [0, 1, 1, 1], [0, 1, 1, 1]],
+            [[1, 0, 1, 1], [0, 1, 0, 0], [0, 1, 0, 1], [0, 1, 0, 0]],
+            [[1, 0, 1, 1], [0, 0, 1, 0], [0, 0, 1, 0], [0, 0, 0, 1]],
+        ]
+    )
+    substsytem = (0, 1)
+    entropy = process_renyi_entropy_from_bitstrings(bitstrings, substsytem, pool)
+    assert entropy == 0.5145731728297583
+
+
+def test_process_renyi_entropy_from_bitstrings_safeguards_against_divide_by_0_error():
+    bitstrings = np.array([[[0, 1, 1, 0]], [[0, 1, 1, 0]], [[0, 0, 1, 1]]])
+
+    entropy = process_renyi_entropy_from_bitstrings(bitstrings)
+    assert entropy == 0

cirq/qis/measures.py

@@ -14,15 +14,15 @@
 """Measures on and between quantum states and operations."""
 
 
-from typing import Optional, TYPE_CHECKING, Tuple
+from typing import Optional, Tuple, TYPE_CHECKING
 
 import numpy as np
 
-from cirq import protocols, value, _import
+from cirq import _import, protocols, value
 from cirq.qis.states import (
-    QuantumState,
     infer_qid_shape,
     quantum_state,
+    QuantumState,
     validate_density_matrix,
     validate_normalized_state_vector,
 )
@@ -247,7 +247,8 @@ def _fidelity_state_vectors_or_density_matrices(state1: np.ndarray, state2: np.n
         eigs = linalg.eigvalsh(state1_sqrt @ state2 @ state1_sqrt)
         trace = np.sum(np.sqrt(np.abs(eigs)))
         return trace**2
-    raise ValueError(
+    # matrix is reshaped before this point
+    raise ValueError(  # pragma: no cover
         'The given arrays must be one- or two-dimensional. '
         f'Got shapes {state1.shape} and {state2.shape}.'
     )

cirq/qis/measures_test.py

@@ -34,6 +34,13 @@ def test_fidelity_symmetric():
     )
 
 
+def test_bad_fidelity():
+    arr = np.asarray([[[1j, 0], [0, 0]], [[0, 0], [0, 0]]])
+    assert arr.ndim > 2
+    assert arr.dtype.kind == 'c'
+    _ = cirq.fidelity(arr, arr)
+
+
 def test_fidelity_between_zero_and_one():
     assert 0 <= cirq.fidelity(VEC1, VEC2) <= 1
     assert 0 <= cirq.fidelity(VEC1, MAT1) <= 1

cirq/qis/noise_utils_test.py

@@ -16,13 +16,13 @@ import numpy as np
 import pytest
 
 from cirq.qis.noise_utils import (
-    decay_constant_to_xeb_fidelity,
+    average_error,
     decay_constant_to_pauli_error,
+    decay_constant_to_xeb_fidelity,
+    decoherence_pauli_error,
+    pauli_error_from_t1,
     pauli_error_to_decay_constant,
     xeb_fidelity_to_decay_constant,
-    pauli_error_from_t1,
-    average_error,
-    decoherence_pauli_error,
 )
 
 

cirq/qis/quantum_state_representation.py

@@ -14,9 +14,9 @@
 
 import abc
 from typing import List, Sequence, Tuple, TYPE_CHECKING
-from typing_extensions import Self
 
 import numpy as np
+from typing_extensions import Self
 
 from cirq import value
 

cirq/qis/states.py

@@ -14,8 +14,8 @@
 
 """Classes and methods for quantum states."""
 
-from typing import Any, cast, Iterable, List, Optional, Sequence, Set, TYPE_CHECKING, Tuple, Union
 import itertools
+from typing import Any, cast, Iterable, List, Optional, Sequence, Set, Tuple, TYPE_CHECKING, Union
 
 import numpy as np
 
@@ -23,9 +23,10 @@ from cirq import value
 from cirq._doc import document
 
 if TYPE_CHECKING:
-    import cirq
     from numpy.typing import DTypeLike
 
+    import cirq
+
 DEFAULT_COMPLEX_DTYPE = np.complex64
 
 STATE_VECTOR_LIKE = Union[
@@ -35,7 +36,7 @@ STATE_VECTOR_LIKE = Union[
     Sequence[int],
     # Explicit state vector or state tensor.
     np.ndarray,
-    Sequence[Union[int, float, complex]],
+    Sequence[complex],
     # Product state object
     'cirq.ProductState',
 ]
@@ -264,7 +265,7 @@ def quantum_state(
             dtype = DEFAULT_COMPLEX_DTYPE
         data = one_hot(index=state, shape=(dim,), dtype=dtype)
     else:
-        data = np.array(state, copy=False)
+        data = np.asarray(state)
         if qid_shape is None:
             qid_shape = infer_qid_shape(state)
         if data.ndim == 1 and data.dtype.kind != 'c':
@@ -341,7 +342,7 @@ _NON_INT_STATE_LIKE = Union[
     Sequence[int],
     # Explicit state vector or state tensor.
     np.ndarray,
-    Sequence[Union[int, float, complex]],
+    Sequence[complex],
     # Product state object
     'cirq.ProductState',
     # Quantum state object
@@ -677,7 +678,6 @@ def density_matrix_from_state_vector(
     sum_inds = np.array(range(n_qubits))
     sum_inds[indices] += n_qubits
 
-    # TODO(#5757): remove type ignore when numpy has proper override signature.
     rho = np.einsum(
         state_vector,
         list(range(n_qubits)),
@@ -845,7 +845,7 @@ def _qudit_values_to_state_tensor(
             )
 
     if state_vector.dtype.kind[0] not in '?bBiu':
-        raise ValueError(
+        raise ValueError(  # pragma: no cover
             f'Expected a bool or int entry for each qudit in '
             f'`state`, because len(state) == len(qid_shape), '
             f'but got dtype {state_vector.dtype}.'

cirq/sim/__init__.py

@@ -15,63 +15,81 @@
 """Classes for circuit simulators and base implementations of these classes."""
 
 from cirq.sim.clifford import (
-    CliffordSimulator,
-    CliffordSimulatorStepResult,
-    CliffordState,
-    CliffordTrialResult,
-    CliffordTableauSimulationState,
-    StabilizerChFormSimulationState,
-    StabilizerSampler,
-    StabilizerSimulationState,
-    StabilizerStateChForm,
+    CliffordSimulator as CliffordSimulator,
+    CliffordSimulatorStepResult as CliffordSimulatorStepResult,
+    CliffordState as CliffordState,
+    CliffordTrialResult as CliffordTrialResult,
+    CliffordTableauSimulationState as CliffordTableauSimulationState,
+    StabilizerChFormSimulationState as StabilizerChFormSimulationState,
+    StabilizerSampler as StabilizerSampler,
+    StabilizerSimulationState as StabilizerSimulationState,
+    StabilizerStateChForm as StabilizerStateChForm,
 )
 
-from cirq.sim.density_matrix_simulation_state import DensityMatrixSimulationState
+from cirq.sim.density_matrix_simulation_state import (
+    DensityMatrixSimulationState as DensityMatrixSimulationState,
+)
 
 from cirq.sim.density_matrix_simulator import (
-    DensityMatrixSimulator,
-    DensityMatrixStepResult,
-    DensityMatrixTrialResult,
+    DensityMatrixSimulator as DensityMatrixSimulator,
+    DensityMatrixStepResult as DensityMatrixStepResult,
+    DensityMatrixTrialResult as DensityMatrixTrialResult,
 )
 
-from cirq.sim.density_matrix_utils import measure_density_matrix, sample_density_matrix
+from cirq.sim.density_matrix_utils import (
+    measure_density_matrix as measure_density_matrix,
+    sample_density_matrix as sample_density_matrix,
+)
 
 from cirq.sim.mux import (
-    CIRCUIT_LIKE,
-    final_density_matrix,
-    final_state_vector,
-    sample,
-    sample_sweep,
+    CIRCUIT_LIKE as CIRCUIT_LIKE,
+    final_density_matrix as final_density_matrix,
+    final_state_vector as final_state_vector,
+    sample as sample,
+    sample_sweep as sample_sweep,
 )
 
-from cirq.sim.simulation_product_state import SimulationProductState
+from cirq.sim.simulation_product_state import SimulationProductState as SimulationProductState
 
-from cirq.sim.simulation_state import SimulationState
+from cirq.sim.simulation_state import SimulationState as SimulationState
 
-from cirq.sim.simulation_state_base import SimulationStateBase
+from cirq.sim.simulation_state_base import SimulationStateBase as SimulationStateBase
 
 from cirq.sim.simulator import (
-    SimulatesAmplitudes,
-    SimulatesExpectationValues,
-    SimulatesFinalState,
-    SimulatesIntermediateState,
-    SimulatesSamples,
-    SimulationTrialResult,
-    StepResult,
+    SimulatesAmplitudes as SimulatesAmplitudes,
+    SimulatesExpectationValues as SimulatesExpectationValues,
+    SimulatesFinalState as SimulatesFinalState,
+    SimulatesIntermediateState as SimulatesIntermediateState,
+    SimulatesSamples as SimulatesSamples,
+    SimulationTrialResult as SimulationTrialResult,
+    StepResult as StepResult,
 )
 
-from cirq.sim.simulator_base import SimulationTrialResultBase, SimulatorBase, StepResultBase
+from cirq.sim.simulator_base import (
+    SimulationTrialResultBase as SimulationTrialResultBase,
+    SimulatorBase as SimulatorBase,
+    StepResultBase as StepResultBase,
+)
 
-from cirq.sim.sparse_simulator import Simulator, SparseSimulatorStep
+from cirq.sim.sparse_simulator import (
+    Simulator as Simulator,
+    SparseSimulatorStep as SparseSimulatorStep,
+)
 
-from cirq.sim.state_vector import measure_state_vector, sample_state_vector, StateVectorMixin
+from cirq.sim.state_vector import (
+    measure_state_vector as measure_state_vector,
+    sample_state_vector as sample_state_vector,
+    StateVectorMixin as StateVectorMixin,
+)
 
-from cirq.sim.state_vector_simulation_state import StateVectorSimulationState
+from cirq.sim.state_vector_simulation_state import (
+    StateVectorSimulationState as StateVectorSimulationState,
+)
 
-from cirq.sim.classical_simulator import ClassicalStateSimulator
+from cirq.sim.classical_simulator import ClassicalStateSimulator as ClassicalStateSimulator
 
 from cirq.sim.state_vector_simulator import (
-    SimulatesIntermediateStateVector,
-    StateVectorStepResult,
-    StateVectorTrialResult,
+    SimulatesIntermediateStateVector as SimulatesIntermediateStateVector,
+    StateVectorStepResult as StateVectorStepResult,
+    StateVectorTrialResult as StateVectorTrialResult,
 )

cirq/sim/classical_simulator.py

@@ -13,14 +13,15 @@
 # limitations under the License.
 
 
-from typing import Dict, Generic, Any, Sequence, List, Optional, Union, TYPE_CHECKING
-from copy import deepcopy, copy
-from cirq import ops, qis
-from cirq.value import big_endian_int_to_bits
-from cirq import sim
-from cirq.sim.simulation_state import TSimulationState, SimulationState
+from copy import copy, deepcopy
+from typing import Any, Dict, Generic, List, Optional, Sequence, TYPE_CHECKING, Union
+
 import numpy as np
 
+from cirq import ops, qis, sim
+from cirq.sim.simulation_state import SimulationState, TSimulationState
+from cirq.value import big_endian_int_to_bits
+
 if TYPE_CHECKING:
     import cirq
 

cirq/sim/classical_simulator_test.py

@@ -13,11 +13,13 @@
 # limitations under the License.
 
 from itertools import product
+
 import numpy as np
 import pytest
-import cirq
 import sympy
 
+import cirq
+
 
 def test_x_gate():
     q0, q1 = cirq.LineQubit.range(2)

cirq/sim/clifford/__init__.py

@@ -1,18 +1,26 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
 
 from cirq.sim.clifford.clifford_simulator import (
-    CliffordSimulator,
-    CliffordSimulatorStepResult,
-    CliffordState,
-    CliffordTrialResult,
+    CliffordSimulator as CliffordSimulator,
+    CliffordSimulatorStepResult as CliffordSimulatorStepResult,
+    CliffordState as CliffordState,
+    CliffordTrialResult as CliffordTrialResult,
 )
 
-from cirq.sim.clifford.clifford_tableau_simulation_state import CliffordTableauSimulationState
+from cirq.sim.clifford.clifford_tableau_simulation_state import (
+    CliffordTableauSimulationState as CliffordTableauSimulationState,
+)
 
-from cirq.sim.clifford.stabilizer_ch_form_simulation_state import StabilizerChFormSimulationState
+from cirq.sim.clifford.stabilizer_ch_form_simulation_state import (
+    StabilizerChFormSimulationState as StabilizerChFormSimulationState,
+)
 
-from cirq.sim.clifford.stabilizer_sampler import StabilizerSampler
+from cirq.sim.clifford.stabilizer_sampler import StabilizerSampler as StabilizerSampler
 
-from cirq.sim.clifford.stabilizer_simulation_state import StabilizerSimulationState
+from cirq.sim.clifford.stabilizer_simulation_state import (
+    StabilizerSimulationState as StabilizerSimulationState,
+)
 
-from cirq.sim.clifford.stabilizer_state_ch_form import StabilizerStateChForm
+from cirq.sim.clifford.stabilizer_state_ch_form import (
+    StabilizerStateChForm as StabilizerStateChForm,
+)

cirq/sim/clifford/clifford_simulator.py

@@ -15,8 +15,8 @@
 """An efficient simulator for Clifford circuits.
 
 Allowed operations include:
-	- X,Y,Z,H,S,CNOT,CZ
-	- measurements in the computational basis
+    - X,Y,Z,H,S,CNOT,CZ
+    - measurements in the computational basis
 
 The quantum state is specified in two forms:
     1. In terms of stabilizer generators. These are a set of n Pauli operators
@@ -90,7 +90,8 @@ class CliffordSimulator(
             StabilizerChFormSimulationState for the circuit.
         """
         if isinstance(initial_state, clifford.StabilizerChFormSimulationState):
-            return initial_state
+            # Instances of SimulationStateBase usually returned before this point
+            return initial_state  # pragma: no cover
 
         return clifford.StabilizerChFormSimulationState(
             prng=self._prng,
@@ -188,7 +189,7 @@ class CliffordSimulatorStepResult(
         return self._clifford_state
 
 
-@value.value_equality
+@value.value_equality(unhashable=True)
 class CliffordState:
     """A state of the Clifford simulation.