cirq-core 1.5.0.dev20240907040843__py3-none-any.whl → 1.5.0.dev20240911234931__py3-none-any.whl

cirq/protocols/__init__.py

@@ -14,114 +14,166 @@
 
 """Protocols (structural subtyping) supported in Cirq."""
 
-from cirq.protocols.act_on_protocol import act_on, SupportsActOn, SupportsActOnQubits
+from cirq.protocols.act_on_protocol import (
+    act_on as act_on,
+    SupportsActOn as SupportsActOn,
+    SupportsActOnQubits as SupportsActOnQubits,
+)
+
 from cirq.protocols.apply_unitary_protocol import (
-    apply_unitaries,
-    apply_unitary,
-    ApplyUnitaryArgs,
-    SupportsConsistentApplyUnitary,
+    apply_unitaries as apply_unitaries,
+    apply_unitary as apply_unitary,
+    ApplyUnitaryArgs as ApplyUnitaryArgs,
+    SupportsConsistentApplyUnitary as SupportsConsistentApplyUnitary,
 )
+
 from cirq.protocols.apply_channel_protocol import (
-    apply_channel,
-    ApplyChannelArgs,
-    SupportsApplyChannel,
+    apply_channel as apply_channel,
+    ApplyChannelArgs as ApplyChannelArgs,
+    SupportsApplyChannel as SupportsApplyChannel,
 )
+
 from cirq.protocols.apply_mixture_protocol import (
-    apply_mixture,
-    ApplyMixtureArgs,
-    SupportsApplyMixture,
+    apply_mixture as apply_mixture,
+    ApplyMixtureArgs as ApplyMixtureArgs,
+    SupportsApplyMixture as SupportsApplyMixture,
 )
-from cirq.protocols.approximate_equality_protocol import approx_eq, SupportsApproximateEquality
-from cirq.protocols.kraus_protocol import kraus, has_kraus, SupportsKraus
-from cirq.protocols.commutes_protocol import commutes, definitely_commutes, SupportsCommutes
+
+from cirq.protocols.approximate_equality_protocol import (
+    approx_eq as approx_eq,
+    SupportsApproximateEquality as SupportsApproximateEquality,
+)
+
+from cirq.protocols.kraus_protocol import (
+    kraus as kraus,
+    has_kraus as has_kraus,
+    SupportsKraus as SupportsKraus,
+)
+
+from cirq.protocols.commutes_protocol import (
+    commutes as commutes,
+    definitely_commutes as definitely_commutes,
+    SupportsCommutes as SupportsCommutes,
+)
+
 from cirq.protocols.control_key_protocol import (
-    control_keys,
-    measurement_keys_touched,
-    SupportsControlKey,
+    control_keys as control_keys,
+    measurement_keys_touched as measurement_keys_touched,
+    SupportsControlKey as SupportsControlKey,
 )
+
 from cirq.protocols.circuit_diagram_info_protocol import (
-    circuit_diagram_info,
-    CircuitDiagramInfo,
-    CircuitDiagramInfoArgs,
-    LabelEntity,
-    SupportsCircuitDiagramInfo,
+    circuit_diagram_info as circuit_diagram_info,
+    CircuitDiagramInfo as CircuitDiagramInfo,
+    CircuitDiagramInfoArgs as CircuitDiagramInfoArgs,
+    LabelEntity as LabelEntity,
+    SupportsCircuitDiagramInfo as SupportsCircuitDiagramInfo,
 )
+
 from cirq.protocols.decompose_protocol import (
-    decompose,
-    decompose_once,
-    decompose_once_with_qubits,
-    DecompositionContext,
-    SupportsDecompose,
-    SupportsDecomposeWithQubits,
+    decompose as decompose,
+    decompose_once as decompose_once,
+    decompose_once_with_qubits as decompose_once_with_qubits,
+    DecompositionContext as DecompositionContext,
+    SupportsDecompose as SupportsDecompose,
+    SupportsDecomposeWithQubits as SupportsDecomposeWithQubits,
 )
+
 from cirq.protocols.equal_up_to_global_phase_protocol import (
-    equal_up_to_global_phase,
-    SupportsEqualUpToGlobalPhase,
+    equal_up_to_global_phase as equal_up_to_global_phase,
+    SupportsEqualUpToGlobalPhase as SupportsEqualUpToGlobalPhase,
+)
+
+from cirq.protocols.has_stabilizer_effect_protocol import (
+    has_stabilizer_effect as has_stabilizer_effect,
+)
+
+from cirq.protocols.has_unitary_protocol import (
+    has_unitary as has_unitary,
+    SupportsExplicitHasUnitary as SupportsExplicitHasUnitary,
 )
-from cirq.protocols.has_stabilizer_effect_protocol import has_stabilizer_effect
-from cirq.protocols.has_unitary_protocol import has_unitary, SupportsExplicitHasUnitary
-from cirq.protocols.inverse_protocol import inverse
+
+from cirq.protocols.inverse_protocol import inverse as inverse
+
 from cirq.protocols.json_serialization import (
-    cirq_type_from_json,
-    DEFAULT_RESOLVERS,
-    HasJSONNamespace,
-    JsonResolver,
-    json_cirq_type,
-    json_namespace,
-    to_json_gzip,
-    read_json_gzip,
-    to_json,
-    read_json,
-    obj_to_dict_helper,
-    dataclass_json_dict,
-    SerializableByKey,
-    SupportsJSON,
+    cirq_type_from_json as cirq_type_from_json,
+    DEFAULT_RESOLVERS as DEFAULT_RESOLVERS,
+    HasJSONNamespace as HasJSONNamespace,
+    JsonResolver as JsonResolver,
+    json_cirq_type as json_cirq_type,
+    json_namespace as json_namespace,
+    to_json_gzip as to_json_gzip,
+    read_json_gzip as read_json_gzip,
+    to_json as to_json,
+    read_json as read_json,
+    obj_to_dict_helper as obj_to_dict_helper,
+    dataclass_json_dict as dataclass_json_dict,
+    SerializableByKey as SerializableByKey,
+    SupportsJSON as SupportsJSON,
 )
+
 from cirq.protocols.measurement_key_protocol import (
-    is_measurement,
-    measurement_key_name,
-    measurement_key_obj,
-    measurement_key_names,
-    measurement_key_objs,
-    with_key_path,
-    with_key_path_prefix,
-    with_measurement_key_mapping,
-    with_rescoped_keys,
-    SupportsMeasurementKey,
-)
-from cirq.protocols.mixture_protocol import has_mixture, mixture, SupportsMixture, validate_mixture
-from cirq.protocols.mul_protocol import mul
-from cirq.protocols.pauli_expansion_protocol import pauli_expansion, SupportsPauliExpansion
+    is_measurement as is_measurement,
+    measurement_key_name as measurement_key_name,
+    measurement_key_obj as measurement_key_obj,
+    measurement_key_names as measurement_key_names,
+    measurement_key_objs as measurement_key_objs,
+    with_key_path as with_key_path,
+    with_key_path_prefix as with_key_path_prefix,
+    with_measurement_key_mapping as with_measurement_key_mapping,
+    with_rescoped_keys as with_rescoped_keys,
+    SupportsMeasurementKey as SupportsMeasurementKey,
+)
+
+from cirq.protocols.mixture_protocol import (
+    has_mixture as has_mixture,
+    mixture as mixture,
+    SupportsMixture as SupportsMixture,
+    validate_mixture as validate_mixture,
+)
+
+from cirq.protocols.mul_protocol import mul as mul
+
+from cirq.protocols.pauli_expansion_protocol import (
+    pauli_expansion as pauli_expansion,
+    SupportsPauliExpansion as SupportsPauliExpansion,
+)
 
 # pylint: disable=redefined-builtin
-from cirq.protocols.pow_protocol import pow
+from cirq.protocols.pow_protocol import pow as pow
 
 # pylint: enable=redefined-builtin
+
 from cirq.protocols.qasm import (
-    qasm,
-    QasmArgs,
-    SupportsQasm,
-    SupportsQasmWithArgs,
-    SupportsQasmWithArgsAndQubits,
+    qasm as qasm,
+    QasmArgs as QasmArgs,
+    SupportsQasm as SupportsQasm,
+    SupportsQasmWithArgs as SupportsQasmWithArgs,
+    SupportsQasmWithArgsAndQubits as SupportsQasmWithArgsAndQubits,
 )
+
 from cirq.protocols.trace_distance_bound import (
-    SupportsTraceDistanceBound,
-    trace_distance_bound,
-    trace_distance_from_angle_list,
+    SupportsTraceDistanceBound as SupportsTraceDistanceBound,
+    trace_distance_bound as trace_distance_bound,
+    trace_distance_from_angle_list as trace_distance_from_angle_list,
 )
+
 from cirq.protocols.resolve_parameters import (
-    is_parameterized,
-    parameter_names,
-    parameter_symbols,
-    resolve_parameters,
-    resolve_parameters_once,
-    SupportsParameterization,
-)
-from cirq.protocols.phase_protocol import phase_by, SupportsPhase
+    is_parameterized as is_parameterized,
+    parameter_names as parameter_names,
+    parameter_symbols as parameter_symbols,
+    resolve_parameters as resolve_parameters,
+    resolve_parameters_once as resolve_parameters_once,
+    SupportsParameterization as SupportsParameterization,
+)
+
+from cirq.protocols.phase_protocol import phase_by as phase_by, SupportsPhase as SupportsPhase
+
 from cirq.protocols.qid_shape_protocol import (
-    num_qubits,
-    qid_shape,
-    SupportsExplicitQidShape,
-    SupportsExplicitNumQubits,
+    num_qubits as num_qubits,
+    qid_shape as qid_shape,
+    SupportsExplicitQidShape as SupportsExplicitQidShape,
+    SupportsExplicitNumQubits as SupportsExplicitNumQubits,
 )
-from cirq.protocols.unitary_protocol import SupportsUnitary, unitary
+
+from cirq.protocols.unitary_protocol import SupportsUnitary as SupportsUnitary, unitary as unitary

cirq/protocols/json_test_data/__init__.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from cirq.protocols.json_test_data.spec import TestSpec
+from cirq.protocols.json_test_data.spec import TestSpec as TestSpec

cirq/qis/__init__.py

@@ -15,49 +15,61 @@
 """Tools and methods for primitives used in quantum information science."""
 
 from cirq.qis.channels import (
-    choi_to_kraus,
-    choi_to_superoperator,
-    kraus_to_choi,
-    kraus_to_superoperator,
-    operation_to_choi,
-    operation_to_superoperator,
-    superoperator_to_choi,
-    superoperator_to_kraus,
+    choi_to_kraus as choi_to_kraus,
+    choi_to_superoperator as choi_to_superoperator,
+    kraus_to_choi as kraus_to_choi,
+    kraus_to_superoperator as kraus_to_superoperator,
+    operation_to_choi as operation_to_choi,
+    operation_to_superoperator as operation_to_superoperator,
+    superoperator_to_choi as superoperator_to_choi,
+    superoperator_to_kraus as superoperator_to_kraus,
 )
 
-from cirq.qis.clifford_tableau import CliffordTableau, StabilizerState
+from cirq.qis.clifford_tableau import (
+    CliffordTableau as CliffordTableau,
+    StabilizerState as StabilizerState,
+)
 
-from cirq.qis.measures import entanglement_fidelity, fidelity, von_neumann_entropy
+from cirq.qis.measures import (
+    entanglement_fidelity as entanglement_fidelity,
+    fidelity as fidelity,
+    von_neumann_entropy as von_neumann_entropy,
+)
 
-from cirq.qis.quantum_state_representation import QuantumStateRepresentation
+from cirq.qis.quantum_state_representation import (
+    QuantumStateRepresentation as QuantumStateRepresentation,
+)
 
 from cirq.qis.states import (
-    bloch_vector_from_state_vector,
-    density_matrix,
-    density_matrix_from_state_vector,
-    dirac_notation,
-    eye_tensor,
-    infer_qid_shape,
-    one_hot,
-    QUANTUM_STATE_LIKE,
-    QuantumState,
-    quantum_state,
-    STATE_VECTOR_LIKE,
-    to_valid_density_matrix,
-    to_valid_state_vector,
-    validate_density_matrix,
-    validate_indices,
-    validate_qid_shape,
-    validate_normalized_state_vector,
+    bloch_vector_from_state_vector as bloch_vector_from_state_vector,
+    density_matrix as density_matrix,
+    density_matrix_from_state_vector as density_matrix_from_state_vector,
+    dirac_notation as dirac_notation,
+    eye_tensor as eye_tensor,
+    infer_qid_shape as infer_qid_shape,
+    one_hot as one_hot,
+    QUANTUM_STATE_LIKE as QUANTUM_STATE_LIKE,
+    QuantumState as QuantumState,
+    quantum_state as quantum_state,
+    STATE_VECTOR_LIKE as STATE_VECTOR_LIKE,
+    to_valid_density_matrix as to_valid_density_matrix,
+    to_valid_state_vector as to_valid_state_vector,
+    validate_density_matrix as validate_density_matrix,
+    validate_indices as validate_indices,
+    validate_qid_shape as validate_qid_shape,
+    validate_normalized_state_vector as validate_normalized_state_vector,
 )
 
 from cirq.qis.noise_utils import (
-    decay_constant_to_xeb_fidelity,
-    decay_constant_to_pauli_error,
-    pauli_error_to_decay_constant,
-    xeb_fidelity_to_decay_constant,
-    pauli_error_from_t1,
-    average_error,
-    decoherence_pauli_error,
+    decay_constant_to_xeb_fidelity as decay_constant_to_xeb_fidelity,
+    decay_constant_to_pauli_error as decay_constant_to_pauli_error,
+    pauli_error_to_decay_constant as pauli_error_to_decay_constant,
+    xeb_fidelity_to_decay_constant as xeb_fidelity_to_decay_constant,
+    pauli_error_from_t1 as pauli_error_from_t1,
+    average_error as average_error,
+    decoherence_pauli_error as decoherence_pauli_error,
+)
+
+from cirq.qis.entropy import (
+    process_renyi_entropy_from_bitstrings as process_renyi_entropy_from_bitstrings,
 )
-from cirq.qis.entropy import process_renyi_entropy_from_bitstrings

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/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/study/__init__.py

@@ -15,33 +15,38 @@
 """Parameterized circuits and results."""
 
 from cirq.study.flatten_expressions import (
-    ExpressionMap,
-    flatten,
-    flatten_with_params,
-    flatten_with_sweep,
+    ExpressionMap as ExpressionMap,
+    flatten as flatten,
+    flatten_with_params as flatten_with_params,
+    flatten_with_sweep as flatten_with_sweep,
 )
 
 from cirq.study.resolver import (
-    ParamDictType,
-    ParamMappingType,
-    ParamResolver,
-    ParamResolverOrSimilarType,
+    ParamDictType as ParamDictType,
+    ParamMappingType as ParamMappingType,
+    ParamResolver as ParamResolver,
+    ParamResolverOrSimilarType as ParamResolverOrSimilarType,
 )
 
-from cirq.study.sweepable import Sweepable, to_resolvers, to_sweep, to_sweeps
+from cirq.study.sweepable import (
+    Sweepable as Sweepable,
+    to_resolvers as to_resolvers,
+    to_sweep as to_sweep,
+    to_sweeps as to_sweeps,
+)
 
 from cirq.study.sweeps import (
-    Linspace,
-    ListSweep,
-    Points,
-    Product,
-    Sweep,
-    UNIT_SWEEP,
-    UnitSweep,
-    Zip,
-    ZipLongest,
-    dict_to_product_sweep,
-    dict_to_zip_sweep,
+    Linspace as Linspace,
+    ListSweep as ListSweep,
+    Points as Points,
+    Product as Product,
+    Sweep as Sweep,
+    UNIT_SWEEP as UNIT_SWEEP,
+    UnitSweep as UnitSweep,
+    Zip as Zip,
+    ZipLongest as ZipLongest,
+    dict_to_product_sweep as dict_to_product_sweep,
+    dict_to_zip_sweep as dict_to_zip_sweep,
 )
 
-from cirq.study.result import ResultDict, Result
+from cirq.study.result import ResultDict as ResultDict, Result as Result