qiskit/advanced/aqua/linear_systems_of_equations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../../../images/qiskit_header.png\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trusted Notebook\" align=\"middle\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# _*Qiskit Aqua: Solving linear systems of equations with the HHL algorithm*_\n",
    "\n",
    "***\n",
    "### Contributors\n",
    "David Bucher<sup>[1]</sup>, Jan Mueggenburg<sup>[1]</sup>, Gawel Kus<sup>[1]</sup>, Isabel Haide<sup>[1]</sup>, Shubha Deutschle<sup>[1]</sup>, Harry Barowski<sup>[1]</sup>, Dominik Steenken<sup>[1]</sup>, and Albert Frisch<sup>[1]</sup>\n",
    "### Affiliation\n",
    "- <sup>[1]</sup>IBMQ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The HHL algorithm (after the author’s surnames Harrow-Hassidim-Lloyd) [1] is a quantum algorithm to solve systems of linear equations $A \\vec{x} = \\vec{b}$. To perform this calculation quantum mechanically, we need in general 4 main steps requiring three qubit registers:\n",
    "<ol>\n",
    "<li>First, we have to express the vector $\\vec{b}$ as a quantum state $|b\\rangle$ on a quantum register.</li>\n",
    "<li>Now, we have to decompose $\\vec{b}$ into a superposition of eigenvectors of $A$ remembering on the linear combination of the vector $\\vec{b}$. We achieve this using the Quantum Phase Estimation algorithm (Quantum Phase Estimation (QPE)). Since the matrix is hereby diagonalized wherefore $A$ is easily invertible.</li>\n",
    "<li>The inversion of the eigenvector base of $A$ is achieved by rotating an ancillary qubit by an angle $\\arcsin \\left( \\frac{C}{\\lambda _{\\text{i}}} \\right)$ around the y-axis where $\\lambda_{\\text{i}}$ are the eigenvalues of $A$. Now, we obtain the state $A^{-1}|b\\rangle = |x \\rangle$.</li>\n",
    "<li>We need to uncompute the register storing the eigenvalues using the inverse QPE. We measure the ancillary qubit whereby the measurement of 1 indicates that the matrix inversion was successful. The inverse QPE leaves the system in a state proportional to the solution vector $|x\\rangle$. In many cases one is not interested in the single vector elements of $|x\\rangle$ but only on certain properties. These are accessible by applying a problem-specific operator $M$ to the state $|x\\rangle$. Another use-case of the HHL algorithm is the implementation in a larger quantum program.</li>\n",
    "</ol>\n",
    "Currently only hermitian matrices with a dimension of $2^n$ are supported.\n",
    "\n",
    "Take into account that in the general case, the entries of $\\vec{x}$ can not be efficiently read out because we would need to know all coefficients describing the quantum state.\n",
    "In the following examples, we ignore this constraint and show for our small linear system as a proof of principle that $\\vec{x}$ is calculated correctly.\n",
    "\n",
    "References:\n",
    "- A. W. Harrow, A. Hassidim, and S. Lloyd, Phys. Rev. Lett. 103, 150502 (2009), e-print arXiv 0811.3171\n",
    "- S. Barz, I. Kassal, M. Ringbauer, Y. Ole Lipp, B. Dakić, A. Aspuru-Guzik, and P. Walther, Sci Rep. 4: 6115 (2014), e-print arXiv 1302.1210"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T01:39:51.130989Z",
     "start_time": "2019-08-22T01:39:48.567368Z"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit.aqua import run_algorithm\n",
    "from qiskit.aqua.input import LinearSystemInput\n",
    "from qiskit.quantum_info import state_fidelity\n",
    "from qiskit.aqua.algorithms.classical import ExactLSsolver\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T01:39:51.149609Z",
     "start_time": "2019-08-22T01:39:51.144479Z"
    }
   },
   "outputs": [],
   "source": [
    "params = {\n",
    "    'problem': {\n",
    "        'name': 'linear_system'\n",
    "    },\n",
    "    'algorithm': {\n",
    "        'name': 'HHL'\n",
    "    },\n",
    "    'eigs': {\n",
    "        'expansion_mode': 'suzuki',\n",
    "        'expansion_order': 2,\n",
    "        'name': 'EigsQPE',\n",
    "        'num_ancillae': 3,\n",
    "        'num_time_slices': 50\n",
    "    },\n",
    "    'reciprocal': {\n",
    "        'name': 'Lookup'\n",
    "    },\n",
    "    'backend': {\n",
    "        'provider': 'qiskit.BasicAer',\n",
    "        'name': 'statevector_simulator'\n",
    "    }\n",
    "}\n",
    "\n",
    "def fidelity(hhl, ref):\n",
    "    solution_hhl_normed = hhl / np.linalg.norm(hhl)\n",
    "    solution_ref_normed = ref / np.linalg.norm(ref)\n",
    "    fidelity = state_fidelity(solution_hhl_normed, solution_ref_normed)\n",
    "    print(\"fidelity %f\" % fidelity)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2x2 diagonal matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we show an example for running the HHL algorithm with Qiskit Aqua on a diagonal matrix as input\n",
    "$$\n",
    "A=\n",
    "\\begin{bmatrix}\n",
    "1 & 0 \\\\\n",
    "0 & 2\n",
    "\\end{bmatrix}$$ with the vector $$\\vec{b}= \\left( \\begin{array}{c}1 \\\\ 4  \\end{array} \\right)$$\n",
    "The `result` dictionary contains several return values. The HHL solution for $\\vec{x}$ is accessible by the key `'solution'`. For comparison, also the classical solution of the linear system of equations is calculated using standard linear algebra functions in numpy. The fidelity between the HHL solution and the classical solution is also given in the output. Furthermore, the probability is shown with which HHL was running successfully, i.e. the HHL ancillary qubit has been measured to be $|1\\rangle$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T01:39:51.435207Z",
     "start_time": "2019-08-22T01:39:51.431997Z"
    }
   },
   "outputs": [],
   "source": [
    "matrix = [[1, 0], [0, 2]]\n",
    "vector = [1, 4]\n",
    "params['input'] = {\n",
    "    'name': 'LinearSystemInput',\n",
    "    'matrix': matrix,\n",
    "    'vector': vector\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T01:40:22.904918Z",
     "start_time": "2019-08-22T01:39:51.718509Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Numpy 1.16 has memory leak bug  https://github.com/numpy/numpy/issues/13808\n",
      "It is recommended to downgrade to numpy 1.15 or older\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "solution  [1.05859-0.j 1.99245-0.j]\n",
      "classical solution  [1. 2.]\n",
      "probability 0.024630\n",
      "fidelity 0.999389\n"
     ]
    }
   ],
   "source": [
    "result = run_algorithm(params)\n",
    "print(\"solution \", np.round(result['solution'], 5))\n",
    "\n",
    "result_ref = ExactLSsolver(matrix, vector).run()\n",
    "print(\"classical solution \", np.round(result_ref['solution'], 5))\n",
    "\n",
    "print(\"probability %f\" % result['probability_result'])\n",
    "fidelity(result['solution'], result_ref['solution'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The probabilty that HHL runs successfully depends on the constant $C$ (see step 3. in the introduction). In the HHL algorithm, $C$ can be given as the parameter `scale` $\\in [0,1]$. In the above example `scale` is not defined in the `params` dictionary and the HHL algorithm initializes it to the smallest possible eigenvalue before execution. Alternatively, we can set `scale` to 0.5 and see how the results are influenced thereby."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T01:40:50.874643Z",
     "start_time": "2019-08-22T01:40:22.925404Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "solution  [0.84664-0.j 2.01762-0.j]\n",
      "classical solution  [1. 2.]\n",
      "probability 0.361437\n",
      "fidelity 0.995605\n"
     ]
    }
   ],
   "source": [
    "params2 = params\n",
    "params2['reciprocal'] = {    \n",
    "    'scale': 0.5\n",
    "}\n",
    "\n",
    "result = run_algorithm(params2)\n",
    "print(\"solution \", np.round(result['solution'], 5))\n",
    "\n",
    "result_ref = ExactLSsolver(matrix, vector).run()\n",
    "print(\"classical solution \", np.round(result_ref['solution'], 5))\n",
    "\n",
    "print(\"probability %f\" % result['probability_result'])\n",
    "fidelity(result['solution'], result_ref['solution'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to know how many qubits are required (circuit width) or how large the maximum number of gates applied to a single qubit (circuit depth) is, you can print it out by"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T01:40:50.892442Z",
     "start_time": "2019-08-22T01:40:50.888521Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "circuit_width 7\n",
      "circuit_depth 129\n"
     ]
    }
   ],
   "source": [
    "print(\"circuit_width\", result['circuit_info']['width'])\n",
    "print(\"circuit_depth\", result['circuit_info']['depth'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2x2 non-diagonal matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we show an example for running the HHL algorithm with Qiskit Aqua on a non-diagonal matrix as input\n",
    "$$\n",
    "A=\n",
    "\\begin{bmatrix}\n",
    "1 & 3 \\\\\n",
    "3 & 2\n",
    "\\end{bmatrix}$$ with the vector $$\\vec{b}= \\left( \\begin{array}{c}1 \\\\ 1  \\end{array} \\right)$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T01:40:50.912216Z",
     "start_time": "2019-08-22T01:40:50.908085Z"
    }
   },
   "outputs": [],
   "source": [
    "matrix = [[1, 3], [3, 2]]\n",
    "vector = [1, 1]\n",
    "params3 = params\n",
    "params3['input'] = {\n",
    "    'name': 'LinearSystemInput',\n",
    "    'matrix': matrix,\n",
    "    'vector': vector\n",
    "}\n",
    "params3['reciprocal'] = {\n",
    "    'negative_evals': True\n",
    "}\n",
    "params3['eigs'] = {\n",
    "    'negative_evals': True\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2019-08-22T01:40:04.769Z"
    }
   },
   "outputs": [],
   "source": [
    "result = run_algorithm(params3)\n",
    "print(\"solution \", np.round(result['solution'], 5))\n",
    "\n",
    "result_ref = ExactLSsolver(matrix, vector).run()\n",
    "print(\"classical solution \", np.round(result_ref['solution'], 5))\n",
    "\n",
    "print(\"probability %f\" % result['probability_result'])\n",
    "fidelity(result['solution'], result_ref['solution'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compared to the the first example, the circuit depth is increased approximately by a factor of 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2019-08-22T01:40:07.544Z"
    }
   },
   "outputs": [],
   "source": [
    "print(\"circuit_width\", result['circuit_info']['width'])\n",
    "print(\"circuit_depth\", result['circuit_info']['depth'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8x8 non-diagonal matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For simplicity, we show a HHL execution of a linear systom of equations defined by the following 8x8 dimensional matrix\n",
    "$$\n",
    "A=\n",
    "\\begin{bmatrix}\n",
    "4 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\\\\n",
    "0 & 3 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n",
    "0 & 0 & 8 & 0 & 0 & 0 & 0 & 0 \\\\\n",
    "0 & 0 & 0 & 5 & 0 & 0 & 0 & 0 \\\\\n",
    "0 & 0 & 0 & 0 & 2 & 1 & 0 & 0 \\\\\n",
    "0 & 0 & 0 & 0 & 1 & 1 & 0 & 0 \\\\\n",
    "0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\\\\n",
    "1 & 0 & 0 & 0 & 0 & 0 & 0 & 5\n",
    "\\end{bmatrix}$$ and the vector $$\\vec{b}= \\left( \\begin{array}{c}1 \\\\ 0 \\\\ 0 \\\\ 0 \\\\ 0 \\\\ 0 \\\\ 0 \\\\ 1 \\end{array} \\right)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2019-08-22T01:40:08.096Z"
    }
   },
   "outputs": [],
   "source": [
    "matrix = [[4, 0, 0, 0, 0, 0, 0, 1],\n",
    "          [0, 3, 0, 0, 0, 0, 0, 0],\n",
    "          [0, 0, 8, 0, 0, 0, 0, 0],\n",
    "          [0, 0, 0, 5, 0, 0, 0, 0],\n",
    "          [0, 0, 0, 0, 2, 1, 0, 0],\n",
    "          [0, 0, 0, 0, 1, 1, 0, 0],\n",
    "          [0, 0, 0, 0, 0, 0, 1, 0],\n",
    "          [1, 0, 0, 0, 0, 0, 0, 5]]\n",
    "vector = [1, 0, 0, 0, 0, 0, 0, 1]\n",
    "params4 = params\n",
    "params4['input'] = {\n",
    "    'name': 'LinearSystemInput',\n",
    "    'matrix': matrix,\n",
    "    'vector': vector\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2019-08-22T01:40:08.599Z"
    }
   },
   "outputs": [],
   "source": [
    "result = run_algorithm(params4)\n",
    "print(\"solution \", np.round(result['solution'], 5))\n",
    "\n",
    "result_ref = ExactLSsolver(matrix, vector).run()\n",
    "print(\"classical solution \", np.round(result_ref['solution'], 5))\n",
    "\n",
    "print(\"probability %f\" % result['probability_result'])\n",
    "fidelity(result['solution'], result_ref['solution'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Considering the circuit depth and circuit width"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2019-08-22T01:40:09.363Z"
    }
   },
   "outputs": [],
   "source": [
    "print(\"circuit_width\", result['circuit_info']['width'])\n",
    "print(\"circuit_depth\", result['circuit_info']['depth'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4x4 randomly-generated matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we show the application of HHL on a randomly-generated 4x4 matrix. We use the function `random_hermitian` to generate a random hermitian matrix and initialize the random seed to achieve reproducibility of the HHL run. Since the matrix can have negative eigenvalues, the `params` dictionary has to be modified by `\"negative_evals\": True` in `\"eigs\"` and `\"reciprocal\"`, respectively. We choose $$\\vec{b}= \\left( \\begin{array}{c}1 \\\\ 2 \\\\ 3 \\\\ 1 \\end{array} \\right)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2019-08-22T01:40:10.519Z"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit import BasicAer\n",
    "from qiskit.aqua import QuantumInstance\n",
    "from qiskit.aqua.algorithms.single_sample import HHL\n",
    "from qiskit.aqua.utils import random_hermitian"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is needed for this example to define the \"initial_state\", the \"qft\" and the \"iqft\" additionally:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2019-08-22T01:40:11.498Z"
    }
   },
   "outputs": [],
   "source": [
    "params5 = params\n",
    "params5['algorithm'] = {\n",
    "    'truncate_powerdim': False,\n",
    "    'truncate_hermitian': False\n",
    "}\n",
    "params5['reciprocal'] = {\n",
    "    'name': 'Lookup',\n",
    "    'negative_evals': True\n",
    "}\n",
    "params5['eigs'] = {\n",
    "    'expansion_mode': 'suzuki',\n",
    "    'expansion_order': 2,\n",
    "    'name': 'EigsQPE',\n",
    "    'negative_evals': True,\n",
    "    'num_ancillae': 6,\n",
    "    'num_time_slices': 70\n",
    "}\n",
    "params5['initial_state'] = {\n",
    "    'name': 'CUSTOM'\n",
    "}\n",
    "params5['iqft'] = {\n",
    "    'name': 'STANDARD'\n",
    "}\n",
    "params5['qft'] = {\n",
    "    'name': 'STANDARD'\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we create an instance of the `HHL` class and run the algorithm with an input that is created programatically. To get the same pseudo-random matrix for every run, we set the random seed by using `np.random.seed(1)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2019-08-22T01:40:12.367Z"
    }
   },
   "outputs": [],
   "source": [
    "# set the random seed to get the same pseudo-random matrix for every run\n",
    "np.random.seed(1)\n",
    "matrix = random_hermitian(4)\n",
    "vector = [1, 2, 3, 1]\n",
    "\n",
    "print(\"random matrix:\")\n",
    "m = np.array(matrix)\n",
    "print(np.round(m, 3))\n",
    "\n",
    "algo_input = LinearSystemInput(matrix=matrix, vector=vector)\n",
    "hhl = HHL.init_params(params5, algo_input)\n",
    "backend = BasicAer.get_backend('statevector_simulator')\n",
    "quantum_instance = QuantumInstance(backend=backend)\n",
    "result = hhl.run(quantum_instance)\n",
    "print(\"solution \", np.round(result['solution'], 5))\n",
    "\n",
    "result_ref = ExactLSsolver(matrix, vector).run()\n",
    "print(\"classical solution \", np.round(result_ref['solution'], 5))\n",
    "\n",
    "print(\"probability %f\" % result['probability_result'])\n",
    "fidelity(result['solution'], result_ref['solution'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The circuit width and depth are"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2019-08-22T01:40:13.243Z"
    }
   },
   "outputs": [],
   "source": [
    "print(\"circuit_width\", result['circuit_info']['width'])\n",
    "print(\"circuit_depth\", result['circuit_info']['depth'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-22T01:53:14.511056Z",
     "start_time": "2019-08-22T01:53:14.501261Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h3>Version Information</h3><table><tr><th>Qiskit Software</th><th>Version</th></tr><tr><td>Qiskit</td><td>None</td></tr><tr><td>Terra</td><td>0.9.0</td></tr><tr><td>Aer</td><td>0.3.0</td></tr><tr><td>Ignis</td><td>0.2.0</td></tr><tr><td>Aqua</td><td>0.5.6</td></tr><tr><td>IBM Q Provider</td><td>0.3.2rc1</td></tr><tr><th>System information</th></tr><tr><td>Python</td><td>3.7.4 (default, Aug 13 2019, 15:17:50) \n",
       "[Clang 4.0.1 (tags/RELEASE_401/final)]</td></tr><tr><td>OS</td><td>Darwin</td></tr><tr><td>CPUs</td><td>4</td></tr><tr><td>Memory (Gb)</td><td>16.0</td></tr><tr><td colspan='2'>Wed Aug 21 21:53:14 2019 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, 2019.</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 qiskit.tools.jupyter\n",
    "%qiskit_version_table\n",
    "%qiskit_copyright"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.7.4"
  },
  "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
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}