Added V2 and ISA support

.pylintdict

@@ -145,6 +145,7 @@ hopkins
 hoyer
 https
 hyperparameters
+iae
 idx
 im
 imag
@@ -155,6 +156,7 @@ interatomic
 ints
 iprint
 iqft
+isa
 ising
 iteratively
 iz
@@ -333,6 +335,7 @@ spsa
 sqrt
 statefn
 statevector
+statevectorestimator
 statevectors
 stddev
 stdout
@@ -367,8 +370,11 @@ trainability
 transpilation
 transpile
 transpiled
+transpiler
+transpiler's
 trotterization
 trotterized
+tweedledum
 uncompute
 unitaries
 univariate

qiskit_algorithms/algorithm_job.py

@@ -20,26 +20,6 @@ class AlgorithmJob(PrimitiveJob):
     """
     This class is introduced for typing purposes and provides no
     additional function beyond that inherited from its parents.
-
-    Update: :meth:`AlgorithmJob.submit()` method added. See its
-    documentation for more info.
     """
 
-    def submit(self) -> None:
-        """
-        Submit the job for execution.
-
-        For V1 primitives, Qiskit ``PrimitiveJob`` subclassed JobV1 and defined ``submit()``.
-        ``PrimitiveJob`` was updated for V2 primitives, no longer subclasses ``JobV1``, and
-        now has a private ``_submit()`` method, with ``submit()`` being deprecated as of
-        Qiskit version 0.46. This maintains the ``submit()`` for ``AlgorithmJob`` here as
-        it's called in many places for such a job. An alternative could be to make
-        0.46 the required minimum version and alter all algorithm's call sites to use
-        ``_submit()`` and make this an empty class again as it once was. For now this
-        way maintains compatibility with the current min version of 0.44.
-        """
-        # TODO: Considering changing this in the future - see above docstring.
-        try:
-            super()._submit()
-        except AttributeError:
-            super().submit()
+    pass

qiskit_algorithms/amplitude_amplifiers/grover.py

@@ -1,6 +1,6 @@
 # This code is part of a Qiskit project.
 #
-# (C) Copyright IBM 2018, 2023.
+# (C) Copyright IBM 2018, 2025.
 #
 # 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
@@ -18,16 +18,14 @@
 from typing import Any
 
 import numpy as np
-
 from qiskit import ClassicalRegister, QuantumCircuit
-from qiskit.primitives import BaseSampler
-from qiskit.quantum_info import Statevector
+from qiskit.primitives import BaseSamplerV2
 
 from qiskit_algorithms.exceptions import AlgorithmError
 from qiskit_algorithms.utils import algorithm_globals
-
 from .amplification_problem import AmplificationProblem
 from .amplitude_amplifier import AmplitudeAmplifier, AmplitudeAmplifierResult
+from ..custom_types import Transpiler
 
 
 class Grover(AmplitudeAmplifier):
@@ -116,7 +114,10 @@ def __init__(
         iterations: list[int] | Iterator[int] | int | None = None,
         growth_rate: float | None = None,
         sample_from_iterations: bool = False,
-        sampler: BaseSampler | None = None,
+        sampler: BaseSamplerV2 | None = None,
+        *,
+        transpiler: Transpiler | None = None,
+        transpiler_options: dict[str, Any] | None = None,
     ) -> None:
         r"""
         Args:
@@ -136,6 +137,11 @@ def __init__(
                 powers of the Grover operator, a random integer sample between 0 and smaller value
                 than the iteration is used as a power, see [1], Section 4.
             sampler: A Sampler to use for sampling the results of the circuits.
+            transpiler: An optional object with a `run` method allowing to transpile the circuits
+                that are produced within this algorithm. If set to `None`, these won't be
+                transpiled.
+            transpiler_options: A dictionary of options to be passed to the transpiler's `run`
+                method as keyword arguments.
 
         Raises:
             ValueError: If ``growth_rate`` is a float but not larger than 1.
@@ -165,9 +171,11 @@ def __init__(
         self._sampler = sampler
         self._sample_from_iterations = sample_from_iterations
         self._iterations_arg = iterations
+        self._transpiler = transpiler
+        self._transpiler_options = transpiler_options if transpiler_options is not None else {}
 
     @property
-    def sampler(self) -> BaseSampler | None:
+    def sampler(self) -> BaseSamplerV2 | None:
         """Get the sampler.
 
         Returns:
@@ -176,7 +184,7 @@ def sampler(self) -> BaseSampler | None:
         return self._sampler
 
     @sampler.setter
-    def sampler(self, sampler: BaseSampler) -> None:
+    def sampler(self, sampler: BaseSamplerV2) -> None:
         """Set the sampler.
 
         Args:
@@ -234,23 +242,29 @@ def amplify(self, amplification_problem: AmplificationProblem) -> "GroverResult"
             # sample from [0, power) if specified
             if self._sample_from_iterations:
                 power = algorithm_globals.random.integers(power)
+
             # Run a grover experiment for a given power of the Grover operator.
-            if self._sampler is not None:
-                qc = self.construct_circuit(amplification_problem, power, measurement=True)
-                job = self._sampler.run([qc])
-
-                try:
-                    results = job.result()
-                except Exception as exc:
-                    raise AlgorithmError("Sampler job failed.") from exc
-
-                num_bits = len(amplification_problem.objective_qubits)
-                circuit_results: dict[str, Any] | Statevector | np.ndarray = {
-                    np.binary_repr(k, num_bits): v for k, v in results.quasi_dists[0].items()
-                }
-                top_measurement, max_probability = max(
-                    circuit_results.items(), key=lambda x: x[1]  # type: ignore[union-attr]
-                )
+            qc = self.construct_circuit(amplification_problem, power, measurement=True)
+
+            if self._transpiler is not None:
+                qc = self._transpiler.run(qc, **self._transpiler_options)
+
+            job = self._sampler.run([qc])
+
+            try:
+                results = job.result()
+            except Exception as exc:
+                raise AlgorithmError("Sampler job failed.") from exc
+
+            circuit_results = getattr(results[0].data, qc.cregs[0].name)
+            circuit_results = {
+                label: value / circuit_results.num_shots
+                for label, value in circuit_results.get_counts().items()
+            }
+
+            top_measurement, max_probability = max(
+                circuit_results.items(), key=lambda x: x[1]  # type: ignore[union-attr]
+            )
 
             all_circuit_results.append(circuit_results)
 

qiskit_algorithms/amplitude_estimators/ae.py

@@ -1,6 +1,6 @@
 # This code is part of a Qiskit project.
 #
-# (C) Copyright IBM 2018, 2023.
+# (C) Copyright IBM 2018, 2025.
 #
 # 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
@@ -13,17 +13,21 @@
 """The Quantum Phase Estimation-based Amplitude Estimation algorithm."""
 
 from __future__ import annotations
-from collections import OrderedDict
+
 import warnings
+from collections import OrderedDict
+from typing import Any
+
 import numpy as np
-from scipy.stats import chi2, norm
+from qiskit import QuantumCircuit, ClassicalRegister
+from qiskit.primitives import BaseSamplerV2, StatevectorSampler
 from scipy.optimize import bisect
+from scipy.stats import chi2, norm
 
-from qiskit import QuantumCircuit, ClassicalRegister
-from qiskit.primitives import BaseSampler, Sampler
-from .amplitude_estimator import AmplitudeEstimator, AmplitudeEstimatorResult
 from .ae_utils import pdf_a, derivative_log_pdf_a, bisect_max
+from .amplitude_estimator import AmplitudeEstimator, AmplitudeEstimatorResult
 from .estimation_problem import EstimationProblem
+from ..custom_types import Transpiler
 from ..exceptions import AlgorithmError
 
 
@@ -66,7 +70,10 @@ def __init__(
         num_eval_qubits: int,
         phase_estimation_circuit: QuantumCircuit | None = None,
         iqft: QuantumCircuit | None = None,
-        sampler: BaseSampler | None = None,
+        sampler: BaseSamplerV2 | None = None,
+        *,
+        transpiler: Transpiler | None = None,
+        transpiler_options: dict[str, Any] | None = None,
     ) -> None:
         r"""
         Args:
@@ -77,6 +84,10 @@ def __init__(
             iqft: The inverse quantum Fourier transform component, defaults to using a standard
                 implementation from `qiskit.circuit.library.QFT` when None.
             sampler: A sampler primitive to evaluate the circuits.
+            transpiler: An optional object with a `run` method allowing to transpile the circuits
+                that are produced within this algorithm. If set to `None`, these won't be transpiled.
+            transpiler_options: A dictionary of options to be passed to the transpiler's `run`
+                method as keyword arguments.
 
         Raises:
             ValueError: If the number of evaluation qubits is smaller than 1.
@@ -94,8 +105,11 @@ def __init__(
         self._pec = phase_estimation_circuit
         self._sampler = sampler
 
+        self._transpiler = transpiler
+        self._transpiler_options = transpiler_options
+
     @property
-    def sampler(self) -> BaseSampler | None:
+    def sampler(self) -> BaseSamplerV2 | None:
         """Get the sampler primitive.
 
         Returns:
@@ -104,7 +118,7 @@ def sampler(self) -> BaseSampler | None:
         return self._sampler
 
     @sampler.setter
-    def sampler(self, sampler: BaseSampler) -> None:
+    def sampler(self, sampler: BaseSamplerV2) -> None:
         """Set sampler primitive.
 
         Args:
@@ -149,6 +163,9 @@ def construct_circuit(
             circuit.add_register(cr)
             circuit.measure(list(range(self._m)), list(range(self._m)))
 
+        if self._transpiler is not None:
+            circuit = self._transpiler.run(circuit, **self._transpiler_options)
+
         return circuit
 
     def evaluate_measurements(
@@ -288,8 +305,10 @@ def estimate(self, estimation_problem: EstimationProblem) -> "AmplitudeEstimatio
                 "The state_preparation property of the estimation problem must be set."
             )
         if self._sampler is None:
-            warnings.warn("No sampler provided, defaulting to Sampler from qiskit.primitives")
-            self._sampler = Sampler()
+            warnings.warn(
+                "No sampler provided, defaulting to StatevectorSampler from qiskit.primitives"
+            )
+            self._sampler = StatevectorSampler()
 
         if estimation_problem.objective_qubits is None:
             raise ValueError("The objective_qubits property of the estimation problem must be set.")
@@ -307,23 +326,17 @@ def estimate(self, estimation_problem: EstimationProblem) -> "AmplitudeEstimatio
         result.post_processing = estimation_problem.post_processing  # type: ignore[assignment]
 
         circuit = self.construct_circuit(estimation_problem, measurement=True)
+
         try:
-            job = self._sampler.run([circuit])
-            ret = job.result()
+            job = self._sampler.run([(circuit,)])
+            ret = job.result()[0]
         except Exception as exc:
             raise AlgorithmError("The job was not completed successfully. ") from exc
 
-        shots = ret.metadata[0].get("shots")
-        exact = True
+        circuit_results = getattr(ret.data, next(iter(ret.data.keys())))
+        shots = ret.metadata["shots"]
 
-        if shots is None:
-            result.circuit_results = ret.quasi_dists[0].binary_probabilities()
-            shots = 1
-        else:
-            result.circuit_results = {
-                k: round(v * shots) for k, v in ret.quasi_dists[0].binary_probabilities().items()
-            }
-            exact = False
+        result.circuit_results = circuit_results.get_counts()
 
         # store shots
         result.shots = shots
@@ -356,7 +369,7 @@ def estimate(self, estimation_problem: EstimationProblem) -> "AmplitudeEstimatio
             mle  # type: ignore[assignment,arg-type]
         )
 
-        result.confidence_interval = self.compute_confidence_interval(result, exact=exact)
+        result.confidence_interval = self.compute_confidence_interval(result)
         result.confidence_interval_processed = tuple(
             estimation_problem.post_processing(value)  # type: ignore[assignment,arg-type]
             for value in result.confidence_interval
@@ -369,7 +382,6 @@ def compute_confidence_interval(
         result: "AmplitudeEstimationResult",
         alpha: float = 0.05,
         kind: str = "likelihood_ratio",
-        exact: bool = False,
     ) -> tuple[float, float]:
         """Compute the (1 - alpha) confidence interval.
 
@@ -378,17 +390,13 @@ def compute_confidence_interval(
             alpha: Confidence level: compute the (1 - alpha) confidence interval.
             kind: The method to compute the confidence interval, can be 'fisher', 'observed_fisher'
                 or 'likelihood_ratio' (default)
-            exact: Whether the result comes from a statevector simulation or not
 
         Returns:
             The (1 - alpha) confidence interval of the specified kind.
 
         Raises:
             NotImplementedError: If the confidence interval method `kind` is not implemented.
         """
-        # if statevector simulator the estimate is exact
-        if exact:
-            return (result.mle, result.mle)
 
         if kind in ["likelihood_ratio", "lr"]:
             return _likelihood_ratio_confint(result, alpha)