Fix fill_color=0 bug in ITT rule learning + add mixed→recolor fallback

itt_solver/itt_engine.py

@@ -1,498 +0,0 @@
-"""
-ITT Physics Engine for ARC-AGI
-==============================
-
-Pure implementation of the Intent Tensor Theory solver, ported from
-Sensei-Intent-Tensor/0.0_ARC_AGI (ITT_PURE_SOLVER.py v4).
-
-Phases 1-7 of the ITT integration:
-  1. PhiField dual-field (Phi_q + Phi_tilde)
-  2. rho_q boundary charge with physics-derived threshold
-  3. SigmaResidue change typing
-  4. Fan Signature 6-bit classifier
-  5. TransformationRule.learn()
-  6. FieldInvariants (spectral, harmonic, eigenspectrum, Fourier, frames)
-  7. Rule apply methods (tile, self_tile, fill, multi_fill, period, shape, recolor)
-
-References:
-  - https://github.com/Sensei-Intent-Tensor/0.0_ARC_AGI
-  - https://zenodo.org/records/18077258
-"""
-
-import numpy as np
-from typing import Dict, List, Tuple, Optional, Set, Any
-from dataclasses import dataclass, field
-from collections import deque, Counter
-from math import gcd
-from functools import reduce
-
-
-class PhiField:
-    """Dual-Field: Phi_q (int semantics) + Phi_tilde (smooth float operators)."""
-
-    def __init__(self, data):
-        arr = np.array(data, dtype=np.float64)
-        self._q = np.rint(arr).astype(np.int32)
-        self._tilde = self._compute_smooth(self._q)
-
-    @staticmethod
-    def _compute_smooth(q, iters=2):
-        x = q.astype(np.float64)
-        h, w = x.shape
-        for _ in range(iters):
-            new_x = x.copy()
-            for i in range(h):
-                for j in range(w):
-                    total = x[i, j]; count = 1
-                    if i > 0:     total += x[i-1, j]; count += 1
-                    if i < h-1:   total += x[i+1, j]; count += 1
-                    if j > 0:     total += x[i, j-1]; count += 1
-                    if j < w-1:   total += x[i, j+1]; count += 1
-                    new_x[i, j] = total / count
-            x = new_x
-        return x
-
-    @property
-    def q(self): return self._q
-    @property
-    def tilde(self): return self._tilde
-    @property
-    def shape(self): return self._q.shape
-    @property
-    def h(self): return self._q.shape[0]
-    @property
-    def w(self): return self._q.shape[1]
-    @property
-    def colors(self): return set(int(x) for x in self._q.flatten() if x != 0)
-
-    def gradient(self):
-        gx = np.zeros_like(self._tilde); gy = np.zeros_like(self._tilde)
-        gy[:-1, :] = self._tilde[1:, :] - self._tilde[:-1, :]
-        gx[:, :-1] = self._tilde[:, 1:] - self._tilde[:, :-1]
-        return gx, gy
-
-    def gradient_magnitude(self):
-        gx, gy = self.gradient()
-        return np.sqrt(gx**2 + gy**2)
-
-    def laplacian(self):
-        x = self._tilde; lap = np.zeros_like(x); h, w = self.shape
-        for i in range(h):
-            for j in range(w):
-                total = 0.0; count = 0
-                if i > 0:   total += x[i-1, j]; count += 1
-                if i < h-1: total += x[i+1, j]; count += 1
-                if j > 0:   total += x[i, j-1]; count += 1
-                if j < w-1: total += x[i, j+1]; count += 1
-                lap[i, j] = total - count * x[i, j]
-        return lap
-
-    def boundary_charge(self):
-        """rho_q := |grad(laplacian(Phi_tilde))|"""
-        lap = self.laplacian()
-        gx = np.zeros_like(lap); gy = np.zeros_like(lap)
-        gy[:-1, :] = lap[1:, :] - lap[:-1, :]
-        gx[:, :-1] = lap[:, 1:] - lap[:, :-1]
-        return np.sqrt(gx**2 + gy**2)
-
-    def boundary_mask(self):
-        """Boolean boundary mask, threshold = mu + 1.5*sigma."""
-        rho = self.boundary_charge()
-        nonzero = rho[rho > 0]
-        if len(nonzero) == 0: return np.zeros_like(rho, dtype=bool)
-        mu = np.mean(nonzero); sigma = np.std(nonzero)
-        return rho > (mu + 1.5 * sigma)
-
-
-class FieldInvariants:
-
-    @staticmethod
-    def enclosed_mask(phi):
-        h, w = phi.shape; boundary = phi.boundary_mask()
-        if not np.any(boundary): boundary = (phi.q != 0)
-        exterior = np.zeros((h, w), dtype=bool); queue = deque()
-        for i in range(h):
-            for j in range(w):
-                if (i == 0 or i == h-1 or j == 0 or j == w-1):
-                    if not boundary[i, j] and phi.q[i, j] == 0:
-                        exterior[i, j] = True; queue.append((i, j))
-        while queue:
-            r, c = queue.popleft()
-            for dr, dc in [(-1,0),(1,0),(0,-1),(0,1)]:
-                nr, nc = r + dr, c + dc
-                if 0 <= nr < h and 0 <= nc < w and not exterior[nr, nc] and not boundary[nr, nc]:
-                    if phi.q[nr, nc] == 0: exterior[nr, nc] = True; queue.append((nr, nc))
-        return (phi.q == 0) & ~exterior & ~boundary
-
-    @staticmethod
-    def get_enclosed_regions(phi):
-        mask = FieldInvariants.enclosed_mask(phi)
-        if not np.any(mask): return []
-        h, w = phi.shape; visited = np.zeros((h, w), dtype=bool); regions = []
-        for r in range(h):
-            for c in range(w):
-                if mask[r, c] and not visited[r, c]:
-                    cells = set(); queue = deque([(r, c)]); visited[r, c] = True
-                    while queue:
-                        cr, cc = queue.popleft(); cells.add((cr, cc))
-                        for dr, dc in [(-1,0),(1,0),(0,-1),(0,1)]:
-                            nr, nc = cr+dr, cc+dc
-                            if 0 <= nr < h and 0 <= nc < w and mask[nr, nc] and not visited[nr, nc]:
-                                visited[nr, nc] = True; queue.append((nr, nc))
-                    rm = np.zeros((h, w), dtype=bool)
-                    for rr, rc in cells: rm[rr, rc] = True
-                    regions.append({'mask': rm, 'cells': cells, 'size': len(cells)})
-        return regions
-
-    @staticmethod
-    def frame_size(phi, interior_mask):
-        rows = np.any(interior_mask, axis=1); cols = np.any(interior_mask, axis=0)
-        if not rows.any() or not cols.any(): return (0, 0)
-        rmin, rmax = np.where(rows)[0][[0, -1]]; cmin, cmax = np.where(cols)[0][[0, -1]]
-        return (rmax - rmin + 1, cmax - cmin + 1)
-
-    @staticmethod
-    def get_frame_components(phi):
-        h, w = phi.shape; bg = _most_common(phi.q); frames = []
-        for color in sorted(phi.colors):
-            color_mask = (phi.q == color); visited = np.zeros((h, w), dtype=bool)
-            for r in range(h):
-                for c in range(w):
-                    if color_mask[r, c] and not visited[r, c]:
-                        comp = set(); queue = deque([(r, c)]); visited[r, c] = True
-                        while queue:
-                            cr, cc = queue.popleft(); comp.add((cr, cc))
-                            for dr, dc in [(-1,0),(1,0),(0,-1),(0,1)]:
-                                nr, nc = cr+dr, cc+dc
-                                if 0 <= nr < h and 0 <= nc < w and color_mask[nr, nc] and not visited[nr, nc]:
-                                    visited[nr, nc] = True; queue.append((nr, nc))
-                        if len(comp) < 4: continue
-                        rows_c = [rr for rr, _ in comp]; cols_c = [cc for _, cc in comp]
-                        rmin, rmax = min(rows_c), max(rows_c); cmin, cmax = min(cols_c), max(cols_c)
-                        bbox_area = (rmax - rmin + 1) * (cmax - cmin + 1)
-                        if bbox_area > len(comp) and len(comp) >= 4:
-                            interior_mask = np.zeros((h, w), dtype=bool)
-                            for ir in range(rmin + 1, rmax):
-                                for ic in range(cmin + 1, cmax):
-                                    if (ir, ic) not in comp: interior_mask[ir, ic] = True
-                            if np.any(interior_mask):
-                                frames.append({'frame_color': color, 'interior_mask': interior_mask,
-                                               'frame_size': (rmax-rmin+1, cmax-cmin+1), 'bbox': (rmin,cmin,rmax,cmax)})
-        return frames
-
-    @staticmethod
-    def shape_eigenspectrum(phi, positions, k=4):
-        n = len(positions)
-        if n < 2: return None
-        pos_to_idx = {p: i for i, p in enumerate(positions)}
-        L = np.zeros((n, n), dtype=np.float64)
-        for i, (r, c) in enumerate(positions):
-            degree = 0
-            for dr, dc in [(-1,0),(1,0),(0,-1),(0,1)]:
-                nb = (r+dr, c+dc)
-                if nb in pos_to_idx: j = pos_to_idx[nb]; L[i, j] = -1; degree += 1
-            L[i, i] = degree
-        try:
-            eigs = np.linalg.eigvalsh(L)
-            nonzero = eigs[eigs > 1e-8]
-            if len(nonzero) == 0: return (0.0,)
-            return tuple(round(float(e), 4) for e in sorted(nonzero)[:k])
-        except Exception: return None
-
-    @staticmethod
-    def detect_period_fourier(phi, axis=0):
-        data = phi.q.astype(np.float64)
-        signal = data.mean(axis=1) if axis == 0 else data.mean(axis=0)
-        n = len(signal)
-        if n < 2: return 0
-        fft = np.fft.rfft(signal); mags = np.abs(fft)
-        if len(mags) < 2: return 0
-        m = mags[1:]
-        if len(m) == 0 or np.max(m) < 1e-10: return 0
-        threshold = np.max(m) * 0.3
-        sig_freqs = np.where(m > threshold)[0] + 1
-        if len(sig_freqs) == 0: return 0
-        periods = [n // f for f in sig_freqs if 0 < n // f < n]
-        for p in sorted(set(periods)):
-            if p > 0 and p < n:
-                base = signal[:p]; ok = True
-                for start in range(p, n - p + 1, p):
-                    chunk = signal[start:start+p]
-                    if len(chunk) == p and not np.allclose(chunk, base, atol=0.5): ok = False; break
-                if ok: return p
-        return 0
-
-
-@dataclass
-class SigmaResidue:
-    residue: float; total_cells: int; change_type: str; structural_condition: str
-
-    @classmethod
-    def from_transformation(cls, phi_in, phi_out):
-        h_in, w_in = phi_in.shape; h_out, w_out = phi_out.shape; total = h_out * w_out
-        if h_out > h_in or w_out > w_in:
-            return cls(float(np.sum(np.abs(phi_out.q))), total, "expansion", "size_increase")
-        if h_out < h_in or w_out < w_in:
-            return cls(float(np.sum(np.abs(phi_in.q))), total, "compression", "size_decrease")
-        diff = (phi_in.q != phi_out.q)
-        residue = float(np.sum(np.abs(phi_out.q.astype(float) - phi_in.q.astype(float))))
-        if not np.any(diff): return cls(0.0, total, "identity", "none")
-        in_v = phi_in.q[diff]; out_v = phi_out.q[diff]
-        z2n = np.sum((in_v == 0) & (out_v != 0)); n2z = np.sum((in_v != 0) & (out_v == 0))
-        cc = np.sum((in_v != 0) & (out_v != 0) & (in_v != out_v))
-        if z2n > 0 and n2z == 0 and cc == 0: return cls(residue, total, "fill", "enclosed")
-        if n2z > 0 and z2n == 0: return cls(residue, total, "erase", "removal")
-        if cc > 0 and z2n == 0 and n2z == 0: return cls(residue, total, "recolor", "substitution")
-        return cls(residue, total, "mixed", "complex")
-
-
-@dataclass
-class FanSignature:
-    delta_1: bool; delta_2: bool; delta_3: bool; delta_4: bool; delta_5: bool; delta_6: bool
-    def to_tuple(self): return tuple(int(x) for x in [self.delta_1,self.delta_2,self.delta_3,self.delta_4,self.delta_5,self.delta_6])
-    def __repr__(self):
-        fans = []
-        if self.delta_1: fans.append("D1")
-        if self.delta_2: fans.append("D2")
-        if self.delta_3: fans.append("D3")
-        if self.delta_4: fans.append("D4")
-        if self.delta_5: fans.append("D5")
-        if self.delta_6: fans.append("D6")
-        return f"FanSig[{','.join(fans) or 'none'}]"
-
-
-def compute_fan_signature(train_pairs):
-    inputs = [np.array(p['input']) for p in train_pairs]
-    outputs = [np.array(p['output']) for p in train_pairs]
-    same_shape = all(i.shape == o.shape for i, o in zip(inputs, outputs))
-    is_expansion = all(o.shape[0] >= i.shape[0] and o.shape[1] >= i.shape[1] and o.shape != i.shape for i, o in zip(inputs, outputs))
-    has_sym = False
-    for inp in inputs:
-        if np.array_equal(inp, np.fliplr(inp)) or np.array_equal(inp, np.flipud(inp)): has_sym = True
-        if inp.shape[0] == inp.shape[1] and np.array_equal(inp, np.rot90(inp)): has_sym = True
-    for inp, out in zip(inputs, outputs):
-        if inp.shape == out.shape:
-            if np.array_equal(out, np.fliplr(inp)) or np.array_equal(out, np.flipud(inp)) or np.array_equal(out, np.rot90(inp, 2)): has_sym = True
-    has_enc = False
-    for inp in inputs:
-        if np.any(FieldInvariants.enclosed_mask(PhiField(inp))): has_enc = True; break
-    has_per = False
-    for inp in inputs:
-        phi = PhiField(inp)
-        if FieldInvariants.detect_period_fourier(phi, 0) > 0 or FieldInvariants.detect_period_fourier(phi, 1) > 0: has_per = True; break
-    ic = set(); oc = set()
-    for i, o in zip(inputs, outputs): ic |= set(np.unique(i)); oc |= set(np.unique(o))
-    return FanSignature(same_shape and has_enc, has_sym, is_expansion, has_enc or same_shape, has_per, bool(oc - ic) or bool(ic - oc))
-
-
-@dataclass
-class TransformationRule:
-    rule_type: str = "unknown"
-    size_ratio: Tuple[float, float] = (1.0, 1.0)
-    fill_color: int = 0
-    size_to_color: Dict = field(default_factory=dict)
-    frame_to_fill: Dict = field(default_factory=dict)
-    color_map: Dict = field(default_factory=dict)
-    tile_pattern: List = field(default_factory=list)
-    detected_period: int = 0
-    indicator_color: int = 0
-    target_color: int = 0
-    shape_to_color: Dict = field(default_factory=dict)
-
-    @classmethod
-    def learn(cls, train_pairs):
-        rule = cls(); sigmas = []
-        for pair in train_pairs:
-            pi = PhiField(pair['input']); po = PhiField(pair['output'])
-            s = SigmaResidue.from_transformation(pi, po); sigmas.append(s)
-            rule.size_ratio = (po.h / pi.h, po.w / pi.w)
-            rule._learn_from_pair(pi, po, s)
-        ct = [s.change_type for s in sigmas]; sc = [s.structural_condition for s in sigmas]
-        if all(t == "fill" and s == "enclosed" for t, s in zip(ct, sc)):
-            rule.rule_type = "multi_region_fill" if len(rule.size_to_color) > 1 and len(set(rule.size_to_color.values())) > 1 else "fill_enclosed"
-        elif all(t == "fill" for t in ct): rule.rule_type = "fill"
-        elif all(t == "recolor" for t in ct): rule.rule_type = "recolor"
-        elif all(t == "expansion" for t in ct):
-            if rule._check_tiling(train_pairs): rule.rule_type = "tile"
-            elif rule._check_self_tile(train_pairs): rule.rule_type = "self_tile"
-            elif rule.detected_period > 0: rule.rule_type = "periodic_extension"
-            else: rule.rule_type = "expansion"
-        elif rule.indicator_color != 0: rule.rule_type = "shape_indicator"
-        return rule
-
-    def _learn_from_pair(self, phi_in, phi_out, sigma):
-        if sigma.change_type == "fill" and sigma.structural_condition == "enclosed":
-            for frame in FieldInvariants.get_frame_components(phi_in):
-                fv = phi_out.q[frame['interior_mask']]
-                if len(fv) > 0:
-                    u, c = np.unique(fv, return_counts=True); fc = int(u[np.argmax(c)])
-                    if fc != 0:
-                        self.size_to_color[frame['frame_size']] = fc; self.fill_color = fc
-                        if frame['frame_color'] != 0: self.frame_to_fill[frame['frame_color']] = fc
-            for region in FieldInvariants.get_enclosed_regions(phi_in):
-                fs = FieldInvariants.frame_size(phi_in, region['mask']); fv = phi_out.q[region['mask']]
-                if len(fv) > 0:
-                    u, c = np.unique(fv, return_counts=True); fc = int(u[np.argmax(c)])
-                    if fc != 0 and fs not in self.size_to_color: self.size_to_color[fs] = fc; self.fill_color = fc
-        if phi_in.shape == phi_out.shape:
-            for col in phi_in.colors:
-                ov = phi_out.q[phi_in.q == col]; u = np.unique(ov)
-                if len(u) == 1 and u[0] != col: self.color_map[int(col)] = int(u[0])
-        if phi_in.shape != phi_out.shape and phi_in.w == phi_out.w:
-            p = FieldInvariants.detect_period_fourier(phi_in, axis=0)
-            if p > 0:
-                self.detected_period = p
-                ib = phi_in.q[:p, :]; ob = phi_out.q[:p, :]
-                for ci in set(ib.flatten()) - {0}:
-                    ov = ob[ib == ci]; u = np.unique(ov)
-                    if len(u) == 1 and u[0] != ci: self.color_map[int(ci)] = int(u[0])
-        if len(phi_in.colors) == 2: self._learn_shape_indicator(phi_in, phi_out)
-        self._learn_tile_pattern(phi_in, phi_out)
-
-    def _learn_shape_indicator(self, phi_in, phi_out):
-        if phi_in.shape != phi_out.shape: return
-        c1, c2 = sorted(phi_in.colors)
-        o1 = set(phi_out.q[phi_in.q == c1].flatten()) - {0}; o2 = set(phi_out.q[phi_in.q == c2].flatten()) - {0}
-        if len(o1) == 0 and len(o2) == 1: ind, tgt, oc = c1, c2, int(list(o2)[0])
-        elif len(o2) == 0 and len(o1) == 1: ind, tgt, oc = c2, c1, int(list(o1)[0])
-        else: return
-        self.indicator_color = ind; self.target_color = tgt
-        pos = list(zip(*np.where(phi_in.q == ind)))
-        if pos:
-            ss = FieldInvariants.shape_eigenspectrum(phi_in, pos)
-            if ss: self.shape_to_color[ss] = oc
-
-    def _learn_tile_pattern(self, phi_in, phi_out):
-        ih, iw = phi_in.shape; oh, ow = phi_out.shape
-        if oh < ih or ow < iw or oh % ih != 0 or ow % iw != 0: return
-        th, tw = oh // ih, ow // iw
-        if th == 1 and tw == 1: return
-        pattern = []
-        for ti in range(th):
-            row = []
-            for tj in range(tw):
-                t = phi_out.q[ti*ih:(ti+1)*ih, tj*iw:(tj+1)*iw]
-                if np.array_equal(t, phi_in.q): row.append(0)
-                elif np.array_equal(t, np.fliplr(phi_in.q)): row.append(1)
-                elif np.array_equal(t, np.flipud(phi_in.q)): row.append(2)
-                elif np.array_equal(t, np.rot90(phi_in.q, 2)): row.append(3)
-                else: row.append(-1)
-            pattern.append(row)
-        self.tile_pattern = pattern
-
-    def _check_tiling(self, pairs):
-        for p in pairs:
-            pi, po = PhiField(p['input']), PhiField(p['output'])
-            if po.h % pi.h != 0 or po.w % pi.w != 0: return False
-            th, tw = po.h // pi.h, po.w // pi.w
-            if th <= 1 and tw <= 1: return False
-            for ti in range(th):
-                for tj in range(tw):
-                    t = po.q[ti*pi.h:(ti+1)*pi.h, tj*pi.w:(tj+1)*pi.w]
-                    if not any(np.array_equal(t, x) for x in [pi.q, np.fliplr(pi.q), np.flipud(pi.q), np.rot90(pi.q, 2)]): return False
-        return True
-
-    def _check_self_tile(self, pairs):
-        for p in pairs:
-            pi, po = PhiField(p['input']), PhiField(p['output'])
-            ih, iw = pi.shape
-            if po.h != ih*ih or po.w != iw*iw: continue
-            ok = True
-            for ti in range(ih):
-                for tj in range(iw):
-                    t = po.q[ti*ih:(ti+1)*ih, tj*iw:(tj+1)*iw]
-                    if pi.q[ti, tj] != 0:
-                        if not np.array_equal(t, pi.q): ok = False; break
-                    elif np.any(t != 0): ok = False; break
-                if not ok: break
-            if ok: return True
-        return False
-
-    def apply(self, phi_in):
-        m = {'tile': self._apply_tile, 'self_tile': self._apply_self_tile, 'fill_enclosed': self._apply_fill,
-             'fill': self._apply_fill, 'multi_region_fill': self._apply_multi_fill,
-             'periodic_extension': self._apply_period, 'shape_indicator': self._apply_shape,
-             'recolor': self._apply_recolor}
-        return m.get(self.rule_type, lambda p: p.q.copy())(phi_in)
-
-    def _apply_tile(self, phi_in):
-        ih, iw = phi_in.shape; th, tw = int(self.size_ratio[0]), int(self.size_ratio[1])
-        r = np.zeros((ih*th, iw*tw), dtype=int)
-        xforms = [phi_in.q, np.fliplr(phi_in.q), np.flipud(phi_in.q), np.rot90(phi_in.q, 2)]
-        for ti in range(th):
-            for tj in range(tw):
-                code = self.tile_pattern[ti][tj] if self.tile_pattern and ti < len(self.tile_pattern) and tj < len(self.tile_pattern[ti]) else 0
-                r[ti*ih:(ti+1)*ih, tj*iw:(tj+1)*iw] = xforms[code] if 0 <= code <= 3 else phi_in.q
-        return r
-
-    def _apply_self_tile(self, phi_in):
-        ih, iw = phi_in.shape; r = np.zeros((ih*ih, iw*iw), dtype=int)
-        for ti in range(ih):
-            for tj in range(iw):
-                if phi_in.q[ti, tj] != 0: r[ti*ih:(ti+1)*ih, tj*iw:(tj+1)*iw] = phi_in.q
-        return r
-
-    def _apply_fill(self, phi_in):
-        r = phi_in.q.copy(); m = FieldInvariants.enclosed_mask(phi_in)
-        if np.any(m): r[m] = self.fill_color
-        return r
-
-    def _apply_multi_fill(self, phi_in):
-        r = phi_in.q.copy()
-        for frame in FieldInvariants.get_frame_components(phi_in):
-            fs = frame['frame_size']; fc = self.size_to_color.get(fs)
-            if fc is None and self.size_to_color:
-                fa = fs[0]*fs[1]; fc = self.size_to_color[min(self.size_to_color, key=lambda s: abs(s[0]*s[1]-fa))]
-            if fc is None: fc = self.frame_to_fill.get(frame.get('frame_color', 0))
-            if fc is None: fc = self.fill_color
-            if fc and fc != 0: r[frame['interior_mask']] = fc
-        return r
-
-    def _apply_period(self, phi_in):
-        if self.detected_period == 0: return phi_in.q.copy()
-        oh = int(phi_in.h * self.size_ratio[0]); base = phi_in.q[:self.detected_period, :].copy()
-        for oc, nc in self.color_map.items(): base[base == oc] = nc
-        reps = max(1, oh // self.detected_period)
-        return np.tile(base, (reps, 1))[:oh, :]
-
-    def _apply_shape(self, phi_in):
-        r = np.zeros_like(phi_in.q); pos = list(zip(*np.where(phi_in.q == self.indicator_color)))
-        if pos:
-            ss = FieldInvariants.shape_eigenspectrum(phi_in, pos); oc = self.shape_to_color.get(ss, 0)
-            if oc == 0:
-                best_d = float('inf')
-                for ks, kc in self.shape_to_color.items():
-                    if ss and ks:
-                        ml = min(len(ss), len(ks)); d = sum((a-b)**2 for a, b in zip(ss[:ml], ks[:ml]))
-                        if d < best_d: best_d = d; oc = kc
-            r[phi_in.q == self.target_color] = oc
-        return r
-
-    def _apply_recolor(self, phi_in):
-        r = phi_in.q.copy()
-        for oc, nc in self.color_map.items(): r[phi_in.q == oc] = nc
-        return r
-
-
-class ITTSolver:
-    def try_solve(self, task):
-        train = task.get('train', []); tests = task.get('test', [])
-        if not train: return None
-        rule = TransformationRule.learn(train)
-        if rule.rule_type == "unknown": return None
-        for pair in train:
-            pred = rule.apply(PhiField(pair['input'])); exp = np.array(pair['output'], dtype=int)
-            if pred.shape != exp.shape or not np.array_equal(pred, exp): return None
-        return [rule.apply(PhiField(t['input'])).tolist() for t in tests]
-
-    def try_solve_pair(self, inp, target, train_pairs):
-        rule = TransformationRule.learn(train_pairs)
-        if rule.rule_type == "unknown": return None
-        for pair in train_pairs:
-            pred = rule.apply(PhiField(pair['input'])); exp = np.array(pair['output'], dtype=int)
-            if pred.shape != exp.shape or not np.array_equal(pred, exp): return None
-        return rule.apply(PhiField(inp))
-
-
-def _most_common(arr):
-    return Counter(arr.flatten().tolist()).most_common(1)[0][0]