multi-puzzle-solver 0.9.15__py3-none-any.whl → 0.9.20__py3-none-any.whl

puzzle_solver/puzzles/slant/slant.py

@@ -0,0 +1,117 @@
+from typing import Literal, Optional, Union
+from dataclasses import dataclass
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, set_char, in_bounds, get_pos
+from puzzle_solver.core.utils_ortools import force_no_loops, generic_solve_all, SingleSolution
+
+
+@dataclass(frozen=True)
+class Node:
+    """The grid is represented as a graph of cells connected to corners."""
+    node_type: Union[Literal["Cell"], Literal["Corner"]]
+    pos: Pos
+    slant: Union[Literal["//"], Literal["\\"], None]
+
+    def get_neighbors(self, board_nodes: dict[tuple[str, Pos, Optional[str]], "Node"]) -> list["Node"]:
+        if self.node_type == "Cell" and self.slant == "//":
+            n1 = board_nodes[("Corner", get_pos(self.pos.x+1, self.pos.y), None)]
+            n2 = board_nodes[("Corner", get_pos(self.pos.x, self.pos.y+1), None)]
+            return [n1, n2]
+        elif self.node_type == "Cell" and self.slant == "\\":
+            n1 = board_nodes[("Corner", get_pos(self.pos.x, self.pos.y), None)]
+            n2 = board_nodes[("Corner", get_pos(self.pos.x+1, self.pos.y+1), None)]
+            return [n1, n2]
+        elif self.node_type == "Corner":
+            # 4 cells, 2 cells per slant
+            n1 = ("Cell", get_pos(self.pos.x-1, self.pos.y-1), "\\")
+            n2 = ("Cell", get_pos(self.pos.x, self.pos.y-1), "//")
+            n3 = ("Cell", get_pos(self.pos.x-1, self.pos.y), "//")
+            n4 = ("Cell", get_pos(self.pos.x, self.pos.y), "\\")
+            return {board_nodes[n] for n in [n1, n2, n3, n4] if n in board_nodes}
+
+
+class Board:
+    def __init__(self, numbers: Union[list[tuple[Pos, int]], np.array], V: int = None, H: int = None):
+        if isinstance(numbers, np.ndarray):
+            V, H = numbers.shape
+            V = V - 1
+            H = H - 1
+            numbers = [(get_pos(x=pos[1], y=pos[0]), int(d)) for pos, d in np.ndenumerate(numbers) if str(d).isdecimal()]
+            numbers = [(p, n) for p, n in numbers if n >= 0]
+        else:
+            assert V is not None and H is not None, 'V and H must be provided if numbers is not a numpy array'
+        assert V >= 1 and H >= 1, 'V and H must be at least 1'
+        assert all(isinstance(number, int) and number >= 0 for (pos, number) in numbers), 'numbers must be a list of integers'
+        self.V = V
+        self.H = H
+        self.numbers = numbers
+        self.pos_to_number: dict[Pos, int] = {pos: number for pos, number in numbers}
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[tuple[Pos, str], cp_model.IntVar] = {}
+        self.nodes: dict[Node, cp_model.IntVar] = {}
+        self.neighbor_dict: dict[Node, set[Node]] = {}
+
+        self.create_vars()
+        self.add_all_constraints()
+
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.model_vars[(pos, '//')] = self.model.NewBoolVar(f'{pos}://')
+            self.model_vars[(pos, '\\')] = self.model.NewBoolVar(f'{pos}:\\')
+            self.model.AddExactlyOne([self.model_vars[(pos, '//')], self.model_vars[(pos, '\\')]])
+        for (pos, slant), v in self.model_vars.items():
+            self.nodes[Node(node_type="Cell", pos=pos, slant=slant)] = v
+        for pos in get_all_pos(self.V + 1, self.H + 1):
+            self.nodes[Node(node_type="Corner", pos=pos, slant=None)] = self.model.NewConstant(1)
+
+
+    def add_all_constraints(self):
+        for pos, number in self.pos_to_number.items():
+            # pos is a position on the intersection of 4 cells
+            # when pos is (xi, yi) then it gets a +1 contribution for each:
+            # - cell (xi-1, yi-1) is a "\\"
+            # - cell (xi, yi) is a "\\"
+            # - cell (xi, yi-1) is a "//"
+            # - cell (xi-1, yi) is a "//"
+            xi, yi = pos.x, pos.y
+            tl_pos = get_pos(xi-1, yi-1)
+            br_pos = get_pos(xi, yi)
+            tr_pos = get_pos(xi, yi-1)
+            bl_pos = get_pos(xi-1, yi)
+            tl_var = self.model_vars[(tl_pos, '\\')] if in_bounds(tl_pos, self.V, self.H) else 0
+            br_var = self.model_vars[(br_pos, '\\')] if in_bounds(br_pos, self.V, self.H) else 0
+            tr_var = self.model_vars[(tr_pos, '//')] if in_bounds(tr_pos, self.V, self.H) else 0
+            bl_var = self.model_vars[(bl_pos, '//')] if in_bounds(bl_pos, self.V, self.H) else 0
+            self.model.Add(sum([tl_var, tr_var, bl_var, br_var]) == number)
+        board_nodes = {(node.node_type, node.pos, node.slant): node for node in self.nodes.keys()}
+        self.neighbor_dict = {node: node.get_neighbors(board_nodes) for node in self.nodes.keys()}
+        no_loops_vars = force_no_loops(self.model, self.nodes, is_neighbor=lambda n1, n2: n1 in self.neighbor_dict[n2])
+        self.no_loops_vars = no_loops_vars
+
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            # graph = {node: solver.Value(var) for node, var in board.nodes.items()}
+            for (pos, s), var in board.model_vars.items():
+                if solver.Value(var) == 1:
+                    assignment[pos] = s
+            for p in get_all_pos(self.V, self.H):
+                assert p in assignment, f'position {p} is not assigned a number'
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.V, self.H), ' ', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                set_char(res, pos, '/' if single_res.assignment[pos] == '//' else '\\')
+            print('[')
+            for row in range(self.V):
+                line = '    [ ' + ' '.join(res[row].tolist()) + ' ]'
+                print(line)
+            print(']')
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/slitherlink/slitherlink.py

@@ -0,0 +1,248 @@
+import numpy as np
+from collections import defaultdict
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, get_pos, Direction, get_row_pos, get_col_pos, get_next_pos, in_bounds, get_opposite_direction
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
+
+
+CellBorder = tuple[Pos, Direction]
+Corner = Pos
+
+
+class Board:
+    def __init__(self, board: np.array):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all(c.item() == ' ' or str(c.item()).isdecimal() for c in np.nditer(board)), 'board must contain only spaces or digits'
+        self.V = board.shape[0]
+        self.H = board.shape[1]
+        self.board = board
+        self.cell_borders_to_corners: dict[CellBorder, set[Corner]] = defaultdict(set)  # for every cell border, a set of all corners it is connected to
+        self.corners_to_cell_borders: dict[Corner, set[CellBorder]] = defaultdict(set)  # opposite direction
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[CellBorder, cp_model.IntVar] = {}  # one entry for every unique variable in the model
+        self.cell_borders: dict[CellBorder, cp_model.IntVar] = {}  # for every position and direction, one entry for that edge (thus the same edge variables are used in opposite directions of neighboring cells)
+        self.corner_vars: dict[Corner, set[cp_model.IntVar]] = defaultdict(set)  # for every corner, one entry for each edge that touches the corner (i.e. 4 per corner unless on the border)
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            for direction in [Direction.RIGHT, Direction.DOWN]:
+                self.add_var(pos, direction)
+        for pos in get_row_pos(0, self.H):
+            self.add_var(pos, Direction.UP)
+        for pos in get_col_pos(0, self.V):
+            self.add_var(pos, Direction.LEFT)
+
+    def add_var(self, pos: Pos, direction: Direction):
+        cell_border = (pos, direction)
+        v = self.model.NewBoolVar(f'main:{cell_border}')
+        self.model_vars[cell_border] = v
+        self.add_cell_border_var(cell_border, v)
+        self.add_corner_vars(cell_border, v)
+
+    def add_cell_border_var(self, cell_border: CellBorder, var: cp_model.IntVar):
+        """An edge belongs to two cells unless its on the border in which case it only belongs to one."""
+        pos, direction = cell_border
+        self.cell_borders[cell_border] = var
+        next_pos = get_next_pos(pos, direction)
+        if in_bounds(next_pos, self.V, self.H):
+            self.cell_borders[(next_pos, get_opposite_direction(direction))] = var
+    
+    def add_corner_vars(self, cell_border: CellBorder, var: cp_model.IntVar):
+        """
+        An edge always belongs to two corners. Note that the cell xi,yi has the 4 corners (xi,yi), (xi+1,yi), (xi,yi+1), (xi+1,yi+1). (memorize these 4 coordinates or the function wont make sense)
+        Thus corner index is +1 of board coordinates.
+        Never check for bounds here because an edge ALWAYS touches two corners AND because the +1 will make in_bounds return False when its still in bounds.
+        """
+        pos, direction = cell_border
+        if direction == Direction.LEFT:  # it touches me and (xi,yi+1)
+            corner1 = pos
+            corner2 = get_next_pos(pos, Direction.DOWN)
+        elif direction == Direction.UP:  # it touches me and (xi+1,yi)
+            corner1 = pos
+            corner2 = get_next_pos(pos, Direction.RIGHT)
+        elif direction == Direction.RIGHT:  # it touches (xi+1,yi) and (xi+1,yi+1)
+            corner1 = get_next_pos(pos, Direction.RIGHT)
+            corner2 = get_next_pos(corner1, Direction.DOWN)
+        elif direction == Direction.DOWN:  # it touches (xi,yi+1) and (xi+1,yi+1)
+            corner1 = get_next_pos(pos, Direction.DOWN)
+            corner2 = get_next_pos(corner1, Direction.RIGHT)
+        else:
+            raise ValueError(f'Invalid direction: {direction}')
+        self.corner_vars[corner1].add(var)
+        self.corner_vars[corner2].add(var)
+        self.cell_borders_to_corners[cell_border].add(corner1)
+        self.cell_borders_to_corners[cell_border].add(corner2)
+        self.corners_to_cell_borders[corner1].add(cell_border)
+        self.corners_to_cell_borders[corner2].add(cell_border)
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):  # enforce cells with numbers
+            variables = [self.cell_borders[(pos, direction)] for direction in Direction if (pos, direction) in self.cell_borders]
+            val = get_char(self.board, pos)
+            if not val.isdecimal():
+                continue
+            self.model.Add(sum(variables) == int(val))
+        for corner in self.corner_vars:  # a corder always has 0 or 2 active edges
+            g = self.model.NewBoolVar(f'corner_gate_{corner}')
+            self.model.Add(sum(self.corner_vars[corner]) == 0).OnlyEnforceIf(g.Not())
+            self.model.Add(sum(self.corner_vars[corner]) == 2).OnlyEnforceIf(g)
+        # single connected component
+        def is_neighbor(cb1: CellBorder, cb2: CellBorder) -> bool:
+            cb1_corners = self.cell_borders_to_corners[cb1]
+            cb2_corners = self.cell_borders_to_corners[cb2]
+            return len(cb1_corners & cb2_corners) > 0
+        force_connected_component(self.model, self.model_vars, is_neighbor=is_neighbor)
+
+
+
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, str] = {}
+            for (pos, direction), var in board.model_vars.items():
+                if solver.value(var) == 1:
+                    if pos not in assignment:
+                        assignment[pos] = ''
+                    assignment[pos] += direction.name[0]
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.V, self.H), ' ', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                if pos not in single_res.assignment:
+                    continue
+                c = ''.join(sorted(single_res.assignment[pos]))
+                set_char(res, pos, c)
+            print(render_grid(cell_flags=res, center_char=lambda c, r: self.board[r, c] if self.board[r, c] != ' ' else '·'))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose, max_solutions=999)
+
+
+
+
+
+def render_grid(cell_flags: np.ndarray = None,
+                H: np.ndarray = None,
+                V: np.ndarray = None,
+                mark_centers: bool = True,
+                center_char: str = '·',
+                show_axes: bool = True,
+                scale_x: int = 2) -> str:
+    """
+    AI generated this because I don't currently care about the details of rendering to the terminal and I did it in a quick and dirty way while the AI made it in a pretty way, and this looks good during my development.
+        cell_flags: np.ndarray of shape (N, N) with characters 'U', 'D', 'L', 'R' to represent the edges of the cells.
+    OR:
+        H: (N+1, N) horizontal edges between corners
+        V: (N,   N+1) vertical edges between corners
+    scale_x: horizontal stretch factor (>=1). Try 2 or 3 for squarer cells.
+    """
+    if cell_flags is not None:
+        N = cell_flags.shape[0]
+        H = np.zeros((N+1, N), dtype=bool)
+        V = np.zeros((N, N+1), dtype=bool)
+        for r in range(N):
+            for c in range(N):
+                s = cell_flags[r, c]
+                if 'U' in s: H[r, c]   = True          # edge between (r,c) and (r, c+1) above the cell
+                if 'D' in s: H[r+1, c] = True          # edge below the cell
+                if 'L' in s: V[r, c]   = True          # edge left of the cell
+                if 'R' in s: V[r, c+1] = True          # edge right of the cell
+    assert H is not None and V is not None, 'H and V must be provided'
+    # Bitmask for corner connections
+    U, R, D, L = 1, 2, 4, 8
+    JUNCTION = {
+        0: ' ',
+        U: '│', D: '│', U|D: '│',
+        L: '─', R: '─', L|R: '─',
+        U|R: '└', R|D: '┌', D|L: '┐', L|U: '┘',
+        U|D|L: '┤', U|D|R: '├', L|R|U: '┴', L|R|D: '┬',
+        U|R|D|L: '┼',
+    }
+
+    assert scale_x >= 1
+    N = V.shape[0]
+    assert H.shape == (N+1, N) and V.shape == (N, N+1)
+
+    rows = 2*N + 1
+    cols = 2*N*scale_x + 1                 # stretched width
+    canvas = [[' ']*cols for _ in range(rows)]
+
+    def x_corner(c):     # x of corner column c
+        return (2*c) * scale_x
+    def x_between(c,k):  # kth in-between column (1..scale_x) between c and c+1 corners
+        return (2*c) * scale_x + k
+
+    # horizontal edges: fill the stretched band between corners with '─'
+    for r in range(N+1):
+        rr = 2*r
+        for c in range(N):
+            if H[r, c]:
+                # previously: for k in range(1, scale_x*2, 2):
+                for k in range(1, scale_x*2):          # 1..(2*scale_x-1), no gaps
+                    canvas[rr][x_between(c, k)] = '─'
+
+    # vertical edges: draw at the corner columns (no horizontal stretching needed)
+    for r in range(N):
+        rr = 2*r + 1
+        for c in range(N+1):
+            if V[r, c]:
+                canvas[rr][x_corner(c)] = '│'
+
+    # junctions at corners
+    for r in range(N+1):
+        rr = 2*r
+        for c in range(N+1):
+            m = 0
+            if r > 0   and V[r-1, c]: m |= U
+            if c < N   and H[r, c]:   m |= R
+            if r < N   and V[r, c]:   m |= D
+            if c > 0   and H[r, c-1]: m |= L
+            canvas[rr][x_corner(c)] = JUNCTION[m]
+
+    # centers (help count exact widths/heights)
+    if mark_centers:
+        for r in range(N):
+            rr = 2*r + 1
+            for c in range(N):
+                # center lies midway across the stretched span
+                xc = x_corner(c) + scale_x          # middle-ish; works for any integer scale_x
+                canvas[rr][xc] = center_char if isinstance(center_char, str) else center_char(c, r)
+
+    # turn canvas rows into strings
+    art_rows = [''.join(row) for row in canvas]
+
+    if not show_axes:
+        return '\n'.join(art_rows)
+
+    # ── Axes ────────────────────────────────────────────────────────────────
+    gut = max(2, len(str(N-1)))       # left gutter width
+    gutter = ' ' * gut
+    top_tens = list(gutter + ' ' * cols)
+    top_ones = list(gutter + ' ' * cols)
+
+    for c in range(N):
+        xc_center = x_corner(c) + scale_x
+        if N >= 10:
+            top_tens[gut + xc_center] = str((c // 10) % 10)
+        top_ones[gut + xc_center] = str(c % 10)
+
+    # tiny corner labels
+    if gut >= 2:
+        top_tens[gut-2:gut] = list('  ')
+        top_ones[gut-2:gut] = list('  ')
+
+    labeled = []
+    for r, line in enumerate(art_rows):
+        if r % 2 == 1:                     # cell-center row
+            label = str(r//2).rjust(gut)
+        else:
+            label = ' ' * gut
+        labeled.append(label + line)
+
+    return ''.join(top_tens) + '\n' + ''.join(top_ones) + '\n' + '\n'.join(labeled)
+
+

puzzle_solver/puzzles/stitches/parse_map/parse_map.py

@@ -1,8 +1,9 @@
 """
-    This file is a simple helper that parses the images from https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/inertia.html and converts them to a json file. 
+    This file is a simple helper that parses the images from https://www.puzzle-stitches.com/ and converts them to a json file. 
     Look at the ./input_output/ directory for examples of input images and output json files.
     The output json is used in the test_solve.py file to test the solver.
 """
+# import json
 from pathlib import Path
 import numpy as np
 cv = None
@@ -72,6 +73,8 @@ def mean_consecutives(arr: np.ndarray) -> np.ndarray:
     return np.array(sums) // np.array(counts)
 
 def dfs(x, y, out, output, current_num):
+    # if current_num == '48':
+    #     print('dfs', x, y, current_num)
     if x < 0 or x >= out.shape[1] or y < 0 or y >= out.shape[0]:
         return
     if out[y, x] != '  ':
@@ -136,6 +139,8 @@ def main(image):
             cell = src[hidx1:hidx2, vidx1:vidx2]
             mid_x = cell.shape[1] // 2
             mid_y = cell.shape[0] // 2
+            # if j > height - 4 and i > width - 6:
+            #     show_wait_destroy(f"cell_{i}_{j}", cell)
             # show_wait_destroy(f"cell_{i}_{j}", cell)
             cell = cv.bitwise_not(cell)  # invert colors
             top = cell[0:10, mid_y-5:mid_y+5]
@@ -156,10 +161,18 @@ def main(image):
     axs[1, 0].set_title('Right')
     axs[1, 1].hist(list(hists['bottom'].values()), bins=100)
     axs[1, 1].set_title('Bottom')
+    global_target = None
+    # global_target = 28_000
     target_top = np.mean(list(hists['top'].values()))
     target_left = np.mean(list(hists['left'].values()))
     target_right = np.mean(list(hists['right'].values()))
     target_bottom = np.mean(list(hists['bottom'].values()))
+    if global_target is not None:
+        target_top = global_target
+        target_left = global_target
+        target_right = global_target
+        target_bottom = global_target
+
     axs[0, 0].axvline(target_top, color='red')
     axs[0, 1].axvline(target_left, color='red')
     axs[1, 0].axvline(target_right, color='red')
@@ -185,12 +198,18 @@ def main(image):
             print('   Sums: ', hists['top'][j, i], hists['left'][j, i], hists['right'][j, i], hists['bottom'][j, i])
 
     current_count = 0
-    out = np.full_like(output['top'], '  ', dtype='U2')
+    z_fill = 2
+    out = np.full_like(output['top'], '  ', dtype='U32')
     for j in range(out.shape[0]):
+        if current_count > 99:
+            z_fill = 3
         for i in range(out.shape[1]):
             if out[j, i] == '  ':
-                dfs(i, j, out, output, str(current_count).zfill(2))
+                if current_count == 48:
+                    print(f"current_count: {current_count}, x: {i}, y: {j}")
+                dfs(i, j, out, output, str(current_count).zfill(z_fill))
                 current_count += 1
+    print(out)
 
     with open(output_path, 'w') as f:
         f.write('[\n')
@@ -202,6 +221,18 @@ def main(image):
         f.write(']')
     print('output json: ', output_path)
 
+    # with open(output_path.parent / 'debug.json', 'w') as f:
+    #     debug_pos = {}
+    #     for j in range(out.shape[0]):
+    #         for i in range(out.shape[1]):
+    #             out_str = ''
+    #             out_str += 'T' if output['top'][j, i] else ''
+    #             out_str += 'L' if output['left'][j, i] else ''
+    #             out_str += 'R' if output['right'][j, i] else ''
+    #             out_str += 'B' if output['bottom'][j, i] else ''
+    #             debug_pos[f'{j}_{i}'] = out_str
+    #     json.dump(debug_pos, f, indent=2)
+
 if __name__ == '__main__':
     # to run this script and visualize the output, in the root run:
     #  python .\src\puzzle_solver\puzzles\stitches\parse_map\parse_map.py | python .\src\puzzle_solver\utils\visualizer.py --read_stdin
@@ -209,4 +240,6 @@ if __name__ == '__main__':
     # main(Path(__file__).parent / 'input_output' / 'weekly_oct_3rd_2025.png')
     # main(Path(__file__).parent / 'input_output' / 'star_battle_67f73ff90cd8cdb4b3e30f56f5261f4968f5dac940bc6.png')
     # main(Path(__file__).parent / 'input_output' / 'LITS_MDoxNzksNzY3.png')
-    main(Path(__file__).parent / 'input_output' / 'lits_OTo3LDMwNiwwMTU=.png')
+    # main(Path(__file__).parent / 'input_output' / 'lits_OTo3LDMwNiwwMTU=.png')
+    # main(Path(__file__).parent / 'input_output' / 'norinori_501d93110d6b4b818c268378973afbf268f96cfa8d7b4.png')
+    main(Path(__file__).parent / 'input_output' / 'norinori_OTo0LDc0Miw5MTU.png')

puzzle_solver/puzzles/unequal/unequal.py

@@ -0,0 +1,128 @@
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_row_pos, get_col_pos, set_char, get_pos, get_char, Direction, in_bounds, get_next_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+def parse_board(board: np.array) -> tuple[np.array, list[tuple[Pos, Pos, str]]]:
+    """Returns the internal board and a list for every pair of positions (p1, p2, comparison_type) where p1 < p2 if comparison_type is '<' otherwise abs(p1 - p2)==1 if comparison_type is '|'"""
+    V = int(np.ceil(board.shape[0] / 2))
+    H = int(np.ceil(board.shape[1] / 2))
+    internal_board = np.full((V, H), ' ', dtype=object)
+    pairs = []
+    for row_i in range(board.shape[0]):
+        for col_i in range(board.shape[1]):
+            cell = board[row_i, col_i]
+            if row_i % 2 == 0 and col_i % 2 == 0:  # number or empty cell
+                if cell == ' ':
+                    continue
+                # map A to 10, B to 11, etc.
+                if str(cell).isalpha() and len(str(cell)) == 1:
+                    cell = ord(cell.upper()) - ord('A') + 10
+                assert str(cell).isdecimal(), f'expected number at {row_i, col_i}, got {cell}'
+                internal_board[row_i // 2, col_i // 2] = int(cell)
+            elif row_i % 2 == 0 and col_i % 2 == 1:  # horizontal comparison
+                assert cell in ['<', '>', '|', ' '], f'expected <, >, |, or empty cell at {row_i, col_i}, got {cell}'
+                if cell == ' ':
+                    continue
+                p1 = get_pos(x=col_i // 2, y=row_i // 2)
+                p2 = get_pos(x=p1.x + 1, y=p1.y)
+                if cell == '<':
+                    pairs.append((p1, p2, '<'))
+                elif cell == '>':
+                    pairs.append((p2, p1, '<'))
+                elif cell == '|':
+                    pairs.append((p1, p2, '|'))
+                else:
+                    raise ValueError(f'unexpected cell {cell} at {row_i, col_i}')
+            elif row_i % 2 == 1 and col_i % 2 == 0:  # vertical comparison
+                assert cell in ['∧', '∨', 'U', 'D', 'V', 'n', '-', '|', ' '], f'expected ∧, ∨, U, D, V, n, -, |, or empty cell at {row_i, col_i}, got {cell}'
+                if cell == ' ':
+                    continue
+                p1 = get_pos(x=col_i // 2, y=row_i // 2)
+                p2 = get_pos(x=p1.x, y=p1.y + 1)
+                if cell in ['∨', 'U', 'V']:
+                    pairs.append((p2, p1, '<'))
+                elif cell in ['∧', 'D', 'n']:
+                    pairs.append((p1, p2, '<'))
+                elif cell in ['-', '|']:
+                    pairs.append((p1, p2, '|'))
+                else:
+                    raise ValueError(f'unexpected cell {cell} at {row_i, col_i}')
+            else:
+                assert cell in [' ', '.', 'X'], f'expected empty cell or dot or X at unused corner {row_i, col_i}, got {cell}'
+    return internal_board, pairs
+
+class Board:
+    def __init__(self, board: np.array, adjacent_mode: bool = False, include_zero_before_letter: bool = True):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert board.shape[0] > 0 and board.shape[1] > 0, 'board must be non-empty'
+        self.board, self.pairs = parse_board(board)
+        self.adjacent_mode = adjacent_mode
+        self.V, self.H = self.board.shape
+        self.lb = 1
+        self.N = max(self.V, self.H)
+        if include_zero_before_letter and self.N > 9: # zero is introduced when board gets to 10, then we add 1 letter after that
+            self.lb = 0
+            self.N -= 1
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for pos in get_all_pos(self.V, self.H):
+            self.model_vars[pos] = self.model.NewIntVar(self.lb, self.N, f'{pos}')
+
+    def add_all_constraints(self):
+        for row_i in range(self.V):
+            self.model.AddAllDifferent([self.model_vars[pos] for pos in get_row_pos(row_i, self.H)])
+        for col_i in range(self.H):
+            self.model.AddAllDifferent([self.model_vars[pos] for pos in get_col_pos(col_i, self.V)])
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.board, pos)
+            if str(c).isdecimal():
+                self.model.Add(self.model_vars[pos] == int(c))
+
+        for p1, p2, comparison_type in self.pairs:
+            assert comparison_type in ['<', '|'], f'SHOULD NEVER HAPPEN: invalid comparison type {comparison_type}, expected < or |'
+            if comparison_type == '<':
+                self.model.Add(self.model_vars[p1] < self.model_vars[p2])
+            elif comparison_type == '|':
+                aux = self.model.NewIntVar(0, 2*self.N, f'aux_{p1}_{p2}')
+                self.model.AddAbsEquality(aux, self.model_vars[p1] - self.model_vars[p2])
+                self.model.Add(aux == 1)
+        if self.adjacent_mode:
+            # in adjacent mode, there is strict NON adjacency if a | does not exist
+            all_pairs = {(p1, p2) for p1, p2, _ in self.pairs}
+            for pos in get_all_pos(self.V, self.H):
+                for direction in [Direction.RIGHT, Direction.DOWN]:
+                    neighbor = get_next_pos(pos, direction)
+                    if not in_bounds(neighbor, self.V, self.H):
+                        continue
+                    if (pos, neighbor) in all_pairs:
+                        continue
+                    assert (neighbor, pos) not in all_pairs, f'SHOULD NEVER HAPPEN: both {pos}->{neighbor} and {neighbor}->{pos} are in the same pair'
+                    aux = self.model.NewIntVar(0, 2*self.N, f'aux_{pos}_{neighbor}')
+                    self.model.AddAbsEquality(aux, self.model_vars[pos] - self.model_vars[neighbor])
+                    self.model.Add(aux != 1)
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            for pos, var in board.model_vars.items():
+                assignment[pos] = solver.Value(var)
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.V, self.H), ' ', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                set_char(res, pos, str(single_res.assignment[pos]))
+            print('[')
+            for row in range(self.V):
+                line = '    [ ' + ' '.join(res[row].tolist()) + ' ]'
+                print(line)
+            print(']')
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)