Replaced deprecated Qiskit classes by their respective replacement functions (#237)

Co-authored-by: Steve Wood <40241007+woodsp-ibm@users.noreply.github.com>

Author: tnemoz

docs/tutorials/01_algorithms_introduction.ipynb

@@ -19,7 +19,7 @@
     "\n",
     "Algorithms are configurable, and part of the configuration will often be in the form of smaller building blocks. For instance `VQE`, the Variational Quantum Eigensolver, it takes a trial wavefunction, in the form of a `QuantumCircuit` and a classical optimizer among other things.\n",
     "\n",
-    "Let's take a look at an example to construct a VQE instance. Here, `TwoLocal` is the variational form (trial wavefunction), a parameterized circuit which can be varied, and `SLSQP` a classical optimizer. These are created as separate instances and passed to VQE when it is constructed. Trying, for example, a different classical optimizer, or variational form is simply a case of creating an instance of the one you want and passing it into VQE."
+    "Let's take a look at an example to construct a VQE instance. Here, `n_local` is the variational form (trial wavefunction), a parameterized circuit which can be varied, and `SLSQP` a classical optimizer. These are created as separate instances and passed to VQE when it is constructed. Trying, for example, a different classical optimizer, or variational form is simply a case of creating an instance of the one you want and passing it into VQE."
    ]
   },
   {

docs/tutorials/02_vqe_advanced_options.ipynb

@@ -81,7 +81,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "You are now ready to compare a set of optimizers through the `VQE` callback. The minimum energy of the H2 Hamiltonian can be found quite easily, so the maximum number of iterations (`maxiter`) does not have to be very large. You can once again use `TwoLocal` as the selected trial wavefunction (i.e. ansatz)."
+    "You are now ready to compare a set of optimizers through the `VQE` callback. The minimum energy of the H2 Hamiltonian can be found quite easily, so the maximum number of iterations (`maxiter`) does not have to be very large. You can once again use `n_local` as the selected trial wavefunction (i.e. ansatz)."
    ]
   },
   {
@@ -528,7 +528,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.13.3"
+   "version": "3.13.5"
   }
  },
  "nbformat": 4,

docs/tutorials/05_qaoa.ipynb

@@ -98,7 +98,7 @@
    "source": [
     "## Imaginary Time Evolution\n",
     "\n",
-    "Imaginary time evolution can be used, for example, to find the ground state or calculate the finite temperature expectation value of the system. Here, we will use the `VarQITE` class from `time_evolvers.variational` to compute a ground state energy. Firstly, we need to choose an ansatz. We can use `EfficientSU2` to easily construct an ansatz, setting the number of repetitions using `reps`."
+    "Imaginary time evolution can be used, for example, to find the ground state or calculate the finite temperature expectation value of the system. Here, we will use the `VarQITE` class from `time_evolvers.variational` to compute a ground state energy. Firstly, we need to choose an ansatz. We can use `efficient_su2` to easily construct an ansatz, setting the number of repetitions using `reps`."
    ]
   },
   {
@@ -948,7 +948,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.13.3"
+   "version": "3.13.5"
   }
  },
  "nbformat": 4,

docs/tutorials/06_grover.ipynb

@@ -1,6 +1,6 @@
 # This code is part of a Qiskit project.
 #
-# (C) Copyright IBM 2021, 2024.
+# (C) Copyright IBM 2021, 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
@@ -16,7 +16,7 @@
 from collections.abc import Callable
 from typing import Any, List, cast
 
-from qiskit.circuit import QuantumCircuit
+from qiskit.circuit import QuantumCircuit, Gate
 from qiskit.circuit.library import GroverOperator
 from qiskit.quantum_info import Statevector
 
@@ -32,7 +32,7 @@ class AmplificationProblem:
     # pylint: disable=too-many-positional-arguments
     def __init__(
         self,
-        oracle: QuantumCircuit | Statevector,
+        oracle: QuantumCircuit | Gate | Statevector,
         state_preparation: QuantumCircuit | None = None,
         grover_operator: QuantumCircuit | None = None,
         post_processing: Callable[[str], Any] | None = None,
@@ -41,7 +41,9 @@ def __init__(
     ) -> None:
         r"""
         Args:
-            oracle: The oracle reflecting about the bad states.
+            oracle: The oracle reflecting about the bad states. If a
+                :class:`~qiskit.circuit.library.Gate` is passed, it will be converted to a
+                :class:`~qiskit.circuit.QuantumCircuit`.
             state_preparation: A circuit preparing the input state, referred to as
                 :math:`\mathcal{A}`. If None, a layer of Hadamard gates is used.
             grover_operator: The Grover operator :math:`\mathcal{Q}` used as unitary in the
@@ -52,19 +54,26 @@ def __init__(
                 If None, all qubits will be measured. The ``is_good_state`` function will be
                 applied on the measurement outcome of these qubits.
             is_good_state: A function to check whether a string represents a good state. By default
-                if the ``oracle`` argument has an ``evaluate_bitstring`` method (currently only
-                provided by the :class:`~qiskit.circuit.library.PhaseOracle` class) this will be
-                used, otherwise this kwarg is required and **must** be specified.
+                if the ``oracle`` argument has a ``boolean_expression`` attribute (currently only
+                provided by the :class:`~qiskit.circuit.library.PhaseOracle` and
+                :class:`~qiskit.circuit.library.PhaseOracleGate` classes) this will be
+                used for the check, otherwise this kwarg is required and **must** be specified.
         """
-        self._oracle = oracle
+        if isinstance(oracle, Gate):
+            self._oracle = QuantumCircuit(oracle.num_qubits).compose(oracle)
+        else:
+            self._oracle = oracle
+
         self._state_preparation = state_preparation
         self._grover_operator = grover_operator
         self._post_processing = post_processing
         self._objective_qubits = objective_qubits
         if is_good_state is not None:
             self._is_good_state = is_good_state
-        elif hasattr(oracle, "evaluate_bitstring"):
-            self._is_good_state = oracle.evaluate_bitstring
+        elif hasattr(oracle, "boolean_expression"):
+            self._is_good_state = lambda bitstring: oracle.boolean_expression.simulate(
+                bitstring[::-1]
+            )
         else:
             self._is_good_state = None
 

docs/tutorials/07_grover_examples.ipynb

@@ -18,6 +18,7 @@
 from __future__ import annotations
 
 import logging
+import warnings
 from collections.abc import Callable, Sequence, Iterable
 from time import time
 from typing import Any, cast
@@ -213,6 +214,18 @@ def _check_operator_ansatz(self, operator: BaseOperator):
                 # try to set the number of qubits on the ansatz, if possible
                 try:
                     self.ansatz.num_qubits = operator.num_qubits
+                    warnings.warn(
+                        "Previously, it was possible to pass to VQD a BlueprintCircuit as an "
+                        "ansatz without its number of qubits being set, the algorithm taking care "
+                        "of setting it. Since BlueprintCircuits are now  deprecated, and those "
+                        "being the only ones that can have their number of qubits set after their "
+                        "initialization, this behavior is now also deprecated, and won't be "
+                        "supported once the oldest supported Qiskit version is 3.0. As such, users "
+                        "that made use of this feature would now need to ensure that the ansatz "
+                        "they pass to these algorithms have their number of qubits set and matching "
+                        "with that of the operator they wish to run the algorithm on.",
+                        category=DeprecationWarning,
+                    )
                 except AttributeError as exc:
                     raise AlgorithmError(
                         "The number of qubits of the ansatz does not match the "

docs/tutorials/11_VarQTE.ipynb

@@ -15,11 +15,14 @@
 
 import logging
 import re
+import warnings
+from collections.abc import Sequence
 from enum import Enum
 from typing import Iterable
 
 import numpy as np
-from qiskit.circuit.library import EvolvedOperatorAnsatz
+from qiskit import QuantumCircuit
+from qiskit.circuit.library import EvolvedOperatorAnsatz, evolved_operator_ansatz
 from qiskit.quantum_info import SparsePauliOp
 from qiskit.quantum_info.operators.base_operator import BaseOperator
 from qiskit.version import get_version_info as get_qiskit_version_info
@@ -62,6 +65,7 @@ class AdaptVQE(VariationalAlgorithm, MinimumEigensolver):
       from qiskit_algorithms.optimizers import SLSQP
       from qiskit.primitives import StatevectorEstimator
       from qiskit.circuit.library import EvolvedOperatorAnsatz
+      from qiskit import QuantumCircuit
 
       # get your Hamiltonian
       hamiltonian = ...
@@ -73,6 +77,11 @@ class AdaptVQE(VariationalAlgorithm, MinimumEigensolver):
 
       adapt_vqe = AdaptVQE(vqe)
 
+      # or you can do it without EvolvedOperatorAnsatz
+      vqe = VQE(StatevectorEstimator(), QuantumCircuit(1), SLSQP())
+
+      adapt_vqe = AdaptVQE(vqe, operators=...)
+
       eigenvalue, _ = adapt_vqe.compute_minimum_eigenvalue(hamiltonian)
 
     The following attributes can be set via the initializer but can also be read and updated once
@@ -81,7 +90,8 @@ class AdaptVQE(VariationalAlgorithm, MinimumEigensolver):
     Attributes:
         solver: a :class:`~.VQE` instance used internally to compute the minimum eigenvalues.
             It is a requirement that the :attr:`~.VQE.ansatz` of this solver is of type
-            :class:`~qiskit.circuit.library.EvolvedOperatorAnsatz`.
+            :class:`~qiskit.circuit.library.EvolvedOperatorAnsatz` if the `operators` arguments is
+            not set.
         gradient_threshold: once all gradients have an absolute value smaller than this threshold,
             the algorithm has converged and terminates.
         eigenvalue_threshold: once the eigenvalue has changed by less than this threshold from one
@@ -100,12 +110,25 @@ def __init__(
         gradient_threshold: float = 1e-5,
         eigenvalue_threshold: float = 1e-5,
         max_iterations: int | None = None,
+        operators: BaseOperator | Sequence[BaseOperator] | None = None,
+        reps: int = 1,
+        evolution=None,
+        insert_barriers: bool = False,
+        name: str = "EvolvedOps",
+        parameter_prefix: str | Sequence[str] = "t",
+        remove_identities: bool = True,
+        initial_state: QuantumCircuit | None = None,
+        flatten: bool | None = None,
     ) -> None:
         """
         Args:
             solver: a :class:`~.VQE` instance used internally to compute the minimum eigenvalues.
-                It is a requirement that the :attr:`~.VQE.ansatz` of this solver is of type
-                :class:`~qiskit.circuit.library.EvolvedOperatorAnsatz`.
+                It is a requirement that either the :attr:`~.VQE.ansatz` of this solver is of type
+                :class:`~qiskit.circuit.library.EvolvedOperatorAnsatz` or that the `operators`
+                argument is specified. The former is deprecated from the 0.4 version of
+                qiskit-algorithms and this option won't be possible anymore once the oldest
+                supported Qiskit version is 3.0. In the latter case, this class will build its own
+                ansatz using the evolved_operator_ansatz function.
             gradient_threshold: once all gradients have an absolute value smaller than this
                 threshold, the algorithm has converged and terminates. Defaults to ``1e-5``.
             eigenvalue_threshold: once the eigenvalue has changed by less than this threshold from
@@ -115,18 +138,75 @@ def __init__(
                 are not considered.
             max_iterations: the maximum number of iterations for the adaptive loop. If ``None``, the
                 algorithm is not bound in its number of iterations.
+            operators: used to build the ansatz using the
+                :func:`~qiskit.circuit.library.evolved_operator_ansatz` function. If set, the
+                ansatz of the underlying :class:`.VQE` solver won't be used.
+            reps: used to build the ansatz using the
+                :func:`~qiskit.circuit.library.evolved_operator_ansatz` function.
+            evolution: used to build the ansatz using the
+                :func:`~qiskit.circuit.library.evolved_operator_ansatz` function.
+            insert_barriers: used to build the ansatz using the
+                :func:`~qiskit.circuit.library.evolved_operator_ansatz` function.
+            name: used to build the ansatz using the
+                :func:`~qiskit.circuit.library.evolved_operator_ansatz` function.
+            parameter_prefix: used to build the ansatz using the
+                :func:`~qiskit.circuit.library.evolved_operator_ansatz` function.
+            remove_identities: used to build the ansatz using the
+                :func:`~qiskit.circuit.library.evolved_operator_ansatz` function.
+            initial_state: a :class:`~qiskit.circuit.QuantumCircuit` object to prepend to the
+                ansatz.
+            flatten: used to build the ansatz using the
+                :func:`~qiskit.circuit.library.evolved_operator_ansatz` function.
         """
         validate_min("gradient_threshold", gradient_threshold, 1e-15)
         validate_min("eigenvalue_threshold", eigenvalue_threshold, 1e-15)
 
         self.solver = solver
+
+        if (
+            not isinstance(self.solver._original_ansatz, EvolvedOperatorAnsatz)
+            and operators is None
+        ):
+            raise TypeError(
+                "The AdaptVQE ansatz must be of the EvolvedOperatorAnsatz type or the operators "
+                "argument must be set."
+            )
+        if operators is not None:
+            if not isinstance(operators, list):
+                operators = list(operators)
+
+            self._excitation_pool: list[BaseOperator] = operators
+            self._initial_state = (
+                initial_state
+                if initial_state is not None
+                else QuantumCircuit(operators[0].num_qubits)
+            )
+        else:
+            warnings.warn(
+                "The :class:`~qiskit.circuit.library.EvolvedOperatorAnsatz` is deprecated "
+                "as of Qiskit 2.1 and will be removed in Qiskit 3.0. Use the keywords arguments of"
+                "the AdaptVQE's constructor to specify the ansatz instead. Passing the ansatz via the "
+                "underlying :class:`.VQE` solver is deprecated as of qiskit-algorithms 0.4 and "
+                "won't be supported anymore one the oldest supported Qiskit version is 3.0.",
+                category=DeprecationWarning,
+            )
+            self._excitation_pool = self.solver._original_ansatz.operators
+
         self.gradient_threshold = gradient_threshold
         self.eigenvalue_threshold = eigenvalue_threshold
         self.max_iterations = max_iterations
         self._tmp_ansatz: EvolvedOperatorAnsatz | None = None
-        self._excitation_pool: list[BaseOperator] = []
         self._excitation_list: list[BaseOperator] = []
 
+        self._operators = operators
+        self._reps = reps
+        self._evolution = evolution
+        self._insert_barriers = insert_barriers
+        self._name = name
+        self._parameter_prefix = parameter_prefix
+        self._remove_identities = remove_identities
+        self._flatten = flatten
+
     @property
     def initial_point(self) -> np.ndarray | None:
         """Returns the initial point of the internal :class:`~.VQE` solver."""
@@ -198,6 +278,21 @@ def _check_cyclicity(indices: list[int]) -> bool:
         # nature of the algorithm.
         return match is not None or (len(indices) > 1 and indices[-2] == indices[-1])
 
+    def _build_ansatz(self) -> QuantumCircuit:
+        """Builds the ansatz out of the provided parameters."""
+        return self._initial_state.compose(
+            evolved_operator_ansatz(
+                operators=self._operators,
+                reps=self._reps,
+                evolution=self._evolution,
+                insert_barriers=self._insert_barriers,
+                name=self._name,
+                parameter_prefix=self._parameter_prefix,
+                remove_identities=self._remove_identities,
+                flatten=self._flatten,
+            )
+        )
+
     def compute_minimum_eigenvalue(
         self,
         operator: BaseOperator,
@@ -219,14 +314,12 @@ def compute_minimum_eigenvalue(
             includes runtime information about the AdaptVQE algorithm like the number of iterations,
             termination criterion, and the final maximum gradient.
         """
-        if not isinstance(self.solver._original_ansatz, EvolvedOperatorAnsatz):
-            raise TypeError("The AdaptVQE ansatz must be of the EvolvedOperatorAnsatz type.")
-
         # Overwrite the solver's ansatz with the initial state
-        self._tmp_ansatz = self.solver._original_ansatz
-        self._excitation_pool = self._tmp_ansatz.operators
-        # This will transpile the initial state if the solver has a transpiler that is set
-        self.solver.ansatz = self._tmp_ansatz.initial_state
+        if self._operators is not None:
+            self.solver.ansatz = self._initial_state
+        elif isinstance(self.solver._original_ansatz, EvolvedOperatorAnsatz):
+            self._tmp_ansatz = self.solver._original_ansatz
+            self.solver.ansatz = self._tmp_ansatz.initial_state
 
         prev_op_indices: list[int] = []
         raw_vqe_result: VQEResult | None = None
@@ -284,8 +377,13 @@ def compute_minimum_eigenvalue(
             self._excitation_list.append(self._excitation_pool[max_grad_index])
             theta.append(0.0)
             # setting up the ansatz for the VQE iteration
-            self._tmp_ansatz.operators = self._excitation_list
-            self.solver.ansatz = self._tmp_ansatz
+            if self._operators is not None:
+                self._operators = self._excitation_list
+                self.solver.ansatz = self._build_ansatz()
+            else:
+                self._tmp_ansatz.operators = self._excitation_list
+                self.solver.ansatz = self._tmp_ansatz
+
             self.solver.initial_point = np.asarray(theta)
             # evaluating the eigenvalue with the internal VQE
             prev_raw_vqe_result = raw_vqe_result
@@ -306,8 +404,13 @@ def compute_minimum_eigenvalue(
                     )
                     self._excitation_list.pop()
                     theta.pop()
-                    self._tmp_ansatz.operators = self._excitation_list
-                    self.solver.ansatz = self._tmp_ansatz
+                    if self._operators is not None:
+                        self._operators = self._excitation_list
+                        self.solver.ansatz = self._build_ansatz()
+                    else:
+                        self._tmp_ansatz.operators = self._excitation_list
+                        self.solver.ansatz = self._tmp_ansatz
+
                     self.solver.initial_point = np.asarray(theta)
                     raw_vqe_result = prev_raw_vqe_result
                     break
@@ -354,7 +457,7 @@ def compute_minimum_eigenvalue(
             result.aux_operators_evaluated = aux_values  # type: ignore[assignment]
 
         logger.info("The final eigenvalue is: %s", str(result.eigenvalue))
-        self.solver.ansatz.operators = self._excitation_pool
+
         return result