Created SumOfProducts subclass of ControlValues

cirq-core/cirq/__init__.py

@@ -301,6 +301,7 @@
     SQRT_ISWAP_INV,
     SWAP,
     SwapPowGate,
+    SumOfProducts,
     T,
     TaggedOperation,
     ThreeQubitDiagonalGate,

cirq-core/cirq/json_resolver_cache.py

@@ -213,6 +213,7 @@ def _symmetricalqidpair(qids):
         'SqrtIswapTargetGateset': cirq.SqrtIswapTargetGateset,
         'StabilizerStateChForm': cirq.StabilizerStateChForm,
         'StatePreparationChannel': cirq.StatePreparationChannel,
+        'SumOfProducts': cirq.SumOfProducts,
         'SwapPowGate': cirq.SwapPowGate,
         'SympyCondition': cirq.SympyCondition,
         'TaggedOperation': cirq.TaggedOperation,

cirq-core/cirq/ops/__init__.py

@@ -210,4 +210,4 @@
 
 from cirq.ops.state_preparation_channel import StatePreparationChannel
 
-from cirq.ops.control_values import AbstractControlValues, ProductOfSums
+from cirq.ops.control_values import AbstractControlValues, ProductOfSums, SumOfProducts

cirq-core/cirq/ops/control_values.py

@@ -180,3 +180,80 @@ def __and__(self, other: AbstractControlValues) -> 'ProductOfSums':
                 f'And operation not supported between types ProductOfSums and {type(other)}'
             )
         return type(self)(self._internal_representation + other._internal_representation)
+
+
+@dataclass(frozen=True, eq=False)
+class SumOfProducts(AbstractControlValues):
+    """SumOfProducts represents control values in a form of a list or products.
+
+    SumOfProducts allows the creation of control values combinations that
+    can't be factored as the product of independent expressions (e.g. XOR)
+
+
+    Examples:
+        xor = SumOfProducts(((0, 1), (1, 0)))   # xor of two bits.
+        nand =  SumOfProducts(((0, 0), (0, 1), (1, 0))) # nand of two bits
+    """
+
+    _internal_representation: Tuple[Tuple[int, ...], ...]
+
+    def _identifier(self) -> Tuple[Tuple[int, ...], ...]:
+        return self._internal_representation
+
+    def _expand(self) -> Iterator[Tuple[int, ...]]:
+        """Returns the combinations tracked by the object."""
+        self = cast('SumOfProducts', self)
+        for c in self._internal_representation:
+            yield c
+
+    def __repr__(self) -> str:
+        return f'cirq.SumOfProducts({str(self._identifier())})'
+
+    def _number_variables(self) -> int:
+        return len(self._internal_representation[0])
+
+    def __len__(self) -> int:
+        return self._number_variables()
+
+    def __hash__(self) -> int:
+        return hash(self._internal_representation)
+
+    def validate(self, qid_shapes: Union[Tuple[int, ...], List[int]]) -> None:
+        for vals in self._internal_representation:
+            if len(qid_shapes) != len(vals):
+                raise ValueError(
+                    f'number of values in product {vals} doesn\'t  equal number'
+                    f' of qubits(={len(qid_shapes)})'
+                )
+
+            for i, v in enumerate(vals):
+                if not (0 <= v and v < qid_shapes[i]):
+                    raise ValueError(
+                        f'Control values <{v}> in combination {vals} is outside'
+                        f' of range for control qubit number <{i}>.'
+                    )
+
+    def _are_ones(self) -> bool:
+        return frozenset(self._internal_representation) == {(1,) * self._number_variables()}
+
+    def diagram_repr(self) -> str:
+        return NotImplemented
+
+    def __getitem__(
+        self, key: Union[int, slice]
+    ) -> Union['AbstractControlValues', Tuple[int, ...]]:
+        return NotImplemented
+
+    def _json_dict_(self) -> Dict[str, Any]:
+        return {'_internal_representation': self._internal_representation}
+
+    def __and__(self, other: AbstractControlValues) -> 'SumOfProducts':
+        if not isinstance(other, SumOfProducts):
+            raise TypeError(
+                f'And operation not supported between types SumOfProducts and {type(other)}'
+            )
+        combined = map(
+            lambda p: tuple(itertools.chain(*p)),
+            itertools.product(self._internal_representation, other._internal_representation),
+        )
+        return SumOfProducts(tuple(combined))

cirq-core/cirq/ops/control_values_test.py

@@ -25,22 +25,53 @@ def test_init_productOfSum():
         ((((0, 1), (1, 0))), {(0, 0), (0, 1), (1, 0), (1, 1)}),
     ]
     for control_values, want in tests:
-        print(control_values)
         got = {c for c in cv.ProductOfSums(control_values)}
         eq.add_equality_group(got, want)
 
 
+def test_init_SumOfProducts():
+    eq = cirq.testing.EqualsTester()
+    tests = [
+        (((1,),), {(1,)}),
+        (((0, 1), (1, 0)), {(0, 1), (1, 0)}),  # XOR
+        (((0, 0), (0, 1), (1, 0)), {(0, 0), (0, 1), (1, 0)}),  # NAND
+    ]
+    for control_values, want in tests:
+        got = {c for c in cv.SumOfProducts(control_values)}
+        eq.add_equality_group(got, want)
+
+
 def test_and_operation():
     eq = cirq.testing.EqualsTester()
-    originals = [((1,),), ((0, 1), (1,)), (((0, 1), (1, 0)))]
-    for control_values1 in originals:
-        for control_values2 in originals:
+    product_of_sums_data = [((1,),), ((0, 1), (1,)), (((0, 1), (1, 0)))]
+    for control_values1 in product_of_sums_data:
+        for control_values2 in product_of_sums_data:
             control_vals1 = cv.ProductOfSums(control_values1)
             control_vals2 = cv.ProductOfSums(control_values2)
             want = [v1 + v2 for v1 in control_vals1 for v2 in control_vals2]
             got = [c for c in control_vals1 & control_vals2]
             eq.add_equality_group(got, want)
 
+    sum_of_products_data = [((1,),), ((0, 1),), ((0, 0), (0, 1), (1, 0))]
+    eq = cirq.testing.EqualsTester()
+    for control_values1 in sum_of_products_data:
+        for control_values2 in sum_of_products_data:
+            control_vals1 = cv.SumOfProducts(control_values1)
+            control_vals2 = cv.SumOfProducts(control_values2)
+            want = [v1 + v2 for v1 in control_vals1 for v2 in control_vals2]
+            got = [c for c in control_vals1 & control_vals2]
+            eq.add_equality_group(got, want)
+
+    with pytest.raises(TypeError):
+        pos = cv.ProductOfSums(product_of_sums_data[0])
+        sop = cv.SumOfProducts(sum_of_products_data[0])
+        _ = pos & sop
+
+    with pytest.raises(TypeError):
+        pos = cv.ProductOfSums(product_of_sums_data[0])
+        sop = cv.SumOfProducts(sum_of_products_data[0])
+        _ = sop & pos
+
 
 def test_and_supported_types():
     CV = cv.ProductOfSums((1,))
@@ -52,3 +83,47 @@ def test_repr():
     product_of_sums_data = [((1,),), ((0, 1), (1,)), (((0, 1), (1, 0)))]
     for t in map(cv.ProductOfSums, product_of_sums_data):
         cirq.testing.assert_equivalent_repr(t)
+
+    sum_of_products_data = [((1,),), ((0, 1)), ((0, 0), (0, 1), (1, 0))]
+
+    for t in map(cv.SumOfProducts, sum_of_products_data):
+        cirq.testing.assert_equivalent_repr(t)
+
+
+def test_validate():
+    control_val = cv.SumOfProducts(((1, 2), (0, 1)))
+
+    _ = control_val.validate([2, 3])
+
+    with pytest.raises(ValueError):
+        _ = control_val.validate([2, 2])
+
+    # number of qubits != number of control values.
+    with pytest.raises(ValueError):
+        _ = control_val.validate([2])
+
+
+def test_len():
+    data = [((1,),), ((0, 1),), ((0, 0), (0, 1), (1, 0))]
+    for vals in data:
+        c = cv.SumOfProducts(vals)
+        assert len(c) == len(vals[0])
+
+
+def test_hash():
+    data = [((1,),), ((0, 1),), ((0, 0), (0, 1), (1, 0))]
+    assert len(set(map(hash, map(cv.SumOfProducts, data)))) == 3
+
+
+def test_are_ones():
+    data = [((1,),), ((0, 1),), ((0, 0), (0, 1), (1, 0)), ((1, 1, 1, 1),)]
+    are_ones = [True, False, False]
+    for vals, want in zip(data, are_ones):
+        c = cv.SumOfProducts(vals)
+        assert c._are_ones() == want
+
+
+def test_sum_of_products_unsupported():
+    c = cv.SumOfProducts(((1,),))
+    assert c.diagram_repr() == NotImplemented
+    assert c[0] == NotImplemented

cirq-core/cirq/protocols/json_test_data/SumOfProducts.json

@@ -0,0 +1,4 @@
+{
+  "_internal_representation": [[1, 0], [1, 2]],
+  "cirq_type": "SumOfProducts"
+}

cirq-core/cirq/protocols/json_test_data/SumOfProducts.repr

@@ -0,0 +1 @@
+cirq.SumOfProducts([[1, 0], [1, 2]])