logos-blockchain-pocs/cryptarchia/longest-chain-cryptarchia.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ad657d5a-bd36-4329-b134-6745daff7ae9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from dataclasses import dataclass, replace\n",
    "from pyvis.network import Network\n",
    "from pyvis.options import Layout\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a9e0b910-c633-4dbe-827c-4ddb804f7a9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def phi(f, alpha):\n",
    "    return 1 - (1-f)**alpha"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "aa0aadce-a0be-4873-ba23-293be74db313",
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class Block:\n",
    "    id: int\n",
    "    slot: int\n",
    "    height: int\n",
    "    parent: int\n",
    "    leader: int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a538cf45-d551-4603-b484-dbbc3f3d0a73",
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class NetworkParams:\n",
    "    broadcast_delay_mean: int # second\n",
    "    pol_proof_time: int # seconds\n",
    "    # ---- blend network -- \n",
    "    blending_delay: int\n",
    "    desimenation_delay_mean: float\n",
    "    # desimenation_delay_var: float\n",
    "    blend_hops: int\n",
    "    no_network_delay: bool = False\n",
    "\n",
    "    def sample_blending_delay(self):\n",
    "        return np.random.uniform(0, self.blending_delay)\n",
    "\n",
    "    def sample_desimenation_delay(self):\n",
    "        return np.random.exponential(self.desimenation_delay_mean)\n",
    "        # scale = self.desimenation_delay_var / self.desimenation_delay_mean\n",
    "        # shape = self.desimenation_delay_mean / scale\n",
    "        # return np.random.gamma(shape=shape, scale=scale)\n",
    "\n",
    "    def sample_blend_network_delay(self):\n",
    "        return sum(self.sample_blending_delay() + self.sample_desimenation_delay() for _ in range(self.blend_hops))\n",
    "    \n",
    "    def sample_broadcast_delay(self, blocks):\n",
    "        return np.random.exponential(self.broadcast_delay_mean, size=blocks.shape)\n",
    "\n",
    "    def block_arrival_slot(self, block_slot):\n",
    "        if self.no_network_delay:\n",
    "            return block_slot\n",
    "        # return self.pol_proof_time + self.sample_mixnet_delay() + self.sample_broadcast_delay(block_slot) + block_slot\n",
    "        return self.pol_proof_time + self.sample_blend_network_delay() + self.sample_broadcast_delay(block_slot) + block_slot\n",
    "\n",
    "    def empirical_network_delay(self, N=10000, M=1000):\n",
    "        return np.array([self.block_arrival_slot(np.zeros(M)) for _ in range(N)]).reshape(N*M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "17ef82f8-968c-48b0-bee7-f2642c8b3f3e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "blend_net = NetworkParams(\n",
    "    broadcast_delay_mean=0.5,\n",
    "    pol_proof_time=1,\n",
    "    blending_delay=2,\n",
    "    desimenation_delay_mean=0.5,\n",
    "    blend_hops=3,\n",
    ")\n",
    "no_blend_net = replace(blend_net, blend_hops=0)\n",
    "\n",
    "N = 100\n",
    "M = 10000\n",
    "no_blend_samples = no_blend_net.empirical_network_delay()\n",
    "no_blend_mean = no_blend_samples.mean()\n",
    "blend_samples = blend_net.empirical_network_delay()\n",
    "blend_mean = blend_samples.mean()\n",
    "\n",
    "_ = plt.hist(no_blend_samples, bins=100, density=True, label=\"no-blend\")\n",
    "_ = plt.hist(blend_samples, bins=100, density=True, label=\"blend\")\n",
    "\n",
    "for p in [50, 99, 99.9]:\n",
    "    no_blend_pct = np.percentile(no_blend_samples, p)\n",
    "    _ = plt.vlines(no_blend_pct, ymin=0, ymax=0.25, color='darkblue', label=f\"no-blend {p}p={no_blend_pct:.1f}s\")\n",
    "\n",
    "for p in [50, 99, 99.9]:\n",
    "    blend_pct = np.percentile(blend_samples, p)\n",
    "    _ = plt.vlines(blend_pct, ymin=0, ymax=0.25, color='brown', label=f\"blend {p}p={blend_pct:.1f}s\")\n",
    "# _ = plt.vlines(blend_mean, ymin=0, ymax=1, color='brown', label=f\"blend 50p={blend_mean:.1f}s\")\n",
    "# _ = plt.hist(blend_net.block_arrival_slot(np.zeros(1000)), bins=100, density=True, label=\"blend\")\n",
    "_ = plt.legend()\n",
    "_ = plt.xlabel(\"block delay\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "24779de7-284f-4200-9e4a-d2aa6e1b823b",
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class Params:\n",
    "    SLOTS: int\n",
    "    f: float\n",
    "    honest_stake: np.array\n",
    "    adversary_control: float\n",
    "\n",
    "    @property\n",
    "    def N(self):\n",
    "        return len(self.honest_stake) + 1\n",
    "\n",
    "    @property\n",
    "    def stake(self):\n",
    "        return np.append(self.honest_stake, self.honest_stake.sum() / (1/self.adversary_control - 1))\n",
    "    \n",
    "    @property\n",
    "    def relative_stake(self):\n",
    "        return self.stake / self.stake.sum()\n",
    "\n",
    "    def slot_prob(self):\n",
    "        return phi(self.f, self.relative_stake)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a90495a8-fcda-4e47-92b4-cc5ceaa9ff9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Sim:\n",
    "    def __init__(self, params: Params, network: NetworkParams):\n",
    "        self.params = params\n",
    "        self.network = network\n",
    "        self.leaders = np.zeros((params.N, params.SLOTS), dtype=np.int64)\n",
    "        self.blocks = []\n",
    "        max_number_of_blocks = int(3 * params.SLOTS * params.f)\n",
    "        self.block_slots = np.zeros(max_number_of_blocks, dtype=np.int64)\n",
    "        self.block_heights = np.zeros(max_number_of_blocks, dtype=np.int64)\n",
    "        self.block_arrivals = np.zeros(shape=(params.N, max_number_of_blocks), dtype=np.int64) # arrival time to each leader for each block\n",
    "        self.block_arrivals[:,:] = self.params.SLOTS\n",
    "        # self.block_arrivals = np.zeros(shape=(params.N, 0), dtype=np.int64) # arrival time to each leader for each block\n",
    "\n",
    "    \n",
    "    def emit_block(self, leader, slot, height, parent):\n",
    "        assert type(leader) in [int, np.int64]\n",
    "        assert type(slot) in [int, np.int64]\n",
    "        assert type(height) in [int, np.int64]\n",
    "        assert type(parent) in [int, np.int64]\n",
    "\n",
    "        block = Block(\n",
    "            id=len(self.blocks),\n",
    "            slot=slot,\n",
    "            height=height,\n",
    "            parent=parent,\n",
    "            leader=leader,\n",
    "        )\n",
    "        self.blocks.append(block)\n",
    "        self.block_slots[block.id] = block.slot\n",
    "        self.block_heights[block.id] = block.height\n",
    "    \n",
    "        # decide when this block will arrive at each node\n",
    "        new_block_arrival_by_node = self.network.block_arrival_slot(np.repeat(block.slot, self.params.N))\n",
    "\n",
    "        if parent != -1:\n",
    "            # the new block cannot arrive before it's parent\n",
    "            parent_arrival_by_node = self.block_arrivals[:,parent]\n",
    "            new_block_arrival_by_node = np.maximum(new_block_arrival_by_node, parent_arrival_by_node)\n",
    "\n",
    "        self.block_arrivals[:,block.id] = new_block_arrival_by_node\n",
    "        # self.block_arrivals = np.append(self.block_arrivals, new_block_arrival_by_node.reshape((self.params.N, 1)), axis=1)\n",
    "\n",
    "        return block.id\n",
    "\n",
    "    def emit_leader_block(self, leader, slot):\n",
    "        assert type(leader) in [int, np.int64], type(leader)\n",
    "        assert isinstance(slot, int)\n",
    "\n",
    "        parent = self.fork_choice(leader, slot)\n",
    "        return self.emit_block(\n",
    "            leader,\n",
    "            slot,\n",
    "            height=self.blocks[parent].height + 1,\n",
    "            parent=parent,\n",
    "        )\n",
    "\n",
    "    def fork_choice(self, leader, slot):\n",
    "        assert type(leader) in [int, np.int64], type(leader)\n",
    "        assert isinstance(slot, int)\n",
    "        arrived_blocks = (self.block_arrivals[leader, :len(self.blocks)] <= slot) * self.block_heights[:len(self.blocks)]\n",
    "        concurrent = (arrived_blocks == np.max(arrived_blocks)).nonzero()[0]\n",
    "        return np.random.choice(concurrent)\n",
    "\n",
    "    def plot_spacetime_diagram(self, MAX_SLOT=1000):\n",
    "        alpha_index = sorted(range(self.params.N), key=lambda n: self.params.relative_stake[n])\n",
    "        nodes = [f\"$N_{n}$($\\\\alpha$={self.params.relative_stake[n]:.2f})\" for n in alpha_index]\n",
    "        messages = [(nodes[alpha_index.index(self.blocks[b].leader)], nodes[alpha_index.index(node)], self.blocks[b].slot, arrival_slot, f\"$B_{{{b}}}$\") for b, arrival_slots in enumerate(self.block_arrivals[:,:len(self.blocks)].T) for node, arrival_slot in enumerate(arrival_slots) if arrival_slot < MAX_SLOT]\n",
    "    \n",
    "        fig, ax = plt.subplots(figsize=(8,4))\n",
    "        \n",
    "        # Plot vertical lines for each node\n",
    "        max_slot = max(s for _,_,start_t, end_t,_ in messages for s in [start_t, end_t])\n",
    "        for i, node in enumerate(nodes):\n",
    "            ax.plot([i, i], [0, max_slot], 'k-', linewidth=0.1)\n",
    "            ax.text(i, max_slot + 30 * (0 if i % 2 == 0 else 1), node, ha='center', va='bottom')\n",
    "        \n",
    "        # Plot messages\n",
    "        colors = plt.cm.rainbow(np.linspace(0, 1, len(messages)))\n",
    "        for (start, end, start_time, end_time, label), color in zip(messages, colors):\n",
    "            start_idx = nodes.index(start)\n",
    "            end_idx = nodes.index(end)\n",
    "            ax.annotate('', xy=(end_idx, end_time), xytext=(start_idx, start_time),\n",
    "                        arrowprops=dict(arrowstyle='->', color=\"black\", lw=0.5))\n",
    "            placement = 0\n",
    "            mid_x = start_idx * (1 - placement) + end_idx * placement\n",
    "            mid_y = start_time * (1 - placement) + end_time * placement\n",
    "            ax.text(mid_x, mid_y, label, ha='center', va='center', \n",
    "                    bbox=dict(facecolor='white', edgecolor='none', alpha=0.7))\n",
    "        \n",
    "        ax.set_xlim(-1, len(nodes))\n",
    "        ax.set_ylim(0, max_slot + 70)\n",
    "        ax.set_xticks(range(len(nodes)))\n",
    "        ax.set_xticklabels([])\n",
    "        # ax.set_yticks([])\n",
    "        ax.set_title('Space-Time Diagram')\n",
    "        ax.set_ylabel('Slot')\n",
    "        \n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "\n",
    "    def honest_chain(self):\n",
    "        chain_head = max(self.blocks, key=lambda b: b.height)\n",
    "        honest_chain = {chain_head.id}\n",
    "        \n",
    "        curr_block = chain_head\n",
    "        while curr_block.parent >= 0:\n",
    "            honest_chain.add(curr_block.parent)\n",
    "            curr_block = self.blocks[curr_block.parent]\n",
    "        return sorted(honest_chain, key=lambda b: self.blocks[b].height)\n",
    "\n",
    "    def visualize_chain(self):\n",
    "        honest_chain = self.honest_chain()\n",
    "        print(\"Honest chain length\", len(honest_chain))\n",
    "        honest_chain_set = set(honest_chain)\n",
    "        \n",
    "        layout = Layout()\n",
    "        layout.hierachical = True\n",
    "        \n",
    "        G = Network(width=1600, height=800, notebook=True, directed=True, layout=layout, cdn_resources='in_line')\n",
    "\n",
    "        for block in self.blocks:\n",
    "            # level = slot\n",
    "            level = block.height\n",
    "            color = \"lightgrey\"\n",
    "            if block.id in honest_chain_set:\n",
    "                color = \"orange\"\n",
    "\n",
    "            G.add_node(int(block.id), level=level, color=color, label=f\"{block.id},{block.slot}\")\n",
    "            if block.parent >= 0:\n",
    "                G.add_edge(int(block.id), int(block.parent), width=2, color=color)\n",
    "        \n",
    "        return G.show(\"chain.html\")\n",
    "\n",
    "    def run(self, seed=None):\n",
    "        from collections import defaultdict\n",
    "        timings = defaultdict(float)\n",
    "        start_t = time.time()\n",
    "        if seed is not None:\n",
    "            np.random.seed(seed)\n",
    "\n",
    "        # emit the genesis block\n",
    "        self.emit_block(\n",
    "            leader=0,\n",
    "            slot=0,\n",
    "            height=1,\n",
    "            parent=-1,\n",
    "        )\n",
    "        self.block_arrivals[:,0] = 0 # all nodes see the genesis block\n",
    "\n",
    "        prep_t = time.time()\n",
    "\n",
    "\n",
    "        for s in range(1, self.params.SLOTS):\n",
    "            slot_start_t = time.time()\n",
    "            # the adversary will not participate in the simulation\n",
    "            # (implemented by never delivering blocks to the adversary)\n",
    "            # self.block_arrivals[-1,:] = self.params.SLOTS\n",
    "\n",
    "            self.leaders[:,s] = np.random.random(size=self.params.N) < self.params.slot_prob()\n",
    "            leader_lottery_t = time.time()\n",
    "\n",
    "            for leader in np.nonzero(self.leaders[:,s])[0]:\n",
    "                lead_start_t = time.time()\n",
    "                if self.params.adversary_control is not None and leader == self.params.N - 1:\n",
    "                    continue\n",
    "                \n",
    "                parent = self.fork_choice(leader, s)\n",
    "                fork_choice_t = time.time()\n",
    "                \n",
    "                self.emit_block(\n",
    "                    leader,\n",
    "                    s,\n",
    "                    height=self.blocks[parent].height + 1,\n",
    "                    parent=parent,\n",
    "                )\n",
    "                emit_leader_block_t = time.time()\n",
    "\n",
    "                timings[\"forkchoice\"] += fork_choice_t - lead_start_t\n",
    "                timings[\"emit_leader_block\"] += emit_leader_block_t - fork_choice_t\n",
    "                    \n",
    "                # self.emit_leader_block(leader, s)\n",
    "            slot_end_t = time.time()\n",
    "            timings[\"leader\"] += leader_lottery_t - slot_start_t\n",
    "            timings[\"emit\"] += slot_end_t - leader_lottery_t\n",
    "            timings[\"slot\"] += slot_end_t - slot_start_t\n",
    "\n",
    "        end_t = time.time()\n",
    "        timings[\"prep\"] = prep_t - start_t\n",
    "        timings[\"total\"] = end_t - start_t\n",
    "        for phase, duration in timings.items():\n",
    "            print(f\"{phase}\\t{duration:.2f}s\")\n",
    "\n",
    "    def adverserial_analysis(self, should_plot=False, seed=0, k=2160):\n",
    "        from collections import defaultdict\n",
    "\n",
    "        timings = defaultdict(float)\n",
    "\n",
    "        start_t = time.time()\n",
    "        np.random.seed(seed)\n",
    "        \n",
    "        adversary = self.params.N-1 # adversary is always the last node in our simulations\n",
    "\n",
    "        self.block_arrivals[adversary,:len(self.blocks)] = self.block_slots[:len(self.blocks)] # we will say the adversary receives the blocks immidiately\n",
    "\n",
    "        honest_chain = self.honest_chain()\n",
    "        \n",
    "        honest_chain_t = time.time()\n",
    "        \n",
    "        honest_height_by_slot = np.zeros(self.params.SLOTS, dtype=np.int64)\n",
    "\n",
    "        for block_id in honest_chain:\n",
    "            honest_height_by_slot[self.blocks[block_id].slot] = 1\n",
    "        honest_height_by_slot = honest_height_by_slot.cumsum()\n",
    "        \n",
    "        honest_height_by_slot_t = time.time()\n",
    "        \n",
    "        reorg_depths = []\n",
    "        if should_plot:\n",
    "            plt.figure(figsize=(20, 6))\n",
    "            ax = plt.subplot(121)\n",
    "            advantage = np.zeros(self.params.SLOTS)\n",
    "        \n",
    "        adversary_active_slots = np.random.random(size=self.params.SLOTS) < phi(self.params.f, self.params.relative_stake[adversary])\n",
    "        adversary_cumsum = adversary_active_slots.cumsum()\n",
    "\n",
    "        all_active_slots = (self.leaders.sum(axis=0) + adversary_active_slots) > 0\n",
    "        slot_lookahead = int(3 * k / self.params.f)\n",
    "    \n",
    "        prep_t = time.time()\n",
    "        timings[\"honest_chain\"] += honest_chain_t - start_t\n",
    "        timings[\"honest_height_by_slot\"] += honest_height_by_slot_t - honest_chain_t\n",
    "        timings[\"prep_analysis\"] += prep_t - start_t\n",
    "        for b in range(len(self.blocks)):\n",
    "            block_start_t = time.time()\n",
    "            block = self.blocks[b]\n",
    "            if block.id > 0 and block.id % 5000 == 0:\n",
    "                print(\"Processing block\", block)\n",
    "            \n",
    "            nearest_honest_block = block\n",
    "            while nearest_honest_block.height >= len(honest_chain) or honest_chain[nearest_honest_block.height-1] != nearest_honest_block.id:\n",
    "                nearest_honest_block = self.blocks[nearest_honest_block.parent]\n",
    "\n",
    "            nearest_honest_t = time.time()\n",
    "            \n",
    "            cumulative_rel_height = adversary_cumsum[block.slot+1:block.slot+1 + slot_lookahead] - adversary_cumsum[block.slot]\n",
    "\n",
    "            adverserial_height_by_slot = block.height + cumulative_rel_height\n",
    "\n",
    "            honest_height_by_slot_lookahead = honest_height_by_slot[block.slot + 1:block.slot+1 + slot_lookahead]\n",
    "        \n",
    "            adverserial_wins = adverserial_height_by_slot > honest_height_by_slot_lookahead\n",
    "        \n",
    "            reorg_events = adverserial_wins & all_active_slots[block.slot+1:block.slot+1 + slot_lookahead]\n",
    "\n",
    "                \n",
    "            reorg_events_t = time.time()\n",
    "            reorg_depth = honest_height_by_slot_lookahead[reorg_events] - nearest_honest_block.height\n",
    "            reorg_depth_t = time.time()\n",
    "            reorg_depths += list(reorg_depth)\n",
    "            block_end_t = time.time()\n",
    "            timings[\"nearest_honest\"] += nearest_honest_t - block_start_t\n",
    "            timings[\"reorg_events\"] += reorg_events_t - nearest_honest_t\n",
    "            timings[\"reorg_depth\"] += reorg_depth_t - reorg_events_t\n",
    "            timings[\"depth_append\"] += block_end_t - reorg_depth_t\n",
    "            \n",
    "            if should_plot:\n",
    "                if reorg_events.sum() > 0:\n",
    "                    first_slot = block.slot+1\n",
    "                    last_slot = first_slot + np.nonzero(reorg_events)[0].max() + 1\n",
    "                    advantage[first_slot:last_slot] = np.maximum(advantage[first_slot:last_slot], adverserial_height_by_slot[:last_slot-first_slot]-honest_height_by_slot[first_slot:last_slot])\n",
    "\n",
    "        for phase, duration in timings.items():\n",
    "            print(f\"{phase}\\t{duration:.2f}s\")\n",
    "                    \n",
    "        if should_plot:\n",
    "            ax.plot(advantage, color='k', lw=\"0.5\")\n",
    "            _ = ax.set_title(f\"max chain weight with adversery controlling {self.params.relative_stake[adversary] * 100:.0f}% of stake\")\n",
    "            _ = ax.set_ylabel(\"adversary height advantage\")\n",
    "            _ = ax.set_xlabel(\"slot\")\n",
    "            _ = ax.legend()\n",
    "\n",
    "            ax = plt.subplot(122)\n",
    "            _ = ax.grid(True)\n",
    "            _ = ax.hist(reorg_depths, density=False, bins=100)\n",
    "            _ = ax.set_title(f\"re-org depth with {self.params.relative_stake[adversary] * 100:.0f}% adversary\")\n",
    "            _ = ax.set_xlabel(\"re-org depth\")\n",
    "            _ = ax.set_ylabel(\"frequency\")\n",
    "        return reorg_depths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5f2da916-30a0-4b1d-886f-1bc81c17056e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "leader\t0.02s\n",
      "emit\t0.01s\n",
      "slot\t0.03s\n",
      "forkchoice\t0.00s\n",
      "emit_leader_block\t0.00s\n",
      "prep\t0.00s\n",
      "total\t0.03s\n",
      "avg blocks per slot 0.153\n",
      "Number of blocks 153\n",
      "longest chain 92\n",
      "CPU times: user 25.9 ms, sys: 874 μs, total: 26.8 ms\n",
      "Wall time: 26.3 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "np.random.seed(0)\n",
    "sim = Sim(\n",
    "    params=Params(\n",
    "        SLOTS=1000,\n",
    "        f=1/5,\n",
    "        adversary_control = 0.3,\n",
    "        honest_stake = np.random.pareto(10, 1000)\n",
    "    ),\n",
    "    network=blend_net\n",
    ")\n",
    "sim.run(seed=0)\n",
    "\n",
    "n_blocks_per_slot = len(sim.blocks) / sim.params.SLOTS\n",
    "print(\"avg blocks per slot\", n_blocks_per_slot)\n",
    "print(\"Number of blocks\", len(sim.blocks))\n",
    "print(\"longest chain\", max(b.height for b in sim.blocks))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3130e27c-1ce6-439a-a6e7-436990b9315d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "honest_chain\t0.00s\n",
      "honest_height_by_slot\t0.00s\n",
      "prep_analysis\t0.00s\n",
      "nearest_honest\t0.00s\n",
      "reorg_events\t0.00s\n",
      "reorg_depth\t0.00s\n",
      "depth_append\t0.00s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/private/tmp/nix-shell-78445-0/ipykernel_42604/3345309101.py:280: UserWarning: No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n",
      "  _ = ax.legend()\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_ = sim.adverserial_analysis(should_plot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "13b4392d-d4ab-4b97-a7db-2bede9b3de9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# sim.visualize_chain()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f552a04-a9bf-4723-b6a8-8faaa147762e",
   "metadata": {},
   "source": [
    "# Reorg sensitivity to blending delay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f2bbb618-96c0-4a6d-b1dc-3b73ebafa5e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def reorg_depth_analysis(sim, adv, MAX, **kwargs):\n",
    "    max_depth = min(MAX, max(adv)  if sum(adv) > 0 else 0)\n",
    "    \n",
    "    count_by_depth = np.bincount(adv, minlength=max_depth)[:max_depth]\n",
    "    \n",
    "    # count_by_depth = np.zeros(max_depth)\n",
    "    \n",
    "    # for d in range(max_depth):\n",
    "    #     count_by_depth[d] = (adv == d).sum()\n",
    "\n",
    "    block_time = 1 / sim.params.f\n",
    "    honest_chain_length = len(sim.honest_chain())\n",
    "    blocks = len(sim.blocks)\n",
    "    expected_blocks = sim.params.SLOTS * sim.params.f\n",
    "    plt.plot(np.arange(max_depth), count_by_depth / expected_blocks, **kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9cca2f57-1083-446c-b083-1dd158e0e7ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulating 1/5\n",
      "leader\t0.02s\n",
      "emit\t0.00s\n",
      "slot\t0.02s\n",
      "forkchoice\t0.00s\n",
      "emit_leader_block\t0.00s\n",
      "prep\t0.00s\n",
      "total\t0.02s\n",
      "simulating 2/5\n",
      "leader\t0.02s\n",
      "emit\t0.00s\n",
      "slot\t0.02s\n",
      "forkchoice\t0.00s\n",
      "emit_leader_block\t0.00s\n",
      "prep\t0.00s\n",
      "total\t0.02s\n",
      "simulating 3/5\n",
      "leader\t0.02s\n",
      "emit\t0.00s\n",
      "slot\t0.02s\n",
      "forkchoice\t0.00s\n",
      "emit_leader_block\t0.00s\n",
      "prep\t0.00s\n",
      "total\t0.02s\n",
      "simulating 4/5\n",
      "leader\t0.02s\n",
      "emit\t0.00s\n",
      "slot\t0.02s\n",
      "forkchoice\t0.00s\n",
      "emit_leader_block\t0.00s\n",
      "prep\t0.00s\n",
      "total\t0.02s\n",
      "simulating 5/5\n",
      "leader\t0.03s\n",
      "emit\t0.01s\n",
      "slot\t0.03s\n",
      "forkchoice\t0.00s\n",
      "emit_leader_block\t0.00s\n",
      "prep\t0.00s\n",
      "total\t0.03s\n",
      "finished simulation, starting analysis\n",
      "honest_chain\t0.00s\n",
      "honest_height_by_slot\t0.00s\n",
      "prep_analysis\t0.00s\n",
      "nearest_honest\t0.00s\n",
      "reorg_events\t0.00s\n",
      "reorg_depth\t0.00s\n",
      "depth_append\t0.00s\n",
      "honest_chain\t0.00s\n",
      "honest_height_by_slot\t0.00s\n",
      "prep_analysis\t0.00s\n",
      "nearest_honest\t0.00s\n",
      "reorg_events\t0.00s\n",
      "reorg_depth\t0.00s\n",
      "depth_append\t0.00s\n",
      "honest_chain\t0.00s\n",
      "honest_height_by_slot\t0.00s\n",
      "prep_analysis\t0.00s\n",
      "nearest_honest\t0.00s\n",
      "reorg_events\t0.00s\n",
      "reorg_depth\t0.00s\n",
      "depth_append\t0.00s\n",
      "honest_chain\t0.00s\n",
      "honest_height_by_slot\t0.00s\n",
      "prep_analysis\t0.00s\n",
      "nearest_honest\t0.00s\n",
      "reorg_events\t0.00s\n",
      "reorg_depth\t0.00s\n",
      "depth_append\t0.00s\n",
      "honest_chain\t0.00s\n",
      "honest_height_by_slot\t0.00s\n",
      "prep_analysis\t0.00s\n",
      "nearest_honest\t0.00s\n",
      "reorg_events\t0.00s\n",
      "reorg_depth\t0.00s\n",
      "depth_append\t0.00s\n",
      "CPU times: user 116 ms, sys: 5.15 ms, total: 121 ms\n",
      "Wall time: 117 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "np.random.seed(0)\n",
    "stake = np.random.pareto(10, 100)\n",
    "SLOTS = 2000\n",
    "\n",
    "\n",
    "sims = [Sim(\n",
    "    params=Params(\n",
    "        SLOTS=SLOTS,\n",
    "        f=1/30,\n",
    "        adversary_control = 0.3,\n",
    "        honest_stake = stake\n",
    "    ),\n",
    "    network=replace(blend_net, blending_delay=i),\n",
    ") for i in [1,2,3,5]]\n",
    "sims += [Sim(\n",
    "    params=Params(\n",
    "        SLOTS=int(SLOTS * 3/2),\n",
    "        f=1/20,\n",
    "        adversary_control = 0.3,\n",
    "        honest_stake = stake\n",
    "    ),\n",
    "    network=replace(blend_net, blend_hops=0),\n",
    ")]\n",
    "\n",
    "for i, sim in enumerate(sims):\n",
    "    print(f\"simulating {i+1}/{len(sims)}\")\n",
    "    sim.run(seed=0)\n",
    "\n",
    "print(\"finished simulation, starting analysis\")\n",
    "advs = [sim.adverserial_analysis(should_plot=False) for sim in sims]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1ff938f3-6bc4-4b8e-bd9a-492db140d7b9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "MAX=min(40, max(max(adv) for adv in advs))\n",
    "\n",
    "for s in range(len(sims) - 1):\n",
    "    reorg_depth_analysis(sims[s], advs[s], MAX, label=f\"blending_delay={sims[s].network.blending_delay}s\")\n",
    "\n",
    "reorg_depth_analysis(sims[-1], advs[-1], MAX, label=f\"cardano\")\n",
    "\n",
    "_ = plt.title(f\"reorg depth sensitivity to blend network delay @ {1/sims[s].params.f:.0f}s block time\")\n",
    "_ = plt.xlabel(\"reorg depth\")\n",
    "_ = plt.ylabel(\"frequency\")\n",
    "_ = plt.legend()\n",
    "_ = plt.yscale(\"log\")\n",
    "_ = plt.xlim(0, MAX)\n",
    "_ = plt.ylim(10**-4,None)\n",
    "# _ = plt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "8c9a369c-2d55-4c07-8bfe-9e270cfed90a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulating 1/1\n",
      "leader\t57.11s\n",
      "emit\t19.70s\n",
      "slot\t76.81s\n",
      "forkchoice\t10.89s\n",
      "emit_leader_block\t1.81s\n",
      "prep\t0.00s\n",
      "total\t78.08s\n",
      "finished simulation, starting analysis\n",
      "Processing block Block(id=5000, slot=252236, height=4539, parent=np.int64(4999), leader=np.int64(93))\n",
      "Processing block Block(id=10000, slot=497006, height=9067, parent=np.int64(9999), leader=np.int64(58))\n",
      "Processing block Block(id=15000, slot=750959, height=13619, parent=np.int64(14999), leader=np.int64(70))\n",
      "Processing block Block(id=20000, slot=991659, height=18134, parent=np.int64(19999), leader=np.int64(6))\n",
      "Processing block Block(id=25000, slot=1239863, height=22728, parent=np.int64(24999), leader=np.int64(17))\n",
      "Processing block Block(id=30000, slot=1489285, height=27277, parent=np.int64(29999), leader=np.int64(37))\n",
      "Processing block Block(id=35000, slot=1728486, height=31815, parent=np.int64(34999), leader=np.int64(19))\n",
      "Processing block Block(id=40000, slot=1974391, height=36342, parent=np.int64(39999), leader=np.int64(27))\n",
      "Processing block Block(id=45000, slot=2226173, height=40923, parent=np.int64(44999), leader=np.int64(84))\n",
      "Processing block Block(id=50000, slot=2472896, height=45468, parent=np.int64(49999), leader=np.int64(4))\n",
      "Processing block Block(id=55000, slot=2719213, height=50014, parent=np.int64(54999), leader=np.int64(7))\n",
      "Processing block Block(id=60000, slot=2970718, height=54585, parent=np.int64(59999), leader=np.int64(72))\n",
      "Processing block Block(id=65000, slot=3215235, height=59149, parent=np.int64(64999), leader=np.int64(72))\n",
      "Processing block Block(id=70000, slot=3457637, height=63640, parent=np.int64(69999), leader=np.int64(78))\n",
      "Processing block Block(id=75000, slot=3699174, height=68173, parent=np.int64(74999), leader=np.int64(22))\n",
      "Processing block Block(id=80000, slot=3941265, height=72702, parent=np.int64(79999), leader=np.int64(7))\n",
      "Processing block Block(id=85000, slot=4187929, height=77245, parent=np.int64(84999), leader=np.int64(91))\n",
      "Processing block Block(id=90000, slot=4436329, height=81777, parent=np.int64(89999), leader=np.int64(89))\n",
      "Processing block Block(id=95000, slot=4686901, height=86332, parent=np.int64(94999), leader=np.int64(72))\n",
      "Processing block Block(id=100000, slot=4937060, height=90886, parent=np.int64(99998), leader=np.int64(10))\n",
      "Processing block Block(id=105000, slot=5187093, height=95442, parent=np.int64(104999), leader=np.int64(7))\n",
      "Processing block Block(id=110000, slot=5435079, height=100002, parent=np.int64(109999), leader=np.int64(94))\n",
      "Processing block Block(id=115000, slot=5681958, height=104546, parent=np.int64(114999), leader=np.int64(44))\n",
      "Processing block Block(id=120000, slot=5930287, height=109073, parent=np.int64(119999), leader=np.int64(20))\n",
      "Processing block Block(id=125000, slot=6175270, height=113641, parent=np.int64(124999), leader=np.int64(98))\n",
      "Processing block Block(id=130000, slot=6421564, height=118182, parent=np.int64(129999), leader=np.int64(72))\n",
      "Processing block Block(id=135000, slot=6664531, height=122701, parent=np.int64(134999), leader=np.int64(75))\n",
      "Processing block Block(id=140000, slot=6911274, height=127268, parent=np.int64(139998), leader=np.int64(70))\n",
      "honest_chain\t0.03s\n",
      "honest_height_by_slot\t0.03s\n",
      "prep_analysis\t0.47s\n",
      "nearest_honest\t0.04s\n",
      "reorg_events\t25.89s\n",
      "reorg_depth\t2.07s\n",
      "depth_append\t0.09s\n",
      "cardano parameters\n",
      "simulating 1/1\n",
      "leader\t33.10s\n",
      "emit\t15.78s\n",
      "slot\t48.89s\n",
      "forkchoice\t10.64s\n",
      "emit_leader_block\t1.07s\n",
      "prep\t0.00s\n",
      "total\t49.62s\n",
      "Processing block Block(id=5000, slot=135809, height=4899, parent=np.int64(4999), leader=np.int64(70))\n",
      "Processing block Block(id=10000, slot=274084, height=9765, parent=np.int64(9999), leader=np.int64(8))\n",
      "Processing block Block(id=15000, slot=409830, height=14646, parent=np.int64(14998), leader=np.int64(56))\n",
      "Processing block Block(id=20000, slot=549207, height=19525, parent=np.int64(19999), leader=np.int64(25))\n",
      "Processing block Block(id=25000, slot=691610, height=24421, parent=np.int64(24999), leader=np.int64(31))\n",
      "Processing block Block(id=30000, slot=831456, height=29315, parent=np.int64(29999), leader=np.int64(60))\n",
      "Processing block Block(id=35000, slot=970659, height=34209, parent=np.int64(34999), leader=np.int64(98))\n",
      "Processing block Block(id=40000, slot=1111676, height=39085, parent=np.int64(39999), leader=np.int64(49))\n",
      "Processing block Block(id=45000, slot=1253865, height=43968, parent=np.int64(44999), leader=np.int64(35))\n",
      "Processing block Block(id=50000, slot=1395147, height=48859, parent=np.int64(49999), leader=np.int64(77))\n",
      "Processing block Block(id=55000, slot=1533614, height=53745, parent=np.int64(54999), leader=np.int64(83))\n",
      "Processing block Block(id=60000, slot=1672035, height=58644, parent=np.int64(59999), leader=np.int64(44))\n",
      "Processing block Block(id=65000, slot=1810562, height=63514, parent=np.int64(64999), leader=np.int64(23))\n",
      "Processing block Block(id=70000, slot=1947908, height=68389, parent=np.int64(69999), leader=np.int64(56))\n",
      "Processing block Block(id=75000, slot=2090314, height=73280, parent=np.int64(74999), leader=np.int64(89))\n",
      "Processing block Block(id=80000, slot=2229797, height=78164, parent=np.int64(79999), leader=np.int64(66))\n",
      "Processing block Block(id=85000, slot=2370038, height=83058, parent=np.int64(84999), leader=np.int64(28))\n",
      "Processing block Block(id=90000, slot=2506490, height=87933, parent=np.int64(89999), leader=np.int64(38))\n",
      "Processing block Block(id=95000, slot=2645547, height=92812, parent=np.int64(94999), leader=np.int64(7))\n",
      "Processing block Block(id=100000, slot=2782969, height=97689, parent=np.int64(99999), leader=np.int64(89))\n",
      "Processing block Block(id=105000, slot=2923375, height=102592, parent=np.int64(104999), leader=np.int64(66))\n",
      "Processing block Block(id=110000, slot=3065575, height=107487, parent=np.int64(109999), leader=np.int64(98))\n",
      "Processing block Block(id=115000, slot=3207434, height=112370, parent=np.int64(114999), leader=np.int64(86))\n",
      "Processing block Block(id=120000, slot=3344800, height=117256, parent=np.int64(119999), leader=np.int64(89))\n",
      "Processing block Block(id=125000, slot=3482447, height=122160, parent=np.int64(124999), leader=np.int64(84))\n",
      "Processing block Block(id=130000, slot=3622630, height=127033, parent=np.int64(129999), leader=np.int64(39))\n",
      "Processing block Block(id=135000, slot=3764919, height=131937, parent=np.int64(134999), leader=np.int64(19))\n",
      "Processing block Block(id=140000, slot=3903845, height=136842, parent=np.int64(139999), leader=np.int64(6))\n",
      "honest_chain\t0.03s\n",
      "honest_height_by_slot\t0.02s\n",
      "prep_analysis\t0.29s\n",
      "nearest_honest\t0.03s\n",
      "reorg_events\t9.82s\n",
      "reorg_depth\t1.20s\n",
      "depth_append\t0.08s\n",
      "CPU times: user 2min 36s, sys: 10.8 s, total: 2min 47s\n",
      "Wall time: 2min 47s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "PATHS = 1\n",
    "target_block_num = 2000\n",
    "np.random.seed(0)\n",
    "stake = np.random.pareto(10, 100)\n",
    "network = blend_net\n",
    "sim_params = Params(\n",
    "    SLOTS=0,\n",
    "    f=0.05,\n",
    "    adversary_control = 0.3,\n",
    "    honest_stake = stake\n",
    ")\n",
    "np.random.seed(1)\n",
    "sims = [Sim(\n",
    "    params=replace(\n",
    "        sim_params,\n",
    "        SLOTS=int(target_block_num * block_time),\n",
    "        f=1/block_time\n",
    "    ),\n",
    "    network=network\n",
    ") for block_time in np.array([35]).repeat(PATHS)]\n",
    "\n",
    "\n",
    "for i, sim in enumerate(sims):\n",
    "    print(f\"simulating {i+1}/{len(sims)}\")\n",
    "    sim.run(seed=i)\n",
    "\n",
    "print(\"finished simulation, starting analysis\")\n",
    "advs = [sim.adverserial_analysis() for sim in sims]\n",
    "\n",
    "print(\"cardano parameters\")\n",
    "cardano_block_time = 20\n",
    "cardano_sims = [Sim(\n",
    "    params=replace(\n",
    "        sim_params,\n",
    "        SLOTS=int(target_block_num * cardano_block_time),\n",
    "        f=1/cardano_block_time,\n",
    "    ),\n",
    "    network=replace(network, blend_hops=0)\n",
    ") for _ in range(PATHS)]\n",
    "\n",
    "for i, sim in enumerate(cardano_sims):\n",
    "    print(f\"simulating {i+1}/{len(cardano_sims)}\")\n",
    "    sim.run(seed=i)\n",
    "\n",
    "cardano_advs = [sim.adverserial_analysis() for sim in cardano_sims]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "5f47f6b7-f2bd-4db4-a6a8-358d2081820c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAX 30\n",
      "cutoff 30\n",
      "CPU times: user 28.7 ms, sys: 1.05 ms, total: 29.7 ms\n",
      "Wall time: 28.7 ms\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%time\n",
    "i = 0\n",
    "j = 0\n",
    "expected_blocks_nomos = sims[i].params.SLOTS * sims[i].params.f\n",
    "expected_blocks_cardano = cardano_sims[j].params.SLOTS * cardano_sims[j].params.f\n",
    "\n",
    "MAX = max(max(adv) for adv in (advs + cardano_advs))\n",
    "print(\"MAX\", MAX)\n",
    "hist_nomos = np.bincount(advs[0], minlength=MAX)\n",
    "hist_cardano = np.bincount(cardano_advs[0], minlength=MAX)\n",
    "\n",
    "cutoff = min(min(np.where(hist_nomos == 0)[0], default=MAX), min(np.where(hist_cardano == 0)[0], default=MAX))\n",
    "print(\"cutoff\", cutoff)\n",
    "\n",
    "plt.plot(np.arange(cutoff), (hist_nomos[:cutoff] / expected_blocks_nomos) / (hist_cardano[:cutoff] /  expected_blocks_cardano))\n",
    "plt.ylabel(\"Multiple Increase in Reorgs\")\n",
    "plt.xlabel(\"Reorg Depth\")\n",
    "plt.title(\"Plotting the ratio $\\\\frac{\\\\text{Nomos reorgs}}{\\\\text{Caradano reorgs}}$\")\n",
    "None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "87c8d0b8-c8d2-4c49-a9c4-2eaefd41c254",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 / 1\n",
      "CPU times: user 274 ms, sys: 10.6 ms, total: 285 ms\n",
      "Wall time: 284 ms\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%time\n",
    "k = 2160\n",
    "MAX=min(k, max(max(adv) for adv in advs))\n",
    "network_samples = network.empirical_network_delay()\n",
    "network_delay_mean = network_samples.mean()\n",
    "f_index = list({s.params.f for s in sims})\n",
    "hops_index = list({s.network.blend_hops for s in sims})\n",
    "delay_index = list({s.network.blending_delay for s in sims})\n",
    "colors = ['#855C75FF', '#D9AF6BFF', '#AF6458FF', '#736F4CFF', '#526A83FF', '#625377FF', '#68855CFF', '#9C9C5EFF', '#A06177FF', '#8C785DFF', '#467378FF', '#7C7C7CFF']\n",
    "\n",
    "for s in range(len(sims)):\n",
    "    print(f'{s+1} / {len(sims)}')\n",
    "    block_time = 1 / sims[s].params.f\n",
    "    c = colors[f_index.index(sims[s].params.f)]\n",
    "    # c = colors[hops_index.index(sims[s].network.blend_hops)]\n",
    "    # c = colors[delay_index.index(sims[s].network.blending_delay)]\n",
    "    reorg_depth_analysis(sims[s], advs[s], MAX, color=c, lw=\"1\", label=f\"{block_time:.1f}s ~ {block_time / network_delay_mean:.0f}x net delay\")\n",
    "    # reorg_depth_analysis(sims[s], advs[s], MAX, color=c, lw=\"1\", label=f\"hops={sims[s].network.blend_hops}\")\n",
    "    # reorg_depth_analysis(sims[s], advs[s], MAX, color=c, lw=\"1\", label=f\"blending delay={sims[s].network.blending_delay}\")\n",
    "\n",
    "\n",
    "for s in range(len(cardano_sims)):\n",
    "    reorg_depth_analysis(cardano_sims[s], cardano_advs[s], MAX, lw=\"1\", color=\"k\", label=f\"cardano\")\n",
    "\n",
    "_ = plt.title(f\"reorg depth sensitivity\")\n",
    "_ = plt.xlabel(\"reorg depth\")\n",
    "_ = plt.ylabel(\"frequency (per block)\")\n",
    "_ = plt.yscale(\"log\")\n",
    "_ = plt.xlim(0, MAX)\n",
    "_ = plt.ylim(10**-4,None)\n",
    "\n",
    "# avoid duplicate legend entries with the same label\n",
    "handles, labels = plt.gca().get_legend_handles_labels()\n",
    "by_label = dict(zip(labels, handles))\n",
    "_ = plt.legend(by_label.values(), by_label.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "fdc9ae28-5c4f-4ffd-a090-ae7a7225ec4c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "N = 100\n",
    "M = 10000\n",
    "no_blend_samples = no_blend_net.empirical_network_delay()\n",
    "no_blend_mean = no_blend_samples.mean()\n",
    "blend_samples = blend_net.empirical_network_delay()\n",
    "blend_mean = blend_samples.mean()\n",
    "\n",
    "_ = plt.hist(no_blend_samples, bins=100, density=True, label=\"no-blend\")\n",
    "_ = plt.hist(blend_samples, bins=100, density=True, label=\"blend\")\n",
    "\n",
    "for p in [50, 99, 99.9]:\n",
    "    no_blend_pct = np.percentile(no_blend_samples, p)\n",
    "    _ = plt.vlines(no_blend_pct, ymin=0, ymax=0.25, color='darkblue', label=f\"no-blend {p}p={no_blend_pct:.1f}s\")\n",
    "\n",
    "for p in [50, 99, 99.9]:\n",
    "    blend_pct = np.percentile(blend_samples, p)\n",
    "    _ = plt.vlines(blend_pct, ymin=0, ymax=0.25, color='brown', label=f\"blend {p}p={blend_pct:.1f}s\")\n",
    "# _ = plt.vlines(blend_mean, ymin=0, ymax=1, color='brown', label=f\"blend 50p={blend_mean:.1f}s\")\n",
    "# _ = plt.hist(blend_net.block_arrival_slot(np.zeros(1000)), bins=100, density=True, label=\"blend\")\n",
    "_ = plt.legend()\n",
    "_ = plt.xlabel(\"block delay\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa860b3d-6cb1-4ee5-a534-ab6fe4440a46",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "48350036-439a-4954-9021-e55b7b5f004a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "efdd3166-892f-4f0e-b80f-ba279e3a02f2",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}