qiskit 2.0.3__cp39-abi3-macosx_11_0_arm64.whl → 2.1.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/primitives/base/base_estimator.py

@@ -54,8 +54,8 @@ class BaseEstimatorV2(ABC):
             whose final state we define as :math:`\psi(\theta)`.
 
         * One or more observables (specified as any :class:`~.ObservablesArrayLike`, including
-            :class:`~.Pauli`, :class:`~.SparsePauliOp`, ``str``) that specify which expectation
-            values to estimate, denoted :math:`H_j`.
+            :class:`~.quantum_info.Pauli`, :class:`~.SparsePauliOp`, ``str``) that specify which
+            expectation values to estimate, denoted :math:`H_j`.
 
         * A collection parameter value sets to bind the circuit against, :math:`\theta_k`
 

qiskit/primitives/containers/data_bin.py

@@ -103,9 +103,6 @@ class DataBin(ShapedMixin):
     def __len__(self):
         return len(self._data)
 
-    def __setattr__(self, *_):
-        raise NotImplementedError
-
     def __repr__(self):
         vals = [f"{name}={_value_repr(val)}" for name, val in self.items()]
         if self.ndim:

qiskit/primitives/containers/observables_array.py

@@ -16,28 +16,33 @@ ND-Array container class for Estimator observables.
 """
 from __future__ import annotations
 
-import re
-from collections import defaultdict
+from copy import deepcopy
 from collections.abc import Iterable, Mapping as _Mapping
-from functools import lru_cache
-from typing import Union, Mapping, overload
-from numbers import Complex
+from typing import Union, Mapping, overload, TYPE_CHECKING
 
 import numpy as np
 from numpy.typing import ArrayLike
 
-from qiskit.quantum_info import Pauli, PauliList, SparsePauliOp
+from qiskit.quantum_info import Pauli, PauliList, SparsePauliOp, SparseObservable
 
 from .object_array import object_array
 from .shape import ShapedMixin, shape_tuple
 
+
+if TYPE_CHECKING:
+    from qiskit.transpiler.layout import TranspileLayout
+
+
 # Public API classes
 __all__ = ["ObservableLike", "ObservablesArrayLike"]
 
+IndexType = Union[int, slice, None]  # pylint: disable=used-before-assignment
+
 ObservableLike = Union[
     str,
     Pauli,
     SparsePauliOp,
+    SparseObservable,
     Mapping[Union[str, Pauli], float],
 ]
 """Types that can be natively used to construct a Hermitian Estimator observable."""
@@ -51,12 +56,11 @@ class ObservablesArray(ShapedMixin):
     """An ND-array of Hermitian observables for an :class:`.Estimator` primitive."""
 
     __slots__ = ("_array", "_shape")
-    ALLOWED_BASIS: str = "IXYZ01+-lr"
-    """The allowed characters in basis strings."""
 
     def __init__(
         self,
         observables: ObservablesArrayLike,
+        num_qubits: int | None = None,
         copy: bool = True,
         validate: bool = True,
     ):
@@ -66,35 +70,69 @@ class ObservablesArray(ShapedMixin):
             observables: An array-like of basis observable compatible objects.
             copy: Specify the ``copy`` kwarg of the :func:`.object_array` function
                 when initializing observables.
+            num_qubits: The number of qubits of the observables. If not specified, the number of
+                qubits will be inferred from the observables. If specified, then the specified
+                number of qubits must match the number of qubits in the observables.
             validate: If true, coerce entries into the internal format and validate them. If false,
                 the input should already be an array-like.
 
         Raises:
-            ValueError: If ``validate=True`` and the input observables is not valid.
+            ValueError: If ``validate=True`` and the input observables array is not valid.
         """
         super().__init__()
         if isinstance(observables, ObservablesArray):
             observables = observables._array
         self._array = object_array(observables, copy=copy, list_types=(PauliList,))
         self._shape = self._array.shape
+        self._num_qubits = num_qubits
+
         if validate:
-            num_qubits = None
             for ndi, obs in np.ndenumerate(self._array):
                 basis_obs = self.coerce_observable(obs)
-                basis_num_qubits = len(next(iter(basis_obs)))
-                if num_qubits is None:
-                    num_qubits = basis_num_qubits
-                elif basis_num_qubits != num_qubits:
+                if self._num_qubits is None:
+                    self._num_qubits = basis_obs.num_qubits
+                elif self._num_qubits != basis_obs.num_qubits:
                     raise ValueError(
                         "The number of qubits must be the same for all observables in the "
                         "observables array."
                     )
                 self._array[ndi] = basis_obs
+        elif self._num_qubits is None and self._array.size > 0:
+            self._num_qubits = self._array.reshape(-1)[0].num_qubits
+
+        # can happen for empty arrays
+        if self._num_qubits is None:
+            self._num_qubits = 0
+
+    @staticmethod
+    def _obs_to_dict(obs: SparseObservable) -> Mapping[str, float]:
+        """Convert a sparse observable to a mapping from Pauli strings to coefficients."""
+        result = {}
+        for sparse_pauli_str, pauli_qubits, coeff in obs.to_sparse_list():
+
+            if len(sparse_pauli_str) == 0:
+                full_pauli_str = "I" * obs.num_qubits
+            else:
+                sorted_lists = sorted(zip(pauli_qubits, sparse_pauli_str))
+                string_fragments = []
+                prev_qubit = -1
+                for qubit, pauli in sorted_lists:
+                    string_fragments.append("I" * (qubit - prev_qubit - 1) + pauli)
+                    prev_qubit = qubit
+
+                string_fragments.append("I" * (obs.num_qubits - max(pauli_qubits) - 1))
+                full_pauli_str = "".join(string_fragments)[::-1]
+
+            # We know that the dictionary doesn't contain yet full_pauli_str as a key
+            # because the observable is guaranteed to be simplified
+            result[full_pauli_str] = np.real(coeff)
+
+        return result
 
     def __repr__(self):
         prefix = f"{type(self).__name__}("
         suffix = f", shape={self.shape})"
-        array = np.array2string(self._array, prefix=prefix, suffix=suffix, threshold=50)
+        array = np.array2string(self.__array__(), prefix=prefix, suffix=suffix, threshold=50)
         return prefix + array + suffix
 
     def tolist(self) -> list | ObservableLike:
@@ -116,24 +154,68 @@ class ObservablesArray(ShapedMixin):
                 >>> print(type(oa.tolist()))
                 <class 'dict'>
         """
-        return self._array.tolist()
+        return self.__array__().tolist()
 
-    def __array__(self, dtype=None, copy=None):
-        """Convert to an Numpy.ndarray"""
+    def __array__(self, dtype=None, copy=None) -> np.ndarray:  # pylint: disable=unused-argument
+        """Convert to a Numpy.ndarray with elements of type dict."""
         if dtype is None or dtype == object:
-            return self._array.copy() if copy else self._array
+            tmp_result = self.__getitem__(tuple(slice(None) for _ in self._array.shape))
+            if len(self._array.shape) == 0:
+                result = np.ndarray(shape=self._array.shape, dtype=dict)
+                result[()] = tmp_result
+            else:
+                result = np.ndarray(tmp_result.shape, dtype=dict)
+                for ndi, obs in np.ndenumerate(tmp_result._array):
+                    result[ndi] = self._obs_to_dict(obs)
+            return result
         raise ValueError("Type must be 'None' or 'object'")
 
+    def sparse_observables_array(self, copy: bool = False) -> np.ndarray:
+        """Convert to a :class:`numpy.ndarray` with elements of type :class:`~.SparseObservable`.
+
+        Args:
+            copy: Whether to make a new array instance with new sparse observables as elements.
+
+        Returns:
+            A :class:`numpy.ndarray` with elements of type :class:`~.SparseObservable`.
+        """
+        obs = self.copy() if copy else self
+        return obs._array
+
     @overload
     def __getitem__(self, args: int | tuple[int, ...]) -> Mapping[str, float]: ...
 
     @overload
-    def __getitem__(self, args: slice) -> ObservablesArray: ...
+    def __getitem__(self, args: IndexType | tuple[IndexType, ...]) -> ObservablesArray: ...
 
     def __getitem__(self, args):
+        item = self._array[args]
+        if not isinstance(item, np.ndarray):
+            return self._obs_to_dict(item)
+
+        return ObservablesArray(item, copy=False, validate=False)
+
+    @overload
+    def slice(self, args: int | tuple[int, ...]) -> SparseObservable: ...
+
+    @overload
+    def slice(self, args: IndexType | tuple[IndexType, ...]) -> ObservablesArray: ...
+
+    def slice(self, args):
+        """Take a slice of the observables in this array.
+
+        .. note::
+           This method does not copy observables; modifying the returned observables will affect this
+           instance.
+
+        Returns:
+            A single :class:`~.SparseObservable` if an integer is given for every array axis, otherwise,
+            a new :class:`~.ObservablesArray`.
+        """
         item = self._array[args]
         if not isinstance(item, np.ndarray):
             return item
+
         return ObservablesArray(item, copy=False, validate=False)
 
     def reshape(self, *shape: int | Iterable[int]) -> ObservablesArray:
@@ -161,8 +243,13 @@ class ObservablesArray(ShapedMixin):
         """
         return self.reshape(self.size)
 
+    @property
+    def num_qubits(self) -> int:
+        """The number of qubits each observable acts on."""
+        return self._num_qubits
+
     @classmethod
-    def coerce_observable(cls, observable: ObservableLike) -> Mapping[str, float]:
+    def coerce_observable(cls, observable: ObservableLike) -> SparseObservable:
         """Format an observable-like object into the internal format.
 
         Args:
@@ -177,61 +264,39 @@ class ObservablesArray(ShapedMixin):
         """
         # Pauli-type conversions
         if isinstance(observable, SparsePauliOp):
-            observable = observable.simplify(atol=0)
-            # Check that the operator is Hermitian and has real coeffs
+            observable = SparseObservable.from_sparse_pauli_op(observable)
+        elif isinstance(observable, Pauli):
+            observable = SparseObservable.from_pauli(observable)
+        elif isinstance(observable, str):
+            observable = SparseObservable.from_label(observable)
+        elif isinstance(observable, _Mapping):
+            term_list = []
+            for basis, coeff in observable.items():
+                if isinstance(basis, str):
+                    term_list.append((basis, coeff))
+                elif isinstance(basis, Pauli):
+                    unphased_basis, phase = basis[:].to_label(), basis.phase
+                    term_list.append((unphased_basis, complex(0, 1) ** phase * coeff))
+                else:
+                    raise TypeError(f"Invalid observable basis type: {type(basis)}")
+            observable = SparseObservable.from_list(term_list)
+
+        if isinstance(observable, SparseObservable):
+            # Check that the operator has real coeffs
             coeffs = np.real_if_close(observable.coeffs)
             if np.iscomplexobj(coeffs):
                 raise ValueError(
                     "Non-Hermitian input observable: the input SparsePauliOp has non-zero"
                     " imaginary part in its coefficients."
                 )
-            paulis = observable.paulis.to_labels()
-            # Call simplify to combine duplicate keys before converting to a mapping
-            return dict(zip(paulis, coeffs))
-
-        if isinstance(observable, Pauli):
-            label, phase = observable[:].to_label(), observable.phase
-            if phase % 2:
-                raise ValueError(
-                    "Non-Hermitian input observable: the input Pauli has an imaginary phase."
-                )
-            return {label: 1} if phase == 0 else {label: -1}
-
-        # String conversion
-        if isinstance(observable, str):
-            cls._validate_basis(observable)
-            return {observable: 1}
 
-        # Mapping conversion (with possible Pauli keys)
-        if isinstance(observable, _Mapping):
-            num_qubits = len(next(iter(observable)))
-            unique = defaultdict(float)
-            for basis, coeff in observable.items():
-                if isinstance(basis, Pauli):
-                    basis, phase = basis[:].to_label(), basis.phase
-                    if phase % 2:
-                        raise ValueError(
-                            "Non-Hermitian input observable: the input Pauli has an imaginary phase."
-                        )
-                    if phase == 2:
-                        coeff = -coeff
-                # Truncate complex numbers to real
-                if isinstance(coeff, Complex):
-                    if abs(coeff.imag) > 1e-7:
-                        raise TypeError(
-                            f"Non-Hermitian input observable: {basis} term has a complex value"
-                            " coefficient."
-                        )
-                    coeff = coeff.real
-
-                # Validate basis
-                cls._validate_basis(basis)
-                if len(basis) != num_qubits:
-                    raise ValueError(
-                        "Number of qubits must be the same for all observable basis elements."
-                    )
-                unique[basis] += coeff
-            return dict(unique)
+            return SparseObservable.from_raw_parts(
+                observable.num_qubits,
+                coeffs,
+                observable.bit_terms,
+                observable.indices,
+                observable.boundaries,
+            ).simplify(tol=0)
 
         raise TypeError(f"Invalid observable type: {type(observable)}")
 
@@ -249,48 +314,67 @@ class ObservablesArray(ShapedMixin):
             return observables
         return cls(observables)
 
-    def validate(self):
-        """Validate the consistency in observables array."""
-        num_qubits = None
-        for obs in self._array.reshape(-1):
-            basis_num_qubits = len(next(iter(obs)))
-            if num_qubits is None:
-                num_qubits = basis_num_qubits
-            elif basis_num_qubits != num_qubits:
-                raise ValueError(
-                    "The number of qubits must be the same for all observables in the "
-                    "observables array."
-                )
+    def equivalent(self, other: ObservablesArray, tol: float = 1e-08) -> bool:
+        """Compute whether the observable arrays are equal within a given tolerance.
 
-    @classmethod
-    def _validate_basis(cls, basis: str) -> None:
-        """Validate a basis string.
+        Args:
+            other: Another observables array to compare with.
+            tol: The tolerance to provide to :attr:`~.SparseObservable.simplify` during checking.
+
+        Returns:
+            Whether the two observables arrays have the same shape and number of qubits,
+            and if so, whether they are equal within tolerance.
+        """
+        if self.num_qubits != other.num_qubits or self.shape != other.shape:
+            return False
+
+        zero_obs = SparseObservable.zero(self.num_qubits)
+        for obs1, obs2 in zip(self._array.ravel(), other._array.ravel()):
+            if (obs1 - obs2).simplify(tol) != zero_obs:
+                return False
+
+        return True
+
+    def copy(self):
+        """Return a deep copy of the array."""
+        return deepcopy(self)
+
+    def apply_layout(
+        self, layout: TranspileLayout | list[int] | None, num_qubits: int | None = None
+    ) -> ObservablesArray:
+        """Apply a transpiler layout to this :class:`~.ObservablesArray`.
 
         Args:
-            basis: a basis string to validate.
+            layout: Either a :class:`~.TranspileLayout`, a list of integers or None.
+                    If both layout and ``num_qubits`` are none, a deep copy of the array is
+                    returned.
+            num_qubits: The number of qubits to expand the array to. If not
+                provided then if ``layout`` is a :class:`~.TranspileLayout` the
+                number of the transpiler output circuit qubits will be used by
+                default. If ``layout`` is a list of integers the permutation
+                specified will be applied without any expansion. If layout is
+                None, the array will be expanded to the given number of qubits.
+
+        Returns:
+            A new :class:`.ObservablesArray` with the provided layout applied.
 
         Raises:
-            ValueError: If basis string contains invalid characters
+            QiskitError: ...
         """
-        # NOTE: the allowed basis characters can be overridden by modifying the class
-        # attribute ALLOWED_BASIS
-        allowed_pattern = _regex_match(cls.ALLOWED_BASIS)
-        if not allowed_pattern.match(basis):
-            invalid_pattern = _regex_invalid(cls.ALLOWED_BASIS)
-            invalid_chars = list(set(invalid_pattern.findall(basis)))
-            raise ValueError(
-                f"Observable basis string '{basis}' contains invalid characters {invalid_chars},"
-                f" allowed characters are {list(cls.ALLOWED_BASIS)}.",
-            )
-
-
-@lru_cache(1)
-def _regex_match(allowed_chars: str) -> re.Pattern:
-    """Return pattern for matching if a string contains only the allowed characters."""
-    return re.compile(f"^[{re.escape(allowed_chars)}]*$")
-
-
-@lru_cache(1)
-def _regex_invalid(allowed_chars: str) -> re.Pattern:
-    """Return pattern for selecting invalid strings"""
-    return re.compile(f"[^{re.escape(allowed_chars)}]")
+        if layout is None and num_qubits is None:
+            return self.copy()
+
+        new_arr = np.ndarray(self.shape, dtype=SparseObservable)
+        for ndi, obs in np.ndenumerate(self._array):
+            new_arr[ndi] = obs.apply_layout(layout, num_qubits)
+
+        return ObservablesArray(new_arr, validate=False)
+
+    def validate(self):
+        """Validate the consistency in observables array."""
+        for obs in self._array.reshape(-1):
+            if obs.num_qubits != self.num_qubits:
+                raise ValueError(
+                    "An observable was detected, whose number of qubits"
+                    " does not match the array's number of qubits"
+                )

qiskit/primitives/primitive_job.py

@@ -35,6 +35,8 @@ class PrimitiveJob(BasePrimitiveJob[ResultT, JobStatus]):
         super().__init__(str(uuid.uuid4()))
         self._future = None
         self._function = function
+        self._result = None
+        self._status = None
         self._args = args
         self._kwargs = kwargs
 
@@ -46,19 +48,36 @@ class PrimitiveJob(BasePrimitiveJob[ResultT, JobStatus]):
         self._future = executor.submit(self._function, *self._args, **self._kwargs)
         executor.shutdown(wait=False)
 
+    def __getstate__(self):
+        _ = self.result()
+        _ = self.status()
+        state = self.__dict__.copy()
+        state["_future"] = None
+        return state
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        self._future = None
+
     def result(self) -> ResultT:
-        self._check_submitted()
-        return self._future.result()
+        if self._result is None:
+            self._check_submitted()
+            self._result = self._future.result()
+        return self._result
 
     def status(self) -> JobStatus:
-        self._check_submitted()
-        if self._future.running():
-            return JobStatus.RUNNING
-        elif self._future.cancelled():
-            return JobStatus.CANCELLED
-        elif self._future.done() and self._future.exception() is None:
-            return JobStatus.DONE
-        return JobStatus.ERROR
+        if self._status is None:
+            self._check_submitted()
+            if self._future.running():
+                # we should not store status running because it is not completed
+                return JobStatus.RUNNING
+            elif self._future.cancelled():
+                self._status = JobStatus.CANCELLED
+            elif self._future.done() and self._future.exception() is None:
+                self._status = JobStatus.DONE
+            else:
+                self._status = JobStatus.ERROR
+        return self._status
 
     def _check_submitted(self):
         if self._future is None:

qiskit/providers/fake_provider/generic_backend_v2.py

@@ -19,6 +19,7 @@ import numpy as np
 
 from qiskit.circuit import QuantumCircuit, Instruction
 from qiskit.circuit.controlflow import (
+    BoxOp,
     IfElseOp,
     WhileLoopOp,
     ForLoopOp,
@@ -265,6 +266,7 @@ class GenericBackendV2(BackendV2):
             self._target.add_instruction(SwitchCaseOp, name="switch_case")
             self._target.add_instruction(BreakLoopOp, name="break")
             self._target.add_instruction(ContinueLoopOp, name="continue")
+            self._target.add_instruction(BoxOp, name="box")
 
     def _add_noisy_instruction_to_target(
         self,