this is the commit for adding the gp interface

app.py

@@ -0,0 +1,48 @@
+from flask import Flask, render_template, request
+from markupsafe import Markup
+
+import os
+import glob
+from gp1 import run_task  # Make sure run_task returns all required data
+
+app = Flask(__name__)
+
+# Helper function to render a grid as HTML using CSS classes
+def render_grid(grid):
+    html = '<div class="grid">'
+    for row in grid:
+        html += '<div class="grid-row">'
+        for cell in row:
+            html += f'<div class="cell color-{cell}"></div>'
+        html += '</div>'
+    html += '</div>'
+    return Markup(html)
+
+@app.route('/', methods=['GET', 'POST'])
+def index():
+    task_folder = './training/'
+    task_files = sorted(glob.glob(os.path.join(task_folder, '*.json')))
+    task_names = [os.path.basename(f) for f in task_files]
+
+    result = None
+
+    if request.method == 'POST':
+        selected_task = request.form.get('task')
+        task_path = os.path.join(task_folder, selected_task)
+
+        # run_task should return: best_program, correct, input_grid, target_grid, output_grid
+        best_program, correct, input_grid, target_grid, output_grid = run_task(task_path)
+
+        result = {
+            "task": selected_task,
+            "program": best_program,
+            "success": correct,
+            "input": input_grid,
+            "target": target_grid,
+            "output": output_grid
+        }
+
+    return render_template('index.html', tasks=task_names, result=result, render_grid=render_grid)
+
+if __name__ == '__main__':
+    app.run(debug=True)

dsl.py

@@ -0,0 +1,680 @@
+import numpy as np
+from typing import Tuple, List
+
+# Define Count as an alias for int
+Count = int
+from scipy.ndimage import binary_dilation
+from scipy import ndimage
+from typing import Callable
+
+class GridList(list):
+    pass
+
+class PrimitiveException(Exception):
+    pass
+
+# Simple Grid class
+class Grid:
+    def __init__(self, grid: np.ndarray, position: Tuple[int, int]=(0, 0)):
+        self.grid = grid
+        self.position = position
+
+    @property
+    def size(self):
+        return self.grid.shape
+
+    def newgrid(self, grid: np.ndarray, position=None):
+        if position is None:
+            position = self.position
+        return Grid(grid, position)
+
+    def count(self):
+        return np.count_nonzero(self.grid)
+
+Colour = int
+
+def primitive_assert(condition, message="Assertion failed"):
+    if not condition:
+        raise ValueError(message)
+
+# DSL primitives
+def rot90(g: Grid) -> Grid:
+    return g.newgrid(np.rot90(g.grid))
+
+def rot180(g: Grid) -> Grid:
+    return g.newgrid(np.rot90(g.grid, 2))
+
+def ic_compress2(g: Grid) -> Grid:
+    keep_rows = np.any(g.grid, axis=1)
+    keep_cols = np.any(g.grid, axis=0)
+    return g.newgrid(g.grid[keep_rows][:, keep_cols])
+
+def flipy(g: Grid) -> Grid:
+    return g.newgrid(np.flip(g.grid, axis=1))
+
+def mirrorX(g: Grid) -> Grid:
+    return Grid(np.hstack((g.grid, np.fliplr(g.grid))))
+
+def mirrorY(g: Grid) -> Grid:
+    return Grid(np.vstack((g.grid, np.flipud(g.grid))))
+
+def overlay(g: Grid, h: Grid) -> Grid:
+    if g.size == h.size:
+        newgrid = Grid(g.grid.copy())
+        newgrid.grid[h.grid != 0] = h.grid[h.grid != 0]
+        return newgrid
+    else:
+        xpos = min(g.position[0], h.position[0])
+        ypos = min(g.position[1], h.position[1])
+        xsize = max(g.position[0]+g.size[0], h.position[0]+h.size[0]) - xpos
+        ysize = max(g.position[1]+g.size[1], h.position[1]+h.size[1]) - ypos
+
+        newgrid = Grid(np.zeros((xsize, ysize)), position=(xpos, ypos))
+        newgrid.grid[g.position[0]-xpos:g.position[0]-xpos+g.size[0], 
+                     g.position[1]-ypos:g.position[1]-ypos+g.size[1]] = g.grid
+
+        mask = np.nonzero(h.grid)
+        slice = newgrid.grid[h.position[0]-xpos:h.position[0]-xpos+h.size[0],
+                             h.position[1]-ypos:h.position[1]-ypos+h.size[1]]
+        slice[mask] = h.grid[mask]
+        return newgrid
+
+def set_bg(c: Colour, g: Grid) -> Grid:
+    primitive_assert(c != 0, "background with 0 has no effect")
+    grid = np.copy(g.grid)
+    grid[grid == 0] = c
+    return g.newgrid(grid)
+def ic_composegrowing(l: List[Grid]) -> Grid:
+    xpos = min([g.position[0] for g in l])
+    ypos = min([g.position[1] for g in l])
+    xsize = max([g.position[0]+g.size[0] for g in l]) - xpos
+    ysize = max([g.position[1]+g.size[1] for g in l]) - ypos
+
+    newgrid = Grid(np.zeros((xsize, ysize)), position=(xpos, ypos))
+    sorted_list = sorted(l, key=lambda g: g.count(), reverse=True)
+
+    for g in sorted_list:
+        xstart = g.position[0] - xpos
+        ystart = g.position[1] - ypos
+        slice = newgrid.grid[xstart:xstart+g.size[0], ystart:ystart+g.size[1]]
+        mask = np.nonzero(g.grid)
+        slice[mask] = g.grid[mask]
+
+    return newgrid
+
+def ic_splitall(g: Grid) -> GridList:
+    colours = np.unique(g.grid)
+    ret = []
+    for colour in colours:
+        if colour:
+            labeled_grid, _ = ndimage.label(g.grid == colour)
+            objects = ndimage.find_objects(labeled_grid)
+            ret += [g.newgrid(g.grid[obj], position=(obj[0].start, obj[1].start)) for obj in objects]
+    return ret
+
+def ic_connect_kernel(g: Grid, x: bool, y: bool) -> Grid:
+    """
+    Implements a generic connect (not a primitive)
+    x and y control whether it is enabled in the horizontal and vertical directions
+    
+    Connect works as follows:
+    Two cells in the same row/column are connected iff:
+    - they are both non-zero
+    - they have the same value c
+    - there are only zeros in between them
+    Connect fills in the zero values in-between with c.
+    Note that vertical connection happens after horizontal connection and "overrides" it.
+
+    This function is SLOW
+    TODO: Verify this actually works because I'm not confident
+    """
+    ret = np.zeros_like(g.grid)
+
+    if x:
+        for row in range(g.grid.shape[0]):
+            last = last_value = -1
+            for col in range(g.grid.shape[1]):
+                if g.grid[row, col]:
+                    if g.grid[row, col] == last_value:
+                        ret[row, last+1:col] = last_value
+                    last_value = g.grid[row, col]
+                    last = col
+    
+    if y:
+        for col in range(g.grid.shape[1]):
+            last = last_value = -1
+            for row in range(g.grid.shape[0]):
+                if g.grid[row, col]:
+                    if g.grid[row, col] == last_value:
+                        ret[last+1:row, col] = last_value
+                    last_value = g.grid[row, col]
+                    last = row
+
+    return g.newgrid(ret)
+
+def ic_connectY(g: Grid) -> Grid:
+    return ic_connect_kernel(g, False, True)
+
+def ic_connectX(g: Grid) -> Grid:
+    return ic_connect_kernel(g, True, False)
+
+def ic_compress2(g: Grid) -> Grid:
+    """Deletes any black rows/columns in the grid"""
+    keep_rows = np.any(g.grid, axis=1)
+    keep_cols = np.any(g.grid, axis=0)
+
+    return g.newgrid(g.grid[keep_rows][:, keep_cols])
+
+def ic_compress3(g: Grid) -> Grid:
+    """
+    Keep any rows/columns which differ in any way from the previous row/column
+    The first row/column is always kept.
+    """
+    keep_rows = np.ones(g.grid.shape[0], dtype=bool)
+    keep_cols = np.ones(g.grid.shape[1], dtype=bool)
+
+    for row in range(1, g.grid.shape[0]):
+        if np.all(g.grid[row] == g.grid[row-1]):
+            keep_rows[row] = False
+
+    for col in range(1, g.grid.shape[1]):
+        if np.all(g.grid[:, col] == g.grid[:, col-1]):
+            keep_cols[col] = False
+
+    return g.newgrid(g.grid[keep_rows][:, keep_cols])
+
+def ic_erasecol(c: Colour, g: Grid) -> Grid:
+    "Remove a specified colour from the grid, keeping others intact"
+    primitive_assert(c != 0, "erasecol with 0 has no effect")
+    grid = np.copy(g.grid)
+    grid[grid == c] = 0
+    return g.newgrid(grid)
+def rarestcol(g: Grid) -> Colour:
+    """
+    Returns the least common colour, excluding black. 
+    Excludes any colours with zero count.
+    """
+    counts = np.bincount(g.grid.ravel())[1:]
+    counts[counts == 0] = 9999
+    return np.argmin(counts)+1
+
+def left_half(g: Grid) -> Grid:
+    primitive_assert(g.size[1] > 1, "Grid is too small to crop")
+    return g.newgrid(g.grid[:, :g.grid.shape[1]//2])
+
+def right_half(g: Grid) -> Grid:
+    primitive_assert(g.size[1] > 1, "Grid is too small to crop")
+    new_position = (g.position[0], g.position[1] + g.grid.shape[1]//2 + g.grid.shape[1]%2)
+    return g.newgrid(g.grid[:, -g.grid.shape[1]//2:], position=new_position)
+
+def top_half(g: Grid) -> Grid:
+    primitive_assert(g.size[0] > 1, "Grid is too small to crop")
+    return g.newgrid(g.grid[:g.grid.shape[0]//2])
+def repeatX(g: Grid) -> Grid:
+    """
+    Repeat the grid g horizontally, with no gaps
+    """
+    return Grid(np.tile(g.grid, (1, 2)), position=g.position)
+def flipx(g: Grid) -> Grid:
+    return g.newgrid(np.flip(g.grid, axis=0))
+# Your custom primitive function
+def ic_pickunique(l: List[Grid]) -> Grid:
+    """
+    Given a list of grids, return the one which has a unique colour unused by any other grid.
+    If there are no such grids or more than one, terminate.
+    """
+    counts = np.zeros(10)
+    uniques = [np.unique(g.grid) for g in l]
+    for u in uniques:
+        counts[u] += 1
+    
+    colour_mask = counts == 1
+    ccount = np.sum(colour_mask)
+    if not ccount:
+        raise PrimitiveException("pickunique: no unique grids")
+    
+    for g, u in zip(l, uniques):
+        if np.sum(colour_mask[u]) == ccount:
+            return g
+        
+    raise PrimitiveException("pickunique: no unique grids (2)")
+def countToXY(c: int, col: Colour) -> Grid:
+    """
+    Given a count (integer) and a colour, create a square grid of size c×c filled with the given colour.
+    """
+    return Grid(np.full((c, c), col, dtype=int))
+# Primitive definitions
+def gravity(g: Grid, dx=False, dy=False) -> Grid:
+    assert dx or dy
+
+    pieces = ic_splitall(g)
+
+    # Sort pieces by gravity direction
+    pieces = sorted(pieces, 
+                    key=lambda g: -(g.position[0]*dy + g.position[1]*dx))
+    
+    # Start with empty grid
+    newgrid = Grid(np.zeros(g.size))
+
+    # Iterate over pieces
+    for p in pieces:
+        while True:
+            # Move piece by gravity direction
+            p.position = (p.position[0]+dy, p.position[1]+dx)
+
+            # Check bounds
+            if (p.position[0] < 0 or p.position[0]+p.size[0] > g.size[0] or 
+                p.position[1] < 0 or p.position[1]+p.size[1] > g.size[1]):
+                p.position = (p.position[0]-dy, p.position[1]-dx)
+                break
+
+            # Collision check
+            slice = newgrid.grid[
+                p.position[0]:p.position[0]+p.size[0],
+                p.position[1]:p.position[1]+p.size[1]
+            ]
+
+            if slice[p.grid != 0].any():
+                p.position = (p.position[0]-dy, p.position[1]-dx)
+                break
+
+        # Composite piece
+        newgrid = overlay(newgrid, p)
+    
+    return newgrid
+
+# Wrapper primitive: gravity to the right
+def gravity_right(g: Grid) -> Grid:
+    return gravity(g, dx=1)
+struct8 = np.array([[1, 1, 1],
+                    [1, 1, 1],
+                    [1, 1, 1]], dtype=int)
+
+def split8(g: Grid) -> List[Grid]:
+    """
+    Find all objects using 8-connected structuring element.
+    Each colour is separated.
+    """
+    colours = np.unique(g.grid)
+    ret = []
+    for colour in colours:
+        if colour:
+            objects = ndimage.find_objects(ndimage.label(g.grid == colour, structure=struct8)[0])
+            ret += [g.newgrid(g.grid[obj], offset=(obj[0].start, obj[1].start)) for obj in objects]
+    return ret
+def ic_makeborder(g: Grid) -> Grid:
+    """
+    Return a new grid which is the same as the input, but with a border of 1s around it.
+    Only elements which are 0 in the original grid are set to 1 in the new grid.
+    8-connected structuring element used to determine border positions.
+    """
+
+    binary_grid = g.grid > 0
+    output_grid = np.zeros_like(g.grid)
+
+    grown_binary_grid = binary_dilation(binary_grid, structure=np.ones((3, 3)))
+    output_grid[grown_binary_grid & ~binary_grid] = 1
+
+    return g.newgrid(output_grid)
+def ic_filtercol(c: Colour, g: Grid) -> Grid:
+    "Remove all colours except the selected colour"
+    primitive_assert(c != 0, "filtercol with 0 has no effect")
+
+    grid = np.copy(g.grid) # Do we really need to copy? old one thrown away anyway
+    grid[grid != c] = 0
+    return g.newgrid(grid)
+def ic_invert(g: Grid) -> Grid:
+    """
+    Replaces all colours with zeros, and replaces zeros with the most common colour.
+    """
+    mode = np.argmax(np.bincount(g.grid.ravel())[1:]) + 1  # skip counting 0
+    grid = np.zeros_like(g.grid)
+    grid[g.grid == 0] = mode
+    return g.newgrid(grid)
+def logical_and(g: Grid, h: Grid) -> Grid:
+    """
+    Logical AND between two grids. Use the colour of the first argument.
+    Logical OR is given by overlay.
+    """
+    primitive_assert(g.size == h.size, "logical_and: grids must be the same size")
+
+    mask = np.logical_and(g.grid != 0, h.grid != 0)
+    return g.newgrid(np.where(mask, g.grid, 0))
+
+struct4 = np.array([[0,1,0],
+                    [1,1,1],
+                    [0,1,0]], dtype=int)
+
+def fillobj(c: Colour, g: Grid) -> Grid:
+    """
+    Fill in any closed objects in the grid with a specified colour.
+    Uses 4-connectedness to determine closed objects.
+    """
+    primitive_assert(c != 0, "fill with 0 has no effect")
+
+    binhole = ndimage.binary_fill_holes(g.grid != 0, structure=struct4)
+    newgrid = np.copy(g.grid)
+    newgrid[binhole & (g.grid == 0)] = c
+
+    return g.newgrid(newgrid)
+def topcol(g: Grid) -> Colour:
+    """
+    Returns the most common colour in the grid, excluding black (0).
+    Equivalent to majCol in icecuber.
+    """
+    return np.argmax(np.bincount(g.grid.ravel())[1:]) + 1
+def rarestcol(g: Grid) -> Colour:
+    """
+    Returns the least common colour in the grid, excluding black.
+    Colours with zero occurrences are ignored.
+    """
+    counts = np.bincount(g.grid.ravel())[1:]
+    counts[counts == 0] = 9999
+    return np.argmin(counts) + 1
+def gravity_down(g: Grid) -> Grid:
+    return gravity(g, dy=1)
+def setcol(c: Colour, g: Grid) -> Grid:
+    """
+    Set all pixels in the grid to the specified colour.
+    Originally named colShape in icecuber.
+    """
+    primitive_assert(c != 0, "setcol with 0 has no effect")
+
+    grid = np.zeros_like(g.grid)
+    grid[np.nonzero(g.grid)] = c
+    return g.newgrid(grid)
+def ic_embed(img: Grid, shape: Grid) -> Grid:
+    """
+    Embeds a grid into a larger shape defined by a second argument (zero-padded).
+    If the image is larger than the shape, it is cropped.
+    """
+    ret = np.zeros_like(shape.grid)
+    
+    xoffset = shape.position[0] - img.position[0]
+    yoffset = shape.position[1] - img.position[1]
+
+    xsize = min(img.grid.shape[0], shape.grid.shape[0] - xoffset)
+    ysize = min(img.grid.shape[1], shape.grid.shape[1] - yoffset)
+
+    ret[xoffset:xoffset+xsize, yoffset:yoffset+ysize] = img.grid[:xsize, :ysize]
+    return shape.newgrid(ret)
+
+def rot270(g: Grid) -> Grid:
+    """
+    Rotate a grid by 270 degrees.
+    """
+    return g.newgrid(np.rot90(g.grid, k=3))
+def mapSplit8(f: Callable[[Grid], Grid], g: Grid) -> Grid:
+    """
+    Split grid g into objects using 8-connectedness,
+    apply function f to each object, and then reassemble.
+    """
+    pieces = split8(g)
+    processed_pieces = [f(piece) for piece in pieces]
+    return ic_composegrowing(processed_pieces)
+from collections import Counter
+def pickcommon(l: List[Grid]) -> Grid:
+    """
+    Given a list of grids, return the grid that appears most frequently (by exact match).
+    """
+    primitive_assert(len(l) > 0, "pickcommon: list is empty")
+    hashes = [hash(g.grid.data.tobytes()) for g in l]
+    most_common_hash = Counter(hashes).most_common(1)[0][0]
+    return l[hashes.index(most_common_hash)]
+def swapxy(g: Grid) -> Grid:
+    return g.newgrid(g.grid.T)
+
+def topcol(g: Grid) -> Colour:
+    """
+    Returns the most common colour, excluding black.
+    majCol in icecuber.
+    """
+    return np.argmax(np.bincount(g.grid.ravel())[1:])+1
+def setcol(c: Colour, g: Grid) -> Grid:
+    """
+    Set all pixels in the grid to the specified colour.
+    This was named colShape in icecuber. 
+    """
+    primitive_assert(c != 0, "setcol with 0 has no effect")
+
+    grid = np.zeros_like(g.grid)
+    grid[np.nonzero(g.grid)] = c
+    return g.newgrid(grid)
+def get_bg(c: Colour, g: Grid) -> Grid:
+    """
+    Return a grid of all the background pixels in g, coloured c
+    Essentially same as invert.
+    """ 
+    return Grid(np.where(g.grid == 0, c, 0))
+def rarestcol(g: Grid) -> Colour:
+    """
+    Returns the least common colour, excluding black. 
+    Excludes any colours with zero count.
+    """
+    counts = np.bincount(g.grid.ravel())[1:]
+    counts[counts == 0] = 9999
+    return np.argmin(counts)+1
+def ic_fill(g: Grid) -> Grid:
+    """
+    Returns a grid with all closed objects filled in with the most common colour
+    Note that like Icecuber, this also colours everything not connected to the border with the most common colour
+    i.e. the result is a single colour
+    """
+    return setcol(topcol(g), fillobj(1, g))
+def ic_center(g: Grid) -> Grid:
+    # TODO: Figure out why this is useful
+    w,h = g.size
+    
+    newsize = ((w + 1) % 2 + 1, (h + 1) % 2 + 1)
+    newgrid = np.ones(newsize)
+    newpos = (
+        g.position[0] + (newsize[0] - w) / 2,
+        g.position[1] + (newsize[1] - h) / 2
+    )
+
+    return Grid(newgrid, newpos)
+def countToY(c: Count, col: Colour) -> Grid:
+    """
+    Create a vertical (1×c) grid filled with the given colour.
+    """
+    return Grid(np.full((1, c), col, dtype=int))
+
+def countPixels(g: Grid) -> Count:
+    """
+    Count the number of non-zero pixels in the grid.
+    """
+    return np.count_nonzero(g.grid)
+def ic_splitcols(g: Grid) -> List[Grid]:
+    """
+    Split a grid into multiple grids, each with a single colour.
+    """
+    ret = []
+    for colour in np.unique(g.grid):
+        if colour:
+            ret.append(g.newgrid(g.grid == colour))
+    return ret
+def grid_split(g: Grid) -> GridList:
+    # Get rows and columns that are filled with a single color
+    row_colors = [row[0] for row in g.grid if np.all(row == row[0])]
+    col_colors = [col[0] for col in g.grid.T if np.all(col == col[0])]
+
+    colors = row_colors + col_colors
+    primitive_assert(len(colors) > 0, "No uniform rows or columns found")
+
+    # Find the most common such color
+    color = np.argmax(np.bincount(colors))
+
+    # Now split along rows and columns with this color
+    horizontal_splits = []
+    current = []
+    for row in g.grid:
+        if np.all(row == color):
+            if current:
+                horizontal_splits.append(np.stack(current))
+                current = []
+        else:
+            current.append(row)
+    if current:
+        horizontal_splits.append(np.stack(current))
+
+    # Convert each resulting piece to Grid
+    result = []
+    for h in horizontal_splits:
+        if h.shape[0] > 0:
+            result.append(Grid(h))
+
+    return GridList(result)
+
+
+
+def arc_assert(boolean, message=None):
+    if not boolean: 
+        # print('ValueError')
+        raise ValueError(message)
+
+def _get(l):
+    def get(l, i):
+        arc_assert(i >= 0 and i < len(l))
+        return l[i]
+
+    return lambda i: get(l, i)
+
+def stack_no_crop(l: GridList) -> Grid:
+    """
+    Stack same-size grids with masking — first grids drawn underneath later ones.
+    """
+    primitive_assert(len(l) > 0, "Empty GridList in stack_no_crop")
+
+    shape = l[0].grid.shape
+    for g in l:
+        primitive_assert(g.grid.shape == shape, "Mismatched grid shapes in stack_no_crop")
+
+    stackedgrid = np.zeros(shape, dtype=int)
+    for g in l:
+        stackedgrid += g.grid * (stackedgrid == 0)
+
+    return Grid(stackedgrid)
+
+def overlay(g1: Grid, g2: Grid) -> Grid:
+    """
+    Mask overlay of g2 on top of g1.
+    """
+    primitive_assert(g1.grid.shape == g2.grid.shape, "Overlay shape mismatch")
+    result = g1.grid.copy()
+    result[g2.grid != 0] = g2.grid[g2.grid != 0]
+    return Grid(result)
+def _objects2(g: Grid) -> Callable[[bool], Callable[[bool], GridList]]:
+    """
+    Extract connected components (objects) from grid.
+    Options:
+    - connect_diagonals: whether to connect diagonally
+    - separate_colors: whether to segment by color
+    """
+
+    def inner(connect_diagonals: bool):
+        def inner2(separate_colors: bool):
+            structure = ndimage.generate_binary_structure(2, 2 if connect_diagonals else 1)
+            components = []
+
+            if separate_colors:
+                colors = np.unique(g.grid)
+                colors = colors[colors != 0]
+                for c in colors:
+                    mask = (g.grid == c).astype(int)
+                    labeled, num = ndimage.label(mask, structure)
+                    for i in range(1, num + 1):
+                        submask = (labeled == i).astype(int) * c
+                        components.append(Grid(submask))
+            else:
+                mask = (g.grid != 0).astype(int)
+                labeled, num = ndimage.label(mask, structure)
+                for i in range(1, num + 1):
+                    submask = (labeled == i).astype(int) * g.grid
+                    components.append(Grid(submask))
+
+            return GridList(components)
+
+        return inner2
+    return inner
+
+def _objects(g: Grid) -> GridList:
+    connect_diagonals = False
+    separate_colors = True
+    return _objects2(g)(connect_diagonals)(separate_colors)
+def move_down(g: Grid) -> Grid:
+    """
+    Moves the first extracted object down by one row and overlays it back.
+    """
+    objects = _objects(g)
+    primitive_assert(len(objects) > 0, "No objects found to move.")
+
+    obj = objects[0]
+    newg = Grid(np.copy(g.grid))
+    newg.grid[obj.grid != 0] = 0
+
+    moved_obj = Grid(np.roll(obj.grid, 1, axis=0), position=obj.position)
+
+    return overlay(newg, moved_obj)
+def draw_line(g: Grid, angle: int) -> Grid:
+    """
+    Draw a line from some starting condition in the grid in the given direction.
+    Supported angles: 0 (right), 90 (up), 180 (left), 270 (down)
+    """
+    # For example, draw a line from top-left corner in given direction
+    new_grid = np.copy(g.grid)
+    h, w = new_grid.shape
+
+    if angle == 0:  # Right
+        new_grid[0, :] = 1
+    elif angle == 90:  # Up
+        new_grid[:, 0] = 1
+    elif angle == 180:  # Left
+        new_grid[-1, :] = 1
+    elif angle == 270:  # Down
+        new_grid[:, -1] = 1
+    else:
+        primitive_assert(False, f"Unsupported angle: {angle}")
+
+    return Grid(new_grid)
+def draw_line_slant_up(g: Grid) -> Grid:
+    """
+    Extracts first object and draws a 45-degree line from it.
+    """
+    objects = _objects(g)
+    primitive_assert(len(objects) > 0, "No objects found in draw_line_slant_up.")
+    obj = objects[0]
+    return draw_line(g)(obj)(45)
+def draw_line_slant_down(g: Grid) -> Grid:
+    """
+    Automatically extracts the first object from the grid and draws a 315-degree slant.
+    """
+    objects = _objects(g)
+    primitive_assert(len(objects) > 0, "No objects found in draw_line_slant_down.")
+    obj = objects[0]
+    return draw_line(g)(obj)(315)
+
+def _place_into_grid(objects):
+    grid = np.zeros(objects[0].input_grid.shape, dtype=int)
+    # print('grid: {}'.format(grid))
+    for obj in objects:
+        # print('obj: {}'.format(obj))
+        # note: x, y, w, h should be flipped in reality. just go with it
+        y, x = obj.position
+        # print('x, y: {}'.format((x, y)))
+        h, w = obj.grid.shape
+        g_h, g_w = grid.shape
+        # may need to crop the grid for it to fit
+        # if negative, crop out the first parts
+        o_x, o_y = max(0, -x), max(0, -y)
+        # if negative, start at zero instead
+        x, y = max(0, x), max(0, y)
+        # this also affects the width/height
+        w, h = w - o_x, h - o_y
+        # if spills out sides, crop out the extra
+        w, h = min(w, g_w - x), min(h, g_h - y)
+        # print('x, y = {}, {}, o_x, o_y = {}, {}, w, h = {}, {}'.format(x, y,
+            # o_x, o_y, w, h))
+
+        grid[y:y+h, x:x+w] = obj.grid[o_y: o_y + h, o_x: o_x + w]
+
+    return Grid(grid)

gp1.py

@@ -0,0 +1,215 @@
+import numpy as np
+import sys, os, json
+from deap import base, creator, gp, tools, algorithms
+from dsl import *
+import glob
+
+from dsl import _objects
+
+# Custom type definition (DEAP compatibility)
+class GridList(list):
+    pass
+
+# DEAP GP Setup
+creator.create("FitnessMax", base.Fitness, weights=(1.0,))
+creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMax)
+
+pset = gp.PrimitiveSetTyped("MAIN", [Grid], Grid)
+
+# Basic Grid primitives (all your previously defined primitives)
+pset.addPrimitive(ic_compress2, [Grid], Grid)
+pset.addPrimitive(flipy, [Grid], Grid)
+pset.addPrimitive(rot90, [Grid], Grid)
+pset.addPrimitive(rot180, [Grid], Grid)
+pset.addPrimitive(mirrorX, [Grid], Grid)
+pset.addPrimitive(mirrorY, [Grid], Grid)
+pset.addPrimitive(overlay, [Grid, Grid], Grid)
+pset.addPrimitive(set_bg, [int, Grid], Grid)
+pset.addPrimitive(ic_connectY, [Grid], Grid)
+pset.addPrimitive(ic_connectX, [Grid], Grid)
+pset.addPrimitive(ic_compress3, [Grid], Grid)
+pset.addPrimitive(ic_erasecol, [int, Grid], Grid)
+pset.addPrimitive(left_half, [Grid], Grid)
+pset.addPrimitive(right_half, [Grid], Grid)
+pset.addPrimitive(top_half, [Grid], Grid)
+pset.addPrimitive(repeatX, [Grid], Grid)
+pset.addPrimitive(flipx, [Grid], Grid)
+pset.addPrimitive(setcol, [Colour, Grid], Grid)
+pset.addPrimitive(ic_embed, [Grid, Grid], Grid)
+pset.addPrimitive(rot270, [Grid], Grid)
+
+# GridList-based primitives
+pset.addPrimitive(ic_splitall, [Grid], GridList)
+pset.addPrimitive(ic_composegrowing, [GridList], Grid)
+pset.addPrimitive(lambda x: GridList([x]), [Grid], GridList, name="toGridList")
+pset.addTerminal(GridList([]), GridList)
+pset.addPrimitive(ic_pickunique, [GridList], Grid)
+pset.addPrimitive(gravity_right, [Grid], Grid)
+pset.addPrimitive(split8, [Grid], GridList)
+pset.addPrimitive(ic_makeborder, [Grid], Grid)
+pset.addPrimitive(ic_filtercol, [Colour, Grid], Grid)
+pset.addPrimitive(ic_invert, [Grid], Grid)
+pset.addPrimitive(logical_and, [Grid, Grid], Grid)
+pset.addPrimitive(fillobj, [Colour, Grid], Grid)
+pset.addPrimitive(topcol, [Grid], Colour)
+pset.addPrimitive(rarestcol, [Grid], Colour)
+pset.addPrimitive(gravity_down, [Grid], Grid)
+pset.addPrimitive(pickcommon, [GridList], Grid)
+pset.addPrimitive(swapxy, [Grid], Grid)
+pset.addPrimitive(topcol, [Grid], Colour)
+pset.addPrimitive(setcol, [Colour, Grid], Grid)
+pset.addPrimitive(get_bg, [Grid], Colour)
+pset.addPrimitive(rarestcol, [Grid], Colour)
+pset.addPrimitive(ic_fill, [Colour, Grid], Grid)
+pset.addPrimitive(ic_center, [Grid], Grid)
+pset.addPrimitive(countToY, [Count, Colour], Grid)
+pset.addPrimitive(countPixels, [Grid], Count)
+pset.addPrimitive(ic_splitcols, [Grid], GridList)
+pset.addPrimitive(grid_split, [Grid], GridList)
+pset.addPrimitive(_objects, [Grid], GridList)
+pset.addPrimitive(overlay, [Grid, Grid], Grid)
+pset.addPrimitive(stack_no_crop, [GridList], Grid)
+pset.addPrimitive(move_down, [Grid], Grid)
+pset.addPrimitive(draw_line, [Grid, int], Grid)
+pset.addPrimitive(draw_line_slant_up, [Grid, Grid], Grid)
+pset.addPrimitive(draw_line_slant_down, [Grid], Grid)
+pset.addPrimitive(rarestcol, [Grid], int)
+pset.addPrimitive(lambda: 1, [], int, name="int_one")
+
+# Integer terminals
+for i in range(1, 10):
+    pset.addTerminal(i, int)
+
+
+import operator  # needed for operator.attrgetter
+
+toolbox = base.Toolbox()
+toolbox.register("compile", gp.compile, pset=pset)
+toolbox.register("select", tools.selTournament, tournsize=3)
+
+# Use leaf-biased crossover to avoid excessive tree growth
+toolbox.register("mate", gp.cxOnePointLeafBiased, termpb=0.1)
+
+# Mutation setup remains the same
+toolbox.register("expr_mut", gp.genFull, min_=0, max_=2)
+toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset)
+
+# Explicitly limit tree height to avoid memory errors
+MAX_TREE_HEIGHT = 17  # recommended limit
+toolbox.decorate("mate", gp.staticLimit(operator.attrgetter("height"), MAX_TREE_HEIGHT))
+toolbox.decorate("mutate", gp.staticLimit(operator.attrgetter("height"), MAX_TREE_HEIGHT))
+
+# Population initialization (unchanged)
+toolbox.register("population", tools.initRepeat, list,
+                 lambda: creator.Individual(gp.genHalfAndHalf(pset, min_=1, max_=3)))
+
+def evaluate_task(individual, task):
+    func = toolbox.compile(expr=individual)
+    total = 0
+    for example in task['train']:
+        inp = Grid(np.array(example["input"]))
+        tgt = Grid(np.array(example["output"]))
+        try:
+            out = func(inp)
+            if out.grid.shape == tgt.grid.shape:
+                total += np.sum(out.grid == tgt.grid)
+        except:
+            pass
+    return (total,)
+
+toolbox.register("evaluate", evaluate_task)
+
+# Folder containing your tasks
+training_folder = "./training/"
+task_files = glob.glob(training_folder + "*.json")
+
+results = []
+
+# Evaluate each task separately
+for task_file in task_files:
+    task_name = os.path.basename(task_file)
+    print(f"Processing {task_name}")
+
+    with open(task_file, 'r') as f:
+        task = json.load(f)
+
+    # GP initialization per task
+    pop = toolbox.population(n=150)
+    hof = tools.HallOfFame(1)
+
+    for gen in range(250):  # Adjust number of generations if needed
+        offspring = algorithms.varAnd(pop, toolbox, cxpb=0.5, mutpb=0.2)
+        fits = toolbox.map(lambda ind: toolbox.evaluate(ind, task), offspring)
+
+        for fit, ind in zip(fits, offspring):
+            ind.fitness.values = fit
+
+        hof.update(offspring)
+        pop = toolbox.select(offspring, k=len(pop))
+
+    # Evaluate best individual on the test set
+    best_ind = hof[0]
+    func = toolbox.compile(expr=best_ind)
+
+    correct = False
+    try:
+        for test_case in task["test"]:
+            test_inp = Grid(np.array(test_case["input"]))
+            expected_out = np.array(test_case["output"])
+            output_grid = func(test_inp).grid
+            if np.array_equal(output_grid, expected_out):
+                correct = True
+            else:
+                correct = False
+                break
+    except:
+        correct = False
+
+    results.append({
+        "task_name": task_name,
+        "best_program": str(best_ind),
+        "solution_found": correct
+    })
+
+    print(f"{task_name} completed. Solution found: {correct}")
+
+# Save summary results to JSON
+with open("tasks_results_summary.json", "w") as f:
+    json.dump(results, f, indent=2)
+
+print("All tasks processed. Results saved to tasks_results_summary.json.")
+# Put everything you already have here...
+# And then add this at the bottom:
+def run_task(task_path):
+    with open(task_path, 'r') as f:
+        task = json.load(f)
+
+    pop = toolbox.population(n=150)
+    hof = tools.HallOfFame(1)
+
+    for gen in range(250):
+        offspring = algorithms.varAnd(pop, toolbox, cxpb=0.5, mutpb=0.2)
+        fits = toolbox.map(lambda ind: toolbox.evaluate(ind, task), offspring)
+
+        for fit, ind in zip(fits, offspring):
+            ind.fitness.values = fit
+
+        hof.update(offspring)
+        pop = toolbox.select(offspring, k=len(pop))
+
+    best_ind = hof[0]
+    func = toolbox.compile(expr=best_ind)
+
+    # We'll just use the first test example for visual output
+    test_example = task["test"][0]
+    input_grid = np.array(test_example["input"])
+    target_grid = np.array(test_example["output"])
+
+    try:
+        output_grid = func(Grid(input_grid)).grid
+        correct = np.array_equal(output_grid, target_grid)
+    except:
+        output_grid = np.zeros_like(input_grid)
+        correct = False
+
+    return str(best_ind), correct, input_grid.tolist(), target_grid.tolist(), output_grid.tolist()

static/styles.css

@@ -0,0 +1,54 @@
+body {
+    font-family: Arial, sans-serif;
+    background-color: #111;
+    color: white;
+    text-align: center;
+}
+
+h1, h2, h3 {
+    color: #FFD700;
+}
+
+.grid-container {
+    display: flex;
+    justify-content: center;
+    gap: 50px;
+    margin-bottom: 30px;
+}
+
+.grid-wrapper {
+    background-color: #222;
+    padding: 15px;
+    border-radius: 10px;
+    box-shadow: 0 0 10px #fff3;
+}
+
+.grid {
+    display: inline-block;
+}
+
+.grid-row {
+    display: flex;
+}
+
+.cell {
+    width: 30px;
+    height: 30px;
+    border: 1px solid #333;
+}
+
+/* ARC Color Mapping: You can customize these */
+/* You can customize these */
+.color-0 { background-color: #000000; } /* black */
+.color-1 { background-color: #0074D9; } /* strong blue */
+.color-2 { background-color: #FF4136; } /* vivid red */
+.color-3 { background-color: #2ECC40; } /* bright green */
+.color-4 { background-color: #FFDC00; } /* yellow */
+.color-5 { background-color: #AAAAAA; } /* gray */
+.color-6 { background-color: #F012BE; } /* hot pink */
+.color-7 { background-color: #FF851B; } /* orange */
+.color-8 { background-color: #7FDBFF; } /* light blue */
+.color-9 { background-color: #870C25; } /* dark red */
+.color-10 { background-color: #FFFFFF; } /* white */
+
+

templates/index.html

@@ -0,0 +1,44 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Task Solver</title>
+  <link rel="stylesheet" href="{{ url_for('static', filename='styles.css') }}">
+</head>
+<body>
+  <h1>Genetic Programming Task Solver</h1>
+
+  <form method="POST">
+    <label for="task">Select a task:</label>
+    <select name="task" id="task" required>
+      <option disabled selected value="">-- Choose a task --</option>
+      {% for t in tasks %}
+        <option value="{{ t }}">{{ t }}</option>
+      {% endfor %}
+    </select>
+    <button type="submit">Solve</button>
+  </form>
+
+  {% if result %}
+    <h2>Result for: {{ result.task }}</h2>
+
+    <div class="grid-container">
+      <div class="grid-wrapper">
+        <h3>Input</h3>
+        {{ render_grid(result.input) }}
+      </div>
+      <div class="grid-wrapper">
+        <h3>Target Output</h3>
+        {{ render_grid(result.target) }}
+      </div>
+      <div class="grid-wrapper">
+        <h3>Generated Output</h3>
+        {{ render_grid(result.output) }}
+      </div>
+    </div>
+
+    <p><strong>Best Program:</strong> {{ result.program }}</p>
+    <p><strong>Solution Found:</strong> {{ result.success }}</p>
+  {% endif %}
+</body>
+</html>

training/00d62c1b (3).json

@@ -0,0 +1 @@
+{"train": [{"input": [[0, 0, 0, 0, 0, 0], [0, 0, 3, 0, 0, 0], [0, 3, 0, 3, 0, 0], [0, 0, 3, 0, 3, 0], [0, 0, 0, 3, 0, 0], [0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0], [0, 0, 3, 0, 0, 0], [0, 3, 4, 3, 0, 0], [0, 0, 3, 4, 3, 0], [0, 0, 0, 3, 0, 0], [0, 0, 0, 0, 0, 0]]}, {"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 0, 3, 0, 0, 0, 0, 0], [0, 0, 0, 3, 0, 3, 0, 0, 0, 0], [0, 0, 3, 0, 0, 0, 3, 0, 0, 0], [0, 0, 0, 0, 0, 3, 0, 3, 0, 0], [0, 0, 0, 3, 0, 3, 3, 0, 0, 0], [0, 0, 3, 3, 3, 0, 0, 0, 0, 0], [0, 0, 0, 3, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 0, 3, 0, 0, 0, 0, 0], [0, 0, 0, 3, 0, 3, 0, 0, 0, 0], [0, 0, 3, 0, 0, 0, 3, 0, 0, 0], [0, 0, 0, 0, 0, 3, 4, 3, 0, 0], [0, 0, 0, 3, 0, 3, 3, 0, 0, 0], [0, 0, 3, 3, 3, 0, 0, 0, 0, 0], [0, 0, 0, 3, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}, {"input": [[0, 0, 0, 0, 0, 3, 0, 0, 0, 0], [0, 0, 0, 0, 3, 0, 0, 0, 0, 0], [0, 3, 3, 0, 3, 3, 0, 3, 0, 0], [3, 0, 0, 3, 0, 0, 3, 0, 3, 0], [0, 0, 0, 3, 0, 0, 3, 3, 0, 0], [0, 0, 0, 3, 0, 0, 3, 0, 0, 0], [0, 0, 0, 3, 0, 0, 3, 0, 0, 0], [0, 0, 0, 0, 3, 3, 0, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 3, 0, 0, 0, 0], [0, 0, 0, 0, 3, 0, 0, 0, 0, 0], [0, 3, 3, 0, 3, 3, 0, 3, 0, 0], [3, 0, 0, 3, 4, 4, 3, 4, 3, 0], [0, 0, 0, 3, 4, 4, 3, 3, 0, 0], [0, 0, 0, 3, 4, 4, 3, 0, 0, 0], [0, 0, 0, 3, 4, 4, 3, 0, 0, 0], [0, 0, 0, 0, 3, 3, 0, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}, {"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 3, 3, 3, 0, 0, 0, 0], [0, 0, 3, 0, 0, 3, 0, 0, 0, 0], [0, 0, 3, 0, 0, 3, 0, 3, 0, 0], [0, 0, 3, 3, 3, 3, 3, 3, 3, 0], [0, 0, 0, 3, 0, 0, 0, 0, 3, 0], [0, 0, 0, 3, 0, 0, 0, 3, 3, 0], [0, 0, 0, 3, 3, 0, 0, 3, 0, 3], [0, 0, 0, 3, 0, 3, 0, 0, 3, 0], [0, 0, 0, 0, 3, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 3, 3, 3, 0, 0, 0, 0], [0, 0, 3, 4, 4, 3, 0, 0, 0, 0], [0, 0, 3, 4, 4, 3, 0, 3, 0, 0], [0, 0, 3, 3, 3, 3, 3, 3, 3, 0], [0, 0, 0, 3, 0, 0, 0, 0, 3, 0], [0, 0, 0, 3, 0, 0, 0, 3, 3, 0], [0, 0, 0, 3, 3, 0, 0, 3, 4, 3], [0, 0, 0, 3, 4, 3, 0, 0, 3, 0], [0, 0, 0, 0, 3, 0, 0, 0, 0, 0]]}, {"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 3, 3, 3, 3, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0], [0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0], [0, 0, 3, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 0, 0], [0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 3, 0, 0, 3, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 3, 3, 0, 0, 3, 0, 0, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 0, 3, 0, 0, 3, 3, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 3, 0, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 3, 3, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 3, 3, 3, 3, 4, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 4, 4, 4, 4, 4, 3, 0, 0, 0, 0], [0, 0, 0, 0, 3, 0, 0, 0, 3, 4, 4, 4, 4, 4, 4, 3, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 4, 4, 4, 4, 4, 3, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 4, 4, 4, 4, 4, 3, 0, 0, 0, 0], [0, 0, 3, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 3, 0, 3, 0, 0], [0, 0, 0, 0, 0, 0, 3, 3, 4, 4, 3, 0, 0, 3, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 4, 4, 3, 3, 0, 0, 3, 0, 0, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 0, 3, 0, 0, 3, 3, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 3, 4, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 3, 3, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}], "test": [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 3, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 0, 3, 3, 3, 3, 3, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 3, 0, 0, 0, 0, 3, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 3, 3, 3, 3, 3, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 0, 0, 0, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 3, 0, 0], [0, 0, 0, 0, 0, 0, 3, 3, 0, 3, 0, 0, 0, 3, 3, 3, 3, 3, 0, 0], [0, 0, 3, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 0, 3, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 3, 4, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 0, 3, 3, 3, 3, 3, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 3, 4, 4, 4, 4, 3, 4, 4, 3, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 3, 3, 3, 3, 3, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 4, 4, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 4, 4, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 4, 4, 4, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 4, 4, 3, 4, 4, 4, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 4, 4, 4, 3, 0, 0], [0, 0, 0, 0, 0, 0, 3, 3, 4, 3, 0, 0, 0, 3, 3, 3, 3, 3, 0, 0], [0, 0, 3, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 3, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 0, 3, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 4, 4, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 4, 4, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}]}

training/1cf80156.json

@@ -0,0 +1 @@
+{"train": [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 2, 2, 2], [0, 0, 2, 0], [2, 2, 2, 0], [2, 0, 2, 0]]}, {"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[1, 0, 0], [1, 1, 0], [0, 1, 0], [1, 1, 1], [0, 0, 1]]}, {"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 8, 0, 8, 0, 0, 0, 0, 0], [0, 0, 0, 8, 8, 8, 8, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 8, 0, 8, 0], [8, 8, 8, 8, 0], [0, 0, 0, 8, 8]]}], "test": [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 6, 6, 6, 6, 0, 0, 0, 0], [0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 0, 6, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 6, 6, 6, 6], [0, 0, 6, 0, 0, 0], [6, 0, 6, 0, 0, 0], [6, 6, 6, 6, 0, 0]]}]}

training/8a004b2b.json

@@ -0,0 +1 @@
+{"train": [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 4, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 4, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 8, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[4, 0, 0, 0, 0, 0, 4], [0, 2, 2, 3, 3, 0, 0], [0, 2, 2, 3, 3, 0, 0], [0, 3, 3, 8, 8, 0, 0], [0, 3, 3, 8, 8, 0, 0], [0, 0, 0, 0, 0, 0, 0], [4, 0, 0, 0, 0, 0, 4]]}, {"input": [[0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0], [0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 3, 3, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0], [0, 3, 3, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0], [0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0], [0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4]]}, {"input": [[0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0], [0, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0], [0, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0], [0, 0, 0, 0, 3, 3, 3, 1, 1, 1, 0], [0, 0, 0, 0, 3, 3, 3, 1, 1, 1, 0], [0, 0, 0, 0, 3, 3, 3, 1, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4]]}], "test": [{"input": [[4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 8, 8, 8, 8, 0, 0, 0, 0, 3, 3, 3, 3, 0, 0], [0, 0, 0, 0, 8, 8, 8, 8, 0, 0, 0, 0, 3, 3, 3, 3, 0, 0], [0, 0, 0, 0, 8, 8, 8, 8, 0, 0, 0, 0, 3, 3, 3, 3, 0, 0], [0, 0, 0, 0, 8, 8, 8, 8, 0, 0, 0, 0, 3, 3, 3, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 3, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 8, 8, 8, 8, 0, 0, 0, 0, 3, 3, 3, 3, 0, 0], [0, 0, 0, 0, 8, 8, 8, 8, 0, 0, 0, 0, 3, 3, 3, 3, 0, 0], [0, 0, 0, 0, 8, 8, 8, 8, 0, 0, 0, 0, 3, 3, 3, 3, 0, 0], [0, 0, 0, 0, 8, 8, 8, 8, 0, 0, 0, 0, 3, 3, 3, 3, 0, 0], [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0], [4, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 4]]}]}