---
# System prepended metadata

title: Using Qiskit Dynamic Solvers to solve mean-variance portfolio optimization problem using quantum computation.

---

# Using Qiskit Dynamic Solvers to solve mean-variance portfolio optimization problem using quantum computation.

The mean-variance portfolio optimization problem involves finding the optimal allocation of assets to minimize risk and maximize expected returns. The main components of the problem are:

1. **Expected returns**: The average return of each asset in the portfolio. Mathematically, it's given by the equation:

   `E(R) = w^T * r`

   where `E(R)` is the expected return, `w` is the vector of asset weights, `T` is the transpose operator, and `r` is the vector of asset returns.

2. **Portfolio variance**: The risk associated with the portfolio, given by:

   `Var(R) = w^T * Σ * w`

   where `Var(R)` is the portfolio variance, `Σ` is the covariance matrix of asset returns, and `w` is the vector of asset weights.

The objective is to minimize the portfolio variance while maintaining a target expected return. This can be formulated as a constrained optimization problem:

   `minimize w^T * Σ * w` subject to `w^T * r = R_target` and `w^T * 1 = 1`

To use Qiskit Dynamics Solvers to solve this problem, follow these steps:

1. Map the problem to a Quadratic Unconstrained Binary Optimization (QUBO) problem.
2. Convert the QUBO problem to an Ising Hamiltonian.
3. Use the Qiskit Dynamics Solvers to find the ground state of the Hamiltonian.

```Python
from qiskit_optimization.applications import PortfolioOptimization
from qiskit_optimization.converters import QuadraticProgramToQubo
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit import Aer
from qiskit.algorithms import VQE
from qiskit.utils import QuantumInstance

# Define the problem using the PortfolioOptimization class
portfolio = PortfolioOptimization(expected_returns, covariance_matrix, target_return)

# Create a QuadraticProgram and convert it to a QUBO problem
qp = portfolio.to_quadratic_program()
qubo_converter = QuadraticProgramToQubo()
qubo = qubo_converter.convert(qp)

# Define the Hamiltonian, and use the Qiskit Dynamics Solver to find the ground state
hamiltonian = qubo.to_ising()
quantum_instance = QuantumInstance(Aer.get_backend('statevector_simulator'))
solver = VQE(quantum_instance=quantum_instance)
optimizer = MinimumEigenOptimizer(solver)
result = optimizer.solve(qubo)

# Interpret the result and obtain the optimal portfolio
optimal_portfolio = portfolio.interpret(result)
```

The optimal portfolio is the allocation of assets that minimizes risk and achieves the target expected return. The Qiskit Dynamics Solvers help in finding the ground state of the Hamiltonian, which corresponds to the optimal solution for the given set of parameters.

****

Sources:[ Introduction to Reaction-Diffusion Computers](https://media.licdn.com/dms/document/C561FAQHSHMkZZNIw4g/feedshare-document-pdf-analyzed/0/1675273343817?e=1683763200&v=beta&t=ZplVrmB9kBCZfMvzN8_3JBZydSi-dG-JK4f2ZT7Q5V4) - Jules Becci-Morin de la Rivière 27/01/2023

<iframe src="https://media.licdn.com/dms/document/C561FAQHSHMkZZNIw4g/feedshare-document-pdf-analyzed/0/1675273343817?e=1683763200&v=beta&t=ZplVrmB9kBCZfMvzN8_3JBZydSi-dG-JK4f2ZT7Q5V4" width="100%" height="500"" title="Iframe Example"></iframe>

****





