{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Pricing Fixed-Income Assets" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Introduction\n", "\n", "We seek to price a fixed-income asset knowing the distributions describing the relevant interest rates. The cash flows $c_t$ of the asset and the dates at which they occur are known. The total value $V$ of the asset is thus the expectation value of:\n", "\n", "$$V = \\sum_{t=1}^T \\frac{c_t}{(1+r_t)^t}$$\n", "\n", "Each cash flow is treated as a zero coupon bond with a corresponding interest rate $r_t$ that depends on its maturity. The user must specify the distribution modeling the uncertainty in each $r_t$ (possibly correlated) as well as the number of qubits he wishes to use to sample each distribution. In this example we expand the value of the asset to first order in the interest rates $r_t$. This corresponds to studying the asset in terms of its duration.\n", "
\n", "
\n", "The approximation of the objective function follows the following paper:
\n", "[Quantum Risk Analysis. Woerner, Egger. 2018.](https://arxiv.org/abs/1806.06893)" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2020-07-13T23:39:25.388331Z", "start_time": "2020-07-13T23:39:23.208125Z" } }, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "\n", "%matplotlib inline\n", "import numpy as np\n", "from qiskit import QuantumCircuit\n", "from qiskit_algorithms import IterativeAmplitudeEstimation, EstimationProblem\n", "from qiskit_aer.primitives import Sampler\n", "from qiskit_finance.circuit.library import NormalDistribution" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Uncertainty Model\n", "\n", "We construct a circuit to load a multivariate normal random distribution in $d$ dimensions into a quantum state.\n", "The distribution is truncated to a given box $\\otimes_{i=1}^d [low_i, high_i]$ and discretized using $2^{n_i}$ grid points, where $n_i$ denotes the number of qubits used for dimension $i = 1,\\ldots, d$.\n", "The unitary operator corresponding to the circuit implements the following: \n", "$$\\big|0\\rangle_{n_1}\\ldots\\big|0\\rangle_{n_d} \\mapsto \\big|\\psi\\rangle = \\sum_{i_1=0}^{2^n_-1}\\ldots\\sum_{i_d=0}^{2^n_-1} \\sqrt{p_{i_1,...,i_d}}\\big|i_1\\rangle_{n_1}\\ldots\\big|i_d\\rangle_{n_d},$$\n", "where $p_{i_1, ..., i_d}$ denote the probabilities corresponding to the truncated and discretized distribution and where $i_j$ is mapped to the right interval $[low_j, high_j]$ using the affine map:\n", "$$ \\{0, \\ldots, 2^{n_{j}}-1\\} \\ni i_j \\mapsto \\frac{high_j - low_j}{2^{n_j} - 1} * i_j + low_j \\in [low_j, high_j].$$\n", "\n", "In addition to the uncertainty model, we can also apply an affine map, e.g. resulting from a principal component analysis. The interest rates used are then given by:\n", "$$ \\vec{r} = A * \\vec{x} + b,$$\n", "where $\\vec{x} \\in \\otimes_{i=1}^d [low_i, high_i]$ follows the given random distribution." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2020-07-13T23:39:27.609551Z", "start_time": "2020-07-13T23:39:27.600449Z" } }, "outputs": [], "source": [ "# can be used in case a principal component analysis has been done to derive the uncertainty model, ignored in this example.\n", "A = np.eye(2)\n", "b = np.zeros(2)\n", "\n", "# specify the number of qubits that are used to represent the different dimenions of the uncertainty model\n", "num_qubits = [2, 2]\n", "\n", "# specify the lower and upper bounds for the different dimension\n", "low = [0, 0]\n", "high = [0.12, 0.24]\n", "mu = [0.12, 0.24]\n", "sigma = 0.01 * np.eye(2)\n", "\n", "# construct corresponding distribution\n", "bounds = list(zip(low, high))\n", "u = NormalDistribution(num_qubits, mu, sigma, bounds)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2020-07-13T23:39:28.547778Z", "start_time": "2020-07-13T23:39:28.126558Z" }, "tags": [ "nbsphinx-thumbnail" ] }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# plot contour of probability density function\n", "x = np.linspace(low[0], high[0], 2 ** num_qubits[0])\n", "y = np.linspace(low[1], high[1], 2 ** num_qubits[1])\n", "z = u.probabilities.reshape(2 ** num_qubits[0], 2 ** num_qubits[1])\n", "plt.contourf(x, y, z)\n", "plt.xticks(x, size=15)\n", "plt.yticks(y, size=15)\n", "plt.grid()\n", "plt.xlabel(\"$r_1$ (%)\", size=15)\n", "plt.ylabel(\"$r_2$ (%)\", size=15)\n", "plt.colorbar()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Cash flow, payoff function, and exact expected value\n", "\n", "In the following we define the cash flow per period, the resulting payoff function and evaluate the exact expected value.\n", "\n", "For the payoff function we first use a first order approximation and then apply the same approximation technique as for the linear part of the payoff function of the [European Call Option](03_european_call_option_pricing.ipynb)." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2020-07-13T23:39:29.440094Z", "start_time": "2020-07-13T23:39:29.189392Z" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# specify cash flow\n", "cf = [1.0, 2.0]\n", "periods = range(1, len(cf) + 1)\n", "\n", "# plot cash flow\n", "plt.bar(periods, cf)\n", "plt.xticks(periods, size=15)\n", "plt.yticks(size=15)\n", "plt.grid()\n", "plt.xlabel(\"periods\", size=15)\n", "plt.ylabel(\"cashflow ($)\", size=15)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2020-07-13T23:39:29.698674Z", "start_time": "2020-07-13T23:39:29.688947Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Exact value: \t2.1942\n" ] } ], "source": [ "# estimate real value\n", "cnt = 0\n", "exact_value = 0.0\n", "for x1 in np.linspace(low[0], high[0], pow(2, num_qubits[0])):\n", " for x2 in np.linspace(low[1], high[1], pow(2, num_qubits[1])):\n", " prob = u.probabilities[cnt]\n", " for t in range(len(cf)):\n", " # evaluate linear approximation of real value w.r.t. interest rates\n", " exact_value += prob * (\n", " cf[t] / pow(1 + b[t], t + 1)\n", " - (t + 1) * cf[t] * np.dot(A[:, t], np.asarray([x1, x2])) / pow(1 + b[t], t + 2)\n", " )\n", " cnt += 1\n", "print(\"Exact value: \\t%.4f\" % exact_value)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2020-07-13T23:39:30.128058Z", "start_time": "2020-07-13T23:39:30.124504Z" } }, "outputs": [], "source": [ "# specify approximation factor\n", "c_approx = 0.125\n", "\n", "# create fixed income pricing application\n", "from qiskit_finance.applications.estimation import FixedIncomePricing\n", "\n", "fixed_income = FixedIncomePricing(\n", " num_qubits=num_qubits,\n", " pca_matrix=A,\n", " initial_interests=b,\n", " cash_flow=cf,\n", " rescaling_factor=c_approx,\n", " bounds=bounds,\n", " uncertainty_model=u,\n", ")" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
     ┌────┐\n",
       "q_0: ┤0   ├\n",
       "     │    │\n",
       "q_1: ┤1   ├\n",
       "     │    │\n",
       "q_2: ┤2 F ├\n",
       "     │    │\n",
       "q_3: ┤3   ├\n",
       "     │    │\n",
       "q_4: ┤4   ├\n",
       "     └────┘
" ], "text/plain": [ " ┌────┐\n", "q_0: ┤0 ├\n", " │ │\n", "q_1: ┤1 ├\n", " │ │\n", "q_2: ┤2 F ├\n", " │ │\n", "q_3: ┤3 ├\n", " │ │\n", "q_4: ┤4 ├\n", " └────┘" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fixed_income._objective.draw()" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
     ┌───────┐┌────┐\n",
       "q_0: ┤0      ├┤0   ├\n",
       "     │       ││    │\n",
       "q_1: ┤1      ├┤1   ├\n",
       "     │  P(X) ││    │\n",
       "q_2: ┤2      ├┤2 F ├\n",
       "     │       ││    │\n",
       "q_3: ┤3      ├┤3   ├\n",
       "     └───────┘│    │\n",
       "q_4: ─────────┤4   ├\n",
       "              └────┘
" ], "text/plain": [ " ┌───────┐┌────┐\n", "q_0: ┤0 ├┤0 ├\n", " │ ││ │\n", "q_1: ┤1 ├┤1 ├\n", " │ P(X) ││ │\n", "q_2: ┤2 ├┤2 F ├\n", " │ ││ │\n", "q_3: ┤3 ├┤3 ├\n", " └───────┘│ │\n", "q_4: ─────────┤4 ├\n", " └────┘" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fixed_income_circ = QuantumCircuit(fixed_income._objective.num_qubits)\n", "\n", "# load probability distribution\n", "fixed_income_circ.append(u, range(u.num_qubits))\n", "\n", "# apply function\n", "fixed_income_circ.append(fixed_income._objective, range(fixed_income._objective.num_qubits))\n", "\n", "fixed_income_circ.draw()" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2020-07-13T23:39:30.566677Z", "start_time": "2020-07-13T23:39:30.561554Z" } }, "outputs": [], "source": [ "# set target precision and confidence level\n", "epsilon = 0.01\n", "alpha = 0.05\n", "\n", "# construct amplitude estimation\n", "problem = fixed_income.to_estimation_problem()\n", "\n", "ae = IterativeAmplitudeEstimation(\n", " epsilon_target=epsilon, alpha=alpha, sampler=Sampler(run_options={\"shots\": 100, \"seed\": 75})\n", ")" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2020-07-13T23:39:53.292025Z", "start_time": "2020-07-13T23:39:30.882045Z" } }, "outputs": [], "source": [ "result = ae.estimate(problem)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "ExecuteTime": { "end_time": "2020-07-13T23:39:53.298201Z", "start_time": "2020-07-13T23:39:53.294221Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Exact value: \t2.1942\n", "Estimated value: \t2.3437\n", "Confidence interval:\t[2.3101, 2.3772]\n" ] } ], "source": [ "conf_int = np.array(result.confidence_interval_processed)\n", "print(\"Exact value: \\t%.4f\" % exact_value)\n", "print(\"Estimated value: \\t%.4f\" % (fixed_income.interpret(result)))\n", "print(\"Confidence interval:\\t[%.4f, %.4f]\" % tuple(conf_int))" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "ExecuteTime": { "end_time": "2020-07-13T23:39:53.845834Z", "start_time": "2020-07-13T23:39:53.687281Z" } }, "outputs": [ { "data": { "text/html": [ "

Version Information

SoftwareVersion
qiskitNone
qiskit-terra0.45.0.dev0+c626be7
qiskit_finance0.4.0
qiskit_algorithms0.2.0
qiskit_ibm_provider0.6.1
qiskit_optimization0.6.0
qiskit_aer0.12.0
System information
Python version3.9.7
Python compilerGCC 7.5.0
Python builddefault, Sep 16 2021 13:09:58
OSLinux
CPUs2
Memory (Gb)5.778430938720703
Fri Aug 18 16:21:18 2023 EDT
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "

This code is a part of Qiskit

© Copyright IBM 2017, 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
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.

" ], "text/plain": [ "" ] }, "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": 1 }