Support SparseObservable to SparsePauliOp conversions (#13758)

* SparseObservable -> SparsePauliOp

and SparseObservable.to_sparse_list, which can also be used for the PauliEvolutionGate compat

* reno

* allow observable alphabet as well

* Jake's review comments

- to_paulis -> SparseObservable
- test more edge cases
- don't guarantee any ordering

* update reno

* fix ruff

... which was somehow not captured by my pre commit hook

* round 2

- use &'static over Vec
- reverse bit/index order
- rename as_paulis
- direct construciton w/o CoherenceError

* fix tests and improve docs

* Update documentation

---------

Co-authored-by: Jake Lishman <jake.lishman@ibm.com>

Author: Cryoris

crates/accelerate/src/sparse_observable.rs

@@ -11,6 +11,7 @@
 // that they have been altered from the originals.
 
 use hashbrown::HashSet;
+use itertools::Itertools;
 use ndarray::Array2;
 use num_complex::Complex64;
 use num_traits::Zero;
@@ -23,7 +24,7 @@ use pyo3::{
     intern,
     prelude::*,
     sync::GILOnceCell,
-    types::{IntoPyDict, PyList, PyTuple, PyType},
+    types::{IntoPyDict, PyList, PyString, PyTuple, PyType},
     IntoPyObjectExt, PyErr,
 };
 use std::{
@@ -184,6 +185,24 @@ impl BitTerm {
     pub fn has_z_component(&self) -> bool {
         ((*self as u8) & (Self::Z as u8)) != 0
     }
+
+    pub fn is_projector(&self) -> bool {
+        !matches!(self, BitTerm::X | BitTerm::Y | BitTerm::Z)
+    }
+}
+
+fn bit_term_as_pauli(bit: &BitTerm) -> &'static [(bool, Option<BitTerm>)] {
+    match bit {
+        BitTerm::X => &[(true, Some(BitTerm::X))],
+        BitTerm::Y => &[(true, Some(BitTerm::Y))],
+        BitTerm::Z => &[(true, Some(BitTerm::Z))],
+        BitTerm::Plus => &[(true, None), (true, Some(BitTerm::X))],
+        BitTerm::Minus => &[(true, None), (false, Some(BitTerm::X))],
+        BitTerm::Left => &[(true, None), (true, Some(BitTerm::Y))],
+        BitTerm::Right => &[(true, None), (false, Some(BitTerm::Y))],
+        BitTerm::Zero => &[(true, None), (true, Some(BitTerm::Z))],
+        BitTerm::One => &[(true, None), (false, Some(BitTerm::Z))],
+    }
 }
 
 /// The error type for a failed conversion into `BitTerm`.
@@ -641,6 +660,58 @@ impl SparseObservable {
         }
     }
 
+    /// Expand all projectors into Pauli representation.
+    ///
+    /// # Warning
+    ///
+    /// This representation is highly inefficient for projectors. For example, a term with
+    /// :math:`n` projectors :math:`|+\rangle\langle +|` will use :math:`2^n` Pauli terms.
+    pub fn as_paulis(&self) -> Self {
+        let mut paulis: Vec<BitTerm> = Vec::new(); // maybe get capacity here
+        let mut indices: Vec<u32> = Vec::new();
+        let mut coeffs: Vec<Complex64> = Vec::new();
+        let mut boundaries: Vec<usize> = vec![0];
+
+        for view in self.iter() {
+            let num_projectors = view
+                .bit_terms
+                .iter()
+                .filter(|&bit| bit.is_projector())
+                .count();
+            let div = 2_f64.powi(num_projectors as i32);
+
+            let combinations = view
+                .bit_terms
+                .iter()
+                .map(bit_term_as_pauli)
+                .multi_cartesian_product();
+
+            for combination in combinations {
+                let mut positive = true;
+
+                for (index, (sign, bit)) in combination.iter().enumerate() {
+                    positive &= sign;
+                    if let Some(bit) = bit {
+                        paulis.push(*bit);
+                        indices.push(view.indices[index]);
+                    }
+                }
+                boundaries.push(paulis.len());
+
+                let coeff = if positive { view.coeff } else { -view.coeff };
+                coeffs.push(coeff / div)
+            }
+        }
+
+        Self {
+            num_qubits: self.num_qubits,
+            coeffs,
+            bit_terms: paulis,
+            indices,
+            boundaries,
+        }
+    }
+
     /// Add the term implied by a dense string label onto this observable.
     pub fn add_dense_label<L: AsRef<[u8]>>(
         &mut self,
@@ -1741,10 +1812,11 @@ impl PySparseTerm {
 ///
 /// .. note::
 ///
-///     The canonical form produced by :meth:`simplify` will still not universally detect all
-///     observables that are equivalent due to the over-complete basis alphabet; it is not
-///     computationally feasible to do this at scale.  For example, on observable built from ``+``
-///     and ``-`` components will not canonicalize to a single ``X`` term.
+///     The canonical form produced by :meth:`simplify` alone will not universally detect all
+///     observables that are equivalent due to the over-complete basis alphabet. To obtain a
+///     unique expression, you can first represent the observable using Pauli terms only by
+///     calling :meth:`as_paulis`, followed by :meth:`simplify`. Note that the projector
+///     expansion (e.g. ``+`` into ``I`` and ``X``) is not computationally feasible at scale.
 ///
 /// Indexing
 /// --------
@@ -1824,6 +1896,29 @@ impl PySparseTerm {
 ///   :meth:`identity`              The identity operator on a given number of qubits.
 ///   ============================  ================================================================
 ///
+/// Conversions
+/// ===========
+///
+/// An existing :class:`SparseObservable` can be converted into other :mod:`~qiskit.quantum_info`
+/// operators or generic formats.  Beware that other objects may not be able to represent the same
+/// observable as efficiently as :class:`SparseObservable`, including potentially needed
+/// exponentially more memory.
+///
+/// .. table:: Conversion methods to other observable forms.
+///
+///   ===========================  =================================================================
+///   Method                       Summary
+///   ===========================  =================================================================
+///   :meth:`as_paulis`            Create a new :class:`SparseObservable`, expanding in terms
+///                                of Pauli operators only.
+///
+///   :meth:`to_sparse_list`       Express the observable in a sparse list format with elements
+///                                ``(bit_terms, indices, coeff)``.
+///   ===========================  =================================================================
+///
+/// In addition, :meth:`.SparsePauliOp.from_sparse_observable` is available for conversion from this
+/// class to :class:`.SparsePauliOp`.  Beware that this method suffers from the same
+/// exponential-memory usage concerns as :meth:`as_paulis`.
 ///
 /// Mathematical manipulation
 /// =========================
@@ -1925,8 +2020,8 @@ impl PySparseObservable {
             let inner = borrowed.inner.read().map_err(|_| InnerReadError)?;
             return Ok(inner.clone().into());
         }
-        // The type of `vec` is inferred from the subsequent calls to `Self::py_from_list` or
-        // `Self::py_from_sparse_list` to be either the two-tuple or the three-tuple form during the
+        // The type of `vec` is inferred from the subsequent calls to `Self::from_list` or
+        // `Self::from_sparse_list` to be either the two-tuple or the three-tuple form during the
         // `extract`.  The empty list will pass either, but it means the same to both functions.
         if let Ok(vec) = data.extract() {
             return Self::from_list(vec, num_qubits);
@@ -2289,6 +2384,10 @@ impl PySparseObservable {
     ///         ...     for label, coeff in zip(labels, coeffs)
     ///         ... ])
     ///         >>> assert from_list == from_sparse_list
+    ///
+    /// See also:
+    ///     :meth:`to_sparse_list`
+    ///         The reverse of this method.
     #[staticmethod]
     #[pyo3(signature = (iter, /, num_qubits))]
     fn from_sparse_list(
@@ -2337,6 +2436,86 @@ impl PySparseObservable {
         Ok(inner.into())
     }
 
+    /// Express the observable in Pauli terms only, by writing each projector as sum of Pauli terms.
+    ///
+    /// Note that there is no guarantee of the order the resulting Pauli terms. Use
+    /// :meth:`SparseObservable.simplify` in addition to obtain a canonical representation.
+    ///
+    /// .. warning::
+    ///
+    ///     Beware that this will use at least :math:`2^n` terms if there are :math:`n`
+    ///     single-qubit projectors present, which can lead to an exponential number of terms.
+    ///
+    /// Returns:
+    ///     The same observable, but expressed in Pauli terms only.
+    ///
+    /// Examples:
+    ///
+    ///     Rewrite an observable in terms of projectors into Pauli operators::
+    ///
+    ///         >>> obs = SparseObservable("+")
+    ///         >>> obs.as_paulis()
+    ///         <SparseObservable with 2 terms on 1 qubit: (0.5+0j)() + (0.5+0j)(X_0)>
+    ///         >>> direct = SparseObservable.from_list([("I", 0.5), ("Z", 0.5)])
+    ///         >>> assert direct.simplify() == obs.as_paulis().simplify()
+    ///
+    ///     For small operators, this can be used with :meth:`simplify` as a unique canonical form::
+    ///
+    ///         >>> left = SparseObservable.from_list([("+", 0.5), ("-", 0.5)])
+    ///         >>> right = SparseObservable.from_list([("r", 0.5), ("l", 0.5)])
+    ///         >>> assert left.as_paulis().simplify() == right.as_paulis().simplify()
+    ///
+    /// See also:
+    ///     :meth:`.SparsePauliOp.from_sparse_observable`
+    ///         A constructor of :class:`.SparsePauliOp` that can convert a
+    ///         :class:`SparseObservable` in the :class:`.SparsePauliOp` dense Pauli representation.
+    fn as_paulis(&self) -> PyResult<Self> {
+        let inner = self.inner.read().map_err(|_| InnerReadError)?;
+        Ok(inner.as_paulis().into())
+    }
+
+    /// Express the observable in terms of a sparse list format.
+    ///
+    /// This can be seen as counter-operation of :meth:`.SparseObservable.from_sparse_list`, however
+    /// the order of terms is not guaranteed to be the same at after a roundtrip to a sparse
+    /// list and back.
+    ///
+    /// Examples:
+    ///     
+    ///     >>> obs = SparseObservable.from_list([("IIXIZ", 2j), ("IIZIX", 2j)])
+    ///     >>> reconstructed = SparseObservable.from_sparse_list(obs.to_sparse_list(), obs.num_qubits)
+    ///
+    /// See also:
+    ///     :meth:`from_sparse_list`
+    ///         The constructor that can interpret these lists.
+    #[pyo3(signature = ())]
+    fn to_sparse_list(&self, py: Python) -> PyResult<Py<PyList>> {
+        let inner = self.inner.read().map_err(|_| InnerReadError)?;
+
+        // turn a SparseView into a Python tuple of (bit terms, indices, coeff)
+        let to_py_tuple = |view: SparseTermView| {
+            let mut pauli_string = String::with_capacity(view.bit_terms.len());
+
+            // we reverse the order of bits and indices so the Pauli string comes out in
+            // "reading order", consistent with how one would write the label in
+            // SparseObservable.from_list or .from_label
+            for bit in view.bit_terms.iter().rev() {
+                pauli_string.push_str(bit.py_label());
+            }
+            let py_string = PyString::new(py, &pauli_string).unbind();
+            let py_indices = PyList::new(py, view.indices.iter().rev())?.unbind();
+            let py_coeff = view.coeff.into_py_any(py)?;
+
+            PyTuple::new(py, vec![py_string.as_any(), py_indices.as_any(), &py_coeff])
+        };
+
+        let out = PyList::empty(py);
+        for view in inner.iter() {
+            out.append(to_py_tuple(view)?)?;
+        }
+        Ok(out.unbind())
+    }
+
     /// Construct a :class:`.SparseObservable` from a :class:`.SparsePauliOp` instance.
     ///
     /// This will be a largely direct translation of the :class:`.SparsePauliOp`; in particular,

qiskit/quantum_info/operators/symplectic/sparse_pauli_op.py

@@ -30,6 +30,7 @@
     to_matrix_sparse,
     unordered_unique,
 )
+from qiskit._accelerate.sparse_observable import SparseObservable
 from qiskit.circuit.parameter import Parameter
 from qiskit.circuit.parameterexpression import ParameterExpression
 from qiskit.circuit.parametertable import ParameterView
@@ -929,6 +930,27 @@ def from_sparse_list(
         paulis = PauliList(labels)
         return SparsePauliOp(paulis, coeffs, copy=False)
 
+    @staticmethod
+    def from_sparse_observable(obs: SparseObservable) -> SparsePauliOp:
+        r"""Initialize from a :class:`.SparseObservable`.
+
+        .. warning::
+
+            A :class:`.SparseObservable` can efficiently represent eigenstate projectors
+            (such as :math:`|0\langle\rangle 0|`), but a :class:`.SparsePauliOp` **cannot**.
+            If the input ``obs`` has :math:`n` single-qubit projectors, the resulting
+            :class:`.SparsePauliOp` will use :math:`2^n` terms, which is an exponentially
+            expensive representation that can quickly run out of memory.
+
+        Args:
+            obs: The :class:`.SparseObservable` to convert.
+
+        Returns:
+            A :class:`.SparsePauliOp` version of the observable.
+        """
+        as_sparse_list = obs.as_paulis().to_sparse_list()
+        return SparsePauliOp.from_sparse_list(as_sparse_list, obs.num_qubits)
+
     def to_list(self, array: bool = False):
         """Convert to a list Pauli string labels and coefficients.
 

releasenotes/notes/sparse-obs-to-sparse-list-5b7c17c5d7cffd72.yaml

@@ -0,0 +1,25 @@
+---
+features_quantum_info:
+  - |
+    Added :meth:`.SparseObservable.to_sparse_list` to obtain a sparse list representation
+    of a :class:`.SparseObservable`. For example::
+
+      from qiskit.quantum_info import SparseObservable
+
+      obs = SparseObservable.from_list([("+II", 1), ("-II", 1)])
+      print(obs.to_sparse_list())  # [("+", [2], 1), ("-", [2], 1)]
+
+  - | 
+    Added :meth:`.SparseObservable.as_paulis` to express a sparse observable in terms of Paulis
+    only by expanding all projectors. For example::
+
+      from qiskit.quantum_info import SparseObservable
+
+      obs = SparseObservable("+-")
+      obs_paulis = obs.as_paulis()  # 1/4 ( II + XI - IX - XX )
+
+  - |
+    Support construction of a :class:`.SparsePauliOp` from a :class:`.SparseObservable`
+    via the new method :class:`.SparsePauliOp.from_sparse_observable`. It is important
+    to remember that :class:`.SparseObservable`\ s can efficiently represent projectors,
+    which require an exponential number of terms in the :class:`.SparsePauliOp`.

test/python/quantum_info/operators/symplectic/test_sparse_pauli_op.py

@@ -28,7 +28,13 @@
 from qiskit.compiler.transpiler import transpile
 from qiskit.primitives import BackendEstimator
 from qiskit.providers.fake_provider import GenericBackendV2
-from qiskit.quantum_info.operators import Operator, Pauli, PauliList, SparsePauliOp
+from qiskit.quantum_info import SparseObservable
+from qiskit.quantum_info.operators import (
+    Operator,
+    Pauli,
+    PauliList,
+    SparsePauliOp,
+)
 from qiskit.utils import optionals
 
 
@@ -361,6 +367,66 @@ def test_to_list_parameters(self):
         target = list(zip(labels, coeffs))
         self.assertEqual(op.to_list(), target)
 
+    def test_from_sparse_observable(self):
+        """Test from a SparseObservable."""
+        with self.subTest("zero(0)"):
+            obs = SparseObservable.zero(0)
+            expected = SparsePauliOp([""], coeffs=[0])
+            self.assertEqual(expected, SparsePauliOp.from_sparse_observable(obs))
+
+        with self.subTest("identity(0)"):
+            obs = SparseObservable.identity(0)
+            expected = SparsePauliOp([""], coeffs=[1])
+            self.assertEqual(expected, SparsePauliOp.from_sparse_observable(obs))
+
+        with self.subTest("zero(10)"):
+            obs = SparseObservable.zero(10)
+            expected = SparsePauliOp(["I" * 10], coeffs=[0])
+            self.assertEqual(expected, SparsePauliOp.from_sparse_observable(obs))
+
+        with self.subTest("identity(10)"):
+            obs = SparseObservable.identity(10)
+            expected = SparsePauliOp(["I" * 10], coeffs=[1])
+            self.assertEqual(expected, SparsePauliOp.from_sparse_observable(obs))
+
+        with self.subTest("XrZ"):
+            obs = SparseObservable("XrZ")
+            spo = SparsePauliOp.from_sparse_observable(obs)
+            expected = SparsePauliOp(["XIZ", "XYZ"], coeffs=[0.5, -0.5])
+
+            # we don't guarantee the order of Paulis, so check equality by comparing
+            # the matrix representation and that all Pauli strings are present
+            self.assertEqual(Operator(expected), Operator(spo))
+            self.assertTrue(set(spo.paulis.to_labels()) == set(expected.paulis.to_labels()))
+
+    def test_sparse_observable_roundtrip(self):
+        """Test SPO -> OBS -> SPO."""
+        with self.subTest(msg="empty"):
+            op = SparsePauliOp([""], coeffs=[1])
+            obs = SparseObservable.from_sparse_pauli_op(op)
+            roundtrip = SparsePauliOp.from_sparse_observable(obs)
+            self.assertEqual(op, roundtrip)
+
+        with self.subTest(msg="zero"):
+            op = SparsePauliOp(["I"], coeffs=[0])
+            obs = SparseObservable.from_sparse_pauli_op(op)
+            roundtrip = SparsePauliOp.from_sparse_observable(obs)
+            self.assertEqual(op, roundtrip)
+
+        with self.subTest(msg="identity"):
+            op = SparsePauliOp(["I" * 25])
+            obs = SparseObservable.from_sparse_pauli_op(op)
+            roundtrip = SparsePauliOp.from_sparse_observable(obs)
+            self.assertEqual(op, roundtrip)
+
+        with self.subTest(msg="ising like"):
+            op = SparsePauliOp(["ZZI", "IZZ", "IIX", "IXI", "YII"])
+            obs = SparseObservable.from_sparse_pauli_op(op)
+            roundtrip = SparsePauliOp.from_sparse_observable(obs)
+
+            self.assertEqual(Operator(op), Operator(roundtrip))
+            self.assertTrue(set(op.paulis.to_labels()) == set(roundtrip.paulis.to_labels()))
+
 
 class TestSparsePauliOpIteration(QiskitTestCase):
     """Tests for SparsePauliOp iterators class."""