Auto deploy from GitHub

compiler_tetris (1).ipynb

@@ -0,0 +1,651 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "b7fdb9ab",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# ==== CELL 1: Setup ====\n",
+        "!pip install -q pytest\n",
+        "import os, sys\n",
+        "\n",
+        "LOCAL_DIR = \"/content/toyir\"\n",
+        "DRIVE_DIR = \"/content/drive/MyDrive/env/toyir\"\n",
+        "\n",
+        "os.makedirs(LOCAL_DIR, exist_ok=True)\n",
+        "sys.path.insert(0, LOCAL_DIR)\n",
+        "print(\"Workspace ready at\", LOCAL_DIR)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "d0337367",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# ==== CELL 1b: Mount Drive + sync workspace ====\n",
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')\n",
+        "\n",
+        "import shutil\n",
+        "os.makedirs(DRIVE_DIR, exist_ok=True)\n",
+        "\n",
+        "# On fresh runtime: pull existing files from Drive -> local\n",
+        "for f in os.listdir(DRIVE_DIR):\n",
+        "    src = os.path.join(DRIVE_DIR, f)\n",
+        "    if os.path.isfile(src) and f.endswith(\".py\"):\n",
+        "        shutil.copy2(src, os.path.join(LOCAL_DIR, f))\n",
+        "print(\"Synced from Drive:\", sorted(os.listdir(LOCAL_DIR)))\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "2c83c529",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "%%writefile /content/toyir/toy_vm.py\n",
+        "\"\"\"Toy-IR VM: deterministic, dependency-light execution engine for RLVR.\"\"\"\n",
+        "from __future__ import annotations\n",
+        "from copy import deepcopy\n",
+        "from typing import Any\n",
+        "\n",
+        "CYCLE_COST: dict[str, int] = {\n",
+        "    \"CONST\": 1, \"ADD\": 1, \"SUB\": 1, \"MUL\": 3, \"DIV\": 5,\n",
+        "    \"COPY\": 1, \"LOAD\": 4, \"STORE\": 4, \"NOP\": 0,\n",
+        "}\n",
+        "OP_ORDER = (\"CONST\", \"ADD\", \"SUB\", \"MUL\", \"DIV\", \"COPY\", \"LOAD\", \"STORE\", \"NOP\")\n",
+        "VALID_OPS = frozenset(CYCLE_COST)\n",
+        "REQUIRED_KEYS = (\"op\", \"dest\", \"src1\", \"src2\")\n",
+        "\n",
+        "\n",
+        "def _is_str_or_int_or_none(x: Any) -> bool:\n",
+        "    return x is None or isinstance(x, str) or (isinstance(x, int) and not isinstance(x, bool))\n",
+        "\n",
+        "\n",
+        "def _is_str_or_none(x: Any) -> bool:\n",
+        "    return x is None or isinstance(x, str)\n",
+        "\n",
+        "\n",
+        "def validate_ir(program: list[dict]) -> dict:\n",
+        "    errors: list[str] = []\n",
+        "    for i, ins in enumerate(program):\n",
+        "        if not isinstance(ins, dict):\n",
+        "            errors.append(f\"[{i}] not a dict\")\n",
+        "            continue\n",
+        "        for k in REQUIRED_KEYS:\n",
+        "            if k not in ins:\n",
+        "                errors.append(f\"[{i}] missing key '{k}'\")\n",
+        "        if \"op\" not in ins:\n",
+        "            continue\n",
+        "        op = ins[\"op\"]\n",
+        "        if op not in VALID_OPS:\n",
+        "            errors.append(f\"[{i}] invalid op '{op}'\")\n",
+        "            continue\n",
+        "        if not _is_str_or_none(ins.get(\"dest\")):\n",
+        "            errors.append(f\"[{i}] dest must be str|None\")\n",
+        "        if not _is_str_or_int_or_none(ins.get(\"src1\")):\n",
+        "            errors.append(f\"[{i}] src1 must be str|int|None\")\n",
+        "        if not _is_str_or_int_or_none(ins.get(\"src2\")):\n",
+        "            errors.append(f\"[{i}] src2 must be str|int|None\")\n",
+        "\n",
+        "        # per-op contracts\n",
+        "        if op in (\"CONST\", \"ADD\", \"SUB\", \"MUL\", \"DIV\", \"COPY\", \"LOAD\"):\n",
+        "            if not isinstance(ins.get(\"dest\"), str):\n",
+        "                errors.append(f\"[{i}] {op} requires str dest\")\n",
+        "        if op in (\"ADD\", \"SUB\", \"MUL\", \"DIV\"):\n",
+        "            if ins.get(\"src1\") is None or ins.get(\"src2\") is None:\n",
+        "                errors.append(f\"[{i}] {op} requires src1 and src2\")\n",
+        "        if op in (\"CONST\", \"COPY\"):\n",
+        "            if ins.get(\"src1\") is None:\n",
+        "                errors.append(f\"[{i}] {op} requires src1\")\n",
+        "        if op in (\"CONST\", \"COPY\", \"LOAD\", \"STORE\"):\n",
+        "            if ins.get(\"src2\") is not None:\n",
+        "                errors.append(f\"[{i}] {op} requires src2=None\")\n",
+        "        if op == \"LOAD\":\n",
+        "            if not isinstance(ins.get(\"src1\"), str):\n",
+        "                errors.append(f\"[{i}] LOAD src1 must be str (variable name)\")\n",
+        "        if op == \"STORE\":\n",
+        "            if not isinstance(ins.get(\"dest\"), str):\n",
+        "                errors.append(f\"[{i}] STORE dest must be str (variable name)\")\n",
+        "            if ins.get(\"src1\") is None:\n",
+        "                errors.append(f\"[{i}] STORE requires src1\")\n",
+        "        if op == \"NOP\":\n",
+        "            if any(ins.get(k) is not None for k in (\"dest\", \"src1\", \"src2\")):\n",
+        "                errors.append(f\"[{i}] NOP fields must all be None\")\n",
+        "\n",
+        "    return {\"valid\": len(errors) == 0, \"errors\": errors}\n",
+        "\n",
+        "\n",
+        "def _resolve(operand: Any, variables: dict) -> int:\n",
+        "    if isinstance(operand, str):\n",
+        "        if operand not in variables:\n",
+        "            raise KeyError(f\"undefined variable '{operand}'\")\n",
+        "        return variables[operand]\n",
+        "    if isinstance(operand, int) and not isinstance(operand, bool):\n",
+        "        return operand\n",
+        "    raise TypeError(f\"bad operand: {operand!r}\")\n",
+        "\n",
+        "\n",
+        "def _exec_one(ins: dict, variables: dict, memory: dict) -> int:\n",
+        "    op = ins[\"op\"]\n",
+        "    dest = ins[\"dest\"]\n",
+        "    s1, s2 = ins[\"src1\"], ins[\"src2\"]\n",
+        "\n",
+        "    if op == \"CONST\":\n",
+        "        variables[dest] = _resolve(s1, variables)\n",
+        "    elif op == \"ADD\":\n",
+        "        variables[dest] = _resolve(s1, variables) + _resolve(s2, variables)\n",
+        "    elif op == \"SUB\":\n",
+        "        variables[dest] = _resolve(s1, variables) - _resolve(s2, variables)\n",
+        "    elif op == \"MUL\":\n",
+        "        variables[dest] = _resolve(s1, variables) * _resolve(s2, variables)\n",
+        "    elif op == \"DIV\":\n",
+        "        b = _resolve(s2, variables)\n",
+        "        if b == 0:\n",
+        "            raise ZeroDivisionError(\"DIV by zero\")\n",
+        "        variables[dest] = _resolve(s1, variables) // b\n",
+        "    elif op == \"COPY\":\n",
+        "        variables[dest] = _resolve(s1, variables)\n",
+        "    elif op == \"LOAD\":\n",
+        "        if not isinstance(s1, str):\n",
+        "            raise TypeError(\"LOAD src1 must be a variable name\")\n",
+        "        addr = variables.get(s1)\n",
+        "        if not (isinstance(addr, int) and not isinstance(addr, bool)):\n",
+        "            raise TypeError(f\"LOAD address from '{s1}' is not int: {addr!r}\")\n",
+        "        if addr not in memory:\n",
+        "            raise KeyError(f\"LOAD from uninitialized addr {addr}\")\n",
+        "        variables[dest] = memory[addr]\n",
+        "    elif op == \"STORE\":\n",
+        "        if not isinstance(dest, str):\n",
+        "            raise TypeError(\"STORE dest must be a variable name\")\n",
+        "        addr = variables.get(dest)\n",
+        "        if not (isinstance(addr, int) and not isinstance(addr, bool)):\n",
+        "            raise TypeError(f\"STORE address from '{dest}' is not int: {addr!r}\")\n",
+        "        memory[addr] = _resolve(s1, variables)\n",
+        "    elif op == \"NOP\":\n",
+        "        pass\n",
+        "    else:\n",
+        "        raise ValueError(f\"non-executable op {op}\")\n",
+        "    return CYCLE_COST[op]\n",
+        "\n",
+        "\n",
+        "def execute(program: list[dict], initial_state: dict) -> dict:\n",
+        "    variables: dict = {}\n",
+        "    memory: dict = {}\n",
+        "    cycles = 0\n",
+        "    try:\n",
+        "        if not isinstance(initial_state, dict):\n",
+        "            raise TypeError(\"initial_state must be a dict\")\n",
+        "        state = deepcopy(initial_state)\n",
+        "        variables = state.get(\"variables\", {})\n",
+        "        memory = state.get(\"memory\", {})\n",
+        "        if not isinstance(variables, dict):\n",
+        "            raise TypeError(\"initial_state['variables'] must be a dict\")\n",
+        "        if not isinstance(memory, dict):\n",
+        "            raise TypeError(\"initial_state['memory'] must be a dict\")\n",
+        "\n",
+        "        for ins in program:\n",
+        "            cycles += _exec_one(ins, variables, memory)\n",
+        "    except Exception as e:\n",
+        "        return {\"memory\": memory, \"variables\": variables,\n",
+        "                \"cycles\": None, \"success\": False, \"error\": str(e)}\n",
+        "    return {\"memory\": memory, \"variables\": variables,\n",
+        "            \"cycles\": cycles, \"success\": True, \"error\": None}\n",
+        "\n",
+        "\n",
+        "def count_cycles(program: list[dict]) -> int:\n",
+        "    total = 0\n",
+        "    for i, ins in enumerate(program):\n",
+        "        op = ins.get(\"op\") if isinstance(ins, dict) else None\n",
+        "        if op not in CYCLE_COST:\n",
+        "            raise ValueError(f\"count_cycles: invalid or missing op at index {i}: {op!r}\")\n",
+        "        total += CYCLE_COST[op]\n",
+        "    return total\n",
+        "\n",
+        "\n",
+        "def profile(program: list[dict]) -> dict:\n",
+        "    out: dict[str, int] = {\"n_instructions\": len(program)}\n",
+        "    for op in OP_ORDER:\n",
+        "        out[f\"n_{op.lower()}\"] = 0\n",
+        "    for ins in program:\n",
+        "        key = f\"n_{ins['op'].lower()}\"\n",
+        "        if key in out:\n",
+        "            out[key] += 1\n",
+        "    return out\n",
+        "\n",
+        "\n",
+        "def _fmt_operand(x: Any) -> str:\n",
+        "    if x is None:\n",
+        "        return \"\"\n",
+        "    return str(x)\n",
+        "\n",
+        "\n",
+        "def dump_ir(program: list[dict]) -> str:\n",
+        "    stores = [ins[\"dest\"] for ins in program if ins[\"op\"] == \"STORE\"]\n",
+        "    seen, ordered = set(), []\n",
+        "    for s in stores:\n",
+        "        if s not in seen:\n",
+        "            seen.add(s); ordered.append(s)\n",
+        "    header = \"// OBSERVABLE OUT: \" + (\", \".join(f\"mem[{s}]\" for s in ordered) if ordered else \"(none)\")\n",
+        "    lines = [header]\n",
+        "    for ins in program:\n",
+        "        op = ins[\"op\"]\n",
+        "        dest, s1, s2 = ins[\"dest\"], ins[\"src1\"], ins[\"src2\"]\n",
+        "        if op == \"STORE\":\n",
+        "            lines.append(f\"STORE [{dest}] {_fmt_operand(s1)}\")\n",
+        "        elif op == \"LOAD\":\n",
+        "            lines.append(f\"{dest} = LOAD [{_fmt_operand(s1)}]\")\n",
+        "        elif op == \"NOP\":\n",
+        "            lines.append(\"NOP\")\n",
+        "        else:\n",
+        "            parts = [op, _fmt_operand(s1)]\n",
+        "            if s2 is not None:\n",
+        "                parts.append(_fmt_operand(s2))\n",
+        "            lines.append(f\"{dest} = {' '.join(p for p in parts if p)}\")\n",
+        "    return \"\\n\".join(lines)\n",
+        "\n",
+        "\n",
+        "def clean_nops(program: list[dict]) -> list[dict]:\n",
+        "    return [deepcopy(ins) for ins in program if ins[\"op\"] != \"NOP\"]\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "3c85a58b",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "%%writefile /content/toyir/verifier.py\n",
+        "\"\"\"Strict equivalence verifier - anti-cheat for RL reward hacking.\"\"\"\n",
+        "from __future__ import annotations\n",
+        "from toy_vm import execute\n",
+        "\n",
+        "\n",
+        "def verify(original_program: list[dict],\n",
+        "           optimized_program: list[dict],\n",
+        "           initial_states: list[dict]) -> dict:\n",
+        "    if not initial_states:\n",
+        "        raise ValueError(\"verify requires at least one initial_state\")\n",
+        "\n",
+        "    results = []\n",
+        "    all_match = True\n",
+        "    for st in initial_states:\n",
+        "        r_o = execute(original_program, st)\n",
+        "        r_p = execute(optimized_program, st)\n",
+        "        mem_o = r_o[\"memory\"] if r_o[\"success\"] else None\n",
+        "        mem_p = r_p[\"memory\"] if r_p[\"success\"] else None\n",
+        "\n",
+        "        execution_errors = {}\n",
+        "        if not r_o[\"success\"]:\n",
+        "            execution_errors[\"original_error\"] = r_o[\"error\"]\n",
+        "        if not r_p[\"success\"]:\n",
+        "            execution_errors[\"optimized_error\"] = r_p[\"error\"]\n",
+        "\n",
+        "        if execution_errors:\n",
+        "            match = False\n",
+        "            mismatches = [\"__execution_error__\"]\n",
+        "        else:\n",
+        "            keys = set(mem_o.keys()) | set(mem_p.keys())\n",
+        "            mismatches = [k for k in keys if mem_o.get(k) != mem_p.get(k)]\n",
+        "            match = len(mismatches) == 0\n",
+        "\n",
+        "        if not match:\n",
+        "            all_match = False\n",
+        "        results.append({\n",
+        "            \"initial_state\": st,\n",
+        "            \"original_memory\": mem_o,\n",
+        "            \"optimized_memory\": mem_p,\n",
+        "            \"match\": match,\n",
+        "            \"mismatches\": sorted(mismatches, key=lambda x: (isinstance(x, str), x)),\n",
+        "            \"execution_errors\": execution_errors or None,\n",
+        "        })\n",
+        "    return {\"equivalent\": all_match, \"results\": results}\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "cd7f8fa2",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "%%writefile /content/toyir/reward_utils.py\n",
+        "\"\"\"Reward signal: cycle-reduction metric for RL agent.\"\"\"\n",
+        "from __future__ import annotations\n",
+        "from toy_vm import execute\n",
+        "\n",
+        "\n",
+        "def compute_reduction(original_program: list[dict],\n",
+        "                      optimized_program: list[dict],\n",
+        "                      initial_state: dict) -> dict:\n",
+        "    r_o = execute(original_program, initial_state)\n",
+        "    r_p = execute(optimized_program, initial_state)\n",
+        "\n",
+        "    if not (r_o[\"success\"] and r_p[\"success\"]):\n",
+        "        return {\n",
+        "            \"original_cycles\": r_o[\"cycles\"],\n",
+        "            \"optimized_cycles\": r_p[\"cycles\"],\n",
+        "            \"absolute_savings\": None,\n",
+        "            \"relative_savings\": None,\n",
+        "            \"success\": False,\n",
+        "            \"error\": r_o[\"error\"] or r_p[\"error\"],\n",
+        "        }\n",
+        "\n",
+        "    oc, pc = r_o[\"cycles\"], r_p[\"cycles\"]\n",
+        "    rel = 0.0 if oc == 0 else (oc - pc) / oc\n",
+        "    rel = max(-1.0, min(1.0, rel))\n",
+        "    return {\n",
+        "        \"original_cycles\": oc,\n",
+        "        \"optimized_cycles\": pc,\n",
+        "        \"absolute_savings\": oc - pc,\n",
+        "        \"relative_savings\": rel,\n",
+        "        \"success\": True,\n",
+        "        \"error\": None,\n",
+        "    }\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "4f2a941c",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "%%writefile /content/toyir/test_vm.py\n",
+        "\"\"\"Pytest suite covering VM, verifier, reward, and RL exploit guardrails.\"\"\"\n",
+        "from __future__ import annotations\n",
+        "import random\n",
+        "import pytest\n",
+        "from toy_vm import (\n",
+        "    validate_ir, execute, count_cycles, profile, dump_ir, clean_nops, OP_ORDER,\n",
+        ")\n",
+        "from verifier import verify\n",
+        "from reward_utils import compute_reduction\n",
+        "\n",
+        "\n",
+        "def I(op, dest=None, src1=None, src2=None):\n",
+        "    return {\"op\": op, \"dest\": dest, \"src1\": src1, \"src2\": src2}\n",
+        "\n",
+        "\n",
+        "def test_const_fold_equivalence():\n",
+        "    orig = [I(\"CONST\", \"t0\", 5), I(\"CONST\", \"t1\", 7), I(\"ADD\", \"t2\", \"t0\", \"t1\"),\n",
+        "            I(\"CONST\", \"addr\", 0), I(\"STORE\", \"addr\", \"t2\")]\n",
+        "    opt = [I(\"CONST\", \"t2\", 12), I(\"CONST\", \"addr\", 0), I(\"STORE\", \"addr\", \"t2\")]\n",
+        "    res = verify(orig, opt, [{\"variables\": {}, \"memory\": {}}])\n",
+        "    assert res[\"equivalent\"]\n",
+        "    red = compute_reduction(orig, opt, {\"variables\": {}, \"memory\": {}})\n",
+        "    assert red[\"absolute_savings\"] > 0\n",
+        "\n",
+        "\n",
+        "def test_dead_code_invisible():\n",
+        "    orig = [I(\"CONST\", \"addr\", 0), I(\"CONST\", \"x\", 3),\n",
+        "            I(\"MUL\", \"dead\", \"x\", 99), I(\"STORE\", \"addr\", \"x\")]\n",
+        "    opt = [I(\"CONST\", \"addr\", 0), I(\"CONST\", \"x\", 3), I(\"STORE\", \"addr\", \"x\")]\n",
+        "    res = verify(orig, opt, [{\"variables\": {}, \"memory\": {}}])\n",
+        "    assert res[\"equivalent\"]\n",
+        "\n",
+        "\n",
+        "def test_fold_then_dce():\n",
+        "    orig = [I(\"CONST\", \"a\", 2), I(\"CONST\", \"b\", 3), I(\"ADD\", \"c\", \"a\", \"b\"),\n",
+        "            I(\"MUL\", \"d\", \"c\", 10), I(\"CONST\", \"addr\", 0), I(\"STORE\", \"addr\", \"d\")]\n",
+        "    opt = [I(\"CONST\", \"d\", 50), I(\"CONST\", \"addr\", 0), I(\"STORE\", \"addr\", \"d\")]\n",
+        "    res = verify(orig, opt, [{\"variables\": {}, \"memory\": {}}])\n",
+        "    assert res[\"equivalent\"]\n",
+        "    red = compute_reduction(orig, opt, {\"variables\": {}, \"memory\": {}})\n",
+        "    assert red[\"original_cycles\"] > red[\"optimized_cycles\"]\n",
+        "\n",
+        "\n",
+        "def test_strength_reduction():\n",
+        "    orig = [I(\"CONST\", \"addr\", 0), I(\"CONST\", \"x\", 7),\n",
+        "            I(\"MUL\", \"y\", \"x\", 2), I(\"STORE\", \"addr\", \"y\")]\n",
+        "    opt = [I(\"CONST\", \"addr\", 0), I(\"CONST\", \"x\", 7),\n",
+        "           I(\"ADD\", \"y\", \"x\", \"x\"), I(\"STORE\", \"addr\", \"y\")]\n",
+        "    res = verify(orig, opt, [{\"variables\": {}, \"memory\": {}}])\n",
+        "    assert res[\"equivalent\"]\n",
+        "    red = compute_reduction(orig, opt, {\"variables\": {}, \"memory\": {}})\n",
+        "    assert red[\"absolute_savings\"] > 0\n",
+        "\n",
+        "\n",
+        "def test_already_optimal():\n",
+        "    p = [I(\"CONST\", \"addr\", 0), I(\"CONST\", \"x\", 1), I(\"STORE\", \"addr\", \"x\")]\n",
+        "    red = compute_reduction(p, p, {\"variables\": {}, \"memory\": {}})\n",
+        "    assert red[\"absolute_savings\"] == 0\n",
+        "    assert red[\"relative_savings\"] == 0.0\n",
+        "\n",
+        "\n",
+        "def test_div_by_zero():\n",
+        "    p = [I(\"CONST\", \"a\", 10), I(\"CONST\", \"b\", 0), I(\"DIV\", \"c\", \"a\", \"b\")]\n",
+        "    r = execute(p, {\"variables\": {}, \"memory\": {}})\n",
+        "    assert r[\"success\"] is False\n",
+        "    assert \"zero\" in r[\"error\"].lower()\n",
+        "\n",
+        "\n",
+        "def test_hardcoded_exploit_caught():\n",
+        "    orig = [I(\"CONST\", \"addr\", 0), I(\"LOAD\", \"x\", \"in_addr\"),\n",
+        "            I(\"MUL\", \"y\", \"x\", 3), I(\"STORE\", \"addr\", \"y\")]\n",
+        "    opt = [I(\"CONST\", \"addr\", 0), I(\"CONST\", \"y\", 42), I(\"STORE\", \"addr\", \"y\")]\n",
+        "    rng = random.Random(0)\n",
+        "    states = [{\"variables\": {\"in_addr\": 1}, \"memory\": {1: rng.randint(0, 100)}} for _ in range(5)]\n",
+        "    res = verify(orig, opt, states)\n",
+        "    assert res[\"equivalent\"] is False\n",
+        "    assert any(not r[\"match\"] for r in res[\"results\"])\n",
+        "\n",
+        "\n",
+        "def test_nop_zero_cost():\n",
+        "    p = [I(\"NOP\"), I(\"CONST\", \"x\", 1), I(\"NOP\")]\n",
+        "    assert count_cycles(p) == 1\n",
+        "    r = execute(p, {\"variables\": {}, \"memory\": {}})\n",
+        "    assert r[\"success\"] and r[\"cycles\"] == 1\n",
+        "\n",
+        "\n",
+        "def test_load_store_non_int_address():\n",
+        "    p = [I(\"COPY\", \"addr\", \"bad\"), I(\"LOAD\", \"x\", \"addr\")]\n",
+        "    r = execute(p, {\"variables\": {\"bad\": \"notint\"}, \"memory\": {}})\n",
+        "    assert r[\"success\"] is False\n",
+        "\n",
+        "\n",
+        "def test_validate_ir_malformed():\n",
+        "    assert not validate_ir([I(\"FOOBAR\", \"t\", 1, 2)])[\"valid\"]\n",
+        "    assert not validate_ir([{\"op\": \"ADD\", \"dest\": \"x\"}])[\"valid\"]\n",
+        "    assert not validate_ir([I(\"CONST\", 123, 1)])[\"valid\"]\n",
+        "    assert not validate_ir([I(\"STORE\", None, \"x\")])[\"valid\"]\n",
+        "    assert not validate_ir([I(\"LOAD\", \"x\", 42)])[\"valid\"]\n",
+        "    assert not validate_ir([I(\"NOP\", \"x\", 1)])[\"valid\"]\n",
+        "    assert not validate_ir([I(\"ADD\", \"x\", \"a\", None)])[\"valid\"]\n",
+        "    assert not validate_ir([I(\"LOAD\", \"x\", \"addr\", 9)])[\"valid\"]\n",
+        "    assert not validate_ir([I(\"STORE\", \"addr\", \"x\", 9)])[\"valid\"]\n",
+        "    assert validate_ir([I(\"CONST\", \"x\", 1)])[\"valid\"]\n",
+        "\n",
+        "\n",
+        "def test_dump_ir_format():\n",
+        "    p = [I(\"CONST\", \"t0\", 5), I(\"ADD\", \"t1\", \"t0\", \"a\"),\n",
+        "         I(\"MUL\", \"t2\", \"t1\", 3), I(\"STORE\", \"addr0\", \"t2\")]\n",
+        "    s = dump_ir(p)\n",
+        "    lines = s.split(\"\\n\")\n",
+        "    assert lines[0] == \"// OBSERVABLE OUT: mem[addr0]\"\n",
+        "    assert lines[1] == \"t0 = CONST 5\"\n",
+        "    assert lines[2] == \"t1 = ADD t0 a\"\n",
+        "    assert lines[3] == \"t2 = MUL t1 3\"\n",
+        "    assert lines[4] == \"STORE [addr0] t2\"\n",
+        "    assert len(lines) == 5\n",
+        "\n",
+        "\n",
+        "def test_dump_ir_multi_store_header_order():\n",
+        "    p = [I(\"CONST\", \"a\", 0), I(\"CONST\", \"b\", 1),\n",
+        "         I(\"STORE\", \"a\", 5), I(\"STORE\", \"b\", 6), I(\"STORE\", \"a\", 7)]\n",
+        "    s = dump_ir(p)\n",
+        "    assert s.split(\"\\n\")[0] == \"// OBSERVABLE OUT: mem[a], mem[b]\"\n",
+        "\n",
+        "\n",
+        "def test_clean_nops():\n",
+        "    p = [I(\"NOP\"), I(\"CONST\", \"x\", 1), I(\"NOP\"), I(\"CONST\", \"y\", 2), I(\"NOP\")]\n",
+        "    out = clean_nops(p)\n",
+        "    assert len(out) == 2\n",
+        "    assert all(ins[\"op\"] != \"NOP\" for ins in out)\n",
+        "\n",
+        "\n",
+        "def test_verify_mismatches():\n",
+        "    orig = [I(\"CONST\", \"a0\", 0), I(\"CONST\", \"a1\", 1),\n",
+        "            I(\"CONST\", \"x\", 5), I(\"CONST\", \"y\", 9),\n",
+        "            I(\"STORE\", \"a0\", \"x\"), I(\"STORE\", \"a1\", \"y\")]\n",
+        "    opt = [I(\"CONST\", \"a0\", 0), I(\"CONST\", \"a1\", 1),\n",
+        "           I(\"CONST\", \"x\", 5), I(\"CONST\", \"y\", 8),\n",
+        "           I(\"STORE\", \"a0\", \"x\"), I(\"STORE\", \"a1\", \"y\")]\n",
+        "    res = verify(orig, opt, [{\"variables\": {}, \"memory\": {}}])\n",
+        "    assert res[\"equivalent\"] is False\n",
+        "    assert res[\"results\"][0][\"mismatches\"] == [1]\n",
+        "\n",
+        "\n",
+        "def test_profile_counts_and_ordering():\n",
+        "    p = [I(\"CONST\", \"x\", 1), I(\"ADD\", \"y\", \"x\", 2), I(\"MUL\", \"z\", \"y\", 3)]\n",
+        "    pr = profile(p)\n",
+        "    assert pr[\"n_instructions\"] == 3\n",
+        "    assert pr[\"n_const\"] == 1 and pr[\"n_add\"] == 1 and pr[\"n_mul\"] == 1\n",
+        "    expected = [\"n_instructions\"] + [f\"n_{op.lower()}\" for op in OP_ORDER]\n",
+        "    assert list(pr.keys()) == expected\n",
+        "\n",
+        "\n",
+        "def test_no_input_mutation():\n",
+        "    p = [I(\"CONST\", \"x\", 1), I(\"CONST\", \"addr\", 0), I(\"STORE\", \"addr\", \"x\")]\n",
+        "    st = {\"variables\": {}, \"memory\": {}}\n",
+        "    snap = {\"variables\": dict(st[\"variables\"]), \"memory\": dict(st[\"memory\"])}\n",
+        "    execute(p, st)\n",
+        "    assert st == snap\n",
+        "\n",
+        "\n",
+        "def test_clean_nops_no_aliasing():\n",
+        "    p = [I(\"CONST\", \"x\", 1), I(\"NOP\")]\n",
+        "    out = clean_nops(p)\n",
+        "    out[0][\"op\"] = \"MUL\"\n",
+        "    assert p[0][\"op\"] == \"CONST\"\n",
+        "\n",
+        "\n",
+        "def test_verify_rejects_empty_states():\n",
+        "    with pytest.raises(ValueError):\n",
+        "        verify([I(\"NOP\")], [I(\"NOP\")], [])\n",
+        "\n",
+        "\n",
+        "def test_verify_surfaces_execution_errors():\n",
+        "    good = [I(\"CONST\", \"addr\", 0), I(\"CONST\", \"x\", 1), I(\"STORE\", \"addr\", \"x\")]\n",
+        "    bad = [I(\"LOAD\", \"x\", \"missing_addr\")]\n",
+        "    res = verify(good, bad, [{\"variables\": {}, \"memory\": {}}])\n",
+        "    assert res[\"equivalent\"] is False\n",
+        "    assert res[\"results\"][0][\"mismatches\"] == [\"__execution_error__\"]\n",
+        "    assert res[\"results\"][0][\"execution_errors\"][\"optimized_error\"] is not None\n",
+        "    assert \"original_error\" not in res[\"results\"][0][\"execution_errors\"]\n",
+        "\n",
+        "\n",
+        "def test_execute_rejects_bad_initial_state_shape():\n",
+        "    r = execute([I(\"CONST\", \"x\", 1)], \"not-a-dict\")\n",
+        "    assert r[\"success\"] is False\n",
+        "    assert \"initial_state\" in r[\"error\"]\n",
+        "\n",
+        "\n",
+        "def test_compute_reduction_failure_path():\n",
+        "    orig = [I(\"CONST\", \"addr\", 0), I(\"CONST\", \"x\", 1), I(\"STORE\", \"addr\", \"x\")]\n",
+        "    bad = [I(\"CONST\", \"a\", 1), I(\"CONST\", \"b\", 0), I(\"DIV\", \"c\", \"a\", \"b\")]\n",
+        "    red = compute_reduction(orig, bad, {\"variables\": {}, \"memory\": {}})\n",
+        "    assert red[\"success\"] is False\n",
+        "    assert red[\"relative_savings\"] is None\n",
+        "    assert red[\"absolute_savings\"] is None\n",
+        "    assert \"zero\" in red[\"error\"].lower()\n",
+        "\n",
+        "\n",
+        "def test_relative_savings_clamped_on_slowdown():\n",
+        "    fast = [I(\"CONST\", \"addr\", 0), I(\"CONST\", \"x\", 1), I(\"STORE\", \"addr\", \"x\")]\n",
+        "    # slower variant: extra dead MULs balloon the cycle count\n",
+        "    slow = [I(\"CONST\", \"addr\", 0), I(\"CONST\", \"x\", 1)]\n",
+        "    slow += [I(\"MUL\", \"junk\", \"x\", 2)] * 50\n",
+        "    slow += [I(\"STORE\", \"addr\", \"x\")]\n",
+        "    red = compute_reduction(fast, slow, {\"variables\": {}, \"memory\": {}})\n",
+        "    assert red[\"absolute_savings\"] < 0\n",
+        "    assert red[\"relative_savings\"] == -1.0  # clamped\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "e6b83243",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# ==== CELL 6: Push to Drive ====\n",
+        "import shutil, os\n",
+        "for f in os.listdir(LOCAL_DIR):\n",
+        "    if f.endswith(\".py\"):\n",
+        "        shutil.copy2(os.path.join(LOCAL_DIR, f), os.path.join(DRIVE_DIR, f))\n",
+        "print(\"Saved to Drive:\", sorted(os.listdir(DRIVE_DIR)))\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "5675f9a0",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# ==== CELL 7: Run tests ====\n",
+        "import subprocess\n",
+        "res = subprocess.run(\n",
+        "    [\"python\", \"-m\", \"pytest\", \"-v\", \"test_vm.py\"],\n",
+        "    cwd=LOCAL_DIR, capture_output=True, text=True,\n",
+        ")\n",
+        "print(res.stdout)\n",
+        "print(res.stderr)\n",
+        "assert res.returncode == 0, \"Tests failed\"\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "1a500bb3",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# ==== CELL 8: Smoke demo ====\n",
+        "import importlib, toy_vm, verifier, reward_utils\n",
+        "importlib.reload(toy_vm); importlib.reload(verifier); importlib.reload(reward_utils)\n",
+        "from toy_vm import dump_ir\n",
+        "from reward_utils import compute_reduction\n",
+        "from verifier import verify\n",
+        "\n",
+        "orig = [\n",
+        "    {\"op\":\"CONST\",\"dest\":\"addr\",\"src1\":0,\"src2\":None},\n",
+        "    {\"op\":\"CONST\",\"dest\":\"a\",\"src1\":2,\"src2\":None},\n",
+        "    {\"op\":\"CONST\",\"dest\":\"b\",\"src1\":3,\"src2\":None},\n",
+        "    {\"op\":\"ADD\",\"dest\":\"c\",\"src1\":\"a\",\"src2\":\"b\"},\n",
+        "    {\"op\":\"MUL\",\"dest\":\"d\",\"src1\":\"c\",\"src2\":2},\n",
+        "    {\"op\":\"MUL\",\"dest\":\"dead\",\"src1\":\"d\",\"src2\":99},\n",
+        "    {\"op\":\"STORE\",\"dest\":\"addr\",\"src1\":\"d\",\"src2\":None},\n",
+        "]\n",
+        "opt = [\n",
+        "    {\"op\":\"CONST\",\"dest\":\"addr\",\"src1\":0,\"src2\":None},\n",
+        "    {\"op\":\"CONST\",\"dest\":\"d\",\"src1\":10,\"src2\":None},\n",
+        "    {\"op\":\"STORE\",\"dest\":\"addr\",\"src1\":\"d\",\"src2\":None},\n",
+        "]\n",
+        "\n",
+        "print(dump_ir(orig)); print(\"---\"); print(dump_ir(opt)); print(\"---\")\n",
+        "print(compute_reduction(orig, opt, {\"variables\":{},\"memory\":{}}))\n",
+        "print(\"equivalent:\", verify(orig, opt, [{\"variables\":{},\"memory\":{}}])[\"equivalent\"])\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}

space/space/metahack1 (1).ipynb

@@ -0,0 +1,1379 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "source": [
+        "## Design Assumptions (do not violate)\n",
+        "\n",
+        "# 1. **DCE never eliminates STOREs.** They define program output (final mem state).\n",
+        "# 2. **Addresses are distinct by construction.** Generator allocates each address variable to a unique integer; no aliasing.\n",
+        "# 3. **CF refuses to fold DIV by zero.** If src2 == 0 on a DIV op, leave instruction unchanged.\n",
+        "# 4. **Generator never emits DIV by literal zero.** When DIV is generated, src2 is always a non-zero constant or a variable known to be non-zero.\n",
+        "# # 5. **Integer arithmetic only.** No floats anywhere — avoids equivalence-check precision issues.\n",
+        "# 6. Generator declares `observable_addrs` per program — verifier compares only these mem entries.\n",
+        "# 7. State translator annotates observable outputs at top of dump.\n",
+        "# 8. Reward distinguishes broken (-1000) from valid-but-worse (small negative) — Harshal's formula.\n",
+        "# 9. Multi-input verification: 3-5 random initial states, all must match.\n",
+        "# 10. Integer division uses Python floor division (//). Aarush's VM must match."
+      ],
+      "metadata": {
+        "id": "_XI5jT2Ibvrf"
+      },
+      "execution_count": 2,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "metadata": {
+        "id": "j6CQ327KWXwr"
+      },
+      "outputs": [],
+      "source": [
+        "# === TAC Schema v1.0 (LOCKED with Role 1 / Aarush) ===\n",
+        "# Reverse passes deferred to stretch goal — not in initial action space.\n",
+        "\n",
+        "OPS = [\"CONST\", \"ADD\", \"SUB\", \"MUL\", \"DIV\", \"LOAD\", \"STORE\", \"NOP\"]\n",
+        "\n",
+        "CYCLE_COSTS = {\n",
+        "    \"CONST\": 1,\n",
+        "    \"ADD\":   1,\n",
+        "    \"SUB\":   1,\n",
+        "    \"MUL\":   3,\n",
+        "    \"DIV\":   5,\n",
+        "    \"LOAD\":  4,\n",
+        "    \"STORE\": 4,\n",
+        "    \"NOP\":   0,\n",
+        "}\n",
+        "\n",
+        "# Instruction shape: {\"op\": str, \"dest\": str|None, \"src1\": Any, \"src2\": Any}\n",
+        "# Operands: str = variable name, int = literal constant, None = unused\n",
+        "#\n",
+        "# Op semantics:\n",
+        "#   CONST: dest = src1                      (src1 is int literal, src2 = None)\n",
+        "#   ADD/SUB/MUL/DIV: dest = src1 OP src2    (src1, src2 are var names or int literals)\n",
+        "#   LOAD:  dest = mem[src1]                 (src1 is a var holding an address)\n",
+        "#   STORE: mem[dest] = src1                 (dest is a var holding an address)\n",
+        "#   NOP:   no-op                            (all fields None)\n",
+        "#\n",
+        "# Program output (for equivalence check) = final memory state (mem dict).\n",
+        "# Programs ship as: (initial_vars: dict, initial_mem: dict, instructions: list[dict])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import random\n",
+        "\n",
+        "def generate_level_1():\n",
+        "    \"\"\"\n",
+        "    Generate a Level 1 Toy-IR program.\n",
+        "\n",
+        "    Characteristics:\n",
+        "    - 4-6 instructions\n",
+        "    - 2-3 CONST ops with literal values\n",
+        "    - 1-2 arithmetic ops on those constants (foldable by CF)\n",
+        "    - 0-1 dead variables (killable by DCE)\n",
+        "    - Exactly 1 STORE at the end so the program has an observable output\n",
+        "\n",
+        "    Returns:\n",
+        "        dict with keys: initial_vars, initial_mem, instructions, observable_addrs\n",
+        "    \"\"\"\n",
+        "    instructions = []\n",
+        "    var_counter = 0\n",
+        "\n",
+        "    def new_var():\n",
+        "        nonlocal var_counter\n",
+        "        name = f\"v{var_counter}\"\n",
+        "        var_counter += 1\n",
+        "        return name\n",
+        "\n",
+        "    # Step 1: Generate 2-3 constant assignments\n",
+        "    num_consts = random.randint(2, 3)\n",
+        "    const_vars = []\n",
+        "    for _ in range(num_consts):\n",
+        "        var = new_var()\n",
+        "        value = random.randint(1, 10)\n",
+        "        instructions.append({\"op\": \"CONST\", \"dest\": var, \"src1\": value, \"src2\": None})\n",
+        "        const_vars.append(var)\n",
+        "\n",
+        "    # Step 2: Generate 1-2 arithmetic ops using those constants\n",
+        "    num_arith = random.randint(1, 2)\n",
+        "    last_result = None\n",
+        "    for _ in range(num_arith):\n",
+        "        op = random.choice([\"ADD\", \"MUL\"])\n",
+        "        src1 = random.choice(const_vars)\n",
+        "        src2 = random.choice(const_vars)\n",
+        "        dest = new_var()\n",
+        "        instructions.append({\"op\": op, \"dest\": dest, \"src1\": src1, \"src2\": src2})\n",
+        "        last_result = dest\n",
+        "        const_vars.append(dest)\n",
+        "\n",
+        "    # Step 3: Optionally add 1 dead variable (50% chance)\n",
+        "    if random.random() < 0.5:\n",
+        "        dead_var = new_var()\n",
+        "        dead_value = random.randint(1, 10)\n",
+        "        instructions.append({\"op\": \"CONST\", \"dest\": dead_var, \"src1\": dead_value, \"src2\": None})\n",
+        "        # Note: dead_var is intentionally never used — DCE should catch it.\n",
+        "\n",
+        "    # Step 4: Add a STORE at the end so the program has observable output\n",
+        "    initial_vars = {\"addr0\": 0}\n",
+        "    instructions.append({\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": last_result, \"src2\": None})\n",
+        "\n",
+        "    initial_mem = {}\n",
+        "\n",
+        "    return {\n",
+        "        \"initial_vars\":     initial_vars,\n",
+        "        \"initial_mem\":      initial_mem,\n",
+        "        \"instructions\":     instructions,\n",
+        "        \"observable_addrs\": [0],   # Aarush's verifier compares only these mem entries\n",
+        "    }\n",
+        "\n",
+        "\n",
+        "# Sanity-check: generate a few programs and print them\n",
+        "for seed in [42, 1, 7, 99]:\n",
+        "    random.seed(seed)\n",
+        "    prog = generate_level_1()\n",
+        "    print(f\"\\n=== seed={seed} ===\")\n",
+        "    print(f\"initial_vars     : {prog['initial_vars']}\")\n",
+        "    print(f\"initial_mem      : {prog['initial_mem']}\")\n",
+        "    print(f\"observable_addrs : {prog['observable_addrs']}\")\n",
+        "    print(f\"instructions ({len(prog['instructions'])}):\")\n",
+        "    for i, instr in enumerate(prog['instructions']):\n",
+        "        print(f\"  {i}: {instr}\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "a86vD1OyWcB9",
+        "outputId": "2d6d4604-6dc1-4c29-af64-e41cf5717c0d"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "=== seed=42 ===\n",
+            "initial_vars     : {'addr0': 0}\n",
+            "initial_mem      : {}\n",
+            "observable_addrs : [0]\n",
+            "instructions (4):\n",
+            "  0: {'op': 'CONST', 'dest': 'v0', 'src1': 1, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'v1', 'src1': 5, 'src2': None}\n",
+            "  2: {'op': 'ADD', 'dest': 'v2', 'src1': 'v0', 'src2': 'v0'}\n",
+            "  3: {'op': 'STORE', 'dest': 'addr0', 'src1': 'v2', 'src2': None}\n",
+            "\n",
+            "=== seed=1 ===\n",
+            "initial_vars     : {'addr0': 0}\n",
+            "initial_mem      : {}\n",
+            "observable_addrs : [0]\n",
+            "instructions (5):\n",
+            "  0: {'op': 'CONST', 'dest': 'v0', 'src1': 10, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'v1', 'src1': 2, 'src2': None}\n",
+            "  2: {'op': 'ADD', 'dest': 'v2', 'src1': 'v1', 'src2': 'v1'}\n",
+            "  3: {'op': 'MUL', 'dest': 'v3', 'src1': 'v2', 'src2': 'v1'}\n",
+            "  4: {'op': 'STORE', 'dest': 'addr0', 'src1': 'v3', 'src2': None}\n",
+            "\n",
+            "=== seed=7 ===\n",
+            "initial_vars     : {'addr0': 0}\n",
+            "initial_mem      : {}\n",
+            "observable_addrs : [0]\n",
+            "instructions (6):\n",
+            "  0: {'op': 'CONST', 'dest': 'v0', 'src1': 3, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'v1', 'src1': 7, 'src2': None}\n",
+            "  2: {'op': 'CONST', 'dest': 'v2', 'src1': 1, 'src2': None}\n",
+            "  3: {'op': 'ADD', 'dest': 'v3', 'src1': 'v1', 'src2': 'v2'}\n",
+            "  4: {'op': 'CONST', 'dest': 'v4', 'src1': 9, 'src2': None}\n",
+            "  5: {'op': 'STORE', 'dest': 'addr0', 'src1': 'v3', 'src2': None}\n",
+            "\n",
+            "=== seed=99 ===\n",
+            "initial_vars     : {'addr0': 0}\n",
+            "initial_mem      : {}\n",
+            "observable_addrs : [0]\n",
+            "instructions (5):\n",
+            "  0: {'op': 'CONST', 'dest': 'v0', 'src1': 7, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'v1', 'src1': 4, 'src2': None}\n",
+            "  2: {'op': 'CONST', 'dest': 'v2', 'src1': 10, 'src2': None}\n",
+            "  3: {'op': 'ADD', 'dest': 'v3', 'src1': 'v0', 'src2': 'v0'}\n",
+            "  4: {'op': 'STORE', 'dest': 'addr0', 'src1': 'v3', 'src2': None}\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def _resolve_operand(operand, known_constants):\n",
+        "    \"\"\"\n",
+        "    Given a TAC operand (string variable name or int literal),\n",
+        "    return its concrete integer value if known, or None if unknown.\n",
+        "    \"\"\"\n",
+        "    if isinstance(operand, int):\n",
+        "        return operand\n",
+        "    if isinstance(operand, str) and operand in known_constants:\n",
+        "        return known_constants[operand]\n",
+        "    return None\n",
+        "\n",
+        "\n",
+        "def _compute(op, v1, v2):\n",
+        "    \"\"\"Compute the result of a binary arithmetic op on two known integers.\"\"\"\n",
+        "    if op == \"ADD\": return v1 + v2\n",
+        "    if op == \"SUB\": return v1 - v2\n",
+        "    if op == \"MUL\": return v1 * v2\n",
+        "    if op == \"DIV\": return v1 // v2   # floor division (locked semantics)\n",
+        "    raise ValueError(f\"_compute called with non-arithmetic op: {op}\")\n",
+        "\n",
+        "\n",
+        "def constant_folding(program):\n",
+        "    \"\"\"\n",
+        "    Forward pass that folds constant arithmetic into CONST ops, and\n",
+        "    propagates known constants into instruction operands.\n",
+        "\n",
+        "    Behavior:\n",
+        "    - If both sources of an arithmetic op resolve to known integers,\n",
+        "      replaces the instruction with a CONST holding the computed result.\n",
+        "    - If only one source is known, still substitutes that known value\n",
+        "      into the instruction (constant propagation), enabling downstream\n",
+        "      passes (e.g., peephole) to recognize patterns like ADD-with-0 or MUL-by-1.\n",
+        "    - Refuses to fold DIV by zero (Design Assumption #3).\n",
+        "    - Always returns fresh dicts; never aliases input instructions.\n",
+        "\n",
+        "    Args:\n",
+        "        program: list of TAC instruction dicts (per locked schema).\n",
+        "\n",
+        "    Returns:\n",
+        "        new list of TAC instruction dicts. Always semantics-preserving.\n",
+        "        Never raises, never returns None.\n",
+        "    \"\"\"\n",
+        "    known_constants = {}\n",
+        "    new_program = []\n",
+        "\n",
+        "    for instr in program:\n",
+        "        # Always work on a copy — never alias input dicts\n",
+        "        instr = instr.copy()\n",
+        "        op   = instr[\"op\"]\n",
+        "        dest = instr[\"dest\"]\n",
+        "\n",
+        "        if op == \"CONST\":\n",
+        "            known_constants[dest] = instr[\"src1\"]\n",
+        "            new_program.append(instr)\n",
+        "\n",
+        "        elif op in (\"ADD\", \"SUB\", \"MUL\", \"DIV\"):\n",
+        "            # === Constant propagation: substitute known constants into operands ===\n",
+        "            if isinstance(instr[\"src1\"], str) and instr[\"src1\"] in known_constants:\n",
+        "                instr[\"src1\"] = known_constants[instr[\"src1\"]]\n",
+        "            if isinstance(instr[\"src2\"], str) and instr[\"src2\"] in known_constants:\n",
+        "                instr[\"src2\"] = known_constants[instr[\"src2\"]]\n",
+        "\n",
+        "            # === Try to fold ===\n",
+        "            v1 = _resolve_operand(instr[\"src1\"], known_constants)\n",
+        "            v2 = _resolve_operand(instr[\"src2\"], known_constants)\n",
+        "\n",
+        "            if v1 is not None and v2 is not None:\n",
+        "                # Both operands are known integers\n",
+        "                if op == \"DIV\" and v2 == 0:\n",
+        "                    # Refuse to fold DIV by zero\n",
+        "                    new_program.append(instr)\n",
+        "                    known_constants.pop(dest, None)\n",
+        "                else:\n",
+        "                    # Fold: replace with CONST\n",
+        "                    result = _compute(op, v1, v2)\n",
+        "                    new_program.append({\n",
+        "                        \"op\":   \"CONST\",\n",
+        "                        \"dest\": dest,\n",
+        "                        \"src1\": result,\n",
+        "                        \"src2\": None,\n",
+        "                    })\n",
+        "                    known_constants[dest] = result\n",
+        "            else:\n",
+        "                # Can't fold (at least one operand unknown).\n",
+        "                # Instruction may still have been mutated by propagation above.\n",
+        "                new_program.append(instr)\n",
+        "                known_constants.pop(dest, None)\n",
+        "\n",
+        "        elif op == \"LOAD\":\n",
+        "            # Memory reads aren't statically resolvable\n",
+        "            new_program.append(instr)\n",
+        "            known_constants.pop(dest, None)\n",
+        "\n",
+        "        elif op in (\"STORE\", \"NOP\"):\n",
+        "            # No dest tracking needed.\n",
+        "            # Note: we COULD propagate src1 into a STORE for downstream readability,\n",
+        "            # but the cycle cost is unchanged and the executor handles vars fine.\n",
+        "            # Leave STORE alone — keeps the code minimal.\n",
+        "            new_program.append(instr)\n",
+        "\n",
+        "        else:\n",
+        "            # Unknown op — defensive pass-through\n",
+        "            new_program.append(instr)\n",
+        "\n",
+        "    return new_program"
+      ],
+      "metadata": {
+        "id": "CGk8Fz4CZA3t"
+      },
+      "execution_count": 5,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# === Sanity tests for constant_folding ===\n",
+        "\n",
+        "# Test 1: simple fold — ADD of two CONSTs\n",
+        "test1 = [\n",
+        "    {\"op\": \"CONST\", \"dest\": \"a\", \"src1\": 3, \"src2\": None},\n",
+        "    {\"op\": \"CONST\", \"dest\": \"b\", \"src1\": 5, \"src2\": None},\n",
+        "    {\"op\": \"ADD\",   \"dest\": \"c\", \"src1\": \"a\", \"src2\": \"b\"},\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"c\", \"src2\": None},\n",
+        "]\n",
+        "result1 = constant_folding(test1)\n",
+        "print(\"Test 1 (simple ADD fold):\")\n",
+        "for i, instr in enumerate(result1): print(f\"  {i}: {instr}\")\n",
+        "# Expected: instruction 2 becomes CONST c = 8\n",
+        "\n",
+        "# Test 2: chained fold — second op uses first op's folded result\n",
+        "test2 = [\n",
+        "    {\"op\": \"CONST\", \"dest\": \"a\", \"src1\": 3, \"src2\": None},\n",
+        "    {\"op\": \"CONST\", \"dest\": \"b\", \"src1\": 5, \"src2\": None},\n",
+        "    {\"op\": \"ADD\",   \"dest\": \"c\", \"src1\": \"a\", \"src2\": \"b\"},   # → 8\n",
+        "    {\"op\": \"MUL\",   \"dest\": \"d\", \"src1\": \"c\", \"src2\": \"b\"},   # → 8 * 5 = 40\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"d\", \"src2\": None},\n",
+        "]\n",
+        "result2 = constant_folding(test2)\n",
+        "print(\"\\nTest 2 (chained fold):\")\n",
+        "for i, instr in enumerate(result2): print(f\"  {i}: {instr}\")\n",
+        "# Expected: c becomes CONST 8, d becomes CONST 40\n",
+        "\n",
+        "# Test 3: DIV by zero refused\n",
+        "test3 = [\n",
+        "    {\"op\": \"CONST\", \"dest\": \"a\", \"src1\": 10, \"src2\": None},\n",
+        "    {\"op\": \"CONST\", \"dest\": \"b\", \"src1\": 0,  \"src2\": None},\n",
+        "    {\"op\": \"DIV\",   \"dest\": \"c\", \"src1\": \"a\", \"src2\": \"b\"},   # 10/0 — must NOT fold\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"c\", \"src2\": None},\n",
+        "]\n",
+        "result3 = constant_folding(test3)\n",
+        "print(\"\\nTest 3 (DIV by zero refused):\")\n",
+        "for i, instr in enumerate(result3): print(f\"  {i}: {instr}\")\n",
+        "# Expected: instruction 2 unchanged (still DIV, not CONST)\n",
+        "\n",
+        "# Test 4: unknown source can't fold\n",
+        "test4 = [\n",
+        "    {\"op\": \"CONST\", \"dest\": \"a\", \"src1\": 3, \"src2\": None},\n",
+        "    {\"op\": \"LOAD\",  \"dest\": \"b\", \"src1\": \"addr0\", \"src2\": None},   # b is unknown\n",
+        "    {\"op\": \"ADD\",   \"dest\": \"c\", \"src1\": \"a\", \"src2\": \"b\"},        # can't fold\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"c\", \"src2\": None},\n",
+        "]\n",
+        "result4 = constant_folding(test4)\n",
+        "print(\"\\nTest 4 (LOAD makes b unknown, ADD not folded):\")\n",
+        "for i, instr in enumerate(result4): print(f\"  {i}: {instr}\")\n",
+        "# Expected: instruction 2 unchanged (still ADD)\n",
+        "\n",
+        "# Test 5: idempotence — running CF on a generated program\n",
+        "random.seed(42)\n",
+        "prog = generate_level_1()\n",
+        "folded = constant_folding(prog[\"instructions\"])\n",
+        "print(\"\\nTest 5 (CF on generated Level 1 program, seed=42):\")\n",
+        "print(\"Before:\")\n",
+        "for i, instr in enumerate(prog[\"instructions\"]): print(f\"  {i}: {instr}\")\n",
+        "print(\"After:\")\n",
+        "for i, instr in enumerate(folded): print(f\"  {i}: {instr}\")\n",
+        "\n",
+        "# Test 6: constant propagation — only one source is known\n",
+        "test6 = [\n",
+        "    {\"op\": \"CONST\", \"dest\": \"a\", \"src1\": 0, \"src2\": None},\n",
+        "    {\"op\": \"LOAD\",  \"dest\": \"b\", \"src1\": \"addr0\", \"src2\": None},   # b unknown\n",
+        "    {\"op\": \"ADD\",   \"dest\": \"c\", \"src1\": \"a\", \"src2\": \"b\"},        # a known (=0), b unknown\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"c\", \"src2\": None},\n",
+        "]\n",
+        "result6 = constant_folding(test6)\n",
+        "print(\"\\nTest 6 (propagation: a=0 substituted into ADD even though b unknown):\")\n",
+        "for i, instr in enumerate(result6): print(f\"  {i}: {instr}\")\n",
+        "# Expected: instruction 2 is still ADD (can't fold — b unknown), but src1 is now literal 0, not 'a'\n",
+        "# This sets up peephole to recognize \"ADD with 0\" later"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "WLKSTVa8fRF8",
+        "outputId": "e9480e1e-5d59-4afe-a884-bae0fa4a2192"
+      },
+      "execution_count": 6,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Test 1 (simple ADD fold):\n",
+            "  0: {'op': 'CONST', 'dest': 'a', 'src1': 3, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'b', 'src1': 5, 'src2': None}\n",
+            "  2: {'op': 'CONST', 'dest': 'c', 'src1': 8, 'src2': None}\n",
+            "  3: {'op': 'STORE', 'dest': 'addr0', 'src1': 'c', 'src2': None}\n",
+            "\n",
+            "Test 2 (chained fold):\n",
+            "  0: {'op': 'CONST', 'dest': 'a', 'src1': 3, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'b', 'src1': 5, 'src2': None}\n",
+            "  2: {'op': 'CONST', 'dest': 'c', 'src1': 8, 'src2': None}\n",
+            "  3: {'op': 'CONST', 'dest': 'd', 'src1': 40, 'src2': None}\n",
+            "  4: {'op': 'STORE', 'dest': 'addr0', 'src1': 'd', 'src2': None}\n",
+            "\n",
+            "Test 3 (DIV by zero refused):\n",
+            "  0: {'op': 'CONST', 'dest': 'a', 'src1': 10, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'b', 'src1': 0, 'src2': None}\n",
+            "  2: {'op': 'DIV', 'dest': 'c', 'src1': 10, 'src2': 0}\n",
+            "  3: {'op': 'STORE', 'dest': 'addr0', 'src1': 'c', 'src2': None}\n",
+            "\n",
+            "Test 4 (LOAD makes b unknown, ADD not folded):\n",
+            "  0: {'op': 'CONST', 'dest': 'a', 'src1': 3, 'src2': None}\n",
+            "  1: {'op': 'LOAD', 'dest': 'b', 'src1': 'addr0', 'src2': None}\n",
+            "  2: {'op': 'ADD', 'dest': 'c', 'src1': 3, 'src2': 'b'}\n",
+            "  3: {'op': 'STORE', 'dest': 'addr0', 'src1': 'c', 'src2': None}\n",
+            "\n",
+            "Test 5 (CF on generated Level 1 program, seed=42):\n",
+            "Before:\n",
+            "  0: {'op': 'CONST', 'dest': 'v0', 'src1': 1, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'v1', 'src1': 5, 'src2': None}\n",
+            "  2: {'op': 'ADD', 'dest': 'v2', 'src1': 'v0', 'src2': 'v0'}\n",
+            "  3: {'op': 'STORE', 'dest': 'addr0', 'src1': 'v2', 'src2': None}\n",
+            "After:\n",
+            "  0: {'op': 'CONST', 'dest': 'v0', 'src1': 1, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'v1', 'src1': 5, 'src2': None}\n",
+            "  2: {'op': 'CONST', 'dest': 'v2', 'src1': 2, 'src2': None}\n",
+            "  3: {'op': 'STORE', 'dest': 'addr0', 'src1': 'v2', 'src2': None}\n",
+            "\n",
+            "Test 6 (propagation: a=0 substituted into ADD even though b unknown):\n",
+            "  0: {'op': 'CONST', 'dest': 'a', 'src1': 0, 'src2': None}\n",
+            "  1: {'op': 'LOAD', 'dest': 'b', 'src1': 'addr0', 'src2': None}\n",
+            "  2: {'op': 'ADD', 'dest': 'c', 'src1': 0, 'src2': 'b'}\n",
+            "  3: {'op': 'STORE', 'dest': 'addr0', 'src1': 'c', 'src2': None}\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def dead_code_elimination(program):\n",
+        "    \"\"\"\n",
+        "    Backward liveness analysis. Replace dead instructions with NOPs,\n",
+        "    then strip NOPs.\n",
+        "\n",
+        "    Rules:\n",
+        "    - STOREs are always live (define program output).\n",
+        "    - Address variables used in STORE/LOAD are always live.\n",
+        "    - Any instruction whose dest is never read later is dead.\n",
+        "\n",
+        "    Returns a fresh list of instruction dicts. Never raises, never returns None.\n",
+        "    \"\"\"\n",
+        "    # Walk backward, build new program in reverse, then re-reverse at the end\n",
+        "    live = set()\n",
+        "    new_program_reversed = []\n",
+        "\n",
+        "    for instr in reversed(program):\n",
+        "        instr = instr.copy()  # never alias input\n",
+        "        op   = instr[\"op\"]\n",
+        "        dest = instr[\"dest\"]\n",
+        "        src1 = instr[\"src1\"]\n",
+        "        src2 = instr[\"src2\"]\n",
+        "\n",
+        "        if op == \"STORE\":\n",
+        "            # STOREs are always kept; mark sources live\n",
+        "            if isinstance(src1, str): live.add(src1)\n",
+        "            if isinstance(dest, str): live.add(dest)  # address variable\n",
+        "            new_program_reversed.append(instr)\n",
+        "\n",
+        "        elif op == \"NOP\":\n",
+        "            # Pass through; will be stripped at the end\n",
+        "            new_program_reversed.append(instr)\n",
+        "\n",
+        "        elif op in (\"CONST\", \"ADD\", \"SUB\", \"MUL\", \"DIV\", \"LOAD\"):\n",
+        "            if dest in live:\n",
+        "                # Live instruction — keep it, mark its sources live\n",
+        "                live.discard(dest)\n",
+        "                if isinstance(src1, str): live.add(src1)\n",
+        "                if isinstance(src2, str): live.add(src2)\n",
+        "                new_program_reversed.append(instr)\n",
+        "            else:\n",
+        "                # Dead — replace with NOP\n",
+        "                new_program_reversed.append({\n",
+        "                    \"op\": \"NOP\", \"dest\": None, \"src1\": None, \"src2\": None,\n",
+        "                })\n",
+        "\n",
+        "        else:\n",
+        "            # Unknown op — defensive pass-through\n",
+        "            new_program_reversed.append(instr)\n",
+        "\n",
+        "    # Reverse back to forward order, then strip NOPs\n",
+        "    new_program = list(reversed(new_program_reversed))\n",
+        "    new_program = [instr for instr in new_program if instr[\"op\"] != \"NOP\"]\n",
+        "\n",
+        "    return new_program"
+      ],
+      "metadata": {
+        "id": "5vo-KgaffTFR"
+      },
+      "execution_count": 12,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# === Sanity tests for dead_code_elimination ===\n",
+        "\n",
+        "# Test 1: simple dead variable\n",
+        "test1 = [\n",
+        "    {\"op\": \"CONST\", \"dest\": \"a\",    \"src1\": 5, \"src2\": None},\n",
+        "    {\"op\": \"CONST\", \"dest\": \"dead\", \"src1\": 99, \"src2\": None},   # never used\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"a\", \"src2\": None},\n",
+        "]\n",
+        "result1 = dead_code_elimination(test1)\n",
+        "print(\"Test 1 (kill unused CONST):\")\n",
+        "for i, instr in enumerate(result1): print(f\"  {i}: {instr}\")\n",
+        "# Expected: 'dead' instruction removed, 2 instructions remain\n",
+        "\n",
+        "# Test 2: chain of dead computation\n",
+        "test2 = [\n",
+        "    {\"op\": \"CONST\", \"dest\": \"a\", \"src1\": 5, \"src2\": None},\n",
+        "    {\"op\": \"CONST\", \"dest\": \"b\", \"src1\": 3, \"src2\": None},\n",
+        "    {\"op\": \"ADD\",   \"dest\": \"x\", \"src1\": \"a\", \"src2\": \"b\"},   # x never used → dead\n",
+        "    {\"op\": \"CONST\", \"dest\": \"c\", \"src1\": 7, \"src2\": None},\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"c\", \"src2\": None},\n",
+        "]\n",
+        "result2 = dead_code_elimination(test2)\n",
+        "print(\"\\nTest 2 (kill unused ADD and its feeders... but only if feeders are also unused):\")\n",
+        "for i, instr in enumerate(result2): print(f\"  {i}: {instr}\")\n",
+        "# Expected: x's ADD killed. a and b also killed (only fed into x, which is dead).\n",
+        "# Final: just CONST c=7, STORE.\n",
+        "\n",
+        "# Test 3: STORE always preserved\n",
+        "test3 = [\n",
+        "    {\"op\": \"CONST\", \"dest\": \"a\", \"src1\": 5, \"src2\": None},\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"a\", \"src2\": None},\n",
+        "]\n",
+        "result3 = dead_code_elimination(test3)\n",
+        "print(\"\\nTest 3 (STORE preserved, feeder kept live):\")\n",
+        "for i, instr in enumerate(result3): print(f\"  {i}: {instr}\")\n",
+        "# Expected: both instructions unchanged\n",
+        "\n",
+        "# Test 4: variable used by STORE is live, even if defined far above\n",
+        "test4 = [\n",
+        "    {\"op\": \"CONST\", \"dest\": \"a\", \"src1\": 5, \"src2\": None},   # used by STORE → live\n",
+        "    {\"op\": \"CONST\", \"dest\": \"b\", \"src1\": 9, \"src2\": None},   # never used → dead\n",
+        "    {\"op\": \"CONST\", \"dest\": \"c\", \"src1\": 1, \"src2\": None},   # never used → dead\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"a\", \"src2\": None},\n",
+        "]\n",
+        "result4 = dead_code_elimination(test4)\n",
+        "print(\"\\nTest 4 (only 'a' is live, b/c killed):\")\n",
+        "for i, instr in enumerate(result4): print(f\"  {i}: {instr}\")\n",
+        "# Expected: a's CONST + STORE remain. b, c stripped.\n",
+        "\n",
+        "# Test 5: combine CF + DCE on a generated program\n",
+        "random.seed(42)\n",
+        "prog = generate_level_1()\n",
+        "print(\"\\nTest 5 (CF then DCE on seed=42):\")\n",
+        "print(\"Original:\")\n",
+        "for i, instr in enumerate(prog[\"instructions\"]): print(f\"  {i}: {instr}\")\n",
+        "\n",
+        "after_cf = constant_folding(prog[\"instructions\"])\n",
+        "print(\"After CF:\")\n",
+        "for i, instr in enumerate(after_cf): print(f\"  {i}: {instr}\")\n",
+        "\n",
+        "after_dce = dead_code_elimination(after_cf)\n",
+        "print(\"After CF + DCE:\")\n",
+        "for i, instr in enumerate(after_dce): print(f\"  {i}: {instr}\")\n",
+        "# Expected: original 4 instructions become much shorter — dead 'v1' eliminated, v2 folded\n",
+        "\n",
+        "# Test 6: idempotence — running DCE twice gives same result\n",
+        "test6 = [\n",
+        "    {\"op\": \"CONST\", \"dest\": \"a\", \"src1\": 5, \"src2\": None},\n",
+        "    {\"op\": \"CONST\", \"dest\": \"dead\", \"src1\": 99, \"src2\": None},\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"a\", \"src2\": None},\n",
+        "]\n",
+        "once = dead_code_elimination(test6)\n",
+        "twice = dead_code_elimination(once)\n",
+        "print(\"\\nTest 6 (idempotence):\", \"PASS\" if once == twice else \"FAIL\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "vv8QRFRlvzdq",
+        "outputId": "e1d35874-ff1a-4dec-f43f-e22867dd3911"
+      },
+      "execution_count": 8,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Test 1 (kill unused CONST):\n",
+            "  0: {'op': 'CONST', 'dest': 'a', 'src1': 5, 'src2': None}\n",
+            "  1: {'op': 'STORE', 'dest': 'addr0', 'src1': 'a', 'src2': None}\n",
+            "\n",
+            "Test 2 (kill unused ADD and its feeders... but only if feeders are also unused):\n",
+            "  0: {'op': 'CONST', 'dest': 'c', 'src1': 7, 'src2': None}\n",
+            "  1: {'op': 'STORE', 'dest': 'addr0', 'src1': 'c', 'src2': None}\n",
+            "\n",
+            "Test 3 (STORE preserved, feeder kept live):\n",
+            "  0: {'op': 'CONST', 'dest': 'a', 'src1': 5, 'src2': None}\n",
+            "  1: {'op': 'STORE', 'dest': 'addr0', 'src1': 'a', 'src2': None}\n",
+            "\n",
+            "Test 4 (only 'a' is live, b/c killed):\n",
+            "  0: {'op': 'CONST', 'dest': 'a', 'src1': 5, 'src2': None}\n",
+            "  1: {'op': 'STORE', 'dest': 'addr0', 'src1': 'a', 'src2': None}\n",
+            "\n",
+            "Test 5 (CF then DCE on seed=42):\n",
+            "Original:\n",
+            "  0: {'op': 'CONST', 'dest': 'v0', 'src1': 1, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'v1', 'src1': 5, 'src2': None}\n",
+            "  2: {'op': 'ADD', 'dest': 'v2', 'src1': 'v0', 'src2': 'v0'}\n",
+            "  3: {'op': 'STORE', 'dest': 'addr0', 'src1': 'v2', 'src2': None}\n",
+            "After CF:\n",
+            "  0: {'op': 'CONST', 'dest': 'v0', 'src1': 1, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'v1', 'src1': 5, 'src2': None}\n",
+            "  2: {'op': 'CONST', 'dest': 'v2', 'src1': 2, 'src2': None}\n",
+            "  3: {'op': 'STORE', 'dest': 'addr0', 'src1': 'v2', 'src2': None}\n",
+            "After CF + DCE:\n",
+            "  0: {'op': 'CONST', 'dest': 'v2', 'src1': 2, 'src2': None}\n",
+            "  1: {'op': 'STORE', 'dest': 'addr0', 'src1': 'v2', 'src2': None}\n",
+            "\n",
+            "Test 6 (idempotence): PASS\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def peephole_optimization(program):\n",
+        "    \"\"\"\n",
+        "    Single-instruction peephole rewrites. Replaces expensive ops with\n",
+        "    cheaper equivalents when operands hit special values (0, 1, 2, self).\n",
+        "\n",
+        "    Patterns (all preserve semantics):\n",
+        "      MUL by 2      -> ADD x + x\n",
+        "      MUL by 1      -> CONST (the other operand)\n",
+        "      MUL by 0      -> CONST 0\n",
+        "      ADD with 0    -> CONST (the other operand)\n",
+        "      SUB x - x     -> CONST 0\n",
+        "      DIV by 1      -> CONST (the dividend)\n",
+        "\n",
+        "    Notes:\n",
+        "    - Operates on individual instructions; no cross-instruction state.\n",
+        "    - Relies on constant_folding having propagated literal values into operands.\n",
+        "    - Returns fresh instruction dicts; never aliases inputs.\n",
+        "\n",
+        "    Returns a new list. Never raises, never returns None.\n",
+        "    \"\"\"\n",
+        "    new_program = []\n",
+        "\n",
+        "    for instr in program:\n",
+        "        instr = instr.copy()\n",
+        "        op   = instr[\"op\"]\n",
+        "        dest = instr[\"dest\"]\n",
+        "        src1 = instr[\"src1\"]\n",
+        "        src2 = instr[\"src2\"]\n",
+        "\n",
+        "        # === MUL patterns ===\n",
+        "        if op == \"MUL\":\n",
+        "            # MUL by 0 -> CONST 0\n",
+        "            if src1 == 0 or src2 == 0:\n",
+        "                new_program.append({\"op\": \"CONST\", \"dest\": dest, \"src1\": 0, \"src2\": None})\n",
+        "                continue\n",
+        "            # MUL by 1 -> CONST (other operand) if the other operand is a literal,\n",
+        "            #            otherwise leave alone (we don't want to introduce a useless\n",
+        "            #            \"CONST dest = some_var_name\" — that's not a valid CONST).\n",
+        "            if src1 == 1 and isinstance(src2, int):\n",
+        "                new_program.append({\"op\": \"CONST\", \"dest\": dest, \"src1\": src2, \"src2\": None})\n",
+        "                continue\n",
+        "            if src2 == 1 and isinstance(src1, int):\n",
+        "                new_program.append({\"op\": \"CONST\", \"dest\": dest, \"src1\": src1, \"src2\": None})\n",
+        "                continue\n",
+        "            # MUL by 2 -> ADD x + x   (when one operand is literal 2 and the other is a var)\n",
+        "            if src1 == 2 and isinstance(src2, str):\n",
+        "                new_program.append({\"op\": \"ADD\", \"dest\": dest, \"src1\": src2, \"src2\": src2})\n",
+        "                continue\n",
+        "            if src2 == 2 and isinstance(src1, str):\n",
+        "                new_program.append({\"op\": \"ADD\", \"dest\": dest, \"src1\": src1, \"src2\": src1})\n",
+        "                continue\n",
+        "            # No pattern matched — keep as is\n",
+        "            new_program.append(instr)\n",
+        "\n",
+        "        # === ADD patterns ===\n",
+        "        elif op == \"ADD\":\n",
+        "            # ADD with 0 -> CONST (other operand) if the other operand is a literal\n",
+        "            if src1 == 0 and isinstance(src2, int):\n",
+        "                new_program.append({\"op\": \"CONST\", \"dest\": dest, \"src1\": src2, \"src2\": None})\n",
+        "                continue\n",
+        "            if src2 == 0 and isinstance(src1, int):\n",
+        "                new_program.append({\"op\": \"CONST\", \"dest\": dest, \"src1\": src1, \"src2\": None})\n",
+        "                continue\n",
+        "            # If \"ADD x + 0\" where x is a variable, we'd want a copy — but our schema\n",
+        "            # has no MOV/COPY op. Leave alone; CF + DCE handle the rest in practice.\n",
+        "            new_program.append(instr)\n",
+        "\n",
+        "        # === SUB patterns ===\n",
+        "        elif op == \"SUB\":\n",
+        "            # SUB x - x -> CONST 0 (only if both sources are the same string variable)\n",
+        "            if isinstance(src1, str) and isinstance(src2, str) and src1 == src2:\n",
+        "                new_program.append({\"op\": \"CONST\", \"dest\": dest, \"src1\": 0, \"src2\": None})\n",
+        "                continue\n",
+        "            # SUB x - 0 with literal 0 on src2 — we'd want a copy; skip (no COPY op)\n",
+        "            new_program.append(instr)\n",
+        "\n",
+        "        # === DIV patterns ===\n",
+        "        elif op == \"DIV\":\n",
+        "            # DIV by 1 -> CONST (dividend) if dividend is a literal\n",
+        "            if src2 == 1 and isinstance(src1, int):\n",
+        "                new_program.append({\"op\": \"CONST\", \"dest\": dest, \"src1\": src1, \"src2\": None})\n",
+        "                continue\n",
+        "            new_program.append(instr)\n",
+        "\n",
+        "        else:\n",
+        "            # CONST, LOAD, STORE, NOP — pass through\n",
+        "            new_program.append(instr)\n",
+        "\n",
+        "    return new_program"
+      ],
+      "metadata": {
+        "id": "IaczDNeLv5PW"
+      },
+      "execution_count": 9,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# === Sanity tests for peephole_optimization ===\n",
+        "\n",
+        "# Test 1: MUL by 2 -> ADD x+x\n",
+        "test1 = [\n",
+        "    {\"op\": \"LOAD\", \"dest\": \"y\", \"src1\": \"addr0\", \"src2\": None},\n",
+        "    {\"op\": \"MUL\",  \"dest\": \"x\", \"src1\": \"y\", \"src2\": 2},\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"x\", \"src2\": None},\n",
+        "]\n",
+        "result1 = peephole_optimization(test1)\n",
+        "print(\"Test 1 (MUL by 2 -> ADD self):\")\n",
+        "for i, instr in enumerate(result1): print(f\"  {i}: {instr}\")\n",
+        "# Expected: instruction 1 becomes ADD y+y\n",
+        "\n",
+        "# Test 2: MUL by 0 -> CONST 0\n",
+        "test2 = [\n",
+        "    {\"op\": \"LOAD\",  \"dest\": \"y\", \"src1\": \"addr0\", \"src2\": None},\n",
+        "    {\"op\": \"MUL\",   \"dest\": \"x\", \"src1\": \"y\",  \"src2\": 0},\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"x\", \"src2\": None},\n",
+        "]\n",
+        "result2 = peephole_optimization(test2)\n",
+        "print(\"\\nTest 2 (MUL by 0 -> CONST 0):\")\n",
+        "for i, instr in enumerate(result2): print(f\"  {i}: {instr}\")\n",
+        "# Expected: instruction 1 becomes CONST x = 0\n",
+        "\n",
+        "# Test 3: MUL by 1 (both literals)\n",
+        "test3 = [\n",
+        "    {\"op\": \"MUL\",   \"dest\": \"x\", \"src1\": 7, \"src2\": 1},\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"x\", \"src2\": None},\n",
+        "]\n",
+        "result3 = peephole_optimization(test3)\n",
+        "print(\"\\nTest 3 (MUL 7*1 -> CONST 7):\")\n",
+        "for i, instr in enumerate(result3): print(f\"  {i}: {instr}\")\n",
+        "# Expected: instruction 0 becomes CONST x = 7\n",
+        "\n",
+        "# Test 4: SUB x - x -> CONST 0\n",
+        "test4 = [\n",
+        "    {\"op\": \"LOAD\",  \"dest\": \"y\", \"src1\": \"addr0\", \"src2\": None},\n",
+        "    {\"op\": \"SUB\",   \"dest\": \"x\", \"src1\": \"y\", \"src2\": \"y\"},\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"x\", \"src2\": None},\n",
+        "]\n",
+        "result4 = peephole_optimization(test4)\n",
+        "print(\"\\nTest 4 (SUB y-y -> CONST 0):\")\n",
+        "for i, instr in enumerate(result4): print(f\"  {i}: {instr}\")\n",
+        "# Expected: instruction 1 becomes CONST x = 0\n",
+        "\n",
+        "# Test 5: ADD with 0\n",
+        "test5 = [\n",
+        "    {\"op\": \"ADD\",   \"dest\": \"x\", \"src1\": 0, \"src2\": 5},\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"x\", \"src2\": None},\n",
+        "]\n",
+        "result5 = peephole_optimization(test5)\n",
+        "print(\"\\nTest 5 (ADD 0+5 -> CONST 5):\")\n",
+        "for i, instr in enumerate(result5): print(f\"  {i}: {instr}\")\n",
+        "# Expected: instruction 0 becomes CONST x = 5\n",
+        "\n",
+        "# Test 6: full pipeline — CF then peephole on a generated program\n",
+        "random.seed(7)\n",
+        "prog = generate_level_1()\n",
+        "print(\"\\nTest 6 (CF then peephole on seed=7):\")\n",
+        "print(\"Original:\")\n",
+        "for i, instr in enumerate(prog[\"instructions\"]): print(f\"  {i}: {instr}\")\n",
+        "after_cf = constant_folding(prog[\"instructions\"])\n",
+        "print(\"After CF:\")\n",
+        "for i, instr in enumerate(after_cf): print(f\"  {i}: {instr}\")\n",
+        "after_peep = peephole_optimization(after_cf)\n",
+        "print(\"After CF + peephole:\")\n",
+        "for i, instr in enumerate(after_peep): print(f\"  {i}: {instr}\")\n",
+        "\n",
+        "# Test 7: idempotence\n",
+        "test7 = [\n",
+        "    {\"op\": \"MUL\",   \"dest\": \"x\", \"src1\": \"y\", \"src2\": 2},\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"x\", \"src2\": None},\n",
+        "]\n",
+        "once = peephole_optimization(test7)\n",
+        "twice = peephole_optimization(once)\n",
+        "print(\"\\nTest 7 (idempotence):\", \"PASS\" if once == twice else \"FAIL\")\n",
+        "\n",
+        "# Test 8: no false fires — vanilla program shouldn't get rewritten\n",
+        "test8 = [\n",
+        "    {\"op\": \"LOAD\", \"dest\": \"y\", \"src1\": \"addr0\", \"src2\": None},\n",
+        "    {\"op\": \"MUL\",  \"dest\": \"x\", \"src1\": \"y\", \"src2\": \"y\"},   # y*y, no peephole pattern\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"x\", \"src2\": None},\n",
+        "]\n",
+        "result8 = peephole_optimization(test8)\n",
+        "print(\"\\nTest 8 (no false rewrite on y*y):\")\n",
+        "for i, instr in enumerate(result8): print(f\"  {i}: {instr}\")\n",
+        "# Expected: instruction 1 unchanged (still MUL y*y)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "DWDUZUQvwXye",
+        "outputId": "1d1e327f-5f26-43e4-a6ac-f7a286da3781"
+      },
+      "execution_count": 10,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Test 1 (MUL by 2 -> ADD self):\n",
+            "  0: {'op': 'LOAD', 'dest': 'y', 'src1': 'addr0', 'src2': None}\n",
+            "  1: {'op': 'ADD', 'dest': 'x', 'src1': 'y', 'src2': 'y'}\n",
+            "  2: {'op': 'STORE', 'dest': 'addr0', 'src1': 'x', 'src2': None}\n",
+            "\n",
+            "Test 2 (MUL by 0 -> CONST 0):\n",
+            "  0: {'op': 'LOAD', 'dest': 'y', 'src1': 'addr0', 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'x', 'src1': 0, 'src2': None}\n",
+            "  2: {'op': 'STORE', 'dest': 'addr0', 'src1': 'x', 'src2': None}\n",
+            "\n",
+            "Test 3 (MUL 7*1 -> CONST 7):\n",
+            "  0: {'op': 'CONST', 'dest': 'x', 'src1': 7, 'src2': None}\n",
+            "  1: {'op': 'STORE', 'dest': 'addr0', 'src1': 'x', 'src2': None}\n",
+            "\n",
+            "Test 4 (SUB y-y -> CONST 0):\n",
+            "  0: {'op': 'LOAD', 'dest': 'y', 'src1': 'addr0', 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'x', 'src1': 0, 'src2': None}\n",
+            "  2: {'op': 'STORE', 'dest': 'addr0', 'src1': 'x', 'src2': None}\n",
+            "\n",
+            "Test 5 (ADD 0+5 -> CONST 5):\n",
+            "  0: {'op': 'CONST', 'dest': 'x', 'src1': 5, 'src2': None}\n",
+            "  1: {'op': 'STORE', 'dest': 'addr0', 'src1': 'x', 'src2': None}\n",
+            "\n",
+            "Test 6 (CF then peephole on seed=7):\n",
+            "Original:\n",
+            "  0: {'op': 'CONST', 'dest': 'v0', 'src1': 3, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'v1', 'src1': 7, 'src2': None}\n",
+            "  2: {'op': 'CONST', 'dest': 'v2', 'src1': 1, 'src2': None}\n",
+            "  3: {'op': 'ADD', 'dest': 'v3', 'src1': 'v1', 'src2': 'v2'}\n",
+            "  4: {'op': 'CONST', 'dest': 'v4', 'src1': 9, 'src2': None}\n",
+            "  5: {'op': 'STORE', 'dest': 'addr0', 'src1': 'v3', 'src2': None}\n",
+            "After CF:\n",
+            "  0: {'op': 'CONST', 'dest': 'v0', 'src1': 3, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'v1', 'src1': 7, 'src2': None}\n",
+            "  2: {'op': 'CONST', 'dest': 'v2', 'src1': 1, 'src2': None}\n",
+            "  3: {'op': 'CONST', 'dest': 'v3', 'src1': 8, 'src2': None}\n",
+            "  4: {'op': 'CONST', 'dest': 'v4', 'src1': 9, 'src2': None}\n",
+            "  5: {'op': 'STORE', 'dest': 'addr0', 'src1': 'v3', 'src2': None}\n",
+            "After CF + peephole:\n",
+            "  0: {'op': 'CONST', 'dest': 'v0', 'src1': 3, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'v1', 'src1': 7, 'src2': None}\n",
+            "  2: {'op': 'CONST', 'dest': 'v2', 'src1': 1, 'src2': None}\n",
+            "  3: {'op': 'CONST', 'dest': 'v3', 'src1': 8, 'src2': None}\n",
+            "  4: {'op': 'CONST', 'dest': 'v4', 'src1': 9, 'src2': None}\n",
+            "  5: {'op': 'STORE', 'dest': 'addr0', 'src1': 'v3', 'src2': None}\n",
+            "\n",
+            "Test 7 (idempotence): PASS\n",
+            "\n",
+            "Test 8 (no false rewrite on y*y):\n",
+            "  0: {'op': 'LOAD', 'dest': 'y', 'src1': 'addr0', 'src2': None}\n",
+            "  1: {'op': 'MUL', 'dest': 'x', 'src1': 'y', 'src2': 'y'}\n",
+            "  2: {'op': 'STORE', 'dest': 'addr0', 'src1': 'x', 'src2': None}\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def dump_ir(program_data):\n",
+        "    \"\"\"\n",
+        "    Convert a TAC program into a readable string for the LLM observation.\n",
+        "\n",
+        "    Format:\n",
+        "        // OBSERVABLE OUT: mem[0], mem[1]\n",
+        "        0: v0 = 3                       # CONST  [1 cycle]\n",
+        "        1: v1 = 5                       # CONST  [1 cycle]\n",
+        "        2: v2 = v0 + v1                 # ADD    [1 cycle]\n",
+        "        3: mem[addr0] = v2              # STORE  [4 cycles]\n",
+        "        // TOTAL: 7 cycles\n",
+        "\n",
+        "    Args:\n",
+        "        program_data: dict with keys 'instructions' and 'observable_addrs',\n",
+        "                      OR a raw list of instructions (legacy).\n",
+        "\n",
+        "    Returns:\n",
+        "        A multi-line string suitable for inclusion in an LLM prompt.\n",
+        "    \"\"\"\n",
+        "    # Accept both forms — full program dict or raw instruction list\n",
+        "    if isinstance(program_data, dict):\n",
+        "        instructions      = program_data[\"instructions\"]\n",
+        "        observable_addrs  = program_data.get(\"observable_addrs\", [])\n",
+        "    else:\n",
+        "        instructions      = program_data\n",
+        "        observable_addrs  = []\n",
+        "\n",
+        "    lines = []\n",
+        "\n",
+        "    # Header: observable outputs\n",
+        "    if observable_addrs:\n",
+        "        addr_str = \", \".join(f\"mem[{a}]\" for a in observable_addrs)\n",
+        "        lines.append(f\"// OBSERVABLE OUT: {addr_str}\")\n",
+        "\n",
+        "    # Body: each instruction in human-readable form\n",
+        "    total_cycles = 0\n",
+        "    for i, instr in enumerate(instructions):\n",
+        "        op   = instr[\"op\"]\n",
+        "        dest = instr[\"dest\"]\n",
+        "        src1 = instr[\"src1\"]\n",
+        "        src2 = instr[\"src2\"]\n",
+        "        cost = CYCLE_COSTS.get(op, 0)\n",
+        "        total_cycles += cost\n",
+        "\n",
+        "        # Render the instruction body\n",
+        "        if op == \"CONST\":\n",
+        "            body = f\"{dest} = {src1}\"\n",
+        "        elif op == \"ADD\":\n",
+        "            body = f\"{dest} = {src1} + {src2}\"\n",
+        "        elif op == \"SUB\":\n",
+        "            body = f\"{dest} = {src1} - {src2}\"\n",
+        "        elif op == \"MUL\":\n",
+        "            body = f\"{dest} = {src1} * {src2}\"\n",
+        "        elif op == \"DIV\":\n",
+        "            body = f\"{dest} = {src1} // {src2}\"\n",
+        "        elif op == \"LOAD\":\n",
+        "            body = f\"{dest} = mem[{src1}]\"\n",
+        "        elif op == \"STORE\":\n",
+        "            body = f\"mem[{dest}] = {src1}\"\n",
+        "        elif op == \"NOP\":\n",
+        "            body = \"nop\"\n",
+        "        else:\n",
+        "            body = f\"<unknown op: {op}>\"\n",
+        "\n",
+        "        cost_label = f\"{cost} cycle\" if cost == 1 else f\"{cost} cycles\"\n",
+        "        lines.append(f\"{i}: {body:<35} # {op:<6} [{cost_label}]\")\n",
+        "\n",
+        "    # Footer: total cycles\n",
+        "    lines.append(f\"// TOTAL: {total_cycles} cycles\")\n",
+        "\n",
+        "    return \"\\n\".join(lines)"
+      ],
+      "metadata": {
+        "id": "yB_yMNOZwaPT"
+      },
+      "execution_count": 13,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# === Sanity tests for state translator ===\n",
+        "\n",
+        "# Test 1: full generated program\n",
+        "random.seed(1)\n",
+        "prog = generate_level_1()\n",
+        "print(\"Test 1 (raw seed=1 program):\")\n",
+        "print(dump_ir(prog))\n",
+        "\n",
+        "# Test 2: after CF\n",
+        "print(\"\\nTest 2 (after CF):\")\n",
+        "folded = constant_folding(prog[\"instructions\"])\n",
+        "prog_after_cf = {**prog, \"instructions\": folded}\n",
+        "print(dump_ir(prog_after_cf))\n",
+        "\n",
+        "# Test 3: after CF + DCE — should show fewer instructions, lower total\n",
+        "print(\"\\nTest 3 (after CF + DCE):\")\n",
+        "optimized = dead_code_elimination(folded)\n",
+        "prog_optimized = {**prog, \"instructions\": optimized}\n",
+        "print(dump_ir(prog_optimized))\n",
+        "\n",
+        "# Test 4: every op type at least once\n",
+        "test4_instructions = [\n",
+        "    {\"op\": \"CONST\", \"dest\": \"a\",     \"src1\": 5,        \"src2\": None},\n",
+        "    {\"op\": \"ADD\",   \"dest\": \"b\",     \"src1\": \"a\",      \"src2\": 3},\n",
+        "    {\"op\": \"SUB\",   \"dest\": \"c\",     \"src1\": \"b\",      \"src2\": \"a\"},\n",
+        "    {\"op\": \"MUL\",   \"dest\": \"d\",     \"src1\": \"c\",      \"src2\": 2},\n",
+        "    {\"op\": \"DIV\",   \"dest\": \"e\",     \"src1\": \"d\",      \"src2\": 4},\n",
+        "    {\"op\": \"LOAD\",  \"dest\": \"f\",     \"src1\": \"addr0\",  \"src2\": None},\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"e\",      \"src2\": None},\n",
+        "    {\"op\": \"NOP\",   \"dest\": None,    \"src1\": None,     \"src2\": None},\n",
+        "]\n",
+        "test4_data = {\n",
+        "    \"instructions\":     test4_instructions,\n",
+        "    \"observable_addrs\": [0, 1],\n",
+        "}\n",
+        "print(\"\\nTest 4 (every op type):\")\n",
+        "print(dump_ir(test4_data))\n",
+        "\n",
+        "# Test 5: empty program shouldn't crash\n",
+        "print(\"\\nTest 5 (empty program):\")\n",
+        "print(dump_ir({\"instructions\": [], \"observable_addrs\": [0]}))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "SUqa7odp3wB_",
+        "outputId": "c3f44089-213a-4a69-f29f-42b755ed142a"
+      },
+      "execution_count": 14,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Test 1 (raw seed=1 program):\n",
+            "// OBSERVABLE OUT: mem[0]\n",
+            "0: v0 = 10                             # CONST  [1 cycle]\n",
+            "1: v1 = 2                              # CONST  [1 cycle]\n",
+            "2: v2 = v1 + v1                        # ADD    [1 cycle]\n",
+            "3: v3 = v2 * v1                        # MUL    [3 cycles]\n",
+            "4: mem[addr0] = v3                     # STORE  [4 cycles]\n",
+            "// TOTAL: 10 cycles\n",
+            "\n",
+            "Test 2 (after CF):\n",
+            "// OBSERVABLE OUT: mem[0]\n",
+            "0: v0 = 10                             # CONST  [1 cycle]\n",
+            "1: v1 = 2                              # CONST  [1 cycle]\n",
+            "2: v2 = 4                              # CONST  [1 cycle]\n",
+            "3: v3 = 8                              # CONST  [1 cycle]\n",
+            "4: mem[addr0] = v3                     # STORE  [4 cycles]\n",
+            "// TOTAL: 8 cycles\n",
+            "\n",
+            "Test 3 (after CF + DCE):\n",
+            "// OBSERVABLE OUT: mem[0]\n",
+            "0: v3 = 8                              # CONST  [1 cycle]\n",
+            "1: mem[addr0] = v3                     # STORE  [4 cycles]\n",
+            "// TOTAL: 5 cycles\n",
+            "\n",
+            "Test 4 (every op type):\n",
+            "// OBSERVABLE OUT: mem[0], mem[1]\n",
+            "0: a = 5                               # CONST  [1 cycle]\n",
+            "1: b = a + 3                           # ADD    [1 cycle]\n",
+            "2: c = b - a                           # SUB    [1 cycle]\n",
+            "3: d = c * 2                           # MUL    [3 cycles]\n",
+            "4: e = d // 4                          # DIV    [5 cycles]\n",
+            "5: f = mem[addr0]                      # LOAD   [4 cycles]\n",
+            "6: mem[addr0] = e                      # STORE  [4 cycles]\n",
+            "7: nop                                 # NOP    [0 cycles]\n",
+            "// TOTAL: 19 cycles\n",
+            "\n",
+            "Test 5 (empty program):\n",
+            "// OBSERVABLE OUT: mem[0]\n",
+            "// TOTAL: 0 cycles\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def generate_level_2():\n",
+        "    \"\"\"\n",
+        "    Generate a Level 2 Toy-IR program.\n",
+        "\n",
+        "    Characteristics:\n",
+        "    - 8-12 instructions\n",
+        "    - 3-5 CONSTs (some literal, some used in arithmetic)\n",
+        "    - 3-5 arithmetic ops (ADD, SUB, MUL, DIV) with chaining\n",
+        "    - 1-3 dead variables (DCE opportunities)\n",
+        "    - 1 LOAD from initial memory (introduces non-constant variable)\n",
+        "    - 1 STORE at the end (observable output)\n",
+        "    - Mix of operands designed to hit peephole patterns occasionally:\n",
+        "        - MUL by literal 2 / 1 / 0 (not always — diversity matters)\n",
+        "        - DIV by non-zero divisor only (Design Assumption #4)\n",
+        "\n",
+        "    Returns:\n",
+        "        dict with keys: initial_vars, initial_mem, instructions, observable_addrs\n",
+        "    \"\"\"\n",
+        "    instructions = []\n",
+        "    var_counter = 0\n",
+        "\n",
+        "    def new_var():\n",
+        "        nonlocal var_counter\n",
+        "        name = f\"v{var_counter}\"\n",
+        "        var_counter += 1\n",
+        "        return name\n",
+        "\n",
+        "    available_vars = []  # vars that exist and can be used as sources\n",
+        "\n",
+        "    # Step 1: 3-5 CONSTs\n",
+        "    num_consts = random.randint(3, 5)\n",
+        "    for _ in range(num_consts):\n",
+        "        var = new_var()\n",
+        "        value = random.randint(1, 10)\n",
+        "        instructions.append({\"op\": \"CONST\", \"dest\": var, \"src1\": value, \"src2\": None})\n",
+        "        available_vars.append(var)\n",
+        "\n",
+        "    # Step 2: 1 LOAD from initial memory\n",
+        "    # We'll seed initial_mem with something at a fresh address.\n",
+        "    load_addr_var = \"addr_in\"\n",
+        "    loaded_var    = new_var()\n",
+        "    instructions.append({\n",
+        "        \"op\": \"LOAD\", \"dest\": loaded_var, \"src1\": load_addr_var, \"src2\": None,\n",
+        "    })\n",
+        "    available_vars.append(loaded_var)\n",
+        "\n",
+        "    # Step 3: 3-5 arithmetic ops, chained\n",
+        "    num_arith = random.randint(3, 5)\n",
+        "    last_result = None\n",
+        "    for _ in range(num_arith):\n",
+        "        op = random.choice([\"ADD\", \"SUB\", \"MUL\", \"DIV\"])\n",
+        "\n",
+        "        # 30% chance to use a literal as src2 to expose peephole opportunities\n",
+        "        # (MUL by 2/1/0, etc.)\n",
+        "        use_literal_src2 = random.random() < 0.3\n",
+        "\n",
+        "        src1 = random.choice(available_vars)\n",
+        "        if use_literal_src2:\n",
+        "            # For DIV, never emit literal 0 (Design Assumption #4)\n",
+        "            if op == \"DIV\":\n",
+        "                src2 = random.choice([1, 2, 3, 4])  # safe non-zero divisors\n",
+        "            else:\n",
+        "                src2 = random.choice([0, 1, 2, 3])  # 0/1/2 hit peephole patterns\n",
+        "        else:\n",
+        "            src2 = random.choice(available_vars)\n",
+        "            # If we sampled a variable for DIV's src2, we can't be sure it's non-zero\n",
+        "            # at runtime. To stay safe per Assumption #4, restrict DIV to literal src2.\n",
+        "            if op == \"DIV\":\n",
+        "                src2 = random.choice([1, 2, 3, 4])\n",
+        "\n",
+        "        dest = new_var()\n",
+        "        instructions.append({\"op\": op, \"dest\": dest, \"src1\": src1, \"src2\": src2})\n",
+        "        available_vars.append(dest)\n",
+        "        last_result = dest\n",
+        "\n",
+        "    # Step 4: 1-3 extra dead CONSTs sprinkled in (DCE targets)\n",
+        "    num_dead = random.randint(1, 3)\n",
+        "    for _ in range(num_dead):\n",
+        "        dead_var   = new_var()\n",
+        "        dead_value = random.randint(1, 20)\n",
+        "        # Insert at a random position before the (eventual) STORE\n",
+        "        insert_pos = random.randint(0, len(instructions))\n",
+        "        instructions.insert(insert_pos, {\n",
+        "            \"op\": \"CONST\", \"dest\": dead_var, \"src1\": dead_value, \"src2\": None,\n",
+        "        })\n",
+        "        # Note: dead_var intentionally never used afterward\n",
+        "\n",
+        "    # Step 5: STORE the final result\n",
+        "    initial_vars = {\n",
+        "        \"addr0\":   0,\n",
+        "        \"addr_in\": 1,   # address that the LOAD reads from\n",
+        "    }\n",
+        "    initial_mem = {1: random.randint(1, 20)}  # seed mem[1] with a random value\n",
+        "\n",
+        "    instructions.append({\n",
+        "        \"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": last_result, \"src2\": None,\n",
+        "    })\n",
+        "\n",
+        "    return {\n",
+        "        \"initial_vars\":     initial_vars,\n",
+        "        \"initial_mem\":      initial_mem,\n",
+        "        \"instructions\":     instructions,\n",
+        "        \"observable_addrs\": [0],\n",
+        "    }"
+      ],
+      "metadata": {
+        "id": "OL6QbL0H3xuP"
+      },
+      "execution_count": 15,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# === Sanity tests for Level 2 generator ===\n",
+        "\n",
+        "# Test 1: spot-check a few seeds\n",
+        "for seed in [42, 1, 7]:\n",
+        "    random.seed(seed)\n",
+        "    prog = generate_level_2()\n",
+        "    print(f\"\\n=== Level 2, seed={seed} ===\")\n",
+        "    print(dump_ir(prog))\n",
+        "    print(f\"initial_vars: {prog['initial_vars']}\")\n",
+        "    print(f\"initial_mem : {prog['initial_mem']}\")\n",
+        "\n",
+        "# Test 2: full pipeline (CF + DCE + peephole) on a Level 2 program\n",
+        "print(\"\\n=== Full optimization pipeline on Level 2 (seed=42) ===\")\n",
+        "random.seed(42)\n",
+        "prog = generate_level_2()\n",
+        "print(\"ORIGINAL:\")\n",
+        "print(dump_ir(prog))\n",
+        "\n",
+        "after_cf = constant_folding(prog[\"instructions\"])\n",
+        "print(\"\\nAFTER CF:\")\n",
+        "print(dump_ir({**prog, \"instructions\": after_cf}))\n",
+        "\n",
+        "after_dce = dead_code_elimination(after_cf)\n",
+        "print(\"\\nAFTER CF + DCE:\")\n",
+        "print(dump_ir({**prog, \"instructions\": after_dce}))\n",
+        "\n",
+        "after_peep = peephole_optimization(after_dce)\n",
+        "print(\"\\nAFTER CF + DCE + PEEPHOLE:\")\n",
+        "print(dump_ir({**prog, \"instructions\": after_peep}))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "D0XjNetU5gIo",
+        "outputId": "1c35cdfc-a95d-48ff-c7ce-c4c236bbbbdb"
+      },
+      "execution_count": 16,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "=== Level 2, seed=42 ===\n",
+            "// OBSERVABLE OUT: mem[0]\n",
+            "0: v0 = 2                              # CONST  [1 cycle]\n",
+            "1: v1 = 1                              # CONST  [1 cycle]\n",
+            "2: v2 = 5                              # CONST  [1 cycle]\n",
+            "3: v3 = 4                              # CONST  [1 cycle]\n",
+            "4: v11 = 19                            # CONST  [1 cycle]\n",
+            "5: v4 = 4                              # CONST  [1 cycle]\n",
+            "6: v5 = mem[addr_in]                   # LOAD   [4 cycles]\n",
+            "7: v9 = 18                             # CONST  [1 cycle]\n",
+            "8: v10 = 8                             # CONST  [1 cycle]\n",
+            "9: v6 = v4 + v0                        # ADD    [1 cycle]\n",
+            "10: v7 = v0 // 2                        # DIV    [5 cycles]\n",
+            "11: v8 = v0 - v3                        # SUB    [1 cycle]\n",
+            "12: mem[addr0] = v8                     # STORE  [4 cycles]\n",
+            "// TOTAL: 23 cycles\n",
+            "initial_vars: {'addr0': 0, 'addr_in': 1}\n",
+            "initial_mem : {1: 1}\n",
+            "\n",
+            "=== Level 2, seed=1 ===\n",
+            "// OBSERVABLE OUT: mem[0]\n",
+            "0: v0 = 10                             # CONST  [1 cycle]\n",
+            "1: v7 = 19                             # CONST  [1 cycle]\n",
+            "2: v1 = 2                              # CONST  [1 cycle]\n",
+            "3: v2 = 5                              # CONST  [1 cycle]\n",
+            "4: v3 = mem[addr_in]                   # LOAD   [4 cycles]\n",
+            "5: v4 = v3 // 2                        # DIV    [5 cycles]\n",
+            "6: v5 = v3 + v3                        # ADD    [1 cycle]\n",
+            "7: v6 = v2 + v5                        # ADD    [1 cycle]\n",
+            "8: mem[addr0] = v6                     # STORE  [4 cycles]\n",
+            "// TOTAL: 19 cycles\n",
+            "initial_vars: {'addr0': 0, 'addr_in': 1}\n",
+            "initial_mem : {1: 11}\n",
+            "\n",
+            "=== Level 2, seed=7 ===\n",
+            "// OBSERVABLE OUT: mem[0]\n",
+            "0: v0 = 3                              # CONST  [1 cycle]\n",
+            "1: v1 = 7                              # CONST  [1 cycle]\n",
+            "2: v2 = 1                              # CONST  [1 cycle]\n",
+            "3: v3 = 2                              # CONST  [1 cycle]\n",
+            "4: v4 = mem[addr_in]                   # LOAD   [4 cycles]\n",
+            "5: v5 = v0 + v4                        # ADD    [1 cycle]\n",
+            "6: v6 = v3 - 3                         # SUB    [1 cycle]\n",
+            "7: v7 = v4 + 3                         # ADD    [1 cycle]\n",
+            "8: v10 = 2                             # CONST  [1 cycle]\n",
+            "9: v8 = v1 + v3                        # ADD    [1 cycle]\n",
+            "10: v9 = v6 + v0                        # ADD    [1 cycle]\n",
+            "11: mem[addr0] = v9                     # STORE  [4 cycles]\n",
+            "// TOTAL: 18 cycles\n",
+            "initial_vars: {'addr0': 0, 'addr_in': 1}\n",
+            "initial_mem : {1: 5}\n",
+            "\n",
+            "=== Full optimization pipeline on Level 2 (seed=42) ===\n",
+            "ORIGINAL:\n",
+            "// OBSERVABLE OUT: mem[0]\n",
+            "0: v0 = 2                              # CONST  [1 cycle]\n",
+            "1: v1 = 1                              # CONST  [1 cycle]\n",
+            "2: v2 = 5                              # CONST  [1 cycle]\n",
+            "3: v3 = 4                              # CONST  [1 cycle]\n",
+            "4: v11 = 19                            # CONST  [1 cycle]\n",
+            "5: v4 = 4                              # CONST  [1 cycle]\n",
+            "6: v5 = mem[addr_in]                   # LOAD   [4 cycles]\n",
+            "7: v9 = 18                             # CONST  [1 cycle]\n",
+            "8: v10 = 8                             # CONST  [1 cycle]\n",
+            "9: v6 = v4 + v0                        # ADD    [1 cycle]\n",
+            "10: v7 = v0 // 2                        # DIV    [5 cycles]\n",
+            "11: v8 = v0 - v3                        # SUB    [1 cycle]\n",
+            "12: mem[addr0] = v8                     # STORE  [4 cycles]\n",
+            "// TOTAL: 23 cycles\n",
+            "\n",
+            "AFTER CF:\n",
+            "// OBSERVABLE OUT: mem[0]\n",
+            "0: v0 = 2                              # CONST  [1 cycle]\n",
+            "1: v1 = 1                              # CONST  [1 cycle]\n",
+            "2: v2 = 5                              # CONST  [1 cycle]\n",
+            "3: v3 = 4                              # CONST  [1 cycle]\n",
+            "4: v11 = 19                            # CONST  [1 cycle]\n",
+            "5: v4 = 4                              # CONST  [1 cycle]\n",
+            "6: v5 = mem[addr_in]                   # LOAD   [4 cycles]\n",
+            "7: v9 = 18                             # CONST  [1 cycle]\n",
+            "8: v10 = 8                             # CONST  [1 cycle]\n",
+            "9: v6 = 6                              # CONST  [1 cycle]\n",
+            "10: v7 = 1                              # CONST  [1 cycle]\n",
+            "11: v8 = -2                             # CONST  [1 cycle]\n",
+            "12: mem[addr0] = v8                     # STORE  [4 cycles]\n",
+            "// TOTAL: 19 cycles\n",
+            "\n",
+            "AFTER CF + DCE:\n",
+            "// OBSERVABLE OUT: mem[0]\n",
+            "0: v8 = -2                             # CONST  [1 cycle]\n",
+            "1: mem[addr0] = v8                     # STORE  [4 cycles]\n",
+            "// TOTAL: 5 cycles\n",
+            "\n",
+            "AFTER CF + DCE + PEEPHOLE:\n",
+            "// OBSERVABLE OUT: mem[0]\n",
+            "0: v8 = -2                             # CONST  [1 cycle]\n",
+            "1: mem[addr0] = v8                     # STORE  [4 cycles]\n",
+            "// TOTAL: 5 cycles\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "Vo-9MitD5hwM"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

space/space/space/metahack1.ipynb

@@ -0,0 +1,484 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "source": [
+        "## Design Assumptions (do not violate)\n",
+        "\n",
+        "# 1. **DCE never eliminates STOREs.** They define program output (final mem state).\n",
+        "# 2. **Addresses are distinct by construction.** Generator allocates each address variable to a unique integer; no aliasing.\n",
+        "# 3. **CF refuses to fold DIV by zero.** If src2 == 0 on a DIV op, leave instruction unchanged.\n",
+        "# 4. **Generator never emits DIV by literal zero.** When DIV is generated, src2 is always a non-zero constant or a variable known to be non-zero.\n",
+        "# # 5. **Integer arithmetic only.** No floats anywhere — avoids equivalence-check precision issues.\n",
+        "# 6. Generator declares `observable_addrs` per program — verifier compares only these mem entries.\n",
+        "# 7. State translator annotates observable outputs at top of dump.\n",
+        "# 8. Reward distinguishes broken (-1000) from valid-but-worse (small negative) — Harshal's formula.\n",
+        "# 9. Multi-input verification: 3-5 random initial states, all must match.\n",
+        "# 10. Integer division uses Python floor division (//). Aarush's VM must match."
+      ],
+      "metadata": {
+        "id": "_XI5jT2Ibvrf"
+      },
+      "execution_count": 17,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {
+        "id": "j6CQ327KWXwr"
+      },
+      "outputs": [],
+      "source": [
+        "# === TAC Schema v1.0 (LOCKED with Role 1 / Aarush) ===\n",
+        "# Reverse passes deferred to stretch goal — not in initial action space.\n",
+        "\n",
+        "OPS = [\"CONST\", \"ADD\", \"SUB\", \"MUL\", \"DIV\", \"LOAD\", \"STORE\", \"NOP\"]\n",
+        "\n",
+        "CYCLE_COSTS = {\n",
+        "    \"CONST\": 1,\n",
+        "    \"ADD\":   1,\n",
+        "    \"SUB\":   1,\n",
+        "    \"MUL\":   3,\n",
+        "    \"DIV\":   5,\n",
+        "    \"LOAD\":  4,\n",
+        "    \"STORE\": 4,\n",
+        "    \"NOP\":   0,\n",
+        "}\n",
+        "\n",
+        "# Instruction shape: {\"op\": str, \"dest\": str|None, \"src1\": Any, \"src2\": Any}\n",
+        "# Operands: str = variable name, int = literal constant, None = unused\n",
+        "#\n",
+        "# Op semantics:\n",
+        "#   CONST: dest = src1                      (src1 is int literal, src2 = None)\n",
+        "#   ADD/SUB/MUL/DIV: dest = src1 OP src2    (src1, src2 are var names or int literals)\n",
+        "#   LOAD:  dest = mem[src1]                 (src1 is a var holding an address)\n",
+        "#   STORE: mem[dest] = src1                 (dest is a var holding an address)\n",
+        "#   NOP:   no-op                            (all fields None)\n",
+        "#\n",
+        "# Program output (for equivalence check) = final memory state (mem dict).\n",
+        "# Programs ship as: (initial_vars: dict, initial_mem: dict, instructions: list[dict])\n",
+        "# 10. Integer division uses Python floor division (//). Aarush's VM must match."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import random\n",
+        "\n",
+        "def generate_level_1():\n",
+        "    \"\"\"\n",
+        "    Generate a Level 1 Toy-IR program.\n",
+        "\n",
+        "    Characteristics:\n",
+        "    - 4-6 instructions\n",
+        "    - 2-3 CONST ops with literal values\n",
+        "    - 1-2 arithmetic ops on those constants (foldable by CF)\n",
+        "    - 0-1 dead variables (killable by DCE)\n",
+        "    - Exactly 1 STORE at the end so the program has an observable output\n",
+        "\n",
+        "    Returns:\n",
+        "        dict with keys: initial_vars, initial_mem, instructions, observable_addrs\n",
+        "    \"\"\"\n",
+        "    instructions = []\n",
+        "    var_counter = 0\n",
+        "\n",
+        "    def new_var():\n",
+        "        nonlocal var_counter\n",
+        "        name = f\"v{var_counter}\"\n",
+        "        var_counter += 1\n",
+        "        return name\n",
+        "\n",
+        "    # Step 1: Generate 2-3 constant assignments\n",
+        "    num_consts = random.randint(2, 3)\n",
+        "    const_vars = []\n",
+        "    for _ in range(num_consts):\n",
+        "        var = new_var()\n",
+        "        value = random.randint(1, 10)\n",
+        "        instructions.append({\"op\": \"CONST\", \"dest\": var, \"src1\": value, \"src2\": None})\n",
+        "        const_vars.append(var)\n",
+        "\n",
+        "    # Step 2: Generate 1-2 arithmetic ops using those constants\n",
+        "    num_arith = random.randint(1, 2)\n",
+        "    last_result = None\n",
+        "    for _ in range(num_arith):\n",
+        "        op = random.choice([\"ADD\", \"MUL\"])\n",
+        "        src1 = random.choice(const_vars)\n",
+        "        src2 = random.choice(const_vars)\n",
+        "        dest = new_var()\n",
+        "        instructions.append({\"op\": op, \"dest\": dest, \"src1\": src1, \"src2\": src2})\n",
+        "        last_result = dest\n",
+        "        const_vars.append(dest)\n",
+        "\n",
+        "    # Step 3: Optionally add 1 dead variable (50% chance)\n",
+        "    if random.random() < 0.5:\n",
+        "        dead_var = new_var()\n",
+        "        dead_value = random.randint(1, 10)\n",
+        "        instructions.append({\"op\": \"CONST\", \"dest\": dead_var, \"src1\": dead_value, \"src2\": None})\n",
+        "        # Note: dead_var is intentionally never used — DCE should catch it.\n",
+        "\n",
+        "    # Step 4: Add a STORE at the end so the program has observable output\n",
+        "    initial_vars = {\"addr0\": 0}\n",
+        "    instructions.append({\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": last_result, \"src2\": None})\n",
+        "\n",
+        "    initial_mem = {}\n",
+        "\n",
+        "    return {\n",
+        "        \"initial_vars\":     initial_vars,\n",
+        "        \"initial_mem\":      initial_mem,\n",
+        "        \"instructions\":     instructions,\n",
+        "        \"observable_addrs\": [0],   # Aarush's verifier compares only these mem entries\n",
+        "    }\n",
+        "\n",
+        "\n",
+        "# Sanity-check: generate a few programs and print them\n",
+        "for seed in [42, 1, 7, 99]:\n",
+        "    random.seed(seed)\n",
+        "    prog = generate_level_1()\n",
+        "    print(f\"\\n=== seed={seed} ===\")\n",
+        "    print(f\"initial_vars     : {prog['initial_vars']}\")\n",
+        "    print(f\"initial_mem      : {prog['initial_mem']}\")\n",
+        "    print(f\"observable_addrs : {prog['observable_addrs']}\")\n",
+        "    print(f\"instructions ({len(prog['instructions'])}):\")\n",
+        "    for i, instr in enumerate(prog['instructions']):\n",
+        "        print(f\"  {i}: {instr}\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "a86vD1OyWcB9",
+        "outputId": "de3d7093-eaea-420e-a0d7-2bd9451bcf6b"
+      },
+      "execution_count": 14,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "=== seed=42 ===\n",
+            "initial_vars     : {'addr0': 0}\n",
+            "initial_mem      : {}\n",
+            "observable_addrs : [0]\n",
+            "instructions (4):\n",
+            "  0: {'op': 'CONST', 'dest': 'v0', 'src1': 1, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'v1', 'src1': 5, 'src2': None}\n",
+            "  2: {'op': 'ADD', 'dest': 'v2', 'src1': 'v0', 'src2': 'v0'}\n",
+            "  3: {'op': 'STORE', 'dest': 'addr0', 'src1': 'v2', 'src2': None}\n",
+            "\n",
+            "=== seed=1 ===\n",
+            "initial_vars     : {'addr0': 0}\n",
+            "initial_mem      : {}\n",
+            "observable_addrs : [0]\n",
+            "instructions (5):\n",
+            "  0: {'op': 'CONST', 'dest': 'v0', 'src1': 10, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'v1', 'src1': 2, 'src2': None}\n",
+            "  2: {'op': 'ADD', 'dest': 'v2', 'src1': 'v1', 'src2': 'v1'}\n",
+            "  3: {'op': 'MUL', 'dest': 'v3', 'src1': 'v2', 'src2': 'v1'}\n",
+            "  4: {'op': 'STORE', 'dest': 'addr0', 'src1': 'v3', 'src2': None}\n",
+            "\n",
+            "=== seed=7 ===\n",
+            "initial_vars     : {'addr0': 0}\n",
+            "initial_mem      : {}\n",
+            "observable_addrs : [0]\n",
+            "instructions (6):\n",
+            "  0: {'op': 'CONST', 'dest': 'v0', 'src1': 3, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'v1', 'src1': 7, 'src2': None}\n",
+            "  2: {'op': 'CONST', 'dest': 'v2', 'src1': 1, 'src2': None}\n",
+            "  3: {'op': 'ADD', 'dest': 'v3', 'src1': 'v1', 'src2': 'v2'}\n",
+            "  4: {'op': 'CONST', 'dest': 'v4', 'src1': 9, 'src2': None}\n",
+            "  5: {'op': 'STORE', 'dest': 'addr0', 'src1': 'v3', 'src2': None}\n",
+            "\n",
+            "=== seed=99 ===\n",
+            "initial_vars     : {'addr0': 0}\n",
+            "initial_mem      : {}\n",
+            "observable_addrs : [0]\n",
+            "instructions (5):\n",
+            "  0: {'op': 'CONST', 'dest': 'v0', 'src1': 7, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'v1', 'src1': 4, 'src2': None}\n",
+            "  2: {'op': 'CONST', 'dest': 'v2', 'src1': 10, 'src2': None}\n",
+            "  3: {'op': 'ADD', 'dest': 'v3', 'src1': 'v0', 'src2': 'v0'}\n",
+            "  4: {'op': 'STORE', 'dest': 'addr0', 'src1': 'v3', 'src2': None}\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def _resolve_operand(operand, known_constants):\n",
+        "    \"\"\"\n",
+        "    Given a TAC operand (string variable name or int literal),\n",
+        "    return its concrete integer value if known, or None if unknown.\n",
+        "    \"\"\"\n",
+        "    if isinstance(operand, int):\n",
+        "        return operand\n",
+        "    if isinstance(operand, str) and operand in known_constants:\n",
+        "        return known_constants[operand]\n",
+        "    return None\n",
+        "\n",
+        "\n",
+        "def _compute(op, v1, v2):\n",
+        "    \"\"\"Compute the result of a binary arithmetic op on two known integers.\"\"\"\n",
+        "    if op == \"ADD\": return v1 + v2\n",
+        "    if op == \"SUB\": return v1 - v2\n",
+        "    if op == \"MUL\": return v1 * v2\n",
+        "    if op == \"DIV\": return v1 // v2   # floor division (locked semantics)\n",
+        "    raise ValueError(f\"_compute called with non-arithmetic op: {op}\")\n",
+        "\n",
+        "\n",
+        "def constant_folding(program):\n",
+        "    \"\"\"\n",
+        "    Forward pass that folds constant arithmetic into CONST ops, and\n",
+        "    propagates known constants into instruction operands.\n",
+        "\n",
+        "    Behavior:\n",
+        "    - If both sources of an arithmetic op resolve to known integers,\n",
+        "      replaces the instruction with a CONST holding the computed result.\n",
+        "    - If only one source is known, still substitutes that known value\n",
+        "      into the instruction (constant propagation), enabling downstream\n",
+        "      passes (e.g., peephole) to recognize patterns like ADD-with-0 or MUL-by-1.\n",
+        "    - Refuses to fold DIV by zero (Design Assumption #3).\n",
+        "    - Always returns fresh dicts; never aliases input instructions.\n",
+        "\n",
+        "    Args:\n",
+        "        program: list of TAC instruction dicts (per locked schema).\n",
+        "\n",
+        "    Returns:\n",
+        "        new list of TAC instruction dicts. Always semantics-preserving.\n",
+        "        Never raises, never returns None.\n",
+        "    \"\"\"\n",
+        "    known_constants = {}\n",
+        "    new_program = []\n",
+        "\n",
+        "    for instr in program:\n",
+        "        # Always work on a copy — never alias input dicts\n",
+        "        instr = instr.copy()\n",
+        "        op   = instr[\"op\"]\n",
+        "        dest = instr[\"dest\"]\n",
+        "\n",
+        "        if op == \"CONST\":\n",
+        "            known_constants[dest] = instr[\"src1\"]\n",
+        "            new_program.append(instr)\n",
+        "\n",
+        "        elif op in (\"ADD\", \"SUB\", \"MUL\", \"DIV\"):\n",
+        "            # === Constant propagation: substitute known constants into operands ===\n",
+        "            if isinstance(instr[\"src1\"], str) and instr[\"src1\"] in known_constants:\n",
+        "                instr[\"src1\"] = known_constants[instr[\"src1\"]]\n",
+        "            if isinstance(instr[\"src2\"], str) and instr[\"src2\"] in known_constants:\n",
+        "                instr[\"src2\"] = known_constants[instr[\"src2\"]]\n",
+        "\n",
+        "            # === Try to fold ===\n",
+        "            v1 = _resolve_operand(instr[\"src1\"], known_constants)\n",
+        "            v2 = _resolve_operand(instr[\"src2\"], known_constants)\n",
+        "\n",
+        "            if v1 is not None and v2 is not None:\n",
+        "                # Both operands are known integers\n",
+        "                if op == \"DIV\" and v2 == 0:\n",
+        "                    # Refuse to fold DIV by zero\n",
+        "                    new_program.append(instr)\n",
+        "                    known_constants.pop(dest, None)\n",
+        "                else:\n",
+        "                    # Fold: replace with CONST\n",
+        "                    result = _compute(op, v1, v2)\n",
+        "                    new_program.append({\n",
+        "                        \"op\":   \"CONST\",\n",
+        "                        \"dest\": dest,\n",
+        "                        \"src1\": result,\n",
+        "                        \"src2\": None,\n",
+        "                    })\n",
+        "                    known_constants[dest] = result\n",
+        "            else:\n",
+        "                # Can't fold (at least one operand unknown).\n",
+        "                # Instruction may still have been mutated by propagation above.\n",
+        "                new_program.append(instr)\n",
+        "                known_constants.pop(dest, None)\n",
+        "\n",
+        "        elif op == \"LOAD\":\n",
+        "            # Memory reads aren't statically resolvable\n",
+        "            new_program.append(instr)\n",
+        "            known_constants.pop(dest, None)\n",
+        "\n",
+        "        elif op in (\"STORE\", \"NOP\"):\n",
+        "            # No dest tracking needed.\n",
+        "            # Note: we COULD propagate src1 into a STORE for downstream readability,\n",
+        "            # but the cycle cost is unchanged and the executor handles vars fine.\n",
+        "            # Leave STORE alone — keeps the code minimal.\n",
+        "            new_program.append(instr)\n",
+        "\n",
+        "        else:\n",
+        "            # Unknown op — defensive pass-through\n",
+        "            new_program.append(instr)\n",
+        "\n",
+        "    return new_program"
+      ],
+      "metadata": {
+        "id": "CGk8Fz4CZA3t"
+      },
+      "execution_count": 18,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# === Sanity tests for constant_folding ===\n",
+        "\n",
+        "# Test 1: simple fold — ADD of two CONSTs\n",
+        "test1 = [\n",
+        "    {\"op\": \"CONST\", \"dest\": \"a\", \"src1\": 3, \"src2\": None},\n",
+        "    {\"op\": \"CONST\", \"dest\": \"b\", \"src1\": 5, \"src2\": None},\n",
+        "    {\"op\": \"ADD\",   \"dest\": \"c\", \"src1\": \"a\", \"src2\": \"b\"},\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"c\", \"src2\": None},\n",
+        "]\n",
+        "result1 = constant_folding(test1)\n",
+        "print(\"Test 1 (simple ADD fold):\")\n",
+        "for i, instr in enumerate(result1): print(f\"  {i}: {instr}\")\n",
+        "# Expected: instruction 2 becomes CONST c = 8\n",
+        "\n",
+        "# Test 2: chained fold — second op uses first op's folded result\n",
+        "test2 = [\n",
+        "    {\"op\": \"CONST\", \"dest\": \"a\", \"src1\": 3, \"src2\": None},\n",
+        "    {\"op\": \"CONST\", \"dest\": \"b\", \"src1\": 5, \"src2\": None},\n",
+        "    {\"op\": \"ADD\",   \"dest\": \"c\", \"src1\": \"a\", \"src2\": \"b\"},   # → 8\n",
+        "    {\"op\": \"MUL\",   \"dest\": \"d\", \"src1\": \"c\", \"src2\": \"b\"},   # → 8 * 5 = 40\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"d\", \"src2\": None},\n",
+        "]\n",
+        "result2 = constant_folding(test2)\n",
+        "print(\"\\nTest 2 (chained fold):\")\n",
+        "for i, instr in enumerate(result2): print(f\"  {i}: {instr}\")\n",
+        "# Expected: c becomes CONST 8, d becomes CONST 40\n",
+        "\n",
+        "# Test 3: DIV by zero refused\n",
+        "test3 = [\n",
+        "    {\"op\": \"CONST\", \"dest\": \"a\", \"src1\": 10, \"src2\": None},\n",
+        "    {\"op\": \"CONST\", \"dest\": \"b\", \"src1\": 0,  \"src2\": None},\n",
+        "    {\"op\": \"DIV\",   \"dest\": \"c\", \"src1\": \"a\", \"src2\": \"b\"},   # 10/0 — must NOT fold\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"c\", \"src2\": None},\n",
+        "]\n",
+        "result3 = constant_folding(test3)\n",
+        "print(\"\\nTest 3 (DIV by zero refused):\")\n",
+        "for i, instr in enumerate(result3): print(f\"  {i}: {instr}\")\n",
+        "# Expected: instruction 2 unchanged (still DIV, not CONST)\n",
+        "\n",
+        "# Test 4: unknown source can't fold\n",
+        "test4 = [\n",
+        "    {\"op\": \"CONST\", \"dest\": \"a\", \"src1\": 3, \"src2\": None},\n",
+        "    {\"op\": \"LOAD\",  \"dest\": \"b\", \"src1\": \"addr0\", \"src2\": None},   # b is unknown\n",
+        "    {\"op\": \"ADD\",   \"dest\": \"c\", \"src1\": \"a\", \"src2\": \"b\"},        # can't fold\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"c\", \"src2\": None},\n",
+        "]\n",
+        "result4 = constant_folding(test4)\n",
+        "print(\"\\nTest 4 (LOAD makes b unknown, ADD not folded):\")\n",
+        "for i, instr in enumerate(result4): print(f\"  {i}: {instr}\")\n",
+        "# Expected: instruction 2 unchanged (still ADD)\n",
+        "\n",
+        "# Test 5: idempotence — running CF on a generated program\n",
+        "random.seed(42)\n",
+        "prog = generate_level_1()\n",
+        "folded = constant_folding(prog[\"instructions\"])\n",
+        "print(\"\\nTest 5 (CF on generated Level 1 program, seed=42):\")\n",
+        "print(\"Before:\")\n",
+        "for i, instr in enumerate(prog[\"instructions\"]): print(f\"  {i}: {instr}\")\n",
+        "print(\"After:\")\n",
+        "for i, instr in enumerate(folded): print(f\"  {i}: {instr}\")\n",
+        "\n",
+        "# Test 6: constant propagation — only one source is known\n",
+        "test6 = [\n",
+        "    {\"op\": \"CONST\", \"dest\": \"a\", \"src1\": 0, \"src2\": None},\n",
+        "    {\"op\": \"LOAD\",  \"dest\": \"b\", \"src1\": \"addr0\", \"src2\": None},   # b unknown\n",
+        "    {\"op\": \"ADD\",   \"dest\": \"c\", \"src1\": \"a\", \"src2\": \"b\"},        # a known (=0), b unknown\n",
+        "    {\"op\": \"STORE\", \"dest\": \"addr0\", \"src1\": \"c\", \"src2\": None},\n",
+        "]\n",
+        "result6 = constant_folding(test6)\n",
+        "print(\"\\nTest 6 (propagation: a=0 substituted into ADD even though b unknown):\")\n",
+        "for i, instr in enumerate(result6): print(f\"  {i}: {instr}\")\n",
+        "# Expected: instruction 2 is still ADD (can't fold — b unknown), but src1 is now literal 0, not 'a'\n",
+        "# This sets up peephole to recognize \"ADD with 0\" later"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "WLKSTVa8fRF8",
+        "outputId": "27042d38-0044-4814-bbfa-8a2c2d87ee06"
+      },
+      "execution_count": 20,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Test 1 (simple ADD fold):\n",
+            "  0: {'op': 'CONST', 'dest': 'a', 'src1': 3, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'b', 'src1': 5, 'src2': None}\n",
+            "  2: {'op': 'CONST', 'dest': 'c', 'src1': 8, 'src2': None}\n",
+            "  3: {'op': 'STORE', 'dest': 'addr0', 'src1': 'c', 'src2': None}\n",
+            "\n",
+            "Test 2 (chained fold):\n",
+            "  0: {'op': 'CONST', 'dest': 'a', 'src1': 3, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'b', 'src1': 5, 'src2': None}\n",
+            "  2: {'op': 'CONST', 'dest': 'c', 'src1': 8, 'src2': None}\n",
+            "  3: {'op': 'CONST', 'dest': 'd', 'src1': 40, 'src2': None}\n",
+            "  4: {'op': 'STORE', 'dest': 'addr0', 'src1': 'd', 'src2': None}\n",
+            "\n",
+            "Test 3 (DIV by zero refused):\n",
+            "  0: {'op': 'CONST', 'dest': 'a', 'src1': 10, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'b', 'src1': 0, 'src2': None}\n",
+            "  2: {'op': 'DIV', 'dest': 'c', 'src1': 10, 'src2': 0}\n",
+            "  3: {'op': 'STORE', 'dest': 'addr0', 'src1': 'c', 'src2': None}\n",
+            "\n",
+            "Test 4 (LOAD makes b unknown, ADD not folded):\n",
+            "  0: {'op': 'CONST', 'dest': 'a', 'src1': 3, 'src2': None}\n",
+            "  1: {'op': 'LOAD', 'dest': 'b', 'src1': 'addr0', 'src2': None}\n",
+            "  2: {'op': 'ADD', 'dest': 'c', 'src1': 3, 'src2': 'b'}\n",
+            "  3: {'op': 'STORE', 'dest': 'addr0', 'src1': 'c', 'src2': None}\n",
+            "\n",
+            "Test 5 (CF on generated Level 1 program, seed=42):\n",
+            "Before:\n",
+            "  0: {'op': 'CONST', 'dest': 'v0', 'src1': 1, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'v1', 'src1': 5, 'src2': None}\n",
+            "  2: {'op': 'ADD', 'dest': 'v2', 'src1': 'v0', 'src2': 'v0'}\n",
+            "  3: {'op': 'STORE', 'dest': 'addr0', 'src1': 'v2', 'src2': None}\n",
+            "After:\n",
+            "  0: {'op': 'CONST', 'dest': 'v0', 'src1': 1, 'src2': None}\n",
+            "  1: {'op': 'CONST', 'dest': 'v1', 'src1': 5, 'src2': None}\n",
+            "  2: {'op': 'CONST', 'dest': 'v2', 'src1': 2, 'src2': None}\n",
+            "  3: {'op': 'STORE', 'dest': 'addr0', 'src1': 'v2', 'src2': None}\n",
+            "\n",
+            "Test 6 (propagation: a=0 substituted into ADD even though b unknown):\n",
+            "  0: {'op': 'CONST', 'dest': 'a', 'src1': 0, 'src2': None}\n",
+            "  1: {'op': 'LOAD', 'dest': 'b', 'src1': 'addr0', 'src2': None}\n",
+            "  2: {'op': 'ADD', 'dest': 'c', 'src1': 0, 'src2': 'b'}\n",
+            "  3: {'op': 'STORE', 'dest': 'addr0', 'src1': 'c', 'src2': None}\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "5vo-KgaffTFR"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

space/space/space/space/.github/workflows/deploy.yml

@@ -0,0 +1,30 @@
+name: Deploy to Hugging Face Space
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout Repo
+        uses: actions/checkout@v4
+
+      - name: Push to Hugging Face
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          git config --global user.email "github-actions@github.com"
+          git config --global user.name "github-actions"
+
+          git clone https://user:$HF_TOKEN@huggingface.co/spaces/greedybeserk95/Compilertetris space
+
+          rsync -av --exclude ".git" ./ space/
+
+          cd space
+          git add .
+          git commit -m "Auto deploy from GitHub" || echo "No changes"
+          git push

space/space/space/space/README.md

@@ -1,11 +1 @@
----
-title: Compilertetris
-emoji: ⚡
-colorFrom: red
-colorTo: gray
-sdk: docker
-pinned: false
-short_description: an RL environment which optimizes IR code
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# MetaHackathon2026Finals

space/space/space/space/space/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

space/space/space/space/space/README.md

@@ -0,0 +1,11 @@
+---
+title: Compilertetris
+emoji: ⚡
+colorFrom: red
+colorTo: gray
+sdk: docker
+pinned: false
+short_description: an RL environment which optimizes IR code
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference