diff --git a/03-analyse_outputs/03-06-coacquisitions_by_branch_length_bin.ipynb b/03-analyse_outputs/03-06-coacquisitions_by_branch_length_bin.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..8c0b1cdc2bcbe114901abf9b5dded09db19ea4fe
--- /dev/null
+++ b/03-analyse_outputs/03-06-coacquisitions_by_branch_length_bin.ipynb
@@ -0,0 +1,1146 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "cdfd0f39",
+   "metadata": {},
+   "source": [
+    "# Coaquisitions analyses binned by length of recipient-branch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "6d4ccde0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_dir = '../data/'\n",
+    "taxonomic_id = '1236'\n",
+    "compiled_res_dir = '../data/compiled_results/'\n",
+    "plots_dir = '../plots/'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "9c844271",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# to suppress warning from ete3 because it's not up to date with py3.12\n",
+    "import warnings\n",
+    "\n",
+    "# ignore SyntaxWarning\n",
+    "warnings.filterwarnings(\"ignore\", category=SyntaxWarning)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "61fe8701",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import scipy.stats as stats\n",
+    "import seaborn as sns\n",
+    "import numpy as np\n",
+    "import matplotlib as mpl\n",
+    "import ete3\n",
+    "\n",
+    "# use plotly for interactive plots\n",
+    "from plotly.offline import plot\n",
+    "import plotly.io as pio\n",
+    "import plotly.graph_objs as go\n",
+    "from plotly.subplots import make_subplots\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib.ticker import FixedLocator\n",
+    "import math\n",
+    "\n",
+    "import json\n",
+    "# read in the marker styles\n",
+    "with open('lib/plot_marker_styles.json', 'r') as f:\n",
+    "    marker_styles_dict = json.load(f)['marker_styles_dict']\n",
+    "    # this is a dictionary such that for each method it contains\n",
+    "    # a dict of marker styles for 'pyplot', 'plotly', 'marker_color', 'face_color'\n",
+    "\n",
+    "# set global pyplot font to be serif\n",
+    "plt.rcParams[\"font.family\"] = \"serif\"\n",
+    "\n",
+    "neighbor_genes_between_cutoffs = [1]\n",
+    "minimum_genome_size = 1000  # minimum genome size to consider a genome (i.e. contig or chromosome) for analysis\n",
+    "min_coacquisitions = 20  # minimum number of coacquisitions to consider a threshold of a method for analysis\n",
+    "# minimum number of coacquisitions with known positions, as a certain numerator, for considering it for percentage calculation\n",
+    "# e.g. for the percentage of coacquisitions that are neighbors,\n",
+    "# we need at least this meany neighbors that are coacquired for a given transfer threshold of a method to be considered\n",
+    "min_numerator = 0  # if 0, then in paper we add notes about the fact that there may be small number effects"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "b63a57d5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import importlib\n",
+    "\n",
+    "\n",
+    "# reload the library in case it has been updated\n",
+    "if \"clsl\" in globals():\n",
+    "    importlib.reload(clsl)\n",
+    "from lib import coacq_logscale_summary_lib as clsl"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "95ddbab7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Scale the relevant rcParams by 1.5x, but use font_scale_factor for font sizes\n",
+    "scale_factor = 1.5\n",
+    "font_scale_factor = 2.5\n",
+    "for key in mpl.rcParams:\n",
+    "    try:\n",
+    "        if not \"size\" in key:\n",
+    "            continue\n",
+    "        # Use font_scale_factor if the key is related to font size\n",
+    "        if \"font\" in key:\n",
+    "            factor = font_scale_factor\n",
+    "        else:\n",
+    "            factor = scale_factor\n",
+    "        if isinstance(mpl.rcParams[key], (int, float)) and not isinstance(\n",
+    "            mpl.rcParams[key], bool\n",
+    "        ):\n",
+    "            mpl.rcParams[key] *= factor\n",
+    "        elif isinstance(mpl.rcParams[key], (list, tuple)):\n",
+    "            mpl.rcParams[key] = [\n",
+    "                (\n",
+    "                    v * factor\n",
+    "                    if isinstance(v, (int, float)) and not isinstance(v, bool)\n",
+    "                    else v\n",
+    "                )\n",
+    "                for v in mpl.rcParams[key]\n",
+    "            ]\n",
+    "    except Exception as e:\n",
+    "        print(f\"Error scaling {key} from {mpl.rcParams[key]}: {e}\")\n",
+    "        raise e"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "e665548a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>recipient_branch</th>\n",
+       "      <th>branch_length</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1896966</td>\n",
+       "      <td>0.707034</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>381306</td>\n",
+       "      <td>0.298287</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>1810504</td>\n",
+       "      <td>0.263150</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>246195</td>\n",
+       "      <td>0.206865</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>797473</td>\n",
+       "      <td>0.179588</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "  recipient_branch  branch_length\n",
+       "0          1896966       0.707034\n",
+       "1           381306       0.298287\n",
+       "2          1810504       0.263150\n",
+       "3           246195       0.206865\n",
+       "4           797473       0.179588"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Short bin: 0.07552, Long bin: 0.707034\n",
+      "Number of short branches: 180\n",
+      " Number of long branches: 180\n",
+      " Total number of branches: 359\n"
+     ]
+    }
+   ],
+   "source": [
+    "# read in the genome tree\n",
+    "# to prepare a map of recipient branch id to branch length\n",
+    "genome_tree_filepath = f\"{\n",
+    "    data_dir}/{taxonomic_id}_wol_tree_pruned_with_internal_labels.nwk\"\n",
+    "# read in with ete3\n",
+    "genome_tree = ete3.Tree(genome_tree_filepath, format=1)\n",
+    "# prepare a map of recipient branch id to branch length\n",
+    "rec_branch_length_dict = {\n",
+    "    node.name: node.dist for node in genome_tree.traverse() if node.is_leaf()\n",
+    "}\n",
+    "rec_branch_length_df = pd.DataFrame.from_dict(\n",
+    "    rec_branch_length_dict, orient=\"index\", columns=[\"branch_length\"]\n",
+    ").reset_index(names=\"recipient_branch\")\n",
+    "display(rec_branch_length_df.head())\n",
+    "# plot the distribution of branch lengths\n",
+    "branch_lengths = [node.dist for node in genome_tree.traverse() if node.is_leaf()]\n",
+    "fig, ax = plt.subplots(figsize=(8, 8))\n",
+    "sns.histplot(\n",
+    "    branch_lengths,\n",
+    "    bins=50,\n",
+    "    log_scale=True,\n",
+    "    ax=ax,\n",
+    ")\n",
+    "plt.xlabel(\"Branch length\")\n",
+    "plt.ylabel(\"Frequency\")\n",
+    "plt.show()\n",
+    "\n",
+    "# bin the branches by terciles of branch lengths\n",
+    "# the bins are equally spaced (similar number of NOGs in each bin, not in logspace)\n",
+    "total_num_branches = len(branch_lengths)\n",
+    "short_bin = float(np.percentile(branch_lengths, 50))\n",
+    "# medium_bin = float(np.percentile(branch_lengths, 66))\n",
+    "long_bin = float(np.percentile(branch_lengths, 100))\n",
+    "print(f\"Short bin: {short_bin}, Long bin: {long_bin}\")\n",
+    "short_branches = rec_branch_length_df[\n",
+    "    rec_branch_length_df[\"branch_length\"].between(0, short_bin)\n",
+    "]\n",
+    "# medium_branches = rec_branch_length_df[\n",
+    "#     rec_branch_length_df[\"branch_length\"].between(short_bin, medium_bin)\n",
+    "# ]\n",
+    "long_branches = rec_branch_length_df[\n",
+    "    rec_branch_length_df[\"branch_length\"].between(short_bin, long_bin)\n",
+    "]\n",
+    "# add a column to the dataframe with the bin\n",
+    "def get_bin(row):\n",
+    "    if row[\"branch_length\"] <= short_bin:\n",
+    "        return \"short\"\n",
+    "    # elif row[\"branch_length\"] <= medium_bin:\n",
+    "    #     return \"medium\"\n",
+    "    else:\n",
+    "        return \"long\"\n",
+    "rec_branch_length_df[\"bin\"] = rec_branch_length_df.apply(get_bin, axis=1)\n",
+    "# print the number of branches in each bin\n",
+    "print(\n",
+    "    f\"Number of short branches: {len(short_branches)}\\n\",\n",
+    "    # f\"Number of medium branches: {len(medium_branches)}\\n\",\n",
+    "    f\"Number of long branches: {len(long_branches)}\\n\",\n",
+    "    f\"Total number of branches: {total_num_branches}\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "68fb43a3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The following methods are included in the coacquisitions data:\n",
+      "['gloome.ml', 'gloome.ml.without_tree', 'angst', 'ale', 'ranger-fast', 'ranger', 'count.ml', 'wn']\n",
+      "The following methods are included in the coacquisitions data:\n",
+      "['count.mp.0.33', 'count.mp.0.5', 'count.mp.1', 'count.mp.2', 'count.mp.3', 'count.mp.4', 'count.mp.5', 'count.mp.6', 'count.mp.7', 'count.mp.8']\n",
+      "The following methods are included in the coacquisitions data:\n",
+      "['gloome.mp.0.33', 'gloome.mp.0.5', 'gloome.mp.1', 'gloome.mp.2', 'gloome.mp.3', 'gloome.mp.4', 'gloome.mp.5', 'gloome.mp.6', 'gloome.mp.7', 'gloome.mp.8', 'gloome.mp.without_tree.0.33', 'gloome.mp.without_tree.0.5', 'gloome.mp.without_tree.1', 'gloome.mp.without_tree.2', 'gloome.mp.without_tree.3', 'gloome.mp.without_tree.4', 'gloome.mp.without_tree.5', 'gloome.mp.without_tree.6', 'gloome.mp.without_tree.7', 'gloome.mp.without_tree.8']\n",
+      "The following methods are included in the coacquisitions data:\n",
+      "['gloome.mp.0.33', 'gloome.mp.0.5', 'gloome.mp.1', 'gloome.mp.2', 'gloome.mp.3', 'gloome.mp.4', 'gloome.mp.5', 'gloome.mp.6', 'gloome.mp.7', 'gloome.mp.8', 'gloome.mp.without_tree.0.33', 'gloome.mp.without_tree.0.5', 'gloome.mp.without_tree.1', 'gloome.mp.without_tree.2', 'gloome.mp.without_tree.3', 'gloome.mp.without_tree.4', 'gloome.mp.without_tree.5', 'gloome.mp.without_tree.6', 'gloome.mp.without_tree.7', 'gloome.mp.without_tree.8']\n",
+      "The following methods are included in the coacquisitions data:\n",
+      "['wn', 'wn.4.0', 'wn.5.0', 'wn.7.0', 'wn.6.0', 'wn.13.0', 'wn.10.0', 'wn.8.0', 'wn.12.0', 'wn.11.0', 'wn.9.0']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# now we perform the neighboring co-acquisitions analysis but for the binned branch lengths\n",
+    "# read in the data: chromosome locations, and coacquisitions for each method\n",
+    "coacquisitions_dfs = clsl.load_data(compiled_res_dir)\n",
+    "# for each method, find the minimum number of transfers under different transfer thresholds\n",
+    "coacquisitions_dfs = clsl.calculate_min_transfers(coacquisitions_dfs)\n",
+    "\n",
+    "# the following methods have manually set thresholds (gain-loss penalty ratios or MAD values)\n",
+    "methods_for_manual_thresholds = [\n",
+    "    \"count_mp\",\n",
+    "    \"gloome_mp\",\n",
+    "    \"gloome_mp.without_tree\",\n",
+    "    \"wn\",\n",
+    "]\n",
+    "manual_threshold_coacquisitions_dfs_dict = {}\n",
+    "for meth in methods_for_manual_thresholds:\n",
+    "    # read in the data\n",
+    "    manual_threshold_coacquisitions_dfs_dict[meth] = clsl.load_data(\n",
+    "        os.path.join(compiled_res_dir, meth.split(\".\")[0]),\n",
+    "        include_manual_thresholds=True\n",
+    "    )\n",
+    "    # calculate the minimum number of transfers\n",
+    "    manual_threshold_coacquisitions_dfs_dict[meth] = clsl.calculate_min_transfers(\n",
+    "        manual_threshold_coacquisitions_dfs_dict[meth]\n",
+    "    )\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "f0e95166",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# summarize the coacquisitions for each method across transfer thresholds\n",
+    "def summarize_coacquisitions_for_bins(\n",
+    "    coacquisitions_dfs,\n",
+    "    neighbor_genes_between_cutoffs,\n",
+    "    minimum_genome_size,\n",
+    "    bins: list,\n",
+    "    bin_names: list,\n",
+    "    min_coacquisitions: int,\n",
+    "):\n",
+    "    binned_coacq_summary_dfs = {}\n",
+    "    for bin_name, bin_df in zip(bin_names, bins):\n",
+    "        print(f\"Processing {bin_name} bin\")\n",
+    "        # keep only the bin recipient_branch values in the coacquisitions_dfs\n",
+    "        this_bin_coacquisitions_dfs = {\n",
+    "            method: coacquisitions_dfs[method][\n",
+    "                coacquisitions_dfs[method][\"recipient_branch\"].isin(bin_df[\"recipient_branch\"])\n",
+    "            ]\n",
+    "            for method in coacquisitions_dfs.keys()\n",
+    "        }\n",
+    "        # summarize the coacquisitions for each method across transfer thresholds\n",
+    "        this_bin_coacq_summary_df = clsl.summarize_coacquisitions_parallel(\n",
+    "            this_bin_coacquisitions_dfs,\n",
+    "            neighbor_genes_between_cutoffs,\n",
+    "            minimum_genome_size,\n",
+    "            min_coacquisitions=min_coacquisitions,\n",
+    "        )\n",
+    "        # replace zeros with NaNs in certain columns\n",
+    "        this_bin_coacq_summary_df = clsl.replace_zeros_with_nan(this_bin_coacq_summary_df)\n",
+    "\n",
+    "        for manual_meth in methods_for_manual_thresholds:\n",
+    "            manual_meth_bin_coacquisitions_dfs = manual_threshold_coacquisitions_dfs_dict[manual_meth]\n",
+    "            # keep only the bin recipient_branch values in the coacquisitions_dfs\n",
+    "            manual_meth_bin_coacquisitions_dfs = {\n",
+    "                method: manual_meth_bin_coacquisitions_dfs[method][\n",
+    "                    manual_meth_bin_coacquisitions_dfs[method][\"recipient_branch\"].isin(\n",
+    "                        bin_df[\"recipient_branch\"]\n",
+    "                    )\n",
+    "                ]\n",
+    "                for method in manual_meth_bin_coacquisitions_dfs.keys()\n",
+    "            }\n",
+    "            manual_meth_bin_coacquisitions_df = clsl.summarize_coacquisitions_manual_thresholds(\n",
+    "                    manual_meth_bin_coacquisitions_dfs,\n",
+    "                    neighbor_genes_between_cutoffs,\n",
+    "                    minimum_genome_size,\n",
+    "                    method=manual_meth.replace(\"_\", \".\", 1),\n",
+    "                    min_coacquisitions=min_coacquisitions,\n",
+    "                )\n",
+    "            # replace zeros with NaNs in certain columns\n",
+    "            manual_meth_bin_coacquisitions_df = clsl.replace_zeros_with_nan(\n",
+    "                manual_meth_bin_coacquisitions_df\n",
+    "            )\n",
+    "            this_bin_coacq_summary_df = pd.concat(\n",
+    "                [this_bin_coacq_summary_df, manual_meth_bin_coacquisitions_df],\n",
+    "                ignore_index=True,\n",
+    "            )\n",
+    "        \n",
+    "        binned_coacq_summary_dfs[bin_name] = this_bin_coacq_summary_df\n",
+    "    return binned_coacq_summary_dfs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "3a9adde8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Processing short branches bin\n",
+      "Methods in the dataframe: ['gloome.ml' 'gloome.ml.without_tree' 'angst' 'ale' 'ranger-fast' 'ranger'\n",
+      " 'count.ml' 'wn']\n",
+      "Methods in the dataframe: ['count.mp']\n",
+      "Skipping non-numeric threshold value: without_tree.8\n",
+      "Skipping non-numeric threshold value: without_tree.7\n",
+      "Skipping non-numeric threshold value: without_tree.6\n",
+      "Skipping non-numeric threshold value: without_tree.5\n",
+      "Skipping non-numeric threshold value: without_tree.4\n",
+      "Skipping non-numeric threshold value: without_tree.3\n",
+      "Skipping non-numeric threshold value: without_tree.2\n",
+      "Skipping non-numeric threshold value: without_tree.1\n",
+      "Skipping non-numeric threshold value: without_tree.0.5\n",
+      "Skipping non-numeric threshold value: without_tree.0.33\n",
+      "Methods in the dataframe: ['gloome.mp']\n",
+      "Skipping non-numeric threshold value: gloome.mp.8\n",
+      "Skipping non-numeric threshold value: gloome.mp.7\n",
+      "Skipping non-numeric threshold value: gloome.mp.6\n",
+      "Skipping non-numeric threshold value: gloome.mp.5\n",
+      "Skipping non-numeric threshold value: gloome.mp.4\n",
+      "Skipping non-numeric threshold value: gloome.mp.3\n",
+      "Skipping non-numeric threshold value: gloome.mp.2\n",
+      "Skipping non-numeric threshold value: gloome.mp.1\n",
+      "Skipping non-numeric threshold value: gloome.mp.0.5\n",
+      "Skipping non-numeric threshold value: gloome.mp.0.33\n",
+      "Methods in the dataframe: ['gloome.mp.without_tree']\n",
+      "Method wn has less than 20 coacquisitions with known gene positions. Skipping.\n",
+      "Skipping non-numeric threshold value: wn\n",
+      "Methods in the dataframe: ['wn']\n",
+      "Processing long branches bin\n",
+      "Methods in the dataframe: ['gloome.ml' 'gloome.ml.without_tree' 'angst' 'ale' 'ranger-fast' 'ranger'\n",
+      " 'count.ml' 'wn']\n",
+      "Method count.mp has less than 20 coacquisitions with known gene positions. Skipping.\n",
+      "Methods in the dataframe: ['count.mp']\n",
+      "Method gloome.mp has less than 20 coacquisitions with known gene positions. Skipping.\n",
+      "Skipping non-numeric threshold value: without_tree.8\n",
+      "Skipping non-numeric threshold value: without_tree.7\n",
+      "Skipping non-numeric threshold value: without_tree.6\n",
+      "Skipping non-numeric threshold value: without_tree.5\n",
+      "Skipping non-numeric threshold value: without_tree.4\n",
+      "Skipping non-numeric threshold value: without_tree.3\n",
+      "Skipping non-numeric threshold value: without_tree.2\n",
+      "Skipping non-numeric threshold value: without_tree.1\n",
+      "Skipping non-numeric threshold value: without_tree.0.5\n",
+      "Skipping non-numeric threshold value: without_tree.0.33\n",
+      "Methods in the dataframe: ['gloome.mp']\n",
+      "Skipping non-numeric threshold value: gloome.mp.8\n",
+      "Skipping non-numeric threshold value: gloome.mp.7\n",
+      "Skipping non-numeric threshold value: gloome.mp.6\n",
+      "Skipping non-numeric threshold value: gloome.mp.5\n",
+      "Skipping non-numeric threshold value: gloome.mp.4\n",
+      "Skipping non-numeric threshold value: gloome.mp.3\n",
+      "Skipping non-numeric threshold value: gloome.mp.2\n",
+      "Skipping non-numeric threshold value: gloome.mp.1\n",
+      "Skipping non-numeric threshold value: gloome.mp.0.5\n",
+      "Skipping non-numeric threshold value: gloome.mp.0.33\n",
+      "Methods in the dataframe: ['gloome.mp.without_tree']\n",
+      "Method wn has less than 20 coacquisitions with known gene positions. Skipping.\n",
+      "Skipping non-numeric threshold value: wn\n",
+      "Methods in the dataframe: ['wn']\n"
+     ]
+    }
+   ],
+   "source": [
+    "binned_coacq_by_branch_length_dfs = summarize_coacquisitions_for_bins(\n",
+    "    coacquisitions_dfs,\n",
+    "    neighbor_genes_between_cutoffs,\n",
+    "    minimum_genome_size,\n",
+    "    bins=[short_branches, \n",
+    "        #   medium_branches, \n",
+    "          long_branches],\n",
+    "    bin_names=[\"short branches\", \n",
+    "            #    \"medium branches\", \n",
+    "               \"long branches\"],\n",
+    "    min_coacquisitions=min_coacquisitions,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "af6cfbf0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 100x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot just the legend without any plot\n",
+    "fig, ax = plt.subplots(figsize=(1, 5))\n",
+    "for sm_key in marker_styles_dict.keys():\n",
+    "    if type(marker_styles_dict[sm_key]) is dict:\n",
+    "        method = sm_key\n",
+    "        ax.plot(\n",
+    "            [],\n",
+    "            [],\n",
+    "            marker=marker_styles_dict[method][\"marker_pyplot\"],\n",
+    "            color=marker_styles_dict[method][\"marker_color\"],\n",
+    "            markerfacecolor=marker_styles_dict[method][\"face_color\"],\n",
+    "            label=marker_styles_dict[method][\"label\"],\n",
+    "        )\n",
+    "ax.legend()\n",
+    "ax.axis(\"off\")\n",
+    "plt.savefig(f\"{plots_dir}/legend_tall.jpg\", bbox_inches=\"tight\", dpi=300)\n",
+    "plt.show()\n",
+    "\n",
+    "# Plot the percentage of neighboring coacquisitions\n",
+    "fig, ax = plt.subplots(figsize=(10, 10))\n",
+    "insets = [[0.7, 0.7, 0.3, 0.3]]\n",
+    "x_inset_lims = [[2e5, 3e5]]\n",
+    "y_inset_lims = [[0.3, 0.4]]\n",
+    "fig, ax = clsl.plot_multiple_figs_with_insets(\n",
+    "    fig,\n",
+    "    [ax],\n",
+    "    {\n",
+    "        \"short branch length\": binned_coacq_by_branch_length_dfs[\"short branches\"]\n",
+    "    },\n",
+    "    \"coacquisitions with known positions\",\n",
+    "    \"neighbor (max 1 intervening genes) percentage\",\n",
+    "    marker_styles_dict,\n",
+    "    x_inset_lims,\n",
+    "    y_inset_lims,\n",
+    "    \"Co-acquisitions\",\n",
+    "    \"Percentage of neighboring co-acquisitions\",\n",
+    "    insets,\n",
+    ")\n",
+    "plt.savefig(\n",
+    "    f\"{plots_dir}/neighboring_coacq_short_branch_length.jpg\", bbox_inches=\"tight\", dpi=300,\n",
+    ")\n",
+    "plt.show()\n",
+    "# fig, ax = plt.subplots(figsize=(10, 10))\n",
+    "# x_inset_lims = [[1.5e5, 1.8e5]]\n",
+    "# y_inset_lims = [[0.3, 0.4]]\n",
+    "# fig, ax = clsl.plot_multiple_figs_with_insets(\n",
+    "#     fig,\n",
+    "#     [ax],\n",
+    "#     {\n",
+    "#         \"medium branch length\": binned_coacq_by_branch_length_dfs[\"medium branches\"]\n",
+    "#     },\n",
+    "#     \"coacquisitions with known positions\",\n",
+    "#     \"neighbor (max 1 intervening genes) percentage\",\n",
+    "#     marker_styles_dict,\n",
+    "#     x_inset_lims,\n",
+    "#     y_inset_lims,\n",
+    "#     \"Co-acquisitions\",\n",
+    "#     \"Percentage of neighboring co-acquisitions\",\n",
+    "#     insets,\n",
+    "# )\n",
+    "# plt.savefig(\n",
+    "#     f\"{plots_dir}/neighboring_coacq_medium_branch_length.jpg\", bbox_inches=\"tight\", dpi=300,\n",
+    "# )\n",
+    "# plt.show()\n",
+    "fig, ax = plt.subplots(figsize=(10, 10))\n",
+    "x_inset_lims = [[3e5, 4e5]]\n",
+    "y_inset_lims = [[0.3, 0.4]]\n",
+    "fig, ax = clsl.plot_multiple_figs_with_insets(\n",
+    "    fig,\n",
+    "    [ax],\n",
+    "    {\"long branch length\": binned_coacq_by_branch_length_dfs[\"long branches\"]},\n",
+    "    \"coacquisitions with known positions\",\n",
+    "    \"neighbor (max 1 intervening genes) percentage\",\n",
+    "    marker_styles_dict,\n",
+    "    x_inset_lims,\n",
+    "    y_inset_lims,\n",
+    "    \"Co-acquisitions\",\n",
+    "    \"Percentage of neighboring co-acquisitions\",\n",
+    "    insets,\n",
+    ")\n",
+    "plt.savefig(\n",
+    "    f\"{plots_dir}/neighboring_coacq_long_branch_length.jpg\", bbox_inches=\"tight\", dpi=300,\n",
+    ")\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6055afa2",
+   "metadata": {},
+   "source": [
+    "GLOOME MP and Count MP agree completely. GLOOME ML>Count ML unless it's long branches. In fact Count ML severely underperforms with short branches."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "f4585b23",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Processing short branches bin\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Method</th>\n",
+       "      <th>Mean</th>\n",
+       "      <th>Std</th>\n",
+       "      <th>Max</th>\n",
+       "      <th>Stringency</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>count.mp</td>\n",
+       "      <td>1.926534</td>\n",
+       "      <td>0.718971</td>\n",
+       "      <td>2.634804</td>\n",
+       "      <td>5.00000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>gloome.mp</td>\n",
+       "      <td>1.926534</td>\n",
+       "      <td>0.718971</td>\n",
+       "      <td>2.634804</td>\n",
+       "      <td>5.00000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>gloome.mp.without_tree</td>\n",
+       "      <td>1.725659</td>\n",
+       "      <td>0.450583</td>\n",
+       "      <td>2.200000</td>\n",
+       "      <td>8.00000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>gloome.ml</td>\n",
+       "      <td>1.410879</td>\n",
+       "      <td>0.451470</td>\n",
+       "      <td>2.300000</td>\n",
+       "      <td>0.96120</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>count.ml</td>\n",
+       "      <td>0.905961</td>\n",
+       "      <td>0.304671</td>\n",
+       "      <td>1.287013</td>\n",
+       "      <td>0.90103</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>gloome.ml.without_tree</td>\n",
+       "      <td>0.817516</td>\n",
+       "      <td>0.144165</td>\n",
+       "      <td>0.990000</td>\n",
+       "      <td>0.97780</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>ale</td>\n",
+       "      <td>0.516635</td>\n",
+       "      <td>0.147398</td>\n",
+       "      <td>0.700000</td>\n",
+       "      <td>0.78000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>ranger</td>\n",
+       "      <td>0.326052</td>\n",
+       "      <td>0.037447</td>\n",
+       "      <td>0.366157</td>\n",
+       "      <td>1.00000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>wn</td>\n",
+       "      <td>0.208883</td>\n",
+       "      <td>0.031903</td>\n",
+       "      <td>0.242718</td>\n",
+       "      <td>7.00000</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                   Method      Mean       Std       Max  Stringency\n",
+       "2                count.mp  1.926534  0.718971  2.634804     5.00000\n",
+       "5               gloome.mp  1.926534  0.718971  2.634804     5.00000\n",
+       "6  gloome.mp.without_tree  1.725659  0.450583  2.200000     8.00000\n",
+       "3               gloome.ml  1.410879  0.451470  2.300000     0.96120\n",
+       "1                count.ml  0.905961  0.304671  1.287013     0.90103\n",
+       "4  gloome.ml.without_tree  0.817516  0.144165  0.990000     0.97780\n",
+       "0                     ale  0.516635  0.147398  0.700000     0.78000\n",
+       "7                  ranger  0.326052  0.037447  0.366157     1.00000\n",
+       "8                      wn  0.208883  0.031903  0.242718     7.00000"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Processing long branches bin\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Method</th>\n",
+       "      <th>Mean</th>\n",
+       "      <th>Std</th>\n",
+       "      <th>Max</th>\n",
+       "      <th>Stringency</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>count.mp</td>\n",
+       "      <td>1.820171</td>\n",
+       "      <td>1.147707</td>\n",
+       "      <td>3.162333</td>\n",
+       "      <td>5.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>gloome.mp</td>\n",
+       "      <td>1.820171</td>\n",
+       "      <td>1.147707</td>\n",
+       "      <td>3.162333</td>\n",
+       "      <td>5.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>gloome.ml</td>\n",
+       "      <td>1.305296</td>\n",
+       "      <td>0.479244</td>\n",
+       "      <td>1.900000</td>\n",
+       "      <td>0.979700</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>gloome.mp.without_tree</td>\n",
+       "      <td>0.933437</td>\n",
+       "      <td>0.168480</td>\n",
+       "      <td>1.099933</td>\n",
+       "      <td>8.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>count.ml</td>\n",
+       "      <td>0.830176</td>\n",
+       "      <td>0.256207</td>\n",
+       "      <td>1.400000</td>\n",
+       "      <td>0.999964</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>gloome.ml.without_tree</td>\n",
+       "      <td>0.488408</td>\n",
+       "      <td>0.063550</td>\n",
+       "      <td>0.553042</td>\n",
+       "      <td>1.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>ale</td>\n",
+       "      <td>0.462872</td>\n",
+       "      <td>0.154577</td>\n",
+       "      <td>0.700000</td>\n",
+       "      <td>0.750000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>ranger</td>\n",
+       "      <td>0.390763</td>\n",
+       "      <td>0.069145</td>\n",
+       "      <td>0.469289</td>\n",
+       "      <td>1.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>wn</td>\n",
+       "      <td>0.259038</td>\n",
+       "      <td>0.039742</td>\n",
+       "      <td>0.303637</td>\n",
+       "      <td>5.000000</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                   Method      Mean       Std       Max  Stringency\n",
+       "2                count.mp  1.820171  1.147707  3.162333    5.000000\n",
+       "5               gloome.mp  1.820171  1.147707  3.162333    5.000000\n",
+       "3               gloome.ml  1.305296  0.479244  1.900000    0.979700\n",
+       "6  gloome.mp.without_tree  0.933437  0.168480  1.099933    8.000000\n",
+       "1                count.ml  0.830176  0.256207  1.400000    0.999964\n",
+       "4  gloome.ml.without_tree  0.488408  0.063550  0.553042    1.000000\n",
+       "0                     ale  0.462872  0.154577  0.700000    0.750000\n",
+       "7                  ranger  0.390763  0.069145  0.469289    1.000000\n",
+       "8                      wn  0.259038  0.039742  0.303637    5.000000"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead tr th {\n",
+       "        text-align: left;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th colspan=\"2\" halign=\"left\">short branches</th>\n",
+       "      <th colspan=\"2\" halign=\"left\">long branches</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th>Method</th>\n",
+       "      <th>Mean</th>\n",
+       "      <th>Method</th>\n",
+       "      <th>Mean</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Count (MP)</td>\n",
+       "      <td>1.926534</td>\n",
+       "      <td>Count (MP)</td>\n",
+       "      <td>1.820171</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>GLOOME (MP)</td>\n",
+       "      <td>1.926534</td>\n",
+       "      <td>GLOOME (MP)</td>\n",
+       "      <td>1.820171</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>GLOOME (MP) α</td>\n",
+       "      <td>1.725659</td>\n",
+       "      <td>GLOOME (ML)</td>\n",
+       "      <td>1.305296</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>GLOOME (ML)</td>\n",
+       "      <td>1.410879</td>\n",
+       "      <td>GLOOME (MP) α</td>\n",
+       "      <td>0.933437</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Count (ML)</td>\n",
+       "      <td>0.905961</td>\n",
+       "      <td>Count (ML)</td>\n",
+       "      <td>0.830176</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>GLOOME (ML) α</td>\n",
+       "      <td>0.817516</td>\n",
+       "      <td>GLOOME (ML) α</td>\n",
+       "      <td>0.488408</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>ALE</td>\n",
+       "      <td>0.516635</td>\n",
+       "      <td>ALE</td>\n",
+       "      <td>0.462872</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>RANGER</td>\n",
+       "      <td>0.326052</td>\n",
+       "      <td>RANGER</td>\n",
+       "      <td>0.390763</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>Wn</td>\n",
+       "      <td>0.208883</td>\n",
+       "      <td>Wn</td>\n",
+       "      <td>0.259038</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "  short branches            long branches          \n",
+       "          Method      Mean         Method      Mean\n",
+       "0     Count (MP)  1.926534     Count (MP)  1.820171\n",
+       "1    GLOOME (MP)  1.926534    GLOOME (MP)  1.820171\n",
+       "2  GLOOME (MP) α  1.725659    GLOOME (ML)  1.305296\n",
+       "3    GLOOME (ML)  1.410879  GLOOME (MP) α  0.933437\n",
+       "4     Count (ML)  0.905961     Count (ML)  0.830176\n",
+       "5  GLOOME (ML) α  0.817516  GLOOME (ML) α  0.488408\n",
+       "6            ALE  0.516635            ALE  0.462872\n",
+       "7         RANGER  0.326052         RANGER  0.390763\n",
+       "8             Wn  0.208883             Wn  0.259038"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\\begin{tabular}{lrlr}\n",
+      "\\toprule\n",
+      "\\multicolumn{2}{r}{short branches} & \\multicolumn{2}{r}{long branches} \\\\\n",
+      "Method & Mean & Method & Mean \\\\\n",
+      "\\midrule\n",
+      "Count (MP) & 1.927 & Count (MP) & 1.820 \\\\\n",
+      "GLOOME (MP) & 1.927 & GLOOME (MP) & 1.820 \\\\\n",
+      "GLOOME (MP) α & 1.726 & GLOOME (ML) & 1.305 \\\\\n",
+      "GLOOME (ML) & 1.411 & GLOOME (MP) α & 0.933 \\\\\n",
+      "Count (ML) & 0.906 & Count (ML) & 0.830 \\\\\n",
+      "GLOOME (ML) α & 0.818 & GLOOME (ML) α & 0.488 \\\\\n",
+      "ALE & 0.517 & ALE & 0.463 \\\\\n",
+      "RANGER & 0.326 & RANGER & 0.391 \\\\\n",
+      "Wn & 0.209 & Wn & 0.259 \\\\\n",
+      "\\bottomrule\n",
+      "\\end{tabular}\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# for each bin_df, find the mean of the corrected percentage of neighboring coacquisitions\n",
+    "\n",
+    "agg_var = \"neighbor (max 1 intervening genes) percentage\"\n",
+    "ranked_method_mean_performance_dfs_dict = {}\n",
+    "for bin_name, bin_df in binned_coacq_by_branch_length_dfs.items():\n",
+    "    print(f\"Processing {bin_name} bin\")\n",
+    "    # first remove from bin_df any of the rows where the number of coacquisitions is < 1e3 and > 1e5\n",
+    "    bin_df = bin_df[(bin_df[\"coacquisitions with known positions\"] >= 1e3) & (bin_df[\"coacquisitions with known positions\"] <= 1e5)]\n",
+    "    # for each method, find the mean of the corrected percentage of neighboring coacquisitions\n",
+    "    #     ...for each method. Groupby method,\n",
+    "    #     and find max of the transfer threshold\n",
+    "    #     value of mean of observed minus expected percentage of neighboring coacquisitions (max 1 intervening genes)\n",
+    "    #     and std of the values across the transfer thresholds\n",
+    "    percentage_binned_df = bin_df.groupby(\"method\"\n",
+    "        ).agg(\n",
+    "        {\n",
+    "            agg_var: [\n",
+    "                \"mean\",\n",
+    "                \"std\",\n",
+    "                lambda x: x.idxmax(),\n",
+    "                lambda x: x.max(),\n",
+    "            ]\n",
+    "        }\n",
+    "    ).reset_index()\n",
+    "    percentage_binned_df.columns = [\n",
+    "        \"Method\",\n",
+    "        \"Mean\",\n",
+    "        \"Std\",\n",
+    "        \"Max IDX\",\n",
+    "        \"Max\",\n",
+    "    ]\n",
+    "    percentage_binned_df[\"Stringency\"] = bin_df.loc[\n",
+    "        percentage_binned_df[\"Max IDX\"]\n",
+    "    ][\"transfer threshold\"].values\n",
+    "    percentage_binned_df = percentage_binned_df.drop(\n",
+    "        columns=[\"Max IDX\"]\n",
+    "    )\n",
+    "    # sort descending by Mean\n",
+    "    percentage_binned_df = percentage_binned_df.sort_values(\n",
+    "        by=\"Mean\", ascending=False\n",
+    "    )\n",
+    "    # replace NaN with 'NA'\n",
+    "    percentage_binned_df = percentage_binned_df.fillna(\"NA\")\n",
+    "    # show the dataframe\n",
+    "    display(percentage_binned_df)\n",
+    "\n",
+    "    # replace method names with the 'label' from marker_styles_dict[method]['label']\n",
+    "    percentage_binned_df[\"Method\"] = percentage_binned_df[\"Method\"].apply(\n",
+    "        lambda x: marker_styles_dict[x][\"label\"] if x in marker_styles_dict else x\n",
+    "    )\n",
+    "\n",
+    "    # add the df to the ranked_method_mean_performance_dfs_dict\n",
+    "    ranked_method_mean_performance_dfs_dict[bin_name] = percentage_binned_df\n",
+    "\n",
+    "# combine dfs in the ranked_method_mean_performance_dfs_dict into a single df\n",
+    "## with a header row for each bin type\n",
+    "# Prepare multi-row header\n",
+    "\n",
+    "# Get the number of methods per bin (should be the same for both bins)\n",
+    "n_methods = [len(df) for df in ranked_method_mean_performance_dfs_dict.values()]\n",
+    "\n",
+    "# Build the multi-row columns\n",
+    "columns = []\n",
+    "for bin_name, df in ranked_method_mean_performance_dfs_dict.items():\n",
+    "    columns.extend([(bin_name, \"Method\"), (bin_name, \"Mean\")])\n",
+    "\n",
+    "# Build the data for the table\n",
+    "data = []\n",
+    "for i in range(max(n_methods)):\n",
+    "    row = []\n",
+    "    for bin_name, df in ranked_method_mean_performance_dfs_dict.items():\n",
+    "        if i < len(df):\n",
+    "            row.extend([df.iloc[i, 0], df.iloc[i, 1]])\n",
+    "        else:\n",
+    "            row.extend([np.nan, np.nan])\n",
+    "    data.append(row)\n",
+    "\n",
+    "multi_index = pd.MultiIndex.from_tuples(columns)\n",
+    "ranked_method_mean_performance_table = pd.DataFrame(data, columns=multi_index)\n",
+    "\n",
+    "# Display the table\n",
+    "display(ranked_method_mean_performance_table)\n",
+    "# display latex\n",
+    "print(\n",
+    "    ranked_method_mean_performance_table.to_latex(\n",
+    "        index=False, float_format=\"%.3f\"\n",
+    "    ).replace(\"NaN\", \"\")\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "hgt_analyses",
+   "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.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}