cirq-core 1.3.0.dev20231201141002__py3-none-any.whl → 1.4.0__py3-none-any.whl

cirq/transformers/transformer_primitives.py

@@ -46,19 +46,18 @@ def _to_target_circuit_type(
 ) -> CIRCUIT_TYPE:
     return cast(
         CIRCUIT_TYPE,
-        circuit.unfreeze(copy=False)
-        if isinstance(target_circuit, circuits.Circuit)
-        else circuit.freeze(),
+        (
+            circuit.unfreeze(copy=False)
+            if isinstance(target_circuit, circuits.Circuit)
+            else circuit.freeze()
+        ),
     )
 
 
 def _create_target_circuit_type(ops: ops.OP_TREE, target_circuit: CIRCUIT_TYPE) -> CIRCUIT_TYPE:
-    return cast(
-        CIRCUIT_TYPE,
-        circuits.Circuit(ops)
-        if isinstance(target_circuit, circuits.Circuit)
-        else circuits.FrozenCircuit(ops),
-    )
+    if isinstance(target_circuit, circuits.FrozenCircuit):
+        return cast(CIRCUIT_TYPE, circuits.FrozenCircuit(ops).with_tags(*target_circuit.tags))
+    return cast(CIRCUIT_TYPE, circuits.Circuit(ops))
 
 
 def map_moments(
@@ -640,11 +639,13 @@ def merge_moments(
     if deep:
         circuit = map_operations(
             circuit,
-            lambda op, _: op.untagged.replace(
-                circuit=merge_moments(op.untagged.circuit, merge_func, deep=deep)
-            ).with_tags(*op.tags)
-            if isinstance(op.untagged, circuits.CircuitOperation)
-            else op,
+            lambda op, _: (
+                op.untagged.replace(
+                    circuit=merge_moments(op.untagged.circuit, merge_func, deep=deep)
+                ).with_tags(*op.tags)
+                if isinstance(op.untagged, circuits.CircuitOperation)
+                else op
+            ),
             tags_to_ignore=tags_to_ignore,
         )
     merged_moments: List[circuits.Moment] = [circuit[0]]

cirq/transformers/transformer_primitives_test.py

@@ -131,38 +131,38 @@ def test_map_operations_deep_subcircuits():
     )
 
     def map_func(op: cirq.Operation, _: int) -> 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 else op
+        yield (
+            [cirq.Z.on_each(*op.qubits), cirq.CX(*op.qubits), cirq.Z.on_each(*op.qubits)]
+            if op.gate == cirq.CX
+            else op
+        )
 
     cirq.testing.assert_has_diagram(
         c_orig_with_circuit_ops,
         '''
-      [       [ 0: ───@─── ]                                                               ]
-      [ 0: ───[       │    ]────────────────────────────────────────────────────────────── ]
-      [       [ 1: ───X─── ](loops=2)['internal']                                          ]
-      [       │                                                                            ]
-      [ 1: ───#2────────────────────────────────────────────────────────────────────────── ]
-      [                                                                                    ]
-      [       [ 2: ───X─── ]                                                               ]
-0: ───[ 2: ───[       │    ]────────────────────────────────────────────────────────────── ]────────────────────────
-      [       [ 3: ───@─── ](loops=2)['internal']                                          ]
-      [       │                                                                            ]
-      [       │                                     [ 3: ───@─── ]                         ]
-      [ 3: ───#2────────────────────────────────────[       │    ]──────────────────────── ]
-      [                                             [ 4: ───X─── ](loops=2)['internal']    ]
-      [                                             │                                      ]
-      [ 4: ─────────────────────────────────────────#2──────────────────────────────────── ](loops=6)['external']
+      [       [ 0: ───@─── ]                                                           ]
+      [ 0: ───[       │    ]────────────────────────────────────────────────────────── ]
+      [       [ 1: ───X─── ](loops=2)[internal]                                        ]
+      [       │                                                                        ]
+      [ 1: ───#2────────────────────────────────────────────────────────────────────── ]
+      [                                                                                ]
+      [       [ 2: ───X─── ]                                                           ]
+0: ───[ 2: ───[       │    ]────────────────────────────────────────────────────────── ]──────────────────────
+      [       [ 3: ───@─── ](loops=2)[internal]                                        ]
+      [       │                                                                        ]
+      [       │                                   [ 3: ───@─── ]                       ]
+      [ 3: ───#2──────────────────────────────────[       │    ]────────────────────── ]
+      [                                           [ 4: ───X─── ](loops=2)[internal]    ]
+      [                                           │                                    ]
+      [ 4: ───────────────────────────────────────#2────────────────────────────────── ](loops=6)[external]
       │
-1: ───#2────────────────────────────────────────────────────────────────────────────────────────────────────────────
+1: ───#2──────────────────────────────────────────────────────────────────────────────────────────────────────
       │
-2: ───#3────────────────────────────────────────────────────────────────────────────────────────────────────────────
+2: ───#3──────────────────────────────────────────────────────────────────────────────────────────────────────
       │
-3: ───#4────────────────────────────────────────────────────────────────────────────────────────────────────────────
+3: ───#4──────────────────────────────────────────────────────────────────────────────────────────────────────
       │
-4: ───#5────────────────────────────────────────────────────────────────────────────────────────────────────────────
+4: ───#5──────────────────────────────────────────────────────────────────────────────────────────────────────
 ''',
     )
 
@@ -175,29 +175,29 @@ def test_map_operations_deep_subcircuits():
         cirq.testing.assert_has_diagram(
             unroller(c_mapped, deep=True),
             '''
-      [       [ 0: ───Z───@───Z─── ]                                                                       ]
-      [ 0: ───[           │        ]────────────────────────────────────────────────────────────────────── ]
-      [       [ 1: ───Z───X───Z─── ](loops=2)['internal']                                                  ]
-      [       │                                                                                            ]
-      [ 1: ───#2────────────────────────────────────────────────────────────────────────────────────────── ]
-      [                                                                                                    ]
-      [       [ 2: ───Z───X───Z─── ]                                                                       ]
-0: ───[ 2: ───[           │        ]────────────────────────────────────────────────────────────────────── ]────────────────────────
-      [       [ 3: ───Z───@───Z─── ](loops=2)['internal']                                                  ]
-      [       │                                                                                            ]
-      [       │                                             [ 3: ───Z───@───Z─── ]                         ]
-      [ 3: ───#2────────────────────────────────────────────[           │        ]──────────────────────── ]
-      [                                                     [ 4: ───Z───X───Z─── ](loops=2)['internal']    ]
-      [                                                     │                                              ]
-      [ 4: ─────────────────────────────────────────────────#2──────────────────────────────────────────── ](loops=6)['external']
+      [       [ 0: ───Z───@───Z─── ]                                                                   ]
+      [ 0: ───[           │        ]────────────────────────────────────────────────────────────────── ]
+      [       [ 1: ───Z───X───Z─── ](loops=2)[internal]                                                ]
+      [       │                                                                                        ]
+      [ 1: ───#2────────────────────────────────────────────────────────────────────────────────────── ]
+      [                                                                                                ]
+      [       [ 2: ───Z───X───Z─── ]                                                                   ]
+0: ───[ 2: ───[           │        ]────────────────────────────────────────────────────────────────── ]──────────────────────
+      [       [ 3: ───Z───@───Z─── ](loops=2)[internal]                                                ]
+      [       │                                                                                        ]
+      [       │                                           [ 3: ───Z───@───Z─── ]                       ]
+      [ 3: ───#2──────────────────────────────────────────[           │        ]────────────────────── ]
+      [                                                   [ 4: ───Z───X───Z─── ](loops=2)[internal]    ]
+      [                                                   │                                            ]
+      [ 4: ───────────────────────────────────────────────#2────────────────────────────────────────── ](loops=6)[external]
       │
-1: ───#2────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+1: ───#2──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
       │
-2: ───#3────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+2: ───#3──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
       │
-3: ───#4────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+3: ───#4──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
       │
-4: ───#5────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+4: ───#5──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 ''',
         )
 
@@ -205,6 +205,33 @@ def test_map_operations_deep_subcircuits():
 # pylint: enable=line-too-long
 
 
+@pytest.mark.parametrize("deep", [False, True])
+def test_map_operations_preserves_circuit_tags(deep: bool) -> None:
+    tag = "should be preserved"
+
+    def func(op: cirq.Operation, idx: int) -> cirq.Operation:
+        return cirq.Y(op.qubits[0]) if op.gate == cirq.X else op
+
+    x = cirq.X(cirq.q(0))
+    circuit = cirq.FrozenCircuit.from_moments(x, cirq.FrozenCircuit(x)).with_tags(tag)
+    mapped = cirq.map_operations(circuit, func, deep=deep)
+
+    assert mapped.tags == (tag,)
+
+
+def test_map_operations_deep_preserves_subcircuit_tags():
+    tag = "should be preserved"
+
+    def func(op: cirq.Operation, idx: int) -> cirq.Operation:
+        return cirq.Y(op.qubits[0]) if op.gate == cirq.X else op
+
+    x = cirq.X(cirq.q(0))
+    circuit = cirq.FrozenCircuit.from_moments(x, cirq.FrozenCircuit(x).with_tags(tag))
+    mapped = cirq.map_operations(circuit, func, deep=True)
+
+    assert mapped[1].operations[0].circuit.tags == (tag,)
+
+
 def test_map_operations_deep_respects_tags_to_ignore():
     q = cirq.LineQubit.range(2)
     c_nested = cirq.FrozenCircuit(cirq.CX(*q), cirq.CX(*q).with_tags("ignore"), cirq.CX(*q))
@@ -296,9 +323,9 @@ def test_unroll_circuit_op_and_variants():
     cirq.testing.assert_has_diagram(
         mapped_circuit_deep,
         '''
-0: ───[ 0: ───X─── ]────────────────────────────────────────────────────────────X───
+0: ───[ 0: ───X─── ]──────────────────────────────────────────────────────────X───
 
-1: ────────────────────[ 1: ───[ 1: ───Z───Z─── ]['<mapped_circuit_op>']─── ]───────
+1: ────────────────────[ 1: ───[ 1: ───Z───Z─── ][<mapped_circuit_op>]─── ]───────
 ''',
     )
     for unroller in [
@@ -614,11 +641,11 @@ def test_merge_operations_merges_connected_component():
     cirq.testing.assert_has_diagram(
         c_orig,
         '''
-0: ───H───@───@───H───@───X───────@───────X───X['ignore']───@───
-          │   │       │           │                         │
-1: ───H───┼───X───────@───────Y───X───@───────Y─────────────X───
+0: ───H───@───@───H───@───X───────@───────X───X[ignore]───@───
+          │   │       │           │                       │
+1: ───H───┼───X───────@───────Y───X───@───────Y───────────X───
           │                           │
-2: ───H───X───────────────────────────X─────────────────────────
+2: ───H───X───────────────────────────X───────────────────────
 ''',
     )
 
@@ -685,11 +712,11 @@ def test_merge_operations_to_circuit_op_merges_connected_component():
     cirq.testing.assert_has_diagram(
         c_orig,
         '''
-0: ───H───@───@───H───@───X───────@───────X───X['ignore']───@───
-          │   │       │           │                         │
-1: ───H───┼───X───────@───────Y───X───@───────Y─────────────X───
+0: ───H───@───@───H───@───X───────@───────X───X[ignore]───@───
+          │   │       │           │                       │
+1: ───H───┼───X───────@───────Y───X───@───────Y───────────X───
           │                           │
-2: ───H───X───────────────────────────X─────────────────────────
+2: ───H───X───────────────────────────X───────────────────────
 ''',
     )
 
@@ -704,12 +731,12 @@ def test_merge_operations_to_circuit_op_merges_connected_component():
         c_new,
         '''
                       [ 0: ───────@───H───@───X───@───X─── ]
-0: ───H───@───────────[           │       │       │        ]─────────────────────────────────X['ignore']───@───
-          │           [ 1: ───H───X───────@───Y───X─────── ]['merged']                                     │
-          │           │                                                                                    │
-1: ───────┼───────────#2─────────────────────────────────────────────────────────────@───────Y─────────────X───
-          │                                                                          │
-2: ───H───X──────────────────────────────────────────────────────────────────────────X─────────────────────────
+0: ───H───@───────────[           │       │       │        ]───────────────────────────────X[ignore]───@───
+          │           [ 1: ───H───X───────@───Y───X─────── ][merged]                                   │
+          │           │                                                                                │
+1: ───────┼───────────#2───────────────────────────────────────────────────────────@───────Y───────────X───
+          │                                                                        │
+2: ───H───X────────────────────────────────────────────────────────────────────────X───────────────────────
 ''',
     )
 
@@ -720,11 +747,11 @@ def test_merge_2q_unitaries_to_circuit_op():
     cirq.testing.assert_has_diagram(
         c_orig,
         '''
-0: ───H───@───@───H───@───X───────@───────X───X['ignore']───@───
-          │   │       │           │                         │
-1: ───H───┼───X───────@───────Y───X───@───────Y─────────────X───
+0: ───H───@───@───H───@───X───────@───────X───X[ignore]───@───
+          │   │       │           │                       │
+1: ───H───┼───X───────@───────Y───X───@───────Y───────────X───
           │                           │
-2: ───H───X───────────────────────────X─────────────────────M───
+2: ───H───X───────────────────────────X───────────────────M───
 ''',
     )
 
@@ -734,15 +761,15 @@ def test_merge_2q_unitaries_to_circuit_op():
     cirq.testing.assert_has_diagram(
         cirq.drop_empty_moments(c_new),
         '''
-      [ 0: ───H───@─── ]             [ 0: ───────@───H───@───X───@───X─── ]
-0: ───[           │    ]─────────────[           │       │       │        ]────────────────────────────────────────────X['ignore']───@───
-      [ 2: ───H───X─── ]['merged']   [ 1: ───H───X───────@───Y───X─────── ]['merged']                                                │
-      │                              │                                                                                               │
-      │                              │                                                  [ 1: ───@───Y─── ]                           │
-1: ───┼──────────────────────────────#2─────────────────────────────────────────────────[       │        ]───────────────────────────X───
-      │                                                                                 [ 2: ───X─────── ]['merged']
-      │                                                                                 │
-2: ───#2────────────────────────────────────────────────────────────────────────────────#2───────────────────────────────────────────M───''',
+      [ 0: ───H───@─── ]           [ 0: ───────@───H───@───X───@───X─── ]
+0: ───[           │    ]───────────[           │       │       │        ]────────────────────────────────────────X[ignore]───@───
+      [ 2: ───H───X─── ][merged]   [ 1: ───H───X───────@───Y───X─────── ][merged]                                            │
+      │                            │                                                                                         │
+      │                            │                                                [ 1: ───@───Y─── ]                       │
+1: ───┼────────────────────────────#2───────────────────────────────────────────────[       │        ]───────────────────────X───
+      │                                                                             [ 2: ───X─────── ][merged]
+      │                                                                             │
+2: ───#2────────────────────────────────────────────────────────────────────────────#2───────────────────────────────────────M───''',
     )
 
 

cirq/value/classical_data.py

@@ -165,13 +165,13 @@ class ClassicalDataDictionaryStore(ClassicalDataStore):
         if _channel_records is None:
             _channel_records = {}
         self._records: Dict['cirq.MeasurementKey', List[Tuple[int, ...]]] = _records
-        self._measured_qubits: Dict[
-            'cirq.MeasurementKey', List[Tuple['cirq.Qid', ...]]
-        ] = _measured_qubits
+        self._measured_qubits: Dict['cirq.MeasurementKey', List[Tuple['cirq.Qid', ...]]] = (
+            _measured_qubits
+        )
         self._channel_records: Dict['cirq.MeasurementKey', List[int]] = _channel_records
-        self._measurement_types: Dict[
-            'cirq.MeasurementKey', 'cirq.MeasurementType'
-        ] = _measurement_types
+        self._measurement_types: Dict['cirq.MeasurementKey', 'cirq.MeasurementType'] = (
+            _measurement_types
+        )
 
     @property
     def records(self) -> Mapping['cirq.MeasurementKey', List[Tuple[int, ...]]]:

cirq/value/value_equality_attr.py

@@ -70,6 +70,8 @@ class _SupportsValueEquality(Protocol):
 
 
 def _value_equality_eq(self: _SupportsValueEquality, other: _SupportsValueEquality) -> bool:
+    if other is self:
+        return True
     cls_self = self._value_equality_values_cls_()
     get_cls_other = getattr(other, '_value_equality_values_cls_', None)
     if get_cls_other is None:
@@ -91,6 +93,8 @@ def _value_equality_hash(self: _SupportsValueEquality) -> int:
 def _value_equality_approx_eq(
     self: _SupportsValueEquality, other: _SupportsValueEquality, atol: float
 ) -> bool:
+    if other is self:
+        return True
     cls_self = self._value_equality_values_cls_()
     get_cls_other = getattr(other, '_value_equality_values_cls_', None)
     if get_cls_other is None:

cirq/work/sampler.py

@@ -294,10 +294,9 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
         See docs for `cirq.Sampler.run_batch`.
         """
         params_list, repetitions = self._normalize_batch_args(programs, params_list, repetitions)
-        return [
-            await self.run_sweep_async(circuit, params=params, repetitions=repetitions)
-            for circuit, params, repetitions in zip(programs, params_list, repetitions)
-        ]
+        return await duet.pstarmap_async(
+            self.run_sweep_async, zip(programs, params_list, repetitions)
+        )
 
     def _normalize_batch_args(
         self,

cirq/work/sampler_test.py

@@ -211,6 +211,31 @@ def test_sampler_run_batch():
         assert np.array_equal(result.measurements['m'], np.array([[0], [0]], dtype='uint8'))
 
 
+@duet.sync
+async def test_run_batch_async_calls_run_sweep_asynchronously():
+    """Test run_batch_async calls run_sweep_async without waiting."""
+    finished = []
+    a = cirq.LineQubit(0)
+    circuit1 = cirq.Circuit(cirq.X(a) ** sympy.Symbol('t'), cirq.measure(a, key='m'))
+    circuit2 = cirq.Circuit(cirq.Y(a) ** sympy.Symbol('t'), cirq.measure(a, key='m'))
+    params1 = cirq.Points('t', [0.3, 0.7])
+    params2 = cirq.Points('t', [0.4, 0.6])
+    params_list = [params1, params2]
+
+    class AsyncSampler(cirq.Sampler):
+        async def run_sweep_async(self, program, params, repetitions: int = 1):
+            if params == params1:
+                await duet.sleep(0.001)
+
+            finished.append(params)
+
+    await AsyncSampler().run_batch_async(
+        [circuit1, circuit2], params_list=params_list, repetitions=[1, 2]
+    )
+
+    assert finished == list(reversed(params_list))
+
+
 def test_sampler_run_batch_default_params_and_repetitions():
     sampler = cirq.ZerosSampler()
     a = cirq.LineQubit(0)

{cirq_core-1.3.0.dev20231201141002.dist-info → cirq_core-1.4.0.dist-info}/METADATA

@@ -1,36 +1,29 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.3.0.dev20231201141002
+Version: 1.4.0
 Summary: A framework for creating, editing, and invoking Noisy Intermediate Scale Quantum (NISQ) circuits.
 Home-page: http://github.com/quantumlib/cirq
 Author: The Cirq Developers
 Author-email: cirq-dev@googlegroups.com
 License: Apache 2
-Platform: UNKNOWN
-Requires-Python: >=3.9.0
+Requires-Python: >=3.10.0
 License-File: LICENSE
-Requires-Dist: duet ~=0.2.8
+Requires-Dist: attrs
+Requires-Dist: duet >=0.2.8
 Requires-Dist: matplotlib ~=3.0
 Requires-Dist: networkx >=2.4
-Requires-Dist: numpy ~=1.16
+Requires-Dist: numpy ~=1.22
 Requires-Dist: pandas
 Requires-Dist: sortedcontainers ~=2.0
-Requires-Dist: scipy
+Requires-Dist: scipy ~=1.0
 Requires-Dist: sympy
 Requires-Dist: typing-extensions >=4.2
 Requires-Dist: tqdm
 Provides-Extra: contrib
 Requires-Dist: ply >=3.6 ; extra == 'contrib'
-Requires-Dist: pylatex ~=1.3.0 ; extra == 'contrib'
-Requires-Dist: quimb ; extra == 'contrib'
+Requires-Dist: pylatex ~=1.4 ; extra == 'contrib'
+Requires-Dist: quimb ~=1.7 ; extra == 'contrib'
 Requires-Dist: opt-einsum ; extra == 'contrib'
-Requires-Dist: autoray ; extra == 'contrib'
-Requires-Dist: numba >=0.53.0 ; extra == 'contrib'
-
-**This is a development version of Cirq-core and may be unstable.**
-
-**For the latest stable release of Cirq-core see**
-`here <https://pypi.org/project/cirq-core>`__.
 
 .. image:: https://raw.githubusercontent.com/quantumlib/Cirq/main/docs/images/Cirq_logo_color.png
   :target: https://github.com/quantumlib/cirq
@@ -47,8 +40,6 @@ Installation
 ------------
 
 To install the stable version of only **cirq-core**, use `pip install cirq-core`.
-To install the pre-release version of only **cirq-core**, use `pip install cirq-core --pre`.
-
-To get all the optional modules installed as well, you'll have to use `pip install cirq` or `pip install cirq --pre` for the pre-release version.
-
+To install the pre-release version of only **cirq-core**, use `pip install cirq-core~=1.0.dev`.
 
+To get all the optional modules installed as well, you'll have to use `pip install cirq` or `pip install cirq~=1.0.dev` for the pre-release version.