cirq-core 1.5.0.dev20250330074424__py3-none-any.whl → 1.5.0.dev20250331190555__py3-none-any.whl

cirq/__init__.py

@@ -533,6 +533,7 @@ from cirq.value import (
     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,
+    BitMaskKeyCondition as BitMaskKeyCondition,
     ClassicalDataDictionaryStore as ClassicalDataDictionaryStore,
     ClassicalDataStore as ClassicalDataStore,
     ClassicalDataStoreReader as ClassicalDataStoreReader,

cirq/_version.py

@@ -28,4 +28,4 @@ if sys.version_info < (3, 10, 0):  # pragma: no cover
         'of cirq (e.g. "python -m pip install cirq==1.1.*")'
     )
 
-__version__ = "1.5.0.dev20250330074424"
+__version__ = "1.5.0.dev20250331190555"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version():
-    assert cirq.__version__ == "1.5.0.dev20250330074424"
+    assert cirq.__version__ == "1.5.0.dev20250331190555"

cirq/json_resolver_cache.py

@@ -107,6 +107,7 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
         'AnyUnitaryGateFamily': cirq.AnyUnitaryGateFamily,
         'AsymmetricDepolarizingChannel': cirq.AsymmetricDepolarizingChannel,
         'BitFlipChannel': cirq.BitFlipChannel,
+        'BitMaskKeyCondition': cirq.BitMaskKeyCondition,
         'BitstringAccumulator': cirq.work.BitstringAccumulator,
         'BooleanHamiltonianGate': cirq.BooleanHamiltonianGate,
         'CCNotPowGate': cirq.CCNotPowGate,

cirq/protocols/json_serialization.py

@@ -34,6 +34,7 @@ from typing import (
     Union,
 )
 
+import attrs
 import numpy as np
 import pandas as pd
 import sympy
@@ -182,6 +183,12 @@ def dataclass_json_dict(obj: Any) -> Dict[str, Any]:
     return obj_to_dict_helper(obj, attribute_names)
 
 
+def attrs_json_dict(obj: Any) -> Dict[str, Any]:
+    """Return a dictionary suitable for `_json_dict_` from an attrs dataclass."""
+    attribute_names = [f.name for f in attrs.fields(type(obj))]
+    return obj_to_dict_helper(obj, attribute_names)
+
+
 def _json_dict_with_cirq_type(obj: Any):
     base_dict = obj._json_dict_()
     if 'cirq_type' in base_dict:

cirq/protocols/json_serialization_test.py

@@ -24,6 +24,7 @@ import warnings
 from typing import Dict, List, Optional, Tuple, Type
 from unittest import mock
 
+import attrs
 import networkx as nx
 import numpy as np
 import pandas as pd
@@ -790,3 +791,15 @@ def test_datetime():
     assert re_pst_dt == pst_dt
     assert re_pst_dt == utc_dt
     assert re_pst_dt == re_naive_dt
+
+
+@attrs.frozen
+class _TestAttrsClas:
+    name: str
+    x: int
+
+
+def test_attrs_json_dict():
+    obj = _TestAttrsClas('test', x=123)
+    js = json_serialization.attrs_json_dict(obj)
+    assert js == {'name': 'test', 'x': 123}

cirq/protocols/json_test_data/BitMaskKeyCondition.json

@@ -0,0 +1,86 @@
+[
+  {
+    "cirq_type": "BitMaskKeyCondition",
+    "key": {
+      "cirq_type": "MeasurementKey",
+      "name": "a",
+      "path": []
+    },
+    "index": 59,
+    "target_value": 0,
+    "equal_target": false,
+    "bitmask": null
+  },
+  {
+    "cirq_type": "BitMaskKeyCondition",
+    "key": {
+      "cirq_type": "MeasurementKey",
+      "name": "b",
+      "path": []
+    },
+    "index": 58,
+    "target_value": 3,
+    "equal_target": false,
+    "bitmask": null
+  },
+  {
+    "cirq_type": "BitMaskKeyCondition",
+    "key": {
+      "cirq_type": "MeasurementKey",
+      "name": "c",
+      "path": []
+    },
+    "index": 57,
+    "target_value": 0,
+    "equal_target": false,
+    "bitmask": 13
+  },
+  {
+    "cirq_type": "BitMaskKeyCondition",
+    "key": {
+      "cirq_type": "MeasurementKey",
+      "name": "d",
+      "path": []
+    },
+    "index": 56,
+    "target_value": 12,
+    "equal_target": false,
+    "bitmask": 13
+  },
+  {
+    "cirq_type": "BitMaskKeyCondition",
+    "key": {
+      "cirq_type": "MeasurementKey",
+      "name": "d",
+      "path": []
+    },
+    "index": 55,
+    "target_value": 12,
+    "equal_target": true,
+    "bitmask": 13
+  },
+  {
+    "cirq_type": "BitMaskKeyCondition",
+    "key": {
+      "cirq_type": "MeasurementKey",
+      "name": "e",
+      "path": []
+    },
+    "index": 54,
+    "target_value": 11,
+    "equal_target": true,
+    "bitmask": 11
+  },
+  {
+    "cirq_type": "BitMaskKeyCondition",
+    "key": {
+      "cirq_type": "MeasurementKey",
+      "name": "e",
+      "path": []
+    },
+    "index": 53,
+    "target_value": 9,
+    "equal_target": false,
+    "bitmask": 9
+  }
+]

cirq/protocols/json_test_data/BitMaskKeyCondition.repr

@@ -0,0 +1,7 @@
+[cirq.BitMaskKeyCondition(key=cirq.MeasurementKey(name='a'), index=59, target_value=0, equal_target=False, bitmask=None),
+ cirq.BitMaskKeyCondition(key=cirq.MeasurementKey(name='b'), index=58, target_value=3, equal_target=False, bitmask=None),
+ cirq.BitMaskKeyCondition(key=cirq.MeasurementKey(name='c'), index=57, target_value=0, equal_target=False, bitmask=13),
+ cirq.BitMaskKeyCondition(key=cirq.MeasurementKey(name='d'), index=56, target_value=12, equal_target=False, bitmask=13),
+ cirq.BitMaskKeyCondition(key=cirq.MeasurementKey(name='d'), index=55, target_value=12, equal_target=True, bitmask=13),
+ cirq.BitMaskKeyCondition(key=cirq.MeasurementKey(name='e'), index=54, target_value=11, equal_target=True, bitmask=11),
+ cirq.BitMaskKeyCondition(key=cirq.MeasurementKey(name='e'), index=53, target_value=9, equal_target=False, bitmask=9)]

cirq/value/__init__.py

@@ -35,6 +35,7 @@ from cirq.value.condition import (
     Condition as Condition,
     KeyCondition as KeyCondition,
     SympyCondition as SympyCondition,
+    BitMaskKeyCondition as BitMaskKeyCondition,
 )
 
 from cirq.value.digits import (

cirq/value/condition.py

@@ -16,6 +16,7 @@ import abc
 import dataclasses
 from typing import Any, Dict, FrozenSet, Mapping, Optional, Tuple, TYPE_CHECKING
 
+import attrs
 import sympy
 
 from cirq._compat import proper_repr
@@ -135,6 +136,112 @@ class KeyCondition(Condition):
         return f'{key}==1'
 
 
+@attrs.frozen
+class BitMaskKeyCondition(Condition):
+    """A multiqubit classical control condition with a bitmask.
+
+    The control is based on a single measurement key and allows comparing equality or inequality
+    after taking the bitwise and with a bitmask.
+
+    Examples:
+        - BitMaskKeycondition('a') -> a != 0
+        - BitMaskKeyCondition('a', bitmask=13) -> (a & 13) != 0
+        - BitMaskKeyCondition('a', bitmask=13, target_value=9) -> (a & 13) != 9
+        - BitMaskKeyCondition('a', bitmask=13, target_value=9, equal_target=True) -> (a & 13) == 9
+        - BitMaskKeyCondition.create_equal_mask('a', 13) -> (a & 13) == 13
+        - BitMaskKeyCondition.create_not_equal_mask('a', 13) -> (a & 13) != 13
+
+    The bits in the bitmask have the same order as the qubits passed to `cirq.measure(...)`. That's
+    the most significant bit corresponds to the the first (left most) qubit.
+
+    Attributes:
+        - key: Measurement key.
+        - index: integer index (same as KeyCondition.index).
+        - target_value: The value we compare with.
+        - equal_target: Whether to comapre with == or !=.
+        - bitmask: Optional bitmask to apply before doing the comparison.
+    """
+
+    key: 'cirq.MeasurementKey' = attrs.field(
+        converter=lambda x: (
+            x
+            if isinstance(x, measurement_key.MeasurementKey)
+            else measurement_key.MeasurementKey(x)
+        )
+    )
+    index: int = -1
+    target_value: int = 0
+    equal_target: bool = False
+    bitmask: Optional[int] = None
+
+    @property
+    def keys(self):
+        return (self.key,)
+
+    @staticmethod
+    def create_equal_mask(
+        key: 'cirq.MeasurementKey', bitmask: int, *, index: int = -1
+    ) -> 'BitMaskKeyCondition':
+        """Creates a condition that evaluates (meas & bitmask) == bitmask."""
+        return BitMaskKeyCondition(
+            key, index, target_value=bitmask, equal_target=True, bitmask=bitmask
+        )
+
+    @staticmethod
+    def create_not_equal_mask(
+        key: 'cirq.MeasurementKey', bitmask: int, *, index: int = -1
+    ) -> 'BitMaskKeyCondition':
+        """Creates a condition that evaluates (meas & bitmask) != bitmask."""
+        return BitMaskKeyCondition(
+            key, index, target_value=bitmask, equal_target=False, bitmask=bitmask
+        )
+
+    def replace_key(self, current: 'cirq.MeasurementKey', replacement: 'cirq.MeasurementKey'):
+        return BitMaskKeyCondition(replacement) if self.key == current else self
+
+    def __str__(self):
+        s = str(self.key) if self.index == -1 else f'{self.key}[{self.index}]'
+        if self.bitmask is not None:
+            s = f'{s} & {self.bitmask}'
+        if self.equal_target:
+            if self.bitmask is not None:
+                s = f'({s})'
+            s = f'{s} == {self.target_value}'
+        elif self.target_value != 0:
+            if self.bitmask is not None:
+                s = f'({s})'
+            s = f'{s} != {self.target_value}'
+        return s
+
+    def __repr__(self):
+        values = attrs.asdict(self)
+        parameters = ', '.join(f'{f.name}={repr(values[f.name])}' for f in attrs.fields(type(self)))
+        return f'cirq.BitMaskKeyCondition({parameters})'
+
+    def resolve(self, classical_data: 'cirq.ClassicalDataStoreReader') -> bool:
+        if self.key not in classical_data.keys():
+            raise ValueError(f'Measurement key {self.key} missing when testing classical control')
+        value = classical_data.get_int(self.key, self.index)
+        if self.bitmask is not None:
+            value &= self.bitmask
+        if self.equal_target:
+            return value == self.target_value
+        return value != self.target_value
+
+    def _json_dict_(self):
+        return json_serialization.attrs_json_dict(self)
+
+    @classmethod
+    def _from_json_dict_(cls, key, **kwargs):
+        parameter_names = [f.name for f in attrs.fields(cls)[1:]]
+        parameters = {k: kwargs[k] for k in parameter_names if k in kwargs}
+        return cls(key=key, **parameters)
+
+    @property
+    def qasm(self):
+        raise NotImplementedError()  # pragma: no cover
+
+
 @dataclasses.dataclass(frozen=True)
 class SympyCondition(Condition):
     """A classical control condition based on a sympy expression.

cirq/value/condition_test.py

@@ -193,3 +193,182 @@ def test_sympy_condition_qasm():
         ValueError, match='QASM is defined only for SympyConditions of type key == constant'
     ):
         _ = cirq.SympyCondition(sympy.Symbol('a') != 2).qasm
+
+
+@pytest.mark.parametrize(
+    ['cond', 'cond_str'],
+    [
+        (
+            cirq.BitMaskKeyCondition(
+                bitmask=None, equal_target=False, index=59, key='a', target_value=0
+            ),
+            'a[59]',
+        ),
+        (
+            cirq.BitMaskKeyCondition(
+                bitmask=None, equal_target=False, index=-1, key='a', target_value=0
+            ),
+            'a',
+        ),
+        (
+            cirq.BitMaskKeyCondition(
+                bitmask=None, equal_target=False, index=58, key='b', target_value=3
+            ),
+            'b[58] != 3',
+        ),
+        (
+            cirq.BitMaskKeyCondition(
+                bitmask=None, equal_target=False, index=-1, key='b', target_value=3
+            ),
+            'b != 3',
+        ),
+        (
+            cirq.BitMaskKeyCondition(
+                bitmask=13, equal_target=False, index=57, key='c', target_value=0
+            ),
+            'c[57] & 13',
+        ),
+        (
+            cirq.BitMaskKeyCondition(
+                bitmask=13, equal_target=False, index=-1, key='c', target_value=0
+            ),
+            'c & 13',
+        ),
+        (
+            cirq.BitMaskKeyCondition(
+                bitmask=13, equal_target=False, index=56, key='d', target_value=12
+            ),
+            '(d[56] & 13) != 12',
+        ),
+        (
+            cirq.BitMaskKeyCondition(
+                bitmask=13, equal_target=False, index=-1, key='d', target_value=12
+            ),
+            '(d & 13) != 12',
+        ),
+        (
+            cirq.BitMaskKeyCondition(
+                bitmask=13, equal_target=True, index=55, key='d', target_value=12
+            ),
+            '(d[55] & 13) == 12',
+        ),
+        (
+            cirq.BitMaskKeyCondition(
+                bitmask=13, equal_target=True, index=-1, key='d', target_value=12
+            ),
+            '(d & 13) == 12',
+        ),
+        (
+            cirq.BitMaskKeyCondition(
+                bitmask=11, equal_target=True, index=54, key='e', target_value=11
+            ),
+            '(e[54] & 11) == 11',
+        ),
+        (
+            cirq.BitMaskKeyCondition(
+                bitmask=11, equal_target=True, index=-1, key='e', target_value=11
+            ),
+            '(e & 11) == 11',
+        ),
+        (
+            cirq.BitMaskKeyCondition(
+                bitmask=9, equal_target=False, index=53, key='e', target_value=9
+            ),
+            '(e[53] & 9) != 9',
+        ),
+        (
+            cirq.BitMaskKeyCondition(
+                bitmask=9, equal_target=False, index=-1, key='e', target_value=9
+            ),
+            '(e & 9) != 9',
+        ),
+    ],
+)
+def test_bitmask_condition_str(cond: cirq.BitMaskKeyCondition, cond_str: str):
+    assert str(cond) == cond_str
+
+
+@pytest.mark.parametrize(
+    ['cond', 'value'],
+    [
+        (cirq.BitMaskKeyCondition('c', bitmask=13, target_value=9), False),
+        (cirq.BitMaskKeyCondition('d', bitmask=13, target_value=12, equal_target=True), True),
+    ],
+)
+def test_bitmask_condition_resolve(cond: cirq.BitMaskKeyCondition, value: bool):
+    resolver = cirq.ClassicalDataDictionaryStore(
+        _records={
+            cirq.MeasurementKey('c'): [(1, 0, 0, 1)],
+            cirq.MeasurementKey('d'): [(1, 0, 1, 1, 0, 0)],
+        }
+    )
+    assert cond.resolve(resolver) == value
+
+
+def test_bitmask_condition_resolve_invalid_input_raises():
+    cond = cirq.BitMaskKeyCondition('a')
+    resolver = cirq.ClassicalDataDictionaryStore(
+        _records={
+            cirq.MeasurementKey('c'): [(1, 0, 0, 1)],
+            cirq.MeasurementKey('d'): [(1, 0, 1, 1, 0, 0)],
+        }
+    )
+    with pytest.raises(ValueError):
+        _ = cond.resolve(resolver)
+
+
+@pytest.mark.parametrize(
+    'cond',
+    [
+        cirq.BitMaskKeyCondition(
+            bitmask=None, equal_target=False, index=59, key='a', target_value=0
+        ),
+        cirq.BitMaskKeyCondition(
+            bitmask=None, equal_target=False, index=-1, key='a', target_value=0
+        ),
+        cirq.BitMaskKeyCondition(
+            bitmask=None, equal_target=False, index=58, key='b', target_value=3
+        ),
+        cirq.BitMaskKeyCondition(
+            bitmask=None, equal_target=False, index=-1, key='b', target_value=3
+        ),
+        cirq.BitMaskKeyCondition(bitmask=13, equal_target=False, index=57, key='c', target_value=0),
+        cirq.BitMaskKeyCondition(bitmask=13, equal_target=False, index=-1, key='c', target_value=0),
+        cirq.BitMaskKeyCondition(
+            bitmask=13, equal_target=False, index=56, key='d', target_value=12
+        ),
+        cirq.BitMaskKeyCondition(
+            bitmask=13, equal_target=False, index=-1, key='d', target_value=12
+        ),
+        cirq.BitMaskKeyCondition(bitmask=13, equal_target=True, index=55, key='d', target_value=12),
+        cirq.BitMaskKeyCondition(bitmask=13, equal_target=True, index=-1, key='d', target_value=12),
+        cirq.BitMaskKeyCondition(bitmask=11, equal_target=True, index=54, key='e', target_value=11),
+        cirq.BitMaskKeyCondition(bitmask=11, equal_target=True, index=-1, key='e', target_value=11),
+        cirq.BitMaskKeyCondition(bitmask=9, equal_target=False, index=53, key='e', target_value=9),
+        cirq.BitMaskKeyCondition(bitmask=9, equal_target=False, index=-1, key='e', target_value=9),
+    ],
+)
+def test_bitmask_condition_repr(cond):
+    cirq.testing.assert_equivalent_repr(cond)
+
+
+def test_bitmask_condition_keys():
+    assert cirq.BitMaskKeyCondition('test').keys == ('test',)
+
+
+def test_bitmask_create_equal_mask():
+    assert cirq.BitMaskKeyCondition.create_equal_mask('a', 9) == cirq.BitMaskKeyCondition(
+        'a', equal_target=True, bitmask=9, target_value=9
+    )
+
+
+def test_bitmask_create_not_equal_mask():
+    assert cirq.BitMaskKeyCondition.create_not_equal_mask('b', 14) == cirq.BitMaskKeyCondition(
+        'b', equal_target=False, bitmask=14, target_value=14
+    )
+
+
+def test_bitmask_replace_key():
+    cond = cirq.BitMaskKeyCondition('a')
+    assert cond.replace_key('a', 'b') == cirq.BitMaskKeyCondition('b')
+    assert cond.replace_key('c', 'd') is cond

{cirq_core-1.5.0.dev20250330074424.dist-info → cirq_core-1.5.0.dev20250331190555.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.5.0.dev20250330074424
+Version: 1.5.0.dev20250331190555
 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

{cirq_core-1.5.0.dev20250330074424.dist-info → cirq_core-1.5.0.dev20250331190555.dist-info}/RECORD

@@ -1,13 +1,13 @@
-cirq/__init__.py,sha256=Qi4qkUVdT7je-13VrMLdVVcF1RPHI3nR8oTUs90l9OI,28084
+cirq/__init__.py,sha256=rUfvQDtywCak2mJQoihOSyRjGxQahK-YOv909us0w5M,28132
 cirq/_compat.py,sha256=_DknO27XngcjEidNApRsCzLUWDS4QmDk9M12BaqP5Is,29531
 cirq/_compat_test.py,sha256=0m3sYIyxRNv9jvAo6rzJ-cnbpny3KGnAByrbU7bApgQ,34720
 cirq/_doc.py,sha256=yDyWUD_2JDS0gShfGRb-rdqRt9-WeL7DhkqX7np0Nko,2879
 cirq/_import.py,sha256=TZOcGFGV9cW53VvNe8ufqOQmrlxRVP9UP0CdRdTbcBw,8401
 cirq/_import_test.py,sha256=6K_v0riZJXOXUphHNkGA8MY-JcmGlezFaGmvrNhm3OQ,1015
-cirq/_version.py,sha256=lf3dPyotWu0bDr2Kr6SWPRkNjO0fY-ta55H7ROH7fHE,1206
-cirq/_version_test.py,sha256=ifM6HMOJAlJMbW4NCopnTDb3nSRUqx7q14GckWjEqSc,147
+cirq/_version.py,sha256=4KCEx3HIsVvpwElMITJ_yy9yTOwwcnPK439KsAn3Z-k,1206
+cirq/_version_test.py,sha256=NjrWCbs0IQ6LxcRo-nkSspuVSy2P2eq3Yh-xaoht0d4,147
 cirq/conftest.py,sha256=X7yLFL8GLhg2CjPw0hp5e_dGASfvHx1-QT03aUbhKJw,1168
-cirq/json_resolver_cache.py,sha256=AaitojArEHKXoDlTWF4uM8CQUDxdVj64cA59zvrWoq4,13558
+cirq/json_resolver_cache.py,sha256=YVamU72nCUT5dG0bhAvRKVX5lXcZMNTwP3H36v-cYag,13615
 cirq/py.typed,sha256=VFSlmh_lNwnaXzwY-ZuW-C2Ws5PkuDoVgBdNCs0jXJE,63
 cirq/circuits/__init__.py,sha256=HKunqRpZoDmjy1IiK9Cn84MTGT84_PMeQ5VDCPafcWk,1335
 cirq/circuits/_block_diagram_drawer.py,sha256=XuqIQjyHc-B7TaSzuKJe9ZFwzItjxVGdmZjTDw0d2T0,9509
@@ -406,8 +406,8 @@ cirq/protocols/has_unitary_protocol_test.py,sha256=IjmJ3dqvteFUUO4FLwCTokgUvYy8H
 cirq/protocols/hash_from_pickle_test.py,sha256=YvDlLEQKZLhTaVhtHXGB4MntUhxN1Za9rQqf7ZfAfdw,4634
 cirq/protocols/inverse_protocol.py,sha256=aicyqdJVDbd-ZO-wKHA8S_5CcPl3HDhRklSSdosRdy0,4115
 cirq/protocols/inverse_protocol_test.py,sha256=pqqIU4_G4Npc9Z-SeoM9eCB2T5JRTeI02NCXhP0UtaI,2017
-cirq/protocols/json_serialization.py,sha256=zwNSm0nHBRJp5NBwOksJ3gkBVzl87Nw6ZC5b-OqvxGg,24517
-cirq/protocols/json_serialization_test.py,sha256=kspqyqpHXY_oOxW0NZPRUXDZZz1Qr-tAVtfqiTlJfys,27737
+cirq/protocols/json_serialization.py,sha256=VJCEXB9fkIZh3_d6dkh_QDxwjC3iJAlELGHsCmAMvE4,24779
+cirq/protocols/json_serialization_test.py,sha256=AU2Rdr4gpjkSK0g5LasGf0n22RrdA0MK9ruKPeUmOUo,27976
 cirq/protocols/kraus_protocol.py,sha256=9DROCafRytKDE2VNFtPBV9AGmaX7Ju4h-jPTXy8LDSk,9139
 cirq/protocols/kraus_protocol_test.py,sha256=NYVayiCaEpfvelsoR7bP57lUKn2pjFKYOiVOFHeZn9Q,5400
 cirq/protocols/measurement_key_protocol.py,sha256=vqoxjmthtmQ1nWbi7Xd4fdxFNe5y3WL7DZkQ3M_VPnc,13409
@@ -442,6 +442,8 @@ cirq/protocols/json_test_data/AsymmetricDepolarizingChannel.json,sha256=dsqeDJmj
 cirq/protocols/json_test_data/AsymmetricDepolarizingChannel.repr,sha256=yxGsJgd17f0gqjR6Czu2S4driAi0gd9YElTbtIg3EnE,51
 cirq/protocols/json_test_data/BitFlipChannel.json,sha256=4ZfpIzTz4499IaLZFj2kV2l20JUgNlANYvELa9IW5Qc,47
 cirq/protocols/json_test_data/BitFlipChannel.repr,sha256=z_s9pPlKy_giiBKhm74FH2atbyHyaQDurqFWKwV2CdY,20
+cirq/protocols/json_test_data/BitMaskKeyCondition.json,sha256=e39Vw4ZsMFshlgFfbRYK39XRHdms3eA2P38GiDAzYXY,1596
+cirq/protocols/json_test_data/BitMaskKeyCondition.repr,sha256=bg5EWWsUcYOC9Xb904GnxnCLZJXz8YTUKBNLlx_OGh8,844
 cirq/protocols/json_test_data/BitstringAccumulator.json,sha256=YewIkbw90dcbB0D0mGU5wf4obwH6nsyWO5EG9mh3rtc,5661
 cirq/protocols/json_test_data/BitstringAccumulator.repr,sha256=7jc5mO0lwMODjK4sJAI3hQeHmYyw_jIKMtsSEYN2h9Q,1260
 cirq/protocols/json_test_data/BooleanHamiltonian.json_inward,sha256=oHhPkTBsLogMKpgdAr7RKA4EJ4XNCaSStxalfN-OETQ,218
@@ -1146,15 +1148,15 @@ cirq/transformers/target_gatesets/cz_gateset.py,sha256=YPprTliaHN_0qITbFwCGr58TC
 cirq/transformers/target_gatesets/cz_gateset_test.py,sha256=dPXItC91qmmGTsMUR1Fgrgfm54p7GZuMDe9YdR1iVtk,11279
 cirq/transformers/target_gatesets/sqrt_iswap_gateset.py,sha256=_zyVEidlvZ2Grk4prWW390heLcCn9boiqRmfpBiL-PY,6278
 cirq/transformers/target_gatesets/sqrt_iswap_gateset_test.py,sha256=T1Q7TVUiVbLkqhBOaVMtZpgd_pABU157cV9zrcztaZc,14392
-cirq/value/__init__.py,sha256=gk5m8gFTJiNtiOxO3SjsidqKI5L8ZLhRxQyZCyjITqU,2899
+cirq/value/__init__.py,sha256=0OQimJUEjmT8HGPqRWYhWTEBuA9sMAD3IfwVTVbwrVc,2947
 cirq/value/abc_alt.py,sha256=aTWmYTHNFu6yD8i7HcUMfsautsGbPoKuasNFe6-Vq3Q,5997
 cirq/value/abc_alt_test.py,sha256=-N4ZZPVhkm1E5LaB2ZQEkOVObGFcbZbkdhS669cTtOg,9013
 cirq/value/angle.py,sha256=uPa6RrAF-fH4vS8DxWVfBug1FZmT0yEMXdd4VlWOaJw,3315
 cirq/value/angle_test.py,sha256=PqeTBGJw6zfain4cG8FYMobtYQsfyxLQeBu_CF5fIjg,3548
 cirq/value/classical_data.py,sha256=LFW7Q87mjg-KpuU5iJqxyDFNqre5AlHUCXbMVKwFVV4,11608
 cirq/value/classical_data_test.py,sha256=23ZraKZ-V3p-uux21bkcboQcEp81RW6VKnVIYPQc6_o,5231
-cirq/value/condition.py,sha256=ie1MBRAHkZpVdNEPAW8Ew3RnLeqAjctQlgly41vP1nU,7887
-cirq/value/condition_test.py,sha256=TViocolFwabyabjWS7-oACVI-b8vcolX9Zs_K-4b0_A,6835
+cirq/value/condition.py,sha256=QXgAsLYN6SYRGCsteMEykH-EKplFs59fGANNc9IqZWY,11997
+cirq/value/condition_test.py,sha256=RTDP4N3gGiAKX_tdpo1js0d2bK3jAfUFKXsrpN1q8CU,12913
 cirq/value/digits.py,sha256=PLpenXpyhrtEpEETVe3rMle4IKZVGL4GrW5ugThHkeA,6024
 cirq/value/digits_test.py,sha256=evx-y619LfjSN_gUO1B6K7O80X5HJmxxBPl61RrOovo,3812
 cirq/value/duration.py,sha256=ieN9IMYMAr33VdakbbkTpebs2sfniHc0RXfAD7WGZyc,10358
@@ -1206,8 +1208,8 @@ cirq/work/sampler.py,sha256=sW0RhIelGABAKbqTM58shwyyCPgf86JIv9IGdJe__js,19186
 cirq/work/sampler_test.py,sha256=mdk1J-WrvbPUYhY41VhWf9_te4DnXr_XMPcugWwc4-I,13281
 cirq/work/zeros_sampler.py,sha256=8_Ne6dBkDANtTZuql7Eb0Qg_E_P3-_gu-ybFzxTbKAQ,2356
 cirq/work/zeros_sampler_test.py,sha256=JIkpBBFPJe5Ba4142vzogyWyboG1Q1ZAm0UVGgOoZn8,3279
-cirq_core-1.5.0.dev20250330074424.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.5.0.dev20250330074424.dist-info/METADATA,sha256=unrh89yxk8w_s0_UEnxznFWlc7QvDjR-1sopaiT-8A8,4564
-cirq_core-1.5.0.dev20250330074424.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-cirq_core-1.5.0.dev20250330074424.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.5.0.dev20250330074424.dist-info/RECORD,,
+cirq_core-1.5.0.dev20250331190555.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.5.0.dev20250331190555.dist-info/METADATA,sha256=ODiWyZ5E0kLarUwUl48ul8uQBpJ7u9DmZdUM0q0GqkU,4564
+cirq_core-1.5.0.dev20250331190555.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+cirq_core-1.5.0.dev20250331190555.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.5.0.dev20250331190555.dist-info/RECORD,,