diff --git a/tutorials/likelihood/photometric_likelihoods.ipynb b/tutorials/likelihood/photometric_likelihoods.ipynb
index 7099cc1..769e1ed 100644
--- a/tutorials/likelihood/photometric_likelihoods.ipynb
+++ b/tutorials/likelihood/photometric_likelihoods.ipynb
@@ -12,10 +12,36 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "id": "638d6c84-ae61-4d28-ab2a-15fbf745152c",
+   "execution_count": 1,
+   "id": "1308f5ec",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/Users/zahra/anaconda3/envs/cloe-org-env-v2026.1/lib/python3.12/site-packages/HMcode2020Emu\n",
+      "Loading linear emulator...\n",
+      "Linear emulator loaded in memory.\n",
+      "Loading nonlinear emulator...\n",
+      "Non-linear emulator loaded in memory.\n",
+      "Loading linear emulator...\n",
+      "Baryonic boost emulator loaded in memory.\n",
+      "Loading sigma8 emulator...\n",
+      "Linear emulator loaded in memory.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'}"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "# General imports\n",
     "import numpy as np\n",
@@ -33,7 +59,10 @@
     "from cloelib.cosmology.HMcode2020Emu_cosmology import HMemuLinearPerturbations, HMemuNonLinearPerturbations\n",
     "\n",
     "# Import cloelike for likelihood computations\n",
-    "from cloelike.EuclidLikelihood_photo_Cls import EuclidLikelihood_WL, EuclidLikelihood_GCph, EuclidLikelihood_3x2pt"
+    "from cloelike.EuclidLikelihood_photo_Cls import EuclidLikelihood_WL, EuclidLikelihood_GCph, EuclidLikelihood_2x2pt, EuclidLikelihood_3x2pt\n",
+    "\n",
+    "# Avoid warnings for cleaner output \n",
+    "np.seterr(divide='ignore', over='ignore', invalid='ignore') # Ignore divide by zero and overflow errors in numpy operations, which can occur in loglike calculation, it is annoying otherwise"
    ]
   },
   {
@@ -43,15 +72,13 @@
    "source": [
     "## Download Synthetic Data\n",
     "\n",
-    "We are currently developing homogeneous synthetic data vectors, mixing matrices, and covariance matrices that are compatible with [euclidlib](https://github.com/euclidlib/euclidlib) and adhere to the data format specifications used by the Euclid Science Ground Segment (LE3).\n",
-    "\n",
-    "> ⚠️ This effort is still ongoing. Interfaces and file availability may change as development progresses.\n"
+    "We are currently developing homogeneous synthetic data vectors, mixing matrices, and covariance matrices that are compatible with [euclidlib](https://github.com/euclidlib/euclidlib) and adhere to the data format specifications used by the Euclid Science Ground Segment (LE3).\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
-   "id": "b76eff88",
+   "execution_count": 2,
+   "id": "65a202e0",
    "metadata": {},
    "outputs": [
     {
@@ -60,10 +87,8 @@
      "text": [
       "nz_example.fits downloaded successfully\n",
       "mixmats_example.fits downloaded successfully\n",
-      "cls_example.fits downloaded successfully\n",
-      "cov_WL.npz downloaded successfully\n",
-      "cov_GCph.npz downloaded successfully\n",
-      "cov_3x2pt.npz downloaded successfully\n"
+      "synthetic_coupled_cells.fits downloaded successfully\n",
+      "covmat_2D.npz downloaded successfully\n"
      ]
     }
    ],
@@ -78,11 +103,9 @@
     "    # URLs of the files to be downloaded\n",
     "    urls = {\n",
     "        'nz_example.fits': 'https://zenodo.org/records/15092862/files/nz_example.fits',\n",
-    "        'mixmats_example.fits': 'https://zenodo.org/records/17191365/files/example-mixmats.fits',\n",
-    "        'cls_example.fits': 'https://zenodo.org/records/17191365/files/example-spectra.fits',\n",
-    "        'cov_WL.npz': 'https://zenodo.org/records/17191365/files/cov_WL.npz',\n",
-    "        'cov_GCph.npz': 'https://zenodo.org/records/17191365/files/cov_GC.npz',\n",
-    "        'cov_3x2pt.npz': 'https://zenodo.org/records/17191365/files/cov_3x2pt.npz'\n",
+    "        'mixmats_example.fits': 'https://zenodo.org/records/19071608/files/mixmats_example.fits',\n",
+    "        'synthetic_coupled_cells.fits': 'https://zenodo.org/records/19071608/files/synthetic_coupled_cells.fits',\n",
+    "        'covmat_2D.npz': 'https://zenodo.org/records/19071608/files/covmat_2D.npz'\n",
     "    }\n",
     "    \n",
     "    \n",
@@ -117,13 +140,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
-   "id": "210466a1-5c00-4288-833e-eb9e52e532ce",
+   "execution_count": 3,
+   "id": "36f491ba",
    "metadata": {},
    "outputs": [],
    "source": [
     "# Get n(z)\n",
-    "z_nz, nz_heracles = el.photo.redshift_distributions('nz_example.fits')\n",
+    "z_nz, nz_heracles = el.phz.redshift_distributions('nz_example.fits')\n",
     "\n",
     "# Normalize and resample n(z) for both position and shear\n",
     "myz = np.linspace(1e-4, 3.0, 100)\n",
@@ -132,53 +155,138 @@
     "    return np.array([np.interp(z_target, z_grid, nz) for nz in nz_array])\n",
     "\n",
     "my_dndz_pos_norm = normalize_and_resample(nz_heracles, z_nz, myz)\n",
-    "my_dndz_she_norm = normalize_and_resample(nz_heracles, z_nz, myz)\n"
+    "my_dndz_she_norm = normalize_and_resample(nz_heracles, z_nz, myz)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 4,
    "id": "c9d10658-f771-4bcc-a5b2-dfa2409938e4",
    "metadata": {},
+   "outputs": [],
+   "source": [
+    "# We read with euclidlib \n",
+    "cls_data = el.le3.pk_wl.angular_power_spectra('synthetic_coupled_cells.fits')\n",
+    "mixmats = el.le3.pk_wl.mixing_matrices('mixmats_example.fits')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e2c4b953",
+   "metadata": {},
    "outputs": [
     {
-     "ename": "FileNotFoundError",
-     "evalue": "[Errno 2] No such file or directory: 'cov_2x2pt.npz'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[16], line 8\u001b[0m\n\u001b[1;32m      6\u001b[0m covmat_WL \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mload(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcov_WL.npz\u001b[39m\u001b[38;5;124m\"\u001b[39m)[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124marr_0\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[1;32m      7\u001b[0m covmat_GC \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mload(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcov_GCph.npz\u001b[39m\u001b[38;5;124m\"\u001b[39m)[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124marr_0\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[0;32m----> 8\u001b[0m covmat_2x2pt \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcov_2x2pt.npz\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124marr_0\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[1;32m      9\u001b[0m covmat_3x2pt \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mload(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcov_3x2pt.npz\u001b[39m\u001b[38;5;124m\"\u001b[39m)[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124marr_0\u001b[39m\u001b[38;5;124m'\u001b[39m]\n",
-      "File \u001b[0;32m~/miniforge3/envs/cloe-org-cloelike/lib/python3.10/site-packages/numpy/lib/npyio.py:427\u001b[0m, in \u001b[0;36mload\u001b[0;34m(file, mmap_mode, allow_pickle, fix_imports, encoding, max_header_size)\u001b[0m\n\u001b[1;32m    425\u001b[0m     own_fid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[1;32m    426\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 427\u001b[0m     fid \u001b[38;5;241m=\u001b[39m stack\u001b[38;5;241m.\u001b[39menter_context(\u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mos_fspath\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrb\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m)\n\u001b[1;32m    428\u001b[0m     own_fid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m    430\u001b[0m \u001b[38;5;66;03m# Code to distinguish from NumPy binary files and pickles.\u001b[39;00m\n",
-      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'cov_2x2pt.npz'"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Total entries in cls_data: 78\n",
+      "Entries for (SHE, SHE): 21\n",
+      "Entries for (POS, SHE): 36\n",
+      "Entries for (POS, POS): 21\n"
      ]
     }
    ],
    "source": [
-    "# We read with euclidlib v2025.2 (v2025.1 is also compatible)\n",
-    "cls_data = el.photo.angular_power_spectra('cls_example.fits')\n",
-    "mixmats = el.photo.mixing_matrices('mixmats_example.fits')\n",
-    "\n",
-    "# This matrix copies the format of seaborne, that produces a full 3x2pt matrix\n",
-    "covmat_WL = np.load(\"cov_WL.npz\")['arr_0']\n",
-    "covmat_GC = np.load(\"cov_GCph.npz\")['arr_0']\n",
-    "covmat_2x2pt = np.load(\"cov_2x2pt.npz\")['arr_0']\n",
-    "covmat_3x2pt = np.load(\"cov_3x2pt.npz\")['arr_0']"
+    "# Count entries in cls_data by probe pair\n",
+    "probe_pairs = [('SHE', 'SHE'), ('POS', 'SHE'), ('POS', 'POS')]\n",
+    "\n",
+    "counts = {\n",
+    "    pair: sum(1 for k in cls_data.keys() if k[0] == pair[0] and k[1] == pair[1])\n",
+    "    for pair in probe_pairs\n",
+    "}\n",
+    "\n",
+    "print(f\"Total entries in cls_data: {len(cls_data)}\")\n",
+    "for (a, b), n in counts.items():\n",
+    "    print(f\"Entries for ({a}, {b}): {n}\")"
    ]
   },
   {
-   "cell_type": "markdown",
-   "id": "21c0b35c",
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "74b09a50",
    "metadata": {},
+   "outputs": [],
    "source": [
-    "## Prepare Data Dictionary\n",
-    "\n",
-    "We envision that the preparation of data will become significantly simpler once a unified format for reading inputs is adopted. This standardised structure will allow for easier integration of synthetic data vectors, mixing matrices, and covariance matrices into the likelihood evaluation pipeline. \n"
+    "covmat_3x2pt = np.load(\"covmat_2D.npz\")['Gauss']"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 7,
+   "id": "043057ae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Extract covariance submatrices for each probe combination\n",
+    "# The covariance is in the order WL, GGL, GCph\n",
+    "# With 32 ell bins and 6 redshift bins, we have:\n",
+    "# WL (SHE-SHE): 6 bins × 32 ells = 192 elements per bin pair → 6×6 = 36 pairs → 192×6 = 1152, but accounting for symmetric structure: 32×21 = 672\n",
+    "# GCph (POS-POS): Similar structure with 6 POS bins → 32×21 = 672\n",
+    "# 2x2pt (POS-SHE):  2x2pt including GGL and GCph\n",
+    "\n",
+    "# The 3x2pt covariance matrix contains:\n",
+    "# [0:672]       → WL (SHE-SHE), 6 bins, 32 ells: 6*(6+1)/2 * 32 = 21*32 = 672\n",
+    "# [672:1824]    → GGL (POS-SHE cross term), 6×6 = 36 bin pairs, 32 ells: 36*32 = 1152\n",
+    "# [1824:end]    → GCph (POS-POS), 6 bins, 32 ells: 6*(6+1)/2 * 32 = 21*32 = 672\n",
+    "covmat_WL = covmat_3x2pt[:672, :672]\n",
+    "covmat_GC = covmat_3x2pt[1824:, 1824:]\n",
+    "covmat_2x2pt = covmat_3x2pt[672:, 672:]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "06de7843",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Covariance shapes:\n",
+      "WL: (672, 672)\n",
+      "GC: (672, 672)\n",
+      "2x2pt: (1824, 1824)\n",
+      "3x2pt: (2496, 2496)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"Covariance shapes:\")\n",
+    "print(f\"WL: {covmat_WL.shape}\")\n",
+    "print(f\"GC: {covmat_GC.shape}\")\n",
+    "print(f\"2x2pt: {covmat_2x2pt.shape}\")\n",
+    "print(f\"3x2pt: {covmat_3x2pt.shape}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "ef31102a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([  10,   12,   15,   18,   21,   26,   31,   37,   44,   53,   64,\n",
+       "         77,   92,  110,  132,  158,  189,  226,  270,  323,  387,  462,\n",
+       "        553,  661,  790,  944, 1129, 1349, 1613, 1928, 2304, 2754],\n",
+       "      dtype='>i8')"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cls_data[\"POS\", \"POS\", 1, 1].ell"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
    "id": "be0b200e-6432-4024-bcf4-0bd6f6f293fd",
    "metadata": {},
    "outputs": [],
@@ -204,38 +312,19 @@
     "# Build each dataset with correct dndz components\n",
     "data_WL     = build_data(('SHE', 'SHE', 1, 1), covmat_WL,         include_she=True)\n",
     "data_GC     = build_data(('POS', 'POS', 1, 1), covmat_GC,         include_pos=True)\n",
+    "data_2x2pt  = build_data(('POS', 'SHE', 1, 1), covmat_2x2pt,      include_pos=True, include_she=True)\n",
     "data_3x2pt  = build_data(('POS', 'POS', 1, 1), covmat_3x2pt,      include_pos=True, include_she=True)\n",
     "\n",
     "# Settings (same for all, built from cells_data structure)\n",
     "settings_WL     = build_settings()\n",
     "settings_GC     = build_settings()\n",
+    "settings_2x2pt  = build_settings()\n",
     "settings_3x2pt  = build_settings()"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "7f16ac49",
-   "metadata": {},
-   "source": [
-    "## Likelihood Initialisation\n",
-    "\n",
-    "This block handles the initialisation of the Euclid photometric likelihoods in harmonic space. For each observable probe, we construct the corresponding likelihood class instance using the appropriate data and settings dictionaries:\n",
-    "\n",
-    "- **WL**: Weak Lensing\n",
-    "- **GC**: Photometric Galaxy Clustering\n",
-    "- **3x2pt**: Full combination of WL, GC, and GGL\n",
-    "\n",
-    "Each likelihood is instantiated with the required cosmological components:\n",
-    "- `CAMBBackground` for background evolution\n",
-    "- `HMemuLinearPerturbations` for linear theory\n",
-    "- `HMemuNonLinearPerturbations` for non-linear corrections\n",
-    "\n",
-    "We also time the initialisation process to estimate setup costs for each likelihood. This is particularly useful for understanding performance when running larger parameter scans or MCMC chains."
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 11,
    "id": "082a6d05-ef09-473c-9f67-5d30faf9df41",
    "metadata": {},
    "outputs": [
@@ -246,13 +335,16 @@
       "🔍 Timing log-likelihood initialisation (this only happens once) and displaying results:\n",
       "\n",
       "📊 WL loglike:\n",
-      "⏱️ Time elapsed (WL): 0.016 seconds\n",
+      "⏱️ Time elapsed (WL): 0.065 seconds\n",
       "\n",
       "📊 GC loglike:\n",
-      "⏱️ Time elapsed (GC): 0.008 seconds\n",
+      "⏱️ Time elapsed (GC): 0.019 seconds\n",
+      "\n",
+      "📊 2x2pt loglike:\n",
+      "⏱️ Time elapsed (2x2pt): 0.010 seconds\n",
       "\n",
       "📊 3x2pt loglike:\n",
-      "⏱️ Time elapsed (3x2pt): 0.008 seconds\n"
+      "⏱️ Time elapsed (3x2pt): 0.023 seconds\n"
      ]
     }
    ],
@@ -262,12 +354,14 @@
     "likelihood_classes = {\n",
     "    'WL': EuclidLikelihood_WL,\n",
     "    'GC': EuclidLikelihood_GCph,\n",
+    "    '2x2pt': EuclidLikelihood_2x2pt,\n",
     "    '3x2pt': EuclidLikelihood_3x2pt,\n",
     "}\n",
     "\n",
     "data_dicts = {\n",
     "    'WL': (data_WL, settings_WL),\n",
     "    'GC': (data_GC, settings_GC),\n",
+    "    '2x2pt': (data_2x2pt, settings_2x2pt),\n",
     "    '3x2pt': (data_3x2pt, settings_3x2pt),\n",
     "}\n",
     "\n",
@@ -276,7 +370,7 @@
     "\n",
     "print(\"🔍 Timing log-likelihood initialisation (this only happens once) and displaying results:\")\n",
     "\n",
-    "for label in ['WL', 'GC', '3x2pt']:\n",
+    "for label in ['WL', 'GC', '2x2pt', '3x2pt']:\n",
     "    print(f\"\\n📊 {label} loglike:\")\n",
     "    data, settings = data_dicts[label]\n",
     "    cls = likelihood_classes[label]\n",
@@ -288,40 +382,27 @@
     "        Background=CAMBBackground,\n",
     "        LinPerturbations=HMemuLinearPerturbations,\n",
     "        NonLinPerturbations=HMemuNonLinearPerturbations,\n",
+    "        mode='coupled'\n",
     "    )\n",
     "    end = time.time()\n",
     "\n",
     "    print(f\"⏱️ Time elapsed ({label}): {end - start:.3f} seconds\")\n"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "c9742d7b",
-   "metadata": {},
-   "source": [
-    "## Likelihood Evaluation\n",
-    "\n",
-    "In this section, we perform a single evaluation of the log-likelihood for each photometric probe at the fiducial cosmological parameters. \n",
-    "\n",
-    "We use a dictionary of initialized likelihood objects (`like_tests`) and evaluate their `loglike()` method using a shared set of default parameters. The execution time for each evaluation is recorded to give a sense of computational cost.\n",
-    "\n",
-    "This diagnostic helps verify the setup and responsiveness of the likelihood components for each probe before launching more detailed analyses.\n"
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": 50,
+   "execution_count": 12,
    "id": "4573baac",
    "metadata": {},
    "outputs": [],
    "source": [
     "# These are the default parameters used to generate the synthetic data, therefore, the log-likelihood should be close to zero.\n",
-    "default_pars = {'H0':70,'Omega_cdm0':0.25,'Omega_b0':0.05,'ns':0.96,'As':2.1e-9,\n",
-    "                'w0':-1,'wa':0, 'Omega_k0':0,'mnu':0.06,'gamma_MG':0.545, 'N_mnu': 1, \n",
+    "default_pars = {'H0':70,'Omega_cdm0':0.25,'Omega_b0':0.05,'ns':0.96,'As':2.e-9,\n",
+    "                'w0':-1,'wa':0, 'Omega_k0':0,'mnu':0.06,'gamma_MG':0.545, 'N_mnu': 1,  \n",
     "                'log10TAGN': 7.8,\n",
-    "                'AIA':0., 'EtaIA': 0, 'CIA': 0.0,\n",
-    "                'b1_photo_poly0': 1.33291, 'b1_photo_poly1': -0.72414,\n",
-    "                'b1_photo_poly2': 1.0183, 'b1_photo_poly3': -0.14913,\n",
+    "                'AIA': 1.72, 'CIA': 0.0134, 'EtaIA':-0.41,\n",
+    "                'b1_photo_poly0': 1., 'b1_photo_poly1': 0.,\n",
+    "                'b1_photo_poly2': 0.0, 'b1_photo_poly3': 0.,\n",
     "                'magnification_bias_1': 0.0, 'magnification_bias_2': 0.0,\n",
     "                'magnification_bias_3': 0.0, 'magnification_bias_4': 0.0,\n",
     "                'magnification_bias_5': 0.0, 'magnification_bias_6': 0.0,\n",
@@ -336,10 +417,18 @@
     "                'dz_shear_5': 0.0, 'dz_shear_6': 0.0}"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "a41c6718",
+   "metadata": {},
+   "source": [
+    "You can always retrieve the theoretical prediction computed during the $\\chi^2$ calculation and the derived parameters such as (in dictionary shape):"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 51,
-   "id": "9df11cc9-0870-4af1-9835-a557861f4f1b",
+   "execution_count": 13,
+   "id": "aa3df168",
    "metadata": {},
    "outputs": [
     {
@@ -349,24 +438,32 @@
       "⏱️ Timing log-likelihood evaluations and displaying results:\n",
       "\n",
       "📊 Weak Lensing (WL) loglike:\n",
-      "✅ Returned value (WL): -27.651626565250503\n",
-      "⏱️ Time elapsed (WL): 0.161 seconds\n",
+      "✅ Returned value (WL): -6.579833346255802e-29\n",
+      "⏱️ Time elapsed (WL): 2.739 seconds\n",
       "\n",
       "📊 Photometric Angular Galaxy Clustering (GC) loglike:\n",
-      "✅ Returned value (GC): -570.5360648741748\n",
-      "⏱️ Time elapsed (GC): 0.107 seconds\n",
+      "✅ Returned value (GC): -1.497128608563665e-29\n",
+      "⏱️ Time elapsed (GC): 0.576 seconds\n",
+      "\n",
+      "📊 2x2pt loglike:\n",
+      "✅ Returned value (2x2pt): -4.6930536811126575e-29\n",
+      "⏱️ Time elapsed (2x2pt): 0.400 seconds\n",
       "\n",
       "📊 3x2pt loglike:\n",
-      "✅ Returned value (3x2pt): -262676.99760000233\n",
-      "⏱️ Time elapsed (3x2pt): 0.580 seconds\n"
+      "✅ Returned value (3x2pt): -2.114307241661666e-28\n",
+      "⏱️ Time elapsed (3x2pt): 0.590 seconds\n"
      ]
     }
    ],
    "source": [
     "# Dictionary of pretty names for output\n",
+    "from unittest import result\n",
+    "\n",
+    "\n",
     "labels_pretty = {\n",
     "    'WL': \"Weak Lensing (WL)\",\n",
     "    'GC': \"Photometric Angular Galaxy Clustering (GC)\",\n",
+    "    '2x2pt': \"2x2pt\",\n",
     "    '3x2pt': \"3x2pt\"\n",
     "}\n",
     "\n",
@@ -374,19 +471,24 @@
     "\n",
     "loglike_results = {}\n",
     "\n",
-    "for label in ['WL', 'GC', '3x2pt']:\n",
+    "for label in [\n",
+    "              'WL', \n",
+    "              'GC', \n",
+    "              '2x2pt', \n",
+    "              '3x2pt'\n",
+    "              ]:\n",
     "    print(f\"\\n📊 {labels_pretty[label]} loglike:\")\n",
     "    start = time.time()\n",
     "    result = like_tests[label].loglike(default_pars)\n",
     "    elapsed = time.time() - start\n",
     "    loglike_results[label] = result\n",
     "    print(f\"✅ Returned value ({label}): {result}\")\n",
-    "    print(f\"⏱️ Time elapsed ({label}): {elapsed:.3f} seconds\")\n"
+    "    print(f\"⏱️ Time elapsed ({label}): {elapsed:.3f} seconds\")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "a41c6718",
+   "id": "79cb7f33",
    "metadata": {},
    "source": [
     "You can always retrieve the theoretical prediction computed during the $\\chi^2$ calculation and the derived parameters such as (in dictionary shape):"
@@ -394,8 +496,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 52,
-   "id": "1c910f1f",
+   "execution_count": 14,
+   "id": "b013953a",
    "metadata": {},
    "outputs": [
     {
@@ -403,7 +505,7 @@
      "output_type": "stream",
      "text": [
       "{('SHE', 'SHE', 1, 1): AngularPowerSpectrum(axis=(2,)), ('SHE', 'SHE', 1, 2): AngularPowerSpectrum(axis=(2,)), ('SHE', 'SHE', 1, 3): AngularPowerSpectrum(axis=(2,)), ('SHE', 'SHE', 1, 4): AngularPowerSpectrum(axis=(2,)), ('SHE', 'SHE', 1, 5): AngularPowerSpectrum(axis=(2,)), ('SHE', 'SHE', 1, 6): AngularPowerSpectrum(axis=(2,)), ('SHE', 'SHE', 2, 2): AngularPowerSpectrum(axis=(2,)), ('SHE', 'SHE', 2, 3): AngularPowerSpectrum(axis=(2,)), ('SHE', 'SHE', 2, 4): AngularPowerSpectrum(axis=(2,)), ('SHE', 'SHE', 2, 5): AngularPowerSpectrum(axis=(2,)), ('SHE', 'SHE', 2, 6): AngularPowerSpectrum(axis=(2,)), ('SHE', 'SHE', 3, 3): AngularPowerSpectrum(axis=(2,)), ('SHE', 'SHE', 3, 4): AngularPowerSpectrum(axis=(2,)), ('SHE', 'SHE', 3, 5): AngularPowerSpectrum(axis=(2,)), ('SHE', 'SHE', 3, 6): AngularPowerSpectrum(axis=(2,)), ('SHE', 'SHE', 4, 4): AngularPowerSpectrum(axis=(2,)), ('SHE', 'SHE', 4, 5): AngularPowerSpectrum(axis=(2,)), ('SHE', 'SHE', 4, 6): AngularPowerSpectrum(axis=(2,)), ('SHE', 'SHE', 5, 5): AngularPowerSpectrum(axis=(2,)), ('SHE', 'SHE', 5, 6): AngularPowerSpectrum(axis=(2,)), ('SHE', 'SHE', 6, 6): AngularPowerSpectrum(axis=(2,))}\n",
-      "{'sigma8_0': 0.8135475902671722}\n"
+      "{'sigma8_0': np.float64(0.7939373649367804)}\n"
      ]
     }
    ],
@@ -428,8 +530,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 56,
-   "id": "de2f80fa",
+   "execution_count": 15,
+   "id": "240e4449",
    "metadata": {},
    "outputs": [
     {
@@ -437,19 +539,64 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "🔄 Scanning over $\\Omega_{cdm} h^2$ for GC\n"
+      "🔄 Scanning over $H_0$ for WL\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "GC: 100%|███████████████████████████████████████| 50/50 [00:05<00:00,  8.89it/s]\n"
+      "WL: 100%|███████████████████████████████████████| 50/50 [00:06<00:00,  7.85it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "🔄 Scanning over $H_0$ for GC\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "GC: 100%|███████████████████████████████████████| 50/50 [00:04<00:00, 12.32it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "🔄 Scanning over $H_0$ for 2x2pt\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2x2pt: 100%|████████████████████████████████████| 50/50 [00:09<00:00,  5.35it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "🔄 Scanning over $H_0$ for 3x2pt\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "3x2pt: 100%|████████████████████████████████████| 50/50 [00:15<00:00,  3.24it/s]\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 800x600 with 1 Axes>"
       ]
@@ -462,51 +609,371 @@
     "## Exploration of the parameter space\n",
     "from tqdm import tqdm\n",
     "\n",
-    "# Define the range of Omega_cdm0 values to scan\n",
-    "oms = np.linspace(0.24, 0.31, 50)\n",
+    "# Define the range of H0 values to scan\n",
+    "H0 = np.linspace(64, 76, 50)\n",
+    "\n",
+    "# Define colors and linestyles per probe\n",
+    "colors = {'WL': 'cornflowerblue', 'GC': 'silver', '2x2pt': 'lightpink', '3x2pt': 'darkorchid'}\n",
+    "linestyles = {'WL': '-', 'GC': '-', '2x2pt': '-', '3x2pt': '--'}\n",
     "\n",
     "# Prepare the figure\n",
-    "plt.figure(figsize=(8,6))\n",
+    "plt.figure(figsize=(8, 6))\n",
     "\n",
-    "for label in ['GC']:\n",
-    "    print(f\"\\n🔄 Scanning over $\\Omega_{{cdm}} h^2$ for {label}\")\n",
+    "for label in ['WL', 'GC', '2x2pt', '3x2pt']:\n",
+    "    print(f\"\\n🔄 Scanning over $H_0$ for {label}\")\n",
     "    likelihood_curve = []\n",
     "\n",
-    "    for om in tqdm(oms, desc=f\"{label}\", ncols=80):\n",
-    "        # Update Omega_cdm0 parameter from omch2 and H0\n",
-    "        default_pars['Omega_cdm0'] = om \n",
-    "\n",
-    "        # Compute log-likelihood\n",
+    "    for hi in tqdm(H0, desc=f\"{label}\", ncols=80):\n",
+    "        default_pars['H0'] = hi\n",
     "        ll = like_tests[label].loglike(default_pars)\n",
     "        likelihood_curve.append(ll)\n",
-    "    \n",
+    "\n",
     "    # Convert log-likelihoods to likelihoods (exp) and normalize\n",
-    "    likelihood_curve = np.exp(likelihood_curve - np.max(likelihood_curve))\n",
-    "    \n",
-    "    # Plot\n",
-    "    plt.plot(oms, likelihood_curve, label=label)\n",
+    "    likelihood_curve = np.exp(np.array(likelihood_curve) - np.max(likelihood_curve))\n",
+    "\n",
+    "    # Plot with custom color and linestyle\n",
+    "    plt.plot(H0, likelihood_curve, label=label, color=colors[label], linestyle=linestyles[label], lw=2)\n",
     "\n",
-    "plt.xlabel(r'$\\Omega_{cdm} h^2$')\n",
+    "# Reset default_pars H0 to fiducial value\n",
+    "default_pars['H0'] = 70.0\n",
+    "plt.axvline(x=70.0, color='gray', linestyle='--', lw=1, label='Fiducial $H_0$')\n",
+    "\n",
+    "plt.xlabel(r'$H_0$')\n",
     "plt.ylabel('Normalized Likelihood')\n",
-    "plt.title('Likelihood scan over $\\Omega_{cdm} h^2$ for photometric probes')\n",
+    "plt.title('Likelihood scan over $H_0$ for photometric probes')\n",
     "plt.legend()\n",
     "plt.grid(True)\n",
     "plt.tight_layout()\n",
-    "plt.show()\n"
+    "#plt.xlim(69.95, 70.05)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fd92dd34",
+   "metadata": {},
+   "source": [
+    "# Likelihood Calculation for 2PCF"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "240e4449",
+   "execution_count": 17,
+   "id": "b39a5dd8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1344, 1344)\n",
+      "(672, 672)\n",
+      "(1824, 1824)\n",
+      "(3168, 3168)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from cloelike.EuclidLikelihood_photo_2pcf import EuclidLikelihood_WL, EuclidLikelihood_GCph, EuclidLikelihood_3x2pt, EuclidLikelihood_2x2pt\n",
+    "from euclidlib.le3.twopcf_wl import correlation_functions\n",
+    "\n",
+    "\n",
+    "raw_data_GC = correlation_functions(\"correlation_function_GG_synthetic.fits\")\n",
+    "raw_data_WL = correlation_functions(\"correlation_function_EE_synthetic.fits\")\n",
+    "raw_data_GGL = correlation_functions(\"correlation_function_EG_synthetic.fits\")\n",
+    "covmat_3x2pt = np.load('cov_3x2pt_real_2D.npz')['Gauss']\n",
+    "raw_data_3x2pt = {**raw_data_WL,**raw_data_GGL,**raw_data_GC}\n",
+    "raw_data_2x2pt = {**raw_data_GGL,**raw_data_GC}\n",
+    "covmat_WL = covmat_3x2pt[:1344, :1344]\n",
+    "covmat_GC = covmat_3x2pt[2496:, 2496:]\n",
+    "covmat_2x2pt = covmat_3x2pt[1344:, 1344:]\n",
+    "print(covmat_WL.shape)\n",
+    "print(covmat_GC.shape)\n",
+    "print(covmat_2x2pt.shape)\n",
+    "print(covmat_3x2pt.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "e4a3b821",
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "def build_data(cf_data,theta_key, cov, include_pos=False,include_she=False):\n",
+    "    data = {\n",
+    "        '2pcf': cf_data,\n",
+    "        'theta': np.degrees(cf_data[theta_key].theta)*60,\n",
+    "        'z_arr': myz,\n",
+    "        'cov': cov,\n",
+    "        \n",
+    "    }\n",
+    "    if include_pos:\n",
+    "        data['dndz_pos'] = my_dndz_pos_norm\n",
+    "    if include_she:\n",
+    "        data['dndz_she'] = my_dndz_she_norm\n",
+    "    return data\n",
+    "\n",
+    "def build_settings(cf_data):\n",
+    "    \n",
+    "    scale_cuts = {}\n",
+    "    for key in cf_data:\n",
+    "        if key[0] == 'SHE' and key[1] == 'SHE':\n",
+    "            scale_cuts[key] = [10, 250, 60, 250] #for xi_plus and xi_minus respectively\n",
+    "        else:\n",
+    "            scale_cuts[key] = [10, 250]\n",
+    "    \n",
+    "    return {'scale_cuts': scale_cuts}\n",
+    "# Build each dataset with correct dndz components\n",
+    "data_WL     = build_data(raw_data_WL,('SHE', 'SHE', 1, 1),covmat_WL,include_she=True)\n",
+    "data_GC     = build_data(raw_data_GC,('POS', 'POS', 1, 1),covmat_GC,include_pos=True)\n",
+    "data_3x2pt  = build_data(raw_data_3x2pt,('SHE', 'SHE', 1, 1),covmat_3x2pt,include_pos=True,include_she=True)\n",
+    "data_2x2pt  = build_data(raw_data_2x2pt,('POS', 'SHE', 1, 1),covmat_2x2pt,include_pos=True,include_she=True)\n",
+    "\n",
+    "# Settings (same for all, built from cells_data structure)\n",
+    "settings_WL     = build_settings(raw_data_WL)\n",
+    "settings_GC     = build_settings(raw_data_GC)\n",
+    "settings_3x2pt  = build_settings(raw_data_3x2pt)\n",
+    "settings_2x2pt  = build_settings(raw_data_2x2pt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "57b324c5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "🔍 Timing log-likelihood initialisation (this only happens once) and displaying results:\n",
+      "\n",
+      "📊 WL loglike:\n",
+      "⏱️ Time elapsed (WL): 0.000 seconds\n",
+      "\n",
+      "📊 GC loglike:\n",
+      "⏱️ Time elapsed (GC): 0.000 seconds\n",
+      "\n",
+      "📊 2x2pt loglike:\n",
+      "⏱️ Time elapsed (2x2pt): 0.000 seconds\n",
+      "\n",
+      "📊 3x2pt loglike:\n",
+      "⏱️ Time elapsed (3x2pt): 0.000 seconds\n"
+     ]
+    }
+   ],
+   "source": [
+    "likelihood_classes = {\n",
+    "    'WL': EuclidLikelihood_WL,\n",
+    "    'GC': EuclidLikelihood_GCph,\n",
+    "    '3x2pt': EuclidLikelihood_3x2pt,\n",
+    "    '2x2pt': EuclidLikelihood_2x2pt\n",
+    "}\n",
+    "\n",
+    "data_dicts = {\n",
+    "    'WL': (data_WL, settings_WL),\n",
+    "    'GC': (data_GC, settings_GC),\n",
+    "    '3x2pt': (data_3x2pt, settings_3x2pt),\n",
+    "    '2x2pt': (data_2x2pt, settings_2x2pt)\n",
+    "}\n",
+    "\n",
+    "like_tests = {}\n",
+    "loglike_results = {}\n",
+    "\n",
+    "print(\"🔍 Timing log-likelihood initialisation (this only happens once) and displaying results:\")\n",
+    "\n",
+    "for label in ['WL','GC','2x2pt','3x2pt']:\n",
+    "    print(f\"\\n📊 {label} loglike:\")\n",
+    "    data, settings = data_dicts[label]\n",
+    "    cls = likelihood_classes[label]\n",
+    "\n",
+    "    start = time.time()\n",
+    "    like_tests[label] = cls(\n",
+    "        data=data,\n",
+    "        settings=settings,\n",
+    "        Background=CAMBBackground,\n",
+    "        LinPerturbations=HMemuLinearPerturbations,\n",
+    "        NonLinPerturbations=HMemuNonLinearPerturbations,\n",
+    "    )\n",
+    "    end = time.time()\n",
+    "\n",
+    "    print(f\"⏱️ Time elapsed ({label}): {end - start:.3f} seconds\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "40a054c8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "⏱️ Timing log-likelihood evaluations and displaying results:\n",
+      "\n",
+      "📊 WL loglike:\n",
+      "✅ Returned value (WL): -1.495276449055171e-25\n",
+      "⏱️ Time elapsed (WL): 282.602 seconds\n",
+      "\n",
+      "📊 GC loglike:\n",
+      "✅ Returned value (GC): 0.0\n",
+      "⏱️ Time elapsed (GC): 66.980 seconds\n",
+      "\n",
+      "📊 2x2pt loglike:\n",
+      "✅ Returned value (2x2pt): -1.165376063900561e-25\n",
+      "⏱️ Time elapsed (2x2pt): 155.688 seconds\n",
+      "\n",
+      "📊 3x2pt loglike:\n",
+      "✅ Returned value (3x2pt): -5.1628838634115725e-25\n",
+      "⏱️ Time elapsed (3x2pt): 1.701 seconds\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "\n",
+    "print(\"⏱️ Timing log-likelihood evaluations and displaying results:\")\n",
+    "\n",
+    "loglike_results = {}\n",
+    "\n",
+    "for label in ['WL','GC','2x2pt','3x2pt']:\n",
+    "    print(f\"\\n📊 {label} loglike:\")\n",
+    "    start = time.time()\n",
+    "    result = like_tests[label].loglike(default_pars)\n",
+    "    elapsed = time.time() - start\n",
+    "    loglike_results[label] = result\n",
+    "    print(f\"✅ Returned value ({label}): {result}\")\n",
+    "    print(f\"⏱️ Time elapsed ({label}): {elapsed:.3f} seconds\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "2a314b22",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "🔄 Scanning over $H_0$ for WL\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WL: 100%|███████████████████████████████████████| 50/50 [00:22<00:00,  2.19it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "🔄 Scanning over $H_0$ for GC\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "GC: 100%|███████████████████████████████████████| 50/50 [00:21<00:00,  2.30it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "🔄 Scanning over $H_0$ for 2x2pt\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2x2pt: 100%|████████████████████████████████████| 50/50 [00:44<00:00,  1.13it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "🔄 Scanning over $H_0$ for 3x2pt\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "3x2pt: 100%|████████████████████████████████████| 50/50 [01:12<00:00,  1.45s/it]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "## Exploration of the parameter space\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "# Define the range of H0 values to scan\n",
+    "H0 = np.linspace(64, 76, 50)\n",
+    "\n",
+    "# Define colors and linestyles per probe\n",
+    "colors = {'WL': 'cornflowerblue', 'GC': 'silver', '2x2pt': 'lightpink', '3x2pt': 'darkorchid'}\n",
+    "linestyles = {'WL': '-', 'GC': '-', '2x2pt': '-', '3x2pt': '--'}\n",
+    "\n",
+    "# Prepare the figure\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "\n",
+    "for label in ['WL','GC','2x2pt','3x2pt']:\n",
+    "    print(f\"\\n🔄 Scanning over $H_0$ for {label}\")\n",
+    "    likelihood_curve = []\n",
+    "\n",
+    "    for hi in tqdm(H0, desc=f\"{label}\", ncols=80):\n",
+    "        default_pars['H0'] = hi\n",
+    "       \n",
+    "        ll = like_tests[label].loglike(default_pars)\n",
+    "        \n",
+    "        likelihood_curve.append(ll)\n",
+    "\n",
+    "    # Convert log-likelihoods to likelihoods (exp) and normalize\n",
+    "    likelihood_curve = np.exp(np.array(likelihood_curve) - np.max(likelihood_curve))\n",
+    "\n",
+    "    # Plot with custom color and linestyle\n",
+    "    plt.plot(H0, likelihood_curve, label=label, color=colors[label], linestyle=linestyles[label], lw=2)\n",
+    "\n",
+    "# Reset default_pars H0 to fiducial value\n",
+    "default_pars['H0'] = 70.0\n",
+    "plt.axvline(x=70.0, color='gray', linestyle='--', lw=1, label='Fiducial $H_0$')\n",
+    "\n",
+    "plt.xlabel(r'$H_0$')\n",
+    "plt.ylabel('Normalized Likelihood')\n",
+    "plt.title('Likelihood scan over $H_0$ for photometric probes')\n",
+    "plt.legend()\n",
+    "plt.grid(True)\n",
+    "plt.tight_layout()\n",
+    "#plt.xlim(69.95, 70.05)\n",
+    "plt.show()"
+   ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "cloe-org-cloelike",
+   "display_name": "cloe-org-env-v2026.1",
    "language": "python",
    "name": "python3"
   },
@@ -520,7 +987,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.18"
+   "version": "3.12.12"
   }
  },
  "nbformat": 4,