main.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "edb4d5b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Main libraries required\n",
    "import qiskit as qk\n",
    "import numpy as np\n",
    "from scipy.optimize import minimize\n",
    "from itertools import product, combinations, permutations\n",
    "\n",
    "# Plotting libraries\n",
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams.update({'font.size': 22})\n",
    "import seaborn as sns\n",
    "\n",
    "# QAOA implementation using conventional problem encoding\n",
    "from tsp_qaoa_orig import TSP_QAOA_Orig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b7d86fef",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Held-Karp\n",
    "# Keys in table: Use the nodes in the set to reach the point in the second tuple element. \n",
    "# Values in table: Order of the optimum tour and the total distance\n",
    "def tsp_dynamic(adj_matrix, first_node=0, last_node=0):\n",
    "    n = adj_matrix.shape[0]\n",
    "    init_minimum = np.sum(adj_matrix)\n",
    "    table = {}\n",
    "    for i in range(n):\n",
    "        table[(frozenset((i,)),i)] = ((i,), adj_matrix[first_node, i])\n",
    "    nodes = frozenset(range(n)).difference((first_node, last_node))\n",
    "    for s in range(2, len(nodes)+1):\n",
    "        for S in combinations(nodes, s):\n",
    "            set_S = frozenset(S)\n",
    "            for k in S:\n",
    "                minimum_distance = init_minimum\n",
    "                minimum_path = None\n",
    "                set_Smk = set_S.difference((k,))\n",
    "                for m in set_Smk:\n",
    "                    table_entry = table[(set_Smk, m)]\n",
    "                    distance = table_entry[1] + adj_matrix[m,k]\n",
    "                    if distance < minimum_distance:\n",
    "                        minimum_distance = distance\n",
    "                        minimum_path = table_entry[0]\n",
    "                table[(set_S, k)] = (minimum_path + (k,), minimum_distance)\n",
    "    \n",
    "    minimum_distance = init_minimum\n",
    "    minimum_path = None\n",
    "    # Find Minimum\n",
    "    for i in nodes:\n",
    "        table_entry = table[(nodes, i)]\n",
    "        distance = table_entry[1] + adj_matrix[i,last_node]\n",
    "        if distance < minimum_distance:\n",
    "            minimum_distance = distance\n",
    "            minimum_path = table_entry[0] + (last_node,)\n",
    "    return (minimum_path, minimum_distance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a606454e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_path_length(path, adj_matrix):\n",
    "    length = 0\n",
    "    for i,j in zip(path[:-1], path[1:]):\n",
    "        length += adj_matrix[i,j]\n",
    "    return length\n",
    "\n",
    "def path_from_string(string):\n",
    "    n = int(0.5*(3 + (4*len(string) + 1)**0.5))\n",
    "    edge_in = set(range(1, n))\n",
    "    edges = set()\n",
    "    rev_string = string[::-1]\n",
    "    value = None\n",
    "    for bit, edge in enumerate(permutations(range(1, n), 2)):\n",
    "        value = rev_string[bit]\n",
    "        if value == \"1\":\n",
    "            edges.add(edge)\n",
    "            edge_in.remove(edge[1])\n",
    "    path = [0, edge_in.pop()]\n",
    "    while edges:\n",
    "        for edge in edges:\n",
    "            if edge[0] == path[-1]:\n",
    "                path.append(edge[1])\n",
    "                edges.remove(edge)\n",
    "                break\n",
    "    return path + [0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "89d3fad1",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TSP_QAOA:\n",
    "    def __init__(self, n, p):\n",
    "        assert (n > 2) and (n < 5)\n",
    "        \n",
    "        self.qubits = None\n",
    "        self.cbits = None\n",
    "        self.circuit = None\n",
    "        self.matrix_bound = None\n",
    "        self.params_bound = None\n",
    "        self.beta = None\n",
    "        self.gamma = None\n",
    "        self.matrix = None\n",
    "        self.p = p\n",
    "        self.n = n\n",
    "        self.adj_matrix = None\n",
    "        self.opt_iterations = 0\n",
    "\n",
    "    def build_state_preparation(self):\n",
    "        # TODO: Abstract to an arbitrary number of cities\n",
    "        # TODO: This should work recursively (somehow)\n",
    "        if self.n == 3:\n",
    "            self.circuit.h(0)\n",
    "            self.circuit.cx(0, 1)\n",
    "            self.circuit.x(0)\n",
    "        elif self.n == 4:\n",
    "            self.circuit.ry(np.arccos(-1/3), 0)\n",
    "            self.circuit.ch(0, 1)\n",
    "            self.circuit.ch(1, 2)\n",
    "            self.circuit.cx(2, 3)\n",
    "            self.circuit.cx(1, 2)\n",
    "            self.circuit.cx(0, 1)\n",
    "            self.circuit.x(0)\n",
    "            self.circuit.ch(1, 2)\n",
    "            self.circuit.cx(2, 5)\n",
    "            self.circuit.cx(1, 2)\n",
    "            self.circuit.ch(0, 3)\n",
    "            self.circuit.cx(3, 4)\n",
    "            self.circuit.cx(0, 3)\n",
    "        else:\n",
    "            pass\n",
    "\n",
    "    def reverse_state_preparation(self):\n",
    "        # TODO: Abstract to an arbitrary number of cities\n",
    "        if self.n == 3:\n",
    "            self.circuit.x(0)\n",
    "            self.circuit.cx(0, 1)\n",
    "            self.circuit.h(0)\n",
    "        elif self.n == 4:\n",
    "            self.circuit.cx(0, 3)\n",
    "            self.circuit.cx(3, 4)\n",
    "            self.circuit.ch(0, 3)\n",
    "            self.circuit.cx(1, 2)\n",
    "            self.circuit.cx(2, 5)\n",
    "            self.circuit.ch(1, 2)\n",
    "            self.circuit.x(0)\n",
    "            self.circuit.cx(0, 1)\n",
    "            self.circuit.cx(1, 2)\n",
    "            self.circuit.cx(2, 3)\n",
    "            self.circuit.ch(1, 2)\n",
    "            self.circuit.ch(0, 1)\n",
    "            self.circuit.ry(-np.arccos(-1/3), 0)\n",
    "        else:\n",
    "            pass\n",
    "\n",
    "    def build_phase_separator(self, parameter):\n",
    "        \"\"\"\n",
    "        Phase separator for a single iteration, hence only a single parameter is used\n",
    "        \"\"\"\n",
    "        for qubit, edge in enumerate(permutations(range(1, self.n), 2)):\n",
    "            self.circuit.p(2 * parameter * (self.matrix[edge[0]][edge[1]] - (self.n-3)*(self.matrix[edge[0]][0]/(self.n-2)) - (self.n-3)*(self.matrix[0][edge[1]]/(self.n-2))), qubit)\n",
    "            self.circuit.x(qubit)\n",
    "            self.circuit.p(2 * parameter * (self.matrix[edge[0]][0]/(self.n-2) + self.matrix[0][edge[1]]/(self.n-2)), qubit)\n",
    "            self.circuit.x(qubit)\n",
    "\n",
    "    def build_mixer(self, parameter):\n",
    "        \"\"\"\n",
    "        Mixer for a single iteration, hence only a single parameter is used\n",
    "        \"\"\"\n",
    "        self.reverse_state_preparation()\n",
    "\n",
    "        self.circuit.x(self.qubits)\n",
    "\n",
    "        cp_gate = qk.circuit.library.standard_gates.PhaseGate(parameter).control(len(self.qubits) - 1)\n",
    "        self.circuit.append(cp_gate, self.qubits)\n",
    "\n",
    "        self.circuit.x(self.qubits)\n",
    "\n",
    "        self.build_state_preparation()\n",
    "\n",
    "    def bind_matrix(self, adj_matrix):\n",
    "        adj_matrix_norm = adj_matrix/(np.max(adj_matrix)*self.n)\n",
    "        params_matrix = {self.matrix[i][j]: adj_matrix_norm[i,j] for i, j in product(range(self.n), range(self.n)) if i != j}\n",
    "        self.matrix_bound = self.circuit.assign_parameters(params_matrix)\n",
    "        self.adj_matrix = adj_matrix\n",
    "\n",
    "    def bind_parameters(self, parameters):\n",
    "        assert (self.matrix_bound is not None), \"Matrix parameters need to be bound\"\n",
    "        betas = parameters[:self.p]\n",
    "        gammas = parameters[self.p:]\n",
    "        \n",
    "        params_beta = {qcbeta: pbeta for qcbeta, pbeta in zip(self.beta, betas)}\n",
    "        params_gamma = {qcgamma: pgamma for qcgamma, pgamma in zip(self.gamma, gammas)}\n",
    "        \n",
    "        self.params_bound = self.matrix_bound.assign_parameters({**params_beta, **params_gamma})\n",
    "\n",
    "    def compute_path_length(self, measurement):\n",
    "        rev_string = measurement[::-1]\n",
    "        value = 0\n",
    "        for bit, edge in enumerate(permutations(range(1, self.n), 2)):\n",
    "            bit_value = rev_string[bit]\n",
    "            if bit_value == \"0\":\n",
    "                value += self.adj_matrix[edge[0]][0]/(self.n-2)\n",
    "                value += self.adj_matrix[0][edge[1]]/(self.n-2)\n",
    "            else:\n",
    "                value -= (self.n-3)*(self.adj_matrix[edge[0]][0]/(self.n-2))\n",
    "                value -= (self.n-3)*(self.adj_matrix[0][edge[1]]/(self.n-2))\n",
    "                value += self.adj_matrix[edge[0]][edge[1]]\n",
    "        return value\n",
    "\n",
    "    def compute_expectation(self, counts, shots):\n",
    "        sum_count = 0\n",
    "        for string, count in counts.items():\n",
    "            sum_count += self.compute_path_length(string)*count\n",
    "\n",
    "        return sum_count/shots \n",
    "        \n",
    "    def build_circuit(self, backend):\n",
    "        self.beta = [qk.circuit.Parameter(\"beta{}\".format(i)) for i in range(self.p)]\n",
    "        self.gamma = [qk.circuit.Parameter(\"gamma{}\".format(i)) for i in range(self.p)]\n",
    "        self.matrix = [[qk.circuit.Parameter(\"matrix{0}{1}\".format(i,j)) for j in range(self.n)] for i in range(self.n)]\n",
    "\n",
    "        self.qubits = qk.QuantumRegister((self.n-1)*(self.n-2))\n",
    "        self.cbits = qk.ClassicalRegister((self.n-1)*(self.n-2))\n",
    "        \n",
    "        self.circuit = qk.QuantumCircuit(self.qubits, self.cbits)\n",
    "\n",
    "        self.build_state_preparation()\n",
    "        \n",
    "        for i in range(self.p):\n",
    "            self.build_phase_separator(self.gamma[i])\n",
    "            self.build_mixer(self.beta[i])\n",
    "\n",
    "        self.circuit.measure(self.qubits, self.cbits)\n",
    "        self.circuit = qk.transpile(self.circuit, optimization_level=3, backend=backend)\n",
    "\n",
    "    def run_circuit(self, parameters, backend, shots):\n",
    "        self.bind_parameters(parameters)\n",
    "        counts = backend.run(self.params_bound, seed_simulator=42, shots=shots).result().get_counts()\n",
    "        return counts\n",
    "\n",
    "    def solve(self, adj_matrix, shots=1000, backend=None):\n",
    "        assert (self.n == len(adj_matrix)), \"Adjacency matrix does not fit with given number of qubits\"\n",
    "        \n",
    "        if backend is None:\n",
    "            backend = qk.Aer.get_backend('qasm_simulator')\n",
    "\n",
    "        if self.circuit is None:\n",
    "            self.build_circuit(backend)\n",
    "\n",
    "        self.bind_matrix(adj_matrix)\n",
    "\n",
    "        def get_circuit_expectation(parameters):\n",
    "            counts = self.run_circuit(parameters, backend, shots)\n",
    "            expectation = self.compute_expectation(counts, shots)\n",
    "            self.opt_iterations += 1\n",
    "            return expectation\n",
    "        \n",
    "        self.opt_iterations = 0\n",
    "        res = minimize(get_circuit_expectation, [0.5]*(self.p*2), method='COBYLA')\n",
    "        optim = res.x\n",
    "\n",
    "        counts = self.run_circuit(optim, backend, shots)\n",
    "        best_path = max(counts, key=counts.get)\n",
    "        # expectations = {path: self.compute_path_length(path) for path, _ in counts.items()}\n",
    "        path_length = self.compute_path_length(best_path)\n",
    "        best_path = path_from_string(best_path)\n",
    "        \n",
    "        return tuple(best_path[1:]), path_length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "32d918cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "tsp_size = 4\n",
    "p = 1\n",
    "shots = 1000\n",
    "backend = qk.Aer.get_backend('qasm_simulator')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "92983a48",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We create a new QAOA solver object for our desired circuit size\n",
    "tsp_qaoa_solver = TSP_QAOA(tsp_size, p)\n",
    "# Build the circuit with respect to the given backend\n",
    "# This only needs to be done once - this circuit is parametrized and\n",
    "# can be used for any TSP instance of the previously defined size\n",
    "tsp_qaoa_solver.build_circuit(backend)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f9ab5d32",
   "metadata": {},
   "outputs": [],
   "source": [
    "tsp_qaoa_solver_orig = TSP_QAOA_Orig(tsp_size, p)\n",
    "tsp_qaoa_solver_orig.build_circuit(backend)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9dc5ae26",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0, 18,  4,  8],\n",
       "       [ 5,  0,  5,  7],\n",
       "       [13, 11,  0, 10],\n",
       "       [17,  7,  3,  0]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Generate a random TSP instance\n",
    "random_tsp = np.random.randint(low=1, high=20, size=(tsp_size, tsp_size))\n",
    "random_tsp[np.diag_indices(tsp_size)] = 0\n",
    "random_tsp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b55c39c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((2, 3, 1, 0), 26.0)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This will return 2 values: The computed path and the length of it\n",
    "# The first (and last) node are assumed to be 0 (without loss of generality)\n",
    "tsp_qaoa_solver.solve(random_tsp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "03dcb611",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((2, 3, 1, 0), 26)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tsp_qaoa_solver_orig.solve(random_tsp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8f013743",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((2, 3, 1, 0), 26)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Optimal solution - same output format as for the QAOA solution\n",
    "tsp_dynamic(random_tsp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "3d3d415c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Progress: 100.00%\r"
     ]
    }
   ],
   "source": [
    "number_of_samples = 1000\n",
    "tour_lengthts_reference = []\n",
    "tour_lengthts_approxiamtion = []\n",
    "opt_iterations_new = []\n",
    "\n",
    "for i in range(number_of_samples):\n",
    "    # Generate random TSP of the same size as above\n",
    "    random_tsp = np.random.randint(low=1, high=20, size=(tsp_size, tsp_size))\n",
    "    random_tsp[np.diag_indices(tsp_size)] = 0\n",
    "\n",
    "    # Compute optimum solution\n",
    "    solution = tsp_dynamic(random_tsp)\n",
    "    # Compute QAOA approximation\n",
    "    approximation = tsp_qaoa_solver.solve(random_tsp)\n",
    "\n",
    "    # For this comparison we are only interested in the returned tour lengths\n",
    "    tour_lengthts_reference.append(solution[1])\n",
    "    tour_lengthts_approxiamtion.append(approximation[1])\n",
    "    opt_iterations_new.append(tsp_qaoa_solver.opt_iterations)\n",
    "\n",
    "    print(\"Progress: {:.2f}%\".format(((i+1)/number_of_samples)*100), end=\"\\r\")\n",
    "\n",
    "tour_lengthts_reference = np.array(tour_lengthts_reference)\n",
    "tour_lengthts_approxiamtion = np.array(tour_lengthts_approxiamtion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2f2fe1c0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1512x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "relative_errors = np.abs(tour_lengthts_reference - tour_lengthts_approxiamtion)/tour_lengthts_reference\n",
    "weights = np.ones_like(relative_errors)/len(relative_errors)\n",
    "\n",
    "plt.figure(figsize=(21,9))\n",
    "plt.hist(relative_errors, bins=np.arange(0,1,0.02), weights=weights, edgecolor='black', color='skyblue')\n",
    "plt.ylim((0, 1))\n",
    "plt.title(\"Error distribution of test samples\")\n",
    "plt.xlabel(\"Relative error\")\n",
    "plt.ylabel(\"Relative frequency\")\n",
    "plt.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "136074f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.03"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Fraction of non-optimal QAOA solutions\n",
    "len(relative_errors[relative_errors>0])/number_of_samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "2fd73b87",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.05151151273840233"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Average relative error of all non-optimal QAOA solutions\n",
    "np.mean(relative_errors[relative_errors>0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "aff9bf42",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Progress: 100.00%\r"
     ]
    }
   ],
   "source": [
    "tour_lengthts_reference = []\n",
    "tour_lengthts_approxiamtion = []\n",
    "opt_iterations_orig = []\n",
    "\n",
    "for i in range(number_of_samples):\n",
    "    # Generate random TSP of the same size as above\n",
    "    random_tsp = np.random.randint(low=1, high=20, size=(tsp_size, tsp_size))\n",
    "    random_tsp[np.diag_indices(tsp_size)] = 0\n",
    "\n",
    "    # Compute optimum solution\n",
    "    solution = tsp_dynamic(random_tsp)\n",
    "    # Compute QAOA approximation\n",
    "    approximation = tsp_qaoa_solver_orig.solve(random_tsp)\n",
    "\n",
    "    # For this comparison we are only interested in the returned tour lengths\n",
    "    tour_lengthts_reference.append(solution[1])\n",
    "    tour_lengthts_approxiamtion.append(approximation[1])\n",
    "    opt_iterations_orig.append(tsp_qaoa_solver_orig.opt_iterations)\n",
    "\n",
    "    print(\"Progress: {:.2f}%\".format(((i+1)/number_of_samples)*100), end=\"\\r\")\n",
    "\n",
    "tour_lengthts_reference = np.array(tour_lengthts_reference)\n",
    "tour_lengthts_approxiamtion = np.array(tour_lengthts_approxiamtion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b67b5621",
   "metadata": {},
   "outputs": [],
   "source": [
    "tour_lengthts_reference = np.array(tour_lengthts_reference)\n",
    "tour_lengthts_approxiamtion = np.array(tour_lengthts_approxiamtion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "628610fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1512x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "relative_errors = np.abs(tour_lengthts_reference - tour_lengthts_approxiamtion)/tour_lengthts_reference\n",
    "weights = np.ones_like(relative_errors)/len(relative_errors)\n",
    "\n",
    "plt.figure(figsize=(21,9))\n",
    "plt.hist(relative_errors, bins=np.arange(0,1,0.02), weights=weights, edgecolor='black', color='skyblue')\n",
    "plt.ylim((0, 1))\n",
    "plt.title(\"Error distribution of test samples\")\n",
    "plt.xlabel(\"Relative error\")\n",
    "plt.ylabel(\"Relative frequency\")\n",
    "plt.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "67a42e0b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.446"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Fraction of non-optimal QAOA solutions\n",
    "len(relative_errors[relative_errors>0])/number_of_samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "b4311d8f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.727492335131072"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Average relative error of all non-optimal QAOA solutions\n",
    "np.mean(relative_errors[relative_errors>0])"
   ]
  }
 ],
 "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.10.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}