diff --git a/codes_to_global_rotations.ipynb b/codes_to_global_rotations.ipynb
new file mode 100755
index 0000000..f893683
--- /dev/null
+++ b/codes_to_global_rotations.ipynb
@@ -0,0 +1,593 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Subjecting codes of various dimensionality to global rotations\n",
+        "\n",
+        "**A TSIM Implementation of \"A fault-tolerant neutral-atom architecture for universal quantum computation\"**\n",
+        "\n",
+        "*Reproduction of Figure 4a from Bluvstein, D. et al. (2025) using TSIM *\n",
+        "\n",
+        "### At a Glance:\n",
+        "This tutorial will guide practitioner to reproduce experiments of this paper in regard to the logical X expectation value vs global Z-rotation angle φ\n",
+        "for three code configurations:\n",
+        "  1. Unentangled physical qubits (analyzed as 3D code)\n",
+        "  2. 2D color code (Steane [[7,1,3]])\n",
+        "  3. 3D color code (Reed-Muller [[15,1,3]])\n",
+        "\n",
+        "The key feature to observe: the 3D Reed-Muller code shows plateaus at multiples of 45°\n",
+        "corresponding to its transversal T gate — not seen in the 2D code."
+      ],
+      "metadata": {
+        "id": "wLYELRuhBqpp"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Rationale behind the article\n",
+        "\n",
+        "The Steane code can do transversal gates — apply a gate qubit-by-qubit across the 7 physical qubits without spreading errors. But there's a fundamental obstacle:\n",
+        "\n",
+        "### The Eastin-Knill Theorem\n",
+        "> No quantum error-correcting code can implement a universal gate set using only transversal operations.\n",
+        "\n",
+        "This means the Steane code's transversal gates (H, S, CNOT) are powerful but not enough to do arbitrary quantum computations. You're missing something."
+      ],
+      "metadata": {
+        "id": "CUIl7Q_oHcCg"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### What's Missing: The T Gate\n",
+        "A universal gate set needs at least:\n",
+        "H  +  T  =  universal single-qubit rotations\n",
+        "The T gate is a 45° rotation around the Z axis:\n",
+        "\n",
+        "```\n",
+        "T = [1    0  ]\n",
+        "    [0   e^(iπ/4)]\n",
+        "```\n",
+        "\n",
+        "It's a non-Clifford gate — it lives outside the \"safe\" Clifford group that stabilizer codes handle naturally. And by Eastin-Knill, you can't get it transversally from the Steane code.\n",
+        "\n",
+        "### The Solovay-Kitaev Theorem\n",
+        "> Any single-qubit rotation (any point on the Bloch sphere) can be approximated to exponential precision using only H and T gates.\n",
+        "\n",
+        "Concretely, if you want precision ε, you need only O(log^c(1/ε)) gates — a very efficient approximation. This means:\n",
+        "H and T gates alone = universal quantum computation\n",
+        "So the whole problem reduces to: how do you implement a fault-tolerant T gate?\n",
+        "\n",
+        "### The Solution: 3D Codes + Teleportation\n",
+        "This is where the paper's key insight comes in. They use a hierarchy of codes:\n",
+        "- 2D Color Codes = Steane Code\n",
+        "The familiar 7-qubit code = Transversal gates: H, S, CNOT (the Clifford group). but no transversal T.\n",
+        "- 3D Color Codes = Reed-Muller Code\n",
+        "A larger code (15 qubits) that is essentially the Steane code \"stacked into 3D.\"\n",
+        "\n",
+        "It has one extra magical property:\n",
+        "Reed-Muller code has a transversal T gate\n",
+        "But it loses the transversal H. So neither code alone is universal\n",
+        "\n",
+        "...but together they are.\n",
+        "\n",
+        "### How They Circumvent Eastin-Knill: Logical Measurement\n",
+        "The theorem says no unitary transversal universal gate set exists. The escape hatch is:\n",
+        "\n",
+        "Introduce logical measurement, which breaks the unitarity constraint.\n",
+        "\n",
+        "The technique is gate teleportation:\n",
+        "Instead of directly applying T to your logical qubit...\n",
+        "1. Prepare a special \"magic state\" |M⟩ = T|+⟩  using the 3D code\n",
+        "2. Teleport your logical qubit through that magic state\n",
+        "3. The teleportation effectively applies T to your qubit\n",
+        "4. A measurement is involved → unitarity is broken → Eastin-Knill is bypassed\n",
+        "This is called magic state injection/distillation and is the standard way to get non-Clifford gates fault-tolerantly."
+      ],
+      "metadata": {
+        "id": "fDk_stQTJPOU"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## What Figure 4a Shows\n",
+        "They subject their codes to a continuous Z-rotation by angle φ and watch the logical expectation value:\n",
+        "\n",
+        "**Unentangled physical qubits**\n",
+        "→ plateaus only at 0°, 180°, 360°\n",
+        "\n",
+        "**2D Steane code**\n",
+        "→ plateaus at 0°, 90°, 180°, 270°\n",
+        "\n",
+        "**3D Reed-Muller code**\n",
+        "→ plateaus at 0°, 45°, 90°, 135°, ... ← NEW!\n",
+        "\n",
+        "The plateau at 45° is the experimental signature that the 3D code has a robust transversal T gate. The stabilizers also \"revive\" at those angles, confirming the code space is intact. This is a direct physical demonstration that the code is protecting a non-Clifford operation."
+      ],
+      "metadata": {
+        "id": "WQQHBqSqKAtR"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## The Plan\n",
+        "1. Backbones: Install required libraries and perform imports\n",
+        "2. Declare function to produce circuits for Unentangled, 2d and 3D and their measurement helpers\n",
+        "3. Run the circuits\n",
+        "4. Plot the results"
+      ],
+      "metadata": {
+        "id": "BQITAaYBOTld"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [],
+      "metadata": {
+        "id": "GgwugrXGOrvh"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [],
+      "metadata": {
+        "id": "YKUQmyNPOrsk"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form",
+        "id": "2NdU3vjiqZEe"
+      },
+      "outputs": [],
+      "source": [
+        "# @title Installs\n",
+        "%%capture\n",
+        "!pip install bloqade-tsim sinter tesseract-decoder"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @title Imports\n",
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "import tsim\n",
+        "from tsim.utils.encoder import TransversalEncoder, SteaneEncoder"
+      ],
+      "metadata": {
+        "cellView": "form",
+        "id": "8yxmH8oiBibG"
+      },
+      "execution_count": 2,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Reed-Muller 3D Encoder\n",
+        "\n",
+        "There is no (to our knowledge) out-of-the-box implementation of a ReedMuller encoder in TSIM, so we have to do by ourselves (We are still reviewing and experimenting on this, beware!"
+      ],
+      "metadata": {
+        "id": "-9zuUtr5PZUx"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @title Reed-Muller 3D Color encoder for non Clifford Gates\n",
+        "\n",
+        "# The 15-qubit Reed-Muller code is the smallest 3D color code.\n",
+        "# Stabilizer generators: weight-4 X checks and weight-4 Z checks\n",
+        "# derived from the classical [15,11,3] / [15,4,8] Reed-Muller codes.\n",
+        "#\n",
+        "# The standard Reed-Muller [[15,1,3]] stabilizers:\n",
+        "# Z-type generators (detect X/bit-flip errors):\n",
+        "# X-type generators (detect Z/phase-flip errors) — same support sets:\n",
+        "#   same 7 sets as Z\n",
+        "#\n",
+        "# Observable: X_L = X on all 15 qubits (transversal)\n",
+        "#             Z_L = Z on all 15 qubits (transversal)\n",
+        "\n",
+        "\n",
+        "class ReedMullerEncoder(TransversalEncoder):\n",
+        "    \"\"\"Transversal encoder for the [[15,1,3]] Reed-Muller code (3D color code).\"\"\"\n",
+        "\n",
+        "    def __init__(self):\n",
+        "        # Standard stabilizer generators for [[15,1,3]] RM code\n",
+        "        # These are the Z-type generators; X-type have the same support\n",
+        "        stab_generators = [\n",
+        "            [0, 1, 2, 3],\n",
+        "            [0, 1, 4, 5],\n",
+        "            [0, 2, 4, 6],\n",
+        "            [0, 1, 8, 9],\n",
+        "            [0, 2, 8, 10],\n",
+        "            [0, 4, 8, 12],\n",
+        "            [1, 2, 4, 7],\n",
+        "        ]\n",
+        "\n",
+        "        # Logical observable: X on qubits 0,1,2,...,14 (all)\n",
+        "        observables = [list(range(15))]\n",
+        "\n",
+        "        # Encoding circuit for [[15,1,3]].\n",
+        "        # Input qubit is qubit 14. The circuit prepares |0_L> from |0>^14 |psi>\n",
+        "        # using Hadamards and CNOTs that implement the generator matrix.\n",
+        "        # This follows the standard CSS encoding procedure:\n",
+        "        #   1. Prepare ancilla qubits in |+> (for X stabilizers)\n",
+        "        #   2. Apply CNOT chain to spread the logical qubit\n",
+        "        encoding_program = \"\"\"\n",
+        "            R 0 1 2 3 4 5 6 7 8 9 10 11 12 13\n",
+        "            TICK\n",
+        "            H 0 1 2 3 4 5 6 7 8 9 10 11 12 13\n",
+        "            TICK\n",
+        "            CNOT 14 0 14 1 14 2 14 3 14 4 14 5 14 6\n",
+        "            CNOT 14 7 14 8 14 9 14 10 14 11 14 12 14 13\n",
+        "            TICK\n",
+        "            CNOT 0 1 0 2 0 4 0 8\n",
+        "            CNOT 1 3 1 5 1 9\n",
+        "            CNOT 2 3 2 6 2 10\n",
+        "            CNOT 3 7 3 11\n",
+        "            CNOT 4 5 4 6 4 12\n",
+        "            CNOT 5 7 5 13\n",
+        "            CNOT 6 7 6 14\n",
+        "            CNOT 8 9 8 10 8 12\n",
+        "            CNOT 9 11 9 13\n",
+        "            CNOT 10 11 10 14\n",
+        "            CNOT 12 13\n",
+        "            TICK\n",
+        "            H 0 1 2 3 4 5 6 7 8 9 10 11 12 13\n",
+        "        \"\"\"\n",
+        "\n",
+        "        super().__init__(\n",
+        "            n=15,\n",
+        "            encoding_qubit=14,\n",
+        "            encoding_program_text=encoding_program,\n",
+        "            stabilizer_generators=stab_generators,\n",
+        "            observables=observables,\n",
+        "        )"
+      ],
+      "metadata": {
+        "id": "dKP-WktrCCXw"
+      },
+      "execution_count": 3,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @title Measurement helper: logical X expectation value\n",
+        "def measure_logical_x_expectation(circuit_text: str, shots: int = 20_000) -> float:\n",
+        "    \"\"\"\n",
+        "    Given a circuit that ends with a measurement of the logical observable,\n",
+        "    return <X_L> = P(0) - P(1).\n",
+        "    \"\"\"\n",
+        "    c = tsim.Circuit(circuit_text)\n",
+        "    det_sampler = c.compile_detector_sampler(seed=42)\n",
+        "    _, obs_samples = det_sampler.sample(shots=shots, separate_observables=True)\n",
+        "    p1 = np.count_nonzero(obs_samples) / len(obs_samples)\n",
+        "    return 1.0 - 2.0 * p1  # maps P(0)->+1, P(1)->-1\n"
+      ],
+      "metadata": {
+        "id": "d6CZrOMRCb-M"
+      },
+      "execution_count": 4,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @title 1. Unentangled physical qubits\n",
+        "\n",
+        "# Single physical qubit prepared in |+>, rotated by R_Z(phi),\n",
+        "# then measured in X basis. Expected: cos(phi).\n",
+        "\n",
+        "def run_unentangled(phi: float, shots: int = 20_000) -> float:\n",
+        "    # phi is in units of pi (tsim R_Z convention)\n",
+        "    alpha = phi / np.pi\n",
+        "    circuit_text = f\"\"\"\n",
+        "        RX 0\n",
+        "        R_Z({alpha}) 0\n",
+        "        H 0\n",
+        "        M 0\n",
+        "        OBSERVABLE_INCLUDE(0) rec[-1]\n",
+        "    \"\"\"\n",
+        "    c = tsim.Circuit(circuit_text)\n",
+        "    det_sampler = c.compile_detector_sampler(seed=42)\n",
+        "    _, obs_samples = det_sampler.sample(shots=shots, separate_observables=True)\n",
+        "    p1 = np.count_nonzero(obs_samples) / len(obs_samples)\n",
+        "    return 1.0 - 2.0 * p1"
+      ],
+      "metadata": {
+        "id": "bUyvXlhwCb4E"
+      },
+      "execution_count": 5,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## 2D Steane Code\n",
+        "\n",
+        "The Steane code is especially important because many quantum gates (including the full Clifford group) can be implemented transversally — meaning you apply the gate qubit-by-qubit without entangling the 7 physical qubits together. This prevents errors from spreading, making it naturally fault-tolerant."
+      ],
+      "metadata": {
+        "id": "JAvqLkL7H-sh"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @title 2. 2D color code (Steane [[7,1,3]])\n",
+        "\n",
+        "# Prepare logical |+_L>, apply transversal R_Z(phi), measure X_L.\n",
+        "# Transversal R_Z(phi) = R_Z(phi) on each of the 7 physical qubits.\n",
+        "\n",
+        "def run_steane(phi: float, shots: int = 20_000) -> float:\n",
+        "    alpha = phi / np.pi\n",
+        "    enc = SteaneEncoder()\n",
+        "    # Prepare logical |+>: start in |+> then encode\n",
+        "    enc.initialize(\"RX 0\")\n",
+        "    # Transversal R_Z(phi): apply to all 7 qubits\n",
+        "    qubit_list = \" \".join(str(i) for i in range(7))\n",
+        "    enc.circuit.append_from_stim_program_text(\n",
+        "        f\"R_Z({alpha}) {qubit_list}\"\n",
+        "    )\n",
+        "    # Measure logical X: apply H transversally then measure all, combine with observable\n",
+        "    enc.encode_transversally(f\"\"\"\n",
+        "        H 0\n",
+        "        M 0\n",
+        "        OBSERVABLE_INCLUDE(0) rec[-1]\n",
+        "    \"\"\")\n",
+        "    det_sampler = enc.circuit.compile_detector_sampler(seed=42)\n",
+        "    _, obs_samples = det_sampler.sample(shots=shots, separate_observables=True)\n",
+        "    p1 = np.count_nonzero(obs_samples) / len(obs_samples)\n",
+        "    return 1.0 - 2.0 * p1"
+      ],
+      "metadata": {
+        "id": "Gmwp--iqCz27"
+      },
+      "execution_count": 6,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @title 3. 3D color code (Reed-Muller)\n",
+        "\n",
+        "def run_reed_muller(phi: float, shots: int = 20_000) -> float:\n",
+        "    alpha = phi / np.pi\n",
+        "    enc = ReedMullerEncoder()\n",
+        "    enc.initialize(\"RX 0\")\n",
+        "    qubit_list = \" \".join(str(i) for i in range(15))\n",
+        "    enc.circuit.append_from_stim_program_text(\n",
+        "        f\"R_Z({alpha}) {qubit_list}\"\n",
+        "    )\n",
+        "    enc.encode_transversally(f\"\"\"\n",
+        "        H 0\n",
+        "        M 0\n",
+        "        OBSERVABLE_INCLUDE(0) rec[-1]\n",
+        "    \"\"\")\n",
+        "    det_sampler = enc.circuit.compile_detector_sampler(seed=42)\n",
+        "    _, obs_samples = det_sampler.sample(shots=shots, separate_observables=True)\n",
+        "    p1 = np.count_nonzero(obs_samples) / len(obs_samples)\n",
+        "    return 1.0 - 2.0 * p1"
+      ],
+      "metadata": {
+        "id": "zPu5h3GRDAB8"
+      },
+      "execution_count": 7,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @title Sweep over angles and collect results\n",
+        "\n",
+        "print(\"Setting up angle sweep (0 to 360 degrees)...\")\n",
+        "\n",
+        "# Use finer resolution around the plateau angles\n",
+        "phis = np.linspace(0, 2 * np.pi, 73)  # every 5 degrees\n",
+        "shots = 10_000\n",
+        "\n",
+        "print(f\"Running {len(phis)} angles × 3 configurations ({shots} shots each)...\")\n",
+        "print(\"This may take a few minutes.\\n\")\n",
+        "\n",
+        "results_unentangled = []\n",
+        "results_steane = []\n",
+        "results_rm = []\n",
+        "\n",
+        "for i, phi in enumerate(phis):\n",
+        "    deg = np.degrees(phi)\n",
+        "    print(f\"  φ = {deg:6.1f}°  ({i+1}/{len(phis)})\", end=\"\\r\")\n",
+        "\n",
+        "    results_unentangled.append(run_unentangled(phi, shots))\n",
+        "    results_steane.append(run_steane(phi, shots))\n",
+        "    results_rm.append(run_reed_muller(phi, shots))\n",
+        "\n",
+        "print(\"\\nDone! Plotting...\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "eF6LdaWlDNtj",
+        "outputId": "9a5f709e-75df-48be-9703-33136078022e"
+      },
+      "execution_count": 15,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Setting up angle sweep (0 to 360 degrees)...\n",
+            "Running 73 angles × 3 configurations (10000 shots each)...\n",
+            "This may take a few minutes.\n",
+            "\n",
+            "  φ =  360.0°  (73/73)\n",
+            "Done! Plotting...\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# @title Plot — reproducing Figure 4a style\n",
+        "\n",
+        "phis_deg = np.degrees(phis)\n",
+        "theory_unentangled = np.cos(phis)\n",
+        "\n",
+        "fig, axes = plt.subplots(3, 1, figsize=(10, 9), sharex=True)\n",
+        "fig.suptitle(\"Figure 4a reproduction — Logical X projection vs global Z-rotation\",\n",
+        "             fontsize=13, fontweight='bold')\n",
+        "\n",
+        "plateau_colors = dict(alpha=0.12)\n",
+        "configs = [\n",
+        "    (axes[0], results_unentangled, theory_unentangled, \"Unentangled physical qubits\",\n",
+        "     [0, 180, 360], \"#888888\"),\n",
+        "    (axes[1], results_steane, None, \"2D color code (Steane [[7,1,3]])\",\n",
+        "     [0, 90, 180, 270, 360], \"#2196F3\"),\n",
+        "    (axes[2], results_rm, None, \"3D color code (Reed–Muller [[15,1,3]])\",\n",
+        "     [0, 45, 90, 135, 180, 225, 270, 315, 360], \"#E91E63\"),\n",
+        "]\n",
+        "\n",
+        "for ax, data, theory, title, plateau_angles, color in configs:\n",
+        "    # Shade plateau regions\n",
+        "    for pa in plateau_angles:\n",
+        "        ax.axvspan(pa - 5, pa + 5, color=color, alpha=0.10, zorder=0)\n",
+        "        ax.axvline(pa, color=color, alpha=0.3, linewidth=0.8, linestyle='--', zorder=1)\n",
+        "\n",
+        "    # Theory curve for unentangled\n",
+        "    if theory is not None:\n",
+        "        ax.plot(phis_deg, theory, 'k--', linewidth=1, alpha=0.4, label='cos(φ) theory')\n",
+        "\n",
+        "    # Simulated data\n",
+        "    ax.plot(phis_deg, data, 'o-', color=color, markersize=4, linewidth=1.5,\n",
+        "            label='Simulation', zorder=5)\n",
+        "\n",
+        "    ax.set_ylabel(\"⟨X_L⟩\", fontsize=11)\n",
+        "    ax.set_ylim(-1.3, 1.3)\n",
+        "    ax.invert_yaxis()  # Inverts the Y-axis for each chart\n",
+        "    ax.set_title(title, fontsize=11, pad=4)\n",
+        "    ax.axhline(0, color='gray', linewidth=0.5, alpha=0.5)\n",
+        "    ax.legend(loc='upper right', fontsize=9)\n",
+        "    ax.grid(True, alpha=0.2)\n",
+        "    ax.set_yticks([-1, 0, 1])\n",
+        "\n",
+        "# Annotate the 45° plateau on the RM plot specifically\n",
+        "ax_rm = axes[2]\n",
+        "ax_rm.annotate('T gate\\nplateau (45°)',\n",
+        "               xy=(45, 0.85), xytext=(70, 1.1),\n",
+        "               fontsize=9, color='#E91E63',\n",
+        "               arrowprops=dict(arrowstyle='->', color='#E91E63', lw=1.2))\n",
+        "\n",
+        "axes[2].set_xlabel(\"Global Z-rotation angle φ (degrees)\", fontsize=11)\n",
+        "xticks = list(range(0, 361, 45))\n",
+        "axes[2].set_xticks(xticks)\n",
+        "axes[2].set_xticklabels([f\"{x}°\" for x in xticks])\n",
+        "\n",
+        "plt.tight_layout()\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 921
+        },
+        "id": "T67caj7-DYIS",
+        "outputId": "7f16ecc7-9709-4b4a-e0b4-c34b5a22150d"
+      },
+      "execution_count": 16,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Saved to figure4a_reproduction.png\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x900 with 3 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Foreword\n",
+        "This notebook reproduces in TSIM some of the finding of this article towards fault-tolerant universal computation achieved by the combination of the following error correction techniques\n",
+        "```\n",
+        "Steane code (2D)          →  transversal H, S, CNOT   (Clifford)\n",
+        "Reed-Muller code (3D)     →  transversal T            (non-Clifford)\n",
+        "Solovay-Kitaev theorem    →  H + T = any rotation\n",
+        "Gate teleportation        →  glues them together fault-tolerantly\n",
+        "Eastin-Knill              →  bypassed via measurement\n",
+        "```"
+      ],
+      "metadata": {
+        "id": "9xWpDL5RMdzJ"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## References\n",
+        "*Bluvstein, D., Geim, A.A., Li, S.H. et al. *\n",
+        "\n",
+        "[A fault-tolerant neutral-atom architecture for universal quantum computation. ](https://doi.org/10.1038/s41586-025-09848-5)\n",
+        "\n",
+        "*Nature 649, 39–46 (2026)*\n",
+        "\n",
+        "\n",
+        "---\n",
+        "\n",
+        "\n",
+        "\n",
+        "### TSIM\n",
+        "```\n",
+        "@article{tsim2026,\n",
+        "  title={Tsim: Fast Universal Simulator for Quantum Error Correction},\n",
+        "  author={Haenel, Rafael and Luo, Xiuzhe and Zhao, Chen},\n",
+        "  journal={arXiv preprint arXiv:2604.01059},\n",
+        "  year={2026}\n",
+        "}\n",
+        "```\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "bCzGWBeqQE7g"
+      }
+    }
+  ]
+}
\ No newline at end of file