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

cirq/interop/quirk/__init__.py

@@ -20,9 +20,12 @@ References:
 
 # Imports from cells are only to ensure operation reprs work correctly.
 from cirq.interop.quirk.cells import (
-    QuirkArithmeticGate,
-    QuirkInputRotationOperation,
-    QuirkQubitPermutationGate,
+    QuirkArithmeticGate as QuirkArithmeticGate,
+    QuirkInputRotationOperation as QuirkInputRotationOperation,
+    QuirkQubitPermutationGate as QuirkQubitPermutationGate,
 )
 
-from cirq.interop.quirk.url_to_circuit import quirk_json_to_circuit, quirk_url_to_circuit
+from cirq.interop.quirk.url_to_circuit import (
+    quirk_json_to_circuit as quirk_json_to_circuit,
+    quirk_url_to_circuit as quirk_url_to_circuit,
+)

cirq/interop/quirk/cells/__init__.py

@@ -13,17 +13,28 @@
 # limitations under the License.
 """This module defines building blocks for parsing Quirk circuits."""
 
-from cirq.interop.quirk.cells.all_cells import generate_all_quirk_cell_makers
+from cirq.interop.quirk.cells.all_cells import (
+    generate_all_quirk_cell_makers as generate_all_quirk_cell_makers,
+)
 
-from cirq.interop.quirk.cells.cell import Cell, CellMaker, CellMakerArgs, ExplicitOperationsCell
+from cirq.interop.quirk.cells.cell import (
+    Cell as Cell,
+    CellMaker as CellMaker,
+    CellMakerArgs as CellMakerArgs,
+    ExplicitOperationsCell as ExplicitOperationsCell,
+)
 
-from cirq.interop.quirk.cells.composite_cell import CompositeCell
+from cirq.interop.quirk.cells.composite_cell import CompositeCell as CompositeCell
 
-from cirq.interop.quirk.cells.qubit_permutation_cells import QuirkQubitPermutationGate
+from cirq.interop.quirk.cells.qubit_permutation_cells import (
+    QuirkQubitPermutationGate as QuirkQubitPermutationGate,
+)
 
-from cirq.interop.quirk.cells.arithmetic_cells import QuirkArithmeticGate
+from cirq.interop.quirk.cells.arithmetic_cells import QuirkArithmeticGate as QuirkArithmeticGate
 
-from cirq.interop.quirk.cells.input_rotation_cells import QuirkInputRotationOperation
+from cirq.interop.quirk.cells.input_rotation_cells import (
+    QuirkInputRotationOperation as QuirkInputRotationOperation,
+)
 
 import cirq.interop.quirk.cells.swap_cell
 import cirq.interop.quirk.cells.control_cells

cirq/ion/__init__.py

@@ -14,6 +14,8 @@
 
 """Trapped ion devices, gates, and compiling utilties."""
 
-from cirq.ops import ms
+from cirq.ops import ms as ms
 
-from cirq.transformers import two_qubit_matrix_to_ion_operations
+from cirq.transformers import (
+    two_qubit_matrix_to_ion_operations as two_qubit_matrix_to_ion_operations,
+)

cirq/linalg/__init__.py

@@ -17,70 +17,80 @@ Focuses on methods useful for analyzing and optimizing quantum circuits.
 Avoids duplicating functionality present in numpy.
 """
 
-from cirq.linalg.combinators import block_diag, CONTROL_TAG, dot, kron, kron_with_controls
+from cirq.linalg.combinators import (
+    block_diag as block_diag,
+    CONTROL_TAG as CONTROL_TAG,
+    dot as dot,
+    kron as kron,
+    kron_with_controls as kron_with_controls,
+)
 
 from cirq.linalg.decompositions import (
-    axis_angle,
-    AxisAngleDecomposition,
-    deconstruct_single_qubit_matrix_into_angles,
-    extract_right_diag,
-    kak_canonicalize_vector,
-    kak_decomposition,
-    kak_vector,
-    KakDecomposition,
-    kron_factor_4x4_to_2x2s,
-    map_eigenvalues,
-    num_cnots_required,
-    unitary_eig,
-    scatter_plot_normalized_kak_interaction_coefficients,
-    so4_to_magic_su2s,
+    # pylint: disable=line-too-long
+    axis_angle as axis_angle,
+    AxisAngleDecomposition as AxisAngleDecomposition,
+    deconstruct_single_qubit_matrix_into_angles as deconstruct_single_qubit_matrix_into_angles,
+    extract_right_diag as extract_right_diag,
+    kak_canonicalize_vector as kak_canonicalize_vector,
+    kak_decomposition as kak_decomposition,
+    kak_vector as kak_vector,
+    KakDecomposition as KakDecomposition,
+    kron_factor_4x4_to_2x2s as kron_factor_4x4_to_2x2s,
+    map_eigenvalues as map_eigenvalues,
+    num_cnots_required as num_cnots_required,
+    unitary_eig as unitary_eig,
+    scatter_plot_normalized_kak_interaction_coefficients as scatter_plot_normalized_kak_interaction_coefficients,
+    so4_to_magic_su2s as so4_to_magic_su2s,
 )
 
-
 from cirq.linalg.diagonalize import (
-    bidiagonalize_real_matrix_pair_with_symmetric_products,
-    bidiagonalize_unitary_with_special_orthogonals,
-    diagonalize_real_symmetric_and_sorted_diagonal_matrices,
-    diagonalize_real_symmetric_matrix,
+    # pylint: disable=line-too-long
+    bidiagonalize_real_matrix_pair_with_symmetric_products as bidiagonalize_real_matrix_pair_with_symmetric_products,
+    bidiagonalize_unitary_with_special_orthogonals as bidiagonalize_unitary_with_special_orthogonals,
+    diagonalize_real_symmetric_and_sorted_diagonal_matrices as diagonalize_real_symmetric_and_sorted_diagonal_matrices,
+    diagonalize_real_symmetric_matrix as diagonalize_real_symmetric_matrix,
 )
 
 from cirq.linalg.operator_spaces import (
-    expand_matrix_in_orthogonal_basis,
-    hilbert_schmidt_inner_product,
-    kron_bases,
-    matrix_from_basis_coefficients,
-    PAULI_BASIS,
-    pow_pauli_combination,
+    expand_matrix_in_orthogonal_basis as expand_matrix_in_orthogonal_basis,
+    hilbert_schmidt_inner_product as hilbert_schmidt_inner_product,
+    kron_bases as kron_bases,
+    matrix_from_basis_coefficients as matrix_from_basis_coefficients,
+    PAULI_BASIS as PAULI_BASIS,
+    pow_pauli_combination as pow_pauli_combination,
 )
 
 from cirq.linalg.predicates import (
-    allclose_up_to_global_phase,
-    is_cptp,
-    is_diagonal,
-    is_hermitian,
-    is_normal,
-    is_orthogonal,
-    is_special_orthogonal,
-    is_special_unitary,
-    is_unitary,
-    matrix_commutes,
-    slice_for_qubits_equal_to,
+    allclose_up_to_global_phase as allclose_up_to_global_phase,
+    is_cptp as is_cptp,
+    is_diagonal as is_diagonal,
+    is_hermitian as is_hermitian,
+    is_normal as is_normal,
+    is_orthogonal as is_orthogonal,
+    is_special_orthogonal as is_special_orthogonal,
+    is_special_unitary as is_special_unitary,
+    is_unitary as is_unitary,
+    matrix_commutes as matrix_commutes,
+    slice_for_qubits_equal_to as slice_for_qubits_equal_to,
 )
 
-from cirq.linalg.tolerance import all_near_zero, all_near_zero_mod
+from cirq.linalg.tolerance import (
+    all_near_zero as all_near_zero,
+    all_near_zero_mod as all_near_zero_mod,
+)
 
 from cirq.linalg.transformations import (
-    apply_matrix_to_slices,
-    density_matrix_kronecker_product,
-    match_global_phase,
-    partial_trace,
-    partial_trace_of_state_vector_as_mixture,
-    reflection_matrix_pow,
-    state_vector_kronecker_product,
-    sub_state_vector,
-    targeted_conjugate_about,
-    targeted_left_multiply,
-    to_special,
-    transpose_flattened_array,
-    can_numpy_support_shape,
+    apply_matrix_to_slices as apply_matrix_to_slices,
+    density_matrix_kronecker_product as density_matrix_kronecker_product,
+    match_global_phase as match_global_phase,
+    partial_trace as partial_trace,
+    partial_trace_of_state_vector_as_mixture as partial_trace_of_state_vector_as_mixture,
+    reflection_matrix_pow as reflection_matrix_pow,
+    state_vector_kronecker_product as state_vector_kronecker_product,
+    sub_state_vector as sub_state_vector,
+    targeted_conjugate_about as targeted_conjugate_about,
+    targeted_left_multiply as targeted_left_multiply,
+    to_special as to_special,
+    transpose_flattened_array as transpose_flattened_array,
+    can_numpy_support_shape as can_numpy_support_shape,
 )

cirq/neutral_atoms/__init__.py

@@ -15,6 +15,6 @@
 """Neutral atom devices and gates."""
 
 from cirq.neutral_atoms.convert_to_neutral_atom_gates import (
-    is_native_neutral_atom_gate,
-    is_native_neutral_atom_op,
+    is_native_neutral_atom_gate as is_native_neutral_atom_gate,
+    is_native_neutral_atom_op as is_native_neutral_atom_op,
 )

cirq/ops/__init__.py

@@ -14,208 +14,249 @@
 """Gates (unitary and non-unitary), operations, base types, and gate sets.
 """
 
-from cirq.ops.arithmetic_operation import ArithmeticGate
+from cirq.ops.arithmetic_operation import ArithmeticGate as ArithmeticGate
 
-from cirq.ops.clifford_gate import CliffordGate, SingleQubitCliffordGate
+from cirq.ops.clifford_gate import (
+    CliffordGate as CliffordGate,
+    SingleQubitCliffordGate as SingleQubitCliffordGate,
+)
 
 from cirq.ops.dense_pauli_string import (
-    BaseDensePauliString,
-    DensePauliString,
-    MutableDensePauliString,
+    BaseDensePauliString as BaseDensePauliString,
+    DensePauliString as DensePauliString,
+    MutableDensePauliString as MutableDensePauliString,
 )
 
-from cirq.ops.boolean_hamiltonian import BooleanHamiltonianGate
+from cirq.ops.boolean_hamiltonian import BooleanHamiltonianGate as BooleanHamiltonianGate
 
 from cirq.ops.common_channels import (
-    amplitude_damp,
-    AmplitudeDampingChannel,
-    asymmetric_depolarize,
-    AsymmetricDepolarizingChannel,
-    bit_flip,
-    BitFlipChannel,
-    depolarize,
-    DepolarizingChannel,
-    generalized_amplitude_damp,
-    GeneralizedAmplitudeDampingChannel,
-    phase_damp,
-    phase_flip,
-    PhaseDampingChannel,
-    PhaseFlipChannel,
-    R,
-    reset,
-    reset_each,
-    ResetChannel,
+    amplitude_damp as amplitude_damp,
+    AmplitudeDampingChannel as AmplitudeDampingChannel,
+    asymmetric_depolarize as asymmetric_depolarize,
+    AsymmetricDepolarizingChannel as AsymmetricDepolarizingChannel,
+    bit_flip as bit_flip,
+    BitFlipChannel as BitFlipChannel,
+    depolarize as depolarize,
+    DepolarizingChannel as DepolarizingChannel,
+    generalized_amplitude_damp as generalized_amplitude_damp,
+    GeneralizedAmplitudeDampingChannel as GeneralizedAmplitudeDampingChannel,
+    phase_damp as phase_damp,
+    phase_flip as phase_flip,
+    PhaseDampingChannel as PhaseDampingChannel,
+    PhaseFlipChannel as PhaseFlipChannel,
+    R as R,
+    reset as reset,
+    reset_each as reset_each,
+    ResetChannel as ResetChannel,
 )
 
 from cirq.ops.common_gates import (
-    CNOT,
-    CNotPowGate,
-    cphase,
-    CX,
-    CXPowGate,
-    CZ,
-    CZPowGate,
-    H,
-    HPowGate,
-    Rx,
-    Ry,
-    Rz,
-    rx,
-    ry,
-    rz,
-    S,
-    T,
-    XPowGate,
-    YPowGate,
-    ZPowGate,
+    CNOT as CNOT,
+    CNotPowGate as CNotPowGate,
+    cphase as cphase,
+    CX as CX,
+    CXPowGate as CXPowGate,
+    CZ as CZ,
+    CZPowGate as CZPowGate,
+    H as H,
+    HPowGate as HPowGate,
+    Rx as Rx,
+    Ry as Ry,
+    Rz as Rz,
+    rx as rx,
+    ry as ry,
+    rz as rz,
+    S as S,
+    T as T,
+    XPowGate as XPowGate,
+    YPowGate as YPowGate,
+    ZPowGate as ZPowGate,
 )
 
 from cirq.ops.common_gate_families import (
-    AnyUnitaryGateFamily,
-    AnyIntegerPowerGateFamily,
-    ParallelGateFamily,
+    AnyUnitaryGateFamily as AnyUnitaryGateFamily,
+    AnyIntegerPowerGateFamily as AnyIntegerPowerGateFamily,
+    ParallelGateFamily as ParallelGateFamily,
 )
 
-from cirq.ops.classically_controlled_operation import ClassicallyControlledOperation
+from cirq.ops.classically_controlled_operation import (
+    ClassicallyControlledOperation as ClassicallyControlledOperation,
+)
 
-from cirq.ops.controlled_gate import ControlledGate
+from cirq.ops.controlled_gate import ControlledGate as ControlledGate
 
-from cirq.ops.diagonal_gate import DiagonalGate
+from cirq.ops.diagonal_gate import DiagonalGate as DiagonalGate
 
-from cirq.ops.eigen_gate import EigenGate
+from cirq.ops.eigen_gate import EigenGate as EigenGate
 
-from cirq.ops.fourier_transform import PhaseGradientGate, qft, QuantumFourierTransformGate
+from cirq.ops.fourier_transform import (
+    PhaseGradientGate as PhaseGradientGate,
+    qft as qft,
+    QuantumFourierTransformGate as QuantumFourierTransformGate,
+)
 
-from cirq.ops.fsim_gate import FSimGate, PhasedFSimGate
+from cirq.ops.fsim_gate import FSimGate as FSimGate, PhasedFSimGate as PhasedFSimGate
 
-from cirq.ops.gate_features import InterchangeableQubitsGate
+from cirq.ops.gate_features import InterchangeableQubitsGate as InterchangeableQubitsGate
 
-from cirq.ops.gate_operation import GateOperation
+from cirq.ops.gate_operation import GateOperation as GateOperation
 
-from cirq.ops.gateset import GateFamily, Gateset
+from cirq.ops.gateset import GateFamily as GateFamily, Gateset as Gateset
 
-from cirq.ops.identity import I, identity_each, IdentityGate
+from cirq.ops.identity import I as I, identity_each as identity_each, IdentityGate as IdentityGate
 
-from cirq.ops.global_phase_op import GlobalPhaseGate, global_phase_operation
+from cirq.ops.global_phase_op import (
+    GlobalPhaseGate as GlobalPhaseGate,
+    global_phase_operation as global_phase_operation,
+)
 
-from cirq.ops.kraus_channel import KrausChannel
+from cirq.ops.kraus_channel import KrausChannel as KrausChannel
 
 from cirq.ops.linear_combinations import (
-    LinearCombinationOfGates,
-    LinearCombinationOfOperations,
-    PauliSum,
-    PauliSumLike,
-    ProjectorSum,
+    LinearCombinationOfGates as LinearCombinationOfGates,
+    LinearCombinationOfOperations as LinearCombinationOfOperations,
+    PauliSum as PauliSum,
+    PauliSumLike as PauliSumLike,
+    ProjectorSum as ProjectorSum,
 )
 
-from cirq.ops.mixed_unitary_channel import MixedUnitaryChannel
+from cirq.ops.mixed_unitary_channel import MixedUnitaryChannel as MixedUnitaryChannel
 
-from cirq.ops.pauli_sum_exponential import PauliSumExponential
+from cirq.ops.pauli_sum_exponential import PauliSumExponential as PauliSumExponential
 
-from cirq.ops.pauli_measurement_gate import PauliMeasurementGate
+from cirq.ops.pauli_measurement_gate import PauliMeasurementGate as PauliMeasurementGate
 
-from cirq.ops.parallel_gate import ParallelGate, parallel_gate_op
+from cirq.ops.parallel_gate import (
+    ParallelGate as ParallelGate,
+    parallel_gate_op as parallel_gate_op,
+)
 
-from cirq.ops.projector import ProjectorString
+from cirq.ops.projector import ProjectorString as ProjectorString
 
-from cirq.ops.controlled_operation import ControlledOperation
+from cirq.ops.controlled_operation import ControlledOperation as ControlledOperation
 
-from cirq.ops.qubit_manager import BorrowableQubit, CleanQubit, QubitManager, SimpleQubitManager
+from cirq.ops.qubit_manager import (
+    BorrowableQubit as BorrowableQubit,
+    CleanQubit as CleanQubit,
+    QubitManager as QubitManager,
+    SimpleQubitManager as SimpleQubitManager,
+)
 
-from cirq.ops.greedy_qubit_manager import GreedyQubitManager
+from cirq.ops.greedy_qubit_manager import GreedyQubitManager as GreedyQubitManager
 
-from cirq.ops.qubit_order import QubitOrder
+from cirq.ops.qubit_order import QubitOrder as QubitOrder
 
-from cirq.ops.qubit_order_or_list import QubitOrderOrList
+from cirq.ops.qubit_order_or_list import QubitOrderOrList as QubitOrderOrList
 
-from cirq.ops.matrix_gates import MatrixGate
+from cirq.ops.matrix_gates import MatrixGate as MatrixGate
 
 from cirq.ops.measure_util import (
-    M,
-    measure,
-    measure_each,
-    measure_paulistring_terms,
-    measure_single_paulistring,
+    M as M,
+    measure as measure,
+    measure_each as measure_each,
+    measure_paulistring_terms as measure_paulistring_terms,
+    measure_single_paulistring as measure_single_paulistring,
 )
 
-from cirq.ops.measurement_gate import MeasurementGate
+from cirq.ops.measurement_gate import MeasurementGate as MeasurementGate
 
-from cirq.ops.named_qubit import NamedQubit, NamedQid
+from cirq.ops.named_qubit import NamedQubit as NamedQubit, NamedQid as NamedQid
 
 from cirq.ops.op_tree import (
-    flatten_op_tree,
-    freeze_op_tree,
-    flatten_to_ops,
-    flatten_to_ops_or_moments,
-    OP_TREE,
-    transform_op_tree,
+    flatten_op_tree as flatten_op_tree,
+    freeze_op_tree as freeze_op_tree,
+    flatten_to_ops as flatten_to_ops,
+    flatten_to_ops_or_moments as flatten_to_ops_or_moments,
+    OP_TREE as OP_TREE,
+    transform_op_tree as transform_op_tree,
 )
 
-from cirq.ops.parity_gates import XX, XXPowGate, YY, YYPowGate, ZZ, ZZPowGate, MSGate, ms
+from cirq.ops.parity_gates import (
+    XX as XX,
+    XXPowGate as XXPowGate,
+    YY as YY,
+    YYPowGate as YYPowGate,
+    ZZ as ZZ,
+    ZZPowGate as ZZPowGate,
+    MSGate as MSGate,
+    ms as ms,
+)
 
-from cirq.ops.pauli_gates import Pauli, X, Y, Z
+from cirq.ops.pauli_gates import Pauli as Pauli, X as X, Y as Y, Z as Z
 
-from cirq.ops.pauli_interaction_gate import PauliInteractionGate
+from cirq.ops.pauli_interaction_gate import PauliInteractionGate as PauliInteractionGate
 
 from cirq.ops.pauli_string import (
-    MutablePauliString,
-    PAULI_GATE_LIKE,
-    PAULI_STRING_LIKE,
-    PauliString,
-    SingleQubitPauliStringGateOperation,
+    MutablePauliString as MutablePauliString,
+    PAULI_GATE_LIKE as PAULI_GATE_LIKE,
+    PAULI_STRING_LIKE as PAULI_STRING_LIKE,
+    PauliString as PauliString,
+    SingleQubitPauliStringGateOperation as SingleQubitPauliStringGateOperation,
 )
 
-from cirq.ops.pauli_string_phasor import PauliStringPhasor, PauliStringPhasorGate
+from cirq.ops.pauli_string_phasor import (
+    PauliStringPhasor as PauliStringPhasor,
+    PauliStringPhasorGate as PauliStringPhasorGate,
+)
 
-from cirq.ops.pauli_string_raw_types import PauliStringGateOperation
+from cirq.ops.pauli_string_raw_types import PauliStringGateOperation as PauliStringGateOperation
 
-from cirq.ops.permutation_gate import QubitPermutationGate
+from cirq.ops.permutation_gate import QubitPermutationGate as QubitPermutationGate
 
-from cirq.ops.phased_iswap_gate import givens, PhasedISwapPowGate
+from cirq.ops.phased_iswap_gate import givens as givens, PhasedISwapPowGate as PhasedISwapPowGate
 
-from cirq.ops.phased_x_gate import PhasedXPowGate
+from cirq.ops.phased_x_gate import PhasedXPowGate as PhasedXPowGate
 
-from cirq.ops.phased_x_z_gate import PhasedXZGate
+from cirq.ops.phased_x_z_gate import PhasedXZGate as PhasedXZGate
 
-from cirq.ops.qid_util import q
+from cirq.ops.qid_util import q as q
 
-from cirq.ops.random_gate_channel import RandomGateChannel
+from cirq.ops.random_gate_channel import RandomGateChannel as RandomGateChannel
 
-from cirq.ops.raw_types import Gate, Operation, Qid, TaggedOperation
+from cirq.ops.raw_types import (
+    Gate as Gate,
+    Operation as Operation,
+    Qid as Qid,
+    TaggedOperation as TaggedOperation,
+)
 
 from cirq.ops.swap_gates import (
-    ISWAP,
-    ISwapPowGate,
-    ISWAP_INV,
-    riswap,
-    SQRT_ISWAP,
-    SQRT_ISWAP_INV,
-    SWAP,
-    SwapPowGate,
+    ISWAP as ISWAP,
+    ISwapPowGate as ISwapPowGate,
+    ISWAP_INV as ISWAP_INV,
+    riswap as riswap,
+    SQRT_ISWAP as SQRT_ISWAP,
+    SQRT_ISWAP_INV as SQRT_ISWAP_INV,
+    SWAP as SWAP,
+    SwapPowGate as SwapPowGate,
 )
 
-from cirq.ops.tags import RoutingSwapTag, VirtualTag
+from cirq.ops.tags import RoutingSwapTag as RoutingSwapTag, VirtualTag as VirtualTag
 
 from cirq.ops.three_qubit_gates import (
-    CCNOT,
-    CCNotPowGate,
-    CCX,
-    CCXPowGate,
-    CCZ,
-    CCZPowGate,
-    CSWAP,
-    CSwapGate,
-    FREDKIN,
-    ThreeQubitDiagonalGate,
-    TOFFOLI,
+    CCNOT as CCNOT,
+    CCNotPowGate as CCNotPowGate,
+    CCX as CCX,
+    CCXPowGate as CCXPowGate,
+    CCZ as CCZ,
+    CCZPowGate as CCZPowGate,
+    CSWAP as CSWAP,
+    CSwapGate as CSwapGate,
+    FREDKIN as FREDKIN,
+    ThreeQubitDiagonalGate as ThreeQubitDiagonalGate,
+    TOFFOLI as TOFFOLI,
 )
 
-from cirq.ops.two_qubit_diagonal_gate import TwoQubitDiagonalGate
+from cirq.ops.two_qubit_diagonal_gate import TwoQubitDiagonalGate as TwoQubitDiagonalGate
 
-from cirq.ops.wait_gate import wait, WaitGate
+from cirq.ops.wait_gate import wait as wait, WaitGate as WaitGate
 
-from cirq.ops.state_preparation_channel import StatePreparationChannel
+from cirq.ops.state_preparation_channel import StatePreparationChannel as StatePreparationChannel
 
-from cirq.ops.control_values import AbstractControlValues, ProductOfSums, SumOfProducts
+from cirq.ops.control_values import (
+    AbstractControlValues as AbstractControlValues,
+    ProductOfSums as ProductOfSums,
+    SumOfProducts as SumOfProducts,
+)
 
-from cirq.ops.uniform_superposition_gate import UniformSuperpositionGate
+from cirq.ops.uniform_superposition_gate import UniformSuperpositionGate as UniformSuperpositionGate

cirq/ops/boolean_hamiltonian.py

@@ -31,7 +31,8 @@ import sympy.parsing.sympy_parser as sympy_parser
 import cirq
 from cirq import value
 from cirq.ops import raw_types
-from cirq.ops.linear_combinations import PauliSum, PauliString
+from cirq.ops.linear_combinations import PauliSum
+from cirq.ops.pauli_string import PauliString
 
 
 @value.value_equality