Support multiplication of SparsePauliOp with Parameter

[kevinsung]

What should we add?

from qiskit.circuit import Parameter
from qiskit.quantum_info import SparsePauliOp

param = Parameter("a")
op = SparsePauliOp("X")
param * op

---------------------------------------------------------------------------
QiskitError                               Traceback (most recent call last)
Cell In[5], line 6
      4 param = Parameter("a")
      5 op = SparsePauliOp("X")
----> 6 param * op

File ~/projects/qiskit-terra/qiskit/quantum_info/operators/mixins/multiply.py:36, in MultiplyMixin.__rmul__(self, other)
     35 def __rmul__(self, other):
---> 36     return self._multiply(other)

File ~/projects/qiskit-terra/qiskit/quantum_info/operators/symplectic/sparse_pauli_op.py:370, in SparsePauliOp._multiply(self, other)
    368 def _multiply(self, other):
    369     if not isinstance(other, Number):
--> 370         raise QiskitError("other is not a number")
    371     if other == 0:
    372         # Check edge case that we deleted all Paulis
    373         # In this case we return an identity Pauli with a zero coefficient
    374         paulis = PauliList.from_symplectic(
    375             np.zeros((1, self.num_qubits), dtype=bool),
    376             np.zeros((1, self.num_qubits), dtype=bool),
    377         )

QiskitError: 'other is not a number'

[SimoneGasperini]

Hi @kevinsung! I think that the development of this feature and, more in general, the support for symbolic computation within the qiskit.quantum_info module could be very interesting. However, I already had a short but quite exhaustive conversation with @jakelishman on thread #9513 about this and the conclusion was that enabling symbolic computation in Qiskit would mean being able to properly extend all kind of operations already supported for complex/float numbers to symbolic expressions as well: this could very complicated and it goes beyond qiskit-terra core features (e.g. quantum circuit construction, manipulation, and transpilation).
For example, in this specific case, allowing multiplication between SparsePauliOp and Parameter instances could look as simple as adding to _multiply(self, other) something like:

if isinstance(other, ParameterExpression):
    self.coeffs = other * self.coeffs

This works but it converts coeffs from a numpy array of complex to a numpy array of object where each element is actually a ParameterExpression instance. As you can easily understand, this means that all the operations supported for SparsePauliOp (and between it and all the other module classes) have to be basically reimplemented to handle symbolic math.

By the way, I started working on symbolic computation in Qiskit (inspired by #4751) to allow something similar to what you are proposing here and I recently released the package qiskit-symb to leverage sympy for symbolic computation on quantum statevectors, density matrices, and operators as the ones defined in qiskit.quantum_info. The package has also already been published to the Qiskit Ecosystem and I will show a quick demo on June 15th for the Qiskit DemoDay. If interested, check it out and feel free to contact me via Slack.

[kevinsung]

This works but it converts coeffs from a numpy array of complex to a numpy array of object where each element is actually a ParameterExpression instance. As you can easily understand, this means that all the operations supported for SparsePauliOp (and between it and all the other module classes) have to be basically reimplemented to handle symbolic math.

The stored coefficients can already have data type object. See #8620.

[SimoneGasperini]

@kevinsung you are right, sorry for the confusion! It also looks that the SparsePauliOp class already implements the features to support unbound parameters: this means that, taking care of everything that might be needed, multiplication could be supported as well. I will take a look at this possibly in the next days.

[jakelishman]

Closed by #10264.