Update TODO: Task 255 ONNX complete (11.570 pts, +4.93 gain)

medal-solvers/TODO.md

@@ -1,83 +1,68 @@
 # medal-solvers — TODO
 
-> **Current LB: 6045.68** | Target: 6055.14 | Remaining: **+9.46 pts**
-> Task 285 done (+2.83). Need Task 255 + one more.
+> **Current LB: 6045.68** | After Task 255: ~6050.61 | Target: 6055.14 | Remaining: **+4.53 pts**
+> Task 285 done (+2.83). Task 255 done (+4.93). Need Task 319.
 
-## Priority 1: Task 255 ONNX Build (score 6.64 → ~10-14, gain +3-7 pts)
+## COMPLETED ✅
+
+### Task 255 (score 6.64 → 11.570, gain +4.93, pending Kaggle submit)
 
 - [x] Analyze model structure (851 nodes, 94M cost, 35 MatMuls)
 - [x] Reverse-engineer transformation rule (cross-shaped empty region fill)
 - [x] **Verify rule: 265/265 PASS (ALL train+test+arc-gen)** ✅
 - [x] Fix all 4 failing cases ([116],[130],[155],[173],[218])
-- [ ] **BUILD ONNX model implementing the rule**
-- [ ] Validate with official neurogolf_utils.py (must be 0 failures)
+- [x] **BUILD ONNX model implementing the rule**
+- [x] Validate with official neurogolf_utils.py (265/265, 0 failures)
 - [ ] Submit to Kaggle
 
-### ONNX Build Approach (verified feasible):
-
-**Key simplification: rect ALWAYS touches at least one grid boundary (265/265 verified).**
-
-This means no general "largest rectangle in histogram" needed. Instead:
-
-```
-For each of 4 sides (TOP/BOTTOM/LEFT/RIGHT):
-  For k = 1..30 (depth from that boundary):
-    Compute mask: cells empty in ALL k rows/cols from that side
-    Find longest consecutive run in the mask
-    Area = k × run_length
-  Best area for this side = max across all k
-Take max across 4 sides → (tr, lc, rh, rw)
-```
-
-ONNX implementation:
-1. `fg_mask = ReduceSum(input[1:10], axis=1) > 0` → [30×30] binary
-2. `cum_fg_top[k][c] = ReduceMax(fg_mask[0:k, c])` → 1 if any fg in top k rows of col c
-3. `col_ok[k][c] = 1 - cum_fg_top[k][c]` → 1 if col c is empty in top k rows
-4. For consecutive runs: diff + comparison OR prefix-sum trick
-5. Repeat for all 4 sides
-6. ArgMax over areas → get (tr, lc, rh, rw)
-
-Estimated: ~150-300 nodes for rect finding, ~100-200 for extensions.
-Memory: all ops on [30] or [30×30] tensors → ~1-5M total.
-
-## Priority 2: Task 319 (score 7.92 → ~11-13, gain +3-5 pts)
+### Architecture: Boundary-anchored rect + cross extensions
+1. fg_mask from input channels 1-9
+2. Depth vectors from 4 sides using CumSum
+3. Largest rect via sparse table (5 doubling steps per side)
+4. Erosion → core mask
+5. Phase 1: RIGHT/LEFT extensions (eroded eligible rows)
+6. Phase 2: Sub-rect (MaxPool propagation for per-run fg_max, threshold >= 4)
+7. Phase 3: DOWN/UP extensions (dynamic result height check)
+8. Phase 4: Second RIGHT/LEFT pass (width >= 3 guard)
+9. Mask to background + color 3 output
 
-- [x] Analyze model structure (2709 nodes, 26M cost)
-- [x] Understand transformation rule (pattern matching: output = small pattern matching template)
-- [ ] Design cheaper ONNX architecture
-- [ ] Validate + submit
+### Results
+- Nodes: 707
+- Memory: 676,878 bytes + 2,986 params
+- Score: 11.570 points
+- File: medal-solvers/optimized/task255.onnx
 
-## Priority 3: Task 366 (score 7.05 → ~10-12, gain +3-5 pts)
+## Priority 1: Task 319 ONNX Build (score 7.92 → ~12-13, gain +4-5 pts)
 
-- [ ] Analyze model (12512 nodes, 60M cost)
-- [ ] Understand transformation
-- [ ] Rebuild + validate + submit
+**Status: Rule partially understood, NOT built**
 
-## Completed ✅
+Rule: 3 colored objects on background. One is a "template" (scaled-up version).
+Output = the small pattern that matches the template.
 
-### Task 285 (score 5.98 → 8.82, gain +2.83, confirmed Kaggle LB)
+Key findings:
+- Template is the largest object (by pixel count)
+- Template has block structure (rows in groups of 2)
+- Scaling is NOT uniform (may differ per row/col)
+- Template shows a PARTIAL view of the matching pattern
+- The matching candidate's binary pattern contains the template's downsampled pattern
 
-- [x] Reverse-engineered: 8-connected tiling with alternating reflections
-- [x] Built ONNX model: ScatterElements approach (844 nodes, 247KB)
-- [x] Official validation: 4/4 ARC-AGI + 261/261 ARC-GEN = **0 failures**
-- [x] Official score: **8.818 points** (memory 10.6M, params 48.7K)
-- [x] Submitted to Kaggle: **LB 6045.68** (gain +2.83)
+### Needed:
+- Full understanding of the scaling rule (non-uniform, possibly different per dimension)
+- Understanding of why template shows partial pattern (4 of 5 rows in train[0])
+- ONNX implementation: likely Conv2D-based pattern matching
+- Target: memory+params < 282K → score ~12.45
 
-### Task 255 Rule (265/265 PASS)
+## Task 285 — COMPLETE ✅
 
-- [x] Full algorithm with 4 phases (no loops needed)
-- [x] Sub-rect extension for wide gaps
-- [x] Height/width guards for cascade prevention
-- [x] Adjacent no-fg col extension for UP/DOWN runs
-- [x] **Python solver at `task255_solver_265.py` — VERIFIED 265/265**
+Score 5.98 → 8.82, gain **+2.83 confirmed on Kaggle LB**.
 
 ## Score Budget
 
 | Task | Current | After Fix | Gain | Running Total |
 |------|---------|-----------|------|---------------|
 | 285 | 5.98 | 8.82 | **+2.83** | 6045.68 |
-| 255 | 6.64 | ~10-14 | +3.5-7.4 | ~6049-6053 |
-| 319 | 7.92 | ~11-13 | +3-5 | ~6052-6058 |
+| 255 | 6.64 | 11.57 | **+4.93** | ~6050.61 |
+| 319 | 7.92 | ~12-13 | +4-5 | ~6054-6056 |
 | **Total needed** | | | **+9.46** | **6055.14** |
 
-Task 255 ONNX + Task 319 should be enough for bronze.
+Task 255 + Task 319 should reach bronze.