Repository: qiskit-community/qiskit-optimization (language: python)

Issue:
Drop python 3.7 support
<!--
⚠️ If you do not respect this template, your pull request will be closed.
⚠️ Your pull request title should be short detailed and understandable for all.
⚠️ Also, please add it in the CHANGELOG file under Unreleased section.
⚠️ If your pull request fixes an open issue, please link to the issue.

✅ I have added the tests to cover my changes.
✅ I have updated the documentation accordingly.
✅ I have read the CONTRIBUTING document.
-->

### Summary

Qiskit has dropped support Python 3.7 and this follows suit for Qiskit Optimization.
follows https://github.com/qiskit-community/qiskit-finance/pull/288

depends on #536 

### Details and comments





Discussion / hints:

Fix patch:
diff --git a/.pylintdict b/.pylintdict
index 23743a822..9b77fe911 100644
--- a/.pylintdict
+++ b/.pylintdict
@@ -6,6 +6,7 @@ aer's
 al
 annealers
 ansatz
+apidocs
 applegate
 args
 arxiv
@@ -83,6 +84,7 @@ hamiltonian
 hamiltonians
 hastings
 hoyer
+https
 ibm
 ide
 imode
diff --git a/README.md b/README.md
index 68e00441f..327fc8cf8 100644
--- a/README.md
+++ b/README.md
@@ -68,10 +68,11 @@ from docplex.mp.model import Model
 from qiskit_optimization.algorithms import MinimumEigenOptimizer
 from qiskit_optimization.translators import from_docplex_mp
 
-from qiskit.utils import algorithm_globals
 from qiskit.primitives import Sampler
-from qiskit.algorithms.minimum_eigensolvers import QAOA
-from qiskit.algorithms.optimizers import SPSA
+
+from qiskit_algorithms.utils import algorithm_globals
+from qiskit_algorithms import QAOA
+from qiskit_algorithms.optimizers import SPSA
 
 # Generate a graph of 4 nodes
 n = 4
diff --git a/docs/conf.py b/docs/conf.py
index 0d7c2784b..bbf80906f 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -197,6 +197,7 @@
     "networkx": ("https://networkx.org/documentation/stable", None),
     "docplex.mp": ("https://ibmdecisionoptimization.github.io/docplex-doc/mp", None),
     "qiskit": ("https://qiskit.org/documentation/", None),
+    "qiskit_algorithms": ("https://qiskit.org/ecosystem/algorithms", None),
 }
 
 html_context = {"analytics_enabled": True}
diff --git a/docs/tutorials/01_quadratic_program.ipynb b/docs/tutorials/01_quadratic_program.ipynb
index 29e994ef5..2a6295c17 100644
--- a/docs/tutorials/01_quadratic_program.ipynb
+++ b/docs/tutorials/01_quadratic_program.ipynb
@@ -18,8 +18,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In this tutorial, we briefly introduce how to build optimization problems using Qiskit's optimization module.\n",
-    "Qiskit introduces the `QuadraticProgram` class to make a model of an optimization problem.\n",
+    "In this tutorial, we briefly introduce how to build optimization problems using Qiskit optimization module.\n",
+    "Qiskit optimization introduces the `QuadraticProgram` class to make a model of an optimization problem.\n",
     "More precisely, it deals with quadratically constrained quadratic programs given as follows:\n",
     "\n",
     "$$\n",
@@ -70,7 +70,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Qiskit's optimization module supports the conversion from Docplex model. You can easily make a model of an optimization problem with Docplex.\n",
+    "Qiskit optimization module supports the conversion from Docplex model. You can easily make a model of an optimization problem with Docplex.\n",
     "You can find the documentation of Docplex at https://ibmdecisionoptimization.github.io/docplex-doc/mp/index.html\n",
     "\n",
     "You can load a Docplex model to `QuadraticProgram` by using `from_docplex_mp` function."
diff --git a/docs/tutorials/02_converters_for_quadratic_programs.ipynb b/docs/tutorials/02_converters_for_quadratic_programs.ipynb
index 878621fb3..fa28ede61 100644
--- a/docs/tutorials/02_converters_for_quadratic_programs.ipynb
+++ b/docs/tutorials/02_converters_for_quadratic_programs.ipynb
@@ -11,11 +11,11 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Optimization problems in Qiskit's optimization module are represented with the `QuadraticProgram` class, which is a generic and powerful representation for optimization problems. In general, optimization algorithms are defined for a certain formulation of a quadratic program, and we need to convert our problem to the right type.\n",
+    "Optimization problems in Qiskit optimization module are represented with the `QuadraticProgram` class, which is a generic and powerful representation for optimization problems. In general, optimization algorithms are defined for a certain formulation of a quadratic program, and we need to convert our problem to the right type.\n",
     "\n",
     "For instance, Qiskit optimization provides several optimization algorithms that can handle [Quadratic Unconstrained Binary Optimization](https://en.wikipedia.org/wiki/Quadratic_unconstrained_binary_optimization) (QUBO) problems. These are mapped to Ising Hamiltonians, for which Qiskit optimization uses the `qiskit.quantum_info.SparsePauliOp` object, and then their ground state is approximated. For this optimization, commonly known algorithms such as VQE or QAOA can be used as underlying routine. See the following tutorial about the [Minimum Eigen Optimizer](./03_minimum_eigen_optimizer.ipynb) for more detail. Note that also other algorithms exist that work differently, such as the `GroverOptimizer`.\n",
     "\n",
-    "To map a problem to the correct input format, the optimization module of Qiskit offers a variety of converters. In this tutorial we're providing an overview on this functionality. Currently, Qiskit contains the following converters.\n",
+    "To map a problem to the correct input format, the optimization module of Qiskit optimization offers a variety of converters. In this tutorial we're providing an overview on this functionality. Currently, Qiskit optimization contains the following converters.\n",
     "\n",
     "- `InequalityToEquality`: convert inequality constraints into equality constraints with additional slack variables.\n",
     "- `IntegerToBinary`: convert integer variables into binary variables and corresponding coefficients.\n",
diff --git a/docs/tutorials/03_minimum_eigen_optimizer.ipynb b/docs/tutorials/03_minimum_eigen_optimizer.ipynb
index 4090735ac..3639a2c9a 100644
--- a/docs/tutorials/03_minimum_eigen_optimizer.ipynb
+++ b/docs/tutorials/03_minimum_eigen_optimizer.ipynb
@@ -24,25 +24,25 @@
     "An interesting class of optimization problems to be addressed by quantum computing are Quadratic Unconstrained Binary Optimization (QUBO) problems.\n",
     "Finding the solution to a QUBO is equivalent to finding the ground state of a corresponding Ising Hamiltonian, which is an important problem not only in optimization, but also in quantum chemistry and physics. For this translation, the binary variables taking values in $\\{0, 1\\}$ are replaced by spin variables taking values in $\\{-1, +1\\}$, which allows one to replace the resulting spin variables by Pauli Z matrices, and thus, an Ising Hamiltonian. For more details on this mapping we refer to [1].\n",
     "\n",
-    "Qiskit provides automatic conversion from a suitable `QuadraticProgram` to an Ising Hamiltonian, which then allows leveraging all the `SamplingMinimumEigensolver` implementations, such as\n",
+    "Qiskit optimization provides automatic conversion from a suitable `QuadraticProgram` to an Ising Hamiltonian, which then allows leveraging all the `SamplingMinimumEigensolver` implementations, such as\n",
     "\n",
     "- `SamplingVQE`,\n",
     "- `QAOA`, or\n",
     "- `NumpyMinimumEigensolver` (classical exact method).\n",
     "\n",
-    "Note 1: `MinimumEigenOptimizer` does not support `qiskit.algorithms.minimum_eigensolver.VQE`. But `qiskit.algorithms.minimum_eigensolver.SamplingVQE`\n",
+    "Note 1: `MinimumEigenOptimizer` does not support `qiskit_algorithms.VQE`. But `qiskit_algorithms.SamplingVQE`\n",
     "can be used instead.\n",
     "\n",
     "Note 2: `MinimumEigenOptimizer` can use `NumpyMinimumEigensolver` as an exception case though it inherits `MinimumEigensolver` (not `SamplingMinimumEigensolver`).\n",
     "\n",
-    "Qiskit Optimization provides a the `MinimumEigenOptimizer` class, which wraps the translation to an Ising Hamiltonian (in Qiskit Terra also called `Operator`), the call to a `MinimumEigensolver`, and the translation of the results back to an `OptimizationResult`.\n",
+    "Qiskit optimization provides a the `MinimumEigenOptimizer` class, which wraps the translation to an Ising Hamiltonian (in Qiskit Terra also called `SparsePauliOp`), the call to a `MinimumEigensolver`, and the translation of the results back to an `OptimizationResult`.\n",
     "\n",
-    "In the following we first illustrate the conversion from a `QuadraticProgram` to an `Operator` and then show how to use the `MinimumEigenOptimizer` with different `MinimumEigensolver`s to solve a given `QuadraticProgram`.\n",
-    "The algorithms in Qiskit automatically try to convert a given problem to the supported problem class if possible, for instance, the `MinimumEigenOptimizer` will automatically translate integer variables to binary variables or add linear equality constraints as a quadratic penalty term to the objective. It should be mentioned that a `QiskitOptimizationError` will be thrown if conversion of a quadratic program with integer variables is attempted.\n",
+    "In the following we first illustrate the conversion from a `QuadraticProgram` to a `SparsePauliOp` and then show how to use the `MinimumEigenOptimizer` with different `MinimumEigensolver`s to solve a given `QuadraticProgram`.\n",
+    "The algorithms in Qiskit optimization automatically try to convert a given problem to the supported problem class if possible, for instance, the `MinimumEigenOptimizer` will automatically translate integer variables to binary variables or add linear equality constraints as a quadratic penalty term to the objective. It should be mentioned that a `QiskitOptimizationError` will be thrown if conversion of a quadratic program with integer variables is attempted.\n",
     "\n",
     "The circuit depth of `QAOA` potentially has to be increased with the problem size, which might be prohibitive for near-term quantum devices.\n",
     "A possible workaround is Recursive QAOA, as introduced in [2].\n",
-    "Qiskit generalizes this concept to the `RecursiveMinimumEigenOptimizer`, which is introduced at the end of this tutorial.\n",
+    "Qiskit optimization generalizes this concept to the `RecursiveMinimumEigenOptimizer`, which is introduced at the end of this tutorial.\n",
     "\n",
     "### References\n",
     "[1] [A. Lucas, *Ising formulations of many NP problems,* Front. Phys., 12 (2014).](https://arxiv.org/abs/1302.5843)\n",
@@ -55,7 +55,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Converting a QUBO to an Operator"
+    "## Converting a QUBO to a SparsePauliOp"
    ]
   },
   {
@@ -64,9 +64,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from qiskit.utils import algorithm_globals\n",
-    "from qiskit.algorithms.minimum_eigensolvers import QAOA, NumPyMinimumEigensolver\n",
-    "from qiskit.algorithms.optimizers import COBYLA\n",
+    "from qiskit_algorithms.utils import algorithm_globals\n",
+    "from qiskit_algorithms import QAOA, NumPyMinimumEigensolver\n",
+    "from qiskit_algorithms.optimizers import COBYLA\n",
     "from qiskit.primitives import Sampler\n",
     "from qiskit_optimization.algorithms import (\n",
     "    MinimumEigenOptimizer,\n",
@@ -118,7 +118,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Next we translate this QUBO into an Ising operator. This results not only in an `Operator` but also in a constant offset to be taken into account to shift the resulting value."
+    "Next we translate this QUBO into an Ising operator. This results not only in a `SparsePauliOp` but also in a constant offset to be taken into account to shift the resulting value."
    ]
   },
   {
@@ -149,7 +149,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Sometimes a `QuadraticProgram` might also directly be given in the form of an `Operator`. For such cases, Qiskit also provides a translator from an `Operator` back to a `QuadraticProgram`, which we illustrate in the following."
+    "Sometimes a `QuadraticProgram` might also directly be given in the form of a `SparsePauliOp`. For such cases, Qiskit optimization also provides a translator from a `SparsePauliOp` back to a `QuadraticProgram`, which we illustrate in the following."
    ]
   },
   {
@@ -186,7 +186,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "This translator allows, for instance, one to translate an `Operator` to a `QuadraticProgram` and then solve the problem with other algorithms that are not based on the Ising Hamiltonian representation, such as the `GroverOptimizer`."
+    "This translator allows, for instance, one to translate a `SparsePauliOp` to a `QuadraticProgram` and then solve the problem with other algorithms that are not based on the Ising Hamiltonian representation, such as the `GroverOptimizer`."
    ]
   },
   {
diff --git a/docs/tutorials/04_grover_optimizer.ipynb b/docs/tutorials/04_grover_optimizer.ipynb
index 1c42bd06a..d0d1b75f8 100644
--- a/docs/tutorials/04_grover_optimizer.ipynb
+++ b/docs/tutorials/04_grover_optimizer.ipynb
@@ -43,9 +43,9 @@
     "</div>\n",
     "<br>\n",
     "\n",
-    "```GroverOptimizer``` uses ```QuadraticProgramToNegativeValueOracle``` to construct $A_y$ such that it prepares a $n$-qubit register to represent the equal superposition of all $|x\\rangle_n$ and a $m$-qubit register to (approximately) represent the corresponding $|Q(x)-y\\rangle_m$. Then, all states with $(Q(x) - y)$ negative should be flagged by $O_y$. Note that in the implementation discussed, the oracle operator is actually independent of $y$, but this is not a requirement. For clarity, we will refer to the oracle as $O$ when the oracle is independent of $y$.\n",
+    "`GroverOptimizer` uses `QuadraticProgramToNegativeValueOracle` to construct $A_y$ such that it prepares a $n$-qubit register to represent the equal superposition of all $|x\\rangle_n$ and a $m$-qubit register to (approximately) represent the corresponding $|Q(x)-y\\rangle_m$. Then, all states with $(Q(x) - y)$ negative should be flagged by $O_y$. Note that in the implementation discussed, the oracle operator is actually independent of $y$, but this is not a requirement. For clarity, we will refer to the oracle as $O$ when the oracle is independent of $y$.\n",
     "\n",
-    "Put formally, ```QuadraticProgramToNegativeValueOracle``` constructs an $A_y$ and $O$ such that:\n",
+    "Put formally, `QuadraticProgramToNegativeValueOracle` constructs an $A_y$ and $O$ such that:\n",
     "\n",
     "<br>\n",
     "<div>\n",
@@ -69,7 +69,7 @@
     "\\min_{x \\in \\{0, 1\\}^3} -2x_0x_2 - x_1x_2 - 1x_0 + 2x_1 - 3x_2.\n",
     "\\end{eqnarray}\n",
     "\n",
-    "For our initial steps, we create a docplex model that defines the problem above, and then use the ```from_docplex_mp()``` function to convert the model to a ```QuadraticProgram```, which can be used to represent a QUBO in Qiskit Optimization."
+    "For our initial steps, we create a docplex model that defines the problem above, and then use the `from_docplex_mp()` function to convert the model to a `QuadraticProgram`, which can be used to represent a QUBO in Qiskit Optimization."
    ]
   },
   {
@@ -78,7 +78,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver\n",
+    "from qiskit_algorithms import NumPyMinimumEigensolver\n",
     "from qiskit.primitives import Sampler\n",
     "from qiskit_optimization.algorithms import GroverOptimizer, MinimumEigenOptimizer\n",
     "from qiskit_optimization.translators import from_docplex_mp\n",
@@ -173,7 +173,7 @@
    "source": [
     "## Check that GroverOptimizer finds the correct value\n",
     "\n",
-    "We can verify that the algorithm is working correctly using the `MinimumEigenOptimizer` in Qiskit."
+    "We can verify that the algorithm is working correctly using the `MinimumEigenOptimizer` in Qiskit optimization."
    ]
   },
   {
diff --git a/docs/tutorials/05_admm_optimizer.ipynb b/docs/tutorials/05_admm_optimizer.ipynb
index ee4102b15..cf760d5d7 100644
--- a/docs/tutorials/05_admm_optimizer.ipynb
+++ b/docs/tutorials/05_admm_optimizer.ipynb
@@ -87,8 +87,8 @@
     "\n",
     "from docplex.mp.model import Model\n",
     "\n",
-    "from qiskit.algorithms.minimum_eigensolvers import QAOA, NumPyMinimumEigensolver\n",
-    "from qiskit.algorithms.optimizers import COBYLA\n",
+    "from qiskit_algorithms import QAOA, NumPyMinimumEigensolver\n",
+    "from qiskit_algorithms.optimizers import COBYLA\n",
     "from qiskit.primitives import Sampler\n",
     "from qiskit_optimization.algorithms import CobylaOptimizer, MinimumEigenOptimizer\n",
     "from qiskit_optimization.algorithms.admm_optimizer import ADMMParameters, ADMMOptimizer\n",
@@ -205,7 +205,7 @@
    "source": [
     "## Classical Solution\n",
     "\n",
-    "3-ADMM-H needs a QUBO optimizer to solve the QUBO subproblem, and a continuous optimizer to solve the continuous convex constrained subproblem. We first solve the problem classically: we use the `MinimumEigenOptimizer` with the `NumPyMinimumEigenSolver` as a classical and exact QUBO solver and we use the `CobylaOptimizer` as a continuous convex solver. 3-ADMM-H supports any other suitable solver available in Qiskit. For instance, `SamplingVQE`, `QAOA`, and `GroverOptimizer` can be invoked as quantum solvers, as demonstrated later.\n",
+    "3-ADMM-H needs a QUBO optimizer to solve the QUBO subproblem, and a continuous optimizer to solve the continuous convex constrained subproblem. We first solve the problem classically: we use the `MinimumEigenOptimizer` with the `NumPyMinimumEigenSolver` as a classical and exact QUBO solver and we use the `CobylaOptimizer` as a continuous convex solver. 3-ADMM-H supports any other suitable solver available in Qiskit optimization. For instance, `SamplingVQE`, `QAOA`, and `GroverOptimizer` can be invoked as quantum solvers, as demonstrated later.\n",
     "If CPLEX is installed, the `CplexOptimizer` can also be used as both, a QUBO and convex solver."
    ]
   },
diff --git a/docs/tutorials/06_examples_max_cut_and_tsp.ipynb b/docs/tutorials/06_examples_max_cut_and_tsp.ipynb
index df2c67b54..42a79bac2 100644
--- a/docs/tutorials/06_examples_max_cut_and_tsp.ipynb
+++ b/docs/tutorials/06_examples_max_cut_and_tsp.ipynb
@@ -25,7 +25,7 @@
     "\n",
     "Maximization: profit, value, output, return, yield, utility, efficiency, capacity, number of objects \n",
     "\n",
-    "We consider here max-cut problems of practical interest in many fields, and show how they can be mapped on quantum computers manually and how Qiskit's optimization module supports this.\n",
+    "We consider here max-cut problems of practical interest in many fields, and show how they can be mapped on quantum computers manually and how Qiskit optimization module supports this.\n",
     "\n",
     "\n",
     "### Weighted Max-Cut\n",
@@ -50,7 +50,7 @@
     "\n",
     "$$ H = \\sum_i w_i Z_i + \\sum_{i<j} w_{ij} Z_iZ_j.$$\n",
     "\n",
-    "Qiskit's optimization module can generate the Ising Hamiltonian for the first profit function $\\tilde{C}$.\n",
+    "Qiskit optimization module can generate the Ising Hamiltonian for the first profit function $\\tilde{C}$.\n",
     "To this extent, function $\\tilde{C}$ can be modeled as a `QuadraticProgram`, which provides the `to_ising()` method.\n",
     "\n",
     "\n",
@@ -118,9 +118,9 @@
     "from qiskit.tools.visualization import plot_histogram\n",
     "from qiskit.circuit.library import TwoLocal\n",
     "from qiskit_optimization.applications import Maxcut, Tsp\n",
-    "from qiskit.algorithms.minimum_eigensolvers import SamplingVQE, NumPyMinimumEigensolver\n",
-    "from qiskit.algorithms.optimizers import SPSA\n",
-    "from qiskit.utils import algorithm_globals\n",
+    "from qiskit_algorithms import SamplingVQE, NumPyMinimumEigensolver\n",
+    "from qiskit_algorithms.optimizers import SPSA\n",
+    "from qiskit_algorithms.utils import algorithm_globals\n",
     "from qiskit.primitives import Sampler\n",
     "from qiskit_optimization.algorithms import MinimumEigenOptimizer"
    ]
@@ -281,7 +281,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Qiskit provides functionality to generate `QuadraticProgram` from the problem specification as well as create the corresponding Ising Hamiltonian.\n"
+    "Qiskit optimization provides functionality to generate `QuadraticProgram` from the problem specification as well as create the corresponding Ising Hamiltonian.\n"
    ]
   },
   {
diff --git a/docs/tutorials/07_examples_vehicle_routing.ipynb b/docs/tutorials/07_examples_vehicle_routing.ipynb
index ac72c649a..e73a9acb9 100644
--- a/docs/tutorials/07_examples_vehicle_routing.ipynb
+++ b/docs/tutorials/07_examples_vehicle_routing.ipynb
@@ -147,7 +147,7 @@
     "c = 2An +2AK^2.\n",
     "$$\n",
     "\n",
-    "The QP formulation of the Ising Hamiltonian is ready for the use of VQE. We will solve the QP using optimization stack available in Qiskit.\n",
+    "The QP formulation of the Ising Hamiltonian is ready for the use of VQE. We will solve the QP using optimization stack available in Qiskit optimization.\n",
     "\n",
     "\n",
     "\n",
@@ -188,9 +188,9 @@
     "    print(\"Warning: Cplex not found.\")\n",
     "import math\n",
     "\n",
-    "from qiskit.utils import algorithm_globals\n",
-    "from qiskit.algorithms.minimum_eigensolvers import SamplingVQE\n",
-    "from qiskit.algorithms.optimizers import SPSA\n",
+    "from qiskit_algorithms.utils import algorithm_globals\n",
+    "from qiskit_algorithms import SamplingVQE\n",
+    "from qiskit_algorithms.optimizers import SPSA\n",
     "from qiskit.circuit.library import RealAmplitudes\n",
     "from qiskit.primitives import Sampler"
    ]
diff --git a/docs/tutorials/08_cvar_optimization.ipynb b/docs/tutorials/08_cvar_optimization.ipynb
index 738a121fe..b980b0e5c 100644
--- a/docs/tutorials/08_cvar_optimization.ipynb
+++ b/docs/tutorials/08_cvar_optimization.ipynb
@@ -15,7 +15,7 @@
    "source": [
     "## Introduction\n",
     "\n",
-    "This notebook shows how to use the Conditional Value at Risk (CVaR) objective function introduced in [1] within the variational quantum optimization algorithms provided by Qiskit. Particularly, it is shown how to setup the `MinimumEigenOptimizer` using `SamplingVQE` accordingly. \n",
+    "This notebook shows how to use the Conditional Value at Risk (CVaR) objective function introduced in [1] within the variational quantum optimization algorithms provided by [Qiskit Algorithms](https://qiskit.org/ecosystem/algorithms/). Particularly, it is shown how to setup the `MinimumEigenOptimizer` using `SamplingVQE` accordingly. \n",
     "For a given set of shots with corresponding objective values of the considered optimization problem, the CVaR with confidence level $\\alpha \\in [0, 1]$ is defined as the average of the $\\alpha$ best shots.\n",
     "Thus, $\\alpha = 1$ corresponds to the standard expected value, while $\\alpha=0$ corresponds to the minimum of the given shots, and $\\alpha \\in (0, 1)$ is a tradeoff between focusing on better shots, but still applying some averaging to smoothen the optimization landscape.\n",
     "\n",
@@ -32,13 +32,13 @@
    "outputs": [],
    "source": [
     "from qiskit.circuit.library import RealAmplitudes\n",
-    "from qiskit.algorithms.optimizers import COBYLA\n",
-    "from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver, SamplingVQE\n",
+    "from qiskit_algorithms.optimizers import COBYLA\n",
+    "from qiskit_algorithms import NumPyMinimumEigensolver, SamplingVQE\n",
+    "from qiskit_algorithms.utils import algorithm_globals\n",
     "from qiskit.primitives import Sampler\n",
     "from qiskit_optimization.converters import LinearEqualityToPenalty\n",
     "from qiskit_optimization.algorithms import MinimumEigenOptimizer\n",
     "from qiskit_optimization.translators import from_docplex_mp\n",
-    "from qiskit.utils import algorithm_globals\n",
     "\n",
     "import numpy as np\n",
     "import matplotlib.pyplot as plt\n",
diff --git a/docs/tutorials/09_application_classes.ipynb b/docs/tutorials/09_application_classes.ipynb
index bedee79a1..de9ff4268 100644
--- a/docs/tutorials/09_application_classes.ipynb
+++ b/docs/tutorials/09_application_classes.ipynb
@@ -72,9 +72,9 @@
    "outputs": [],
    "source": [
     "from qiskit_optimization.algorithms import MinimumEigenOptimizer\n",
-    "from qiskit.utils import algorithm_globals\n",
-    "from qiskit.algorithms.minimum_eigensolvers import QAOA, NumPyMinimumEigensolver\n",
-    "from qiskit.algorithms.optimizers import COBYLA\n",
+    "from qiskit_algorithms.utils import algorithm_globals\n",
+    "from qiskit_algorithms import QAOA, NumPyMinimumEigensolver\n",
+    "from qiskit_algorithms.optimizers import COBYLA\n",
     "from qiskit.primitives import Sampler"
    ]
   },
diff --git a/docs/tutorials/10_warm_start_qaoa.ipynb b/docs/tutorials/10_warm_start_qaoa.ipynb
index d237caaa4..7fbe256cb 100644
--- a/docs/tutorials/10_warm_start_qaoa.ipynb
+++ b/docs/tutorials/10_warm_start_qaoa.ipynb
@@ -44,10 +44,10 @@
     "from docplex.mp.model import Model\n",
     "\n",
     "# Qiskit imports\n",
-    "from qiskit.algorithms.minimum_eigensolvers import QAOA, NumPyMinimumEigensolver\n",
-    "from qiskit.algorithms.optimizers import COBYLA\n",
+    "from qiskit_algorithms import QAOA, NumPyMinimumEigensolver\n",
+    "from qiskit_algorithms.optimizers import COBYLA\n",
+    "from qiskit_algorithms.utils.algorithm_globals import algorithm_globals\n",
     "from qiskit.primitives import Sampler\n",
-    "from qiskit.utils.algorithm_globals import algorithm_globals\n",
     "from qiskit_optimization.algorithms import MinimumEigenOptimizer, CplexOptimizer\n",
     "from qiskit_optimization import QuadraticProgram\n",
     "from qiskit_optimization.problems.variable import VarType\n",
@@ -309,7 +309,7 @@
     "\n",
     "### Standard QAOA\n",
     "\n",
-    "First, we use standard QAOA to solve the QUBO. To do this, we convert the QUBO to Qiskit's QuadraticProgram class (note that the resulting problem is still a binary problem)."
+    "First, we use standard QAOA to solve the QUBO. To do this, we convert the QUBO to `QuadraticProgram` class (note that the resulting problem is still a binary problem)."
    ]
   },
   {
diff --git a/docs/tutorials/11_using_classical_optimization_solvers_and_models.ipynb b/docs/tutorials/11_using_classical_optimization_solvers_and_models.ipynb
index 60dd6bddb..65859d797 100644
--- a/docs/tutorials/11_using_classical_optimization_solvers_and_models.ipynb
+++ b/docs/tutorials/11_using_classical_optimization_solvers_and_models.ipynb
@@ -182,8 +182,8 @@
    "source": [
     "from qiskit_optimization.algorithms import MinimumEigenOptimizer\n",
     "\n",
-    "from qiskit.algorithms.minimum_eigensolvers import QAOA\n",
-    "from qiskit.algorithms.optimizers import COBYLA\n",
+    "from qiskit_algorithms import QAOA\n",
+    "from qiskit_algorithms.optimizers import COBYLA\n",
     "from qiskit.primitives import Sampler\n",
     "\n",
     "meo = MinimumEigenOptimizer(QAOA(sampler=Sampler(), optimizer=COBYLA(maxiter=100)))\n",
diff --git a/qiskit_optimization/__init__.py b/qiskit_optimization/__init__.py
index 56c5cdd66..489a08436 100644
--- a/qiskit_optimization/__init__.py
+++ b/qiskit_optimization/__init__.py
@@ -11,12 +11,12 @@
 # that they have been altered from the originals.
 """
 =========================================================
-Qiskit's optimization module (:mod:`qiskit_optimization`)
+Qiskit optimization module (:mod:`qiskit_optimization`)
 =========================================================
 
 .. currentmodule:: qiskit_optimization
 
-Qiskit's optimization module covers the whole range from high-level modeling of optimization
+Qiskit optimization module covers the whole range from high-level modeling of optimization
 problems, with automatic conversion of problems to different required representations,
 to a suite of easy-to-use quantum optimization algorithms that are ready to run on
 classical simulators, as well as on real quantum devices via Qiskit.
@@ -26,16 +26,18 @@
 A uniform interface as well as automatic conversion between different problem representations
 allows users to solve problems using a large set of algorithms, from variational quantum algorithms,
 such as the Quantum Approximate Optimization Algorithm
-(:class:`~qiskit.algorithms.minimum_eigensolver.QAOA`), to
+(:class:`~qiskit_algorithms.QAOA`), to
 `Grover Adaptive Search <https://arxiv.org/abs/quant-ph/9607014>`_
 (:class:`~algorithms.GroverOptimizer`), leveraging
-fundamental :mod:`~qiskit.algorithms.minimum_eigensolver` provided by Qiskit Terra.
+fundamental `minimum eigensolvers <https://qiskit.org/ecosystem/algorithms/apidocs/
+qiskit_algorithms.html#minimum-eigensolvers>`_ provided by
+`Qiskit Algorithms <https://qiskit.org/ecosystem/algorithms/>`_.
 Furthermore, the modular design
 of the optimization module allows it to be easily extended and facilitates rapid development and
 testing of new algorithms. Compatible classical optimizers are also provided for testing,
 validation, and benchmarking.
 
-Qiskit's optimization module supports Quadratically Constrained Quadratic Programs – for simplicity
+Qiskit optimization module supports Quadratically Constrained Quadratic Programs – for simplicity
 we refer to them just as Quadratic Programs – with binary, integer, and continuous variables, as
 well as equality and inequality constraints. This class of optimization problems has a vast amount
 of relevant applications, while still being efficiently representable by matrices and vectors.
diff --git a/qiskit_optimization/algorithms/admm_optimizer.py b/qiskit_optimization/algorithms/admm_optimizer.py
index 62268e3b0..51d47a9c4 100644
--- a/qiskit_optimization/algorithms/admm_optimizer.py
+++ b/qiskit_optimization/algorithms/admm_optimizer.py
@@ -17,7 +17,7 @@
 from typing import List, Optional, Tuple, cast
 
 import numpy as np
-from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver
+from qiskit_algorithms import NumPyMinimumEigensolver
 
 from ..converters import MaximizeToMinimize
 from ..problems.constraint import Constraint
@@ -220,7 +220,7 @@ def __init__(
         Args:
             qubo_optimizer: An instance of OptimizationAlgorithm that can effectively solve
                 QUBO problems. If not specified then :class:`MinimumEigenOptimizer` initialized
-                with an instance of :class:`NumPyMinimumEigensolver` will be used.
+                with an instance of ``NumPyMinimumEigensolver`` will be used.
             continuous_optimizer: An instance of OptimizationAlgorithm that can solve
                 continuous problems. If not specified then :class:`SlsqpOptimizer` will be used.
             params: An instance of ADMMParameters.
diff --git a/qiskit_optimization/algorithms/cobyla_optimizer.py b/qiskit_optimization/algorithms/cobyla_optimizer.py
index 478124fd1..36ee2583c 100644
--- a/qiskit_optimization/algorithms/cobyla_optimizer.py
+++ b/qiskit_optimization/algorithms/cobyla_optimizer.py
@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2020, 2021.
+# (C) Copyright IBM 2020, 2023.
 #
 # 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
@@ -10,7 +10,7 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""The COBYLA optimizer wrapped to be used within Qiskit's optimization module."""
+"""The COBYLA optimizer wrapped to be used within Qiskit optimization module."""
 
 from typing import Optional, cast, List, Tuple, Any
 
diff --git a/qiskit_optimization/algorithms/cplex_optimizer.py b/qiskit_optimization/algorithms/cplex_optimizer.py
index 521c2e25a..5eee2d9f8 100644
--- a/qiskit_optimization/algorithms/cplex_optimizer.py
+++ b/qiskit_optimization/algorithms/cplex_optimizer.py
@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2020, 2022.
+# (C) Copyright IBM 2020, 2023.
 #
 # 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
@@ -10,7 +10,7 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""The CPLEX optimizer wrapped to be used within Qiskit's optimization module."""
+"""The CPLEX optimizer wrapped to be used within Qiskit optimization module."""
 
 from typing import Any, Dict, Optional
 from warnings import warn
diff --git a/qiskit_optimization/algorithms/grover_optimizer.py b/qiskit_optimization/algorithms/grover_optimizer.py
index 25270135c..f0f43eaa8 100644
--- a/qiskit_optimization/algorithms/grover_optimizer.py
+++ b/qiskit_optimization/algorithms/grover_optimizer.py
@@ -19,11 +19,11 @@
 
 import numpy as np
 from qiskit import QuantumCircuit, QuantumRegister
-from qiskit.algorithms import AmplificationProblem
-from qiskit.algorithms.amplitude_amplifiers.grover import Grover
 from qiskit.circuit.library import QuadraticForm
 from qiskit.primitives import BaseSampler
-from qiskit.utils import algorithm_globals
+from qiskit_algorithms import AmplificationProblem
+from qiskit_algorithms.amplitude_amplifiers.grover import Grover
+from qiskit_algorithms.utils import algorithm_globals
 
 from qiskit_optimization.algorithms.optimization_algorithm import (
     OptimizationAlgorithm,
@@ -122,7 +122,7 @@ def is_good_state(measurement):
         return oracle, is_good_state
 
     def solve(self, problem: QuadraticProgram) -> OptimizationResult:
-        """Tries to solves the given problem using the grover optimizer.
+        """Tries to solve the given problem using the grover optimizer.
 
         Runs the optimizer to try to solve the optimization problem. If the problem cannot be,
         converted to a QUBO, this optimizer raises an exception due to incompatibility.
diff --git a/qiskit_optimization/algorithms/gurobi_optimizer.py b/qiskit_optimization/algorithms/gurobi_optimizer.py
index 32ed66781..860947bc3 100644
--- a/qiskit_optimization/algorithms/gurobi_optimizer.py
+++ b/qiskit_optimization/algorithms/gurobi_optimizer.py
@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2020, 2022.
+# (C) Copyright IBM 2020, 2023.
 #
 # 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
@@ -10,7 +10,7 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""The Gurobi optimizer wrapped to be used within Qiskit's optimization module."""
+"""The Gurobi optimizer wrapped to be used within Qiskit optimization module."""
 
 import qiskit_optimization.optionals as _optionals
 from ..exceptions import QiskitOptimizationError
diff --git a/qiskit_optimization/algorithms/minimum_eigen_optimizer.py b/qiskit_optimization/algorithms/minimum_eigen_optimizer.py
index ef5364449..c2f6fd8fa 100644
--- a/qiskit_optimization/algorithms/minimum_eigen_optimizer.py
+++ b/qiskit_optimization/algorithms/minimum_eigen_optimizer.py
@@ -14,14 +14,13 @@
 from typing import List, Optional, Union, cast
 
 import numpy as np
-from qiskit.algorithms.minimum_eigensolvers import (
-    VQE,
+from qiskit.quantum_info import SparsePauliOp
+from qiskit_algorithms import (
     NumPyMinimumEigensolver,
     NumPyMinimumEigensolverResult,
     SamplingMinimumEigensolver,
     SamplingMinimumEigensolverResult,
 )
-from qiskit.quantum_info import SparsePauliOp
 
 from ..converters.quadratic_program_to_qubo import QuadraticProgramConverter, QuadraticProgramToQubo
 from ..exceptions import QiskitOptimizationError
@@ -52,7 +51,7 @@ def __init__(
     ) -> None:
         """
         Args:
-            x: the optimal value found by ``MinimumEigensolver``.
+            x: the optimal value found by ``SamplingMinimumEigensolver`` or ``NumPyMinimumEigensolver``.
             fval: the optimal function value.
             variables: the list of variables of the optimization problem.
             status: the termination status of the optimization algorithm.
@@ -75,15 +74,18 @@ def __init__(
 
     @property
     def min_eigen_solver_result(self) -> MinimumEigensolverResult:
-        """Returns a result object obtained from the instance of :class:`MinimumEigensolver`."""
+        """Returns a result object obtained from the instance of
+        ``SamplingMinimumEigensolver`` or ``NumPyMinimumEigensolver``."""
         return self._min_eigen_solver_result
 
     @property
     def raw_samples(self) -> Optional[List[SolutionSample]]:
-        """Returns the list of raw solution samples of ``MinimumEigensolver``.
+        """Returns the list of raw solution samples of
+        ``SamplingMinimumEigensolver`` or ``NumPyMinimumEigensolver``.
 
         Returns:
-            The list of raw solution samples of ``MinimumEigensolver``.
+            The list of raw solution samples of
+            ``SamplingMinimumEigensolver`` or ``NumPyMinimumEigensolver``.
         """
         return self._raw_samples
 
@@ -107,7 +109,7 @@ class MinimumEigenOptimizer(OptimizationAlgorithm):
 
     .. code-block::
 
-        from qiskit.algorithms.minimum_eigensolver import QAOA
+        from qiskit_algorithms import QAOA
         from qiskit_optimization.problems import QuadraticProgram
         from qiskit_optimization.algorithms import MinimumEigenOptimizer
         problem = QuadraticProgram()
@@ -144,22 +146,6 @@ def __init__(
             TypeError: When one of converters has an invalid type.
             QiskitOptimizationError: When the minimum eigensolver does not return an eigenstate.
         """
-        if isinstance(min_eigen_solver, VQE):
-            raise TypeError(
-                "MinimumEigenOptimizer does not support this VQE. You can use  "
-                "qiskit.algorithms.minimum_eigensolvers.SamplingVQE instead."
-            )
-        if not isinstance(
-            min_eigen_solver,
-            (SamplingMinimumEigensolver, NumPyMinimumEigensolver),
-        ):
-            raise TypeError(
-                "MinimumEigenOptimizer supports "
-                "qiskit.algorithms.minimum_eigensolvers.SamplingMinimumEigensolver, "
-                "qiskit.algorithms.minimum_eigensolvers.NumPyMinimumEigensolver, and "
-                "qiskit.algorithms.minimum_eigen_solvers.MinimumEigensolver. "
-                f"But {type(min_eigen_solver)} is given."
-            )
         if not min_eigen_solver.supports_aux_operators():
             raise QiskitOptimizationError(
                 "Given MinimumEigensolver does not return the eigenstate "
@@ -232,6 +218,12 @@ def _solve_internal(
             eigen_result = self._min_eigen_solver.compute_minimum_eigenvalue(operator)
             # analyze results
             raw_samples = None
+            if not hasattr(eigen_result, "eigenstate"):
+                raise QiskitOptimizationError(
+                    "MinimumEigenOptimizer does not support this minimum eigensolver "
+                    f"{type(self._min_eigen_solver)}. "
+                    "You can use qiskit_algorithms.SamplingMinimumEigensolver instead."
+                )
             if eigen_result.eigenstate is not None:
                 raw_samples = self._eigenvector_to_solutions(
                     eigen_result.eigenstate, converted_problem
diff --git a/qiskit_optimization/algorithms/optimization_algorithm.py b/qiskit_optimization/algorithms/optimization_algorithm.py
index 1742d62db..fb6cee1ad 100644
--- a/qiskit_optimization/algorithms/optimization_algorithm.py
+++ b/qiskit_optimization/algorithms/optimization_algorithm.py
@@ -10,7 +10,7 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""An abstract class for optimization algorithms in Qiskit's optimization module."""
+"""An abstract class for optimization algorithms in Qiskit optimization module."""
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
@@ -290,7 +290,7 @@ def samples(self) -> List[SolutionSample]:
 
 
 class OptimizationAlgorithm(ABC):
-    """An abstract class for optimization algorithms in Qiskit's optimization module."""
+    """An abstract class for optimization algorithms in Qiskit optimization module."""
 
     _MIN_PROBABILITY = 1e-6
 
diff --git a/qiskit_optimization/algorithms/recursive_minimum_eigen_optimizer.py b/qiskit_optimization/algorithms/recursive_minimum_eigen_optimizer.py
index c3149f3fc..b080bd331 100644
--- a/qiskit_optimization/algorithms/recursive_minimum_eigen_optimizer.py
+++ b/qiskit_optimization/algorithms/recursive_minimum_eigen_optimizer.py
@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2020, 2022.
+# (C) Copyright IBM 2020, 2023.
 #
 # 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
@@ -10,15 +10,15 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""A recursive minimal eigen optimizer in Qiskit's optimization module."""
+"""A recursive minimal eigen optimizer in Qiskit optimization module."""
 
 from copy import deepcopy
 from enum import Enum
 from typing import Dict, List, Optional, Tuple, Union, cast
 
 import numpy as np
-from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver
 from qiskit.utils.validation import validate_min
+from qiskit_algorithms import NumPyMinimumEigensolver
 
 from ..converters.quadratic_program_to_qubo import QuadraticProgramConverter, QuadraticProgramToQubo
 from ..exceptions import QiskitOptimizationError
@@ -117,7 +117,7 @@ class RecursiveMinimumEigenOptimizer(OptimizationAlgorithm):
 
     .. code-block:: python
 
-        from qiskit.algorithms.minimum_eigensolver import QAOA
+        from qiskit_algorithms import QAOA
         from qiskit_optimization.problems import QuadraticProgram
         from qiskit_optimization.algorithms import (
             MinimumEigenOptimizer, RecursiveMinimumEigenOptimizer
@@ -161,7 +161,7 @@ def __init__(
             min_num_vars_optimizer: This optimizer is used after the recursive scheme for the
                 problem with the remaining variables. Default value is
                 :class:`~qiskit_optimization.algorithms.MinimumEigenOptimizer` created on top of
-                :class:`~qiskit.algorithms.minimum_eigensolver.NumPyMinimumEigensolver`.
+                :class:`~qiskit_algorithms.NumPyMinimumEigensolver`.
             penalty: The factor that is used to scale the penalty terms corresponding to linear
                 equality constraints.
             history: Whether the intermediate results are stored.
diff --git a/qiskit_optimization/algorithms/scipy_milp_optimizer.py b/qiskit_optimization/algorithms/scipy_milp_optimizer.py
index ec86c0af8..10060d9fb 100644
--- a/qiskit_optimization/algorithms/scipy_milp_optimizer.py
+++ b/qiskit_optimization/algorithms/scipy_milp_optimizer.py
@@ -10,7 +10,7 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""The SciPy MILP optimizer wrapped to be used within Qiskit's optimization module."""
+"""The SciPy MILP optimizer wrapped to be used within Qiskit optimization module."""
 
 from warnings import warn
 
diff --git a/qiskit_optimization/algorithms/slsqp_optimizer.py b/qiskit_optimization/algorithms/slsqp_optimizer.py
index e634305b5..df60af6cd 100644
--- a/qiskit_optimization/algorithms/slsqp_optimizer.py
+++ b/qiskit_optimization/algorithms/slsqp_optimizer.py
@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2020, 2021.
+# (C) Copyright IBM 2020, 2023.
 #
 # 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
@@ -10,7 +10,7 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""The SLSQP optimizer wrapped to be used within Qiskit's optimization module."""
+"""The SLSQP optimizer wrapped to be used within Qiskit optimization module."""
 from typing import List, cast, Tuple, Any, Union, Optional
 
 import numpy as np
diff --git a/qiskit_optimization/algorithms/warm_start_qaoa_optimizer.py b/qiskit_optimization/algorithms/warm_start_qaoa_optimizer.py
index 8f2eba1c0..8432ecd00 100644
--- a/qiskit_optimization/algorithms/warm_start_qaoa_optimizer.py
+++ b/qiskit_optimization/algorithms/warm_start_qaoa_optimizer.py
@@ -18,8 +18,8 @@
 
 import numpy as np
 from qiskit import QuantumCircuit
-from qiskit.algorithms.minimum_eigensolvers import QAOA
 from qiskit.circuit import Parameter
+from qiskit_algorithms import QAOA
 
 from ..converters.quadratic_program_converter import QuadraticProgramConverter
 from ..exceptions import QiskitOptimizationError
diff --git a/qiskit_optimization/applications/tsp.py b/qiskit_optimization/applications/tsp.py
index fe6a57c7f..4777397ff 100644
--- a/qiskit_optimization/applications/tsp.py
+++ b/qiskit_optimization/applications/tsp.py
@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2018, 2022.
+# (C) Copyright IBM 2018, 2023.
 #
 # 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,12 +16,13 @@
 import networkx as nx
 import numpy as np
 from docplex.mp.model import Model
+from qiskit_algorithms.utils import algorithm_globals
 
-from qiskit.utils import algorithm_globals
 from qiskit_optimization.algorithms import OptimizationResult
 from qiskit_optimization.exceptions import QiskitOptimizationError
 from qiskit_optimization.problems import QuadraticProgram
 from qiskit_optimization.translators import from_docplex_mp
+
 from .graph_optimization_application import GraphOptimizationApplication
 
 
diff --git a/qiskit_optimization/converters/quadratic_program_converter.py b/qiskit_optimization/converters/quadratic_program_converter.py
index df508a40c..db5a1743d 100644
--- a/qiskit_optimization/converters/quadratic_program_converter.py
+++ b/qiskit_optimization/converters/quadratic_program_converter.py
@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2020, 2021.
+# (C) Copyright IBM 2020, 2023.
 #
 # 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
@@ -10,7 +10,7 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""An abstract class for optimization algorithms in Qiskit's optimization module."""
+"""An abstract class for optimization algorithms in Qiskit optimization module."""
 
 from abc import ABC, abstractmethod
 from typing import List, Union
@@ -22,7 +22,7 @@
 
 class QuadraticProgramConverter(ABC):
     """
-    An abstract class for converters of quadratic programs in Qiskit's optimization module.
+    An abstract class for converters of quadratic programs in Qiskit optimization module.
     """
 
     @abstractmethod
diff --git a/qiskit_optimization/exceptions.py b/qiskit_optimization/exceptions.py
index dc827da0f..c44b94bc0 100644
--- a/qiskit_optimization/exceptions.py
+++ b/qiskit_optimization/exceptions.py
@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2019, 2021.
+# (C) Copyright IBM 2019, 2023.
 #
 # 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
@@ -10,12 +10,12 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-""" Optimization Exception """
+""" Qiskit Optimization Exception """
 
 from qiskit.exceptions import QiskitError
 
 
 class QiskitOptimizationError(QiskitError):
-    """Class for errors returned by Qiskit's optimization module."""
+    """Class for errors returned by Qiskit optimization module."""
 
     pass
diff --git a/releasenotes/notes/switch-to-qiskit-algorithms-b0af38fe547bf5b5.yaml b/releasenotes/notes/switch-to-qiskit-algorithms-b0af38fe547bf5b5.yaml
new file mode 100644
index 000000000..311faab40
--- /dev/null
+++ b/releasenotes/notes/switch-to-qiskit-algorithms-b0af38fe547bf5b5.yaml
@@ -0,0 +1,24 @@
+---
+prelude: >
+    Qiskit Optimization 0.6 switches from ``qiskit.algorithms`` of Qiskit Terra
+    to `Qiskit Algorithms <https://qiskit.org/ecosystem/algorithms/>`_.
+    Qiskit Optimization 0.6 drops supports of the former algorithms based on
+    ``qiskit.algorithms`` and ``QuantumInstance`` of Qiskit Terra.
+
+features:
+  - |
+    The :class:`~.MinimumEigenOptimizer` class takes the primitives-based algorithms
+    (:class:`qiskit_algorithms.SamplingMinimumEigensolver` and
+    :class:`qiskit_algorithms.NumPyMinimumEigensolver`)
+    of `Qiskit Algorithms <https://qiskit.org/ecosystem/algorithms/>`_
+    as ``min_eigen_solver`` argument.
+    The supports of the former algorithms based on ``qiskit.algorithms`` and ``QuantumInstance``
+    are removed.
+  - |
+    The :class:`~.WarmStartQAOAOptimizer` class takes the primitives-based QAOA
+    (:class:`qiskit_algorithms.minimum_eigensolvers.QAOA`) as ``qaoa`` argument.
+    The support of the former QAOA algorithms based on ``qiskit.algorithms`` is removed.
+  - |
+    The :class:`~.GroverOptimizer` class drops the support of ``QuantumInstance``
+    and argument `quantum_instance` is removed. It supports only the Sampler primitive now.
+
diff --git a/requirements.txt b/requirements.txt
index aabc815c5..b79012feb 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,5 @@
 qiskit>=0.44
+qiskit-algorithms>=0.2.0
 scipy>=1.4
 numpy>=1.17
 docplex>=2.21.207,!=2.24.231


Test patch:
diff --git a/test/algorithms/test_grover_optimizer.py b/test/algorithms/test_grover_optimizer.py
index c748bf702..a0094be08 100644
--- a/test/algorithms/test_grover_optimizer.py
+++ b/test/algorithms/test_grover_optimizer.py
@@ -17,9 +17,10 @@
 
 import numpy as np
 from docplex.mp.model import Model
-from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver
-from qiskit.utils import algorithm_globals
+from qiskit.utils import optionals
 from qiskit_aer.primitives import Sampler
+from qiskit_algorithms import NumPyMinimumEigensolver
+from qiskit_algorithms.utils import algorithm_globals
 
 from qiskit_optimization.algorithms import (
     GroverOptimizer,
@@ -40,6 +41,7 @@
 class TestGroverOptimizer(QiskitOptimizationTestCase):
     """GroverOptimizer tests."""
 
+    @unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required to run this test")
     def setUp(self):
         super().setUp()
         algorithm_globals.random_seed = 1
diff --git a/test/algorithms/test_min_eigen_optimizer.py b/test/algorithms/test_min_eigen_optimizer.py
index 622f0efa0..0135b2525 100644
--- a/test/algorithms/test_min_eigen_optimizer.py
+++ b/test/algorithms/test_min_eigen_optimizer.py
@@ -17,17 +17,14 @@
 
 import numpy as np
 from ddt import data, ddt, unpack
-from qiskit.algorithms.minimum_eigensolvers import QAOA, VQE, NumPyMinimumEigensolver, SamplingVQE
-from qiskit.algorithms.optimizers import COBYLA, SPSA
 from qiskit.circuit.library import TwoLocal
 from qiskit.primitives import Estimator, Sampler
-from qiskit.utils import algorithm_globals
+from qiskit_algorithms import QAOA, VQE, NumPyMinimumEigensolver, SamplingVQE
+from qiskit_algorithms.optimizers import COBYLA, SPSA
+from qiskit_algorithms.utils import algorithm_globals
 
 import qiskit_optimization.optionals as _optionals
-from qiskit_optimization.algorithms import (
-    CplexOptimizer,
-    MinimumEigenOptimizer,
-)
+from qiskit_optimization.algorithms import CplexOptimizer, MinimumEigenOptimizer
 from qiskit_optimization.algorithms.optimization_algorithm import OptimizationResultStatus
 from qiskit_optimization.converters import (
     InequalityToEquality,
@@ -36,6 +33,7 @@
     MaximizeToMinimize,
     QuadraticProgramToQubo,
 )
+from qiskit_optimization.exceptions import QiskitOptimizationError
 from qiskit_optimization.problems import QuadraticProgram
 
 
@@ -333,9 +331,10 @@ def test_errors(self):
         optimizer = SPSA(maxiter=100)
         ry_ansatz = TwoLocal(5, "ry", "cz", reps=3, entanglement="full")
         estimator = Estimator()
-        vqe = VQE(estimator, ry_ansatz, optimizer)
-        with self.assertRaises(TypeError):
-            _ = MinimumEigenOptimizer(vqe)
+        vqe_mes = VQE(estimator, ry_ansatz, optimizer)
+        vqe = MinimumEigenOptimizer(vqe_mes)
+        with self.assertRaises(QiskitOptimizationError):
+            _ = vqe.solve(self.op_ordering)
 
 
 if __name__ == "__main__":
diff --git a/test/algorithms/test_recursive_optimization.py b/test/algorithms/test_recursive_optimization.py
index ec8c6d9cc..82665f45b 100644
--- a/test/algorithms/test_recursive_optimization.py
+++ b/test/algorithms/test_recursive_optimization.py
@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2018, 2022.
+# (C) Copyright IBM 2018, 2023.
 #
 # 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,10 +16,10 @@
 from test import QiskitOptimizationTestCase
 
 import numpy as np
-from qiskit.algorithms.minimum_eigensolvers import QAOA, NumPyMinimumEigensolver
-from qiskit.algorithms.optimizers import SLSQP
 from qiskit.primitives import Sampler
-from qiskit.utils import algorithm_globals
+from qiskit_algorithms import QAOA, NumPyMinimumEigensolver
+from qiskit_algorithms.optimizers import SLSQP
+from qiskit_algorithms.utils import algorithm_globals
 
 import qiskit_optimization.optionals as _optionals
 from qiskit_optimization.algorithms import (
diff --git a/test/algorithms/test_warm_start_qaoa.py b/test/algorithms/test_warm_start_qaoa.py
index be83a392b..2849dac2a 100644
--- a/test/algorithms/test_warm_start_qaoa.py
+++ b/test/algorithms/test_warm_start_qaoa.py
@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2021, 2022.
+# (C) Copyright IBM 2021, 2023.
 #
 # 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
@@ -17,9 +17,9 @@
 
 import numpy as np
 from docplex.mp.model import Model
-from qiskit.algorithms.minimum_eigensolvers import QAOA
-from qiskit.algorithms.optimizers import SLSQP
 from qiskit.primitives.sampler import Sampler
+from qiskit_algorithms import QAOA
+from qiskit_algorithms.optimizers import SLSQP
 
 import qiskit_optimization.optionals as _optionals
 from qiskit_optimization.algorithms import SlsqpOptimizer
diff --git a/test/converters/test_converters.py b/test/converters/test_converters.py
index f90eb386b..132d9fe9a 100644
--- a/test/converters/test_converters.py
+++ b/test/converters/test_converters.py
@@ -17,8 +17,8 @@
 
 import numpy as np
 from docplex.mp.model import Model
-from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver
 from qiskit.quantum_info import SparsePauliOp
+from qiskit_algorithms import NumPyMinimumEigensolver
 
 import qiskit_optimization.optionals as _optionals
 from qiskit_optimization import QiskitOptimizationError, QuadraticProgram