getdist_analysis_pipelines_and_tutorials/compute_significance_from_chains.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "992c4826-b079-4648-8070-74bc0e6e340b",
   "metadata": {},
   "source": [
    "# Compute significance from 2D constraints"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "198cfa53-b7d4-4ea5-979f-35ab8fc72757",
   "metadata": {},
   "source": [
    "This notebook computes the significance of a theoretical prediction or an (new) observed data point given the current 2D (and ND) marginal constraints.\n",
    "\n",
    "MCMC chains are assumed to be compatible with `getdist` and the 2D (and ND) marginal densities are estimated by KDEs implemented in `getdist.densities.Density2D` (and `getdist.densities.DensityND`)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "336d21ab-9f4a-4d37-8509-7007fede7959",
   "metadata": {},
   "source": [
    "## Required modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cd804e18-830b-4161-a0d3-9b9efcdb89f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "import bisect\n",
    "import getdist\n",
    "import numpy as np\n",
    "from scipy.interpolate import RectBivariateSpline\n",
    "#import vegas # For ND integration, we need a Monte Carlo integrator\n",
    "#import vegasflow"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb4c4a40-fe2b-4daf-99df-418f1c7ac894",
   "metadata": {},
   "source": [
    "## Class and functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "0d40f156-bc41-48dd-8427-bb9175e484dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TensionBarometer:\n",
    "    r\"\"\"\n",
    "    A class to compute:\n",
    "    - significance of a point in parameter space (from theory or observation) given the data constraint.\n",
    "    - tension between two data constraints (within the same theoretical model).\n",
    "    \"\"\"\n",
    "    def __init__(self, *args):\n",
    "        r\"\"\"\n",
    "        Class constructor.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        samples: list[getdist.MCSamples]\n",
    "            A list consists instance(s) of ``getdist.MCSamples``.\n",
    "        \"\"\"\n",
    "        self.samples = args\n",
    "        self.significances = None\n",
    "        if self.samples is None:\n",
    "            raise Exception(f\"Receive empty input. Provide >=1 instance(s) of ``getdist.MCSamples``.\")\n",
    "        elif self.samples == 1:\n",
    "            warnings.warn(f\"Receive a single ``getdist.MCSamples`` as input.\", category=Warning)\n",
    "        else:\n",
    "            print(f\"Receive {len(self.samples)} instances of ``getdist.MCSamples`` as input.\")\n",
    "            \n",
    "    def compute_point_pdf_2D(self,par_xy,point_xy,normalized=False,**kwargs):\n",
    "        r\"\"\"\n",
    "        Helper function.\n",
    "        Return the posterior densities at points corresponding to input parameters `par_xy`.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        par_xy: list[str]\n",
    "                The indexes or names of the two parameters, [par_x,par_y].\n",
    "        point_xy: [float, float]\n",
    "                The position of the prediction/observation in [par_x, par_y] coordinates.\n",
    "        normalized: bool, optional\n",
    "                Whether to normalize the ``getdist.densities.Density2D`` estimate.\n",
    "                Default to `False`.\n",
    "        **kwargs:\n",
    "                Keyword arguments for ``getdist.mcsamples.get2DDensityGridData()`` and ``scipy.interpolate.RectBivariateSpline``.\n",
    "        \"\"\"\n",
    "        point_pdf_2D=[]\n",
    "        for sample in self.samples:\n",
    "            density2D = sample.get2DDensity(par_xy[0],par_xy[1],normalized=normalized,**kwargs)\n",
    "            interpolator = RectBivariateSpline(density2D.x, density2D.y, density2D.P,**kwargs)\n",
    "            point_pdf_2D.append(interpolator.ev(point_xy[0], point_xy[1]))\n",
    "        return point_pdf_2D\n",
    "    \n",
    "    def get_density_contours_2D(self,par_xy,contour_levels,normalized=False,**kwargs):\n",
    "        r\"\"\"\n",
    "        Helper function.\n",
    "        Return the posterior densities corresponding to input `contour_levels`.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        par_xy: list[str]\n",
    "                The indexes or names of the two parameters, [par_x,par_y].\n",
    "        contour_levels: list[float]\n",
    "                The contour levels, i.e. confidence limits per each sample.\n",
    "        normalized: bool, optional\n",
    "                Whether to normalize the ``getdist.densities.Density2D`` estimate.\n",
    "                Default to `False`.\n",
    "        **kwargs:\n",
    "                Keyword arguments for ``getdist.mcsamples.get2DDensity()``.\n",
    "        \"\"\"\n",
    "        density_contours_2D=[]\n",
    "        for sample in self.samples:\n",
    "            density2D = sample.get2DDensity(par_xy[0],par_xy[1],normalized=normalized,**kwargs)\n",
    "            density_contours_2D.append(density2D.getContourLevels(contours=contour_levels))\n",
    "        return np.asarray(density_contours_2D).reshape(len(self.samples),len(contour_levels))\n",
    "    \n",
    "    def compute_posterior_density_ratio_2D(self,par_xy,point_xy,normalized=False,**kwargs):\n",
    "        r\"\"\"\n",
    "        Main function.\n",
    "        Compute the ratio of the posterior density at `point_xy` over that at the MAP point.\n",
    "        Require a `BestFit` object loaded from a `.minimum` or `.bestfit` file.\n",
    "        Those are outputs from a posterior/likelihood minimization run on top of the MCMC chain.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        par_xy: list[str]\n",
    "                The indexes or names of the two parameters, [par_x,par_y].\n",
    "        point_xy: [float, float]\n",
    "                The position of the prediction/observation in [par_x, par_y] coordinates.\n",
    "        normalized: bool, optional\n",
    "                Whether to normalize the ``getdist.densities.Density2D`` estimate.\n",
    "                Default to `False`.\n",
    "        **kwargs:\n",
    "                Keyword arguments for ``self.compute_point_pdf_2D()`` and ``getdist.mcsamples.get2DDensity()``\n",
    "        \"\"\"\n",
    "        point_pdf_2Ds = self.compute_point_pdf_2D(par_xy,point_xy,normalized=normalized,**kwargs)\n",
    "        MAP_pdf_2Ds = []\n",
    "        for sample in self.samples:\n",
    "            try:\n",
    "                MAP_pdf_2D = self.compute_point_pdf_2D(par_xy,\\\n",
    "                    [sample.getBestFit().getParamDict()[par_xy[0]],sample.getBestFit().getParamDict()[par_xy[1]]],\\\n",
    "                    normalized=normalized,**kwargs)\n",
    "            except FileNotFoundError as err:\n",
    "                warnings.warn(\"Cannot load `BestFit` from file. No `.minimum` or `.bestfit` file found. Use a *noisy* estimate of MAP from chain.\", UserWarning)\n",
    "                density2D = sample.get2DDensity(par_xy[0],par_xy[1],normalized=normalized,**kwargs)\n",
    "                MAP_pdf_2D = density2D.P.max()\n",
    "            MAP_pdf_2Ds.append(MAP_pdf_2D)\n",
    "        return [(point_pdf_2D/MAP_pdf_2D)\\\n",
    "                for point_pdf_2D,MAP_pdf_2D in zip(point_pdf_2Ds,MAP_pdf_2Ds)]\n",
    "    \n",
    "     def compute_Bayes_factor_SD_ratio_2D(self,par_xy,point_xy,prior_loc_xy,prior_scale_xy,prior_dist_xy='uniform',normalized=False,**kwargs):\n",
    "        r\"\"\"\n",
    "        Main function.\n",
    "        Compute the Bayes factor from MCMC chains through the Savage-Dickey density ratio.\n",
    "        Note that S-D estimator only works for nested models.\n",
    "        See, e.g. [here](https://statproofbook.github.io/P/bf-sddr.html)\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        par_xy: list[str]\n",
    "                The indexes or names of the two parameters, [par_x,par_y].\n",
    "        point_xy: [float, float]\n",
    "                The position of the prediction/observation in [par_x, par_y] coordinates.\n",
    "        prior_loc_xy,prior_scale_xy: array_like\n",
    "                The location and scale parameters of the prior distribution(s).\n",
    "        prior_dist_xy: str, optional\n",
    "                Prior distribution of [par_x,par_y].\n",
    "                Currently support either `uniform` or `normal`.\n",
    "                Default to `uniform`.\n",
    "        normalized: bool, optional\n",
    "                Whether to normalize the ``getdist.densities.Density2D`` estimate.\n",
    "                Default to `False`.\n",
    "        **kwargs:\n",
    "                Keyword arguments for ``self.compute_point_pdf_2D()``.\n",
    "        \"\"\"\n",
    "        if prior_dist_xy == 'uniform':\n",
    "            prior_pdf = np.prod(uniform.pdf(point_xy,loc=prior_loc_xy,scale=prior_scale_xy))\n",
    "        elif prior_dist_xy == 'normal':\n",
    "            prior_pdf = np.prod(norm.pdf(point_xy,loc=prior_loc_xy,scale=prior_scale_xy))\n",
    "        else:\n",
    "            prior_pdf = 1.0\n",
    "            warnings.warn(\"Invalid choice of prior distribution. ``prior_dist_xy`` should be either `uniform` or `normal`. Default to 1.0.\",category=Warning)\n",
    "        return np.log10(self.compute_point_pdf_2D(par_xy,point_xy,normalized=normalized,**kwargs)/prior_pdf)\n",
    "    \n",
    "    @staticmethod\n",
    "    def _bisect_search(arr,point):\n",
    "        r\"\"\"\n",
    "        Helper function.\n",
    "        Search the array for the closest *higher* element, by bisection.\n",
    "        Scale as O(log n), more efficient for large array.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        arr: array_like\n",
    "            The input array. Assumed to be sorted in ascending order.\n",
    "        point: float\n",
    "            The input point value.\n",
    "        \"\"\"\n",
    "        return len(arr) - bisect.bisect_left(arr, point) - 1\n",
    "\n",
    "    def compute_posterior_above_point_2D(self,par_xy,point_xy,normalized=False,inner_CL=1e-6,outter_CL=1.0,n_contours=100,convergence_threshold=1e-4,**kwargs):\n",
    "        r\"\"\"\n",
    "        Main function.\n",
    "        Compute the significance of the prediction or observation given the 2D posterior density.\n",
    "        Return the integral of the posterior density over the area with P(`par_xy`|data)>=P(`point_xy`|data).\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        par_xy: list[str]\n",
    "                The indexes or names of the two parameters, [par_x,par_y].\n",
    "        point_xy: [float, float]\n",
    "                The position of the prediction/observation in [par_x, par_y] coordinates.\n",
    "        contour_levels: list[float]\n",
    "                The contour levels, i.e. confidence limits per each sample.\n",
    "        normalized: bool, optional\n",
    "                Whether to normalize the ``getdist.densities.Density2D`` estimate.\n",
    "                Default to `False`.\n",
    "        inner_CL, outter_CL: float, float, optional.\n",
    "                Initial inner and outter confidence levels to begin searching.\n",
    "                Default to `1e-6` and `1.0` of posterior mass, respectively.\n",
    "                If you have a good idea of P([point_x,point_y]), adjust these two accordingly to improve efficiency.\n",
    "        n_contours: int, optional\n",
    "                Number of contour levels to define.\n",
    "                Default to `100`.\n",
    "        convergence_threshold: float, optional.\n",
    "                Threshold for convergence of P search\n",
    "        **kwargs:\n",
    "                Keyword arguments for ``self.compute_point_pdf_2D()`` and ``self.get_density_contours_2D``\n",
    "        \"\"\" \n",
    "        point_pdf_2Ds = self.compute_point_pdf_2D(par_xy,point_xy,normalized=normalized,**kwargs)\n",
    "        contour_levels = np.linspace(inner_CL,outter_CL,n_contours)\n",
    "        density_contours_2Ds = self.get_density_contours_2D(par_xy,contour_levels=contour_levels)\n",
    "        sig2Ds = []\n",
    "        for p,pdf2D_point in enumerate(point_pdf_2Ds):\n",
    "            # Initialize distance from CL to the point\n",
    "            distance = density_contours_2Ds[p][0] - pdf2D_point\n",
    "            if distance < 0:\n",
    "                raise ValueError(f\"Input point is within the innermost contour. Try define initial contours starting closer from the peak. Current distance P={distance}.\")\n",
    "            else: \n",
    "                try:\n",
    "                    while distance > convergence_threshold:\n",
    "                        # Find closest CL with P([par_x,par_y])>=P([point_x,point_y])\n",
    "                        CL_index = self._bisect_search(np.flip(density_contours_2Ds[p, :]), pdf2D_point)\n",
    "                        # Check whether CL_index corresponds to the first or last element of contour_levels\n",
    "                        if CL_index == 0:\n",
    "                            raise IndexError(f\"Input point is closest to the innermost contour. Try define initial contours starting closer from the peak and/or finer contours. Current distance P={distance}.\")\n",
    "                        elif CL_index == n_contours-1:\n",
    "                            raise IndexError(f\"Input point is closest to the outtermost contour. Try define intial contours reaching further out to the tail. Current distance P={distance}.\")\n",
    "                        else:\n",
    "                            # Update inner_CL and outter_CL\n",
    "                            inner_CL = contour_levels[CL_index]\n",
    "                            outter_CL = contour_levels[CL_index+1]\n",
    "                            # Update CLs - Zoom in the vicinity of point_xy\n",
    "                            contour_levels = np.linspace(inner_CL,outter_CL,n_contours)\n",
    "                            # Compute new densities at updated CLs\n",
    "                            density_contours_2Ds = self.get_density_contours_2D(par_xy, contour_levels=contour_levels,**kwargs)\n",
    "                            # Update distance\n",
    "                            distance = density_contours_2Ds[p,0] - pdf2D_point\n",
    "                    print(\"Convergence condition reached.\")\n",
    "                    sig2Ds.append(contour_levels[CL_index])\n",
    "                except ValueError as e:\n",
    "                    print(f\"Convergence condition never met.\")\n",
    "        return sig2Ds\n",
    "    \n",
    "    def print_latex_table(self, sample_names=None,sample_significances=None):\n",
    "        \"\"\"\n",
    "        Return a LaTeX table of sample names and their corresponding significance values.\n",
    "        Compute and fill significances before calling this function.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        \n",
    "        sample_names:\n",
    "            Names of samples/data.\n",
    "            Either pass here as input or grab from ``getdist.mcsamples``.\n",
    "        \n",
    "        sample_significances: float, optional.\n",
    "            Significances of null hypothesis rejections per each sample/data.\n",
    "            Either pass here as input or pre-compute and store in ``self.significances``.\n",
    "        \"\"\"\n",
    "        if len(self.samples) != len(self.significances):\n",
    "            raise ValueError(\"Number of samples and significances must be the same.\")\n",
    "        if sample_names is None:\n",
    "            warnings.warn(\"No input sample names. Try to grab names from ``getdist.mcsamples``.\",category=Warning)\n",
    "            sample_names = []\n",
    "            for sample in self.samples:\n",
    "                name=sample.getName().replace(\"_\", r\"\\textunderscore \")\n",
    "                sample_names.append(name)\n",
    "        if sample_significances is None:\n",
    "            warnings.warn(\"No input sample significances. Try to grab names from ``self.significances``.\",category=Warning)\n",
    "            sample_significances = self.significances\n",
    "        # Table header - 2 columns [sample name | significance]\n",
    "        print(r\"\\begin{table}\")\n",
    "        print(r\"\\begin{center}\")\n",
    "        print(r\"\\begin{tabular}{|l|c|}\")\n",
    "        print(r\"\\hline\")\n",
    "        print(r\"Data & Significance \\\\\")\n",
    "        print(r\"\\hline\")\n",
    "\n",
    "        # Table values - individual rows correspond to individual samples\n",
    "        for sample_name, sample_significance in zip(sample_names, sample_significances):\n",
    "            print(f\"{sample_name} & {sample_significance * 100:.1f}% \\\\\")\n",
    "\n",
    "        # Table footer\n",
    "        print(r\"\\hline\")\n",
    "        print(r\"\\end{tabular}\")\n",
    "        print(r\"\\label{tab:data_significance}\")\n",
    "        print(r\"\\end{center}\")\n",
    "        print(r\"\\end{table}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff27b87c-6ded-41c0-912a-31f049aba4aa",
   "metadata": {},
   "source": [
    "## Usage"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60a7f255-2670-4b00-a05d-c9485830caa6",
   "metadata": {},
   "source": [
    "### Data path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b5cd56c5-ddab-40c9-9935-5e78982dd601",
   "metadata": {},
   "outputs": [],
   "source": [
    "chain_path='./data/GammaPrimefree_Omegakfixed_planck2018_highl_TTTEEE_lowl_TTEE_lensing_BAO_des_fsigma8'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f00feaf-6dc6-4f11-b2a1-0858a89cca49",
   "metadata": {},
   "source": [
    "### Computation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afb513ea-9e91-48ca-bef8-547586c76c24",
   "metadata": {},
   "source": [
    "Load samples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bda60671-3c67-4173-885d-50cea3dd9e20",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Receive 1 instances of ``getdist.MCSamples`` as input.\n"
     ]
    }
   ],
   "source": [
    "settings={'ignore_rows': '0.3'}\n",
    "getdist_samples = getdist.mcsamples.loadMCSamples(file_root=chain_path,ini=None,settings=settings)\n",
    "tension = TensionBarometer(getdist_samples)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9eb1744f-cdc2-4dcf-a4da-fdca03709399",
   "metadata": {},
   "source": [
    "Compute significance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "4dececb7-23f0-46e9-b38d-7cdf4a8c5f34",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Convergence condition reached.\n"
     ]
    }
   ],
   "source": [
    "fid_point=[0.55,0.0]\n",
    "tension.significances = tension.compute_posterior_above_point_2D(['gamma0','gamma1'],fid_point,\\\n",
    "                                normalized=False,\\\n",
    "                                inner_CL=0.99,n_contours=100,convergence_threshold=1e-6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "5a1b871a-c161-42a8-a52b-df3ec922a033",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Convergence condition reached.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.9975005127285507]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tension.compute_posterior_above_point_2D(['gamma0','gamma1'],fid_point,\\\n",
    "                                normalized=False,\\\n",
    "                                inner_CL=0.99,n_contours=100,convergence_threshold=1e-6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2507e1a6-4658-44a5-9814-6dbe1d09fc3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.9975005127285507]\n",
      "\\begin{table}\n",
      "\\begin{center}\n",
      "\\begin{tabular}{|l|c|}\n",
      "\\hline\n",
      "Data & Significance \\\\\n",
      "\\hline\n",
      "GammaPrimefree\\textunderscore Omegakfixed\\textunderscore planck2018\\textunderscore highl\\textunderscore TTTEEE\\textunderscore lowl\\textunderscore TTEE\\textunderscore lensing\\textunderscore BAO\\textunderscore des\\textunderscore fsigma8 & 99.8% \\\n",
      "\\hline\n",
      "\\end{tabular}\n",
      "\\label{tab:data_significance}\n",
      "\\end{center}\n",
      "\\end{table}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_2221903/1161401248.py:228: Warning: No input sample names. Try to grab names from ``getdist.mcsamples``.\n",
      "  warnings.warn(\"No input sample names. Try to grab names from ``getdist.mcsamples``.\",category=Warning)\n",
      "/tmp/ipykernel_2221903/1161401248.py:234: Warning: No input sample significances. Try to grab names from ``self.significances``.\n",
      "  warnings.warn(\"No input sample significances. Try to grab names from ``self.significances``.\",category=Warning)\n"
     ]
    }
   ],
   "source": [
    "print(tension.significances)\n",
    "tension.print_latex_table()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de6f891b-cb67-4425-907c-58bd25830601",
   "metadata": {},
   "source": [
    "### Visual inspection"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e799a4d7-de25-4f65-b169-3906fb82e8c8",
   "metadata": {},
   "source": [
    "Check whether the identified CL intersects the input point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1b2bbda8-2681-4574-b76e-1aa492256084",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "from matplotlib import pyplot as plt\n",
    "from getdist import plots\n",
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "matplotlib.rcParams['legend.framealpha']=0.\n",
    "matplotlib.style.use('Minh_paper_style')\n",
    "cmap=matplotlib.colormaps['viridis']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "686f78fb-41fc-4fbf-9b5e-af6b5a323fb7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.lines.Line2D at 0x151c1ac9cf40>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x450 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 416,
       "width": 566
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "g = plots.get_single_plotter()\n",
    "samples=getdist.mcsamples.loadMCSamples(file_root=chain_path,ini=None,settings=settings)\n",
    "samples.updateSettings({'contours': [0.68, 0.95, tension.significances[0]]})\n",
    "g.settings.num_plot_contours = 3\n",
    "g.plot_2d(samples, 'gamma0', 'gamma1');\n",
    "ax=g.subplots[0,0]\n",
    "ax.axhline(y=0.)\n",
    "ax.axvline(x=0.55)"
   ]
  }
 ],
 "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}