ComputeUncompute done

Author: tnemoz

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/gradients/base/base_estimator_gradient.py

@@ -149,7 +149,7 @@ def run(
         job = AlgorithmJob(
             self._run, circuits, observables, parameter_values, parameters, **opts.__dict__
         )
-        job.submit()
+        job._submit()
         return job
 
     @abstractmethod

qiskit_algorithms/gradients/base/base_qgt.py

@@ -161,7 +161,7 @@ def run(
         opts = copy(self._default_options)
         opts.update_options(**options)
         job = AlgorithmJob(self._run, circuits, parameter_values, parameters, **opts.__dict__)
-        job.submit()
+        job._submit()
         return job
 
     @abstractmethod

qiskit_algorithms/gradients/base/base_sampler_gradient.py

@@ -107,7 +107,7 @@ def run(
         opts = copy(self._default_options)
         opts.update_options(**options)
         job = AlgorithmJob(self._run, circuits, parameter_values, parameters, **opts.__dict__)
-        job.submit()
+        job._submit()
         return job
 
     @abstractmethod

qiskit_algorithms/gradients/qfi.py

@@ -103,7 +103,7 @@ def run(
         opts = copy(self._default_options)
         opts.update_options(**options)
         job = AlgorithmJob(self._run, circuits, parameter_values, parameters, **opts.__dict__)
-        job.submit()
+        job._submit()
         return job
 
     def _run(

qiskit_algorithms/minimum_eigensolvers/diagonal_estimator.py

@@ -104,7 +104,7 @@ def _run(
         job = AlgorithmJob(
             self._call, circuit_indices, observable_indices, parameter_values, **run_options
         )
-        job.submit()
+        job._submit()
         return job
 
     def _call(

qiskit_algorithms/phase_estimators/hamiltonian_phase_estimation.py

@@ -14,6 +14,8 @@
 
 from __future__ import annotations
 
+from typing import Any
+
 from qiskit import QuantumCircuit
 from qiskit.circuit.library import PauliEvolutionGate
 from qiskit.primitives import BaseSamplerV2
@@ -85,6 +87,7 @@ def __init__(
         num_evaluation_qubits: int,
         sampler: BaseSamplerV2 | None = None,
         transpiler: Transpiler | None = None,
+        transpiler_options: dict[str, Any] | None = None,
     ) -> None:
         r"""
         Args:
@@ -94,11 +97,14 @@ def __init__(
             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.
         """
         self._phase_estimation = PhaseEstimation(
             num_evaluation_qubits=num_evaluation_qubits,
             sampler=sampler,
             transpiler=transpiler,
+            transpiler_options=transpiler_options
         )
 
     def _get_scale(self, hamiltonian, bound=None) -> PhaseEstimationScale:

qiskit_algorithms/phase_estimators/phase_estimation.py

@@ -15,6 +15,8 @@
 
 from __future__ import annotations
 
+from typing import Any
+
 import numpy
 import qiskit
 from qiskit import circuit
@@ -85,6 +87,7 @@ def __init__(
         num_evaluation_qubits: int,
         sampler: BaseSamplerV2 | None = None,
         transpiler: Transpiler | None = None,
+        transpiler_options: dict[str, Any] | None = None,
     ) -> None:
         r"""
         Args:
@@ -94,6 +97,8 @@ def __init__(
             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:
             AlgorithmError: If a sampler is not provided

qiskit_algorithms/state_fidelities/base_state_fidelity.py

@@ -16,14 +16,15 @@
 from __future__ import annotations
 from abc import ABC, abstractmethod
 from collections.abc import MutableMapping
-from typing import cast, Sequence, List
+from typing import cast, Sequence, List, Any
 import numpy as np
 
 from qiskit import QuantumCircuit
 from qiskit.circuit import ParameterVector
 from qiskit.primitives.utils import _circuit_key
 
 from ..algorithm_job import AlgorithmJob
+from ..custom_types import Transpiler
 
 
 class BaseStateFidelity(ABC):
@@ -42,10 +43,19 @@ class BaseStateFidelity(ABC):
 
     """
 
-    def __init__(self) -> None:
-
+    def __init__(self, transpiler: Transpiler | None = None, transpiler_options: dict[str, Any] | None = None,) -> None:
+        r"""
+        Args:
+            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.
+        """
         # use cache for preventing unnecessary circuit compositions
         self._circuit_cache: MutableMapping[tuple[int, int], QuantumCircuit] = {}
+        self._transpiler = transpiler
+        self._transpiler_options = transpiler_options if transpiler_options is not None else {}
 
     @staticmethod
     def _preprocess_values(
@@ -195,6 +205,9 @@ def _construct_circuits(
                 # update cache
                 self._circuit_cache[_circuit_key(circuit_1), _circuit_key(circuit_2)] = circuit
 
+        if self._transpiler is not None:
+            return self._transpiler.run(circuits, **self._transpiler_options)
+
         return circuits
 
     def _construct_value_list(
@@ -245,7 +258,7 @@ def _run(
         circuits_2: QuantumCircuit | Sequence[QuantumCircuit],
         values_1: Sequence[float] | Sequence[Sequence[float]] | None = None,
         values_2: Sequence[float] | Sequence[Sequence[float]] | None = None,
-        **options,
+        shots: int | Sequence[int] | None = None,
     ) -> AlgorithmJob:
         r"""
         Computes the state overlap (fidelity) calculation between two
@@ -257,10 +270,12 @@ def _run(
             circuits_2: (Parametrized) quantum circuits preparing :math:`|\phi\rangle`.
             values_1: Numerical parameters to be bound to the first set of circuits
             values_2: Numerical parameters to be bound to the second set of circuits.
-            options: Primitive backend runtime options used for circuit execution. The order
-                of priority is\: options in ``run`` method > fidelity's default
-                options > primitive's default setting.
-                Higher priority setting overrides lower priority setting.
+            shots: Number of shots to be used by the underlying sampler. If a single integer is
+                provided, this number will be used for all circuits. If a sequence of integers is
+                provided, they will be used on a per-circuit basis. If none is provided, the
+                fidelity's default number of shots will be used for all circuits. If this number is
+                also set to None, the underlying primitive's default number of shots will be used
+                for all circuits.
 
         Returns:
             A newly constructed algorithm job instance to get the fidelity result.
@@ -273,7 +288,7 @@ def run(
         circuits_2: QuantumCircuit | Sequence[QuantumCircuit],
         values_1: Sequence[float] | Sequence[Sequence[float]] | None = None,
         values_2: Sequence[float] | Sequence[Sequence[float]] | None = None,
-        **options,
+        shots: int | Sequence[int] | None = None,
     ) -> AlgorithmJob:
         r"""
         Runs asynchronously the state overlap (fidelity) calculation between two
@@ -286,18 +301,20 @@ def run(
             circuits_2: (Parametrized) quantum circuits preparing :math:`|\phi\rangle`.
             values_1: Numerical parameters to be bound to the first set of circuits.
             values_2: Numerical parameters to be bound to the second set of circuits.
-            options: Primitive backend runtime options used for circuit execution. The order
-                of priority is\: options in ``run`` method > fidelity's default
-                options > primitive's default setting.
-                Higher priority setting overrides lower priority setting.
+            shots: Number of shots to be used by the underlying sampler. If a single integer is
+                provided, this number will be used for all circuits. If a sequence of integers is
+                provided, they will be used on a per-circuit basis. If none is provided, the
+                fidelity's default number of shots will be used for all circuits. If this number is
+                also set to None, the underlying primitive's default number of shots will be used
+                for all circuits.
 
         Returns:
             Primitive job for the fidelity calculation.
             The job's result is an instance of :class:`.StateFidelityResult`.
         """
-        job = self._run(circuits_1, circuits_2, values_1, values_2, **options)
+        job = self._run(circuits_1, circuits_2, values_1, values_2, shots)
 
-        job.submit()
+        job._submit()
         return job
 
     @staticmethod