Add SparsePauliOp converter

pennylane_qiskit/converter.py

@@ -26,6 +26,7 @@
 from qiskit.circuit.controlflow.switch_case import _DefaultCaseType
 from qiskit.circuit.library import GlobalPhaseGate
 from qiskit.exceptions import QiskitError
+from qiskit.quantum_info import SparsePauliOp
 from sympy import lambdify
 
 import pennylane as qml
@@ -562,6 +563,74 @@ def load_qasm_from_file(file: str):
     return load(QuantumCircuit.from_qasm_file(file))
 
 
+def convert_sparse_pauli_op_to_pl(
+    sparse_op: SparsePauliOp,
+    params: Any = None,
+) -> qml.operation.Operator:
+    """Converts a Qiskit SparsePauliOp into a PennyLane operator.
+
+    Args:
+        sparse_op (qiskit.quantum_info.SparsePauliOp): the SparsePauliOp to be converted
+        params (Any): optional assignment of coefficient values for the SparsePauliOp; see the
+            `Qiskit documentation <https://docs.quantum.ibm.com/api/qiskit/qiskit.quantum_info.SparsePauliOp#assign_parameters>`__
+            to learn more about the expected format of these parameters
+
+    Returns:
+        pennylane.operation.Operator: The equivalent PennyLane operator.
+
+    .. note::
+
+        The order in which Pauli operations appear in each SparsePauliOp term is the reverse of how
+        they are applied in the PennyLane operator. This is consistent with the iteration order of a
+        Pauli term in Qiskit.
+
+    **Example**
+
+    Consider the following script which creates a Qiskit ``SparsePauliOp``:
+
+    .. code-block:: python
+
+        import numpy as np
+        from qiskit.circuit import Parameter
+        from qiskit.quantum_info import SparsePauliOp
+
+        a, b, c = [Parameter(var) for var in "abc"]
+        qiskit_op = SparsePauliOp(["II", "XZ", "YX"], np.array([a, b, c]))
+
+    The ``SparsePauliOp`` has three coefficients (parameters):
+
+    >>> qiskit_op
+    SparsePauliOp(['II', 'XZ', 'YX'],
+              coeffs=[ParameterExpression(1.0*a), ParameterExpression(1.0*b),
+     ParameterExpression(1.0*c)])
+
+    Now, to convert the ``SparsePauliOp`` into a PennyLane operator, run:
+
+    >>> from pennylane_qiskit.converter import convert_sparse_pauli_op_to_pl
+    >>> convert_sparse_pauli_op_to_pl(qiskit_op, {a: 2, b: 3, c: 4})
+    ((2+0j)*(Identity(wires=[0, 1])))
+    + ((3+0j)*(PauliX(wires=[1]) @ PauliZ(wires=[0])))
+    + ((4+0j)*(PauliY(wires=[1]) @ PauliX(wires=[0])))
+    """
+    if params:
+        sparse_op = sparse_op.assign_parameters(params)
+
+    op_map = {"X": qml.PauliX, "Y": qml.PauliY, "Z": qml.PauliZ, "I": qml.Identity}
+
+    coeffs = sparse_op.coeffs
+    if ParameterExpression in [type(c) for c in coeffs]:
+        raise RuntimeError(f"Not all parameter expressions are assigned in coeffs {coeffs}")
+
+    qiskit_terms = sparse_op.paulis
+    pl_terms = []
+
+    for term in qiskit_terms:
+        operators = [op_map[str(op)](wire) for wire, op in enumerate(term)]
+        pl_terms.append(qml.prod(*operators).simplify())
+
+    return qml.dot(coeffs, pl_terms)
+
+
 # pylint:disable=fixme, protected-access
 def _conditional_funcs(ops, cargs, operation_class, branch_funcs, ctrl_flow_type):
     """Builds the conditional functions for Controlled flows

tests/test_converter.py

@@ -1,16 +1,17 @@
-import math
 import sys
 
 import pytest
 from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
 from qiskit.circuit import library as lib
 from qiskit.circuit import Parameter, ParameterVector
-from qiskit.exceptions import QiskitError
-from qiskit.quantum_info.operators import Operator
 from qiskit.circuit.library import DraperQFTAdder
+from qiskit.exceptions import QiskitError
+from qiskit.quantum_info import SparsePauliOp
+
 import pennylane as qml
 from pennylane import numpy as np
 from pennylane_qiskit.converter import (
+    convert_sparse_pauli_op_to_pl,
     load,
     load_qasm,
     load_qasm_from_file,
@@ -1672,3 +1673,100 @@ def circuit_loaded_qiskit_circuit():
             return qml.expval(qml.PauliZ(0))
 
         assert circuit_loaded_qiskit_circuit() == circuit_native_pennylane()
+
+
+class TestConvertSparsePauliOp:
+    """Tests for the :func:`convert_sparse_pauli_op_to_pl()` function."""
+
+    @pytest.mark.parametrize(
+        "sparse_pauli_op, want_op",
+        [
+            (
+                SparsePauliOp("I"),
+                qml.Identity(wires=0),
+            ),
+            (
+                SparsePauliOp("XYZ"),
+                qml.prod(qml.PauliZ(wires=0), qml.PauliY(wires=1), qml.PauliX(wires=2)),
+            ),
+            (
+                SparsePauliOp(["XY", "ZX"]),
+                qml.sum(
+                    qml.prod(qml.PauliX(wires=1), qml.PauliY(wires=0)),
+                    qml.prod(qml.PauliZ(wires=1), qml.PauliX(wires=0)),
+                )
+            ),
+        ]
+    )
+    def test_convert_with_default_coefficients(self, sparse_pauli_op, want_op):
+        """Tests that a SparsePauliOp can be converted into a PennyLane operator with the default
+        coefficients.
+        """
+        have_op = convert_sparse_pauli_op_to_pl(sparse_pauli_op)
+        assert qml.equal(have_op, want_op)
+
+    @pytest.mark.parametrize(
+        "sparse_pauli_op, want_op",
+        [
+            (
+                SparsePauliOp("I", coeffs=[2]),
+                qml.s_prod(2, qml.Identity(wires=0)),
+            ),
+            (
+                SparsePauliOp(["XY", "ZX"], coeffs=[3, 7]),
+                qml.sum(
+                    qml.s_prod(3, qml.prod(qml.PauliX(wires=1), qml.PauliY(wires=0))),
+                    qml.s_prod(7, qml.prod(qml.PauliZ(wires=1), qml.PauliX(wires=0))),
+                )
+            ),
+        ]
+    )
+    def test_convert_with_literal_coefficients(self, sparse_pauli_op, want_op):
+        """Tests that a SparsePauliOp can be converted into a PennyLane operator with literal
+        coefficient values.
+        """
+        have_op = convert_sparse_pauli_op_to_pl(sparse_pauli_op)
+        assert qml.equal(have_op, want_op)
+
+
+    def test_convert_with_parameter_coefficients(self):
+        """Tests that a SparsePauliOp can be converted into a PennyLane operator by assigning values
+        to each parameterized coefficient.
+        """
+        a, b = [Parameter(var) for var in "ab"]
+        sparse_pauli_op = SparsePauliOp(["XY", "ZX"], coeffs=[a, b])
+
+        have_op = convert_sparse_pauli_op_to_pl(sparse_pauli_op, params={a: 3, b: 7})
+        want_op = qml.sum(
+            qml.s_prod(3, qml.prod(qml.PauliX(wires=1), qml.PauliY(wires=0))),
+            qml.s_prod(7, qml.prod(qml.PauliZ(wires=1), qml.PauliX(wires=0))),
+        )
+        assert qml.equal(have_op, want_op)
+
+    def test_convert_too_few_coefficients(self):
+        """Tests that a RuntimeError is raised if an attempt is made to convert a SparsePauliOp into
+        a PennyLane operator without assigning values for all parameterized coefficients.
+        """
+        a, b = [Parameter(var) for var in "ab"]
+        sparse_pauli_op = SparsePauliOp(["XY", "ZX"], coeffs=[a, b])
+
+        match = (
+            "Not all parameter expressions are assigned in coeffs "
+            r"\[\(3\+0j\) ParameterExpression\(1\.0\*b\)\]"
+        )
+        with pytest.raises(RuntimeError, match=match):
+            convert_sparse_pauli_op_to_pl(sparse_pauli_op, params={a: 3})
+
+    def test_convert_too_many_coefficients(self):
+        """Tests that a SparsePauliOp can be converted into a PennyLane operator by assigning values
+        to a strict superset of the parameterized coefficients.
+        """
+        a, b, c = [Parameter(var) for var in "abc"]
+        sparse_pauli_op = SparsePauliOp(["XY", "ZX"], coeffs=[a, b])
+
+        have_op = convert_sparse_pauli_op_to_pl(sparse_pauli_op, params={a: 3, b: 7, c: 9})
+        want_op = qml.sum(
+            qml.s_prod(3, qml.prod(qml.PauliX(wires=1), qml.PauliY(wires=0))),
+            qml.s_prod(7, qml.prod(qml.PauliZ(wires=1), qml.PauliX(wires=0))),
+        )
+        assert qml.equal(have_op, want_op)