nomos-pocs/cryptarchia/weighted-cryptarchia.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "ad657d5a-bd36-4329-b134-6745daff7ae9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from dataclasses import dataclass\n",
    "from pyvis.network import Network\n",
    "from pyvis.options import Layout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "a9e0b910-c633-4dbe-827c-4ddb804f7a9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def phi(f, alpha):\n",
    "    return 1 - (1-f)**alpha"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "id": "aa0aadce-a0be-4873-ba23-293be74db313",
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class Block:\n",
    "    id: int\n",
    "    slot: int\n",
    "    height: int\n",
    "    weight: int\n",
    "    parent: int\n",
    "    refs: list[int]\n",
    "    leader: int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "id": "a538cf45-d551-4603-b484-dbbc3f3d0a73",
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class NetworkParams:\n",
    "    mixnet_delay_mean: int # seconds\n",
    "    mixnet_delay_var: int\n",
    "    broadcast_delay_mean: int # second\n",
    "    pol_proof_time: int # seconds\n",
    "    no_network_delay: bool = False\n",
    "\n",
    "    def sample_mixnet_delay(self):\n",
    "        scale = self.mixnet_delay_var / self.mixnet_delay_mean\n",
    "        shape = self.mixnet_delay_mean / scale\n",
    "        return np.random.gamma(shape=shape, scale=scale)\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "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": 269,
   "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",
    "        self.block_slots = np.array([], dtype=np.int64)\n",
    "        self.block_weights = np.array([], dtype=np.int64)\n",
    "        self.block_heights = np.array([], dtype=np.int64)\n",
    "        self.block_arrivals = np.zeros(shape=(params.N, 0), dtype=np.int64) # arrival time to each leader for each block\n",
    "\n",
    "        # emit the genesis block\n",
    "        self.emit_block(\n",
    "            leader=0,\n",
    "            slot=0,\n",
    "            height=1,\n",
    "            weight=1,\n",
    "            parent=-1,\n",
    "            refs=[]\n",
    "        )\n",
    "        self.block_arrivals[:,:] = 0 # all nodes see the genesis block\n",
    "\n",
    "    def emit_block(self, leader, slot, weight, height, parent, refs):\n",
    "        assert type(leader) in [int, np.int64]\n",
    "        assert type(slot) in [int, np.int64]\n",
    "        assert type(weight) in [int, np.int64]\n",
    "        assert type(height) in [int, np.int64]\n",
    "        assert type(parent) in [int, np.int64]\n",
    "        assert all(type(r) in [int, np.int64] for r in refs)\n",
    "\n",
    "        block = Block(\n",
    "            id=len(self.blocks),\n",
    "            slot=slot,\n",
    "            weight=weight,\n",
    "            height=height,\n",
    "            parent=parent,\n",
    "            refs=refs,\n",
    "            leader=leader,\n",
    "        )\n",
    "        self.blocks.append(block)\n",
    "        self.block_slots = np.append(self.block_slots, block.slot)\n",
    "        self.block_weights = np.append(self.block_weights, block.weight)\n",
    "        self.block_heights = np.append(self.block_heights, 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 = np.append(self.block_arrivals, new_block_arrival_by_node.reshape((self.params.N, 1)), axis=1)\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",
    "    \n",
    "        refs = self.select_refs(leader, parent, slot)\n",
    "        return self.emit_block(\n",
    "            leader,\n",
    "            slot,\n",
    "            weight=self.blocks[parent].weight + len(refs) + 1,\n",
    "            height=self.blocks[parent].height + 1,\n",
    "            parent=parent,\n",
    "            refs=refs\n",
    "        )\n",
    "\n",
    "    def fork_choice(self, node, slot) -> id:\n",
    "        assert type(node) in [int, np.int64], type(node)\n",
    "        assert isinstance(slot, int)\n",
    "\n",
    "        arrived_blocks = self.block_arrivals[node] <= slot\n",
    "        return (self.block_weights*arrived_blocks).argmax()\n",
    "\n",
    "    def select_refs(self, node: int, parent: int, slot: int) -> list[id]:\n",
    "        assert type(node) in [int, np.int64], node\n",
    "        assert type(parent) in [int, np.int64], parent\n",
    "        assert type(slot) in [int, np.int64], slot\n",
    "        assert parent != -1\n",
    "\n",
    "        parents_siblings = [s for s in self.block_siblings(node, parent, slot) if s != parent]\n",
    "        # we are uniformly sampling from power_set(forks)\n",
    "        return list(np.array(parents_siblings)[np.random.uniform(size=len(parents_siblings)) < 0.5])\n",
    "\n",
    "    \n",
    "    def block_siblings(self, node, block, slot):\n",
    "        blocks_seen_by_node = self.block_arrivals[node,:] <= slot\n",
    "        parent = self.blocks[block].parent\n",
    "        if parent == -1:\n",
    "            return [block]\n",
    "        successor_blocks = self.block_slots > self.blocks[parent].slot\n",
    "        candidate_siblings = np.nonzero(blocks_seen_by_node & successor_blocks)[0]\n",
    "        return [b for b in candidate_siblings if self.blocks[b].parent == parent]\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[:-1,:].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",
    "\n",
    "    def honest_chain(self):\n",
    "        chain_head = max(self.blocks, key=lambda b: b.weight)\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].weight)\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.weight\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}:s={block.slot},w={block.weight},refs={block.refs}\")\n",
    "            if block.parent >= 0:\n",
    "                G.add_edge(int(block.id), int(block.parent), width=2, color=color)\n",
    "            for ref in block.refs:\n",
    "                G.add_edge(int(block.id), int(ref), width=1, color=\"blue\")\n",
    "                \n",
    "        \n",
    "        return G.show(\"chain.html\")\n",
    "\n",
    "    def run(self, seed=None):\n",
    "        if seed is not None:\n",
    "            np.random.seed(seed)\n",
    "        \n",
    "        for s in range(1, self.params.SLOTS):\n",
    "            if s > 0 and s % 100000 == 0:\n",
    "                print(f\"SIM={s}/{self.params.SLOTS}, blocks={len(self.blocks)}\")\n",
    "    \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",
    "            for leader in np.nonzero(self.leaders[:,s])[0]:\n",
    "                if self.params.adversary_control is not None and leader == self.params.N - 1:\n",
    "                    continue\n",
    "                self.emit_leader_block(\n",
    "                    leader,\n",
    "                    s,\n",
    "                )\n",
    "\n",
    "    def adverserial_analysis(self, should_plot=True, seed=0):\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,:] = self.block_slots # we will say the adversary receives the blocks immidiately\n",
    "\n",
    "\n",
    "        \n",
    "        honest_weight_by_slot = np.zeros(self.params.SLOTS, dtype=np.int64)\n",
    "        honest_height_by_slot = np.zeros(self.params.SLOTS, dtype=np.int64)\n",
    "        for block in self.blocks:\n",
    "            block_weight = np.zeros(self.params.SLOTS, dtype=np.int64) + block.weight\n",
    "            block_weight[:block.slot] = 0\n",
    "            honest_weight_by_slot = np.maximum(block_weight, honest_weight_by_slot)\n",
    "            \n",
    "            block_height = np.zeros(self.params.SLOTS, dtype=np.int64) + block.height\n",
    "            block_height[:block.slot] = 0\n",
    "            honest_height_by_slot = np.maximum(block_height, honest_height_by_slot)\n",
    "        \n",
    "        for slot in range(1, self.params.SLOTS):\n",
    "            if honest_weight_by_slot[slot] == 0:\n",
    "                honest_weight_by_slot[slot] = honest_weight_by_slot[slot-1]\n",
    "            if honest_height_by_slot[slot] == 0:\n",
    "                honest_height_by_slot[slot] = honest_height_by_slot[slot-1]\n",
    "\n",
    "        \n",
    "        honest_chain = self.honest_chain()\n",
    "        \n",
    "        reorg_hist = np.zeros(self.params.SLOTS, dtype=np.int64)\n",
    "        reorg_depths = np.array([], dtype=np.int64)\n",
    "\n",
    "        if should_plot:\n",
    "            plt.figure(figsize=(20, 6))\n",
    "            ax = plt.subplot(121)\n",
    "        \n",
    "        adversary_active_slots = np.random.random(size=self.params.SLOTS) < phi(self.params.f, self.params.relative_stake[adversary])\n",
    "        all_active_slots = (self.leaders.sum(axis=0) + adversary_active_slots) > 0\n",
    "\n",
    "        for block in self.blocks:\n",
    "            if block.id > 0 and block.id % 1000 == 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",
    "            cumulative_rel_height = adversary_active_slots[block.slot+1:].cumsum()\n",
    "            refs = self.select_refs(adversary, block.id, slot=self.params.SLOTS)\n",
    "\n",
    "            assert len(refs) == 0\n",
    "\n",
    "            adverserial_weight_by_slot = block.weight + len(refs) + cumulative_rel_height\n",
    "        \n",
    "            adverserial_wins = adverserial_weight_by_slot > honest_weight_by_slot[block.slot + 1:]\n",
    "        \n",
    "            reorg_events = adverserial_wins & all_active_slots[block.slot+1:]\n",
    "            reorg_depths = np.append(reorg_depths, honest_height_by_slot[block.slot + 1:][reorg_events] - nearest_honest_block.height)\n",
    "            reorg_hist += np.append(np.zeros(block.slot, dtype=np.int64), adverserial_wins).sum(axis=0)\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",
    "\n",
    "                    ax.plot(np.arange(first_slot, last_slot), adverserial_weight_by_slot[:last_slot-first_slot]-honest_weight_by_slot[first_slot:last_slot], lw=\"1\")\n",
    "                    for event in np.nonzero(reorg_events)[0]:\n",
    "                        plt.axvline(x = event + block.slot + 1, ymin = 0, ymax = 1, color ='red', lw=0.01)\n",
    "        \n",
    "\n",
    "        if should_plot:\n",
    "            ax.plot(np.zeros(self.params.SLOTS), color=\"k\", label=f\"honest chain\")\n",
    "            _ = ax.set_title(f\"max chain weight with adversery controlling {self.params.relative_stake[adversary] * 100:.0f}% of stake\")\n",
    "            _ = ax.set_ylabel(\"weight 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",
    "\n",
    "        return reorg_depths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "id": "d7eef71a-aa3c-49df-a711-9c9f7f5cb4a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "avg blocks per slot 0.03625\n",
      "Number of blocks 3625\n",
      "longest chain 3625\n",
      "CPU times: user 4.24 s, sys: 3.48 s, total: 7.72 s\n",
      "Wall time: 7.95 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "np.random.seed(0)\n",
    "sim = Sim(\n",
    "    params=Params(\n",
    "        SLOTS=100000,\n",
    "        f=0.05,\n",
    "        adversary_control = 0.3,\n",
    "        honest_stake = np.random.pareto(10, 1000)\n",
    "    ),\n",
    "    network=NetworkParams(\n",
    "        mixnet_delay_mean=10, # seconds\n",
    "        mixnet_delay_var=4,\n",
    "        broadcast_delay_mean=2, # second\n",
    "        pol_proof_time=2, # seconds\n",
    "        no_network_delay=True\n",
    "    )\n",
    ")\n",
    "sim.run(seed=5)\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": 271,
   "id": "6680bc4d-39b9-4c9c-909f-da52f78295eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# sim.plot_spacetime_diagram()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "id": "aabccc4e-8f47-403e-b7f9-7508e93ec18b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# sim.visualize_chain()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "id": "c5e14de5-7ff2-44e8-b825-8e6aa97f6e99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing block Block(id=1000, slot=27702, height=1001, weight=1001, parent=999, refs=[], leader=453)\n",
      "Processing block Block(id=2000, slot=55437, height=2001, weight=2001, parent=1999, refs=[], leader=316)\n",
      "Processing block Block(id=3000, slot=82902, height=3001, weight=3001, parent=2999, refs=[], leader=595)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "reorgs = sim.adverserial_analysis()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "id": "0bdf3ada-059a-4145-bb12-8a15d022bb9f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.01013\n"
     ]
    }
   ],
   "source": [
    "print(len(reorgs[reorgs > 10]) / sim.params.SLOTS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "467972af-de30-4a5d-9e62-f8e17a7f9813",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulating 1/10\n",
      "simulating 2/10\n",
      "simulating 3/10\n",
      "simulating 4/10\n",
      "simulating 5/10\n",
      "simulating 6/10\n",
      "simulating 7/10\n",
      "simulating 8/10\n",
      "simulating 9/10\n",
      "simulating 10/10\n",
      "finished simulation, starting analysis\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "stake = np.random.pareto(10, 100)\n",
    "\n",
    "sims = [Sim(\n",
    "    params=Params(\n",
    "        SLOTS=100000,\n",
    "        f=0.05,\n",
    "        adversary_control = i,\n",
    "        honest_stake = stake\n",
    "    ),\n",
    "    network=NetworkParams(\n",
    "        mixnet_delay_mean=10, # seconds\n",
    "        mixnet_delay_var=4,\n",
    "        broadcast_delay_mean=2, # second\n",
    "        pol_proof_time=10, # seconds\n",
    "        no_network_delay=False\n",
    "    )\n",
    ") for i in np.linspace(1e-3, 0.3, 10)]\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": 11,
   "id": "a8a2f501-aa97-4a80-8206-1a5862006ebc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 4000x4000 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "max_reorg_depth = max(a.max() if len(a) > 0 else 0 for a in advs)\n",
    "\n",
    "\n",
    "heatmap = np.zeros((len(advs), max_reorg_depth), dtype=np.int64)\n",
    "\n",
    "for i,  adv in enumerate(advs):\n",
    "    for depth in range(max_reorg_depth):\n",
    "        heatmap[i][depth] = (adv == depth).sum()\n",
    "\n",
    "plt.figure(figsize=(40,40))\n",
    "ax = plt.subplot(121)\n",
    "im = ax.imshow(heatmap)\n",
    "\n",
    "_ = ax.set_yticks(np.arange(len(sims)), labels=[f\"{s.params.adversary_control:.2f}\" if i % 2 == (len(sims) - 1) % 2 else None for i, s in enumerate(sims)])\n",
    "_ = ax.set_xticks(np.arange(max_reorg_depth), labels=[r if r % (max_reorg_depth // 10) == 0 else None for r in range(max_reorg_depth)])\n",
    "_ = ax.set_xlabel(\"reorg depth\")\n",
    "_ = ax.set_ylabel(\"adversary stake\")\n",
    "\n",
    "ax = plt.subplot(1,10,6)\n",
    "scale = heatmap.max()\n",
    "ax.imshow(np.arange(scale+1).reshape((1, scale+1)).T, extent=(1,0,1,0))\n",
    "_ = ax.set_yticks(np.arange(scale+1) / scale, labels = [r if r % (scale // 10) == 0 else None for r in range(scale+1)])\n",
    "_ = ax.set_xticks([], minor=False)\n",
    "_ = ax.set_ylabel(\"frequency\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9b9cf70-3849-4b3d-9110-a6779df8c83f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36dd222a-cdf6-4fc9-8ca5-6d7acffa153f",
   "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}