docs/handoff

docs/optigami_handoff.md

@@ -0,0 +1,767 @@
+# OrigamiRL — OpenEnv Hackathon Handoff Document
+
+## TL;DR
+
+Build the **first multi-turn RL environment where an LLM learns to generate origami folding instructions**, verified by a computational origami simulator. Target the OpenEnv Hackathon (March 7-8, 2026, SF — $100K+ in prizes). Use OpenEnv spec + Unsloth GRPO for training. Dense verifiable rewards from origami geometry theorems (Kawasaki, Maekawa). No learned reward model needed.
+
+---
+
+## Hackathon Context
+
+- **Event:** OpenEnv Hackathon SF, hosted by Cerebral Valley + Shack15 + Meta/PyTorch
+- **Date:** March 7-8, 2026 (happening NOW)
+- **Prize:** $100K+ cash
+- **Teams:** Up to 4 people
+- **Format:** Build RL environments, post-train a base model
+
+### Judging Criteria
+
+| Category | Weight | What Matters |
+|----------|--------|-------------|
+| Environment Innovation | 40% | Novel, creative, challenging. Does it meaningfully test agent behavior? |
+| Storytelling | 30% | Clear problem explanation, engaging demo, easy to follow |
+| Training Script Showing Improvement | 20% | Observable reward curves, before/after behavior |
+| Reward and Training Pipeline Setup | 10% | Coherent reward logic, meaningful improvement in inference |
+
+### Key Sponsors to Impress
+
+- **Meta/PyTorch** — OpenEnv creators, want environments using their spec
+- **Unsloth AI** — GRPO training infra, ART (Agent Reinforcement Trainer). USE THEIR TOOLS.
+- **OpenPipe** — ART trainer (frontend/backend split for GRPO). Also use.
+- **Patronus AI** — Building "generative simulators" (auto-scaling RL environments). They care about curriculum difficulty scaling and verifiable rewards.
+- **Snorkel AI** — "2026 is the year of environments." They care about data quality and environment diversity.
+- **Hugging Face** — OpenEnv Hub, want environments deployed there
+- **Scale AI / Mercor** — Agent evaluation, structured task environments
+
+---
+
+## The Pitch (for judges)
+
+> "Spatial reasoning is the next frontier for LLM training — NeurIPS 2025 papers like OrigamiSpace showed that even GPT-5 fails at multi-step origami reasoning. But those are benchmarks, not training environments. We built OrigamiRL: the first multi-turn RL environment where an LLM agent learns to fold paper by outputting instructions, receiving geometric feedback, and improving through GRPO. Our reward function is fully verifiable — fold validity is checked against computational origami axioms, not an LLM judge. We built it on OpenEnv + Unsloth with a natural curriculum from single folds to full cranes."
+
+---
+
+## Prior Work (What Exists, Where the Gaps Are)
+
+### 1. OrigamiSpace (NeurIPS 2025 Spotlight)
+
+- **Paper:** https://arxiv.org/abs/2511.18450
+- **What it is:** Benchmark with 350 origami data instances (CP diagrams, folding processes, folded shapes). 4 evaluation tasks: Pattern Prediction, Multi-step Spatial Reasoning, Spatial Relationship Prediction, End-to-End CP Code Generation.
+- **Their compiler:** Outputs detailed flattened diagrams with crease locations and stacking relationships, supports interactive simulation with MLLMs, provides comprehensive error feedback. Checks: syntax validity, geometric foldability, no self-intersections, Kawasaki's theorem, Maekawa's theorem.
+- **Their reward metrics for code gen:** Hausdorff distance (shape similarity), dihedral angle distribution, bounding box aspect ratios, constraint satisfaction.
+- **Difficulty levels:** Easy (3-9 steps), Medium (10-19 steps), Hard (20-30 steps)
+- **Gap:** Single-turn only (LLM generates complete CP code in one shot). They mention RL exploration but it's not the focus. No multi-turn sequential folding.
+
+### 2. GamiBench (Dec 2025)
+
+- **Paper:** https://arxiv.org/abs/2512.22207
+- **What it is:** 186 regular + 186 impossible 2D crease patterns with 3D folded shapes from 6 viewpoints. 3 VQA tasks.
+- **Gap:** Evaluation-only, no training. Tests single-step spatial understanding.
+
+### 3. SpatialThinker (NeurIPS 2025)
+
+- **Paper:** https://arxiv.org/abs/2511.07403
+- **What it is:** 3D-aware MLLM trained with RL using dense spatial rewards. Constructs scene graphs. Multi-objective reward with lexicographic gating.
+- **Key architecture to steal:** Dense reward design with lexicographic ordering — format → count → accuracy → spatial. Nearly doubled RL training gains vs sparse rewards. Only needed 7K training samples with GRPO.
+- **Gap:** Static scene understanding (objects on a table), not sequential physical transformations.
+
+### 4. rigid-origami Gym (IJCAI 2023)
+
+- **Repo:** https://github.com/belalugaX/rigid-origami
+- **Paper:** "Automating Rigid Origami Design" (https://arxiv.org/abs/2211.13219)
+- **What it is:** Gym environment where agent constructs crease pattern graphs on a board. Sparse rewards. Foldability validated by triangle intersection tests + kinematic rigidity model. Game terminates on non-foldable states.
+- **Gap:** Classical RL agents (discrete grid actions), NOT LLMs generating text. Rigid-origami tessellations only, not traditional origami. No natural language.
+
+### 5. The Unique Gap We Fill
+
+Nobody has built a model that reasons about **sequential 2D-to-3D geometric transformations with physical constraints** through **natural language instructions** in a **multi-turn RL training loop**. Origami is uniquely hard because it requires tracking how a flat sheet's topology changes through a sequence of folds — mental rotation, spatial visualization, and perspective-taking all at once.
+
+---
+
+## Environment Design
+
+### Architecture Overview
+
+```
++---------------------------------------------------+
+|                   OpenEnv Server                   |
+|  +-----------+  +----------+  +--------------+    |
+|  |   State   |  |  Action  |  |   Reward     |    |
+|  | (FOLD JSON|  | (LLM     |  | (Dense,      |    |
+|  |  + target)|  |  output) |  |  verifiable) |    |
+|  +-----------+  +----------+  +--------------+    |
+|         |              |              |            |
+|         v              v              v            |
+|  +-----------------------------------------------+|
+|  |         Paper Geometry Engine (Python)         ||
+|  |  - Polygon state (Shapely)                    ||
+|  |  - Fold operations (reflection across line)   ||
+|  |  - Kawasaki/Maekawa constraint checks         ||
+|  |  - Layer tracking                             ||
+|  |  - FOLD format import/export                  ||
+|  +-----------------------------------------------+|
+|         |                                          |
+|         v                                          |
+|  +-----------------------------------------------+|
+|  |         Three.js Visualizer (Demo only)        ||
+|  |  - 3D fold animation                          ||
+|  |  - Strain heatmap                             ||
+|  |  - Instruction stream                         ||
+|  +-----------------------------------------------+|
++---------------------------------------------------+
+         |                    ^
+         v                    |
++---------------------------------------------------+
+|              Unsloth ART / GRPO Trainer            |
+|  - Qwen2.5-VL-7B or Qwen3-4B base model          |
+|  - LoRA/QLoRA for efficient training              |
+|  - Multi-turn rollouts                            |
++---------------------------------------------------+
+```
+
+### OpenEnv Spec Compliance
+
+Must implement these APIs:
+
+```python
+class OrigamiEnv:
+    async def reset() -> Observation     # New episode: flat paper + target
+    async def step(action) -> (Observation, reward, done, info)
+    async def state() -> State           # Current paper geometry
+    async def close()                    # Cleanup
+```
+
+OpenEnv repo: https://github.com/meta-pytorch/OpenEnv
+Install: `pip install -e .` then `openenv init origami_env`
+
+### State Space
+
+```python
+@dataclass
+class OrigamiState:
+    # Current paper geometry
+    vertices: List[Tuple[float, float]]       # 2D vertex positions
+    edges: List[Tuple[int, int]]              # Edge connectivity
+    edges_assignment: List[str]               # 'M', 'V', 'B', 'F' (mountain/valley/boundary/flat)
+    edges_foldAngle: List[float]              # -180 to 180 degrees
+    faces: List[List[int]]                    # Face vertex indices
+    layer_order: List[List[int]]              # Face stacking order
+
+    # Episode context
+    target_crease_pattern: dict               # Target FOLD JSON
+    target_shape_image: Optional[np.ndarray]  # Target folded shape (for multimodal)
+    instruction_history: List[str]            # Previous instructions
+    step_count: int
+    max_steps: int
+```
+
+This maps directly to the **FOLD format** (JSON-based, used by all origami software):
+
+```json
+{
+  "vertices_coords": [[0,0], [1,0], [1,1], [0,1]],
+  "edges_vertices": [[0,1], [1,2], [2,3], [3,0]],
+  "edges_assignment": ["B", "B", "B", "B"],
+  "edges_foldAngle": [0, 0, 0, 0],
+  "faces_vertices": [[0, 1, 2, 3]]
+}
+```
+
+FOLD spec: https://github.com/edemaine/fold
+FOLD JS library: https://edemaine.github.io/fold/
+
+### Action Space
+
+The LLM outputs a JSON action:
+
+```json
+{
+  "instruction": "Fold the top edge down to meet the bottom edge",
+  "fold_line": [[0, 0.5], [1, 0.5]],
+  "fold_angle": -180,
+  "assignment": "V"
+}
+```
+
+The `instruction` field is natural language (what we're training the model to produce well). The geometric fields are the verifiable representation. During training, the model outputs both; for the final demo, the NL instruction is the star.
+
+Alternative simpler action (for early iterations):
+
+```json
+{
+  "instruction": "Valley fold along the horizontal center line",
+  "fold_type": "valley",
+  "fold_axis": "horizontal",
+  "fold_position": 0.5
+}
+```
+
+### Reward Function — Dense, Multi-Objective, Lexicographically Gated
+
+Inspired by SpatialThinker's design. Rewards are computed in order; later rewards only apply if earlier gates pass.
+
+```python
+def compute_reward(state, action, new_state, target) -> dict:
+    rewards = {}
+
+    # LEVEL 1: Format (gate for everything else)
+    # Does the output parse into a valid fold operation?
+    rewards['format'] = 1.0 if parseable(action) else 0.0
+    if rewards['format'] == 0:
+        return rewards  # Stop here
+
+    # LEVEL 2: Local Geometric Validity
+    # Kawasaki's theorem: sector angles at each interior vertex sum to 2pi
+    kawasaki_valid = check_kawasaki(new_state)
+    # Maekawa's theorem: |M - V| = 2 at each interior vertex
+    maekawa_valid = check_maekawa(new_state)
+    # No self-intersection
+    no_intersection = check_no_self_intersection(new_state)
+    rewards['validity'] = (kawasaki_valid + maekawa_valid + no_intersection) / 3.0
+    if rewards['validity'] < 0.5:
+        return rewards  # Stop here
+
+    # LEVEL 3: Physical Feasibility
+    # Can this fold actually be performed given layer stack?
+    layer_consistent = check_layer_ordering(new_state)
+    fold_achievable = check_fold_angle_feasible(new_state)
+    rewards['feasibility'] = (layer_consistent + fold_achievable) / 2.0
+
+    # LEVEL 4: Progress Toward Target (Dense)
+    # Crease pattern graph similarity
+    cp_similarity = crease_pattern_similarity(new_state, target)
+    # Fold angle distribution match
+    angle_similarity = fold_angle_distribution_match(new_state, target)
+    # Bounding box aspect ratio match
+    bbox_similarity = bounding_box_similarity(new_state, target)
+    rewards['progress'] = 0.4 * cp_similarity + 0.4 * angle_similarity + 0.2 * bbox_similarity
+
+    # LEVEL 5: Completion Bonus
+    if shape_matches_target(new_state, target, tolerance=0.05):
+        rewards['completion'] = 10.0
+
+    # LEVEL 6: Efficiency
+    rewards['efficiency'] = -0.01  # Small step penalty to encourage fewer folds
+
+    # Total
+    rewards['total'] = (
+        0.1 * rewards['format'] +
+        0.2 * rewards['validity'] +
+        0.1 * rewards['feasibility'] +
+        0.5 * rewards['progress'] +
+        rewards.get('completion', 0) +
+        rewards['efficiency']
+    )
+    return rewards
+```
+
+### Key Origami Theorems for Verification
+
+These are the verifiable constraints — the "unit tests" of origami:
+
+1. **Kawasaki's Theorem:** At any interior vertex of a flat-foldable crease pattern, the alternating sum of sector angles equals zero (equivalently, they sum to 2pi on each side). NECESSARY condition for flat-foldability.
+
+2. **Maekawa's Theorem:** At any interior vertex, the number of mountain folds minus valley folds equals +/-2. |M - V| = 2.
+
+3. **No self-intersection:** Faces cannot penetrate each other during folding.
+
+4. **Euler's formula for planar graphs:** V - E + F = 2 (sanity check on graph structure).
+
+5. **Huzita-Hatori axioms:** The 7 axioms defining all possible single-fold operations (point-to-point, point-to-line, line-to-line, etc.). These define the VALID action space.
+
+### Curriculum Design
+
+| Level | Folds | Examples | Complexity |
+|-------|-------|----------|-----------|
+| 1 | 1 | Valley fold in half, mountain fold corner | Single fold validity |
+| 2 | 2-3 | Paper airplane nose, triangle fold | Sequential dependency |
+| 3 | 4-6 | Simple boat, fortune teller | Multi-step with symmetry |
+| 4 | 7-12 | Paper airplane (full), jumping frog | Longer horizon planning |
+| 5 | 13-20 | Crane, lily | Complex spatial tracking |
+
+For the hackathon, focus on Levels 1-3. Even showing reward improvement on Level 1-2 is a strong result.
+
+---
+
+## Core Implementation: Python Geometry Engine
+
+This is the MOST IMPORTANT piece. Pure Python, no JS dependencies.
+
+```python
+import numpy as np
+from shapely.geometry import Polygon, LineString, MultiPolygon
+from shapely.ops import split
+from typing import List, Tuple, Dict
+import json
+
+class PaperState:
+    """Represents the current state of the origami paper."""
+
+    def __init__(self, size: float = 1.0):
+        # Start with a unit square
+        self.regions = [Polygon([(0,0), (size,0), (size,size), (0,size)])]
+        self.fold_history = []
+        self.crease_lines = []
+        self.crease_assignments = []  # 'M' or 'V'
+        self.crease_angles = []
+        self.layer_order = [0]  # Stack order of regions
+
+    def apply_fold(self, fold_line: LineString, angle: float, assignment: str) -> dict:
+        """
+        Apply a fold operation. Returns dict with validity info.
+        fold_line: Shapely LineString defining the fold axis
+        angle: fold angle in degrees (-180 to 180)
+        assignment: 'M' (mountain) or 'V' (valley)
+        """
+        result = {'valid': True, 'errors': []}
+
+        # 1. Split regions by fold line
+        new_regions = []
+        for region in self.regions:
+            if fold_line.intersects(region):
+                parts = split(region, fold_line)
+                new_regions.extend(parts.geoms)
+            else:
+                new_regions.append(region)
+
+        # 2. Determine which side folds (based on assignment)
+        folding_side = []
+        staying_side = []
+        for region in new_regions:
+            centroid = region.centroid
+            side = self._point_side(centroid, fold_line)
+            if side > 0:
+                folding_side.append(region)
+            else:
+                staying_side.append(region)
+
+        # 3. Reflect folding regions across fold line
+        reflected = [self._reflect_polygon(r, fold_line) for r in folding_side]
+
+        # 4. Update state
+        self.regions = staying_side + reflected
+        self.crease_lines.append(fold_line)
+        self.crease_assignments.append(assignment)
+        self.crease_angles.append(angle)
+        self.fold_history.append({
+            'line': list(fold_line.coords),
+            'angle': angle,
+            'assignment': assignment
+        })
+
+        # 5. Update layer order
+        self._update_layer_order(staying_side, reflected)
+
+        return result
+
+    def _reflect_polygon(self, poly: Polygon, line: LineString) -> Polygon:
+        """Reflect a polygon across a line."""
+        coords = list(poly.exterior.coords)
+        reflected_coords = [self._reflect_point(p, line) for p in coords]
+        return Polygon(reflected_coords)
+
+    def _reflect_point(self, point: tuple, line: LineString) -> tuple:
+        """Reflect a point across a line."""
+        p = np.array(point[:2])
+        l1 = np.array(line.coords[0])
+        l2 = np.array(line.coords[1])
+        d = l2 - l1
+        d = d / np.linalg.norm(d)
+        # Reflection formula: p' = p - 2(p-l1).n * n where n is normal to line
+        n = np.array([-d[1], d[0]])
+        v = p - l1
+        return tuple(p - 2 * np.dot(v, n) * n)
+
+    def _point_side(self, point, line: LineString) -> float:
+        """Returns positive if point is on left side of line, negative if right."""
+        p = np.array([point.x, point.y])
+        l1 = np.array(line.coords[0])
+        l2 = np.array(line.coords[1])
+        return float(np.cross(l2 - l1, p - l1))
+
+    def _update_layer_order(self, staying, reflected):
+        """Update the layer stacking order after a fold."""
+        self.layer_order = list(range(len(staying))) + \
+                          list(range(len(staying), len(staying) + len(reflected)))
+
+    def to_fold_json(self) -> dict:
+        """Export current state as FOLD format JSON."""
+        vertices = set()
+        for line in self.crease_lines:
+            for coord in line.coords:
+                vertices.add(tuple(round(c, 10) for c in coord))
+        # Add boundary vertices
+        for region in self.regions:
+            for coord in region.exterior.coords:
+                vertices.add(tuple(round(c, 10) for c in coord[:2]))
+
+        vertices = sorted(list(vertices))
+        vertex_map = {v: i for i, v in enumerate(vertices)}
+
+        edge_set = set()
+        edges_list = []
+        assignments_list = []
+        angles_list = []
+
+        # Add crease edges
+        for i, line in enumerate(self.crease_lines):
+            c = [tuple(round(x, 10) for x in coord) for coord in line.coords]
+            edge = tuple(sorted([vertex_map[c[0]], vertex_map[c[1]]]))
+            if edge not in edge_set:
+                edge_set.add(edge)
+                edges_list.append(list(edge))
+                assignments_list.append(self.crease_assignments[i])
+                angles_list.append(self.crease_angles[i])
+
+        return {
+            'vertices_coords': [list(v) for v in vertices],
+            'edges_vertices': edges_list,
+            'edges_assignment': assignments_list,
+            'edges_foldAngle': angles_list,
+        }
+
+
+class OrigamiVerifier:
+    """Verifiable reward functions based on origami theorems."""
+
+    @staticmethod
+    def check_kawasaki(state: PaperState) -> bool:
+        """Kawasaki's theorem: alternating sum of angles at each interior vertex = 0."""
+        fold_json = state.to_fold_json()
+        vertices = fold_json['vertices_coords']
+        edges = fold_json['edges_vertices']
+
+        for v_idx in range(len(vertices)):
+            v = vertices[v_idx]
+            incident_edges = [e for e in edges if v_idx in e]
+            if len(incident_edges) < 4:
+                continue  # Need degree-4+ for Kawasaki
+
+            # Calculate sector angles
+            angles = []
+            for e in incident_edges:
+                other = e[1] if e[0] == v_idx else e[0]
+                other_v = vertices[other]
+                angle = np.arctan2(other_v[1] - v[1], other_v[0] - v[0])
+                angles.append(angle)
+
+            angles.sort()
+            sector_angles = []
+            for i in range(len(angles) - 1):
+                sector_angles.append(angles[i+1] - angles[i])
+            sector_angles.append(2*np.pi - (angles[-1] - angles[0]))
+
+            # Kawasaki: alternating sum should be ~0
+            if len(sector_angles) >= 4:
+                alt_sum = sum(sector_angles[::2]) - sum(sector_angles[1::2])
+                if abs(alt_sum) > 0.01:
+                    return False
+        return True
+
+    @staticmethod
+    def check_maekawa(state: PaperState) -> bool:
+        """Maekawa's theorem: |M - V| = 2 at each interior vertex."""
+        fold_json = state.to_fold_json()
+        vertices = fold_json['vertices_coords']
+        edges = fold_json['edges_vertices']
+        assignments = fold_json['edges_assignment']
+
+        for v_idx in range(len(vertices)):
+            incident = [(i, e) for i, e in enumerate(edges) if v_idx in e]
+            m_count = sum(1 for i, _ in incident if i < len(assignments) and assignments[i] == 'M')
+            v_count = sum(1 for i, _ in incident if i < len(assignments) and assignments[i] == 'V')
+
+            if m_count + v_count >= 4:  # Interior vertex with folds
+                if abs(m_count - v_count) != 2:
+                    return False
+        return True
+
+    @staticmethod
+    def crease_pattern_similarity(state: PaperState, target_fold_json: dict) -> float:
+        """Compare current crease pattern to target. Returns 0-1 similarity."""
+        current = state.to_fold_json()
+
+        n_current = len(current.get('edges_vertices', []))
+        n_target = len(target_fold_json.get('edges_vertices', []))
+
+        if n_target == 0:
+            return 1.0 if n_current == 0 else 0.0
+
+        edge_count_sim = 1.0 - abs(n_current - n_target) / max(n_target, 1)
+        edge_count_sim = max(0, edge_count_sim)
+
+        current_assignments = current.get('edges_assignment', [])
+        target_assignments = target_fold_json.get('edges_assignment', [])
+
+        c_m = current_assignments.count('M')
+        c_v = current_assignments.count('V')
+        t_m = target_assignments.count('M')
+        t_v = target_assignments.count('V')
+
+        total = max(t_m + t_v, 1)
+        assign_sim = 1.0 - (abs(c_m - t_m) + abs(c_v - t_v)) / (2 * total)
+        assign_sim = max(0, assign_sim)
+
+        return 0.5 * edge_count_sim + 0.5 * assign_sim
+```
+
+---
+
+## OpenEnv Environment Wrapper
+
+```python
+# origami_env/server.py
+from openenv.core import Environment
+from paper_engine import PaperState, OrigamiVerifier
+from shapely.geometry import LineString
+import json
+
+class OrigamiEnvironment(Environment):
+
+    def __init__(self, targets_dir="targets/", max_steps=20):
+        self.targets_dir = targets_dir
+        self.max_steps = max_steps
+        self.paper = None
+        self.target = None
+        self.step_count = 0
+
+    async def reset(self, target_id=None):
+        self.paper = PaperState(size=1.0)
+        self.target = self._load_target(target_id)
+        self.step_count = 0
+        return self._get_observation()
+
+    async def step(self, action):
+        self.step_count += 1
+
+        # Parse action
+        try:
+            fold_line = LineString(action['fold_line'])
+            angle = action['fold_angle']
+            assignment = action['assignment']
+        except (KeyError, Exception):
+            reward = {'format': 0, 'total': -0.1}
+            return self._get_observation(), reward, False, {'error': 'parse_failed'}
+
+        # Apply fold
+        result = self.paper.apply_fold(fold_line, angle, assignment)
+
+        # Compute rewards
+        reward = self._compute_reward(result)
+
+        # Check termination
+        done = (
+            self.step_count >= self.max_steps or
+            reward.get('completion', 0) > 0
+        )
+
+        return self._get_observation(), reward, done, {}
+
+    async def state(self):
+        return {
+            'paper': self.paper.to_fold_json(),
+            'target': self.target,
+            'step': self.step_count,
+            'fold_history': self.paper.fold_history
+        }
+
+    def _compute_reward(self, fold_result):
+        rewards = {}
+        rewards['format'] = 1.0
+
+        kawasaki = OrigamiVerifier.check_kawasaki(self.paper)
+        maekawa = OrigamiVerifier.check_maekawa(self.paper)
+        rewards['validity'] = (float(kawasaki) + float(maekawa)) / 2.0
+
+        rewards['progress'] = OrigamiVerifier.crease_pattern_similarity(
+            self.paper, self.target
+        )
+
+        if rewards['progress'] > 0.95:
+            rewards['completion'] = 10.0
+
+        rewards['efficiency'] = -0.01
+
+        rewards['total'] = (
+            0.1 * rewards['format'] +
+            0.2 * rewards['validity'] +
+            0.6 * rewards['progress'] +
+            rewards.get('completion', 0) +
+            rewards['efficiency']
+        )
+        return rewards
+
+    def _get_observation(self):
+        return {
+            'paper_state': self.paper.to_fold_json(),
+            'target': self.target,
+            'step': self.step_count,
+            'instruction_history': [str(f['line']) for f in self.paper.fold_history]
+        }
+
+    def _load_target(self, target_id):
+        if target_id:
+            with open(f"{self.targets_dir}/{target_id}.fold") as f:
+                return json.load(f)
+        # Default: simple valley fold in half
+        return {
+            'vertices_coords': [[0,0], [1,0], [1,1], [0,1], [0,0.5], [1,0.5]],
+            'edges_vertices': [[0,1], [1,2], [2,3], [3,0], [4,5]],
+            'edges_assignment': ['B', 'B', 'B', 'B', 'V'],
+            'edges_foldAngle': [0, 0, 0, 0, -180],
+        }
+```
+
+---
+
+## Training Script (Unsloth GRPO)
+
+```python
+# train.py
+from unsloth import FastLanguageModel
+from trl import GRPOConfig, GRPOTrainer
+import torch
+
+# Load model
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name="unsloth/Qwen2.5-7B-Instruct",
+    max_seq_length=4096,
+    load_in_4bit=True,
+)
+
+# Add LoRA
+model = FastLanguageModel.get_peft_model(
+    model,
+    r=32,
+    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
+                     "gate_proj", "up_proj", "down_proj"],
+    lora_alpha=32,
+    lora_dropout=0,
+    use_gradient_checkpointing="unsloth",
+)
+
+# Reward function
+def origami_reward(completions, prompts):
+    """Compute rewards for a batch of completions."""
+    rewards = []
+    for completion in completions:
+        try:
+            action = parse_fold_action(completion)
+            paper = PaperState()
+            result = paper.apply_fold(action['fold_line'], action['angle'], action['assignment'])
+            r = compute_reward(paper, target)
+            rewards.append(r['total'])
+        except Exception:
+            rewards.append(-0.1)
+    return rewards
+
+# GRPO Config
+config = GRPOConfig(
+    output_dir="origami-grpo",
+    num_train_epochs=3,
+    per_device_train_batch_size=4,
+    gradient_accumulation_steps=4,
+    learning_rate=5e-6,
+    max_completion_length=512,
+    num_generations=8,
+    temperature=1.0,
+    logging_steps=1,
+)
+
+dataset = load_origami_prompts()
+
+trainer = GRPOTrainer(
+    model=model,
+    config=config,
+    train_dataset=dataset,
+    reward_funcs=[origami_reward],
+    tokenizer=tokenizer,
+)
+
+trainer.train()
+```
+
+---
+
+## Visualization (Demo Only — Not in Training Loop)
+
+### Options
+
+1. **Origami Simulator** — https://github.com/amandaghassaei/OrigamiSimulator — Three.js, accepts FOLD files, shows folding animation with strain visualization
+2. **PackCAD** — https://packcad.com/ — Web-based, SVG crease patterns, rigid folding simulation
+3. **Custom Three.js** — Simpler but more control
+
+### Demo UI Layout
+
+```
++----------------------+----------------------+
+|   Instruction Stream |   3D Fold Viewer     |
+|                      |                      |
+| Step 1: Valley fold  |   [Three.js canvas]  |
+| along center [OK]    |                      |
+|                      |   Paper animating    |
+| Step 2: Fold top     |   fold by fold       |
+| corners to center    |                      |
+|                      |                      |
++----------------------+----------------------+
+|   Reward Dashboard                          |
+|   Format:   ========== 1.0                  |
+|   Validity: ========.. 0.8                  |
+|   Progress: ======.... 0.6                  |
+|   Total:    =======... 0.72                 |
+|                                              |
+|   [Reward curve over training steps]         |
++----------------------------------------------+
+```
+
+---
+
+## Key Libraries and Resources
+
+| Tool | Purpose | Link |
+|------|---------|------|
+| OpenEnv | Environment framework | https://github.com/meta-pytorch/OpenEnv |
+| Unsloth | GRPO training | https://github.com/unslothai/unsloth |
+| OpenPipe ART | Multi-turn RL trainer | https://github.com/OpenPipe/ART |
+| FOLD format | Origami data structure | https://github.com/edemaine/fold |
+| Rabbit Ear | JS origami library | https://github.com/rabbit-ear/rabbit-ear |
+| Origami Simulator | 3D visualization | https://github.com/amandaghassaei/OrigamiSimulator |
+| PackCAD | Folding simulation | https://packcad.com/ |
+| Shapely | Python geometry | pip install shapely |
+| rigid-origami gym | Reference gym env | https://github.com/belalugaX/rigid-origami |
+
+### Papers to Cite
+
+- OrigamiSpace: https://arxiv.org/abs/2511.18450
+- GamiBench: https://arxiv.org/abs/2512.22207
+- SpatialThinker: https://arxiv.org/abs/2511.07403
+- Automating Rigid Origami Design: https://arxiv.org/abs/2211.13219
+- FOLD format spec: https://github.com/edemaine/fold/blob/main/doc/spec.md
+
+---
+
+## Priority Build Order
+
+1. **Python geometry engine** — PaperState class with fold operations and FOLD export
+2. **Verifier functions** — Kawasaki, Maekawa, similarity metrics
+3. **OpenEnv wrapper** — step/reset/state API
+4. **Simple targets** — Hand-create 5-10 Level 1-2 targets as .fold files
+5. **Training script** — Wire up Unsloth GRPO with reward function
+6. **Run training** — Even on small model, get reward curves
+7. **Three.js visualizer** — For demo only, not in training loop
+8. **Before/after demo** — Show base model vs trained model outputs
+9. **Polish presentation narrative**
+
+---
+
+## Narrative for Judges
+
+**The story arc:**
+
+1. "LLMs are great at text but terrible at spatial reasoning"
+2. "Origami is the perfect testbed — it's sequential, physical, and verifiable"
+3. "NeurIPS 2025 showed even GPT-5 fails at origami benchmarks, but nobody built a TRAINING environment"
+4. "We built OrigamiRL — the first multi-turn RL environment for origami instruction generation"
+5. "Our rewards come from math theorems, not vibes — Kawasaki's theorem is our unit test"
+6. "Watch the model go from generating paper-tearing nonsense to valid fold sequences"
+7. "This generalizes to any domain where LLMs need to output structured physical instructions"