{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reasoning by Superposition: A Theoretical Perspective on Chain of Continuous Thought"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This interactive notebook illustrates how the Coconut model leverages superposition states for reasoning. We visualize the attention patterns from the first and second transformer layers, and compute the inner products between continuous thoughts and node embeddings to reveal how information propagates and accumulates during inference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# preparation\n",
    "import argparse\n",
    "from transformers import AutoModelForCausalLM, AutoConfig\n",
    "import torch\n",
    "from coconut import Coconut\n",
    "from stokenizer import STokenizer\n",
    "import matplotlib.pyplot as plt\n",
    "import json\n",
    "import random   \n",
    "import numpy as np\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from huggingface_hub import hf_hub_download\n",
    "\n",
    "print(\"loading weights\")\n",
    "checkpoint_path = hf_hub_download(\n",
    "    repo_id=\"Shibo-UCSD/coconut-theory\",\n",
    "    filename=\"checkpoint_300\"\n",
    ")\n",
    "# note that this checkpoint is only an example to visualize the reasoning pattern.\n",
    "# it doesn't precisely reproduce the reported accuracy on ProsQA."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "saved_weights = torch.load(\n",
    "    checkpoint_path, \n",
    "    map_location=torch.device(\"cuda:0\")\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<All keys matched successfully>\n",
      "evaluating\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "GPT2LMHeadModel(\n",
       "  (transformer): GPT2Model(\n",
       "    (wte): Embedding(40, 768)\n",
       "    (wpe): Embedding(1024, 768)\n",
       "    (drop): Dropout(p=0.1, inplace=False)\n",
       "    (h): ModuleList(\n",
       "      (0-1): 2 x GPT2Block(\n",
       "        (ln_1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)\n",
       "        (attn): GPT2Attention(\n",
       "          (c_attn): Conv1D(nf=2304, nx=768)\n",
       "          (c_proj): Conv1D(nf=768, nx=768)\n",
       "          (attn_dropout): Dropout(p=0.1, inplace=False)\n",
       "          (resid_dropout): Dropout(p=0.1, inplace=False)\n",
       "        )\n",
       "        (ln_2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)\n",
       "        (mlp): GPT2MLP(\n",
       "          (c_fc): Conv1D(nf=3072, nx=768)\n",
       "          (c_proj): Conv1D(nf=768, nx=3072)\n",
       "          (act): NewGELUActivation()\n",
       "          (dropout): Dropout(p=0.1, inplace=False)\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "    (ln_f): LayerNorm((768,), eps=1e-05, elementwise_affine=True)\n",
       "  )\n",
       "  (lm_head): Linear(in_features=768, out_features=40, bias=False)\n",
       ")"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# loading the model\n",
    "\n",
    "tokenizer = STokenizer()\n",
    "latent_id = tokenizer.convert_tokens_to_ids(\"<|latent|>\")\n",
    "\n",
    "model = AutoModelForCausalLM.from_config(\n",
    "    AutoConfig.from_pretrained(\"configs/symbol-2layer-8head-768dim.json\")\n",
    ")\n",
    "start_latent_id = tokenizer.convert_tokens_to_ids(\"<|start-latent|>\")\n",
    "end_latent_id = tokenizer.convert_tokens_to_ids(\"<|end-latent|>\")\n",
    "model = Coconut(model, latent_id, start_latent_id, end_latent_id, tokenizer.eos_token_id)\n",
    "print(model.load_state_dict(saved_weights, strict=False))\n",
    "print(\"evaluating\")\n",
    "model.eval()\n",
    "model.base_causallm.to(\"cuda:0\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First Layer Attention"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "According to our theoretical construction, the most important function of LAYER 1 attention heads is to copy the source and target node tokens of an edge onto the corresponding edge\n",
    "token ⟨e⟩. The following code block presents a representative attention map, confirming that the model has instantiated this copying mechanism in practice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Passing a tuple of `past_key_values` is deprecated and will be removed in Transformers v4.53.0. You should pass an instance of `Cache` instead, e.g. `past_key_values=DynamicCache.from_legacy_cache(past_key_values)`.\n",
      "`torch.nn.functional.scaled_dot_product_attention` does not support `output_attentions=True`. Falling back to eager attention. This warning can be removed using the argument `attn_implementation=\"eager\"` when loading the model.\n"
     ]
    }
   ],
   "source": [
    "inputs = \"<eos> 5 15 | 11 16 | 1 3 | 14 17 | 0 14 | 1 8 | 0 9 | 0 5 | 15 16 | 3 4 | 19 20 | 3 7 | 7 20 | 9 17 | 0 15 | 9 10 | 14 16 | 10 12 | 2 6 | 4 8 | 5 9 | 8 19 | 7 13 | 7 11 | 7 8 | 5 21 | 1 12 | 16 22 | 3 8 | 0 10 | 5 18 | 13 22 | 5 10 | 7 22 [Q] 20 18 [R] 1 <|latent|>\"\n",
    "input_ids = tokenizer.encode(inputs, add_special_tokens=False)\n",
    "input_ids = torch.tensor(input_ids).unsqueeze(0).cuda(0)\n",
    "attention_mask = torch.ones_like(input_ids).cuda(0)\n",
    "labels = torch.full_like(input_ids, -100).cuda(0)\n",
    "position_ids = torch.arange(input_ids.shape[1]).unsqueeze(0).cuda(0)\n",
    "outputs = model(input_ids, attention_mask, labels, position_ids)\n",
    "\n",
    "latent_indices = (\n",
    "    input_ids == model.latent_token_id\n",
    ").nonzero()  # (num_latent_tokens_in_the_batch, 2)\n",
    "\n",
    "latent_lists = [\n",
    "    [idx[1].item() for idx in latent_indices if idx[0] == i]\n",
    "    for i in range(input_ids.shape[0])\n",
    "]  # bs, num_latent_tokens_in_the_instance (difference across the batch)\n",
    "\n",
    "max_n_latents = max([len(l) for l in latent_lists])\n",
    "\n",
    "next_compute_range = (0, input_ids.shape[1])\n",
    "inputs_embeds = model.embedding(input_ids)\n",
    "logits = []\n",
    "\n",
    "if max_n_latents > 0:\n",
    "    next_compute_range = (0, latent_indices[:, 1].min().item())\n",
    "    # before the earliest latent token position\n",
    "\n",
    "kv_cache = None\n",
    "\n",
    "for pass_idx in range(max_n_latents):\n",
    "\n",
    "    if kv_cache == None:\n",
    "        # first forward pass\n",
    "        outputs = model.base_causallm(\n",
    "            inputs_embeds=inputs_embeds[\n",
    "                :, next_compute_range[0] : next_compute_range[1], :\n",
    "            ],\n",
    "            attention_mask=attention_mask[\n",
    "                :, next_compute_range[0] : next_compute_range[1]\n",
    "            ],\n",
    "            position_ids=position_ids[\n",
    "                :, next_compute_range[0] : next_compute_range[1]\n",
    "            ],\n",
    "            output_hidden_states=True,\n",
    "            output_attentions=True,\n",
    "        )\n",
    "        hidden_states_offset = 0\n",
    "\n",
    "    else:\n",
    "        # extract kv cache to reuse\n",
    "        past_key_values = [\n",
    "            (\n",
    "                k[:, :, : next_compute_range[0], :],\n",
    "                v[:, :, : next_compute_range[0], :],\n",
    "            )\n",
    "            for k, v in kv_cache\n",
    "        ]\n",
    "\n",
    "        outputs = model.base_causallm(\n",
    "            inputs_embeds=inputs_embeds[\n",
    "                :, next_compute_range[0] : next_compute_range[1], :\n",
    "            ],\n",
    "            attention_mask=attention_mask[:, : next_compute_range[1]],\n",
    "            position_ids=position_ids[\n",
    "                :, next_compute_range[0] : next_compute_range[1]\n",
    "            ],\n",
    "            past_key_values=past_key_values,\n",
    "            output_hidden_states=True,\n",
    "            output_attentions=True,\n",
    "        )\n",
    "\n",
    "        hidden_states_offset = next_compute_range[0]\n",
    "        # when we use kv_cache for the first k tokens\n",
    "        # in `outputs.hidden_states`, [0, k) will be skipped\n",
    "        # so we need to keep this offset to correctly use the last hidden states\n",
    "\n",
    "    logits.append(outputs.logits)\n",
    "\n",
    "    next_compute_range = (\n",
    "        next_compute_range[1],\n",
    "        (\n",
    "            input_ids.shape[1]\n",
    "            if pass_idx + 1 >= max_n_latents\n",
    "            else next_compute_range[1] + 1\n",
    "        ),\n",
    "    )\n",
    "\n",
    "    hidden_states = outputs.hidden_states[\n",
    "        -1\n",
    "    ]  # Get the last layer hidden states\n",
    "    kv_cache = outputs.past_key_values\n",
    "\n",
    "    # feedback the continuous thoughts to the input_embeds\\\n",
    "    # first decide the positions to feedback\n",
    "    filling_indices = [\n",
    "        (instance_idx, mask_list[pass_idx])\n",
    "        for instance_idx, mask_list in enumerate(latent_lists)\n",
    "        if len(mask_list) > pass_idx\n",
    "    ]\n",
    "\n",
    "    # to avoid in-place operations\n",
    "    # break down inputs_embeds (bs, len, hidden_size) into a list of list of 1-d tensors\n",
    "    tensor_list = [\n",
    "        [\n",
    "            inputs_embeds[batch_idx, pos, :]\n",
    "            for pos in range(inputs_embeds.shape[1])\n",
    "        ]\n",
    "        for batch_idx in range(inputs_embeds.shape[0])\n",
    "    ]\n",
    "\n",
    "    # replace some of them with continuous thoughts\n",
    "    for idx_pair in filling_indices:\n",
    "        batch_idx, token_idx = idx_pair\n",
    "\n",
    "        # replace it with the preceding last hidden states\n",
    "        tensor_list[batch_idx][token_idx] = hidden_states[\n",
    "            batch_idx, token_idx - 1 - hidden_states_offset, :\n",
    "        ]\n",
    "\n",
    "    # assemble the new inputs_embeds\n",
    "    inputs_embeds = torch.stack(\n",
    "        [\n",
    "            torch.stack(tensor_list[batch_idx])\n",
    "            for batch_idx in range(inputs_embeds.shape[0])\n",
    "        ]\n",
    "    )\n",
    "# final pass\n",
    "final_outputs = model.base_causallm(\n",
    "    inputs_embeds=inputs_embeds[\n",
    "        :, next_compute_range[0] : next_compute_range[1], :\n",
    "    ],\n",
    "    attention_mask=attention_mask[:, : next_compute_range[1]],\n",
    "    position_ids=position_ids[:, next_compute_range[0] : next_compute_range[1]],\n",
    "    past_key_values=(\n",
    "        [\n",
    "            (\n",
    "                k[:, :, : next_compute_range[0], :],\n",
    "                v[:, :, : next_compute_range[0], :],\n",
    "            )\n",
    "            for k, v in kv_cache\n",
    "        ]\n",
    "        if kv_cache\n",
    "        else None\n",
    "    ),\n",
    "    output_hidden_states=True,\n",
    "    output_attentions=True,\n",
    ")\n",
    "\n",
    "logits.append(final_outputs.logits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([107, 107])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# print(outputs.attentions[1][0][head_idx][-1, :])\n",
    "\n",
    "# draw an attention map\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Get the attention map for the last layer and head\n",
    "\n",
    "first_layer_attentions = outputs.attentions[0][0][:, :, :].sum(dim=0)\n",
    "# layer, batch, head, source_seq_len, target_seq_len\n",
    "\n",
    "\n",
    "print(first_layer_attentions.shape)\n",
    "# 107 * 107\n",
    "\n",
    "# Create a heatmap of the attention weights\n",
    "n_show = 16\n",
    "show_attention = first_layer_attentions[:n_show, :n_show]\n",
    "\n",
    "plt.figure(figsize=(6, 5))\n",
    "# show all the x and y labels\n",
    "# x label rotate 90 degrees\n",
    "\n",
    "inputs_ = inputs.replace(\"|\", \"<e>\").replace(\"<eos>\", \"<s>\")\n",
    "\n",
    "plt.xticks(range(n_show), inputs_.split(\" \")[:n_show])\n",
    "plt.xticks(rotation=0)\n",
    "\n",
    "plt.yticks(range(n_show), inputs_.split(\" \")[:n_show])\n",
    "# add labels for x and y\n",
    "plt.xlabel('Input Tokens (Key)')\n",
    "plt.ylabel('Input Tokens (Query)')\n",
    "\n",
    "\n",
    "# rotate the x and y labels\n",
    "plt.xticks(rotation=90)\n",
    "plt.yticks(rotation=0)\n",
    "\n",
    "plt.imshow(show_attention.detach().cpu().numpy(), cmap='viridis', aspect='auto')\n",
    "plt.colorbar(label='Attention Weight')\n",
    "\n",
    "# tight\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Second Layer Attention"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Layer 2** is responsible for node expansion: at each step, the continuous thought attends to all outgoing edges from nodes that are currently reachable. To quantify this behavior, we compute the aggregated attention score received by each edge token triplet $(s, t, \\langle e \\rangle)$ across all heads when generating the $i$-th continuous thought. We categorize edges into four types:  \n",
    "1. **Reachable** – edges whose source node is in the reachable set at step $i$;  \n",
    "2. **Not Reachable** – source node is not yet reachable;  \n",
    "3. **Frontier** – a subset of reachable edges whose source nodes lie on the current search frontier, i.e., exactly $i$ steps from the root;  \n",
    "4. **Optimal** – a subset of frontier edges that lie along the optimal reasoning path.\n",
    "\n",
    "We report group-wise means averaged over the test set. The model strongly concentrates its attention on **Reachable** edges, aligning with our theoretical construction. Interestingly, it also exhibits a bias toward the **Frontier** subset, possibly because the training objective encourages predicting frontier nodes at each step, while attention to previously explored nodes naturally decays. Furthermore, **Optimal** edges tend to receive higher attention scores, likely due to supervision from multi-stage training based on chain-of-thought (CoT) solutions.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_attn(question):\n",
    "    input_ids = tokenizer.encode(question, add_special_tokens=False)\n",
    "    input_ids = torch.tensor(input_ids).unsqueeze(0).to(model.base_causallm.device)\n",
    "    attention_mask = torch.ones_like(input_ids).to(model.base_causallm.device)\n",
    "    labels = torch.full_like(input_ids, -100).to(model.base_causallm.device)\n",
    "    position_ids = torch.arange(input_ids.shape[1]).unsqueeze(0).to(model.base_causallm.device)\n",
    "    outputs = model(input_ids, attention_mask, labels, position_ids)\n",
    "\n",
    "    latent_indices = (\n",
    "        input_ids == model.latent_token_id\n",
    "    ).nonzero()  # (num_latent_tokens_in_the_batch, 2)\n",
    "\n",
    "    latent_lists = [\n",
    "        [idx[1].item() for idx in latent_indices if idx[0] == i]\n",
    "        for i in range(input_ids.shape[0])\n",
    "    ]  # bs, num_latent_tokens_in_the_instance (difference across the batch)\n",
    "\n",
    "    max_n_latents = max([len(l) for l in latent_lists])\n",
    "\n",
    "    next_compute_range = (0, input_ids.shape[1])\n",
    "    inputs_embeds = model.embedding(input_ids)\n",
    "\n",
    "    if max_n_latents > 0:\n",
    "        next_compute_range = (0, latent_indices[:, 1].min().item())\n",
    "        # before the earliest latent token position\n",
    "\n",
    "    kv_cache = None\n",
    "\n",
    "    for pass_idx in range(max_n_latents):\n",
    "\n",
    "        if kv_cache == None:\n",
    "            # first forward pass\n",
    "            outputs = model.base_causallm(\n",
    "                inputs_embeds=inputs_embeds[\n",
    "                    :, next_compute_range[0] : next_compute_range[1], :\n",
    "                ],\n",
    "                attention_mask=attention_mask[\n",
    "                    :, next_compute_range[0] : next_compute_range[1]\n",
    "                ],\n",
    "                position_ids=position_ids[\n",
    "                    :, next_compute_range[0] : next_compute_range[1]\n",
    "                ],\n",
    "                output_hidden_states=True,\n",
    "                output_attentions=True,\n",
    "            )\n",
    "            hidden_states_offset = 0\n",
    "\n",
    "        else:\n",
    "            # extract kv cache to reuse\n",
    "            past_key_values = [\n",
    "                (\n",
    "                    k[:, :, : next_compute_range[0], :],\n",
    "                    v[:, :, : next_compute_range[0], :],\n",
    "                )\n",
    "                for k, v in kv_cache\n",
    "            ]\n",
    "\n",
    "            outputs = model.base_causallm(\n",
    "                inputs_embeds=inputs_embeds[\n",
    "                    :, next_compute_range[0] : next_compute_range[1], :\n",
    "                ],\n",
    "                attention_mask=attention_mask[:, : next_compute_range[1]],\n",
    "                position_ids=position_ids[\n",
    "                    :, next_compute_range[0] : next_compute_range[1]\n",
    "                ],\n",
    "                past_key_values=past_key_values,\n",
    "                output_hidden_states=True,\n",
    "                output_attentions=True,\n",
    "            )\n",
    "\n",
    "            hidden_states_offset = next_compute_range[0]\n",
    "            # when we use kv_cache for the first k tokens\n",
    "            # in `outputs.hidden_states`, [0, k) will be skipped\n",
    "            # so we need to keep this offset to correctly use the last hidden states\n",
    "\n",
    "        # logits.append(outputs.logits)\n",
    "\n",
    "        next_compute_range = (\n",
    "            next_compute_range[1],\n",
    "            (\n",
    "                input_ids.shape[1]\n",
    "                if pass_idx + 1 >= max_n_latents\n",
    "                else next_compute_range[1] + 1\n",
    "            ),\n",
    "        )\n",
    "\n",
    "        hidden_states = outputs.hidden_states[\n",
    "            -1\n",
    "        ]  # Get the last layer hidden states\n",
    "        kv_cache = outputs.past_key_values\n",
    "\n",
    "        # feedback the continuous thoughts to the input_embeds\n",
    "\n",
    "        # first decide the positions to feedback\n",
    "        filling_indices = [\n",
    "            (instance_idx, mask_list[pass_idx])\n",
    "            for instance_idx, mask_list in enumerate(latent_lists)\n",
    "            if len(mask_list) > pass_idx\n",
    "        ]\n",
    "\n",
    "        # to avoid in-place operations\n",
    "        # break down inputs_embeds (bs, len, hidden_size) into a list of list of 1-d tensors\n",
    "        tensor_list = [\n",
    "            [\n",
    "                inputs_embeds[batch_idx, pos, :]\n",
    "                for pos in range(inputs_embeds.shape[1])\n",
    "            ]\n",
    "            for batch_idx in range(inputs_embeds.shape[0])\n",
    "        ]\n",
    "\n",
    "        # replace some of them with continuous thoughts\n",
    "        for idx_pair in filling_indices:\n",
    "            batch_idx, token_idx = idx_pair\n",
    "\n",
    "            # replace it with the preceding last hidden states\n",
    "            tensor_list[batch_idx][token_idx] = hidden_states[\n",
    "                batch_idx, token_idx - 1 - hidden_states_offset, :\n",
    "            ]\n",
    "\n",
    "        # assemble the new inputs_embeds\n",
    "        inputs_embeds = torch.stack(\n",
    "            [\n",
    "                torch.stack(tensor_list[batch_idx])\n",
    "                for batch_idx in range(inputs_embeds.shape[0])\n",
    "            ]\n",
    "        )\n",
    "    # final pass\n",
    "    final_outputs = model.base_causallm(\n",
    "        inputs_embeds=inputs_embeds[\n",
    "            :, next_compute_range[0] : next_compute_range[1], :\n",
    "        ],\n",
    "        attention_mask=attention_mask[:, : next_compute_range[1]],\n",
    "        position_ids=position_ids[:, next_compute_range[0] : next_compute_range[1]],\n",
    "        past_key_values=(\n",
    "            [\n",
    "                (\n",
    "                    k[:, :, : next_compute_range[0], :],\n",
    "                    v[:, :, : next_compute_range[0], :],\n",
    "                )\n",
    "                for k, v in kv_cache\n",
    "            ]\n",
    "            if kv_cache\n",
    "            else None\n",
    "        ),\n",
    "        output_hidden_states=True,\n",
    "        output_attentions=True,\n",
    "    )\n",
    "\n",
    "    # logits.append(final_outputs.logits)\n",
    "    last_layer_attentions = final_outputs.attentions[1][0][:, -1, :]\n",
    "    return last_layer_attentions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = json.load(open(\"data/prosqa_test_graph_4_coconut.json\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 419/419 [00:02<00:00, 187.00it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "frontier 1.8065\n",
      "optimal 2.1848\n",
      "invalid 0.0732\n",
      "within_k 1.8065\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 419/419 [00:04<00:00, 96.96it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "frontier 0.7455\n",
      "optimal 1.2767\n",
      "invalid 0.071\n",
      "within_k 0.5616\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 419/419 [00:06<00:00, 65.63it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "frontier 0.5061\n",
      "optimal 1.2628\n",
      "invalid 0.118\n",
      "within_k 0.3161\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 419/419 [00:04<00:00, 96.83it/s] "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "frontier 0.4542\n",
      "optimal 1.6539\n",
      "invalid 0.1529\n",
      "within_k 0.2476\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "for n_step in range(0, 4):\n",
    "\n",
    "    att_group_frontier = []\n",
    "    att_group_within_k = []\n",
    "    att_group_optimal = []\n",
    "    att_group_invalid = []\n",
    "\n",
    "    # show progress bar\n",
    "    for data in tqdm(dataset):\n",
    "        \n",
    "        # data['neighbor_k'][str(n_step + 1)]\n",
    "        \n",
    "        if str(n_step + 1) not in data['neighbor_k']:\n",
    "            continue\n",
    "        \n",
    "        symbol_to_idx = {}\n",
    "        for i, s in enumerate(data['idx_to_symbol']):\n",
    "            symbol_to_idx[s] = i\n",
    "        \n",
    "        random.shuffle(data['edges'])\n",
    "\n",
    "        question = \"<eos> \" + \"|\".join([f\" {e[0]} {e[1]} \" for e in data['edges']]).strip() + \\\n",
    "            \" [Q] \"\n",
    "        if random.random() < 0.5:\n",
    "            question += str(data['target']) + \" \" + str(data['neg_target'])\n",
    "        else:\n",
    "            question += str(data['neg_target']) + \" \" + str(data['target'])\n",
    "\n",
    "        question += \" [R] \" + str(data['root']) + \" <|latent|>\" * n_step\n",
    "\n",
    "        last_layer_attentions = get_attn(question)\n",
    "\n",
    "        \n",
    "        # sum the attention weights of all the heads\n",
    "        attn_sum = last_layer_attentions.sum(dim=0)\n",
    "        # plot the sum\n",
    "        # count the number of heads that have attention weights greater than 0.5\n",
    "        \n",
    "        current_node_set = [data['root']]\n",
    "        \n",
    "        reachable_node_set = set(current_node_set)\n",
    "        \n",
    "        for _ in range(n_step):\n",
    "            next_node_set = []\n",
    "            for node in current_node_set:\n",
    "                for edge in data['edges']:\n",
    "                    if edge[0] == node:\n",
    "                        next_node_set.append(edge[1])\n",
    "            current_node_set = next_node_set\n",
    "            reachable_node_set.update(current_node_set)\n",
    "        \n",
    "        # find index of (root, neighbor) in the question\n",
    "        for i in range(1, len(question.split(\" \")), 3):\n",
    "            if question.split(\" \")[i + 2] != \"|\":\n",
    "                break\n",
    "            \n",
    "            if int(question.split(\" \")[i]) in reachable_node_set:\n",
    "                \n",
    "                att_group_within_k.append(attn_sum[i:i+3].sum().item())\n",
    "            \n",
    "                if int(question.split(\" \")[i]) in current_node_set:\n",
    "                    att_group_frontier.append(attn_sum[i:i+3].sum().item())\n",
    "                    if int(question.split(\" \")[i + 1]) in data['neighbor_k'][str(n_step + 1)]:\n",
    "                        att_group_optimal.append(attn_sum[i:i+3].sum().item())\n",
    "                    \n",
    "            else:\n",
    "                # print(\"invalid\", i, question.split(\" \")[i: i+3])\n",
    "                att_group_invalid.append(attn_sum[i:i+3].sum().item())\n",
    "\n",
    "        # break\n",
    "        \n",
    "    # draw a dist plot of att_group_valid and att_group_invalid\n",
    "    # print(len(att_group_frontier), len(att_group_optimal), len(att_group_invalid))\n",
    "    print(n_step)\n",
    "    print(\"frontier\", round(sum(att_group_frontier) / len(att_group_frontier), 4))\n",
    "    print(\"optimal\", round(sum(att_group_optimal) / len(att_group_optimal), 4))\n",
    "    print(\"invalid\", round(sum(att_group_invalid) / len(att_group_invalid), 4))\n",
    "    print(\"within_k\", round(sum(att_group_within_k) / len(att_group_within_k), 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analysis of the continuous thoughts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Representation of Continuous Thoughts**\n",
    "\n",
    "To verify that continuous thoughts serve as superposition states for the search process, we compute the inner product between the continuous thought at step $i$, denoted $[t_i]$, and each node embedding $u_v$. As with edge classification, we categorize nodes into four groups:  \n",
    "1. **Reachable** – nodes within the reachable set at step $i$;  \n",
    "2. **Not Reachable** – nodes not yet reachable;  \n",
    "3. **Frontier** – nodes exactly $i$ steps from the root (the current search frontier);  \n",
    "4. **Optimal** – nodes on the optimal reasoning path.\n",
    "\n",
    "The following code block shows the similarity distributions segmented by reasoning step $i$. As predicted, nodes within $i$ hops exhibit significantly higher similarity to $[t_i]$ than more distant nodes. Notably, **Frontier** nodes are even more similar to the thought vector than other reachable nodes, indicating that the superposition emphasizes candidate expansion fronts. **Optimal** nodes are closer still, likely due to training supervision consistently highlighting optimal paths.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the function to compute the continuous thoughts\n",
    "\n",
    "def get_continuous_thoughts(question):\n",
    "    input_ids = tokenizer.encode(question, add_special_tokens=False)\n",
    "    input_ids = torch.tensor(input_ids).unsqueeze(0).to(model.base_causallm.device)\n",
    "    attention_mask = torch.ones_like(input_ids).to(model.base_causallm.device)\n",
    "    labels = torch.full_like(input_ids, -100).to(model.base_causallm.device)\n",
    "    position_ids = torch.arange(input_ids.shape[1]).unsqueeze(0).to(model.base_causallm.device)\n",
    "    outputs = model(input_ids, attention_mask, labels, position_ids)\n",
    "    return outputs.inputs_embeds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load the dataset\n",
    "dataset = json.load(open(\"data/prosqa_test_graph_4_coconut.json\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 419/419 [00:02<00:00, 173.98it/s]\n",
      "100%|██████████| 419/419 [00:03<00:00, 127.93it/s]\n",
      "100%|██████████| 419/419 [00:04<00:00, 101.10it/s]\n",
      "100%|██████████| 419/419 [00:02<00:00, 159.63it/s]\n"
     ]
    }
   ],
   "source": [
    "stats = {}\n",
    "\n",
    "for n_step in range(0, 4):\n",
    "\n",
    "    inner_prod_frontier = []\n",
    "    inner_prod_within_k = []\n",
    "    inner_prod_invalid = []\n",
    "    inner_prod_optimal = []\n",
    "\n",
    "    # Get token embeddings for comparison\n",
    "    token_embeddings = model.embedding.weight\n",
    "\n",
    "    for data in tqdm(dataset):\n",
    "        if str(n_step + 1) not in data['neighbor_k']:\n",
    "            continue\n",
    "            \n",
    "        # Construct question string\n",
    "        question = \"<eos> \" + \"|\".join([f\" {e[0]} {e[1]} \" for e in data['edges']]).strip() + \\\n",
    "            \" [Q] \"\n",
    "        if random.random() < 0.5:\n",
    "            question += str(data['target']) + \" \" + str(data['neg_target'])\n",
    "        else:\n",
    "            question += str(data['neg_target']) + \" \" + str(data['target'])\n",
    "        question += \" [R] \" + str(data['root']) + \" <|latent|>\" * (n_step + 1)\n",
    "        # the last input embedding is the previous latent continuous thought\n",
    "\n",
    "        # Get continuous thoughts embeddings\n",
    "        continuous_embeds = get_continuous_thoughts(question)\n",
    "        \n",
    "        # Find positions of latent tokens\n",
    "        input_ids = tokenizer.encode(question, add_special_tokens=False)\n",
    "        latent_positions = [i for i, id in enumerate(input_ids) if id == latent_id]\n",
    "        \n",
    "        if len(latent_positions) == 0:\n",
    "            continue\n",
    "            \n",
    "        # Get the last latent token's continuous thought\n",
    "        last_latent_pos = latent_positions[-1]\n",
    "        continuous_thought = continuous_embeds[0, last_latent_pos, :]\n",
    "        \n",
    "        # Compute inner products with all token embeddings\n",
    "        inner_products = torch.matmul(continuous_thought, token_embeddings.t().to(continuous_thought.device))\n",
    "        \n",
    "        # Track current nodes for step n\n",
    "        current_node_set = [data['root']]\n",
    "        previous_node_set = []\n",
    "        for _ in range(n_step + 1):\n",
    "            previous_node_set += current_node_set\n",
    "            next_node_set = []\n",
    "            for node in current_node_set:\n",
    "                for edge in data['edges']:\n",
    "                    if edge[0] == node:\n",
    "                        next_node_set.append(edge[1])\n",
    "            current_node_set = next_node_set\n",
    "        \n",
    "        # Classify nodes and compute average inner products\n",
    "        all_nodes = set()\n",
    "        for edge in data['edges']:\n",
    "            all_nodes.add(edge[0])\n",
    "            all_nodes.add(edge[1])\n",
    "            \n",
    "        optimal_node_set = set(data['neighbor_k'][str(n_step + 1)])\n",
    "        \n",
    "        for node in all_nodes:\n",
    "            node_token_id = tokenizer.encode(str(node), add_special_tokens=False)[0]\n",
    "            inner_prod = inner_products[node_token_id].item()\n",
    "            \n",
    "            if node in current_node_set + previous_node_set:\n",
    "                inner_prod_within_k.append(inner_prod)\n",
    "                if node in current_node_set:\n",
    "                    inner_prod_frontier.append(inner_prod)\n",
    "                    if node in optimal_node_set:\n",
    "                        inner_prod_optimal.append(inner_prod)\n",
    "            else:\n",
    "                inner_prod_invalid.append(inner_prod)\n",
    "\n",
    "    # save the inner products\n",
    "    stats[n_step] = {\n",
    "        \"step\": n_step,\n",
    "        \"inner_prod_invalid\": inner_prod_invalid,\n",
    "        \"inner_prod_within_k\": inner_prod_within_k,\n",
    "        \"inner_prod_frontier\": inner_prod_frontier,\n",
    "        \"inner_prod_optimal\": inner_prod_optimal\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x300 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a 2x4 subplot layout\n",
    "fig, axes = plt.subplots(1, 4, figsize=(14, 3), sharey=False)\n",
    "\n",
    "# First row: Original model\n",
    "for step in range(4):\n",
    "    # Load data for each step\n",
    "    \n",
    "    data = stats[step]\n",
    "    # Extract data\n",
    "    inner_prod_invalid = data['inner_prod_invalid']\n",
    "    inner_prod_within_k = data['inner_prod_within_k']\n",
    "    inner_prod_frontier = data['inner_prod_frontier']\n",
    "    inner_prod_optimal = data['inner_prod_optimal']\n",
    "    \n",
    "    # Calculate means\n",
    "    mean_invalid = np.mean(inner_prod_invalid)\n",
    "    mean_within_k = np.mean(inner_prod_within_k)\n",
    "    mean_frontier = np.mean(inner_prod_frontier)\n",
    "    mean_optimal = np.mean(inner_prod_optimal)\n",
    "    \n",
    "    # Define common bins for this subplot\n",
    "    bins = np.linspace(\n",
    "        min(min(inner_prod_invalid), min(inner_prod_within_k)),\n",
    "        max(max(inner_prod_invalid), max(inner_prod_within_k)),\n",
    "        30\n",
    "    )\n",
    "    \n",
    "    # Plot on current subplot\n",
    "    ax = axes[step]\n",
    "    \n",
    "    # ax.set_xlabel('Inner Product Value')\n",
    "    \n",
    "    ax.hist(inner_prod_invalid, bins=bins, alpha=0.4, \n",
    "            label=f'Not Reachable ({mean_invalid:.2f})',\n",
    "            color='C0', edgecolor='C0', histtype='stepfilled', linewidth=0)\n",
    "    \n",
    "    ax.hist(inner_prod_within_k, bins=bins, alpha=0.3, \n",
    "            label=f'Reachable ({mean_within_k:.2f})',\n",
    "            color='C1', edgecolor='C1', histtype='stepfilled', linewidth=0)\n",
    "    \n",
    "    ax.hist(inner_prod_frontier, bins=bins, alpha=0.3, \n",
    "            label=f'Frontier ({mean_frontier:.2f})',\n",
    "            color='C1', histtype='bar',\n",
    "            hatch='...', edgecolor='C1', linewidth=0)\n",
    "    \n",
    "    ax.hist(inner_prod_optimal, bins=bins, alpha=0.5, \n",
    "            label=f'Optimal ({mean_optimal:.2f})',\n",
    "            color='C1', histtype='bar',\n",
    "            hatch='...', edgecolor='C1', linewidth=0)\n",
    "    \n",
    "    ax.set_title(f'Continuous thought {step + 1}')\n",
    "    ax.grid(alpha=0.3)\n",
    "    \n",
    "    # Only add x-label for bottom row\n",
    "    \n",
    "    ax.set_title(f'Continuous thought {step + 1}')\n",
    "    \n",
    "    # Show legend for all subplots with smaller font size\n",
    "    \n",
    "    from matplotlib.patches import Patch\n",
    "    legend_elements = [\n",
    "        Patch(color='C0', alpha=0.4, label=f'Not Reachable ({mean_invalid:.2f})'),\n",
    "        Patch(color='C1', alpha=0.3, label=f'Reachable ({mean_within_k:.2f})'),\n",
    "        Patch(color='C1', alpha=0.4, hatch='...', label=f'Frontier ({mean_frontier:.2f})'),\n",
    "        Patch(color='C1', alpha=0.7, hatch='...', label=f'Optimal ({mean_optimal:.2f})')  # Higher alpha for optimal\n",
    "    ]\n",
    "    ax.legend(handles=legend_elements, fontsize='small', loc='upper right')\n",
    "\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Together, these findings confirm that trained models implement a soft, parallel search mechanism through superpositional reasoning: **Layer 1** establishes the query context, **Layer 2** expands the search frontier, and the latent vectors encode reachable state sets in a continuous, distributed form—realizing the theoretical construction in the paper."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}