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

cirq/value/classical_data.py

@@ -15,6 +15,7 @@
 import abc
 import enum
 from typing import Dict, List, Mapping, Optional, Sequence, Tuple, TYPE_CHECKING
+
 from typing_extensions import Self
 
 from cirq.value import digits, value_equality_attr

cirq/value/condition.py

@@ -14,8 +14,9 @@
 
 import abc
 import dataclasses
-from typing import Mapping, Tuple, TYPE_CHECKING, FrozenSet
+from typing import Any, Dict, FrozenSet, Mapping, Optional, Tuple, TYPE_CHECKING
 
+import attrs
 import sympy
 
 from cirq._compat import proper_repr
@@ -47,6 +48,9 @@ class Condition(abc.ABC):
     def qasm(self):
         """Returns the qasm of this condition."""
 
+    def _qasm_(self, args: 'cirq.QasmArgs', **kwargs) -> Optional[str]:
+        return self.qasm
+
     def _with_measurement_key_mapping_(self, key_map: Mapping[str, str]) -> 'cirq.Condition':
         condition = self
         for k in self.keys:
@@ -115,6 +119,128 @@ class KeyCondition(Condition):
     def qasm(self):
         raise ValueError('QASM is defined only for SympyConditions of type key == constant.')
 
+    def _qasm_(self, args: 'cirq.QasmArgs', **kwargs) -> Optional[str]:
+        args.validate_version('2.0', '3.0')
+        key_str = str(self.key)
+        if key_str not in args.meas_key_id_map:
+            raise ValueError(f'Key "{key_str}" not in QasmArgs.meas_key_id_map.')
+        key = args.meas_key_id_map[key_str]
+        # QASM 3.0 supports !=, so we return it directly.
+        if args.version == '3.0':
+            return f'{key}!=0'
+        # QASM 2.0 only has == operator, so we must limit to single-bit measurement keys == 1.
+        if key not in args.meas_key_bitcount:
+            raise ValueError(f'Key "{key}" not in QasmArgs.meas_key_bitcount.')
+        if args.meas_key_bitcount[str(key)] != 1:
+            raise ValueError('QASM is defined only for single-bit classical conditions.')
+        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()
+
 
 @dataclasses.dataclass(frozen=True)
 class SympyCondition(Condition):
@@ -123,6 +249,12 @@ class SympyCondition(Condition):
     This condition resolves to True iff the sympy expression resolves to a
     truthy value (i.e. `bool(x) == True`) when the measurement keys are
     substituted in as the free variables.
+
+    `sympy.IndexedBase` can be used for bitwise conditions. For example, the
+    following will create a condition that is controlled by the XOR of the
+    first two bits (big-endian) of measurement 'a'.
+    >>> a = sympy.IndexedBase('a')
+    >>> cond = cirq.SympyCondition(sympy.Xor(a[0], a[1]))
     """
 
     expr: sympy.Basic
@@ -132,6 +264,9 @@ class SympyCondition(Condition):
         return tuple(
             measurement_key.MeasurementKey.parse_serialized(symbol.name)
             for symbol in self.expr.free_symbols
+            if isinstance(symbol, sympy.Symbol)
+            # For bitwise ops, both Symbol ('a') and Indexed ('a[0]') are returned. We only want to
+            # keep the former here.
         )
 
     def replace_key(self, current: 'cirq.MeasurementKey', replacement: 'cirq.MeasurementKey'):
@@ -148,8 +283,19 @@ class SympyCondition(Condition):
         if missing:
             raise ValueError(f'Measurement keys {missing} missing when testing classical control')
 
-        replacements = {str(k): classical_data.get_int(k) for k in self.keys}
-        return bool(self.expr.subs(replacements))
+        replacements: Dict[str, Any] = {}
+        for symbol in self.expr.free_symbols:
+            if isinstance(symbol, sympy.Symbol):
+                name = symbol.name
+                key = measurement_key.MeasurementKey.parse_serialized(name)
+                replacements[str(key)] = classical_data.get_int(key)
+        for symbol in self.expr.free_symbols:
+            if isinstance(symbol, sympy.Indexed):
+                name = symbol.base.name
+                key = measurement_key.MeasurementKey.parse_serialized(name)
+                replacements[str(key)] = tuple(classical_data.get_digits(key))
+        value = self.expr.subs(replacements)
+        return bool(value)
 
     def _json_dict_(self):
         return json_serialization.dataclass_json_dict(self)

cirq/value/condition_test.py

@@ -71,6 +71,35 @@ def test_key_condition_qasm():
         _ = cirq.KeyCondition(cirq.MeasurementKey('a')).qasm
 
 
+def test_key_condition_qasm_protocol():
+    cond = cirq.KeyCondition(cirq.MeasurementKey('a'))
+    args = cirq.QasmArgs(meas_key_id_map={'a': 'm_a'}, meas_key_bitcount={'m_a': 1})
+    qasm = cirq.qasm(cond, args=args)
+    assert qasm == 'm_a==1'
+
+
+def test_key_condition_qasm_protocol_v3():
+    cond = cirq.KeyCondition(cirq.MeasurementKey('a'))
+    args = cirq.QasmArgs(meas_key_id_map={'a': 'm_a'}, version='3.0')
+    qasm = cirq.qasm(cond, args=args)
+    assert qasm == 'm_a!=0'
+
+
+def test_key_condition_qasm_protocol_invalid_args():
+    cond = cirq.KeyCondition(cirq.MeasurementKey('a'))
+    args = cirq.QasmArgs()
+    with pytest.raises(ValueError, match='Key "a" not in QasmArgs.meas_key_id_map.'):
+        _ = cirq.qasm(cond, args=args)
+    args = cirq.QasmArgs(meas_key_id_map={'a': 'm_a'})
+    with pytest.raises(ValueError, match='Key "m_a" not in QasmArgs.meas_key_bitcount.'):
+        _ = cirq.qasm(cond, args=args)
+    args = cirq.QasmArgs(meas_key_id_map={'a': 'm_a'}, meas_key_bitcount={'m_a': 2})
+    with pytest.raises(
+        ValueError, match='QASM is defined only for single-bit classical conditions.'
+    ):
+        _ = cirq.qasm(cond, args=args)
+
+
 def test_sympy_condition_with_keys():
     c = init_sympy_condition.replace_key(key_a, key_b)
     assert c.keys == (key_b,)
@@ -111,6 +140,52 @@ def test_sympy_condition_resolve():
         _ = resolve({'0:b': [[1]]})
 
 
+def test_sympy_indexed_condition():
+    a = sympy.IndexedBase('a')
+    cond = cirq.SympyCondition(sympy.Xor(a[0], a[1]))
+    assert cond.keys == (cirq.MeasurementKey('a'),)
+    assert str(cond) == 'a[0] ^ a[1]'
+
+    def resolve(records):
+        classical_data = cirq.ClassicalDataDictionaryStore(_records=records)
+        return cond.resolve(classical_data)
+
+    assert not resolve({'a': [(0, 0)]})
+    assert resolve({'a': [(1, 0)]})
+    assert resolve({'a': [(0, 1)]})
+    assert not resolve({'a': [(1, 1)]})
+    assert resolve({'a': [(0, 1, 0)]})
+    assert resolve({'a': [(0, 1, 1)]})
+    assert not resolve({'a': [(1, 1, 0)]})
+    assert not resolve({'a': [(1, 1, 1)]})
+    with pytest.raises(IndexError):
+        assert resolve({'a': [()]})
+    with pytest.raises(IndexError):
+        assert resolve({'a': [(0,)]})
+    with pytest.raises(IndexError):
+        assert resolve({'a': [(1,)]})
+
+
+def test_sympy_indexed_condition_qudits():
+    a = sympy.IndexedBase('a')
+    cond = cirq.SympyCondition(sympy.And(a[1] >= 2, a[2] <= 3))
+    assert cond.keys == (cirq.MeasurementKey('a'),)
+    assert str(cond) == '(a[1] >= 2) & (a[2] <= 3)'
+
+    def resolve(records):
+        classical_data = cirq.ClassicalDataDictionaryStore(_records=records)
+        return cond.resolve(classical_data)
+
+    assert not resolve({'a': [(0, 0, 0)]})
+    assert not resolve({'a': [(0, 1, 0)]})
+    assert resolve({'a': [(0, 2, 0)]})
+    assert resolve({'a': [(0, 3, 0)]})
+    assert not resolve({'a': [(0, 0, 4)]})
+    assert not resolve({'a': [(0, 1, 4)]})
+    assert not resolve({'a': [(0, 2, 4)]})
+    assert not resolve({'a': [(0, 3, 4)]})
+
+
 def test_sympy_condition_qasm():
     # Measurements get prepended with "m_", so the condition needs to be too.
     assert cirq.SympyCondition(sympy.Eq(sympy.Symbol('a'), 2)).qasm == 'm_a==2'
@@ -118,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/value/digits.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import List, Iterable, Any, Union, Optional, overload
+from typing import Any, Iterable, List, Optional, overload, Union
 
 
 def big_endian_bits_to_int(bits: Iterable[Any]) -> int:

cirq/value/duration.py

@@ -13,14 +13,14 @@
 # limitations under the License.
 """A typed time delta that supports picosecond accuracy."""
 
-from typing import AbstractSet, Any, Dict, Optional, Tuple, TYPE_CHECKING, Union, List
 import datetime
+from typing import AbstractSet, Any, Dict, List, Optional, Tuple, TYPE_CHECKING, Union
 
-import sympy
 import numpy as np
+import sympy
 
 from cirq import protocols
-from cirq._compat import proper_repr, cached_method
+from cirq._compat import cached_method, proper_repr
 from cirq._doc import document
 
 if TYPE_CHECKING:
@@ -165,7 +165,7 @@ class Duration:
         if other_duration is not None:
             return self.total_picos() / other_duration.total_picos()
 
-        return NotImplemented
+        return NotImplemented  # pragma: no cover
 
     def __eq__(self, other):
         other = _attempt_duration_like_to_duration(other)

cirq/value/duration_test.py

@@ -13,9 +13,10 @@
 # limitations under the License.
 
 from datetime import timedelta
+
+import numpy as np
 import pytest
 import sympy
-import numpy as np
 
 import cirq
 from cirq.value import Duration