refactor(env): update environment, paper state, rewards, prompts, and verifier

env/environment.py

@@ -1,13 +1,13 @@
-import json
-import os
 import copy
+import json
 from pathlib import Path
 from typing import Optional
 
 from .paper_state import PaperState
-from .rewards import compute_reward, compute_terminal_reward, load_target, target_crease_edges
+from .rewards import compute_reward, compute_terminal_reward
 from .prompts import (
     code_as_policy_prompt,
+    get_semantic_description,
     step_level_prompt,
     parse_fold_list,
     parse_single_fold,
@@ -32,11 +32,13 @@ class OrigamiEnvironment:
         mode: str = 'code_as_policy',  # 'code_as_policy' or 'step'
         max_steps: int = 8,
         targets_dir: Optional[str] = None,
+        use_semantic: bool = True,
     ):
         assert mode in ('code_as_policy', 'step'), f"Unknown mode: {mode}"
         self.mode = mode
         self.max_steps = max_steps
         self.targets_dir = Path(targets_dir) if targets_dir else TARGETS_DIR
+        self.use_semantic = use_semantic
 
         self.paper: Optional[PaperState] = None
         self.target: Optional[dict] = None
@@ -44,7 +46,6 @@ class OrigamiEnvironment:
         self.step_count: int = 0
         self.last_reward: Optional[dict] = None
 
-        # Cache all available targets
         self._targets = self._load_all_targets()
 
     def _load_all_targets(self) -> dict[str, dict]:
@@ -128,7 +129,7 @@ class OrigamiEnvironment:
             if not last_result['valid']:
                 break  # stop at first invalid fold, partial credit
 
-        reward = compute_terminal_reward(self.paper, self.target)
+        reward = compute_terminal_reward(self.paper, self.target, self.max_steps)
         self.last_reward = reward
         return self._get_observation(), reward, True, self._info()
 
@@ -155,10 +156,18 @@ class OrigamiEnvironment:
             done = self.step_count >= self.max_steps
             return self._get_observation(), bad_reward, done, self._info()
 
+        prev_state = copy.deepcopy(self.paper)
         result = self.paper.add_crease(p1, p2, assignment)
         self.step_count += 1
 
-        reward = compute_reward(self.paper, result, self.target)
+        reward = compute_reward(
+            prev_state=prev_state,
+            action_result=result,
+            new_state=self.paper,
+            target=self.target,
+            step=self.step_count,
+            max_steps=self.max_steps,
+        )
         self.last_reward = reward
 
         done = (
@@ -169,8 +178,14 @@ class OrigamiEnvironment:
 
     def _get_observation(self) -> dict:
         """Returns observation dict with the LLM prompt and raw state."""
+        desc = None
+        if self.use_semantic and self.target_name and self.target:
+            desc = get_semantic_description(self.target_name, self.target)
+
         if self.mode == 'code_as_policy':
-            prompt = code_as_policy_prompt(self.target, max_folds=self.max_steps)
+            prompt = code_as_policy_prompt(
+                self.target, max_folds=self.max_steps, semantic_description=desc,
+            )
         else:
             prompt = step_level_prompt(
                 target=self.target,
@@ -178,6 +193,7 @@ class OrigamiEnvironment:
                 step=self.step_count,
                 max_steps=self.max_steps,
                 last_reward=self.last_reward,
+                semantic_description=desc,
             )
 
         return {
@@ -233,6 +249,7 @@ class OrigamiEnvironment:
             mode=self.mode,
             max_steps=self.max_steps,
             targets_dir=str(self.targets_dir),
+            use_semantic=self.use_semantic,
         )
         if self.paper is not None:
             new_env.paper = copy.deepcopy(self.paper)

env/paper_state.py

@@ -1,6 +1,5 @@
 import numpy as np
 from shapely.geometry import LineString, Point, Polygon
-from shapely.ops import unary_union
 from typing import Optional
 from .graph import CreaseGraph, VERTEX_TOL
 
@@ -34,6 +33,14 @@ class PaperState:
                 return True
         return False
 
+    def _edge_exists(self, v1_id: int, v2_id: int) -> bool:
+        """Check if an edge already exists between the two vertex IDs."""
+        pair = frozenset((v1_id, v2_id))
+        for ev1, ev2, _ in self.graph.edges.values():
+            if frozenset((ev1, ev2)) == pair:
+                return True
+        return False
+
     def add_crease(self, p1: list, p2: list, assignment: str) -> dict:
         errors: list[str] = []
 
@@ -43,6 +50,7 @@ class PaperState:
                 'anchored': False,
                 'new_vertices': [],
                 'errors': ['invalid_assignment'],
+                'duplicate': False,
             }
 
         p1 = (float(p1[0]), float(p1[1]))
@@ -53,7 +61,7 @@ class PaperState:
         seg_len = np.hypot(p2[0] - p1[0], p2[1] - p1[1])
         if seg_len < VERTEX_TOL:
             errors.append('zero_length')
-            return {'valid': False, 'anchored': anchored, 'new_vertices': [], 'errors': errors}
+            return {'valid': False, 'anchored': anchored, 'new_vertices': [], 'errors': errors, 'duplicate': False}
 
         new_line = LineString([p1, p2])
 
@@ -61,7 +69,7 @@ class PaperState:
             clipped = new_line.intersection(_UNIT_SQUARE)
             if clipped.is_empty:
                 errors.append('outside_bounds')
-                return {'valid': False, 'anchored': anchored, 'new_vertices': [], 'errors': errors}
+                return {'valid': False, 'anchored': anchored, 'new_vertices': [], 'errors': errors, 'duplicate': False}
 
         intersection_points: list[tuple[float, float]] = []
 
@@ -118,6 +126,11 @@ class PaperState:
             wid = self.graph.add_vertex(wp[0], wp[1])
             waypoint_ids.append(wid)
 
+        duplicate = any(
+            self._edge_exists(waypoint_ids[i], waypoint_ids[i + 1])
+            for i in range(len(waypoint_ids) - 1)
+        )
+
         for i in range(len(waypoint_ids) - 1):
             wa = waypoint_ids[i]
             wb = waypoint_ids[i + 1]
@@ -138,6 +151,7 @@ class PaperState:
             'anchored': anchored,
             'new_vertices': new_vertex_coords,
             'errors': errors,
+            'duplicate': duplicate,
         }
 
     def crease_edges(self) -> list[dict]:

env/prompts.py

@@ -6,6 +6,15 @@ _CORNERS = {(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0)}
 _BOUNDARY_X = {0.0, 1.0}
 _BOUNDARY_Y = {0.0, 1.0}
 
+# Semantic descriptions for known target patterns (used when target coords are hidden)
+DESCRIPTIONS: dict[str, str] = {
+    "valley_fold_half": "Fold the paper in half with a single valley fold along the horizontal center line.",
+    "mountain_fold_half": "Fold the paper in half with a single mountain fold along the vertical center line.",
+    "letter_fold": "Create a letter fold (two parallel valley folds dividing the paper into thirds).",
+    "diagonal_fold": "Fold the paper diagonally from one corner to the opposite corner.",
+    "waterbomb_base": "Create a waterbomb base with two valley folds along both diagonals.",
+}
+
 
 def _is_corner(x: float, y: float) -> bool:
     return (round(x, 4), round(y, 4)) in _CORNERS
@@ -33,6 +42,25 @@ def format_target_for_prompt(target: dict) -> str:
     return "\n".join(lines)
 
 
+def get_semantic_description(target_name: str, target: dict) -> str:
+    """Return a natural language description of the target crease pattern."""
+    if target_name in DESCRIPTIONS:
+        return DESCRIPTIONS[target_name]
+
+    # Fallback: generate from target dict structure
+    edges_a = target.get("edges_assignment", [])
+    valley_count = sum(1 for a in edges_a if a == "V")
+    mountain_count = sum(1 for a in edges_a if a == "M")
+    if valley_count or mountain_count:
+        parts = []
+        if valley_count:
+            parts.append(f"{valley_count} valley fold{'s' if valley_count != 1 else ''}")
+        if mountain_count:
+            parts.append(f"{mountain_count} mountain fold{'s' if mountain_count != 1 else ''}")
+        return f"Create an origami crease pattern with {', '.join(parts)}."
+    return "Create an origami crease pattern with the given folds."
+
+
 def format_anchor_points(paper_state) -> str:
     corners = []
     boundary_pts = []
@@ -95,13 +123,25 @@ def format_reward_feedback(reward: Optional[dict]) -> str:
     return "  " + "  ".join(parts)
 
 
-def code_as_policy_prompt(target: dict, max_folds: int = 8) -> str:
-    formatted_target = format_target_for_prompt(target)
-    return f"""You are an origami designer. Generate a fold sequence for a unit square [0,1]x[0,1].
-
-TARGET CREASE PATTERN:
+def code_as_policy_prompt(
+    target: dict,
+    max_folds: int = 8,
+    semantic_description: Optional[str] = None,
+) -> str:
+    if semantic_description is not None:
+        target_section = f"""TASK:
+{semantic_description}
+
+You are an origami designer. Given a description of what to fold, output a sequence of fold operations that build a crease pattern on a unit square [0,1]x[0,1]."""
+    else:
+        formatted_target = format_target_for_prompt(target)
+        target_section = f"""TARGET CREASE PATTERN:
 {formatted_target}
 
+You are an origami designer. Generate a fold sequence for a unit square [0,1]x[0,1]."""
+
+    return f"""{target_section}
+
 RULES (must hold at every interior vertex):
   - Kawasaki: alternating sector angles sum equally (each half = 180 degrees)
   - Maekawa: |mountain_count - valley_count| = 2
@@ -129,16 +169,25 @@ def step_level_prompt(
     step: int,
     max_steps: int,
     last_reward: Optional[dict] = None,
+    semantic_description: Optional[str] = None,
 ) -> str:
-    formatted_target = format_target_for_prompt(target)
+    if semantic_description is not None:
+        target_section = f"""TASK:
+{semantic_description}
+
+You are an origami designer. Given a description of what to fold, add the next crease to build the pattern."""
+    else:
+        formatted_target = format_target_for_prompt(target)
+        target_section = f"""TARGET:
+{formatted_target}
+
+You are an origami designer building a crease pattern step by step."""
+
     formatted_history = format_crease_history(paper_state)
     formatted_anchors = format_anchor_points(paper_state)
     formatted_reward = format_reward_feedback(last_reward)
 
-    return f"""You are an origami designer building a crease pattern step by step.
-
-TARGET:
-{formatted_target}
+    return f"""{target_section}
 
 CURRENT STATE (step {step} of {max_steps}):
   Creases placed:

env/rewards.py

@@ -1,5 +1,5 @@
 import json
-from .verifier import check_all_vertices, geometric_crease_coverage
+from .verifier import check_all_vertices, check_degree_sanity, geometric_crease_coverage
 from .paper_state import PaperState
 
 
@@ -28,66 +28,108 @@ def target_crease_edges(target: dict) -> list[dict]:
 
 
 def compute_reward(
-    state: PaperState,
+    prev_state: PaperState,
     action_result: dict,
+    new_state: PaperState,
     target: dict,
+    step: int,
+    max_steps: int,
 ) -> dict:
     """
-    Compute the full reward dict for a fold action.
+    Compute the full reward dict for a fold action (lexicographically gated).
 
     Args:
-        state: current PaperState AFTER the action was applied
-        action_result: {'valid': bool, 'anchored': bool, 'new_vertices': list, 'errors': list}
+        prev_state: PaperState BEFORE the action was applied
+        action_result: {'valid': bool, 'anchored': bool, 'duplicate': bool, ...}
+        new_state: PaperState AFTER the action was applied
         target: FOLD target dict
+        step: current step index
+        max_steps: maximum steps in episode
 
     Returns dict with keys:
-        format, anchored, kawasaki, maekawa, blb, progress, economy, completion, efficiency, total
+        format, anchored, novelty, kawasaki, maekawa, blb, degree_sanity,
+        progress, economy, assignment_accuracy, delta, regression,
+        completion, efficiency, total
     """
     r = {}
 
-    # Gate 1: format — did the action parse and apply?
+    # GATE 1: Format — did the action parse and apply?
     r['format'] = 1.0 if action_result.get('valid', False) else 0.0
     if not r['format']:
         r['total'] = -0.1
         return r
 
-    # Gate 2: anchoring — were endpoints valid anchor points?
+    # GATE 2: Structural sanity
     r['anchored'] = 1.0 if action_result.get('anchored', False) else 0.3
+    r['novelty'] = 0.0 if action_result.get('duplicate', False) is True else 0.2
 
-    # Vertex-level validity checks (all interior vertices)
-    vertex_scores = check_all_vertices(state.graph)
+    # LEVEL 3: Local flat-foldability
+    vertex_scores = check_all_vertices(new_state.graph)
     r['kawasaki'] = vertex_scores['kawasaki']
     r['maekawa'] = vertex_scores['maekawa']
     r['blb'] = vertex_scores['blb']
+    r['degree_sanity'] = check_degree_sanity(new_state.graph)
 
-    # Geometric progress
+    # LEVEL 4: Progress (absolute + delta)
     t_edges = target_crease_edges(target)
-    coverage, economy = geometric_crease_coverage(state, t_edges)
-    r['progress'] = coverage
-    r['economy'] = economy
+    old_coverage, _, _ = geometric_crease_coverage(prev_state, t_edges)
+    new_coverage, economy, assignment_accuracy = geometric_crease_coverage(new_state, t_edges)
 
-    # Completion bonus: high coverage + all vertex conditions satisfied
-    all_valid = (r['kawasaki'] == 1.0 and r['maekawa'] == 1.0 and r['blb'] == 1.0)
+    r['progress'] = new_coverage
+    r['economy'] = economy
+    r['assignment_accuracy'] = assignment_accuracy
+    r['delta'] = max(0.0, new_coverage - old_coverage)
+    r['regression'] = min(0.0, new_coverage - old_coverage)
+
+    # LEVEL 5: Completion bonus
+    all_valid = (
+        r['kawasaki'] == 1.0
+        and r['maekawa'] == 1.0
+        and r['blb'] == 1.0
+    )
     r['completion'] = 10.0 if (r['progress'] > 0.9 and all_valid) else 0.0
 
-    # Step cost
-    r['efficiency'] = -0.01
+    # LEVEL 6: Efficiency — escalating step cost
+    r['efficiency'] = -0.01 * (1 + step / max_steps)
 
     # Weighted total
     r['total'] = (
-        0.05 * r['anchored'] +
-        0.08 * r['kawasaki'] +
-        0.07 * r['maekawa'] +
-        0.05 * r['blb'] +
-        0.45 * r['progress'] +
-        0.10 * r['economy'] +
-        r['completion'] +
-        r['efficiency']
+        0.05 * r['anchored']
+        + 0.05 * r['novelty']
+        + 0.06 * r['kawasaki']
+        + 0.06 * r['maekawa']
+        + 0.04 * r['blb']
+        + 0.04 * r['degree_sanity']
+        + 0.25 * r['progress']
+        + 0.05 * r['economy']
+        + 0.05 * r['assignment_accuracy']
+        + 0.20 * r['delta']
+        + 0.10 * r['regression']
+        + r['completion']
+        + r['efficiency']
     )
     return r
 
 
-def compute_terminal_reward(state: PaperState, target: dict) -> dict:
-    """Compute reward for the final state after a complete fold sequence."""
-    fake_result = {'valid': True, 'anchored': True, 'new_vertices': [], 'errors': []}
-    return compute_reward(state, fake_result, target)
+def compute_terminal_reward(
+    state: PaperState,
+    target: dict,
+    max_steps: int,
+) -> dict:
+    """
+    Compute reward for the final state after a complete fold sequence.
+    Uses fresh PaperState as baseline and step = max_steps.
+    """
+    fake_result = {
+        'valid': True,
+        'anchored': True,
+        'duplicate': False,
+    }
+    return compute_reward(
+        prev_state=PaperState(),
+        action_result=fake_result,
+        new_state=state,
+        target=target,
+        step=max_steps,
+        max_steps=max_steps,
+    )

env/targets/validator_check.py

@@ -1,10 +1,12 @@
-import json, sys, os
+import json
+import os
+from pathlib import Path
 
-targets_dir = "/Users/ianalin/Desktop/optigami/env/targets"
+targets_dir = Path(__file__).parent
 for fname in os.listdir(targets_dir):
     if not fname.endswith(".fold"):
         continue
-    with open(os.path.join(targets_dir, fname)) as f:
+    with open(targets_dir / fname) as f:
         d = json.load(f)
     n_v = len(d["vertices_coords"])
     n_e = len(d["edges_vertices"])

env/verifier.py

@@ -125,45 +125,85 @@ def geometric_crease_coverage(
     target_edges: list[dict],
     tol_pos: float = 0.05,
     tol_angle_deg: float = 5.0,
-) -> tuple[float, float]:
+) -> tuple[float, float, float]:
     """
     Computes how well the current crease pattern matches the target.
 
     Args:
+        state: current paper state with crease graph
         target_edges: list of {'v1': (x1,y1), 'v2': (x2,y2), 'assignment': 'M'|'V'}
+        tol_pos: position tolerance for midpoint matching
+        tol_angle_deg: angle tolerance in degrees for direction matching
 
     Returns:
-        (coverage, economy)
-        coverage: fraction of target creases matched [0, 1]
+        (coverage, economy, assignment_accuracy)
+        coverage: weighted fraction of target creases matched [0, 1];
+                  1.0 if position+assignment match, 0.5 if position matches but assignment doesn't
         economy: penalty for excess creases [0, 1], 1.0 = no excess
+        assignment_accuracy: fraction of positionally matched edges that also have correct M/V assignment [0, 1];
+                            returns 1.0 if no positional matches (vacuous case)
     """
     current_edges = state.crease_edges()
     tol_angle_rad = np.deg2rad(tol_angle_deg)
 
-    matched = 0
+    total_score = 0.0
+    position_matches = 0
+    assignment_correct = 0
+
     for target in target_edges:
         tx1, ty1 = target['v1']
         tx2, ty2 = target['v2']
         t_mid = ((tx1 + tx2) / 2.0, (ty1 + ty2) / 2.0)
         t_angle = np.arctan2(ty2 - ty1, tx2 - tx1)
+        t_assign = target.get('assignment', 'M')
 
         for current in current_edges:
             cx1, cy1 = current['v1']
             cx2, cy2 = current['v2']
             c_mid = ((cx1 + cx2) / 2.0, (cy1 + cy2) / 2.0)
             c_angle = np.arctan2(cy2 - cy1, cx2 - cx1)
+            c_assign = current.get('assignment', 'M')
 
             mid_dist = np.hypot(c_mid[0] - t_mid[0], c_mid[1] - t_mid[1])
             angle_distance = _angle_diff(c_angle, t_angle)
 
             if mid_dist <= tol_pos and angle_distance <= tol_angle_rad:
-                matched += 1
+                position_matches += 1
+                assign_match = (t_assign == c_assign)
+                if assign_match:
+                    total_score += 1.0
+                    assignment_correct += 1
+                else:
+                    total_score += 0.5
                 break
 
-    coverage = matched / max(len(target_edges), 1)
+    coverage = total_score / max(len(target_edges), 1)
     n_excess = max(0, len(current_edges) - len(target_edges))
     economy = max(0.0, 1.0 - n_excess / max(len(target_edges), 1))
-    return (coverage, economy)
+    assignment_accuracy = (
+        assignment_correct / position_matches if position_matches > 0 else 1.0
+    )
+    return (coverage, economy, assignment_accuracy)
+
+
+def check_degree_sanity(graph: CreaseGraph) -> float:
+    """
+    Checks that interior vertices have even degree (required for flat-foldability).
+
+    Returns:
+        Fraction of interior vertices with even degree [0, 1].
+        1.0 = all interior vertices have even degree.
+        0.0 = none do.
+        Returns 1.0 if there are no interior vertices (vacuous case).
+    """
+    interior = graph.interior_vertices()
+    if not interior:
+        return 1.0
+    even_count = sum(
+        1 for vid in interior
+        if len(graph.vertex_edges[vid]) % 2 == 0
+    )
+    return even_count / len(interior)
 
 
 def check_all_vertices(graph: CreaseGraph) -> dict: