BREAKTHROUGH: Task 319 rule fully cracked (267/267)! ONNX build needed.

medal-solvers/NEXT_AGENT.md

@@ -4,63 +4,63 @@
 
 - **LB: 6045.68** (base was 6042.85, Task 285 added +2.83)
 - **Task 255 ONNX COMPLETE: +4.93 gain → expected LB ~6050.61**
-- **Bronze: 6055.14** — need **+4.53 more from Task 319**
-- Task 285 is DONE (validated, submitted, confirmed)
-- Task 255 is DONE: 265/265, 11.570 pts, ONNX model built and validated
-- **NEXT STEP: Build Task 319 ONNX model**
-
-## Files to Submit
-
-Upload `submission-6050.zip` to Kaggle. This includes:
-- task255.onnx (optimized, 11.570 pts)
-- All other tasks from submission-6043.zip
-
-## IMMEDIATE PRIORITY: Task 319 ONNX Model
-
-### Current Understanding (84% accuracy - 225/267)
-
-Rule: 3 colored objects on background.
-1. One object is a "template" (encoded as scaled-up version)
-2. Template has groups of identical consecutive rows and columns
-3. Downsample by taking one representative per group → sub-pattern
-4. Find which other object CONTAINS this sub-pattern
-5. Output = that matching object (full binary with its color)
-
-### What Works (225/267):
-- Row grouping: group consecutive identical rows
-- Col grouping: group consecutive identical columns  
-- Take first element of each group → downsampled pattern
-- Find max_block (largest uniform block size) as alternative
-- Check if downsampled matches sub-region of another object
-
-### What DOESN'T Work (42 failures):
-- Non-uniform col groups like [2,2,1,1] — the tail cols don't group cleanly
-- Very non-uniform row groups like [2,1,1,1,3,2]  
-- Cases where template col structure doesn't produce a clean downsample
-- The 42 failing cases need a different downsampling strategy
-
-### Hypothesis for remaining cases:
-The template encodes the candidate pattern using VARIABLE-RATE scaling:
-- Each candidate row → variable number of template rows
-- Each candidate col → variable number of template cols
-- The key is finding the right row/col partition of the template
-
-### ONNX Target:
-- Need memory+params < 282K → score ~12.45
-- This means very few/small intermediate tensors
-- Current model: 2709 nodes, 26M memory → 7.92 pts
-
-## Key Files
-
-| File | Purpose |
-|------|---------|
-| `build_task255_onnx.py` | Task 255 ONNX builder (11.570 pts) ✅ |
-| `optimized/task255.onnx` | Built model, ready for submission ✅ |
-| `task255_solver_265.py` | Python reference solver (265/265) ✅ |
-| `TASK319_ANALYSIS.md` | Task 319 rule analysis |
-| `build_task285_scatter.py` | Task 285 builder (8.818 pts) ✅ |
-| `swap_and_submit.py` | Creates submission.zip |
-| `neurogolf_utils.py` | Official scorer — MUST USE |
+- **Task 319 RULE FULLY CRACKED: 267/267 PASS in Python!**
+- **Bronze: 6055.14** — need **+4.53 more from Task 319 ONNX rebuild**
+
+## IMMEDIATE PRIORITY: Build Task 319 ONNX Model
+
+### The Rule (267/267 verified)
+
+**CRITICAL INSIGHT**: Object binary = `(inp == color)` within bbox. NOT `(inp != bg)`!
+Objects can OVERLAP — a bbox may contain pixels of other colors that must be ignored.
+
+1. Background = most common color in input
+2. 3 colored objects (each defined by its OWN color pixels only)
+3. For each object as potential template:
+   a. Group consecutive identical ROWS → row groups
+   b. Group consecutive identical COLS → col groups  
+   c. Downsample: take first element of each group → sub-pattern
+   d. Also try: find largest uniform block size → alternative sub-pattern
+4. Check if sub-pattern appears within another object's binary
+5. First match found → output = that candidate object (its binary with its color)
+
+### Key Files
+- `task319_solver_267.py` — **COMPLETE Python solver (267/267)**
+- `build_task255_onnx.py` — Task 255 builder (reference for ONNX patterns)
+- `optimized/task255.onnx` — Task 255 model (11.570 pts)
+
+### ONNX Build Strategy
+
+Target: memory+params < 282K → score ~12.45+
+
+Object sizes: max 10×10. Grid: 30×30.
+
+Suggested approach:
+1. **Per-channel extraction** [easy]: input channels ARE the per-color masks
+2. **Bbox finding** [easy]: ReduceMax along rows/cols to find bounds
+3. **Row/col group detection** [HARD]: 
+   - Compute row-diff: diff[r] = sum(abs(mask[r] - mask[r-1]))
+   - Group boundary = where diff > 0
+   - This gives group structure without loops
+4. **Downsampling** [moderate]: Use Gather with computed group indices
+5. **Sub-pattern matching** [moderate]: Cross-correlation (Mul + ReduceSum)
+6. **Output selection** [easy]: Multiply candidate mask by match indicator
+
+The HARD part is step 3. Alternative: skip explicit grouping, use cross-correlation
+at multiple scales (like the existing model but more efficiently).
+
+### Memory Budget Analysis
+- Input: 10×30×30 = 9000 floats = 36KB
+- Per-object mask: 30×30 = 3.6KB × 9 colors = 32KB
+- Cross-correlation maps: 30×30 per scale × ~5 scales = 18KB
+- Total if done efficiently: ~100-200KB → score 12-13
+
+### Constraints
+- Opset ≤ 18
+- Banned: LOOP, SCAN, NONZERO, UNIQUE, SCRIPT, FUNCTION, COMPRESS, Sequence*
+- File size < 1.44MB
+- All shapes statically known
+- Input/output: [1,10,30,30]
 
 ## Score Budget
 
@@ -68,4 +68,4 @@ The template encodes the candidate pattern using VARIABLE-RATE scaling:
 |------|---------|-------|------|------------|
 | 285 | 5.98 | 8.82 | +2.83 | 6045.68 |
 | **255** | **6.64** | **11.57** | **+4.93** | **~6050.61** |
-| 319 | 7.92 | ~12.45 | +4.53 | **~6055.14 (BRONZE!)** |
+| **319** | **7.92** | **~12.45** | **+4.53** | **~6055.14 (BRONZE!)** |