SummedOp updates & optimization converters to use Opflow (qiskit-community/qiskit-aqua#1059)

* simplify and reduce, add equals to SummedOp, update tests

* directly use new opflow, no need to go via WPO

* update comments and docstrings

* directly use opflow

* don't do equality check in add

* directly use opflow

* change order in reduce

* fix qaoa

* add short test on summed op equality

* rm prints

* use set comparison, rename simplify to collapse_summands

* fix expected value, should be sqrt(2), not 2

* cast coeffs to complex

* add reno on equals

* fix mypy

* fix spell

* fix lint

* dont cast coefficient to complex

leads to problems if the coeff is exponentitated and not supposed to be complex

* use sum instead of reduce

* rm unused import

* move __hash__ to primitive op and base on repr

* use != over not ==

* add summed op test for different primitives

* check for opbase, not summedop

* adress changes from review

* explicitly raise an error upon ListOp input
* return identity op instead of the int 0

* fix spell

* add note that equals is not mathematically sound

Co-authored-by: Manoel Marques <[email protected]>

Author: Cryoris

qiskit/aqua/operators/list_ops/summed_op.py

@@ -14,7 +14,6 @@
 
 """ SummedOp Class """
 
-from functools import reduce
 from typing import List, Union, cast
 
 import numpy as np
@@ -72,9 +71,6 @@ def add(self, other: OperatorBase) -> OperatorBase:
         Returns:
             A ``SummedOp`` equivalent to the sum of self and other.
         """
-        if self == other:
-            return self.mul(2.0)
-
         self_new_ops = self.oplist if self.coeff == 1 \
             else [op.mul(self.coeff) for op in self.oplist]
         if isinstance(other, SummedOp):
@@ -84,10 +80,10 @@ def add(self, other: OperatorBase) -> OperatorBase:
             other_new_ops = [other]
         return SummedOp(self_new_ops + other_new_ops)
 
-    def simplify(self) -> 'SummedOp':
+    def collapse_summands(self) -> 'SummedOp':
         """Return Operator by simplifying duplicate operators.
 
-        E.g., ``SummedOp([2 * X ^ Y, X ^ Y]).simplify() -> SummedOp([3 * X ^ Y])``.
+        E.g., ``SummedOp([2 * X ^ Y, X ^ Y]).collapse_summands() -> SummedOp([3 * X ^ Y])``.
 
         Returns:
             A simplified ``SummedOp`` equivalent to self.
@@ -113,11 +109,23 @@ def simplify(self) -> 'SummedOp':
                     coeffs.append(self.coeff)
         return SummedOp([op * coeff for op, coeff in zip(oplist, coeffs)])  # type: ignore
 
-    # Try collapsing list or trees of Sums.
     # TODO be smarter about the fact that any two ops in oplist could be evaluated for sum.
     def reduce(self) -> OperatorBase:
-        reduced_ops = [op.reduce() for op in self.oplist]
-        reduced_ops = reduce(lambda x, y: x.add(y), reduced_ops) * self.coeff
+        """Try collapsing list or trees of sums.
+
+        Tries to sum up duplicate operators and reduces the operators
+        in the sum.
+
+        Returns:
+            A collapsed version of self, if possible.
+        """
+        # reduce constituents
+        reduced_ops = sum(op.reduce() for op in self.oplist) * self.coeff
+
+        # group duplicate operators
+        if isinstance(reduced_ops, SummedOp):
+            reduced_ops = reduced_ops.collapse_summands()
+
         if isinstance(reduced_ops, SummedOp) and len(reduced_ops.oplist) == 1:
             return reduced_ops.oplist[0]
         else:
@@ -142,3 +150,49 @@ def to_legacy_op(self, massive: bool = False) -> LegacyBaseOperator:
             coeff = cast(float, self.coeff)
 
         return self.combo_fn(legacy_ops) * coeff
+
+    def equals(self, other: OperatorBase) -> bool:
+        """Check if other is equal to self.
+
+        Note:
+            This is not a mathematical check for equality.
+            If ``self`` and ``other`` implement the same operation but differ
+            in the representation (e.g. different type of summands)
+            ``equals`` will evaluate to ``False``.
+
+        Args:
+            other: The other operator to check for equality.
+
+        Returns:
+            True, if other and self are equal, otherwise False.
+
+        Examples:
+            >>> from qiskit.aqua.operators import X, Z
+            >>> 2 * X == X + X
+            True
+            >>> X + Z == Z + X
+            True
+        """
+        self_reduced, other_reduced = self.reduce(), other.reduce()
+        if not isinstance(other_reduced, type(self_reduced)):
+            return False
+
+        # check if reduced op is still a SummedOp
+        if not isinstance(self_reduced, SummedOp):
+            return self_reduced == other_reduced
+
+        self_reduced = cast(SummedOp, self_reduced)
+        other_reduced = cast(SummedOp, other_reduced)
+        if len(self_reduced.oplist) != len(other_reduced.oplist):
+            return False
+
+        # absorb coeffs into the operators
+        if self_reduced.coeff != 1:
+            self_reduced = SummedOp(
+                [op * self_reduced.coeff for op in self_reduced.oplist])  # type: ignore
+        if other_reduced.coeff != 1:
+            other_reduced = SummedOp(
+                [op * other_reduced.coeff for op in other_reduced.oplist])  # type: ignore
+
+        # compare independent of order
+        return set(self_reduced) == set(other_reduced)

qiskit/aqua/operators/primitive_ops/pauli_op.py

@@ -231,10 +231,6 @@ def exp_i(self) -> OperatorBase:
             from ..evolutions.evolved_op import EvolvedOp
             return EvolvedOp(self)
 
-    def __hash__(self) -> int:
-        # Need this to be able to easily construct AbelianGraphs
-        return hash(str(self))
-
     def commutes(self, other_op: OperatorBase) -> bool:
         """ Returns whether self commutes with other_op.
 

qiskit/aqua/operators/primitive_ops/primitive_op.py

@@ -198,6 +198,9 @@ def log_i(self, massive: bool = False) -> OperatorBase:
     def __str__(self) -> str:
         raise NotImplementedError
 
+    def __hash__(self) -> int:
+        return hash(repr(self))
+
     def __repr__(self) -> str:
         return "{}({}, coeff={})".format(type(self).__name__, repr(self.primitive), self.coeff)