docs/tutorials/02_portfolio_diversification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Portfolio Diversification\n",
    "\n",
    "\n",
    "## Introduction \n",
    "\n",
    "In asset management, there are broadly two approaches: active and passive investment management. Within passive investment management, there are index-tracking funds and there are approaches based on portfolio diversification, which aim at representing a portfolio with a large number of assets by a smaller number of representative stocks.\n",
    "This notebook illustrates a portfolio diversification problem, which has recently become popular for two reasons:\n",
    "1. it makes it possible to mimic the performance of an index (or a similarly large set of assets) with a limited budget, at limited transaction costs. That is: traditional index-tracking may purchase all assets in the index, ideally with the same weights as in the index. This may be impractical for a number of reasons: the total of even a single round lot per asset may amount to more than the assets under management, the large scale of the index-tracking problem with integrality constraints may render the optimization problem difficult, and the transaction costs of the frequent rebalancing to adjust the positions to the weights in the index may render the approach expensive. Thus, a popular approach is to select a portfolio of $q$ assets that represent the market with $n$ assets, where $q$ is significantly smaller than $n$, but where the portfolio replicates the behavior of the underlying market. To determine how to group assets into $q$ clusters and how to determine which $q$ assets should represent the $q$ clusters amounts to solving a large-scale optimization problem. In the following we describe the mathematical model for the portfolio diversification problem as introduced in [Cornuejols & Tutuncu, 2006] \n",
    "2. it allows for similarity measures between time-series beyond the covariance matrix. Notice that traditionally, modern portfolio theory considers the covariance matrix as a measure of similarity between the assets. As such, however, the covariance matrix is imperfect. Consider, for instance, a company listed both in London and New York. Although both listings should be very similar, only parts of the time series of the prices of the two listings will overlap, because of the partial overlap of the times the markets open. Instead of covariance, one can consider, for example, dynamic time warping of [Berndt and Clifford, 1994] as a measure of similarity between two time series, which allows for the fact that for some time periods, the data are captured by only one of the time series, while for others, both time series exhibit the similarity due to the parallel evolution of the stock price.\n",
    "\n",
    "The overall workflow we demonstrate comprises:\n",
    "\n",
    "1. pick the ground set of assets. In our case, this is a small number of US stocks.\n",
    "\n",
    "2. load the time series capturing the evolution of the prices of assets. In our case, this is a simplistic load of adjusted daily closing price data from Wikipedia or Nasdaq or LSE or EuroNext, whereas in a real asset management, a much higher frequency may be considered.\n",
    "\n",
    "3. compute the pair-wise similarity among the time series. In our case, we run a linear-time approximation of the dynamic time warping, still on the classical computer.\n",
    "\n",
    "4. compute the actual portfolio of $q$ representative assets, based on the similarity measure. This step is run twice, actually. First, we obtain a reference value by a run of an IBM solver (IBM ILOG CPLEX or the Exact Eigensolver) on the classical computer. Second, we run an alternative, hybrid algorithm partly on the quantum computer.\n",
    "\n",
    "5. visualization of the results. In our case, this is again a simplistic plot.\n",
    "\n",
    "In the following, we first explain the model used in (4) above, before we proceed with the installation of the pre-requisites and the data loading.\n",
    "\n",
    "\n",
    "## The Model\n",
    "\n",
    "As discussed in [Cornuejols & Tutuncu, 2006], we describe a mathematical model that clusters assets into groups of similar ones and selects one representative asset from each group to be included in the index fund portfolio. The model is based on the following data, which we will discuss in more detail later:\n",
    "\n",
    "$$\n",
    "\\rho_{ij} = \\textrm{similarity}\\, \\textrm{between}\\, \\textrm{stock}\\, i \\, \\textrm{and}\\, \\textrm{stock}\\, j.\n",
    "$$\n",
    "\n",
    "For example, $\\rho_{ii} = 1$, $\\rho_{ij} \\leq  1$ for $i \\neq j$ and $\\rho_{ij}$ is larger for more similar stocks. An example of this is the correlation between the returns of stocks $i$ and $j$. But one could choose other similarity indices $\\rho_{ij}$.\n",
    "\n",
    "The problem that we are interested in solving is:\n",
    "\n",
    "$$\n",
    "(M) \\quad  f = \\max_{x_{ij}, y_{j}} \\,\\, \\sum_{i=1}^n \\sum_{j=1}^n \\rho_{ij} x_{ij}\n",
    "$$\n",
    "\n",
    "subject to the clustering constraint:\n",
    "\n",
    "$$\n",
    "\\sum_{j=1}^n y_j = q,\n",
    "$$\n",
    "\n",
    "to consistency constraints:\n",
    "\n",
    "$$\n",
    "\\sum_{j=1}^n x_{ij} = 1, \\,\\textrm{ for }\\,  i = 1,\\ldots, n,\n",
    "\\quad x_{ij} \\leq y_j,\\,\\textrm{ for }\\,  i = 1,\\ldots, n; \\, j = 1,\\ldots, n,\n",
    "\\quad x_{jj} = y_j,\\,\\textrm{ for }\\,  j = 1,\\ldots, n,\n",
    "$$\n",
    "\n",
    "and integral constraints:\n",
    "\n",
    "$$\n",
    "\\quad  x_{ij}, y_j \\in\\{0,1\\}, \\,\\textrm{ for }\\,  i = 1,\\ldots, n; \\, j = 1,\\ldots, n.\n",
    "$$\n",
    "\n",
    "The variables $y_j$ describe which stocks $j$ are in the index fund ($y_j = 1$ if $j$ is selected in the fund, $0$ otherwise). For each stock $i = 1,\\dots,n$, the variable $x_{ij}$ indicates which stock $j$ in the index fund is most similar to $i$ ($x_{ij} = 1$ if $j$ is the most similar stock in the index fund, $0$ otherwise).\n",
    "\n",
    "The first constraint selects $q$ stocks in the fund. The second constraint imposes that each stock $i$ has exactly one representative stock $j$ in the fund. The third and fourth constraints guarantee that stock $i$ can be represented by stock $j$ only if $j$ is in the fund. The objective of the model maximizes the similarity between the $n$ stocks and their representatives in the fund. Different cost functions can also be considered. \n",
    "\n",
    "Let us concatenate the decision variables in one vector \n",
    "\n",
    "$$\n",
    "{\\bf z} = [x_{11},x_{12},\\ldots,x_{1n}, x_{22},\\ldots,x_{nn}, y_{1},\\ldots,y_{n}],\n",
    "$$\n",
    "\n",
    "whose dimension is ${\\bf z} \\in \\{0,1\\}^N$, with $N = n (n+1)$ and denote the optimal solution with ${\\bf z}^*$, and the optimal cost $f^*$. \n",
    "\n",
    "\n",
    "## A Hybrid Approach\n",
    "\n",
    "Here, we demonstrate an approach that combines classical and quantum computing steps, following the quantum approximate optimization approach of Farhi, Goldstone, and Gutmann (2014). \n",
    "\n",
    "### Construct a binary polynomial optimization\n",
    "\n",
    "From $(M)$ one can construct a binary polynomial optimization with equality constraints only, by substituting the $x_{ij} \\leq y_j$ inequality constraints with the equivalent equality constraints $x_{ij} (1- y_j) = 0$. Then the problem becomes:\n",
    "\n",
    "$$\n",
    "(BPO) \\quad  f = \\max_{x_{ij}, y_{j}} \\,\\, \\sum_{i=1}^n \\sum_{j=1}^n \\rho_{ij} x_{ij}\n",
    "$$\n",
    "\n",
    "subject to the clustering constraint, the integral constraints, and the following modified consistency constraints:\n",
    "\n",
    "$$\\sum_{j=1}^n x_{ij} = 1, \\,\\textrm{ for }\\,  i = 1,\\ldots, n,$$\n",
    "$$\\quad x_{ij} (1- y_j) = 0,\\,\\textrm{ for }\\,  i = 1,\\ldots, n; \\, j = 1,\\ldots, n,$$\n",
    "$$\\quad x_{jj} = y_j,\\,\\textrm{ for }\\,  j = 1,\\ldots, n.$$\n",
    "\n",
    "### Construct the Ising Hamiltonian\n",
    "\n",
    "We can now construct the Ising Hamiltonian (QUBO) by penalty methods (introducing a penalty coefficient $A$ for each equality constraint) as\n",
    "\n",
    "$$\n",
    "(IH) \\quad H = \\sum_{i=1}^n \\sum_{j=1}^n \\rho_{ij} x_{ij} + A\\Big( \\sum_{j=1}^n y_j - q\\Big)^2 + \\sum_{i=1}^n A\\Big( \\sum_{j=1}^n x_{ij} - 1\\Big)^2 + \\sum_{j=1}^n A (x_{jj}-y_j)^2 +\\sum_{i=1}^n \\sum_{j=1}^n A \\left(x_{ij} (1- y_j)\\right).\n",
    "$$\n",
    "\n",
    "### From Hamiltonian to Quadratic Programming (QP) formulation \n",
    "\n",
    "In the vector ${\\bf z}$, the Ising Hamiltonian elements can be rewritten as follows,\n",
    "\n",
    "First term:\n",
    "\n",
    "$$\n",
    "\\sum_{i=1}^n \\sum_{j=1}^n \\rho_{ij} x_{ij} = [\\rho_{11},\\rho_{12},\\ldots,\\rho_{1n}, \\rho_{22},\\ldots,\\rho_{nn}|{\\bf 0}_n ]{\\bf z} =: {\\bf c}_0^T {\\bf z}\n",
    "$$\n",
    "\n",
    "Second term:\n",
    "\n",
    "$$\n",
    "A\\Big( \\sum_{j=1}^n y_j - q\\Big)^2 = A \\Big(\\sum_{j=1}^n y_j\\Big)^2 - 2 Aq \\sum_{j=1}^n y_j + A q^2 = A {\\bf z}^T \\left[\\begin{array}{c}{\\bf 0}_{n^2} \\\\ \\hline  {\\bf 1}_n  \\end{array}\\right]\\left[\\begin{array}{cc}{\\bf 0}_{n^2} | {\\bf 1}_n  \\end{array}\\right]{\\bf z} - 2 A q [{\\bf 0}_{n^2}|{\\bf 1}_n]{\\bf z} + A q^2 =: {\\bf z}^T {\\bf Q}_0 {\\bf z} + {\\bf c}_1^T {\\bf z} + r_0\n",
    "$$\n",
    "\n",
    "Third term:\n",
    "\n",
    "$$\n",
    "\\sum_{i=1}^n A\\Big( \\sum_{j=1}^n x_{ij} - 1\\Big)^2 = A\\sum_{i=1}^n \\Big(\\sum_{j=1}^n x_{ij}\\Big)^2 - 2 A \\sum_{i=1}^n\\sum_{j=1}^n x_{ij} + n A = \\qquad\\qquad\\qquad\\qquad\\qquad\\qquad\\qquad\n",
    "$$\n",
    "\n",
    "which is equivalent to: \n",
    "\n",
    "$$\n",
    "\\qquad\\qquad\\qquad\\qquad\\qquad\\qquad\\qquad = A {\\bf z}^T \\left(\\sum_{i=1}^n \\left[\\begin{array}{c}{\\bf 0}_{n(i-1)}  \\\\ {\\bf 1}_n  \\\\ {\\bf 0}_{n(n-i)} \\\\ \\hline {\\bf 0}_{n} \\end{array}\\right]\\left[\\begin{array}{cccc}{\\bf 0}_{n(i-1)} & {\\bf 1}_n  & {\\bf 0}_{n(n-i)} & | {\\bf 0}_{n} \\end{array}\\right]\\right){\\bf z} - 2 A [{\\bf 1}_{n^2}|{\\bf 0}_n]{\\bf z} + n A =: {\\bf z}^T {\\bf Q}_1 {\\bf z} + {\\bf c}_2^T {\\bf z} + r_1\n",
    "$$\n",
    "\n",
    "Fourth term:\n",
    "\n",
    "$$\n",
    "A \\sum_{j=1}^n  (x_{jj}-y_j)^2 = A {\\bf z}^T  \\left(\\sum_{j=0}^{n-1} \\left[\\begin{array}{c}{\\bf 0}_{nj + j}  \\\\ 1  \\\\ {\\bf 0}_{n^2-(nj+j+1)} \\\\ \\hline {\\bf 0}_{j} \\\\ -1 \\\\ {\\bf 0}_{n-j-1} \\end{array}\\right]\\left[\\begin{array}{cccccc}{\\bf 0}_{nj + j} & 1  & {\\bf 0}_{n^2-(nj+j+1)} & | {\\bf 0}_{j} & -1 & {\\bf 0}_{n-j-1}  \\end{array}\\right]\\right){\\bf z} = A {\\bf z}^T {\\bf Q}_2 {\\bf z}\n",
    "$$\n",
    "\n",
    "Fifth term:\n",
    "\n",
    "$$\n",
    "\\sum_{i=1}^n \\sum_{j=1}^n A \\left(x_{ij} (1- y_j)\\right) = A [{\\bf 1}_{n^2}|{\\bf 0}_n]{\\bf z} + A {\\bf z}^T \\left( \\sum_{i=1}^n \\sum_{j=1}^n \\left[\\begin{array}{ccc|c}  &  & & \\\\ & {\\bf 0}_{n^2\\times n^2} & & -1/2_{(ij,j)}  \\\\ & & & \\\\ \\hline & -1/2_{(j, ij)} &  & {\\bf 0}_{n} \\end{array}\\right] \\right) {\\bf z} =:  {\\bf z}^T {\\bf Q}_3 {\\bf z} + {\\bf c}_3^T {\\bf z}\n",
    "$$\n",
    "\n",
    "Therefore, the formulation becomes,\n",
    "\n",
    "$$\n",
    "(IH-QP)\\quad \\max_{{\\bf z}\\in\\{0,1\\}^{n(n+1)}} \\, {\\bf z}^T ({\\bf Q}_0+{\\bf Q}_1+ {\\bf Q}_2 + {\\bf Q}_3 ){\\bf z} + ({\\bf c}_0+{\\bf c}_1+{\\bf c}_2+{\\bf c}_3)^T {\\bf z} +r_0+r_1+r_2$$\n",
    "\n",
    "which can be passed to the variational quantum eigensolver. \n",
    "\n",
    "\n",
    "\n",
    "## References\n",
    "\n",
    "[1] G. Cornuejols, M. L. Fisher, and G. L. Nemhauser, *Location of bank accounts to optimize float: an analytical study of exact and approximate algorithms*, Management Science, vol. 23(8), 1997\n",
    "\n",
    "[2] E. Farhi, J. Goldstone, S. Gutmann e-print [arXiv 1411.4028, 2014](https://arxiv.org/abs/1411.4028)\n",
    "\n",
    "[3] G. Cornuejols and R. Tutuncu, [Optimization methods in finance](http://web.math.ku.dk/~rolf/CT_FinOpt.pdf), 2006\n",
    "\n",
    "[4] DJ. Berndt and J. Clifford, *Using dynamic time warping to find patterns in time series*. In KDD workshop 1994  (Vol. 10, No. 16, pp. 359-370).\n",
    "\n",
    "[5] [Max-Cut and Traveling Salesman Problem](https://qiskit-community.github.io/qiskit-optimization/tutorials/06_examples_max_cut_and_tsp.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Implementation\n",
    "\n",
    "First, we import the requisite modules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-13T20:33:36.400744Z",
     "start_time": "2020-07-13T20:33:36.392428Z"
    }
   },
   "outputs": [],
   "source": [
    "# Import requisite modules\n",
    "import math\n",
    "import datetime\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "# Import Qiskit packages\n",
    "from qiskit.circuit.library import TwoLocal\n",
    "from qiskit_aer.primitives import Sampler\n",
    "from qiskit_algorithms import NumPyMinimumEigensolver, QAOA, SamplingVQE\n",
    "from qiskit_algorithms.optimizers import COBYLA\n",
    "from qiskit_optimization.algorithms import MinimumEigenOptimizer\n",
    "\n",
    "# The data providers of stock-market data\n",
    "from qiskit_finance.data_providers import RandomDataProvider\n",
    "from qiskit_finance.applications.optimization import PortfolioDiversification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we download price data for two stocks and compute their pair-wise similarity matrix ([dynamic time warping](https://en.wikipedia.org/wiki/Dynamic_time_warping) distance normalized to (0,1] by taking the reciprocal). If this fails, e.g., due to you being offline or exceeding the daily limit for accesses to the stock-market data, we consider a constant matrix instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-13T20:33:37.631522Z",
     "start_time": "2020-07-13T20:33:37.624973Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Generate a pairwise time-series similarity matrix\n",
    "seed = 123\n",
    "\n",
    "stocks = [\"TICKER1\", \"TICKER2\"]\n",
    "n = len(stocks)\n",
    "\n",
    "data = RandomDataProvider(\n",
    "    tickers=stocks,\n",
    "    start=datetime.datetime(2016, 1, 1),\n",
    "    end=datetime.datetime(2016, 1, 30),\n",
    "    seed=seed,\n",
    ")\n",
    "data.run()\n",
    "rho = data.get_similarity_matrix()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we decide on the number of clusters. This has to be smaller than the number of stocks we have loaded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-13T20:33:37.921627Z",
     "start_time": "2020-07-13T20:33:37.919217Z"
    }
   },
   "outputs": [],
   "source": [
    "q = 1  # q less or equal than n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classical solution using IBM ILOG CPLEX\n",
    "\n",
    "For a classical solution, we use IBM CPLEX. CPLEX is able to find the exact solution of this problem. We first define a ClassicalOptimizer class that encodes the problem in a way that CPLEX can solve, and then instantiate the class and solve it. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-13T20:33:38.238311Z",
     "start_time": "2020-07-13T20:33:38.218944Z"
    }
   },
   "outputs": [],
   "source": [
    "class ClassicalOptimizer:\n",
    "    def __init__(self, rho, n, q):\n",
    "\n",
    "        self.rho = rho\n",
    "        self.n = n  # number of inner variables\n",
    "        self.q = q  # number of required selection\n",
    "\n",
    "    def compute_allowed_combinations(self):\n",
    "        f = math.factorial\n",
    "        return int(f(self.n) / f(self.q) / f(self.n - self.q))\n",
    "\n",
    "    def cplex_solution(self):\n",
    "\n",
    "        # refactoring\n",
    "        rho = self.rho\n",
    "        n = self.n\n",
    "        q = self.q\n",
    "\n",
    "        my_obj = list(rho.reshape(1, n**2)[0]) + [0.0 for x in range(0, n)]\n",
    "        my_ub = [1 for x in range(0, n**2 + n)]\n",
    "        my_lb = [0 for x in range(0, n**2 + n)]\n",
    "        my_ctype = \"\".join([\"I\" for x in range(0, n**2 + n)])\n",
    "\n",
    "        my_rhs = (\n",
    "            [q]\n",
    "            + [1 for x in range(0, n)]\n",
    "            + [0 for x in range(0, n)]\n",
    "            + [0.1 for x in range(0, n**2)]\n",
    "        )\n",
    "        my_sense = (\n",
    "            \"\".join([\"E\" for x in range(0, 1 + n)])\n",
    "            + \"\".join([\"E\" for x in range(0, n)])\n",
    "            + \"\".join([\"L\" for x in range(0, n**2)])\n",
    "        )\n",
    "\n",
    "        try:\n",
    "            my_prob = cplex.Cplex()\n",
    "            self.populatebyrow(my_prob, my_obj, my_ub, my_lb, my_ctype, my_sense, my_rhs)\n",
    "\n",
    "            my_prob.solve()\n",
    "\n",
    "        except CplexError as exc:\n",
    "            print(exc)\n",
    "            return\n",
    "\n",
    "        x = my_prob.solution.get_values()\n",
    "        x = np.array(x)\n",
    "        cost = my_prob.solution.get_objective_value()\n",
    "\n",
    "        return x, cost\n",
    "\n",
    "    def populatebyrow(self, prob, my_obj, my_ub, my_lb, my_ctype, my_sense, my_rhs):\n",
    "\n",
    "        n = self.n\n",
    "\n",
    "        prob.objective.set_sense(prob.objective.sense.minimize)\n",
    "        prob.variables.add(obj=my_obj, lb=my_lb, ub=my_ub, types=my_ctype)\n",
    "\n",
    "        prob.set_log_stream(None)\n",
    "        prob.set_error_stream(None)\n",
    "        prob.set_warning_stream(None)\n",
    "        prob.set_results_stream(None)\n",
    "\n",
    "        rows = []\n",
    "        col = [x for x in range(n**2, n**2 + n)]\n",
    "        coef = [1 for x in range(0, n)]\n",
    "        rows.append([col, coef])\n",
    "\n",
    "        for ii in range(0, n):\n",
    "            col = [x for x in range(0 + n * ii, n + n * ii)]\n",
    "            coef = [1 for x in range(0, n)]\n",
    "\n",
    "            rows.append([col, coef])\n",
    "\n",
    "        for ii in range(0, n):\n",
    "            col = [ii * n + ii, n**2 + ii]\n",
    "            coef = [1, -1]\n",
    "            rows.append([col, coef])\n",
    "\n",
    "        for ii in range(0, n):\n",
    "            for jj in range(0, n):\n",
    "                col = [ii * n + jj, n**2 + jj]\n",
    "                coef = [1, -1]\n",
    "\n",
    "                rows.append([col, coef])\n",
    "\n",
    "        prob.linear_constraints.add(lin_expr=rows, senses=my_sense, rhs=my_rhs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-13T20:33:38.380358Z",
     "start_time": "2020-07-13T20:33:38.375446Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of feasible combinations= 2\n",
      "Total number of combinations= 64\n"
     ]
    }
   ],
   "source": [
    "# Instantiate the classical optimizer class\n",
    "classical_optimizer = ClassicalOptimizer(rho, n, q)\n",
    "\n",
    "# Compute the number of feasible solutions:\n",
    "print(\"Number of feasible combinations= \" + str(classical_optimizer.compute_allowed_combinations()))\n",
    "\n",
    "# Compute the total number of possible combinations (feasible + unfeasible)\n",
    "print(\"Total number of combinations= \" + str(2 ** (n * (n + 1))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-13T20:33:38.545880Z",
     "start_time": "2020-07-13T20:33:38.536785Z"
    }
   },
   "outputs": [],
   "source": [
    "# Visualize the solution\n",
    "def visualize_solution(xc, yc, x, C, n, K, title_str):\n",
    "    plt.figure()\n",
    "    plt.scatter(xc, yc, s=200)\n",
    "    for i in range(len(xc)):\n",
    "        plt.annotate(i, (xc[i] + 0.015, yc[i]), size=16, color=\"r\")\n",
    "\n",
    "    plt.grid()\n",
    "\n",
    "    for ii in range(n**2, n**2 + n):\n",
    "\n",
    "        if x[ii] > 0:\n",
    "            plt.plot(xc[ii - n**2], yc[ii - n**2], \"r*\", ms=20)\n",
    "\n",
    "    for ii in range(0, n**2):\n",
    "\n",
    "        if x[ii] > 0:\n",
    "            iy = ii // n\n",
    "            ix = ii % n\n",
    "            plt.plot([xc[ix], xc[iy]], [yc[ix], yc[iy]], \"C2\")\n",
    "\n",
    "    plt.title(title_str + \" cost = \" + str(int(C * 100) / 100.0))\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solution shows the selected stocks via the stars and in green the links (via similarities) with other stocks that are represented in the fund by the linked stock. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantum Computing solution using Qiskit\n",
    "\n",
    "For the quantum solution, we use Qiskit. We first define a class QuantumOptimizer that encodes the quantum approach to solve the problem and then we instantiate it and solve it. We define the following methods inside the class:\n",
    "\n",
    "- `exact_solution` : to make sure that the Ising Hamiltonian is correctly encoded in the $Z$ basis, we can compute its eigendecomposition classically, i.e., considering a symmetric matrix of dimension $2^N \\times 2^N$. For the problem at hand $n=3$, that is $N = 12$, seems to be the limit for many laptops; \n",
    "- `sampling_vqe_solution` : solves the problem $(M)$ via the Sampling Variational Quantum Eigensolver (`SamplingVQE`);\n",
    "- `qaoa_solution` : solves the problem $(M)$ via a Quantum Approximate Optimization Algorithm (`QAOA`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-13T20:33:39.009254Z",
     "start_time": "2020-07-13T20:33:38.988574Z"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit_algorithms.utils import algorithm_globals\n",
    "\n",
    "\n",
    "class QuantumOptimizer:\n",
    "    def __init__(self, rho, n, q):\n",
    "        self.rho = rho\n",
    "        self.n = n\n",
    "        self.q = q\n",
    "        self.pdf = PortfolioDiversification(similarity_matrix=rho, num_assets=n, num_clusters=q)\n",
    "        self.qp = self.pdf.to_quadratic_program()\n",
    "\n",
    "    # Obtains the least eigenvalue of the Hamiltonian classically\n",
    "    def exact_solution(self):\n",
    "        exact_mes = NumPyMinimumEigensolver()\n",
    "        exact_eigensolver = MinimumEigenOptimizer(exact_mes)\n",
    "        result = exact_eigensolver.solve(self.qp)\n",
    "        return self.decode_result(result)\n",
    "\n",
    "    def sampling_vqe_solution(self):\n",
    "        algorithm_globals.random_seed = 100\n",
    "        cobyla = COBYLA()\n",
    "        cobyla.set_options(maxiter=250)\n",
    "        ry = TwoLocal(n, \"ry\", \"cz\", reps=5, entanglement=\"full\")\n",
    "        svqe_mes = SamplingVQE(sampler=Sampler(), ansatz=ry, optimizer=cobyla)\n",
    "        svqe = MinimumEigenOptimizer(svqe_mes)\n",
    "        result = svqe.solve(self.qp)\n",
    "        return self.decode_result(result)\n",
    "\n",
    "    def qaoa_solution(self):\n",
    "        algorithm_globals.random_seed = 1234\n",
    "        cobyla = COBYLA()\n",
    "        cobyla.set_options(maxiter=250)\n",
    "        qaoa_mes = QAOA(sampler=Sampler(), optimizer=cobyla, reps=3)\n",
    "        qaoa = MinimumEigenOptimizer(qaoa_mes)\n",
    "        result = qaoa.solve(self.qp)\n",
    "        return self.decode_result(result)\n",
    "\n",
    "    def decode_result(self, result, offset=0):\n",
    "        quantum_solution = 1 - (result.x)\n",
    "        ground_level = self.qp.objective.evaluate(result.x)\n",
    "        return quantum_solution, ground_level"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 1\n",
    "\n",
    "Instantiate the quantum optimizer class with parameters: \n",
    "- the similarity matrix `rho`;\n",
    "- the number of assets and clusters `n` and `q`;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-13T20:33:39.664145Z",
     "start_time": "2020-07-13T20:33:39.661532Z"
    }
   },
   "outputs": [],
   "source": [
    "# Instantiate the quantum optimizer class with parameters:\n",
    "quantum_optimizer = QuantumOptimizer(rho, n, q)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2\n",
    "\n",
    "Encode the problem as a binary formulation (IH-QP).\n",
    "\n",
    "Sanity check: make sure that the binary formulation in the quantum optimizer is correct (i.e., yields the same cost given the same solution)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-13T20:33:40.354542Z",
     "start_time": "2020-07-13T20:33:40.347435Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 1. 0. 1. 0. 1.] 1.000779571614484\n",
      "[1. 0. 1. 0. 1. 0.] 1.000779571614484\n",
      "Binary formulation is correct\n"
     ]
    }
   ],
   "source": [
    "# Check if the binary representation is correct. This requires CPLEX\n",
    "try:\n",
    "    import cplex\n",
    "\n",
    "    # warnings.filterwarnings('ignore')\n",
    "    quantum_solution, quantum_cost = quantum_optimizer.exact_solution()\n",
    "    print(quantum_solution, quantum_cost)\n",
    "    classical_solution, classical_cost = classical_optimizer.cplex_solution()\n",
    "    print(classical_solution, classical_cost)\n",
    "    if np.abs(quantum_cost - classical_cost) < 0.01:\n",
    "        print(\"Binary formulation is correct\")\n",
    "    else:\n",
    "        print(\"Error in the formulation of the Hamiltonian\")\n",
    "except Exception as ex:\n",
    "    print(ex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 3\n",
    "\n",
    "Encode the problem as an Ising Hamiltonian in the Z basis. \n",
    "\n",
    "Sanity check: make sure that the formulation is correct (i.e., yields the same cost given the same solution)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-13T20:33:41.191948Z",
     "start_time": "2020-07-13T20:33:41.167088Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 1. 0. 1. 0. 1.]\n",
      "Ising Hamiltonian in Z basis is correct\n"
     ]
    }
   ],
   "source": [
    "ground_state, ground_level = quantum_optimizer.exact_solution()\n",
    "print(ground_state)\n",
    "classical_cost = 1.000779571614484  # obtained from the CPLEX solution\n",
    "\n",
    "try:\n",
    "    if np.abs(ground_level - classical_cost) < 0.01:\n",
    "        print(\"Ising Hamiltonian in Z basis is correct\")\n",
    "    else:\n",
    "        print(\"Error in the Ising Hamiltonian formulation\")\n",
    "except Exception as ex:\n",
    "    print(ex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 4\n",
    "\n",
    "Solve the problem via `SamplingVQE`. Notice that depending on the number of qubits, this can take a while: for 6 qubits it takes 15 minutes on a 2015 Macbook Pro, for 12 qubits it takes more than 12 hours. For longer runs, logging may be useful to observe the workings; otherwise, you just have to wait until the solution is printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-13T20:33:44.036843Z",
     "start_time": "2020-07-13T20:33:41.816593Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 1. 0. 1. 0. 1.] 1.000779571614484\n",
      "SamplingVQE produces the same solution as the exact eigensolver.\n"
     ]
    }
   ],
   "source": [
    "svqe_state, svqe_level = quantum_optimizer.sampling_vqe_solution()\n",
    "print(svqe_state, svqe_level)\n",
    "\n",
    "try:\n",
    "    if np.linalg.norm(ground_state - svqe_state) < 0.01:\n",
    "        print(\"SamplingVQE produces the same solution as the exact eigensolver.\")\n",
    "    else:\n",
    "        print(\n",
    "            \"SamplingVQE does not produce the same solution as the exact eigensolver, but that is to be expected.\"\n",
    "        )\n",
    "except Exception as ex:\n",
    "    print(ex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 5\n",
    "Visualize the solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-13T20:33:44.472764Z",
     "start_time": "2020-07-13T20:33:44.039069Z"
    }
   },
   "outputs": [],
   "source": [
    "xc, yc = data.get_coordinates()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "visualize_solution(xc, yc, ground_state, ground_level, n, q, \"Classical\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": [
     "nbsphinx-thumbnail"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "visualize_solution(xc, yc, svqe_state, svqe_level, n, q, \"SamplingVQE\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solution shows the selected stocks via the stars and in green the links (via similarities) with other stocks that are represented in the fund by the linked stock. Keep in mind that SamplingVQE is a heuristic working on the QP formulation of the Ising Hamiltonian, though. For suitable choices of A, local optima of the QP formulation will be feasible solutions to the ILP (integer linear program). While for some small instances, as above, we can find optimal solutions of the QP formulation which coincide with optima of the ILP, finding optimal solutions of the ILP is harder than finding local optima of the QP formulation, in general. Even within the SamplingVQE, one may provide stronger guarantees, for specific variational forms (trial wave functions). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-13T20:33:46.752475Z",
     "start_time": "2020-07-13T20:33:46.245954Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h3>Version Information</h3><table><tr><th>Software</th><th>Version</th></tr><tr><td><code>qiskit</code></td><td>0.45.0.dev0+ea871e0</td></tr><tr><td><code>qiskit_optimization</code></td><td>0.6.0</td></tr><tr><td><code>qiskit_finance</code></td><td>0.4.0</td></tr><tr><td><code>qiskit_algorithms</code></td><td>0.3.0</td></tr><tr><td><code>qiskit_aer</code></td><td>0.12.2</td></tr><tr><td><code>qiskit_ibm_provider</code></td><td>0.7.0</td></tr><tr><th colspan='2'>System information</th></tr><tr><td>Python version</td><td>3.9.7</td></tr><tr><td>Python compiler</td><td>GCC 7.5.0</td></tr><tr><td>Python build</td><td>default, Sep 16 2021 13:09:58</td></tr><tr><td>OS</td><td>Linux</td></tr><tr><td>CPUs</td><td>2</td></tr><tr><td>Memory (Gb)</td><td>5.7784271240234375</td></tr><tr><td colspan='2'>Tue Sep 05 15:08:55 2023 EDT</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div style='width: 100%; background-color:#d5d9e0;padding-left: 10px; padding-bottom: 10px; padding-right: 10px; padding-top: 5px'><h3>This code is a part of Qiskit</h3><p>&copy; Copyright IBM 2017, 2023.</p><p>This code is licensed under the Apache License, Version 2.0. You may<br>obtain a copy of this license in the LICENSE.txt file in the root directory<br> of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.<p>Any modifications or derivative works of this code must retain this<br>copyright notice, and modified files need to carry a notice indicating<br>that they have been altered from the originals.</p></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import tutorial_magics\n",
    "\n",
    "%qiskit_version_table\n",
    "%qiskit_copyright"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  },
  "vscode": {
   "interpreter": {
    "hash": "e3b168dd14084693aa742087410f9921d6040e41eb6bdb17b20e4003862f82dd"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}