cirq-core 1.4.0.dev20240529225110__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/contrib/circuitdag/circuit_dag_test.py

@@ -15,8 +15,8 @@
 import itertools
 import random
 
-import pytest
 import networkx
+import pytest
 
 import cirq
 

cirq/contrib/custom_simulators/custom_state_simulator.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import Any, Dict, Generic, Sequence, Type, TYPE_CHECKING
 
 import numpy as np
@@ -47,7 +49,7 @@ class CustomStateSimulator(
         self,
         state_type: Type[TSimulationState],
         *,
-        noise: 'cirq.NOISE_MODEL_LIKE' = None,
+        noise: cirq.NOISE_MODEL_LIKE = None,
         split_untangled_states: bool = False,
     ):
         """Initializes a CustomStateSimulator.
@@ -63,24 +65,24 @@ class CustomStateSimulator(
 
     def _create_simulator_trial_result(
         self,
-        params: 'cirq.ParamResolver',
+        params: cirq.ParamResolver,
         measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[TSimulationState]',
-    ) -> 'CustomStateTrialResult[TSimulationState]':
+        final_simulator_state: cirq.SimulationStateBase[TSimulationState],
+    ) -> CustomStateTrialResult[TSimulationState]:
         return CustomStateTrialResult(
             params, measurements, final_simulator_state=final_simulator_state
         )
 
     def _create_step_result(
-        self, sim_state: 'cirq.SimulationStateBase[TSimulationState]'
-    ) -> 'CustomStateStepResult[TSimulationState]':
+        self, sim_state: cirq.SimulationStateBase[TSimulationState]
+    ) -> CustomStateStepResult[TSimulationState]:
         return CustomStateStepResult(sim_state)
 
     def _create_partial_simulation_state(
         self,
         initial_state: Any,
-        qubits: Sequence['cirq.Qid'],
-        classical_data: 'cirq.ClassicalDataStore',
+        qubits: Sequence[cirq.Qid],
+        classical_data: cirq.ClassicalDataStore,
     ) -> TSimulationState:
         return self.state_type(
             initial_state=initial_state, qubits=qubits, classical_data=classical_data

cirq/contrib/custom_simulators/custom_state_simulator_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import List, Sequence, Tuple
 
 import numpy as np
@@ -25,10 +27,10 @@ class ComputationalBasisState(cirq.qis.QuantumStateRepresentation):
     def __init__(self, initial_state: List[int]):
         self.basis = initial_state
 
-    def copy(self, deep_copy_buffers: bool = True) -> 'ComputationalBasisState':
-        return ComputationalBasisState(self.basis)
+    def copy(self, deep_copy_buffers: bool = True) -> ComputationalBasisState:
+        return ComputationalBasisState(self.basis)  # pragma: no cover
 
-    def measure(self, axes: Sequence[int], seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None):
+    def measure(self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None):
         return [self.basis[i] for i in axes]
 
 
@@ -137,25 +139,27 @@ class ComputationalBasisProductState(cirq.qis.QuantumStateRepresentation):
     def __init__(self, initial_state: List[int]):
         self.basis = initial_state
 
-    def copy(self, deep_copy_buffers: bool = True) -> 'ComputationalBasisProductState':
+    def copy(self, deep_copy_buffers: bool = True) -> ComputationalBasisProductState:
         return ComputationalBasisProductState(self.basis)
 
-    def measure(self, axes: Sequence[int], seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None):
+    def measure(self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None):
         return [self.basis[i] for i in axes]
 
-    def kron(self, other: 'ComputationalBasisProductState') -> 'ComputationalBasisProductState':
+    def kron(self, other: ComputationalBasisProductState) -> ComputationalBasisProductState:
         return ComputationalBasisProductState(self.basis + other.basis)
 
     def factor(
         self, axes: Sequence[int], *, validate=True, atol=1e-07
-    ) -> Tuple['ComputationalBasisProductState', 'ComputationalBasisProductState']:
-        extracted = ComputationalBasisProductState([self.basis[i] for i in axes])
+    ) -> Tuple[ComputationalBasisProductState, ComputationalBasisProductState]:
+        extracted = ComputationalBasisProductState(
+            [self.basis[i] for i in axes]
+        )  # pragma: no cover
         remainder = ComputationalBasisProductState(
             [self.basis[i] for i in range(len(self.basis)) if i not in axes]
-        )
-        return extracted, remainder
+        )  # pragma: no cover
+        return extracted, remainder  # pragma: no cover
 
-    def reindex(self, axes: Sequence[int]) -> 'ComputationalBasisProductState':
+    def reindex(self, axes: Sequence[int]) -> ComputationalBasisProductState:
         return ComputationalBasisProductState([self.basis[i] for i in axes])
 
     @property

cirq/contrib/graph_device/__init__.py

@@ -14,17 +14,17 @@
 
 """Tools for representing a device as an edge-labelled graph."""
 
-from cirq.contrib.graph_device.hypergraph import UndirectedHypergraph
+from cirq.contrib.graph_device.hypergraph import UndirectedHypergraph as UndirectedHypergraph
 
 from cirq.contrib.graph_device.graph_device import (
-    is_undirected_device_graph,
-    is_crosstalk_graph,
-    FixedDurationUndirectedGraphDeviceEdge,
-    UndirectedGraphDevice,
-    UnconstrainedUndirectedGraphDeviceEdge,
+    is_undirected_device_graph as is_undirected_device_graph,
+    is_crosstalk_graph as is_crosstalk_graph,
+    FixedDurationUndirectedGraphDeviceEdge as FixedDurationUndirectedGraphDeviceEdge,
+    UndirectedGraphDevice as UndirectedGraphDevice,
+    UnconstrainedUndirectedGraphDeviceEdge as UnconstrainedUndirectedGraphDeviceEdge,
 )
 
 from cirq.contrib.graph_device.uniform_graph_device import (
-    uniform_undirected_graph_device,
-    uniform_undirected_linear_device,
+    uniform_undirected_graph_device as uniform_undirected_graph_device,
+    uniform_undirected_linear_device as uniform_undirected_linear_device,
 )

cirq/contrib/graph_device/graph_device.py

@@ -12,13 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import abc
 import itertools
-
-from typing import Iterable, Optional, TYPE_CHECKING, Tuple, cast
+from typing import cast, Iterable, Optional, Tuple, TYPE_CHECKING
 
 from cirq import devices, ops, value
-
 from cirq.contrib.graph_device.hypergraph import UndirectedHypergraph
 
 if TYPE_CHECKING:
@@ -30,11 +30,11 @@ class UndirectedGraphDeviceEdge(metaclass=abc.ABCMeta):
 
     @abc.abstractmethod
     def duration_of(self, operation: ops.Operation) -> value.Duration:
-        pass  # pragma: no cover
+        pass
 
     @abc.abstractmethod
     def validate_operation(self, operation: ops.Operation) -> None:
-        pass  # pragma: no cover
+        pass
 
 
 @value.value_equality
@@ -62,7 +62,7 @@ class _UnconstrainedUndirectedGraphDeviceEdge(UndirectedGraphDeviceEdge):
         return value.Duration(picos=0)
 
     def validate_operation(self, operation: ops.Operation) -> None:
-        pass  # pragma: no cover
+        pass
 
     def __eq__(self, other):
         return self.__class__ == other.__class__
@@ -152,7 +152,7 @@ class UndirectedGraphDevice(devices.Device):
         self.crosstalk_graph = crosstalk_graph
 
     @property
-    def qubits(self) -> Tuple['cirq.Qid', ...]:
+    def qubits(self) -> Tuple[cirq.Qid, ...]:
         return cast(Tuple['cirq.Qid', ...], tuple(sorted(self.device_graph.vertices)))
 
     @property
@@ -194,7 +194,7 @@ class UndirectedGraphDevice(devices.Device):
             ):
                 validator(operation, *crosstalk_operations)
 
-    def validate_moment(self, moment: 'cirq.Moment'):
+    def validate_moment(self, moment: cirq.Moment):
         super().validate_moment(moment)
         ops = moment.operations
         for i, op in enumerate(ops):

cirq/contrib/graph_device/graph_device_test.py

@@ -15,7 +15,6 @@
 import pytest
 
 import cirq
-
 import cirq.contrib.graph_device as ccgd
 import cirq.contrib.graph_device.graph_device as ccgdgd
 

cirq/contrib/graph_device/hypergraph_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import random
+
 import pytest
 
 import cirq.contrib.graph_device as ccgd

cirq/contrib/json.py

@@ -1,6 +1,5 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
-"""Functions for JSON serialization and de-serialization for classes in Contrib.
-"""
+"""Functions for JSON serialization and de-serialization for classes in Contrib."""
 
 from cirq.protocols.json_serialization import DEFAULT_RESOLVERS
 

cirq/contrib/json_test.py

@@ -1,10 +1,10 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
 import cirq
-from cirq.testing import assert_json_roundtrip_works
-from cirq.contrib.json import DEFAULT_CONTRIB_RESOLVERS
 from cirq.contrib.acquaintance import SwapPermutationGate
 from cirq.contrib.bayesian_network import BayesianNetworkGate
+from cirq.contrib.json import DEFAULT_CONTRIB_RESOLVERS
 from cirq.contrib.quantum_volume import QuantumVolumeResult
+from cirq.testing import assert_json_roundtrip_works
 
 
 def test_bayesian_network_gate():

cirq/contrib/noise_models/__init__.py

@@ -11,11 +11,10 @@
 # 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 cirq.contrib.noise_models.noise_models import (
-    DepolarizingNoiseModel,
-    ReadoutNoiseModel,
-    DampedReadoutNoiseModel,
-    DepolarizingWithReadoutNoiseModel,
-    DepolarizingWithDampedReadoutNoiseModel,
+    DepolarizingNoiseModel as DepolarizingNoiseModel,
+    ReadoutNoiseModel as ReadoutNoiseModel,
+    DampedReadoutNoiseModel as DampedReadoutNoiseModel,
+    DepolarizingWithReadoutNoiseModel as DepolarizingWithReadoutNoiseModel,
+    DepolarizingWithDampedReadoutNoiseModel as DepolarizingWithDampedReadoutNoiseModel,
 )

cirq/contrib/noise_models/noise_models.py

@@ -12,9 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import Sequence, TYPE_CHECKING
 
-from cirq import circuits, devices, value, ops
+from cirq import circuits, devices, ops, value
 from cirq.devices.noise_model import validate_all_measurements
 
 if TYPE_CHECKING:
@@ -40,7 +42,7 @@ class DepolarizingNoiseModel(devices.NoiseModel):
         self.qubit_noise_gate = ops.DepolarizingChannel(depol_prob)
         self._prepend = prepend
 
-    def noisy_moment(self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
         if validate_all_measurements(moment) or self.is_virtual_moment(moment):  # pragma: no cover
             return moment
 
@@ -76,7 +78,7 @@ class ReadoutNoiseModel(devices.NoiseModel):
         self.readout_noise_gate = ops.BitFlipChannel(bitflip_prob)
         self._prepend = prepend
 
-    def noisy_moment(self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
         if self.is_virtual_moment(moment):
             return moment
         if validate_all_measurements(moment):
@@ -113,7 +115,7 @@ class DampedReadoutNoiseModel(devices.NoiseModel):
         self.readout_decay_gate = ops.AmplitudeDampingChannel(decay_prob)
         self._prepend = prepend
 
-    def noisy_moment(self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
         if self.is_virtual_moment(moment):
             return moment
         if validate_all_measurements(moment):
@@ -146,7 +148,7 @@ class DepolarizingWithReadoutNoiseModel(devices.NoiseModel):
         self.qubit_noise_gate = ops.DepolarizingChannel(depol_prob)
         self.readout_noise_gate = ops.BitFlipChannel(bitflip_prob)
 
-    def noisy_moment(self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
         if validate_all_measurements(moment):
             return [circuits.Moment(self.readout_noise_gate(q) for q in system_qubits), moment]
         return [moment, circuits.Moment(self.qubit_noise_gate(q) for q in system_qubits)]
@@ -176,7 +178,7 @@ class DepolarizingWithDampedReadoutNoiseModel(devices.NoiseModel):
         self.readout_noise_gate = ops.BitFlipChannel(bitflip_prob)
         self.readout_decay_gate = ops.AmplitudeDampingChannel(decay_prob)
 
-    def noisy_moment(self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
         if validate_all_measurements(moment):
             return [
                 circuits.Moment(self.readout_decay_gate(q) for q in system_qubits),

cirq/contrib/paulistring/__init__.py

@@ -14,23 +14,35 @@
 
 """Methods related to optimizing and transforming PauliStrings."""
 
-from cirq.contrib.paulistring.clifford_target_gateset import CliffordTargetGateset
+from cirq.contrib.paulistring.clifford_target_gateset import (
+    CliffordTargetGateset as CliffordTargetGateset,
+)
 
 from cirq.contrib.paulistring.separate import (
-    convert_and_separate_circuit,
-    pauli_string_half,
-    regular_half,
+    convert_and_separate_circuit as convert_and_separate_circuit,
+    pauli_string_half as pauli_string_half,
+    regular_half as regular_half,
 )
 
 from cirq.contrib.paulistring.pauli_string_dag import (
-    pauli_string_dag_from_circuit,
-    pauli_string_reorder_pred,
+    pauli_string_dag_from_circuit as pauli_string_dag_from_circuit,
+    pauli_string_reorder_pred as pauli_string_reorder_pred,
+)
+
+from cirq.contrib.paulistring.recombine import (
+    move_pauli_strings_into_circuit as move_pauli_strings_into_circuit,
 )
 
-from cirq.contrib.paulistring.recombine import move_pauli_strings_into_circuit
+from cirq.contrib.paulistring.pauli_string_optimize import (
+    pauli_string_optimized_circuit as pauli_string_optimized_circuit,
+)
 
-from cirq.contrib.paulistring.pauli_string_optimize import pauli_string_optimized_circuit
+from cirq.contrib.paulistring.clifford_optimize import (
+    clifford_optimized_circuit as clifford_optimized_circuit,
+)
 
-from cirq.contrib.paulistring.clifford_optimize import clifford_optimized_circuit
+from cirq.contrib.paulistring.optimize import optimized_circuit as optimized_circuit
 
-from cirq.contrib.paulistring.optimize import optimized_circuit
+from cirq.contrib.paulistring.pauli_string_measurement_with_readout_mitigation import (
+    measure_pauli_strings as measure_pauli_strings,
+)

cirq/contrib/paulistring/clifford_optimize.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Tuple, cast
+from typing import cast, Tuple
 
 from cirq import circuits, ops, protocols, transformers
 from cirq.contrib.paulistring.clifford_target_gateset import CliffordTargetGateset

cirq/contrib/paulistring/clifford_optimize_test.py

@@ -14,7 +14,6 @@
 
 
 import cirq
-
 from cirq.contrib.paulistring import clifford_optimized_circuit, CliffordTargetGateset
 
 

cirq/contrib/paulistring/clifford_target_gateset.py

@@ -12,19 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import List, Union, Type, cast, TYPE_CHECKING
+from __future__ import annotations
+
 from enum import Enum
+from types import NotImplementedType
+from typing import cast, List, Type, TYPE_CHECKING, Union
+
 import numpy as np
 
-from cirq import ops, transformers, protocols, linalg
-from cirq.type_workarounds import NotImplementedType
+from cirq import linalg, ops, protocols, transformers
 
 if TYPE_CHECKING:
     import cirq
 
 
 def _matrix_to_clifford_op(
-    mat: np.ndarray, qubit: 'cirq.Qid', *, atol: float
+    mat: np.ndarray, qubit: cirq.Qid, *, atol: float
 ) -> Union[ops.Operation, NotImplementedType]:
     rotations = transformers.single_qubit_matrix_to_pauli_rotations(mat, atol)
     clifford_gate = ops.SingleQubitCliffordGate.I
@@ -42,7 +45,7 @@ def _matrix_to_clifford_op(
 
 
 def _matrix_to_pauli_string_phasors(
-    mat: np.ndarray, qubit: 'cirq.Qid', *, keep_clifford: bool, atol: float
+    mat: np.ndarray, qubit: cirq.Qid, *, keep_clifford: bool, atol: float
 ) -> ops.OP_TREE:
     rotations = transformers.single_qubit_matrix_to_pauli_rotations(mat, atol)
     out_ops: List[ops.GateOperation] = []
@@ -94,7 +97,7 @@ class CliffordTargetGateset(transformers.TwoQubitCompilationTargetGateset):
         """
         self.atol = atol
         self.single_qubit_target = single_qubit_target
-        gates: List[Union['cirq.Gate', Type['cirq.Gate']]] = [ops.CZ, ops.MeasurementGate]
+        gates: List[Union[cirq.Gate, Type[cirq.Gate]]] = [ops.CZ, ops.MeasurementGate]
         if single_qubit_target in [
             self.SingleQubitTarget.SINGLE_QUBIT_CLIFFORDS,
             self.SingleQubitTarget.PAULI_STRING_PHASORS_AND_CLIFFORDS,
@@ -108,8 +111,8 @@ class CliffordTargetGateset(transformers.TwoQubitCompilationTargetGateset):
         super().__init__(*gates)
 
     def _decompose_single_qubit_operation(
-        self, op: 'cirq.Operation', _
-    ) -> Union[NotImplementedType, 'cirq.OP_TREE']:
+        self, op: cirq.Operation, _
+    ) -> Union[NotImplementedType, cirq.OP_TREE]:
         if not protocols.has_unitary(op):
             return NotImplemented
         mat = protocols.unitary(op)
@@ -125,8 +128,8 @@ class CliffordTargetGateset(transformers.TwoQubitCompilationTargetGateset):
         )
 
     def _decompose_two_qubit_operation(
-        self, op: 'cirq.Operation', _
-    ) -> Union[NotImplementedType, 'cirq.OP_TREE']:
+        self, op: cirq.Operation, _
+    ) -> Union[NotImplementedType, cirq.OP_TREE]:
         if not protocols.has_unitary(op):
             return NotImplemented
         return transformers.two_qubit_matrix_to_cz_operations(
@@ -138,10 +141,10 @@ class CliffordTargetGateset(transformers.TwoQubitCompilationTargetGateset):
         )
 
     @property
-    def postprocess_transformers(self) -> List['cirq.TRANSFORMER']:
+    def postprocess_transformers(self) -> List[cirq.TRANSFORMER]:
         """List of transformers which should be run after decomposing individual operations."""
 
-        def rewriter(o: 'cirq.CircuitOperation'):
+        def rewriter(o: cirq.CircuitOperation):
             result = self._decompose_single_qubit_operation(o, -1)
             return o.circuit.all_operations() if result is NotImplemented else result
 

cirq/contrib/paulistring/optimize.py

@@ -14,9 +14,9 @@
 
 from typing import Callable
 
-from cirq import ops, circuits, transformers
-from cirq.contrib.paulistring.pauli_string_optimize import pauli_string_optimized_circuit
+from cirq import circuits, ops, transformers
 from cirq.contrib.paulistring.clifford_optimize import clifford_optimized_circuit
+from cirq.contrib.paulistring.pauli_string_optimize import pauli_string_optimized_circuit
 
 
 class _CZTargetGateSet(transformers.CZTargetGateset):

cirq/contrib/paulistring/optimize_test.py

@@ -14,7 +14,6 @@
 
 
 import cirq
-
 from cirq.contrib.paulistring import optimized_circuit
 
 

cirq/contrib/paulistring/pauli_string_dag_test.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 import cirq
-
 from cirq.contrib.paulistring import convert_and_separate_circuit, pauli_string_dag_from_circuit