cirq-core 1.5.0.dev20250328173837__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.dev20250328173837"
+__version__ = "1.5.0.dev20250331190555"

cirq/_version_test.py

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

cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation.py

@@ -283,13 +283,13 @@ def measure_pauli_strings(
     """Measures expectation values of Pauli strings on given circuits with/without
     readout error mitigation.
 
-    This function takes a list of circuits and corresponding List[Pauli string] to measure.
-    For each circuit-List[Pauli string] pair, it:
+    This function takes a list of circuits and corresponding List[PauliString] to measure.
+    For each circuit-List[PauliString] pair, it:
     1.  Constructs circuits to measure the Pauli string expectation value by
         adding basis change moments and measurement operations.
     2.  Runs shuffled readout benchmarking on these circuits to calibrate readout errors.
     3.  Mitigates readout errors using the calibrated confusion matrices.
-    4.  Calculates and returns both error-mitigated and unmitigatedexpectation values for
+    4.  Calculates and returns both error-mitigated and unmitigated expectation values for
     each Pauli string.
 
     Args:
@@ -300,9 +300,9 @@ def measure_pauli_strings(
             Pauli strings.
         readout_repetitions: The number of repetitions for readout calibration
             in the shuffled benchmarking.
-        num_random_bitstrings: The number of random bitstrings to use in shuffled
+        num_random_bitstrings: The number of random bitstrings to use in readout
             benchmarking.
-        rng_or_seed: A random number generator or seed for the shuffled benchmarking.
+        rng_or_seed: A random number generator or seed for the readout benchmarking.
 
     Returns:
         A list of CircuitToPauliStringsMeasurementResult objects, where each object contains:

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.dev20250328173837.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.dev20250328173837
+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.dev20250328173837.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=Ut_199clANVfuVu5HEZpEsUqO6PzQzB1pWIcrO1oPIE,1206
-cirq/_version_test.py,sha256=VvRweZsRgIxxHfrrykxQ_HQ6AJRChTry_hWq4DVYpj0,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
@@ -96,7 +96,7 @@ cirq/contrib/paulistring/optimize.py,sha256=ArUWzXYpHq9SE7K9FdqsJ5WJg1ZvHs8DP6zH
 cirq/contrib/paulistring/optimize_test.py,sha256=jdZBpXIialcHQGsp8LIuIpU9M5wBQX9HgnqqiMv5l8U,3559
 cirq/contrib/paulistring/pauli_string_dag.py,sha256=vg0994h84zHIejSdwfqR-mdwmHOWWOAOOcGuStfKPdk,1106
 cirq/contrib/paulistring/pauli_string_dag_test.py,sha256=4XQ2IoXx-2g5OUU1SMCLbEvDWoGyDg9FMy3_rTTqfBk,1124
-cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation.py,sha256=U8RjZrrbUaaTADmy9K-ZbdCzcKROav25VmjHkTWsnho,15677
+cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation.py,sha256=6sX2EBxwtgZ0F3ANaJVvfO_GEedLBSzu_K8wQA2Zq7c,15674
 cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation_test.py,sha256=r2maZa_9bhuolXWn2OaSe3DucOFchIMoZrX3gWs1_l8,21435
 cirq/contrib/paulistring/pauli_string_optimize.py,sha256=81MDk6rKl0jmw7DXFkA02YmluiXLLznuuCTvca7mVoY,2815
 cirq/contrib/paulistring/pauli_string_optimize_test.py,sha256=EbgbY6cohl5vi2XCz8VzYFYn9Rv85yA7atDKE68Dp4Y,2896
@@ -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.dev20250328173837.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.5.0.dev20250328173837.dist-info/METADATA,sha256=5bJplApqA4OtjjxWgC6qICabx8PpGC5kmsrMOAeQNR0,4564
-cirq_core-1.5.0.dev20250328173837.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-cirq_core-1.5.0.dev20250328173837.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.5.0.dev20250328173837.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,,