{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "215d1e02-88dc-4d07-a38b-aa66357c59f3",
   "metadata": {},
   "source": [
    "# 01-Finance Tutorial-Portfolio Optimization\n",
    "### Modified for Quantum Rings toolkit for Qiskit 2.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f6137ce8-70b0-420c-9ca4-d2d3bd0affce",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This tutorial is from:\n",
    "# https://qiskit-community.github.io/qiskit-finance/tutorials/01_portfolio_optimization.html\n",
    "\n",
    "# Modified for use with Quantum Rings toolkit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "8f356a1a-604d-4157-af12-afc3e27a8246",
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# Setup your account\n",
    "# You can also save your account locally using the class method QrRuntimeService.save_account(...) and\n",
    "# invoke the QrRuntimeService class constructor without any arguments.\n",
    "#\n",
    "\n",
    "import os\n",
    "my_token = os.environ[\"QR_TOKEN\"]\n",
    "my_name = os.environ[\"QR_ACCOUNT\"]\n",
    "\n",
    "#\n",
    "# Set the backend of your choice, depending upon the task and your hardware configuration.\n",
    "# See SDK documentation for additional help.\n",
    "#\n",
    "\n",
    "my_backend = \"scarlet_quantum_rings\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "2a9feb0d-75cc-41a8-98c3-432a3f17e371",
   "metadata": {},
   "outputs": [],
   "source": [
    "#from qiskit.circuit.library import TwoLocal\n",
    "from qiskit.circuit.library import n_local as TwoLocal\n",
    "from qiskit.result import QuasiDistribution\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_finance.applications.optimization import PortfolioOptimization\n",
    "from qiskit_finance.data_providers import RandomDataProvider\n",
    "from qiskit_optimization.algorithms import MinimumEigenOptimizer\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "46ec7b78-eafe-42e6-aa01-4908d9e14d1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# set number of assets (= number of qubits)\n",
    "num_assets = 4\n",
    "seed = 123\n",
    "\n",
    "# Generate expected return and covariance matrix from (random) time-series\n",
    "stocks = [(\"TICKER%s\" % i) for i in range(num_assets)]\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",
    "mu = data.get_period_return_mean_vector()\n",
    "sigma = data.get_period_return_covariance_matrix()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "639ccd0b-c3b8-4109-8ddb-a27aa9a184b0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot sigma\n",
    "plt.imshow(sigma, interpolation=\"nearest\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "acd8cac2-3cc4-46d7-bc8a-28773801ca8e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<QuadraticProgram: minimize 0.001270694296030004*x_0^2 + 7.34022166934733e-05*..., 4 variables, 1 constraints, 'Portfolio optimization'>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q = 0.5  # set risk factor\n",
    "budget = num_assets // 2  # set budget\n",
    "penalty = num_assets  # set parameter to scale the budget penalty term\n",
    "\n",
    "portfolio = PortfolioOptimization(\n",
    "    expected_returns=mu, covariances=sigma, risk_factor=q, budget=budget\n",
    ")\n",
    "qp = portfolio.to_quadratic_program()\n",
    "qp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "85b06cc3-edb4-46be-b6d6-049b57a2d2f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_result(result):\n",
    "    selection = result.x\n",
    "    value = result.fval\n",
    "    print(\"Optimal: selection {}, value {:.4f}\".format(selection, value))\n",
    "\n",
    "    eigenstate = result.min_eigen_solver_result.eigenstate\n",
    "\n",
    "    if (isinstance(eigenstate, dict)):    \n",
    "        probabilities = (\n",
    "            eigenstate.binary_probabilities()\n",
    "            if isinstance(eigenstate, QuasiDistribution)\n",
    "            else {k: np.abs(v) ** 2 for k, v in eigenstate.items()}\n",
    "        )\n",
    "    else:\n",
    "        probabilities = (\n",
    "            eigenstate.binary_probabilities()\n",
    "            if isinstance(eigenstate, QuasiDistribution)\n",
    "            else {k: np.abs(v) ** 2 for k, v in eigenstate.to_dict().items()}\n",
    "        )\n",
    "        \n",
    "    print(\"\\n----------------- Full result ---------------------\")\n",
    "    print(\"selection\\tvalue\\t\\tprobability\")\n",
    "    print(\"---------------------------------------------------\")\n",
    "    probabilities = sorted(probabilities.items(), key=lambda x: x[1], reverse=True)\n",
    "\n",
    "    for k, v in probabilities:\n",
    "        x = np.array([int(i) for i in list(reversed(k))])\n",
    "        value = portfolio.to_quadratic_program().objective.evaluate(x)\n",
    "        print(\"%10s\\t%.4f\\t\\t%.4f\" % (x, value, v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "a4fc28cc-2020-4f1c-bcf5-d6cb2d1609dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal: selection [1. 0. 0. 1.], value -0.0149\n",
      "\n",
      "----------------- Full result ---------------------\n",
      "selection\tvalue\t\tprobability\n",
      "---------------------------------------------------\n",
      " [1 0 0 1]\t-0.0149\t\t1.0000\n"
     ]
    }
   ],
   "source": [
    "exact_mes = NumPyMinimumEigensolver()\n",
    "exact_eigensolver = MinimumEigenOptimizer(exact_mes)\n",
    "\n",
    "result = exact_eigensolver.solve(qp)\n",
    "\n",
    "print_result(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "ad38cbfe-3ff0-4f99-badc-7bdc10da02e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "from quantumrings.toolkit.qiskit import QrRuntimeService\n",
    "from quantumrings.toolkit.qiskit import QrSamplerV2 as Sampler\n",
    "\n",
    "#\n",
    "# Acquire Quantum Rings Backend\n",
    "#\n",
    "\n",
    "qr_services = QrRuntimeService(name = my_name, token = my_token)\n",
    "qr_backend = qr_services.backend(name = my_backend, precision = \"single\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "9329483c-3c76-4269-93b0-c260f1a0d313",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal: selection [1. 0. 0. 1.], value -0.0149\n",
      "\n",
      "----------------- Full result ---------------------\n",
      "selection\tvalue\t\tprobability\n",
      "---------------------------------------------------\n",
      " [1 0 0 1]\t-0.0149\t\t0.6257\n",
      " [0 1 1 0]\t0.0008\t\t0.0326\n",
      " [0 1 0 1]\t0.0002\t\t0.0004\n",
      " [0 1 1 1]\t-0.0000\t\t0.0000\n",
      " [1 0 1 0]\t-0.0140\t\t0.0000\n",
      " [0 1 0 0]\t0.0009\t\t0.0000\n",
      " [1 0 0 0]\t-0.0140\t\t0.0000\n"
     ]
    }
   ],
   "source": [
    "from qiskit_algorithms.utils import algorithm_globals\n",
    "\n",
    "algorithm_globals.random_seed = 1234\n",
    "\n",
    "cobyla = COBYLA()\n",
    "cobyla.set_options(maxiter=500)\n",
    "ry = TwoLocal(num_assets, \"ry\", \"cz\", reps=3, entanglement=\"full\")\n",
    "svqe_mes = SamplingVQE(sampler=Sampler(backend = qr_backend), ansatz=ry, optimizer=cobyla)\n",
    "svqe = MinimumEigenOptimizer(svqe_mes)\n",
    "result = svqe.solve(qp)\n",
    "\n",
    "print_result(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "76956e5e-073a-461b-9868-00b8c68096d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal: selection [1. 0. 0. 1.], value -0.0149\n",
      "\n",
      "----------------- Full result ---------------------\n",
      "selection\tvalue\t\tprobability\n",
      "---------------------------------------------------\n",
      " [1 0 1 0]\t-0.0140\t\t0.0097\n",
      " [1 0 0 1]\t-0.0149\t\t0.0093\n",
      " [1 1 0 0]\t-0.0130\t\t0.0076\n",
      " [0 0 1 1]\t-0.0010\t\t0.0052\n",
      " [1 0 0 0]\t-0.0140\t\t0.0052\n",
      " [1 1 0 1]\t-0.0139\t\t0.0049\n",
      " [0 1 1 0]\t0.0008\t\t0.0047\n",
      " [1 0 1 1]\t-0.0150\t\t0.0045\n",
      " [0 1 0 1]\t0.0002\t\t0.0040\n",
      " [0 1 1 1]\t-0.0000\t\t0.0039\n",
      " [0 0 0 1]\t-0.0008\t\t0.0039\n",
      " [0 0 1 0]\t-0.0001\t\t0.0038\n",
      " [1 1 1 0]\t-0.0130\t\t0.0037\n",
      " [0 1 0 0]\t0.0009\t\t0.0020\n",
      " [0 0 0 0]\t0.0000\t\t0.0001\n",
      " [1 1 1 1]\t-0.0139\t\t0.0000\n"
     ]
    }
   ],
   "source": [
    "algorithm_globals.random_seed = 1234\n",
    "\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(qp)\n",
    "\n",
    "print_result(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "67f0db6a-be91-4eec-ac5d-96edb0f7cc10",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h3>Version Information</h3><table><tr><th>Software</th><th>Version</th></tr><tr><td><code>qiskit</code></td><td>2.2.1</td></tr><tr><td><code>qiskit_aer</code></td><td>0.17.1</td></tr><tr><td><code>qiskit_optimization</code></td><td>0.7.0</td></tr><tr><td><code>qiskit_algorithms</code></td><td>0.4.0</td></tr><tr><td><code>qiskit_ibm_runtime</code></td><td>0.40.1</td></tr><tr><td><code>qiskit_finance</code></td><td>0.4.1</td></tr><tr><th colspan='2'>System information</th></tr><tr><td>Python version</td><td>3.12.9</td></tr><tr><td>OS</td><td>Windows</td></tr><tr><td colspan='2'>Thu Oct 16 10:54:08 2025 Mountain Daylight Time</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<h3>Quantum Rings Version Information</h3><table><tr><th>Software</th><th>Version</th></tr><tr><td><code>QuantumRingsLib</code></td><td>0.11.0</td></tr><tr><td><code>quantumrings-toolkit-qiskit</code></td><td>0.1.10</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 a Qiskit project</h3><p>&copy; Copyright IBM 2017, 2025.</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><p>Modifications Copyright Quantum Rings Inc, 2025<br>Modified from the originals<br>Added support for Quantum Rings QrEstimatorV2 class. </p></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import tutorial_magics\n",
    "\n",
    "%qiskit_version_table\n",
    "%quantumrings_version_table\n",
    "%qiskit_copyright"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}