sims.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0dd6974a-79aa-402f-b474-1c8faa46fe44",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import json\n",
    "import math\n",
    "import networkx as nx\n",
    "import pandas as pd\n",
    "import altair as alt\n",
    "import numpy as np\n",
    "from scipy import stats\n",
    "from scipy.optimize import curve_fit\n",
    "import distfit\n",
    "import os\n",
    "\n",
    "from generator_v2 import Generator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04976e2d-bf37-4bfa-8087-6316bbb4cf43",
   "metadata": {},
   "source": [
    "# Vis Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24e2f49c-26d3-492e-b1d9-6594e8c2d340",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "alt.data_transformers.enable(\"vegafusion\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2bb64ce8-04a7-4fde-8248-5939dbdeb088",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "COLOR = \"#99d8c9\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a227afe-303a-43da-8583-e377e99a6efe",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "alt.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32fc2e17-c502-408d-af71-a9a850e9cfca",
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the theme by returning the dictionary of configurations\n",
    "\n",
    "font = \"monospace\"\n",
    "# Axes\n",
    "axisColor = \"#000000\"\n",
    "gridColor = \"#DEDDDD\"\n",
    "# Colors\n",
    "main_palette = [\"#1696d2\", \n",
    "                \"#d2d2d2\",\n",
    "                \"#000000\", \n",
    "                \"#fdbf11\", \n",
    "                \"#ec008b\", \n",
    "                \"#55b748\", \n",
    "                \"#5c5859\", \n",
    "                \"#db2b27\", \n",
    "               ]\n",
    "sequential_palette = [\"black\", \n",
    "                      \"#a2d4ec\", \n",
    "                      \"#73bfe2\", \n",
    "                      \"#46abdb\", \n",
    "                      \"#1696d2\", \n",
    "                      \"#12719e\", \n",
    "                     ]\n",
    "\n",
    "\n",
    "# markColor = \"#8856a7\"\n",
    "# markColor = \"#6a51a3\"\n",
    "markColor = \"#9ebcda\"\n",
    "\n",
    "# Define custom color schemes for ordinal and categorical data\n",
    "categorical_color_scheme = ['red', 'green', 'blue', 'purple', 'orange']\n",
    "ordinal_color_scheme = [\"#fcfbfd\",\n",
    "\"#efedf5\",\n",
    "\"#dadaeb\",\n",
    "\"#bcbddc\",\n",
    "\"#9e9ac8\",\n",
    "\"#807dba\",\n",
    "\"#6a51a3\",\n",
    "\"#4a1486\"]\n",
    "\n",
    "\n",
    "def simple_theme():\n",
    "    return {\n",
    "        'config': {\n",
    "            'view': {\n",
    "                'height': 300,\n",
    "                'width': 300,\n",
    "            },\n",
    "            \"title\": {\n",
    "                    \"fontSize\": 18,\n",
    "                    \"font\": font,\n",
    "                    \"anchor\":\"start\", # equivalent of left-aligned.\n",
    "                    \"fontColor\": \"#000000\"\n",
    "                },\n",
    "            \"facet\": {\n",
    "                \"labelFontSize\": 16,\n",
    "                \"titleFontSize\": 20  # Adjust the fontsize as needed\n",
    "            },\n",
    "            \"axisX\": {\n",
    "                    \"labelFont\": font,\n",
    "                    \"labelFontSize\": 16,\n",
    "                    \"titleFontSize\": 20,\n",
    "                    \"grid\": False,\n",
    "                },\n",
    "                \"axisY\": {\n",
    "                    \"domain\": False,\n",
    "                    \"grid\": False,\n",
    "                    \"labelFont\": font,\n",
    "                    \"labelFontSize\": 16,\n",
    "                    \"titleFontSize\": 20,\n",
    "                },\n",
    "            'mark': {\n",
    "                'color': markColor,\n",
    "                'fill': markColor\n",
    "            },\n",
    "            \"line\": {\n",
    "                \"fill\": None,\n",
    "               \"stroke\": \"black\",\n",
    "           },\n",
    "            # \"range\": {\n",
    "            #         \"category\": categorical_color_scheme,\n",
    "            #         \"ordinal\": ordinal_color_scheme,\n",
    "            #         \"diverging\": sequential_palette,\n",
    "            #     },\n",
    "            \"scale\": {\"color\": {\"scheme\": \"blue\"}},\n",
    "            \"legend\": {\n",
    "\n",
    "                \"titleFontSize\": 20,\n",
    "                \"labelFontSize\": 16\n",
    "            }            \n",
    "        }\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3c371ce-4db1-4277-8cc3-b7b8fcaab7c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# alt.themes.register(\"theme\", theme)\n",
    "alt.themes.register(\"theme\", simple_theme)\n",
    "alt.themes.enable(\"theme\")\n",
    "#alt.themes.enable(\"ggplot2\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ac232a0-e9f1-410d-b4ab-f74096d28a37",
   "metadata": {},
   "source": [
    "# Model Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "600173db-fff0-4485-8e98-d81cf3eb39c3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "N = 1000\n",
    "N_edges = 200\n",
    "\n",
    "# Last value is the one used for most simulations\n",
    "# Ns = [200, 300, 500, 700, 1000, 2000]\n",
    "Ns = [1000]\n",
    "\n",
    "N_coms = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "837e2f3f-71b2-4a26-923a-b67b091b6afc",
   "metadata": {},
   "source": [
    "# Simulations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a618dba0-c59f-4193-ad68-7ab13a538a60",
   "metadata": {},
   "outputs": [],
   "source": [
    "p_init = 30 / N\n",
    "q_init = 30 / N\n",
    "# p_init = 0.1\n",
    "# q_init = 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "afe99831-cabe-49e1-820e-64e6915df881",
   "metadata": {},
   "outputs": [],
   "source": [
    "p_init"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3806ea8d-1473-4a54-8776-bb137dc97956",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fit_function(x, n, p):\n",
    "    return stats.binom.pmf(x, n, p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab3d6ebc-e965-45a1-82cd-ea3d786816e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "qs = np.arange(0, 1.01, 0.10)\n",
    "# qs = np.append(qs, [0.95, 0.99])\n",
    "qs = np.append(qs, [0.01, 0.05])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb257ffb-ebf2-446d-8dbb-4144395ca3a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Min test \n",
    "qs = [0.01, 0.05, 0.1, 0.5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "887edae0-c72e-4b60-a959-e67f89839af8",
   "metadata": {},
   "outputs": [],
   "source": [
    "fits_N = 1000\n",
    "# fits_strat = \"max\"\n",
    "fits_strat = \"weighted\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ca22866-ddb9-4e1c-8a61-1eb93b802515",
   "metadata": {},
   "source": [
    "## Run simulations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfb6896c-a3e1-41d1-aed5-998f5b5dc869",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "p = p_init\n",
    "q = q_init\n",
    "\n",
    "df_degrees = pd.DataFrame(columns=[\"degree\"], dtype=int)\n",
    "df_hsizes = pd.DataFrame(columns=[\"hsize\"], dtype=int)\n",
    "\n",
    "df_sim = pd.DataFrame(columns=[\"sim\", \"type\", \"count\"], dtype=int)\n",
    "df_fraction = pd.DataFrame(columns=[\"sim\", \"count\", \"fraction0\"], dtype=int)\n",
    "df_fraction2 = pd.DataFrame(columns=[\"sim\", \"value\"])\n",
    "\n",
    "df_fits = pd.DataFrame(columns=[\"peff\", \"Neff\", \"p_hsize_eff\", \"n_eff_hsize\", \"p\", \"q\", \"q_frac\"], dtype=int)\n",
    "\n",
    "# Same as df_fits but other format so easier altair plots \n",
    "df_fits2 = pd.DataFrame()\n",
    "\n",
    "increment = 0.05\n",
    "N_sim = int(1 / increment) + 1\n",
    "q_frac_order = []\n",
    "\n",
    "\n",
    "# N_graphs = 5\n",
    "N_graphs = 20\n",
    "# N_graphs = 100\n",
    "\n",
    "q_to_degreefit = {}\n",
    "q_to_hsizefit = {}\n",
    "\n",
    "for q_frac in qs:\n",
    "    q = round(p * q_frac,  4)\n",
    "    print(p, q)\n",
    "    \n",
    "    q_frac_order.append(q_frac) \n",
    "\n",
    "    # for strat in [\"weighted\", \"max\", \"min\", \"frequent\"]:\n",
    "    for strat in [\"max\"]:\n",
    "        for n in Ns:\n",
    "            all_degrees = []\n",
    "            all_hsizes = []  \n",
    "    \n",
    "            community_array = []\n",
    "            for i in range(N_coms):\n",
    "                community_array += [i for x in range(n // N_coms)]\n",
    "            \n",
    "            for n_graph in range(N_graphs):\n",
    "                # gen = Generator(N, N_edges, N_coms, p, q, community_array, sampling_strat)\n",
    "                gen = Generator(n, N_edges, N_coms, p, q, community_array, strat)\n",
    "                gen.run()\n",
    "                    \n",
    "                #     For com distrib of hyperedges\n",
    "                comp = gen.hyperedges_nmax()\n",
    "                ginis = gen.ginis()\n",
    "                \n",
    "                # for fraction in comp:\n",
    "                df = pd.DataFrame({\"q\": [q] * len(comp), \"value\": comp, \"gini\": ginis, \"N_nodes\": [n] * len(comp), \"strat\": [strat] * len(comp)})\n",
    "                df_fraction2 = pd.concat([df_fraction2, df])\n",
    "                \n",
    "                # for peffectif computation\n",
    "                if n == fits_N and strat == fits_strat:\n",
    "                    degrees = dict(gen.degrees()).values()\n",
    "                    hsizes = dict(gen.hyperedge_sizes()).values()\n",
    "                    \n",
    "                    all_degrees = all_degrees + list(degrees)\n",
    "                    all_hsizes = all_hsizes + list(hsizes)\n",
    "        \n",
    "\n",
    "            # DO THE DISTRIBUTIONS AND FIT ONLY FOR THOSE VALUES\n",
    "            if n == fits_N and strat == fits_strat:\n",
    "                df = pd.DataFrame({\"degree\": all_degrees, \"q\": q_frac, \"q / p\": q / p, \"N_nodes\": n})\n",
    "                df_degrees = pd.concat([df_degrees, df])\n",
    "                                      \n",
    "                df = pd.DataFrame({\"hsize\": all_hsizes, \"q\": q_frac, \"q / p\": q / p, \"N_nodes\": n})\n",
    "                df_hsizes = pd.concat([df_hsizes, df])\n",
    "    \n",
    "                # Distrib of degree\n",
    "                # Bounds of n and p effectif\n",
    "                bounds = [(0, N_edges), (0, p)]\n",
    "                \n",
    "                dist = stats.binom\n",
    "                res = stats.fit(dist, all_degrees, bounds)\n",
    "                \n",
    "                peff = res.params[1]\n",
    "                neff = res.params[0]\n",
    "                \n",
    "                bounds2 = [(N_edges, N_edges), (0, p)]\n",
    "                res = stats.fit(dist, all_degrees, bounds2)\n",
    "                peffNfixed = res.params[1]\n",
    "                neffNfixed = res.params[0]\n",
    "                \n",
    "                bounds3 = [(0, N_edges), (p, p)]\n",
    "                res = stats.fit(dist, all_degrees, bounds3)\n",
    "                peffpfixed = res.params[1]\n",
    "                neffpfixed = res.params[0]\n",
    "                \n",
    "                df_notfixed = pd.DataFrame({\"p\": [p], \"q\": [q], \"q_frac\": [q_frac], \"peff\": [peff], \"Neff\": [neff], \"bounds\": [\"not fixed\"], \"measure\": [\"degree\"]})\n",
    "                df_pfixed = pd.DataFrame({\"p\": [p], \"q\": [q], \"q_frac\": [q_frac], \"peff\": [peffNfixed], \"Neff\": [neffNfixed], \"bounds\": [\"n Fixed\"], \"measure\": [\"degree\"]})\n",
    "                df_nfixed = pd.DataFrame({\"p\": [p], \"q\": [q], \"q_frac\": [q_frac], \"peff\": [peffpfixed], \"Neff\": [neffpfixed], \"bounds\": [\"p Fixed\"], \"measure\": [\"degree\"]})\n",
    "                df_fits2 = pd.concat([df_fits2, df_notfixed, df_pfixed, df_nfixed])\n",
    "                \n",
    "                q_to_degreefit[q] = res\n",
    "                \n",
    "                # Distrib of hsizes\n",
    "                dist = stats.binom\n",
    "                \n",
    "                # bounds = [(N / N_coms, N), (q, p)]\n",
    "                bounds = [(N / N_coms, N), (0, p)]\n",
    "                res = stats.fit(dist, all_hsizes, bounds)\n",
    "                peffhsize = res.params[1]\n",
    "                neff_hsize = res.params[0]\n",
    "                q_to_hsizefit[q] = res\n",
    "                \n",
    "                # bounds = [(N / N_coms, N), (p, p)]\n",
    "                bounds = [(0, N), (p, p)]\n",
    "                res = stats.fit(dist, all_hsizes, bounds)\n",
    "                peff_hsize_pfixed = res.params[1]\n",
    "                neff_hsize_pfixed = res.params[0]\n",
    "                \n",
    "                bounds = [(N, N), (0, p)]\n",
    "                res = stats.fit(dist, all_hsizes, bounds)\n",
    "                peff_hsize_nfixed = res.params[1]\n",
    "                neff_hsize_nfixed = res.params[0]\n",
    "                \n",
    "                df = pd.DataFrame({\"p\": [p], \"q\": [q], \"q_frac\": [q_frac], \"peff\": [peff], \"Neff\": [neff], \"peffpfixed\": [peffpfixed], \"Neffpfixed\": [neffpfixed], \"peffnfixed\": [peffNfixed], \"Neffnfixed\": [neffNfixed], \"p_hsize_eff\": [peffhsize], \"n_eff_hsize\": [neff_hsize]})\n",
    "                df_fits = pd.concat([df_fits, df])\n",
    "                # df_peff = pd.concat([df_peff, df])\n",
    "                \n",
    "                df_notfixed = pd.DataFrame({\"p\": [p], \"q\": [q], \"q_frac\": [q_frac], \"peff\": [peffhsize], \"Neff\": [neff_hsize], \"bounds\": [\"not fixed\"], \"measure\": [\"hsize\"]})\n",
    "                df_pfixed = pd.DataFrame({\"p\": [p], \"q\": [q], \"q_frac\": [q_frac], \"peff\": [peff_hsize_nfixed], \"Neff\": [neff_hsize_nfixed], \"bounds\": [\"n Fixed\"], \"measure\": [\"hsize\"]})\n",
    "                df_nfixed = pd.DataFrame({\"p\": [p], \"q\": [q], \"q_frac\": [q_frac], \"peff\": [peff_hsize_pfixed], \"Neff\": [neff_hsize_pfixed], \"bounds\": [\"p Fixed\"], \"measure\": [\"hsize\"]})\n",
    "                df_fits2 = pd.concat([df_fits2, df_notfixed, df_pfixed, df_nfixed])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1847639a-cb95-4e90-a987-4ec2282c52a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "simulation_folder = \"./simulations/\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8370c2f-794a-4b84-8db3-e915867de0e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "fn = f\"{simulation_folder}he_distrib_{p_init}p.csv\"\n",
    "if not os.path.exists(fn):\n",
    "    df_fraction2.to_csv(fn, sep=',', index=False, encoding='utf-8')\n",
    "else:\n",
    "    print(\"load\")\n",
    "    df_fraction2 = pd.read_csv(fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6d14bc0-3f10-4e92-90d0-6aead3389f45",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fraction2[\"q / p\"] = df_fraction2[\"q\"] / p_init\n",
    "df_fraction2[\"N / E\"] = df_fraction2[\"N_nodes\"] / N_edges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b5d5850-a95f-488f-ae36-5f5b1814b6c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fraction2 = df_fraction2.drop([\"sim\"], axis=1)\n",
    "df_fraction2 = df_fraction2.drop(\"value\", axis=1)\n",
    "df_fraction2 = df_fraction2.drop(\"N_nodes\", axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54d461e2-4791-47d2-903d-fb8b63d01122",
   "metadata": {},
   "outputs": [],
   "source": [
    "fn = f\"{simulation_folder}hsize_distrib_{fits_N}_{fits_strat}_{p_init}p.csv\"\n",
    "if not os.path.exists(fn):\n",
    "    df_hsizes.to_csv(fn, sep=',', index=False, encoding='utf-8')\n",
    "else:\n",
    "    print(\"load\")\n",
    "    df_hsizes = pd.read_csv(fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4f3a3dc-03f8-4859-b10f-5087ad8b5704",
   "metadata": {},
   "outputs": [],
   "source": [
    "fn = f\"{simulation_folder}degree_distrib_{fits_N}_{fits_strat}_{p_init}p.csv\"\n",
    "if not os.path.exists(fn):\n",
    "    df_degrees.to_csv(fn, sep=',', index=False, encoding='utf-8')\n",
    "else:\n",
    "    print(\"load\")\n",
    "    df_degrees = pd.read_csv(fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff2818c5-30e4-4f74-b6f5-fab133fcf716",
   "metadata": {},
   "outputs": [],
   "source": [
    "fn = f\"{simulation_folder}fits1_{fits_N}_{fits_strat}_{p_init}p.csv\"\n",
    "if not os.path.exists(fn):\n",
    "    df_fits.to_csv(fn, sep=',', index=False, encoding='utf-8')\n",
    "else:\n",
    "    print(\"load\")\n",
    "    df_fits = pd.read_csv(fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12722b2b-e25b-4fda-952a-7e42dea25ae4",
   "metadata": {},
   "outputs": [],
   "source": [
    "fn = f\"{simulation_folder}fits2_{fits_N}_{fits_strat}{p_init}p.csv\"\n",
    "if not os.path.exists(fn):\n",
    "    df_fits2.to_csv(fn, sep=',', index=False, encoding='utf-8')\n",
    "else:\n",
    "    print(\"load\")\n",
    "    df_fits2 = pd.read_csv(fn)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc469584-67d1-4275-9b50-145881b4dc99",
   "metadata": {},
   "source": [
    "## Values Computation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b77481e-386f-4f66-a87c-0a346df2ad72",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.mean(df_hsizes[df_hsizes.q == 0.3].hsize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "859ce7ca-7355-463d-a986-13c31915c456",
   "metadata": {},
   "outputs": [],
   "source": [
    "set(df_hsizes.N_nodes)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cb8a4fe-e2e9-40bb-99db-d82619e277d8",
   "metadata": {},
   "source": [
    "## Group by"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "696565d4-bd18-4362-9c00-fd4d4c7a8d50",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_degrees = df_degrees[df_degrees[\"N_nodes\"] == 1000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c306f22a-b38e-4402-8012-30ebf0acfbb1",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_degrees.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a61d2eb-f462-4f4d-b227-b77862f2d334",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a12296a-e375-44f8-aa77-2b6a88a644c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fits = df_fits.round({'q_frac': 3})\n",
    "df_fits.q_frac"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44b2dab8-db42-4ea7-b0bc-71d87bd91def",
   "metadata": {},
   "outputs": [],
   "source": [
    "grouped = df_degrees.groupby('q / p')['degree'].value_counts(normalize=True).reset_index(name='Percentage')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f559a06-4d5b-4951-88ac-cd486f60103b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "grouped = grouped.round({'q / p': 2})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9400966d-2cfc-49a0-822e-1d4ffa7988bb",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "grouped['binomial'] = 0  # Initialize the column\n",
    "\n",
    "for q in qs:\n",
    "    q = round(q, 3)\n",
    "    df = df_degrees[df_degrees[\"q\"] == f\"{q}p\"]\n",
    "    # fit = q_to_degreefit[round(q * p, 3)]\n",
    "    \n",
    "    # Calculate the binomial PDF values for a range of x values\n",
    "    x_values = range(19)  # Assuming a range from 0 to 10\n",
    "\n",
    "    fit_values = df_fits[df_fits[\"q_frac\"] == q]\n",
    "\n",
    "    if len(fit_values) > 0:\n",
    "        for x in x_values:\n",
    "            binom_pdf = stats.binom.pmf(x, fit_values.Neffpfixed.iloc[0], fit_values.peffpfixed.iloc[0])\n",
    "            print(binom_pdf, q)\n",
    "            # grouped.loc[(grouped['degree'] == x) & (grouped['q'] == f\"{q}p\"), 'binomial'] = binom_pdf\n",
    "            grouped.loc[(grouped['degree'] == x) & (grouped['q / p'] == q), 'binomial'] = binom_pdf \n",
    "    else:\n",
    "        print(\"WARNING\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2d797ad-ae27-45b2-afdb-846e02d878a7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "grouped_selp_deg = grouped[grouped[\"q / p\"].isin([0, 0.3, 0.7, 1])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0d3a3e9-3ba9-4dd3-93c3-628652669088",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "grouped_selp_deg.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a06e1f5-95ba-4441-b47e-eeacdc48f295",
   "metadata": {},
   "outputs": [],
   "source": [
    "pdf = alt.Chart(grouped_selp_deg).mark_line(width=1, opacity=0.7, fill=None, color=\"black\").encode(\n",
    "# pdf = alt.Chart(grouped_selp_deg).mark_line(width=1, opacity=0.7, color=\"darkgrey\", fill=None).encode(\n",
    "        x=alt.X('degree:Q', title=\"k\", axis=alt.Axis(labelExpr=\"datum.value % 4 ? null : datum.label\"), scale=alt.Scale(domainMin=0)),\n",
    "        y=alt.Y('binomial:Q', title=\"P(k)\"),\n",
    "        # color=\"q\"\n",
    "        # facet=alt.Facet(\"q:O\")    \n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9aa3b46b-a166-4749-b453-304ba68fd593",
   "metadata": {},
   "outputs": [],
   "source": [
    "# distrib = alt.Chart(grouped_selp_deg).mark_bar(width=5,  opacity=0.7, color=\"black\").encode(\n",
    "distrib = alt.Chart(grouped_selp_deg).mark_bar(width=5,  opacity=0.7).encode(\n",
    "        x=alt.X('degree:Q', title=\"k\", axis=alt.Axis(tickMinStep=1), scale=alt.Scale(domainMin=0)),\n",
    "        y=alt.Y('Percentage:Q'),\n",
    "        # facet=alt.Facet(\"q:O\")\n",
    "        # color=\"q\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d75d6bf-d363-4ee5-90b0-e32fe1932ff7",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# alt.layer(pdf, distrib, data=grouped_selp_deg).facet(column='q')\n",
    "alt.layer(pdf, distrib, data=grouped_selp_deg).facet(\n",
    "    facet=alt.Facet(\n",
    "        'q / p',\n",
    "        header=alt.Header(labelFontSize=18, titleFontSize=20)\n",
    "    ),\n",
    "    columns=2\n",
    ").configure_axisY(\n",
    "    titleAngle=0,\n",
    "    titleX=-80,\n",
    ")\n",
    "\n",
    "# alt.hconcat(freq_table, background + data_plot, spacing=100).properties(padding=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f56dc04d-140d-4c11-bcbe-3b02175f2df9",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Hsize"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11cd6d09-098c-4d93-b231-9dc047935f10",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Group by"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef81a5c3-397c-45ef-a8d2-605dc677f705",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_hsizes = df_hsizes[df_hsizes[\"N_nodes\"] == 1000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19bd18c3-3b90-4ff3-a1bd-78970876ac32",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fits2 = df_fits2.round({'q_frac': 3})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f258c57-17ee-46ec-9ab2-b6e410fe4d69",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "grouped = df_hsizes.groupby('q / p')['hsize'].value_counts(normalize=True).reset_index(name='Percentage')\n",
    "grouped"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66b2b63b-50c0-471b-899d-1e7c199094e5",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "grouped = grouped.round({'q / p': 2})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c16c0b2d-ff4b-45bc-91e7-defd95d1ba48",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "grouped['binomial'] = 0  # Initialize the column\n",
    "\n",
    "for q in qs:\n",
    "    q = round(q, 2)\n",
    "    # df = df_hsizes[df_hsizes[\"q\"] == f\"{q}p\"]\n",
    "    df = df_hsizes[df_hsizes[\"q\"] == q]\n",
    "    \n",
    "    # fit_values = df_fits2[(df_fits2[\"q_frac\"] == f\"{q}p\") & (df_fits2[\"measure\"] == \"hsize\") & (df_fits2[\"bounds\"] == \"p Fixed\")]\n",
    "    fit_values = df_fits2[(df_fits2[\"q_frac\"] == q) & (df_fits2[\"measure\"] == \"hsize\") & (df_fits2[\"bounds\"] == \"p Fixed\")]\n",
    "\n",
    "    # p = 0.03\n",
    "    # x_values = range(60)\n",
    "\n",
    "    # p = 0.1\n",
    "    x_values = range(200)\n",
    "    \n",
    "    for x in x_values:\n",
    "        binom_pdf = stats.binom.pmf(x, fit_values.Neff, fit_values.peff)\n",
    "        grouped.loc[(grouped['hsize'] == x) & (grouped['q / p'] == q), 'binomial'] = binom_pdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "022cfedf-6338-4795-b2d3-f8891b27c9ae",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "grouped_selp = grouped[grouped[\"q / p\"].isin([0, 0.3, 0.7, 1])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "310ecfe6-38ed-4afd-8382-fd5cef9d016f",
   "metadata": {},
   "outputs": [],
   "source": [
    "grouped_selp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed6325e4-d289-46bc-9459-a497e21d1cdc",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "pdf = alt.Chart(grouped_selp).mark_line(width=1, opacity=0.7, color=\"black\", fill=None).encode(\n",
    "        # x=alt.X('hsize:O', title=\"Hyperedge Size\", axis=alt.Axis(tickMinStep=10), scale=alt.Scale(domain=list(range(3, 51)), padding=0.1, paddingInner=0.1)),\n",
    "        x=alt.X('hsize:Q', title=\"m\", axis=alt.Axis(tickMinStep=5)),\n",
    "        y=alt.Y('binomial:Q', title=\"P(m)\"),\n",
    "        # color=\"q\"\n",
    "        # facet=alt.Facet(\"q:O\")    \n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ed6085b-0b78-4d87-bd5c-c688b9491bd3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "distrib = alt.Chart(grouped_selp).mark_bar(width=5,  opacity=0.7).encode(\n",
    "        # x=alt.X('hsize:O', title=\"Hyperedge Size\", axis=alt.Axis(tickMinStep=10), scale=alt.Scale(domain=list(range(3, 51)), padding=0.1, paddingInner=0.1)),\n",
    "        x=alt.X('hsize:Q', title=\"m\", axis=alt.Axis(tickMinStep=5)),\n",
    "        y=alt.Y('Percentage:Q'),\n",
    "        # facet=alt.Facet(\"q:O\")\n",
    "        # color=\"q\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97af04aa-8c09-4da5-ad14-892cefd876ed",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "alt.layer(distrib, pdf, data=grouped_selp).facet(\n",
    "    facet=alt.Facet('q / p', header=alt.Header(labelFontSize=18, titleFontSize=20)),  columns=2\n",
    ").configure_axisY(\n",
    "    titleAngle=0,\n",
    "    titleX=-80,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5110b2c6-19c1-4347-99f3-dc20ee9374db",
   "metadata": {},
   "source": [
    "## Hyperedge composition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0975639a-2686-42e9-8f87-3977c21f6e3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fraction2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "937a3773-73f3-4cb0-9bc9-32a7ed7605f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fraction2['strat'] = df_fraction2['strat'].replace(['frequent'], ['majority'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec0c8793-96c8-4dd3-9199-68f991118ff9",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fraction2 = df_fraction2.round({\"q / p\": 3})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bdc6da00-69e1-4246-a620-97e380c3c7af",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1000 nodes\n",
    "df_fraction_1000 = df_fraction2[df_fraction2[\"N / E\"] == 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba10a78f-f535-4ee3-a0b1-7233f8b3bafc",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test = df_fraction2[(df_fraction2[\"N / E\"].isin([10])) & (df_fraction2[\"strat\"] == \"max\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "265fad11-0f69-4d00-b720-1b480489887e",
   "metadata": {},
   "outputs": [],
   "source": [
    "error = alt.Chart(df_fraction_1000).mark_errorband(extent=\"stdev\").encode(\n",
    "    x=\"q / p\",\n",
    "    y=alt.Y(\n",
    "        \"gini:Q\",\n",
    "        title=\"gini\"\n",
    "    ),\n",
    ")\n",
    "\n",
    "mean_line = alt.Chart(df_fraction_1000).mark_line().encode(\n",
    "    x=\"q / p\",\n",
    "    y=alt.Y(\n",
    "        \"mean(gini)\",\n",
    "        title=\"gini\"\n",
    "    ),\n",
    ")\n",
    "\n",
    "error + mean_line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4508fdb2-8612-4a38-b865-ef0fe880cb73",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate mean and standard deviation for each category\n",
    "summary_data = df_test.groupby('q / p').agg({'gini': ['mean', 'std']}).reset_index()\n",
    "summary_data.columns = ['q / p', 'Mean', 'Std']# Calculate mean and standard deviation for each category"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad089f5f-5dc9-4ad8-9cbf-8b667c9e59a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_split = pd.DataFrame(columns=[\"q / p\", \"value\", \"type\"])\n",
    "\n",
    "for i, row in summary_data.iterrows():\n",
    "\n",
    "    df_split = pd.concat([df_split, pd.DataFrame({'q / p': [row[\"q / p\"]], 'value': [row.Mean], 'type': [\"Ḡ\"]})], ignore_index=True)\n",
    "    df_split = pd.concat([df_split, pd.DataFrame({'q / p': [row[\"q / p\"]], 'value': [row.Std], 'type': [\"σ\"]})], ignore_index=True)\n",
    "    \n",
    "    # df_split = df_split.append({'q / p': row[\"q / p\"], 'value': row.Mean, 'type': \"Mean\"}, ignore_index=True)\n",
    "    # df_split = df_split.append({'q / p': row[\"q / p\"], 'value': row.Std, 'type': \"Std\"}, ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4a55836-b762-4b9e-8eee-16b01430fe73",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_split.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81422f08-2634-466b-aa8c-33f99275caf3",
   "metadata": {},
   "outputs": [],
   "source": [
    "alt.Chart(df_split).mark_line().encode(\n",
    "    x=\"q / p\",\n",
    "    y=alt.Y(\n",
    "        \"value\",\n",
    "        title=\"G\",\n",
    "    ),\n",
    "        color=alt.Color(\"type\", scale=alt.Scale(range=[\"black\", markColor]),\n",
    "                       legend=alt.Legend(title=\"\", orient=\"top-right\", symbolSize=750, symbolStrokeWidth=3))\n",
    ").configure_legend(\n",
    "titleFontSize=20,\n",
    "labelFontSize=16,\n",
    ").properties(height=330).configure_axisY(\n",
    "    titleAngle=0,\n",
    "    titleX=-60,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4dd7839-f762-48a4-960d-daa78c3600e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# alt.layer(pdf, distrib, data=grouped_selp_deg).facet(column='q')\n",
    "alt.layer(error, mean_line, data=df_fraction_1000).facet(column='strat')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41d8ff32-d31a-4876-a349-b34de4844ba6",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "alt.Chart(df_fraction2).mark_line().encode(\n",
    "    x=\"q / p\",\n",
    "    y=alt.Y(\n",
    "        \"mean(gini)\",\n",
    "        # title=\"Hyperedge Purity\"\n",
    "        # title=\"max(n1, n2) / n1 + n2\"\n",
    "        title=\"mean(Gini*)\"\n",
    "    ),\n",
    "    # color=alt.Color(\"N / E:N\", scale=alt.Scale(scheme=\"category10\"))\n",
    "    # color=alt.Color(\"N / E:N\", scale=alt.Scale()),\n",
    "    strokeDash=\"N / E\"\n",
    ").facet(column='strat')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13e7ea09-47ff-4be3-a15b-d9769a616f1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "gini_strat = alt.Chart(df_fraction_1000).mark_line(color=markColor, opacity=1, size=3).encode(\n",
    "    x=\"q / p\",\n",
    "    y=alt.Y(\n",
    "        \"mean(gini)\",\n",
    "        # title=\"normalized gini\",\n",
    "        title=\"Ḡ\"\n",
    "    ),\n",
    "    # color=alt.Color(\"N / E:N\", scale=alt.Scale()),\n",
    "    strokeDash=alt.StrokeDash(\"strat\", scale=alt.Scale(range=[[1,0], [4, 1], [8, 2], [4, 8]]), legend=alt.Legend(title=\"Strategy\", orient=\"top-right\", symbolSize=750, symbolStrokeWidth=3)),\n",
    ").configure_legend(\n",
    "titleFontSize=20,\n",
    "labelFontSize=16,\n",
    ").properties(height=330).configure_axisY(\n",
    "    titleAngle=0,\n",
    "    titleX=-60,\n",
    ")\n",
    "\n",
    "gini_strat"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97d76d9a-bb53-4598-bc14-b52c7ae75060",
   "metadata": {},
   "source": [
    "Valeur de G pour q / p =1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65cd41d3-69b3-4640-b55e-1ba8a60dde57",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sqrtApply(v):\n",
    "    return 1 / math.sqrt(v)\n",
    "\n",
    "df_fraction2[\"sqrt\"] = df_fraction2[\"N / E\"].apply(sqrtApply)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b11b7489-6760-4661-ad3f-910fff69385f",
   "metadata": {},
   "outputs": [],
   "source": [
    "c1 = alt.Chart(df_fraction2[df_fraction2[\"q / p\"] == 1]).mark_line(color=markColor, opacity=1, size=3).encode(\n",
    "    x=alt.X(\"sqrt\", title=\"1 / sqrt(N / E)\"),\n",
    "    y=alt.Y(\n",
    "        \"mean(gini)\",\n",
    "        # title=\"normalized gini\",\n",
    "        title=\"Ḡ\"\n",
    "    )\n",
    ")\n",
    "\n",
    "c2 = alt.Chart(df_fraction2[df_fraction2[\"q / p\"] == 1]).mark_point(\n",
    "    size=80, opacity=0.8, fill=markColor, stroke=\"black\", shape=\"diamond\").encode(\n",
    "    x=alt.X(\"sqrt\", title=\"1 / sqrt(N / E)\"),\n",
    "    y=alt.Y(\n",
    "        \"mean(gini)\",\n",
    "        # title=\"normalized gini\",\n",
    "        title=\"Ḡ\"\n",
    "    )\n",
    ")\n",
    "\n",
    "\n",
    "alt.layer(c1, c2).configure_legend(\n",
    "titleFontSize=20,\n",
    "labelFontSize=16,\n",
    ").properties(height=330).configure_axisY(\n",
    "    titleAngle=0,\n",
    "    titleX=-60,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a4d6200-e29b-43e7-bd3e-16ba2c4ade7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# mettre la legende à l'interieur\n",
    "# Utiliser couleur et stroke?\n",
    "gini_size = alt.Chart(df_fraction2[df_fraction2.strat == \"weighted\"]).mark_line().encode(\n",
    "    x=\"q / p\",\n",
    "    y=alt.Y(\n",
    "        \"mean(gini)\",\n",
    "        # title=\"Hyperedge Purity\"\n",
    "        # title=\"max(n1, n2) / n1 + n2\"\n",
    "        # title=\"normalized gini\",\n",
    "        title=\"Ḡ\"\n",
    "    ),\n",
    "    # color=alt.Color(\"N / E:N\", scale=alt.Scale(scheme=\"category10\"))\n",
    "    color=alt.Color(\"N / E:O\", scale=alt.Scale(scheme=\"blues\"), legend=alt.Legend(orient=\"top-right\")),\n",
    "    # strokeDash=\"strat\"\n",
    ").configure_legend(\n",
    "titleFontSize=20,\n",
    "labelFontSize=16,\n",
    ").properties(height=330).configure_axisY(\n",
    "    titleAngle=0,\n",
    "    titleX=-60,\n",
    ")\n",
    "\n",
    "\n",
    "gini_size"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5218740-f561-4f78-9935-e15eaebd9fa1",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Normalize "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58f301f5-0c85-4e3e-b109-4c88049fc33f",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fraction2_var = (df_fraction2\n",
    "    # .groupby('q / p')\n",
    "    .groupby(['q / p', \"N / E\", \"strat\"])\n",
    "    # ['value']\n",
    "    ['gini']\n",
    "    .agg(['mean', 'std'])\n",
    "    .assign(stdNorm = lambda df: df['std'] / df['mean'])\n",
    "    .reset_index())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0557bf31-e10a-47e0-a1a4-88df11d0c6fb",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_fraction2_var[(df_fraction2_var.strat == \"max\") & (df_fraction2_var[\"N / E\"] == 10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a4907ad-8bac-46d2-8c62-397f83381317",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Figure 6. Essayer en couleurs. Enlever le strat. Double colones\n",
    "# Pour le max de strat max: metrre plus de point\n",
    "# Tracer en fct de E / N en faisant varier N\n",
    "alt.Chart(df_fraction2_var).mark_line().encode(\n",
    "    x=\"q / p\",\n",
    "    y=alt.Y(\n",
    "        \"stdNorm\",\n",
    "        # \"std\",\n",
    "        title=\"δ\"\n",
    "    ),\n",
    "    color=alt.Color(\"N / E:O\", scale=alt.Scale(scheme=\"blues\")),\n",
    "    # strokeDash=alt.StrokeDash(\"N / E:O\", legend=alt.Legend(symbolSize=750))\n",
    ").facet(\n",
    "    facet=alt.Facet(\"strat\", header=alt.Header(title=\"Strategy\", labelFontSize=18, titleFontSize=20))\n",
    "       ).configure_axisY(\n",
    "    titleAngle=0,\n",
    "    titleX=-60,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "266c3081-ebe3-4b9b-adfa-ec676c9e3aef",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "alt.Chart(df_fraction2_var).mark_line().encode(\n",
    "    x=\"q / p\",\n",
    "    y=alt.Y(\n",
    "        \"std\",\n",
    "        # \"std\",\n",
    "        title=\"σ\"\n",
    "    ),\n",
    "    color=alt.Color(\"N / E:O\", scale=alt.Scale(scheme=\"blues\")),\n",
    "    # strokeDash=alt.StrokeDash(\"N / E:O\", legend=alt.Legend(symbolSize=750))\n",
    ").facet(\n",
    "    facet=alt.Facet(\"strat\", header=alt.Header(title=\"Strategy\", labelFontSize=18, titleFontSize=20))\n",
    "       ).configure_axisY(\n",
    "    titleAngle=0,\n",
    "    titleX=-60,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc44da6c-9e58-44f5-98c5-fd1219884060",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "alt.Chart(df_fraction2_var).mark_line().encode(\n",
    "    x=\"q / p\",\n",
    "    y=alt.Y(\n",
    "        \"mean\",\n",
    "        # \"std\",\n",
    "        title=\"mean\"\n",
    "    ),\n",
    "    color=alt.Color(\"N / E:O\", scale=alt.Scale(scheme=\"blues\")),\n",
    "    # strokeDash=alt.StrokeDash(\"N / E:O\", legend=alt.Legend(symbolSize=750))\n",
    ").facet(\n",
    "    facet=alt.Facet(\"strat\", header=alt.Header(title=\"Strategy\", labelFontSize=18, titleFontSize=20))\n",
    "       ).configure_axisY(\n",
    "    titleAngle=0,\n",
    "    titleX=-60,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a24a4b3f-cf83-45c6-84a3-075945deb20e",
   "metadata": {},
   "source": [
    "# Hyperedge Gini Distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c21f5b6f-6db2-45e0-b1e9-fe6992c7bdff",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fraction2[(df_fraction2[\"q / p\"].isin([0.2])) & (df_fraction2[\"N / E\"].isin([10]))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ad2ff52-e33a-4887-85ed-29d74cee1977",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "alt.Chart(df_fraction2[(df_fraction2[\"q / p\"].isin([0.2])) & (df_fraction2[\"N / E\"].isin([10, 1, 2.5]))]).transform_density(\n",
    "    'gini',\n",
    "    groupby=['N / E', \"strat\"],\n",
    "    as_=['value', 'density'],\n",
    ").mark_line().encode(\n",
    "    x=alt.X(\"value:Q\", title=\"G\"),\n",
    "    y=alt.Y('density:Q', title=\"P(G)\"),\n",
    "    color=alt.Color(\"N / E:O\", scale=alt.Scale(scheme=\"blues\"))\n",
    ").facet(facet=alt.Facet(\"strat\", header=alt.Header(title=\"Strategy\", labelFontSize=18, titleFontSize=20))\n",
    "       ).configure_axisY(\n",
    "    titleAngle=0,\n",
    "    titleX=-60,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82b21d51-9a21-4aef-a6dd-cb96edaf77a2",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "alt.Chart(df_fraction2[(df_fraction2[\"q / p\"].isin([0.05, 0.1, 0.2, 0.3, 0.4])) & (df_fraction2[\"N / E\"].isin([10])) & (df_fraction2[\"strat\"] == \"max\")]).transform_density(\n",
    "    'gini',\n",
    "    groupby=['q / p'],\n",
    "    as_=['value', 'density'],\n",
    ").mark_line().encode(\n",
    "    x=alt.X(\"value:Q\", title=\"G\"),\n",
    "    y=alt.Y('density:Q', title=\"P(G)\"),\n",
    "    color=alt.Color(\"q / p:N\", scale=alt.Scale(scheme=\"purples\",  domainMax=1, domainMin=0.1))\n",
    ").configure_axisY(\n",
    "    titleAngle=0,\n",
    "    titleX=-60,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e18ea678-775f-483f-9aaa-ea9d398e3f52",
   "metadata": {},
   "outputs": [],
   "source": [
    "# gini_plot = alt.Chart(df_fraction2[(df_fraction2.N_nodes == 1000) & (~df_fraction2[\"q / p\"].isin([0, 0.01]))]).transform_density(\n",
    "# gini_plot = alt.Chart(df_fraction2[(df_fraction2[\"N / E\"] == 5) & (~df_fraction2[\"q / p\"].isin([0, 0.01]))]).transform_density(\n",
    "gini_plot = alt.Chart(df_fraction2[(df_fraction2[\"N / E\"] == 10) & (~df_fraction2[\"q / p\"].isin([0]))]).transform_density(\n",
    "    'gini',\n",
    "    groupby=['q / p', \"strat\"],\n",
    "    as_=['gini', 'density'],\n",
    "    # counts=True\n",
    ").mark_line().encode(\n",
    "    x=alt.X(\"gini:Q\", title=\"G\"),\n",
    "    # y=alt.Y('density:Q', title=\"P(G)\", scale=alt.Scale(domainMax=8)),\n",
    "    y=alt.Y('density:Q', title=\"P(G)\", scale=alt.Scale()),\n",
    "    color=alt.Color(\"q / p:N\",  scale=alt.Scale(scheme=\"purples\"))\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86878a9b-bda8-41cb-beae-4a666bb05c86",
   "metadata": {},
   "outputs": [],
   "source": [
    "gini_plot.facet(facet=alt.Facet(\"strat\", header=alt.Header(title=\"Strategy\", labelFontSize=18, titleFontSize=20))).configure_axisY(\n",
    "    titleAngle=0,\n",
    "    titleX=-60,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dff46da2-0f2b-41de-91ab-8d28184664c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# df_hsizes[df_hsizes.N_nodes == 1000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f2ee357-a5f7-4052-b51b-326fa094c614",
   "metadata": {},
   "outputs": [],
   "source": [
    "gini_plot = alt.Chart(df_fraction2[\"q / p\"].isin([0.2])).transform_density(\n",
    "    'gini',\n",
    "    groupby=['q / p', \"strat\"],\n",
    "    as_=['gini', 'density'],\n",
    "    counts=True\n",
    ").mark_line().encode(\n",
    "    x=alt.X(\"gini:Q\", title=\"gini\"),\n",
    "    y='density:Q',\n",
    "    color=alt.Color(\"strat\",  scale=alt.Scale(scheme=\"greys\"))\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b22d82b6-bcf1-4353-b9e6-f45dab3ead67",
   "metadata": {},
   "source": [
    "# Distrib effectives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c600c620-e040-4919-b7f6-5ca4248ddb5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fits"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57817257-8c32-4f33-a0ec-575438f34a49",
   "metadata": {},
   "source": [
    "## Degree distrib fit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f58a39ba-f89c-4906-bf0d-1bd5a99c5f79",
   "metadata": {},
   "outputs": [],
   "source": [
    "points = alt.Chart(df_fits).mark_point().encode(\n",
    "    x=alt.X('q', sort=q_frac_order),\n",
    "    # x=alt.X('q', sort=q_frac_order, axis=alt.Axis(labelExpr=q_frac_order)),\n",
    "    y=alt.Y('peff', title=\"p_eff\"),\n",
    ").properties(\n",
    "    width=800,\n",
    "    height=300\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45b375da-2f25-4294-a2d1-fd1d798ce088",
   "metadata": {},
   "outputs": [],
   "source": [
    "regresssion = points.transform_regression('q', 'peff', method=\"poly\").mark_line(color=\"black\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64c4a344-3d48-4a7a-ba48-d56835f494e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "line = alt.Chart(pd.DataFrame({'y': [p]})).mark_rule().encode(y='y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33eb8ac3-10c4-4301-9c59-fb6fef6d595e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# points + regresssion + line\n",
    "# Pour plusieurs valeur de N\n",
    "points + line"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "440aefaa-a6b8-4a78-858a-43e54dc3a582",
   "metadata": {},
   "source": [
    "### Normalize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9256a438-99ed-494a-9f3d-1afc584650b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fits[\"peff / p\"] = df_fits[\"peff\"] / df_fits[\"p\"] \n",
    "df_fits[\"p_h_eff / p\"] = df_fits[\"p_hsize_eff\"] / df_fits[\"p\"] \n",
    "df_fits[\"q / p\"] = df_fits[\"q\"] / df_fits[\"p\"] \n",
    "\n",
    "df_fits[\"Neff / Nedges\"] = df_fits[\"Neff\"] / N_edges\n",
    "df_fits[\"NeffHsize / N\"] = df_fits[\"n_eff_hsize\"] / N"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3230d458-65bd-4590-a784-1379e5cd0433",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_fits2[\"q / p\"] = df_fits2[\"q\"] / df_fits2[\"p\"] \n",
    "df_fits2[\"peff / p\"] = df_fits2[\"peff\"] / df_fits2[\"p\"] \n",
    "df_fits2[\"neff / Nedges\"] = df_fits2[\"Neff\"] / N_edges\n",
    "df_fits2[\"neff / N\"] = df_fits2[\"Neff\"] / N"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae9604e6-a285-415a-a8bc-0ea8e3d46260",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Old"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7298dd6-7a46-4819-934a-800ed6dcfe1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "points = alt.Chart(df_fits).mark_point().encode(\n",
    "    x=alt.X('q / p', sort=q_frac_order),\n",
    "    # x=alt.X('q', sort=q_frac_order, axis=alt.Axis(labelExpr=q_frac_order)),\n",
    "    y=alt.Y('peff / p'),\n",
    ").properties(\n",
    "    width=800,\n",
    "    height=300\n",
    ")\n",
    "\n",
    "points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3aad3714-8bac-430c-b420-c51d475e21a3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "points_Neff = alt.Chart(df_fits).mark_point().encode(\n",
    "    x=alt.X('q / p', sort=q_frac_order),\n",
    "    # x=alt.X('q', sort=q_frac_order, axis=alt.Axis(labelExpr=q_frac_order)),\n",
    "    y=alt.Y('Neff / Nedges'),\n",
    ").properties(\n",
    "    width=800,\n",
    "    height=300\n",
    ")\n",
    "\n",
    "points_Neff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a1cbece-85de-46da-98fc-8cdaac1a1e9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "alt.Chart(df_fits).mark_line().encode(\n",
    "    x=alt.X('peff / p', sort=q_frac_order),\n",
    "    # x=alt.X('q', sort=q_frac_order, axis=alt.Axis(labelExpr=q_frac_order)),\n",
    "    y=alt.Y('Neff / Nedges'),\n",
    ").properties(\n",
    "    width=800,\n",
    "    height=300\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c5e4ec8-5b85-41be-91d1-acb2648f2655",
   "metadata": {},
   "outputs": [],
   "source": [
    "alt.Chart(df_fits).mark_point().encode(\n",
    "    x=alt.X('q / p', sort=q_frac_order),\n",
    "    # x=alt.X('q', sort=q_frac_order, axis=alt.Axis(labelExpr=q_frac_order)),\n",
    "    y=alt.Y('Neffpfixed'),\n",
    ").properties(\n",
    "    width=800,\n",
    "    height=300\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ade90860-de3f-4747-bf19-ca73e5bb2cf1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fitter par une droite (rouge)\n",
    "# Point plus grand,\n",
    "\n",
    "alt.Chart(df_fits2[df_fits2.measure == \"degree\"]).mark_point().encode(\n",
    "    x=alt.X('q / p', sort=q_frac_order),\n",
    "    # x=alt.X('q', sort=q_frac_order, axis=alt.Axis(labelExpr=q_frac_order)),\n",
    "    y=alt.Y('neff / Nedges'),\n",
    "    color=\"bounds\"\n",
    ").properties(\n",
    "    width=800,\n",
    "    height=300\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c582207-e222-4d77-b412-dc5bb8422c18",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "alt.Chart(df_fits2[df_fits2.measure == \"degree\"]).mark_point().encode(\n",
    "    x=alt.X('q / p', sort=q_frac_order),\n",
    "    # x=alt.X('q', sort=q_frac_order, axis=alt.Axis(labelExpr=q_frac_order)),\n",
    "    y=alt.Y('peff / p'),\n",
    "    color=\"bounds\"\n",
    ").properties(\n",
    "    width=800,\n",
    "    height=300\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9d0ad25-1598-4c29-b5c1-376020fab053",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_fits2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1448e8c1-fb97-4997-8d0e-2374b9d4b90c",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Hsize fits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14e162d3-66e2-469b-9b7a-60652d6d2a35",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "points = alt.Chart(df_fits).mark_point().encode(\n",
    "    x=alt.X('q / p', sort=q_frac_order),\n",
    "    # x=alt.X('q', sort=q_frac_order, axis=alt.Axis(labelExpr=q_frac_order)),\n",
    "    y=alt.Y('p_h_eff / p'),\n",
    ").properties(\n",
    "    width=800,\n",
    "    height=300\n",
    ")\n",
    "\n",
    "points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f8d7ad9-dc53-4166-8145-0ec2ab6e13c2",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "points_Neff = alt.Chart(df_fits).mark_point().encode(\n",
    "    x=alt.X('q / p', sort=q_frac_order),\n",
    "    # x=alt.X('q', sort=q_frac_order, axis=alt.Axis(labelExpr=q_frac_order)),\n",
    "    y=alt.Y(\"NeffHsize / N\"),\n",
    ").properties(\n",
    "    width=800,\n",
    "    height=300\n",
    ")\n",
    "\n",
    "points_Neff"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a53c6e4-d9d5-4a0b-8c68-b88173573eac",
   "metadata": {},
   "source": [
    "## Several bounds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c72fd7cc-0bf4-4258-bb6f-15f7fa4494c0",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "chart = alt.Chart(df_fits2[df_fits2.measure == \"hsize\"]).mark_point().encode(\n",
    "    x=alt.X('q / p'),\n",
    "    # x=alt.X('q / p', sort=q_frac_order),\n",
    "    # x=alt.X('q', sort=q_frac_order, axis=alt.Axis(labelExpr=q_frac_order)),\n",
    "    y=alt.Y('neff / N'),\n",
    "    # color=\"bounds\"\n",
    ").properties(\n",
    "    width=800,\n",
    "    height=300\n",
    ")\n",
    "\n",
    "# chart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f781bd77-b804-47e1-b9d9-c3df2a4137a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "chart + chart.transform_regression('q / p', 'neff / N').mark_line()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "272407a8-c235-4928-93bf-b4ce59e70153",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "alt.Chart(df_fits2[df_fits2.measure == \"hsize\"]).mark_point().encode(\n",
    "    x=alt.X('q / p'),\n",
    "    # x=alt.X('q / p', sort=q_frac_order),\n",
    "    # x=alt.X('q', sort=q_frac_order, axis=alt.Axis(labelExpr=q_frac_order)),\n",
    "    y=alt.Y('peff / p'),\n",
    "    color=\"bounds\"\n",
    ").properties(\n",
    "    width=800,\n",
    "    height=300\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ccfc00b7-c4b5-49c3-b2a2-6d894d8d020d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df_fits2[(df_fits2.measure == \"hsize\") & (df_fits2.bounds == \"p Fixed\") & (~df_fits2[\"q / p\"].isin([0.01, 0.05]))]\n",
    "chart = alt.Chart(df).mark_point(size=80, opacity=0.8, fill=markColor, stroke=\"black\").encode(\n",
    "# chart = alt.Chart(df).mark_point(size=60, opacity=0.7).encode(\n",
    "    x=alt.X('q / p', axis=alt.Axis(format='')),\n",
    "    # x=alt.X('q / p', sort=q_frac_order),\n",
    "    # x=alt.X('q', sort=q_frac_order, axis=alt.Axis(labelExpr=q_frac_order)),\n",
    "    y=alt.Y('neff / N', title=\"N* / N\", scale=alt.Scale(domain=[0, 1.1])),\n",
    ").properties(\n",
    "    width=600,\n",
    "    height=300\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a3392add-d2d6-4e8b-905b-5bfb376656f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "hsize_chart = chart.transform_regression('q / p', 'neff / N').mark_line(color=markColor) + chart\n",
    "hsize_chart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c41feed-e272-4839-a036-e951c3213007",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df_fits2[(df_fits2.measure == \"degree\") & (df_fits2.bounds == \"p Fixed\") & (~df_fits2[\"q / p\"].isin([0.01, 0.05]))]\n",
    "chart2 = alt.Chart(df).mark_point(size=80, opacity=0.8, fill=markColor, stroke=\"black\", shape=\"square\").encode(\n",
    "    # x=alt.X('q / p', sort=q_frac_order, axis=None),\n",
    "    x=alt.X('q / p', axis=alt.Axis(format='')),\n",
    "    # x=alt.X('q', sort=q_frac_order, axis=alt.Axis(labelExpr=q_frac_order)),\n",
    "    y=alt.Y('neff / Nedges', title=\"E* / E\", scale=alt.Scale(domain=[0, 1.1])),\n",
    ").properties(\n",
    "    width=600,\n",
    "    height=300\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3ef9a8f-c735-4818-8b90-4924f73a4566",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "reg_degree = chart2.transform_regression('q / p', 'neff / Nedges', params=False).mark_line(color=markColor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7fd72ec-4ced-4158-bb8e-7a9fc4203e3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "degree_chart = reg_degree + chart2 \n",
    "degree_chart"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58c56bf6-a472-4a8d-8f1b-ac6658d3600c",
   "metadata": {},
   "source": [
    "### Regression coeffs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6e509b8-7b0b-4c4d-8d89-298d75fc3eca",
   "metadata": {},
   "outputs": [],
   "source": [
    "import altair_transform"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6fe201af-7fb7-46da-9bd0-98da2cc65f58",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "reg = chart2.transform_regression('q / p', 'neff / Nedges', params=True)\n",
    "# print(altair_transform.extract_data(reg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f91dcb3-c08a-4317-83a5-be5f8d8330b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "chart2.transform_regression(\n",
    "    'q / p', 'neff / Nedges', params=True\n",
    ").transform_calculate(\n",
    "    intercept='datum.coef[0]',\n",
    "    slope='datum.coef[1]',\n",
    ").mark_text(align='left').encode(\n",
    "    x=alt.value(20),  # pixels from left\n",
    "    y=alt.value(20),  # pixels from top\n",
    "    text='slope:N'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5fc2a0a-d20a-45cf-b2c0-d8df3e076a68",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "reg2 = chart.transform_regression('q / p', 'neff / N', params=True)\n",
    "# print(altair_transform.extract_data(reg2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "575e4c21-6a60-4f8c-bdab-d898d4e23ae6",
   "metadata": {},
   "outputs": [],
   "source": [
    "chart.transform_regression(\n",
    "    'q / p', 'neff / N', params=True\n",
    ").transform_calculate(\n",
    "    intercept='datum.coef[0]',\n",
    "    slope='datum.coef[1]',\n",
    ").mark_text(align='left').encode(\n",
    "    x=alt.value(20),  # pixels from left\n",
    "    y=alt.value(20),  # pixels from top\n",
    "    text='intercept:N'\n",
    ")"
   ]
  }
 ],
 "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}