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

cirq/transformers/routing/__init__.py

@@ -14,8 +14,17 @@
 
 """Routing utilities in Cirq."""
 
-from cirq.transformers.routing.initial_mapper import AbstractInitialMapper, HardCodedInitialMapper
-from cirq.transformers.routing.mapping_manager import MappingManager
-from cirq.transformers.routing.line_initial_mapper import LineInitialMapper
-from cirq.transformers.routing.route_circuit_cqc import RouteCQC
-from cirq.transformers.routing.visualize_routed_circuit import routed_circuit_with_mapping
+from cirq.transformers.routing.initial_mapper import (
+    AbstractInitialMapper as AbstractInitialMapper,
+    HardCodedInitialMapper as HardCodedInitialMapper,
+)
+
+from cirq.transformers.routing.mapping_manager import MappingManager as MappingManager
+
+from cirq.transformers.routing.line_initial_mapper import LineInitialMapper as LineInitialMapper
+
+from cirq.transformers.routing.route_circuit_cqc import RouteCQC as RouteCQC
+
+from cirq.transformers.routing.visualize_routed_circuit import (
+    routed_circuit_with_mapping as routed_circuit_with_mapping,
+)

cirq/transformers/routing/initial_mapper.py

@@ -12,8 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import TYPE_CHECKING, Dict
 import abc
+from typing import Dict, TYPE_CHECKING
 
 from cirq import value
 

cirq/transformers/routing/initial_mapper_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import pytest
+
 import cirq
 
 

cirq/transformers/routing/line_initial_mapper.py

@@ -30,12 +30,13 @@ If some logical qubits are unampped after this first procedure then there are tw
     the nearest available neighbor to the center of the device.
 """
 
-from typing import Deque, Dict, List, Set, Tuple, TYPE_CHECKING
 from collections import deque
+from typing import Deque, Dict, List, Set, Tuple, TYPE_CHECKING
+
 import networkx as nx
 
-from cirq.transformers.routing import initial_mapper
 from cirq import protocols, value
+from cirq.transformers.routing import initial_mapper
 
 if TYPE_CHECKING:
     import cirq

cirq/transformers/routing/mapping_manager.py

@@ -14,9 +14,9 @@
 
 """Manages the mapping from logical to physical qubits during a routing procedure."""
 
-from typing import List, Dict, Sequence, TYPE_CHECKING
-import networkx as nx
+from typing import Dict, List, Sequence, TYPE_CHECKING
 
+import networkx as nx
 import numpy as np
 
 if TYPE_CHECKING:

cirq/transformers/routing/mapping_manager_test.py

@@ -12,9 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from networkx.utils.misc import graphs_equal
-import pytest
 import networkx as nx
+import pytest
+from networkx.utils.misc import graphs_equal
 
 import cirq
 

cirq/transformers/routing/route_circuit_cqc.py

@@ -14,13 +14,14 @@
 
 """Heuristic qubit routing algorithm based on arxiv:1902.08091."""
 
-from typing import Any, Dict, List, Optional, Set, Sequence, Tuple, TYPE_CHECKING
 import itertools
+from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, TYPE_CHECKING
+
 import networkx as nx
 
 from cirq import circuits, ops, protocols
 from cirq.transformers import transformer_api, transformer_primitives
-from cirq.transformers.routing import mapping_manager, line_initial_mapper
+from cirq.transformers.routing import line_initial_mapper, mapping_manager
 
 if TYPE_CHECKING:
     import cirq

cirq/transformers/routing/route_circuit_cqc_test.py

@@ -12,9 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import cirq
 import pytest
 
+import cirq
+
 
 def test_directed_device():
     device = cirq.testing.construct_ring_device(10, directed=True)

cirq/transformers/routing/visualize_routed_circuit.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 from typing import Dict, Optional, Tuple, TYPE_CHECKING
+
 from cirq import circuits, ops
 
 if TYPE_CHECKING:

cirq/transformers/routing/visualize_routed_circuit_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import pytest
+
 import cirq
 
 

cirq/transformers/stratify.py

@@ -15,9 +15,9 @@
 """Transformer pass to repack circuits avoiding simultaneous operations with different classes."""
 
 import itertools
-from typing import TYPE_CHECKING, Type, Callable, Dict, Optional, Union, Iterable, Sequence, List
+from typing import Callable, Dict, Iterable, List, Optional, Sequence, Type, TYPE_CHECKING, Union
 
-from cirq import ops, circuits, protocols, _import
+from cirq import _import, circuits, ops, protocols
 from cirq.transformers import transformer_api
 
 drop_empty_moments = _import.LazyLoader('drop_empty_moments', globals(), 'cirq.transformers')

cirq/transformers/synchronize_terminal_measurements.py

@@ -15,7 +15,8 @@
 """Transformer pass to move terminal measurements to the end of circuit."""
 
 from typing import List, Optional, Set, Tuple, TYPE_CHECKING
-from cirq import protocols, circuits
+
+from cirq import circuits, protocols
 from cirq.transformers import transformer_api
 
 if TYPE_CHECKING:

cirq/transformers/target_gatesets/__init__.py

@@ -15,11 +15,13 @@
 """Gatesets which can act as compilation targets in Cirq."""
 
 from cirq.transformers.target_gatesets.compilation_target_gateset import (
-    create_transformer_with_kwargs,
-    CompilationTargetGateset,
-    TwoQubitCompilationTargetGateset,
+    create_transformer_with_kwargs as create_transformer_with_kwargs,
+    CompilationTargetGateset as CompilationTargetGateset,
+    TwoQubitCompilationTargetGateset as TwoQubitCompilationTargetGateset,
 )
 
-from cirq.transformers.target_gatesets.cz_gateset import CZTargetGateset
+from cirq.transformers.target_gatesets.cz_gateset import CZTargetGateset as CZTargetGateset
 
-from cirq.transformers.target_gatesets.sqrt_iswap_gateset import SqrtIswapTargetGateset
+from cirq.transformers.target_gatesets.sqrt_iswap_gateset import (
+    SqrtIswapTargetGateset as SqrtIswapTargetGateset,
+)

cirq/transformers/target_gatesets/compilation_target_gateset.py

@@ -14,14 +14,13 @@
 
 """Base class for creating custom target gatesets which can be used for compilation."""
 
-from typing import Optional, List, Hashable, TYPE_CHECKING, Union, Type
 import abc
+from typing import Hashable, List, Optional, Type, TYPE_CHECKING, Union
 
 from cirq import circuits, ops, protocols, transformers
 from cirq.protocols.decompose_protocol import DecomposeResult
 from cirq.transformers import merge_k_qubit_gates, merge_single_qubit_gates
 
-
 if TYPE_CHECKING:
     import cirq
 
@@ -76,7 +75,7 @@ def create_transformer_with_kwargs(transformer: 'cirq.TRANSFORMER', **kwargs) ->
 class CompilationTargetGateset(ops.Gateset, metaclass=abc.ABCMeta):
     """Abstract base class to create gatesets that can be used as targets for compilation.
 
-    An instance of this type can be passed to transformers like `cirq.convert_to_target_gateset`,
+    An instance of this type can be passed to transformers like `cirq.optimize_for_target_gateset`,
     which can transform any given circuit to contain gates accepted by this gateset.
     """
 
@@ -86,6 +85,7 @@ class CompilationTargetGateset(ops.Gateset, metaclass=abc.ABCMeta):
         name: Optional[str] = None,
         unroll_circuit_op: bool = True,
         preserve_moment_structure: bool = True,
+        reorder_operations: bool = False,
     ):
         """Initializes CompilationTargetGateset.
 
@@ -97,9 +97,18 @@ class CompilationTargetGateset(ops.Gateset, metaclass=abc.ABCMeta):
                 validated by validating the underlying `cirq.Circuit`.
             preserve_moment_structure: Whether to preserve the moment structure of the
                 circuit during compilation or not.
+            reorder_operations: Whether to attempt to reorder the operations in order to reduce
+                circuit depth or not (can be True only if preserve_moment_structure=False).
+        Raises:
+            ValueError: If both reorder_operations and preserve_moment_structure are True.
         """
+        if reorder_operations and preserve_moment_structure:
+            raise ValueError(
+                'reorder_operations and preserve_moment_structure can not both be True'
+            )
         super().__init__(*gates, name=name, unroll_circuit_op=unroll_circuit_op)
         self._preserve_moment_structure = preserve_moment_structure
+        self._reorder_operations = reorder_operations
 
     @property
     @abc.abstractmethod
@@ -146,11 +155,15 @@ class CompilationTargetGateset(ops.Gateset, metaclass=abc.ABCMeta):
     @property
     def preprocess_transformers(self) -> List['cirq.TRANSFORMER']:
         """List of transformers which should be run before decomposing individual operations."""
+        reorder_transfomers = (
+            [transformers.insertion_sort_transformer] if self._reorder_operations else []
+        )
         return [
             create_transformer_with_kwargs(
                 transformers.expand_composite,
                 no_decomp=lambda op: protocols.num_qubits(op) <= self.num_qubits,
             ),
+            *reorder_transfomers,
             create_transformer_with_kwargs(
                 merge_k_qubit_gates.merge_k_qubit_unitaries,
                 k=self.num_qubits,

cirq/transformers/target_gatesets/compilation_target_gateset_test.py

@@ -13,7 +13,9 @@
 # limitations under the License.
 
 from typing import List
+
 import pytest
+
 import cirq
 from cirq.protocols.decompose_protocol import DecomposeResult
 

cirq/transformers/target_gatesets/cz_gateset.py

@@ -14,7 +14,7 @@
 
 """Target gateset used for compiling circuits to CZ + 1-q rotations + measurement gates."""
 
-from typing import Any, Dict, Sequence, Type, Union, TYPE_CHECKING
+from typing import Any, Dict, Sequence, Type, TYPE_CHECKING, Union
 
 from cirq import ops, protocols
 from cirq.transformers.analytical_decompositions import two_qubit_to_cz
@@ -49,6 +49,7 @@ class CZTargetGateset(compilation_target_gateset.TwoQubitCompilationTargetGatese
         allow_partial_czs: bool = False,
         additional_gates: Sequence[Union[Type['cirq.Gate'], 'cirq.Gate', 'cirq.GateFamily']] = (),
         preserve_moment_structure: bool = True,
+        reorder_operations: bool = False,
     ) -> None:
         """Initializes CZTargetGateset
 
@@ -60,6 +61,8 @@ class CZTargetGateset(compilation_target_gateset.TwoQubitCompilationTargetGatese
               be "accepted" by this gateset. This is empty by default.
             preserve_moment_structure: Whether to preserve the moment structure of the
                 circuit during compilation or not.
+            reorder_operations: Whether to attempt to reorder the operations in order to reduce
+                circuit depth or not (can be True only if preserve_moment_structure=False).
         """
         super().__init__(
             ops.CZPowGate if allow_partial_czs else ops.CZ,
@@ -69,6 +72,7 @@ class CZTargetGateset(compilation_target_gateset.TwoQubitCompilationTargetGatese
             *additional_gates,
             name='CZPowTargetGateset' if allow_partial_czs else 'CZTargetGateset',
             preserve_moment_structure=preserve_moment_structure,
+            reorder_operations=reorder_operations,
         )
         self.additional_gates = tuple(
             g if isinstance(g, ops.GateFamily) else ops.GateFamily(gate=g) for g in additional_gates

cirq/transformers/target_gatesets/cz_gateset_test.py

@@ -13,10 +13,12 @@
 # limitations under the License.
 
 from typing import Optional, Sequence, Type
+
+import numpy as np
 import pytest
-import cirq
 import sympy
-import numpy as np
+
+import cirq
 
 
 def all_gates_of_type(m: cirq.Moment, g: cirq.Gateset):
@@ -319,3 +321,22 @@ def test_unsupported_gate():
 )
 def test_repr(gateset):
     cirq.testing.assert_equivalent_repr(gateset)
+
+
+def test_with_commutation():
+    c = cirq.Circuit(
+        cirq.CZ(cirq.q(0), cirq.q(1)), cirq.CZ(cirq.q(1), cirq.q(2)), cirq.CZ(cirq.q(0), cirq.q(1))
+    )
+    got = cirq.optimize_for_target_gateset(
+        c,
+        gateset=cirq.CZTargetGateset(preserve_moment_structure=False, reorder_operations=True),
+        max_num_passes=1,
+    )
+    assert got == cirq.Circuit(cirq.CZ(cirq.q(1), cirq.q(2)))
+
+
+def test_reorder_operations_and_preserve_moment_structure_raises():
+    with pytest.raises(
+        ValueError, match='reorder_operations and preserve_moment_structure can not both be True'
+    ):
+        _ = cirq.CZTargetGateset(preserve_moment_structure=True, reorder_operations=True)

cirq/transformers/target_gatesets/sqrt_iswap_gateset.py

@@ -14,7 +14,7 @@
 
 """Target gateset used for compiling circuits to √iSWAP + 1-q rotations + measurement gates."""
 
-from typing import Any, Dict, Optional, Sequence, Type, Union, TYPE_CHECKING
+from typing import Any, Dict, Optional, Sequence, Type, TYPE_CHECKING, Union
 
 from cirq import ops, protocols
 from cirq.protocols.decompose_protocol import DecomposeResult

cirq/transformers/target_gatesets/sqrt_iswap_gateset_test.py

@@ -14,10 +14,11 @@
 
 from typing import Optional
 
-import cirq
+import numpy as np
 import pytest
 import sympy
-import numpy as np
+
+import cirq
 
 
 def all_gates_of_type(m: cirq.Moment, g: cirq.Gateset):

cirq/transformers/transformer_api.py

@@ -15,24 +15,25 @@
 """Defines the API for circuit transformers in Cirq."""
 
 import dataclasses
-import inspect
 import enum
 import functools
+import inspect
 import textwrap
 from typing import (
-    cast,
     Any,
     Callable,
-    Tuple,
+    cast,
     Hashable,
     List,
-    overload,
     Optional,
+    overload,
+    Tuple,
     Type,
     TYPE_CHECKING,
     TypeVar,
     Union,
 )
+
 from typing_extensions import Protocol
 
 from cirq import circuits

cirq/transformers/transformer_api_test.py

@@ -12,14 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from unittest import mock
 from typing import Optional
+from unittest import mock
+
+import pytest
 
 import cirq
 from cirq.transformers.transformer_api import LogLevel
 
-import pytest
-
 
 @cirq.transformer()
 class MockTransformerClass:
@@ -257,6 +257,14 @@ def test_transformer_stats_logger_show_levels(capfd):
     assert all(line not in out for line in [info_line, debug_line, warning_line])
 
 
+def test_noop_logger():
+    logger = cirq.transformers.transformer_api.NoOpTransformerLogger()
+    logger.register_initial(cirq.Circuit(), "test")
+    logger.log("stuff")
+    logger.register_final(cirq.Circuit(), "test")
+    logger.show()
+
+
 def test_transformer_stats_logger_linear_and_nested(capfd):
     q = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(cirq.H.on_each(*q), cirq.CNOT(*q))

cirq/transformers/transformer_primitives.py

@@ -14,22 +14,21 @@
 
 """Defines primitives for common transformer patterns."""
 
-from collections import defaultdict
 import bisect
 import dataclasses
-
+from collections import defaultdict
 from typing import (
-    cast,
     Callable,
+    cast,
     Dict,
     Hashable,
     List,
     Optional,
     Sequence,
     Set,
-    Union,
     Tuple,
     TYPE_CHECKING,
+    Union,
 )
 
 from cirq import circuits, ops, protocols
@@ -196,37 +195,16 @@ def _map_operations_impl(
         return mapped_ops
 
     new_moments: List[List['cirq.Operation']] = []
-
-    # Keep track of the latest time index for each qubit, measurement key, and control key.
-    qubit_time_index: Dict['cirq.Qid', int] = {}
-    measurement_time_index: Dict['cirq.MeasurementKey', int] = {}
-    control_time_index: Dict['cirq.MeasurementKey', int] = {}
-
-    # New mapped operations in the current moment should be inserted after `last_moment_time_index`.
-    last_moment_time_index = -1
-
     for idx, moment in enumerate(circuit):
-        if wrap_in_circuit_op:
-            new_moments.append([])
+        curr_moments: List[List['cirq.Operation']] = [[]] if wrap_in_circuit_op else []
+        placement_cache = circuits.circuit._PlacementCache()
         for op in moment:
             mapped_ops = apply_map_func(op, idx)
-
             for mapped_op in mapped_ops:
-                # Identify the earliest moment that can accommodate this op.
-                placement_index = circuits.circuit.get_earliest_accommodating_moment_index(
-                    mapped_op, qubit_time_index, measurement_time_index, control_time_index
-                )
-                placement_index = max(placement_index, last_moment_time_index + 1)
-                new_moments.extend([[] for _ in range(placement_index - len(new_moments) + 1)])
-                new_moments[placement_index].append(mapped_op)
-                for qubit in mapped_op.qubits:
-                    qubit_time_index[qubit] = placement_index
-                for key in protocols.measurement_key_objs(mapped_op):
-                    measurement_time_index[key] = placement_index
-                for key in protocols.control_keys(mapped_op):
-                    control_time_index[key] = placement_index
-
-        last_moment_time_index = len(new_moments) - 1
+                placement_index = placement_cache.append(mapped_op)
+                curr_moments.extend([[] for _ in range(placement_index - len(curr_moments) + 1)])
+                curr_moments[placement_index].append(mapped_op)
+        new_moments.extend(curr_moments)
 
     return _create_target_circuit_type([circuits.Moment(moment) for moment in new_moments], circuit)
 

cirq/transformers/transformer_primitives_test.py

@@ -12,7 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Optional, List
+from typing import Iterator, List, Optional
+
 import pytest
 
 import cirq
@@ -64,7 +65,7 @@ def test_map_operations_does_not_insert_too_many_moments():
     q = cirq.LineQubit.range(5)
     c_orig = cirq.Circuit(cirq.CX(q[0], q[1]), cirq.CX(q[3], q[2]), cirq.CX(q[3], q[4]))
 
-    def map_func(op: cirq.Operation, _: int) -> cirq.OP_TREE:
+    def map_func(op: cirq.Operation, _: int) -> Iterator[cirq.OP_TREE]:
         yield cirq.Z.on_each(*op.qubits)
         yield cirq.CX(*op.qubits)
         yield cirq.Z.on_each(*op.qubits)
@@ -130,7 +131,7 @@ def test_map_operations_deep_subcircuits():
         .with_tags("external")
     )
 
-    def map_func(op: cirq.Operation, _: int) -> cirq.OP_TREE:
+    def map_func(op: cirq.Operation, _: int) -> Iterator[cirq.OP_TREE]:
         yield (
             [cirq.Z.on_each(*op.qubits), cirq.CX(*op.qubits), cirq.Z.on_each(*op.qubits)]
             if op.gate == cirq.CX
@@ -585,7 +586,7 @@ def test_merge_moments_empty_moment_as_intermediate_step():
 
 def test_merge_moments_empty_circuit():
     def fail_if_called_func(*_):
-        assert False
+        assert False  # pragma: no cover
 
     c = cirq.Circuit()
     assert cirq.merge_moments(c, fail_if_called_func) is c
@@ -600,7 +601,7 @@ def test_merge_operations_raises():
 
 def test_merge_operations_nothing_to_merge():
     def fail_if_called_func(*_):
-        assert False
+        assert False  # pragma: no cover
 
     # Empty Circuit.
     c = cirq.Circuit()

cirq/value/__init__.py

@@ -13,55 +13,76 @@
 # limitations under the License.
 
 """Value conversion utilities and classes for time and quantum states."""
-from cirq.value.abc_alt import ABCMetaImplementAnyOneOf, alternative
+from cirq.value.abc_alt import (
+    ABCMetaImplementAnyOneOf as ABCMetaImplementAnyOneOf,
+    alternative as alternative,
+)
 
 from cirq.value.angle import (
-    canonicalize_half_turns,
-    chosen_angle_to_canonical_half_turns,
-    chosen_angle_to_half_turns,
+    canonicalize_half_turns as canonicalize_half_turns,
+    chosen_angle_to_canonical_half_turns as chosen_angle_to_canonical_half_turns,
+    chosen_angle_to_half_turns as chosen_angle_to_half_turns,
 )
 
 from cirq.value.classical_data import (
-    ClassicalDataDictionaryStore,
-    ClassicalDataStore,
-    ClassicalDataStoreReader,
-    MeasurementType,
+    ClassicalDataDictionaryStore as ClassicalDataDictionaryStore,
+    ClassicalDataStore as ClassicalDataStore,
+    ClassicalDataStoreReader as ClassicalDataStoreReader,
+    MeasurementType as MeasurementType,
 )
 
-from cirq.value.condition import Condition, KeyCondition, SympyCondition
+from cirq.value.condition import (
+    Condition as Condition,
+    KeyCondition as KeyCondition,
+    SympyCondition as SympyCondition,
+    BitMaskKeyCondition as BitMaskKeyCondition,
+)
 
 from cirq.value.digits import (
-    big_endian_bits_to_int,
-    big_endian_digits_to_int,
-    big_endian_int_to_bits,
-    big_endian_int_to_digits,
+    big_endian_bits_to_int as big_endian_bits_to_int,
+    big_endian_digits_to_int as big_endian_digits_to_int,
+    big_endian_int_to_bits as big_endian_int_to_bits,
+    big_endian_int_to_digits as big_endian_int_to_digits,
 )
 
-from cirq.value.duration import Duration, DURATION_LIKE
+from cirq.value.duration import Duration as Duration, DURATION_LIKE as DURATION_LIKE
 
-from cirq.value.linear_dict import LinearDict, Scalar
+from cirq.value.linear_dict import LinearDict as LinearDict, Scalar as Scalar
 
-from cirq.value.measurement_key import MEASUREMENT_KEY_SEPARATOR, MeasurementKey
+from cirq.value.measurement_key import (
+    MEASUREMENT_KEY_SEPARATOR as MEASUREMENT_KEY_SEPARATOR,
+    MeasurementKey as MeasurementKey,
+)
 
-from cirq.value.probability import state_vector_to_probabilities, validate_probability
+from cirq.value.probability import (
+    state_vector_to_probabilities as state_vector_to_probabilities,
+    validate_probability as validate_probability,
+)
 
 from cirq.value.product_state import (
-    ProductState,
-    KET_PLUS,
-    KET_MINUS,
-    KET_IMAG,
-    KET_MINUS_IMAG,
-    KET_ZERO,
-    KET_ONE,
-    PAULI_STATES,
+    ProductState as ProductState,
+    KET_PLUS as KET_PLUS,
+    KET_MINUS as KET_MINUS,
+    KET_IMAG as KET_IMAG,
+    KET_MINUS_IMAG as KET_MINUS_IMAG,
+    KET_ZERO as KET_ZERO,
+    KET_ONE as KET_ONE,
+    PAULI_STATES as PAULI_STATES,
 )
 
-from cirq.value.periodic_value import PeriodicValue
+from cirq.value.periodic_value import PeriodicValue as PeriodicValue
 
-from cirq.value.random_state import parse_random_state, RANDOM_STATE_OR_SEED_LIKE
+from cirq.value.random_state import (
+    parse_random_state as parse_random_state,
+    RANDOM_STATE_OR_SEED_LIKE as RANDOM_STATE_OR_SEED_LIKE,
+)
 
-from cirq.value.timestamp import Timestamp
+from cirq.value.timestamp import Timestamp as Timestamp
 
-from cirq.value.type_alias import TParamKey, TParamVal, TParamValComplex
+from cirq.value.type_alias import (
+    TParamKey as TParamKey,
+    TParamVal as TParamVal,
+    TParamValComplex as TParamValComplex,
+)
 
-from cirq.value.value_equality_attr import value_equality
+from cirq.value.value_equality_attr import value_equality as value_equality

cirq/value/abc_alt.py

@@ -16,8 +16,7 @@
 
 import abc
 import functools
-from typing import cast, Callable, Set, TypeVar
-
+from typing import Callable, cast, Set, TypeVar
 
 T = TypeVar('T')
 

cirq/value/angle.py

@@ -13,8 +13,10 @@
 # limitations under the License.
 
 from typing import Optional, overload
+
 import numpy as np
 import sympy
+
 from cirq.value import type_alias