qiskit 1.3.0__cp39-abi3-win32.whl

qiskit/primitives/containers/shape.py

@@ -0,0 +1,129 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2024.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""
+Array shape related classes and functions
+"""
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Protocol, Union, runtime_checkable
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+
+ShapeInput = Union[int, "Iterable[ShapeInput]"]
+"""An input that is coercible into a shape tuple."""
+
+
+@runtime_checkable
+class Shaped(Protocol):
+    """Protocol that defines what it means to be a shaped object.
+
+    Note that static type checkers will classify ``numpy.ndarray`` as being :class:`Shaped`.
+    Moreover, since this protocol is runtime-checkable, we will even have
+    ``isinstance(<numpy.ndarray instance>, Shaped) == True``.
+    """
+
+    @property
+    def shape(self) -> tuple[int, ...]:
+        """The array shape of this object."""
+        raise NotImplementedError("A `Shaped` protocol must implement the `shape` property")
+
+    @property
+    def ndim(self) -> int:
+        """The number of array dimensions of this object."""
+        raise NotImplementedError("A `Shaped` protocol must implement the `ndim` property")
+
+    @property
+    def size(self) -> int:
+        """The total dimension of this object, i.e. the product of the entries of :attr:`~shape`."""
+        raise NotImplementedError("A `Shaped` protocol must implement the `size` property")
+
+
+class ShapedMixin(Shaped):
+    """Mixin class to create :class:`~Shaped` types by only providing :attr:`_shape` attribute."""
+
+    _shape: tuple[int, ...]
+
+    def __repr__(self):
+        return f"{type(self).__name__}(<{self.shape}>)"
+
+    @property
+    def shape(self):
+        return self._shape
+
+    @property
+    def ndim(self):
+        return len(self._shape)
+
+    @property
+    def size(self):
+        return int(np.prod(self._shape, dtype=int))
+
+
+def array_coerce(arr: ArrayLike | Shaped) -> NDArray | Shaped:
+    """Coerce the input into an object with a shape attribute.
+
+    Copies are avoided.
+
+    Args:
+        arr: The object to coerce.
+
+    Returns:
+        Something that is :class:`~Shaped`, and always ``numpy.ndarray`` if the input is not
+        already :class:`~Shaped`.
+    """
+    if isinstance(arr, Shaped):
+        return arr
+    return np.asarray(arr)
+
+
+def _flatten_to_ints(arg: ShapeInput) -> Iterable[int]:
+    """
+    Yield one integer at a time.
+
+    Args:
+        arg: Integers or iterables of integers, possibly nested, to be yielded.
+
+    Yields:
+        The provided integers in depth-first recursive order.
+
+    Raises:
+        ValueError: If an input is not an iterable or an integer.
+    """
+    for item in arg:
+        try:
+            if isinstance(item, Iterable):
+                yield from _flatten_to_ints(item)
+            elif int(item) == item:
+                yield int(item)
+            else:
+                raise ValueError(f"Expected {item} to be iterable or an integer.")
+        except (TypeError, RecursionError) as ex:
+            raise ValueError(f"Expected {item} to be iterable or an integer.") from ex
+
+
+def shape_tuple(*shapes: ShapeInput) -> tuple[int, ...]:
+    """
+    Flatten the input into a single tuple of integers, preserving order.
+
+    Args:
+        shapes: Integers or iterables of integers, possibly nested.
+
+    Returns:
+        A tuple of integers.
+
+    Raises:
+        ValueError: If some member of ``shapes`` is not an integer or iterable.
+    """
+    return tuple(_flatten_to_ints(shapes))

qiskit/primitives/estimator.py

@@ -0,0 +1,172 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2022.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Estimator V1 reference implementation
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+import numpy as np
+
+from qiskit.circuit import QuantumCircuit
+from qiskit.exceptions import QiskitError
+from qiskit.quantum_info.operators.base_operator import BaseOperator
+from qiskit.utils.deprecation import deprecate_func
+
+from .base import BaseEstimator, EstimatorResult
+from .primitive_job import PrimitiveJob
+from .utils import (
+    _circuit_key,
+    _observable_key,
+    _statevector_from_circuit,
+    init_observable,
+)
+
+
+class Estimator(BaseEstimator[PrimitiveJob[EstimatorResult]]):
+    """
+    Reference implementation of :class:`BaseEstimator` (V1).
+
+    :Run Options:
+
+        - **shots** (None or int) --
+          The number of shots. If None, it calculates the expectation values
+          with full state vector simulation.
+          Otherwise, it samples from normal distributions with standard errors as standard
+          deviations using normal distribution approximation.
+
+        - **seed** (np.random.Generator or int) --
+          Set a fixed seed or generator for the normal distribution. If shots is None,
+          this option is ignored.
+
+    .. note::
+        The result of this class is exact if the circuit contains only unitary operations.
+        On the other hand, the result could be stochastic if the circuit contains a non-unitary
+        operation such as a reset for a some subsystems.
+        The stochastic result can be made reproducible by setting ``seed``, e.g.,
+        ``Estimator(options={"seed":123})``.
+    """
+
+    @deprecate_func(
+        since="1.2",
+        additional_msg="All implementations of the `BaseEstimatorV1` interface "
+        "have been deprecated in favor of their V2 counterparts. "
+        "The V2 alternative for the `Estimator` class is `StatevectorEstimator`.",
+    )
+    def __init__(self, *, options: dict | None = None):
+        """
+        Args:
+            options: Default options.
+
+        Raises:
+            QiskitError: if some classical bits are not used for measurements.
+        """
+        super().__init__(options=options)
+        self._circuits = []
+        self._parameters = []
+        self._observables = []
+        self._circuit_ids = {}
+        self._observable_ids = {}
+
+    def _call(
+        self,
+        circuits: Sequence[int],
+        observables: Sequence[int],
+        parameter_values: Sequence[Sequence[float]],
+        **run_options,
+    ) -> EstimatorResult:
+        shots = run_options.pop("shots", None)
+        seed = run_options.pop("seed", None)
+        if seed is None:
+            rng = np.random.default_rng()
+        elif isinstance(seed, np.random.Generator):
+            rng = seed
+        else:
+            rng = np.random.default_rng(seed)
+
+        # Initialize metadata
+        metadata: list[dict[str, Any]] = [{} for _ in range(len(circuits))]
+
+        bound_circuits = []
+        for i, value in zip(circuits, parameter_values):
+            if len(value) != len(self._parameters[i]):
+                raise QiskitError(
+                    f"The number of values ({len(value)}) does not match "
+                    f"the number of parameters ({len(self._parameters[i])})."
+                )
+            bound_circuits.append(
+                self._circuits[i]
+                if len(value) == 0
+                else self._circuits[i].assign_parameters(dict(zip(self._parameters[i], value)))
+            )
+        sorted_observables = [self._observables[i] for i in observables]
+        expectation_values = []
+        for circ, obs, metadatum in zip(bound_circuits, sorted_observables, metadata):
+            if circ.num_qubits != obs.num_qubits:
+                raise QiskitError(
+                    f"The number of qubits of a circuit ({circ.num_qubits}) does not match "
+                    f"the number of qubits of a observable ({obs.num_qubits})."
+                )
+            final_state = _statevector_from_circuit(circ, rng)
+            expectation_value = final_state.expectation_value(obs)
+            if shots is None:
+                expectation_values.append(expectation_value)
+            else:
+                expectation_value = np.real_if_close(expectation_value)
+                sq_obs = (obs @ obs).simplify(atol=0)
+                sq_exp_val = np.real_if_close(final_state.expectation_value(sq_obs))
+                variance = sq_exp_val - expectation_value**2
+                variance = max(variance, 0)
+                standard_error = np.sqrt(variance / shots)
+                expectation_value_with_error = rng.normal(expectation_value, standard_error)
+                expectation_values.append(expectation_value_with_error)
+                metadatum["variance"] = variance
+                metadatum["shots"] = shots
+
+        return EstimatorResult(np.real_if_close(expectation_values), metadata)
+
+    def _run(
+        self,
+        circuits: tuple[QuantumCircuit, ...],
+        observables: tuple[BaseOperator, ...],
+        parameter_values: tuple[tuple[float, ...], ...],
+        **run_options,
+    ):
+        circuit_indices = []
+        for circuit in circuits:
+            key = _circuit_key(circuit)
+            index = self._circuit_ids.get(key)
+            if index is not None:
+                circuit_indices.append(index)
+            else:
+                circuit_indices.append(len(self._circuits))
+                self._circuit_ids[key] = len(self._circuits)
+                self._circuits.append(circuit)
+                self._parameters.append(circuit.parameters)
+        observable_indices = []
+        for observable in observables:
+            observable = init_observable(observable)
+            index = self._observable_ids.get(_observable_key(observable))
+            if index is not None:
+                observable_indices.append(index)
+            else:
+                observable_indices.append(len(self._observables))
+                self._observable_ids[_observable_key(observable)] = len(self._observables)
+                self._observables.append(observable)
+        job = PrimitiveJob(
+            self._call, circuit_indices, observable_indices, parameter_values, **run_options
+        )
+        job._submit()
+        return job

qiskit/primitives/primitive_job.py

@@ -0,0 +1,81 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2022, 2024.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Job for the reference implementations of Primitives V1 and V2.
+"""
+
+import uuid
+from concurrent.futures import ThreadPoolExecutor
+
+from qiskit.providers import JobError, JobStatus
+from qiskit.providers.jobstatus import JOB_FINAL_STATES
+
+from .base.base_primitive_job import BasePrimitiveJob, ResultT
+
+
+class PrimitiveJob(BasePrimitiveJob[ResultT, JobStatus]):
+    """
+    Primitive job class for the reference implementations of Primitives.
+    """
+
+    def __init__(self, function, *args, **kwargs):
+        """
+        Args:
+            function: A callable function to execute the job.
+        """
+        super().__init__(str(uuid.uuid4()))
+        self._future = None
+        self._function = function
+        self._args = args
+        self._kwargs = kwargs
+
+    def _submit(self):
+        if self._future is not None:
+            raise JobError("Primitive job has been submitted already.")
+
+        executor = ThreadPoolExecutor(max_workers=1)  # pylint: disable=consider-using-with
+        self._future = executor.submit(self._function, *self._args, **self._kwargs)
+        executor.shutdown(wait=False)
+
+    def result(self) -> ResultT:
+        self._check_submitted()
+        return self._future.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
+
+    def _check_submitted(self):
+        if self._future is None:
+            raise JobError("Primitive Job has not been submitted yet.")
+
+    def cancel(self):
+        self._check_submitted()
+        return self._future.cancel()
+
+    def done(self) -> bool:
+        return self.status() == JobStatus.DONE
+
+    def running(self) -> bool:
+        return self.status() == JobStatus.RUNNING
+
+    def cancelled(self) -> bool:
+        return self.status() == JobStatus.CANCELLED
+
+    def in_final_state(self) -> bool:
+        return self.status() in JOB_FINAL_STATES

qiskit/primitives/sampler.py

@@ -0,0 +1,162 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2022.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""
+Sampler V1 reference implementation
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+import numpy as np
+
+from qiskit.circuit import QuantumCircuit
+from qiskit.exceptions import QiskitError
+from qiskit.quantum_info import Statevector
+from qiskit.result import QuasiDistribution
+from qiskit.utils.deprecation import deprecate_func
+
+from .base import BaseSampler, SamplerResult
+from .primitive_job import PrimitiveJob
+from .utils import (
+    _circuit_key,
+    bound_circuit_to_instruction,
+    final_measurement_mapping,
+    init_circuit,
+)
+
+
+class Sampler(BaseSampler[PrimitiveJob[SamplerResult]]):
+    """
+    Sampler V1 class.
+
+    :class:`~Sampler` is a reference implementation of :class:`~BaseSampler` (V1).
+
+    :Run Options:
+
+        - **shots** (None or int) --
+          The number of shots. If None, it calculates the probabilities.
+          Otherwise, it samples from multinomial distributions.
+
+        - **seed** (np.random.Generator or int) --
+          Set a fixed seed or generator for the multinomial distribution. If shots is None, this
+          option is ignored.
+    """
+
+    @deprecate_func(
+        since="1.2",
+        additional_msg="All implementations of the `BaseSamplerV1` interface "
+        "have been deprecated in favor of their V2 counterparts. "
+        "The V2 alternative for the `Sampler` class is `StatevectorSampler`.",
+    )
+    def __init__(self, *, options: dict | None = None):
+        """
+        Args:
+            options: Default options.
+
+        Raises:
+            QiskitError: if some classical bits are not used for measurements.
+        """
+        super().__init__(options=options)
+        self._circuits = []
+        self._parameters = []
+        self._qargs_list = []
+        self._circuit_ids = {}
+
+    def _call(
+        self,
+        circuits: Sequence[int],
+        parameter_values: Sequence[Sequence[float]],
+        **run_options,
+    ) -> SamplerResult:
+        shots = run_options.pop("shots", None)
+        seed = run_options.pop("seed", None)
+        if seed is None:
+            rng = np.random.default_rng()
+        elif isinstance(seed, np.random.Generator):
+            rng = seed
+        else:
+            rng = np.random.default_rng(seed)
+
+        # Initialize metadata
+        metadata: list[dict[str, Any]] = [{} for _ in range(len(circuits))]
+
+        bound_circuits = []
+        qargs_list = []
+        for i, value in zip(circuits, parameter_values):
+            if len(value) != len(self._parameters[i]):
+                raise QiskitError(
+                    f"The number of values ({len(value)}) does not match "
+                    f"the number of parameters ({len(self._parameters[i])})."
+                )
+            bound_circuits.append(
+                self._circuits[i]
+                if len(value) == 0
+                else self._circuits[i].assign_parameters(dict(zip(self._parameters[i], value)))
+            )
+            qargs_list.append(self._qargs_list[i])
+        probabilities = [
+            Statevector(bound_circuit_to_instruction(circ)).probabilities_dict(
+                qargs=qargs, decimals=16
+            )
+            for circ, qargs in zip(bound_circuits, qargs_list)
+        ]
+        if shots is not None:
+            for i, prob_dict in enumerate(probabilities):
+                counts = rng.multinomial(shots, np.fromiter(prob_dict.values(), dtype=float))
+                probabilities[i] = {
+                    key: count / shots for key, count in zip(prob_dict.keys(), counts) if count > 0
+                }
+            for metadatum in metadata:
+                metadatum["shots"] = shots
+        quasis = [QuasiDistribution(p, shots=shots) for p in probabilities]
+
+        return SamplerResult(quasis, metadata)
+
+    def _run(
+        self,
+        circuits: tuple[QuantumCircuit, ...],
+        parameter_values: tuple[tuple[float, ...], ...],
+        **run_options,
+    ):
+        circuit_indices = []
+        for circuit in circuits:
+            key = _circuit_key(circuit)
+            index = self._circuit_ids.get(key)
+            if index is not None:
+                circuit_indices.append(index)
+            else:
+                circuit_indices.append(len(self._circuits))
+                self._circuit_ids[key] = len(self._circuits)
+                circuit, qargs = self._preprocess_circuit(circuit)
+                self._circuits.append(circuit)
+                self._qargs_list.append(qargs)
+                self._parameters.append(circuit.parameters)
+        job = PrimitiveJob(self._call, circuit_indices, parameter_values, **run_options)
+        job._submit()
+        return job
+
+    @staticmethod
+    def _preprocess_circuit(circuit: QuantumCircuit):
+        circuit = init_circuit(circuit)
+        q_c_mapping = final_measurement_mapping(circuit)
+        if set(range(circuit.num_clbits)) != set(q_c_mapping.values()):
+            raise QiskitError(
+                "Some classical bits are not used for measurements."
+                f" the number of classical bits ({circuit.num_clbits}),"
+                f" the used classical bits ({set(q_c_mapping.values())})."
+            )
+        c_q_mapping = sorted((c, q) for q, c in q_c_mapping.items())
+        qargs = [q for _, q in c_q_mapping]
+        circuit = circuit.remove_final_measurements(inplace=False)
+        return circuit, qargs