Add ITT physics engine (960 lines): PhiField, ρ_q, SigmaResidue, Fan Signatures, rule learning, FieldInvariants — 47/400 solved

itt_solver/itt_engine.py

@@ -6,8 +6,8 @@ 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 (Φ_q + Φ̃)
-  2. ρ_q boundary charge with physics-derived threshold
+  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()
@@ -18,3 +18,481 @@ 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]