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

cirq/transformers/__init__.py

@@ -15,122 +15,141 @@
 """Classes and methods for transforming circuits."""
 
 from cirq.transformers.analytical_decompositions import (
-    compute_cphase_exponents_for_fsim_decomposition,
-    decompose_cphase_into_two_fsim,
-    decompose_clifford_tableau_to_operations,
-    decompose_multi_controlled_x,
-    decompose_multi_controlled_rotation,
-    decompose_two_qubit_interaction_into_four_fsim_gates,
-    is_negligible_turn,
-    parameterized_2q_op_to_sqrt_iswap_operations,
-    prepare_two_qubit_state_using_cz,
-    prepare_two_qubit_state_using_iswap,
-    prepare_two_qubit_state_using_sqrt_iswap,
-    quantum_shannon_decomposition,
-    single_qubit_matrix_to_gates,
-    single_qubit_matrix_to_pauli_rotations,
-    single_qubit_matrix_to_phased_x_z,
-    single_qubit_matrix_to_phxz,
-    single_qubit_op_to_framed_phase_form,
-    three_qubit_matrix_to_operations,
-    two_qubit_matrix_to_cz_isometry,
-    two_qubit_matrix_to_cz_operations,
-    two_qubit_matrix_to_diagonal_and_cz_operations,
-    two_qubit_matrix_to_ion_operations,
-    two_qubit_matrix_to_sqrt_iswap_operations,
-    unitary_to_pauli_string,
+    # pylint: disable=line-too-long
+    compute_cphase_exponents_for_fsim_decomposition as compute_cphase_exponents_for_fsim_decomposition,
+    decompose_cphase_into_two_fsim as decompose_cphase_into_two_fsim,
+    decompose_clifford_tableau_to_operations as decompose_clifford_tableau_to_operations,
+    decompose_multi_controlled_x as decompose_multi_controlled_x,
+    decompose_multi_controlled_rotation as decompose_multi_controlled_rotation,
+    decompose_two_qubit_interaction_into_four_fsim_gates as decompose_two_qubit_interaction_into_four_fsim_gates,
+    is_negligible_turn as is_negligible_turn,
+    parameterized_2q_op_to_sqrt_iswap_operations as parameterized_2q_op_to_sqrt_iswap_operations,
+    prepare_two_qubit_state_using_cz as prepare_two_qubit_state_using_cz,
+    prepare_two_qubit_state_using_iswap as prepare_two_qubit_state_using_iswap,
+    prepare_two_qubit_state_using_sqrt_iswap as prepare_two_qubit_state_using_sqrt_iswap,
+    quantum_shannon_decomposition as quantum_shannon_decomposition,
+    single_qubit_matrix_to_gates as single_qubit_matrix_to_gates,
+    single_qubit_matrix_to_pauli_rotations as single_qubit_matrix_to_pauli_rotations,
+    single_qubit_matrix_to_phased_x_z as single_qubit_matrix_to_phased_x_z,
+    single_qubit_matrix_to_phxz as single_qubit_matrix_to_phxz,
+    single_qubit_op_to_framed_phase_form as single_qubit_op_to_framed_phase_form,
+    three_qubit_matrix_to_operations as three_qubit_matrix_to_operations,
+    two_qubit_matrix_to_cz_isometry as two_qubit_matrix_to_cz_isometry,
+    two_qubit_matrix_to_cz_operations as two_qubit_matrix_to_cz_operations,
+    two_qubit_matrix_to_diagonal_and_cz_operations as two_qubit_matrix_to_diagonal_and_cz_operations,
+    two_qubit_matrix_to_ion_operations as two_qubit_matrix_to_ion_operations,
+    two_qubit_matrix_to_sqrt_iswap_operations as two_qubit_matrix_to_sqrt_iswap_operations,
+    unitary_to_pauli_string as unitary_to_pauli_string,
 )
 
 from cirq.transformers.heuristic_decompositions import (
-    TwoQubitGateTabulation,
-    TwoQubitGateTabulationResult,
-    two_qubit_gate_product_tabulation,
+    TwoQubitGateTabulation as TwoQubitGateTabulation,
+    TwoQubitGateTabulationResult as TwoQubitGateTabulationResult,
+    two_qubit_gate_product_tabulation as two_qubit_gate_product_tabulation,
 )
 
 from cirq.transformers.routing import (
-    AbstractInitialMapper,
-    HardCodedInitialMapper,
-    LineInitialMapper,
-    MappingManager,
-    RouteCQC,
-    routed_circuit_with_mapping,
+    AbstractInitialMapper as AbstractInitialMapper,
+    HardCodedInitialMapper as HardCodedInitialMapper,
+    LineInitialMapper as LineInitialMapper,
+    MappingManager as MappingManager,
+    RouteCQC as RouteCQC,
+    routed_circuit_with_mapping as routed_circuit_with_mapping,
 )
 
 from cirq.transformers.target_gatesets import (
-    create_transformer_with_kwargs,
-    CompilationTargetGateset,
-    CZTargetGateset,
-    SqrtIswapTargetGateset,
-    TwoQubitCompilationTargetGateset,
+    create_transformer_with_kwargs as create_transformer_with_kwargs,
+    CompilationTargetGateset as CompilationTargetGateset,
+    CZTargetGateset as CZTargetGateset,
+    SqrtIswapTargetGateset as SqrtIswapTargetGateset,
+    TwoQubitCompilationTargetGateset as TwoQubitCompilationTargetGateset,
 )
 
-from cirq.transformers.align import align_left, align_right
+from cirq.transformers.align import align_left as align_left, align_right as align_right
 
-from cirq.transformers.stratify import stratified_circuit
+from cirq.transformers.stratify import stratified_circuit as stratified_circuit
 
-from cirq.transformers.expand_composite import expand_composite
+from cirq.transformers.expand_composite import expand_composite as expand_composite
 
-from cirq.transformers.eject_phased_paulis import eject_phased_paulis
+from cirq.transformers.eject_phased_paulis import eject_phased_paulis as eject_phased_paulis
 
-from cirq.transformers.optimize_for_target_gateset import optimize_for_target_gateset
+from cirq.transformers.optimize_for_target_gateset import (
+    optimize_for_target_gateset as optimize_for_target_gateset,
+)
 
-from cirq.transformers.drop_empty_moments import drop_empty_moments
+from cirq.transformers.drop_empty_moments import drop_empty_moments as drop_empty_moments
 
-from cirq.transformers.drop_negligible_operations import drop_negligible_operations
+from cirq.transformers.drop_negligible_operations import (
+    drop_negligible_operations as drop_negligible_operations,
+)
 
-from cirq.transformers.dynamical_decoupling import add_dynamical_decoupling
+from cirq.transformers.dynamical_decoupling import (
+    add_dynamical_decoupling as add_dynamical_decoupling,
+)
 
-from cirq.transformers.eject_z import eject_z
+from cirq.transformers.eject_z import eject_z as eject_z
 
 from cirq.transformers.measurement_transformers import (
-    defer_measurements,
-    dephase_measurements,
-    drop_terminal_measurements,
+    defer_measurements as defer_measurements,
+    dephase_measurements as dephase_measurements,
+    drop_terminal_measurements as drop_terminal_measurements,
 )
 
-from cirq.transformers.merge_k_qubit_gates import merge_k_qubit_unitaries
+from cirq.transformers.merge_k_qubit_gates import merge_k_qubit_unitaries as merge_k_qubit_unitaries
 
 from cirq.transformers.merge_single_qubit_gates import (
-    merge_single_qubit_gates_to_phased_x_and_z,
-    merge_single_qubit_gates_to_phxz,
-    merge_single_qubit_moments_to_phxz,
+    merge_single_qubit_gates_to_phased_x_and_z as merge_single_qubit_gates_to_phased_x_and_z,
+    merge_single_qubit_gates_to_phxz as merge_single_qubit_gates_to_phxz,
+    merge_single_qubit_moments_to_phxz as merge_single_qubit_moments_to_phxz,
 )
 
-from cirq.transformers.qubit_management_transformers import map_clean_and_borrowable_qubits
+from cirq.transformers.qubit_management_transformers import (
+    map_clean_and_borrowable_qubits as map_clean_and_borrowable_qubits,
+)
 
-from cirq.transformers.synchronize_terminal_measurements import synchronize_terminal_measurements
+from cirq.transformers.synchronize_terminal_measurements import (
+    synchronize_terminal_measurements as synchronize_terminal_measurements,
+)
 
 from cirq.transformers.transformer_api import (
-    LogLevel,
-    TRANSFORMER,
-    TransformerContext,
-    TransformerLogger,
-    transformer,
+    LogLevel as LogLevel,
+    TRANSFORMER as TRANSFORMER,
+    TransformerContext as TransformerContext,
+    TransformerLogger as TransformerLogger,
+    transformer as transformer,
 )
 
 from cirq.transformers.transformer_primitives import (
-    map_moments,
-    map_operations,
-    map_operations_and_unroll,
-    merge_k_qubit_unitaries_to_circuit_op,
-    merge_moments,
-    merge_operations,
-    merge_operations_to_circuit_op,
-    toggle_tags,
-    unroll_circuit_op,
-    unroll_circuit_op_greedy_earliest,
-    unroll_circuit_op_greedy_frontier,
+    map_moments as map_moments,
+    map_operations as map_operations,
+    map_operations_and_unroll as map_operations_and_unroll,
+    merge_k_qubit_unitaries_to_circuit_op as merge_k_qubit_unitaries_to_circuit_op,
+    merge_moments as merge_moments,
+    merge_operations as merge_operations,
+    merge_operations_to_circuit_op as merge_operations_to_circuit_op,
+    toggle_tags as toggle_tags,
+    unroll_circuit_op as unroll_circuit_op,
+    unroll_circuit_op_greedy_earliest as unroll_circuit_op_greedy_earliest,
+    unroll_circuit_op_greedy_frontier as unroll_circuit_op_greedy_frontier,
 )
 
-
 from cirq.transformers.gauge_compiling import (
-    CZGaugeTransformer,
-    ConstantGauge,
-    Gauge,
-    GaugeSelector,
-    GaugeTransformer,
-    ISWAPGaugeTransformer,
-    SpinInversionGaugeTransformer,
-    SqrtCZGaugeTransformer,
-    SqrtISWAPGaugeTransformer,
+    CZGaugeTransformer as CZGaugeTransformer,
+    ConstantGauge as ConstantGauge,
+    Gauge as Gauge,
+    GaugeSelector as GaugeSelector,
+    GaugeTransformer as GaugeTransformer,
+    ISWAPGaugeTransformer as ISWAPGaugeTransformer,
+    SpinInversionGaugeTransformer as SpinInversionGaugeTransformer,
+    SqrtCZGaugeTransformer as SqrtCZGaugeTransformer,
+    SqrtISWAPGaugeTransformer as SqrtISWAPGaugeTransformer,
+)
+
+from cirq.transformers.randomized_measurements import (
+    RandomizedMeasurements as RandomizedMeasurements,
+)
+
+
+from cirq.transformers.insertion_sort import (
+    insertion_sort_transformer as insertion_sort_transformer,
 )

cirq/transformers/align.py

@@ -16,6 +16,7 @@
 
 import dataclasses
 from typing import Optional, TYPE_CHECKING
+
 from cirq import circuits, ops
 from cirq.transformers import transformer_api
 
@@ -73,4 +74,14 @@ def align_right(
     """
     if context is not None and context.deep is True:
         context = dataclasses.replace(context, deep=False)
-    return align_left(circuit[::-1], context=context)[::-1]
+    # Reverse the circuit, align left, and reverse again. Note each moment also has to have its ops
+    # reversed internally, to avoid edge conditions where non-commuting but can-be-in-same-moment
+    # ops (measurements and classical controls, particularly) could end up getting swapped.
+    backwards = []
+    for moment in circuit[::-1]:
+        backwards.append(circuits.Moment(reversed(moment.operations)))
+    aligned_backwards = align_left(circuits.Circuit(backwards), context=context)
+    forwards = []
+    for moment in aligned_backwards[::-1]:
+        forwards.append(circuits.Moment(reversed(moment.operations)))
+    return circuits.Circuit(forwards)

cirq/transformers/align_test.py

@@ -208,3 +208,16 @@ def test_classical_control():
     )
     cirq.testing.assert_same_circuits(cirq.align_left(circuit), circuit)
     cirq.testing.assert_same_circuits(cirq.align_right(circuit), circuit)
+
+
+def test_measurement_and_classical_control_same_moment_preserve_order():
+    q0, q1 = cirq.LineQubit.range(2)
+    circuit = cirq.Circuit()
+    op_measure = cirq.measure(q0, key='m')
+    op_controlled = cirq.X(q1).with_classical_controls('m')
+    circuit.append(op_measure)
+    circuit.append(op_controlled, cirq.InsertStrategy.INLINE)
+    circuit = cirq.align_right(circuit)
+    ops_in_order = list(circuit.all_operations())
+    assert ops_in_order[0] == op_measure
+    assert ops_in_order[1] == op_controlled

cirq/transformers/analytical_decompositions/__init__.py

@@ -15,64 +15,67 @@
 """Utilities for analytical decomposition of cirq gates."""
 
 from cirq.transformers.analytical_decompositions.clifford_decomposition import (
-    decompose_clifford_tableau_to_operations,
+    decompose_clifford_tableau_to_operations as decompose_clifford_tableau_to_operations,
 )
 
 from cirq.transformers.analytical_decompositions.controlled_gate_decomposition import (
-    decompose_multi_controlled_x,
-    decompose_multi_controlled_rotation,
+    decompose_multi_controlled_x as decompose_multi_controlled_x,
+    decompose_multi_controlled_rotation as decompose_multi_controlled_rotation,
 )
 
 from cirq.transformers.analytical_decompositions.cphase_to_fsim import (
-    compute_cphase_exponents_for_fsim_decomposition,
-    decompose_cphase_into_two_fsim,
+    # pylint: disable=line-too-long
+    compute_cphase_exponents_for_fsim_decomposition as compute_cphase_exponents_for_fsim_decomposition,
+    decompose_cphase_into_two_fsim as decompose_cphase_into_two_fsim,
 )
 
 from cirq.transformers.analytical_decompositions.quantum_shannon_decomposition import (
-    quantum_shannon_decomposition,
+    quantum_shannon_decomposition as quantum_shannon_decomposition,
 )
 
 from cirq.transformers.analytical_decompositions.single_qubit_decompositions import (
-    is_negligible_turn,
-    single_qubit_matrix_to_gates,
-    single_qubit_matrix_to_pauli_rotations,
-    single_qubit_matrix_to_phased_x_z,
-    single_qubit_matrix_to_phxz,
-    single_qubit_op_to_framed_phase_form,
+    is_negligible_turn as is_negligible_turn,
+    single_qubit_matrix_to_gates as single_qubit_matrix_to_gates,
+    single_qubit_matrix_to_pauli_rotations as single_qubit_matrix_to_pauli_rotations,
+    single_qubit_matrix_to_phased_x_z as single_qubit_matrix_to_phased_x_z,
+    single_qubit_matrix_to_phxz as single_qubit_matrix_to_phxz,
+    single_qubit_op_to_framed_phase_form as single_qubit_op_to_framed_phase_form,
 )
 
 from cirq.transformers.analytical_decompositions.three_qubit_decomposition import (
-    three_qubit_matrix_to_operations,
+    three_qubit_matrix_to_operations as three_qubit_matrix_to_operations,
 )
 
 from cirq.transformers.analytical_decompositions.two_qubit_to_cz import (
-    two_qubit_matrix_to_cz_operations,
-    two_qubit_matrix_to_diagonal_and_cz_operations,
+    # pylint: disable=line-too-long
+    two_qubit_matrix_to_cz_operations as two_qubit_matrix_to_cz_operations,
+    two_qubit_matrix_to_diagonal_and_cz_operations as two_qubit_matrix_to_diagonal_and_cz_operations,
 )
 
 from cirq.transformers.analytical_decompositions.two_qubit_to_fsim import (
-    decompose_two_qubit_interaction_into_four_fsim_gates,
+    # pylint: disable=line-too-long
+    decompose_two_qubit_interaction_into_four_fsim_gates as decompose_two_qubit_interaction_into_four_fsim_gates,
 )
 
 from cirq.transformers.analytical_decompositions.two_qubit_to_ms import (
-    two_qubit_matrix_to_ion_operations,
+    two_qubit_matrix_to_ion_operations as two_qubit_matrix_to_ion_operations,
 )
 
 from cirq.transformers.analytical_decompositions.two_qubit_to_sqrt_iswap import (
-    parameterized_2q_op_to_sqrt_iswap_operations,
-    two_qubit_matrix_to_sqrt_iswap_operations,
+    parameterized_2q_op_to_sqrt_iswap_operations as parameterized_2q_op_to_sqrt_iswap_operations,
+    two_qubit_matrix_to_sqrt_iswap_operations as two_qubit_matrix_to_sqrt_iswap_operations,
 )
 
 from cirq.transformers.analytical_decompositions.two_qubit_state_preparation import (
-    prepare_two_qubit_state_using_cz,
-    prepare_two_qubit_state_using_sqrt_iswap,
-    prepare_two_qubit_state_using_iswap,
+    prepare_two_qubit_state_using_cz as prepare_two_qubit_state_using_cz,
+    prepare_two_qubit_state_using_sqrt_iswap as prepare_two_qubit_state_using_sqrt_iswap,
+    prepare_two_qubit_state_using_iswap as prepare_two_qubit_state_using_iswap,
 )
 
 from cirq.transformers.analytical_decompositions.single_to_two_qubit_isometry import (
-    two_qubit_matrix_to_cz_isometry,
+    two_qubit_matrix_to_cz_isometry as two_qubit_matrix_to_cz_isometry,
 )
 
 from cirq.transformers.analytical_decompositions.pauli_string_decomposition import (
-    unitary_to_pauli_string,
+    unitary_to_pauli_string as unitary_to_pauli_string,
 )

cirq/transformers/analytical_decompositions/clifford_decomposition.py

@@ -14,10 +14,11 @@
 
 """Utility methods to decompose Clifford gates into circuits."""
 
-from typing import List, TYPE_CHECKING
 import functools
+from typing import List, TYPE_CHECKING
 
 import numpy as np
+
 from cirq import ops, protocols, qis, sim
 
 if TYPE_CHECKING:

cirq/transformers/analytical_decompositions/clifford_decomposition_test.py

@@ -12,8 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import pytest
 import numpy as np
+import pytest
 
 import cirq
 from cirq.testing import assert_allclose_up_to_global_phase

cirq/transformers/analytical_decompositions/controlled_gate_decomposition.py

@@ -17,7 +17,7 @@ from typing import List, Tuple, TYPE_CHECKING
 import numpy as np
 
 from cirq import ops
-from cirq.linalg import is_unitary, is_special_unitary, map_eigenvalues
+from cirq.linalg import is_special_unitary, is_unitary, map_eigenvalues
 from cirq.protocols import unitary
 
 if TYPE_CHECKING:

cirq/transformers/analytical_decompositions/controlled_gate_decomposition_test.py

@@ -87,6 +87,7 @@ def test_decompose_specific_matrices():
             _test_decompose(cirq.unitary(gate), controls_count)
 
 
+@cirq.testing.retry_once_with_later_random_values
 def test_decompose_random_unitary():
     for controls_count in range(5):
         for _ in range(10):
@@ -95,6 +96,7 @@ def test_decompose_random_unitary():
         _test_decompose(_random_unitary(), controls_count)
 
 
+@cirq.testing.retry_once_with_later_random_values
 def test_decompose_random_special_unitary():
     for controls_count in range(5):
         for _ in range(10):

cirq/transformers/analytical_decompositions/cphase_to_fsim.py

@@ -56,7 +56,7 @@ def compute_cphase_exponents_for_fsim_decomposition(
     """
 
     def nonempty_intervals(
-        intervals: Sequence[Tuple[float, float]]
+        intervals: Sequence[Tuple[float, float]],
     ) -> Sequence[Tuple[float, float]]:
         return tuple((a, b) for a, b in intervals if a < b)
 

cirq/transformers/analytical_decompositions/cphase_to_fsim_test.py

@@ -12,9 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import itertools
 from typing import List, Sequence, Tuple
 
-import itertools
 import numpy as np
 import pytest
 import sympy

cirq/transformers/analytical_decompositions/pauli_string_decomposition.py

@@ -12,13 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Optional, Tuple, cast
+from typing import cast, Optional, Tuple
 
 import numpy as np
 import numpy.typing as npt
 
-from cirq.ops import DensePauliString
 from cirq import protocols
+from cirq.ops import DensePauliString
 
 
 def _argmax(V: npt.NDArray) -> Tuple[int, float]:

cirq/transformers/analytical_decompositions/pauli_string_decomposition_test.py

@@ -12,15 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import cast
-import itertools
 import cmath
-import pytest
+import itertools
+from typing import cast
 
 import numpy as np
+import pytest
 
-from cirq.ops import DensePauliString, T
 from cirq import protocols
+from cirq.ops import DensePauliString, T
 from cirq.transformers.analytical_decompositions import unitary_to_pauli_string