Remove VariationalForm and InitialState (Qiskit/qiskit#6064)

* Remove VariationalForm

* Remove legacy option: preferred_init_point

* Add reno

* Remove mentioning of `variational_form` from docs

* Replace legacy InitialState with pure QuantumCircuit

* Remove reno

* Revert "Remove legacy option: preferred_init_point"

This reverts commit 95f94e5b447fe15e51608d66c5aa2c642dd60888.

* Review comments

Co-authored-by: Julien Gacon <gaconju@gmail.com>

Co-authored-by: Julien Gacon <gaconju@gmail.com>
Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

qiskit_algorithms/__init__.py

@@ -17,8 +17,7 @@
 carry out research and investigate how to solve problems in different domains on
 near-term quantum devices with short depth circuits.
 
-Algorithms configuration includes the use of :mod:`~qiskit.algorithms.optimizers`
-and :mod:`~qiskit.algorithms.variational_forms` which
+Algorithms configuration includes the use of :mod:`~qiskit.algorithms.optimizers` which
 were designed to be swappable sub-parts of an algorithm. Any component and may be exchanged for
 a different implementation of the same component type in order to potentially alter the behavior
 and outcome of the algorithm.

qiskit_algorithms/minimum_eigen_solvers/vqe.py

@@ -32,7 +32,6 @@
 from qiskit.utils.backend_utils import is_aer_provider
 from qiskit.utils.quantum_instance import QuantumInstance
 from ..optimizers import Optimizer, SLSQP
-from ..variational_forms import VariationalForm
 from ..variational_algorithm import VariationalAlgorithm, VariationalResult
 from .minimum_eigen_solver import MinimumEigensolver, MinimumEigensolverResult
 from ..exceptions import AlgorithmError
@@ -51,11 +50,11 @@ class VQE(VariationalAlgorithm, MinimumEigensolver):
     the minimum eigenvalue of the Hamiltonian :math:`H` of a given system.
 
     An instance of VQE requires defining two algorithmic sub-components:
-    a trial state (ansatz) from  :mod:`~qiskit.algorithms.variational_forms`, and one
-    of the classical :mod:`~qiskit.algorithms.optimizers`. The ansatz is varied, via its set
-    of parameters, by the optimizer, such that it works towards a state, as determined by the
-    parameters applied to the variational form, that will result in the minimum expectation value
-    being measured of the input operator (Hamiltonian).
+    a trial state (a.k.a. ansatz) which is a :class:`QuantumCircuit`, and one of the classical
+    :mod:`~qiskit.algorithms.optimizers`. The ansatz is varied, via its set of parameters, by the
+    optimizer, such that it works towards a state, as determined by the parameters applied to the
+    variational form, that will result in the minimum expectation value being measured of the input
+    operator (Hamiltonian).
 
     An optional array of parameter values, via the *initial_point*, may be provided as the
     starting point for the search of the minimum eigenvalue. This feature is particularly useful
@@ -87,7 +86,7 @@ class VQE(VariationalAlgorithm, MinimumEigensolver):
     """
 
     def __init__(self,
-                 var_form: Optional[Union[QuantumCircuit, VariationalForm]] = None,
+                 var_form: Optional[QuantumCircuit] = None,
                  optimizer: Optional[Optimizer] = None,
                  initial_point: Optional[np.ndarray] = None,
                  gradient: Optional[Union[GradientBase, Callable]] = None,
@@ -495,8 +494,6 @@ def get_optimal_circuit(self) -> QuantumCircuit:
         if self._ret.optimal_point is None:
             raise AlgorithmError("Cannot find optimal circuit before running the "
                                  "algorithm to find optimal params.")
-        if isinstance(self.var_form, VariationalForm):
-            return self._var_form.construct_circuit(self._ret.optimal_point)
         return self.var_form.assign_parameters(self._ret.optimal_parameters)
 
     def get_optimal_vector(self) -> Union[List[float], Dict[str, int]]:

qiskit_algorithms/variational_algorithm.py

@@ -26,14 +26,13 @@
 from abc import abstractmethod
 import numpy as np
 
-from qiskit.circuit import QuantumCircuit, ParameterVector
+from qiskit.circuit import QuantumCircuit
 from qiskit.providers import BaseBackend
 from qiskit.providers import Backend
 from qiskit.opflow.gradients import GradientBase
 from qiskit.utils import QuantumInstance, algorithm_globals
 from .algorithm_result import AlgorithmResult
 from .optimizers import Optimizer, SLSQP
-from .variational_forms import VariationalForm
 
 logger = logging.getLogger(__name__)
 
@@ -42,7 +41,7 @@ class VariationalAlgorithm:
     """The Variational Algorithm Base Class."""
 
     def __init__(self,
-                 var_form: Union[QuantumCircuit, VariationalForm],
+                 var_form: QuantumCircuit,
                  optimizer: Optimizer,
                  cost_fn: Optional[Callable] = None,
                  gradient: Optional[Union[GradientBase, Callable]] = None,
@@ -96,20 +95,17 @@ def quantum_instance(self, quantum_instance: Union[QuantumInstance,
         self._quantum_instance = quantum_instance
 
     @property
-    def var_form(self) -> Optional[Union[QuantumCircuit, VariationalForm]]:
+    def var_form(self) -> Optional[QuantumCircuit]:
         """ Returns variational form """
         return self._var_form
 
     @var_form.setter
-    def var_form(self, var_form: Optional[Union[QuantumCircuit, VariationalForm]]):
+    def var_form(self, var_form: Optional[QuantumCircuit]):
         """ Sets variational form """
         if isinstance(var_form, QuantumCircuit):
             # store the parameters
             self._var_form_params = sorted(var_form.parameters, key=lambda p: p.name)
             self._var_form = var_form
-        elif isinstance(var_form, VariationalForm):
-            self._var_form_params = ParameterVector('θ', length=var_form.num_parameters)
-            self._var_form = var_form
         elif var_form is None:
             self._var_form_params = None
             self._var_form = var_form
@@ -138,7 +134,7 @@ def initial_point(self, initial_point: np.ndarray):
 
     def find_minimum(self,
                      initial_point: Optional[np.ndarray] = None,
-                     var_form: Optional[Union[QuantumCircuit, VariationalForm]] = None,
+                     var_form: Optional[QuantumCircuit] = None,
                      cost_fn: Optional[Callable] = None,
                      optimizer: Optional[Optimizer] = None,
                      gradient_fn: Optional[Callable] = None) -> 'VariationalResult':