Add support for non-hermitian operators in AerPauliExpectation

qiskit/opflow/expectations/aer_pauli_expectation.py

@@ -43,13 +43,36 @@ def convert(self, operator: OperatorBase) -> OperatorBase:
         AerSnapshot-based expectation circuits.
 
         Args:
-            operator: The operator to convert.
+            operator: The operator to convert. If it contains non-hermitian terms, apply an
+                additional step.
 
         Returns:
             The converted operator.
         """
+
         if isinstance(operator, OperatorStateFn) and operator.is_measurement:
-            return self._replace_pauli_sums(operator.primitive) * operator.coeff
+            if isinstance(operator.primitive, ListOp):
+                is_herm = all([op.is_hermitian() for op in operator.primitive.oplist])
+            else:
+                is_herm = operator.primitive.is_hermitian()
+
+            if not is_herm:
+                pauli_sum_re = (
+                    self._replace_pauli_sums(
+                        1 / 2 * (operator.primitive + operator.primitive.adjoint()).reduce()
+                    )
+                    * operator.coeff
+                )
+                pauli_sum_im = (
+                    self._replace_pauli_sums(
+                        1 / 2j * (operator.primitive - operator.primitive.adjoint()).reduce()
+                    )
+                    * operator.coeff
+                )
+                pauli_sum = (pauli_sum_re + 1j * pauli_sum_im).reduce()
+            else:
+                pauli_sum = self._replace_pauli_sums(operator.primitive) * operator.coeff
+            return pauli_sum
         elif isinstance(operator, ListOp):
             return operator.traverse(self.convert)
         else:

test/python/opflow/test_aer_pauli_expectation.py

@@ -38,6 +38,7 @@
     Y,
     Z,
     Zero,
+    MatrixOp
 )
 from qiskit.utils import QuantumInstance
 
@@ -120,6 +121,22 @@ def test_pauli_expect_state_vector(self):
 
         np.testing.assert_array_almost_equal(sampled.eval(), [0, 0, 1, -1], decimal=1)
 
+    def test_pauli_expect_non_hermitian_state_vector(self):
+        """pauli expect state vector with non hermitian operator test"""
+        states_op = ListOp([One, Zero, Plus, Minus])
+
+        op = np.zeros((2, 2))
+        op[0, 0] = 0
+        op[0, 1] = 1
+        op[1, 0] = 2
+        op[1, 1] = 3
+        op_mat = MatrixOp(op)
+
+        converted_meas = self.expect.convert(~StateFn(op_mat) @ states_op)
+        sampled = self.sampler.convert(converted_meas)
+
+        np.testing.assert_array_almost_equal(sampled.eval(), [3, 0, 3, 0], decimal=1)
+
     def test_pauli_expect_op_vector_state_vector(self):
         """pauli expect op vector state vector test"""
         paulis_op = ListOp([X, Y, Z, I])