qiskit 1.4.2__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/primitives/backend_sampler.py

@@ -1,222 +0,0 @@
-# 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 implementation for an arbitrary Backend object."""
-
-from __future__ import annotations
-
-import math
-from collections.abc import Sequence
-from typing import Any
-
-from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.providers.backend import BackendV1, BackendV2
-from qiskit.providers.options import Options
-from qiskit.result import QuasiDistribution, Result
-from qiskit.transpiler.passmanager import PassManager
-from qiskit.utils.deprecation import deprecate_func
-
-from .backend_estimator import _prepare_counts, _run_circuits
-from .base import BaseSampler, SamplerResult
-from .primitive_job import PrimitiveJob
-from .utils import _circuit_key
-
-
-class BackendSampler(BaseSampler[PrimitiveJob[SamplerResult]]):
-    """A :class:`~.BaseSampler` (V1) implementation that provides a wrapper for
-    leveraging the Sampler V1 interface from any backend.
-
-    This class provides a sampler interface from any backend and doesn't do
-    any measurement mitigation, it just computes the probability distribution
-    from the counts. It facilitates using backends that do not provide a
-    native :class:`~.BaseSampler` V1 implementation in places that work with
-    :class:`~.BaseSampler` V1.
-    However, if you're using a provider that has a native implementation of
-    :class:`~.BaseSamplerV1` ( :class:`~.BaseSampler`) or
-    :class:`~.BaseESamplerV2`, it is a better
-    choice to leverage that native implementation as it will likely include
-    additional optimizations and be a more efficient implementation.
-    The generic nature of this class precludes doing any provider- or
-    backend-specific optimizations.
-    """
-
-    @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 `BackendSampler` class is `BackendSamplerV2`.",
-    )
-    def __init__(
-        self,
-        backend: BackendV1 | BackendV2,
-        options: dict | None = None,
-        bound_pass_manager: PassManager | None = None,
-        skip_transpilation: bool = False,
-    ):
-        """Initialize a new BackendSampler (V1) instance
-
-        Args:
-            backend: (required) the backend to run the sampler primitive on
-            options: Default options.
-            bound_pass_manager: An optional pass manager to run after
-                parameter binding.
-            skip_transpilation: If this is set to True the internal compilation
-                of the input circuits is skipped and the circuit objects
-                will be directly executed when this objected is called.
-        Raises:
-            ValueError: If backend is not provided
-        """
-
-        super().__init__(options=options)
-        self._circuits = []
-        self._parameters = []
-        self._backend = backend
-        self._transpile_options = Options()
-        self._bound_pass_manager = bound_pass_manager
-        self._preprocessed_circuits: list[QuantumCircuit] | None = None
-        self._transpiled_circuits: list[QuantumCircuit] = []
-        self._skip_transpilation = skip_transpilation
-        self._circuit_ids = {}
-
-    @property
-    def preprocessed_circuits(self) -> list[QuantumCircuit]:
-        """
-        Preprocessed quantum circuits produced by preprocessing
-        Returns:
-            List of the transpiled quantum circuit
-        Raises:
-            QiskitError: if the instance has been closed.
-        """
-        return list(self._circuits)
-
-    @property
-    def transpiled_circuits(self) -> list[QuantumCircuit]:
-        """
-        Transpiled quantum circuits.
-        Returns:
-            List of the transpiled quantum circuit
-        Raises:
-            QiskitError: if the instance has been closed.
-        """
-        if self._skip_transpilation:
-            self._transpiled_circuits = list(self._circuits)
-        elif len(self._transpiled_circuits) < len(self._circuits):
-            # transpile only circuits that are not transpiled yet
-            self._transpile()
-        return self._transpiled_circuits
-
-    @property
-    def backend(self) -> BackendV1 | BackendV2:
-        """
-        Returns:
-            The backend which this sampler object based on
-        """
-        return self._backend
-
-    @property
-    def transpile_options(self) -> Options:
-        """Return the transpiler options for transpiling the circuits."""
-        return self._transpile_options
-
-    def set_transpile_options(self, **fields):
-        """Set the transpiler options for transpiler.
-        Args:
-            **fields: The fields to update the options.
-        Returns:
-            self.
-        Raises:
-            QiskitError: if the instance has been closed.
-        """
-        self._transpile_options.update_options(**fields)
-
-    def _call(
-        self,
-        circuits: Sequence[int],
-        parameter_values: Sequence[Sequence[float]],
-        **run_options,
-    ) -> SamplerResult:
-
-        # This line does the actual transpilation
-        transpiled_circuits = self.transpiled_circuits
-        bound_circuits = [
-            (
-                transpiled_circuits[i]
-                if len(value) == 0
-                else transpiled_circuits[i].assign_parameters(
-                    (dict(zip(self._parameters[i], value)))
-                )
-            )
-            for i, value in zip(circuits, parameter_values)
-        ]
-        bound_circuits = self._bound_pass_manager_run(bound_circuits)
-        # Run
-        result, _metadata = _run_circuits(bound_circuits, self._backend, **run_options)
-        return self._postprocessing(result, bound_circuits)
-
-    def _postprocessing(
-        self, result: list[Result], circuits: list[QuantumCircuit]
-    ) -> SamplerResult:
-        counts = _prepare_counts(result)
-        shots = sum(counts[0].values())
-
-        probabilities = []
-        metadata: list[dict[str, Any]] = [{} for _ in range(len(circuits))]
-        for count in counts:
-            prob_dist = {k: v / shots for k, v in count.items()}
-            probabilities.append(
-                QuasiDistribution(prob_dist, shots=shots, stddev_upper_bound=math.sqrt(1 / shots))
-            )
-            for metadatum in metadata:
-                metadatum["shots"] = shots
-
-        return SamplerResult(probabilities, metadata)
-
-    def _transpile(self):
-        from qiskit.compiler import transpile
-
-        start = len(self._transpiled_circuits)
-        self._transpiled_circuits.extend(
-            transpile(  # pylint:disable=unexpected-keyword-arg
-                self.preprocessed_circuits[start:],
-                self.backend,
-                **self.transpile_options.__dict__,
-            ),
-        )
-
-    def _bound_pass_manager_run(self, circuits):
-        if self._bound_pass_manager is None:
-            return circuits
-        else:
-            output = self._bound_pass_manager.run(circuits)
-            if not isinstance(output, list):
-                output = [output]
-            return output
-
-    def _run(
-        self,
-        circuits: tuple[QuantumCircuit, ...],
-        parameter_values: tuple[tuple[float, ...], ...],
-        **run_options,
-    ):
-        circuit_indices = []
-        for circuit in circuits:
-            index = self._circuit_ids.get(_circuit_key(circuit))
-            if index is not None:
-                circuit_indices.append(index)
-            else:
-                circuit_indices.append(len(self._circuits))
-                self._circuit_ids[_circuit_key(circuit)] = len(self._circuits)
-                self._circuits.append(circuit)
-                self._parameters.append(circuit.parameters)
-        job = PrimitiveJob(self._call, circuit_indices, parameter_values, **run_options)
-        job._submit()
-        return job

qiskit/primitives/estimator.py

@@ -1,172 +0,0 @@
-# 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/sampler.py

@@ -1,162 +0,0 @@
-# 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