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

test/aqua/operators/test_op_construction.py

@@ -14,23 +14,26 @@
 
 """ Test Operator construction, including OpPrimitives and singletons. """
 
+
 import unittest
 from test.aqua import QiskitAquaTestCase
 import itertools
 import numpy as np
+from ddt import ddt, data
 
 from qiskit.circuit import QuantumCircuit, QuantumRegister, Instruction
 from qiskit.extensions.exceptions import ExtensionError
 from qiskit.quantum_info.operators import Operator, Pauli
-from qiskit.circuit.library import CZGate
+from qiskit.circuit.library import CZGate, ZGate
 
 from qiskit.aqua.operators import (
-    X, Y, Z, I, CX, T, H, PrimitiveOp, SummedOp, PauliOp, Minus, CircuitOp
+    X, Y, Z, I, CX, T, H, PrimitiveOp, SummedOp, PauliOp, Minus, CircuitOp, MatrixOp
 )
 
 
 # pylint: disable=invalid-name
 
+@ddt
 class TestOpConstruction(QiskitAquaTestCase):
     """Operator Construction tests."""
 
@@ -235,7 +238,7 @@ def test_circuit_permute(self):
         c_op_id = c_op_perm.permute(perm)
         self.assertEqual(c_op, c_op_id)
 
-    def test_summed_op(self):
+    def test_summed_op_reduce(self):
         """Test SummedOp"""
         sum_op = (X ^ X * 2) + (Y ^ Y)  # type: SummedOp
         with self.subTest('SummedOp test 1'):
@@ -250,7 +253,7 @@ def test_summed_op(self):
             self.assertListEqual([str(op.primitive) for op in sum_op], ['XX', 'YY', 'YY'])
             self.assertListEqual([op.coeff for op in sum_op], [2, 1, 1])
 
-        sum_op = sum_op.simplify()
+        sum_op = sum_op.collapse_summands()
         with self.subTest('SummedOp test 2-b'):
             self.assertEqual(sum_op.coeff, 1)
             self.assertListEqual([str(op.primitive) for op in sum_op], ['XX', 'YY'])
@@ -263,7 +266,7 @@ def test_summed_op(self):
             self.assertListEqual([str(op.primitive) for op in sum_op], ['XX', 'YY', 'YY', 'XX'])
             self.assertListEqual([op.coeff for op in sum_op], [2, 1, 1, 2])
 
-        sum_op = sum_op.simplify()
+        sum_op = sum_op.reduce()
         with self.subTest('SummedOp test 3-b'):
             self.assertEqual(sum_op.coeff, 1)
             self.assertListEqual([str(op.primitive) for op in sum_op], ['XX', 'YY'])
@@ -275,7 +278,7 @@ def test_summed_op(self):
             self.assertListEqual([str(op.primitive) for op in sum_op], ['XX', 'YY'])
             self.assertListEqual([op.coeff for op in sum_op], [2, 1])
 
-        sum_op = sum_op.simplify()
+        sum_op = sum_op.collapse_summands()
         with self.subTest('SummedOp test 4-b'):
             self.assertEqual(sum_op.coeff, 1)
             self.assertListEqual([str(op.primitive) for op in sum_op], ['XX', 'YY'])
@@ -288,7 +291,7 @@ def test_summed_op(self):
             self.assertListEqual([str(op.primitive) for op in sum_op], ['XX', 'YY', 'YY'])
             self.assertListEqual([op.coeff for op in sum_op], [4, 2, 1])
 
-        sum_op = sum_op.simplify()
+        sum_op = sum_op.collapse_summands()
         with self.subTest('SummedOp test 5-b'):
             self.assertEqual(sum_op.coeff, 1)
             self.assertListEqual([str(op.primitive) for op in sum_op], ['XX', 'YY'])
@@ -301,7 +304,7 @@ def test_summed_op(self):
             self.assertListEqual([str(op.primitive) for op in sum_op], ['XX', 'YY', 'XX', 'YY'])
             self.assertListEqual([op.coeff for op in sum_op], [4, 2, 2, 1])
 
-        sum_op = sum_op.simplify()
+        sum_op = sum_op.collapse_summands()
         with self.subTest('SummedOp test 6-b'):
             self.assertEqual(sum_op.coeff, 1)
             self.assertListEqual([str(op.primitive) for op in sum_op], ['XX', 'YY'])
@@ -310,11 +313,11 @@ def test_summed_op(self):
         sum_op = SummedOp([X ^ X * 2, Y ^ Y], 2)
         sum_op += sum_op
         with self.subTest('SummedOp test 7-a'):
-            self.assertEqual(sum_op.coeff, 4)
-            self.assertListEqual([str(op.primitive) for op in sum_op], ['XX', 'YY'])
-            self.assertListEqual([op.coeff for op in sum_op], [2, 1])
+            self.assertEqual(sum_op.coeff, 1)
+            self.assertListEqual([str(op.primitive) for op in sum_op], ['XX', 'YY', 'XX', 'YY'])
+            self.assertListEqual([op.coeff for op in sum_op], [4, 2, 4, 2])
 
-        sum_op = sum_op.simplify()
+        sum_op = sum_op.collapse_summands()
         with self.subTest('SummedOp test 7-b'):
             self.assertEqual(sum_op.coeff, 1)
             self.assertListEqual([str(op.primitive) for op in sum_op], ['XX', 'YY'])
@@ -326,12 +329,28 @@ def test_summed_op(self):
             self.assertListEqual([str(op.primitive) for op in sum_op], ['XX', 'YY', 'XX', 'ZZ'])
             self.assertListEqual([op.coeff for op in sum_op], [4, 2, 6, 3])
 
-        sum_op = sum_op.simplify()
+        sum_op = sum_op.collapse_summands()
         with self.subTest('SummedOp test 8-b'):
             self.assertEqual(sum_op.coeff, 1)
             self.assertListEqual([str(op.primitive) for op in sum_op], ['XX', 'YY', 'ZZ'])
             self.assertListEqual([op.coeff for op in sum_op], [10, 2, 3])
 
+    def test_summed_op_equals(self):
+        """Test corner cases of SummedOp's equals function."""
+        with self.subTest('multiplicative factor'):
+            self.assertEqual(2 * X, X + X)
+
+        with self.subTest('commutative'):
+            self.assertEqual(X + Z, Z + X)
+
+        with self.subTest('circuit and paulis'):
+            z = CircuitOp(ZGate())
+            self.assertEqual(Z + z, z + Z)
+
+        with self.subTest('matrix op and paulis'):
+            z = MatrixOp([[1, 0], [0, -1]])
+            self.assertEqual(Z + z, z + Z)
+
     def test_circuit_compose_register_independent(self):
         """Test that CircuitOp uses combines circuits independent of the register.
 
@@ -344,13 +363,14 @@ def test_circuit_compose_register_independent(self):
 
         self.assertEqual(composed.num_qubits, 2)
 
-    def test_pauli_op_hashing(self):
+    @data(Z, CircuitOp(ZGate()), MatrixOp([[1, 0], [0, -1]]))
+    def test_op_hashing(self, op):
         """Regression test against faulty set comparison.
 
         Set comparisons rely on a hash table which requires identical objects to have identical
-        hashes. Thus, the PauliOp.__hash__ should support this requirement.
+        hashes. Thus, the PrimitiveOp.__hash__ should support this requirement.
         """
-        self.assertEqual(set([2*Z]), set([2*Z]))
+        self.assertEqual(set([2 * op]), set([2 * op]))
 
 
 if __name__ == '__main__':