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

puzzle_solver/puzzles/galaxies/galaxies.py

@@ -0,0 +1,110 @@
+from collections import defaultdict
+from typing import Iterable, Union
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, Direction, get_next_pos, in_bounds, get_opposite_direction, get_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, or_constraint, force_connected_component
+
+
+def parse_numpy(galaxies: np.ndarray) -> list[tuple[Pos, ...]]:
+    result = defaultdict(list)
+    for pos, arr_id in np.ndenumerate(galaxies):
+        if not arr_id.strip():
+            continue
+        result[arr_id].append(get_pos(x=pos[1], y=pos[0]))
+    return [positions for _, positions in sorted(result.items(), key=lambda x: x[0])]
+
+
+class Board:
+    def __init__(self, galaxies: Union[list[tuple[Pos, ...]], np.ndarray], V: int = None, H: int = None):
+        if isinstance(galaxies, np.ndarray):
+            V, H = galaxies.shape
+            galaxies = parse_numpy(galaxies)
+        else:
+            assert V is not None and H is not None, 'V and H must be provided if galaxies is not a numpy array'
+        assert V >= 1 and H >= 1, 'V and H must be at least 1'
+        assert all(isinstance(galaxy, Iterable) for galaxy in galaxies), 'galaxies must be a list of Iterables'
+        assert all(len(galaxy) in [1, 2, 4] for galaxy in galaxies), 'each galaxy must be exactly 1, 2, or 4 positions'
+        self.V = V
+        self.H = H
+        self.n_galaxies = len(galaxies)
+        self.galaxies = galaxies
+        self.prelocated_positions: set[Pos] = {pos: i for i, galaxy in enumerate(galaxies) for pos in galaxy}
+
+        self.model = cp_model.CpModel()
+        self.pos_to_galaxy: dict[Pos, dict[int, cp_model.IntVar]] = {p: {} for p in get_all_pos(V, H)}  # each position can be part of exactly one out of many possible galaxies
+        self.allocated_pairs: set[tuple[Pos, Pos]] = set()  # each pair is allocated to exactly one galaxy
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for i in range(self.n_galaxies):
+            galaxy = self.galaxies[i]
+            if len(galaxy) == 1:
+                p1, p2 = galaxy[0], galaxy[0]
+            elif len(galaxy) == 2:
+                p1, p2 = galaxy[0], galaxy[1]
+            elif len(galaxy) == 4:
+                p1, p2 = galaxy[0], galaxy[3]  # [1] and [2] will be linked with symmetry
+            self.expand_galaxy(p1, p2, i)
+
+    def expand_galaxy(self, p1: Pos, p2: Pos, galaxy_idx: int):
+        if (p1, p2) in self.allocated_pairs or (p2, p1) in self.allocated_pairs:
+            return
+        if p1 in self.prelocated_positions and self.prelocated_positions[p1] != galaxy_idx:
+            return
+        if p2 in self.prelocated_positions and self.prelocated_positions[p2] != galaxy_idx:
+            return
+        if not in_bounds(p1, self.V, self.H) or not in_bounds(p2, self.V, self.H):
+            return
+        self.bind_pair(p1, p2, galaxy_idx)
+        # symmetrically expand the galaxy until illegal position is hit
+        for direction in [Direction.RIGHT, Direction.UP, Direction.DOWN, Direction.LEFT]:
+            symmetrical_direction = get_opposite_direction(direction)
+            new_p1 = get_next_pos(p1, direction)
+            new_p2 = get_next_pos(p2, symmetrical_direction)
+            self.expand_galaxy(new_p1, new_p2, galaxy_idx)
+
+    def bind_pair(self, p1: Pos, p2: Pos, galaxy_idx: int):
+        assert galaxy_idx not in self.pos_to_galaxy[p1], f'p1={p1} already has galaxy idx={galaxy_idx}'
+        assert galaxy_idx not in self.pos_to_galaxy[p2], f'p2={p2} already has galaxy idx={galaxy_idx}'
+        self.allocated_pairs.add((p1, p2))
+        v1 = self.model.NewBoolVar(f'{p1}:{galaxy_idx}')
+        v2 = self.model.NewBoolVar(f'{p2}:{galaxy_idx}')
+        self.model.Add(v1 == v2)
+        self.pos_to_galaxy[p1][galaxy_idx] = v1
+        self.pos_to_galaxy[p2][galaxy_idx] = v2
+
+    def add_all_constraints(self):
+        galaxy_vars = {}
+        for pos in get_all_pos(self.V, self.H):
+            pos_vars = list(self.pos_to_galaxy[pos].values())
+            self.model.AddExactlyOne(pos_vars)
+            for galaxy_idx, v in self.pos_to_galaxy[pos].items():
+                galaxy_vars.setdefault(galaxy_idx, {})[pos] = v
+        for galaxy_idx, pos_vars in galaxy_vars.items():
+            force_connected_component(self.model, pos_vars)
+
+
+    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, galaxy_vars in board.pos_to_galaxy.items():
+                for galaxy_idx, var in galaxy_vars.items():  # every pos is part of exactly one galaxy
+                    if solver.Value(var) == 1:
+                        assignment[pos] = galaxy_idx
+                        break
+            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]).zfill(2))
+            print('[')
+            for row in range(self.V):
+                print('   ', res[row].tolist(), end=',\n')
+            print(']')
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/galaxies/parse_map/parse_map.py

@@ -0,0 +1,216 @@
+"""
+    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. 
+    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.
+"""
+from pathlib import Path
+import numpy as np
+cv = None
+Image = None
+
+
+def extract_lines(bw):
+    # Create the images that will use to extract the horizontal and vertical lines
+    horizontal = np.copy(bw)
+    vertical = np.copy(bw)
+
+    cols = horizontal.shape[1]
+    horizontal_size = cols // 5
+    # Create structure element for extracting horizontal lines through morphology operations
+    horizontalStructure = cv.getStructuringElement(cv.MORPH_RECT, (horizontal_size, 1))
+    horizontal = cv.erode(horizontal, horizontalStructure)
+    horizontal = cv.dilate(horizontal, horizontalStructure)
+    horizontal_means = np.mean(horizontal, axis=1)
+    horizontal_cutoff = np.percentile(horizontal_means, 50)
+    # location where the horizontal lines are
+    horizontal_idx = np.where(horizontal_means > horizontal_cutoff)[0]
+    # print(f"horizontal_idx: {horizontal_idx}")
+    height = len(horizontal_idx)
+    # show_wait_destroy("horizontal", horizontal)  # this has the horizontal lines
+
+    rows = vertical.shape[0]
+    verticalsize = rows // 5
+    # Create structure element for extracting vertical lines through morphology operations
+    verticalStructure = cv.getStructuringElement(cv.MORPH_RECT, (1, verticalsize))
+    vertical = cv.erode(vertical, verticalStructure)
+    vertical = cv.dilate(vertical, verticalStructure)
+    vertical_means = np.mean(vertical, axis=0)
+    vertical_cutoff = np.percentile(vertical_means, 50)
+    vertical_idx = np.where(vertical_means > vertical_cutoff)[0]
+    # print(f"vertical_idx: {vertical_idx}")
+    width = len(vertical_idx)
+    # print(f"height: {height}, width: {width}")
+    # print(f"vertical_means: {vertical_means}")
+    # show_wait_destroy("vertical", vertical)  # this has the vertical lines
+
+    vertical = cv.bitwise_not(vertical)
+    # show_wait_destroy("vertical_bit", vertical)
+
+    return horizontal_idx, vertical_idx
+
+def show_wait_destroy(winname, img):
+    cv.imshow(winname, img)
+    cv.moveWindow(winname, 500, 0)
+    cv.waitKey(0)
+    cv.destroyWindow(winname)
+
+
+def mean_consecutives(arr: np.ndarray) -> np.ndarray:
+    """if a sequence of values is consecutive, then average the values"""
+    sums = []
+    counts = []
+    for i in range(len(arr)):
+        if i == 0:
+            sums.append(arr[i])
+            counts.append(1)
+        elif arr[i] == arr[i-1] + 1:
+            sums[-1] += arr[i]
+            counts[-1] += 1
+        else:
+            sums.append(arr[i])
+            counts.append(1)
+    return np.array(sums) // np.array(counts)
+
+def main(image):
+    global Image
+    global cv
+    import matplotlib.pyplot as plt
+    from PIL import Image as Image_module
+    import cv2 as cv_module
+    Image = Image_module
+    cv = cv_module
+
+
+    image_path = Path(image)
+    output_path = image_path.parent / (image_path.stem + '.json')
+    src = cv.imread(image, cv.IMREAD_COLOR)
+    assert src is not None, f'Error opening image: {image}'
+    if len(src.shape) != 2:
+        gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+    else:
+        gray = src
+    # now the image is in grayscale
+
+    # Apply adaptiveThreshold at the bitwise_not of gray, notice the ~ symbol
+    gray = cv.bitwise_not(gray)
+    bw = cv.adaptiveThreshold(gray.copy(), 255, cv.ADAPTIVE_THRESH_MEAN_C, \
+                                cv.THRESH_BINARY, 15, -2)
+    # show_wait_destroy("binary", bw)
+
+    # show_wait_destroy("src", src)
+    horizontal_idx, vertical_idx = extract_lines(bw)
+    horizontal_idx = mean_consecutives(horizontal_idx)
+    vertical_idx = mean_consecutives(vertical_idx)
+    height = len(horizontal_idx)
+    width = len(vertical_idx)
+    print(f"height: {height}, width: {width}")
+    print(f"horizontal_idx: {horizontal_idx}")
+    print(f"vertical_idx: {vertical_idx}")
+    arr = np.zeros((height - 1, width - 1), dtype=object)
+    output = {(dx, dy): arr.copy() for dx in [-1, 0, 1] for dy in [-1, 0, 1]}
+    hists = {(dx, dy): {} for dx in [-1, 0, 1] for dy in [-1, 0, 1]}
+    for j in range(height - 1):
+        for i in range(width - 1):
+            hidx1, hidx2 = horizontal_idx[j], horizontal_idx[j+1]
+            vidx1, vidx2 = vertical_idx[i], vertical_idx[i+1]
+            hidx1 = max(0, hidx1 - 2)
+            hidx2 = min(src.shape[0], hidx2 + 4)
+            vidx1 = max(0, vidx1 - 2)
+            vidx2 = min(src.shape[1], vidx2 + 4)
+            cell = src[hidx1:hidx2, vidx1:vidx2]
+            mid_x = cell.shape[1] // 2
+            mid_y = cell.shape[0] // 2
+            cell = cv.bitwise_not(cell)  # invert colors
+            for dx in [-1, 0, 1]:
+                for dy in [-1, 0, 1]:
+                    mx = mid_x + dx*mid_x
+                    my = mid_y + dy*mid_y
+                    mx0 = max(0, mx - 5)
+                    mx1 = min(cell.shape[1], mx + 5)
+                    my0 = max(0, my - 5)
+                    my1 = min(cell.shape[0], my + 5)
+                    cell_part = cell[my0:my1, mx0:mx1]
+                    hists[(dx, dy)][j, i] = np.sum(cell_part)
+            # top = cell[0:10, mid_y-5:mid_y+5]
+            # hists['top'][j, i] = np.sum(top)
+            # left = cell[mid_x-5:mid_x+5, 0:10]
+            # hists['left'][j, i] = np.sum(left)
+            # right = cell[mid_x-5:mid_x+5, -10:]
+            # hists['right'][j, i] = np.sum(right)
+            # bottom = cell[-10:, mid_y-5:mid_y+5]
+            # hists['bottom'][j, i] = np.sum(bottom)
+            # print(f"cell_{i}_{j}, ", [hists[(dx, dy)][j, i] for dx in [-1, 0, 1] for dy in [-1, 0, 1]])
+            # show_wait_destroy(f"cell_{i}_{j}", cell)
+
+    fig, axs = plt.subplots(3, 3)
+    target = 100
+    for dx in [-1, 0, 1]:
+        for dy in [-1, 0, 1]:
+            axs[dx+1, dy+1].hist(list(hists[(dx, dy)].values()), bins=100)
+            axs[dx+1, dy+1].set_title(f'{dx},{dy}')
+            # target = np.mean(list(hists[(dx, dy)].values()))
+            axs[dx+1, dy+1].axvline(target, color='red')
+    # plt.show()
+    # 1/0
+    for j in range(height - 1):
+        for i in range(width - 1):
+            sums_str = ''
+            out_str = ''
+            for dx in [-1, 0, 1]:
+                out_xpart = 'L' if dx == -1 else 'C' if dx == 0 else 'R'
+                for dy in [-1, 0, 1]:
+                    out_ypart = 'T' if dy == -1 else 'C' if dy == 0 else 'B'
+                    sums_str += str(hists[(dx, dy)][j, i]) + ' '
+                    if hists[(dx, dy)][j, i] < target:
+                        out_str += (out_xpart + out_ypart + ' ')
+                        output[(dx, dy)][j, i] = 1
+            print(f"cell_{j}_{i}", end=': ')
+            print(out_str)
+            print('   Sums: ', sums_str)
+
+    out = np.full_like(output[(0, 0)], '  ', dtype='U2')
+    counter = 0
+    for j in range(out.shape[0]):
+        for i in range(out.shape[1]):
+            for dx in [-1, 0, 1]:
+                for dy in [-1, 0, 1]:
+                    if output[(dx, dy)][j, i] == 1:
+                        # out[j, i] = dxdy_to_char[(dx, dy)]
+                        if dx == 0 and dy == 0:  # single point
+                            out[j, i] = str(counter).zfill(2)
+                            counter += 1
+                        elif dx == 0 and dy == 1:  # vertical
+                            out[j, i] = str(counter).zfill(2)
+                            out[j+1, i] = str(counter).zfill(2)
+                            counter += 1
+                        elif dx == 1 and dy == 0:  # horizontal
+                            out[j, i] = str(counter).zfill(2)
+                            out[j, i+1] = str(counter).zfill(2)
+                            counter += 1
+                        elif dx == 1 and dy == 1:  # 2 by 2
+                            out[j, i] = str(counter).zfill(2)
+                            out[j+1, i] = str(counter).zfill(2)
+                            out[j, i+1] = str(counter).zfill(2)
+                            out[j+1, i+1] = str(counter).zfill(2)
+                            counter += 1
+
+    # print(out)
+    with open(output_path, 'w') as f:
+        f.write('[\n')
+        for i, row in enumerate(out):
+            f.write('  ' + str(row.tolist()).replace("'", '"'))
+            if i != len(out) - 1:
+                f.write(',')
+            f.write('\n')
+        f.write(']')
+    print('output json: ', output_path)
+
+if __name__ == '__main__':
+    # to run this script and visualize the output, in the root run:
+    #  python .\src\puzzle_solver\puzzles\galaxies\parse_map\parse_map.py | python .\src\puzzle_solver\utils\visualizer.py --read_stdin
+    # main(Path(__file__).parent / 'input_output' / 'MTM6OSw4MjEsNDAx.png')
+    # 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' / 'eofodowmumgzzdkopzlpzkzaezrhefoezejvdtxrzmpgozzemxjdcigcqzrk.png')

puzzle_solver/puzzles/inertia/tsp.py

@@ -342,7 +342,9 @@ def solve_optimal_walk(
     for attempt in range(attempts):
         cluster_orders = shuffled_cluster_orders()
         for meta in meta_list:
+            # print('solve once')
             rep_idxs, _, _, _ = solve_once(cluster_orders, meta)
+            # print('solve once done')
             if rep_idxs is None:
                 continue
 
@@ -370,6 +372,7 @@ def solve_optimal_walk(
                         new_nodes, new_cost = reps_to_nodes_and_cost(new_reps)
                         if new_cost < cost:
                             reps = new_reps
+                            # print('2-opt improved cost from', cost, 'to', new_cost)
                             nodes_seq, cost = new_nodes, new_cost
                             improved = True
                             break
@@ -383,7 +386,7 @@ def solve_optimal_walk(
 
     if best_nodes is None:
         raise RuntimeError("No solution found.")
-
+    # print('final check')
     # Final checks and edge list
     edge_walk: List[Tuple[Pos, Pos]] = [(best_nodes[i], best_nodes[i+1]) for i in range(len(best_nodes)-1)]
     assert all(e in edges for e in edge_walk), "Output contains an edge not in the input directed edges."

puzzle_solver/puzzles/lits/lits.py

@@ -6,7 +6,7 @@ from typing import Optional, Union
 from ortools.sat.python import cp_model
 import numpy as np
 
-from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, get_pos, in_bounds, Direction, get_next_pos
+from puzzle_solver.core.utils import Pos, get_all_pos, get_char, set_char, get_pos, in_bounds, Direction, get_next_pos, polyominoes_with_shape_id
 from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
 
 
@@ -14,79 +14,6 @@ from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution,
 Shape = frozenset[Pos]
 
 
-def polyominoes(N):
-    """Generate all polyominoes of size N. Every rotation and reflection is considered different and included in the result.
-    Translation is not considered different and is removed from the result (otherwise the result would be infinite).
-
-    Below is the number of unique polyominoes of size N (not including rotations and reflections) and the lenth of the returned result (which includes all rotations and reflections)
-    N	name		#shapes		#results
-    1	monomino	1			1
-    2	domino		1			2
-    3	tromino		2			6
-    4	tetromino	5			19
-    5	pentomino	12			63
-    6	hexomino	35			216
-    7	heptomino	108			760
-    8	octomino	369			2,725
-    9	nonomino	1,285		9,910
-    10	decomino	4,655		36,446
-    11	undecomino	17,073		135,268
-    12	dodecomino	63,600		505,861
-    Source: https://en.wikipedia.org/wiki/Polyomino
-
-    Args:
-        N (int): The size of the polyominoes to generate.
-
-    Returns:
-        set[(frozenset[Pos], int)]: A set of all polyominoes of size N (rotated and reflected up to D4 symmetry) along with a unique ID for each polyomino.
-    """
-    assert N >= 1, 'N cannot be less than 1'
-    # need a frozenset because regular sets are not hashable
-    shapes: set[Shape] = {frozenset({Pos(0, 0)})}
-    for i in range(1, N):
-        next_shapes: set[Shape] = set()
-        for s in shapes:
-            # frontier: all 4-neighbors of existing cells not already in the shape
-            frontier = {get_next_pos(pos, direction)
-                        for pos in s
-                        for direction in Direction
-                        if get_next_pos(pos, direction) not in s}
-            for cell in frontier:
-                t = s | {cell}
-                # normalize by translation only: shift so min x,y is (0,0). This removes translational symmetries.
-                minx = min(pos.x for pos in t)
-                miny = min(pos.y for pos in t)
-                t0 = frozenset(Pos(x=pos.x - minx, y=pos.y - miny) for pos in t)
-                next_shapes.add(t0)
-        shapes = next_shapes
-    # shapes is now complete, now classify up to D4 symmetry (rotations/reflections), translations ignored
-    mats = (
-        ( 1, 0,  0, 1),  # regular
-        (-1, 0,  0, 1),  # reflect about x
-        ( 1, 0,  0,-1),  # reflect about y
-        (-1, 0,  0,-1),  # reflect about x and y
-        # trnaspose then all 4 above
-        ( 0, 1,  1, 0), ( 0, 1, -1, 0), ( 0,-1,  1, 0), ( 0,-1, -1, 0),
-    )
-    # compute canonical representative for each shape (lexicographically smallest normalized transform)
-    shape_to_canon: dict[Shape, tuple[Pos, ...]] = {}
-    for s in shapes:
-        reps: list[tuple[Pos, ...]] = []
-        for a, b, c, d in mats:
-            pts = {Pos(x=a*p.x + b*p.y, y=c*p.x + d*p.y) for p in s}
-            minx = min(p.x for p in pts)
-            miny = min(p.y for p in pts)
-            rep = tuple(sorted(Pos(x=p.x - minx, y=p.y - miny) for p in pts))
-            reps.append(rep)
-        canon = min(reps)
-        shape_to_canon[s] = canon
-
-    canon_set = set(shape_to_canon.values())
-    canon_to_id = {canon: i for i, canon in enumerate(sorted(canon_set))}
-    result = {(s, canon_to_id[shape_to_canon[s]]) for s in shapes}
-    return result
-
-
 @dataclass(frozen=True)
 class SingleSolution:
     assignment: dict[Pos, Union[str, int]]
@@ -117,7 +44,7 @@ class Board:
         assert all((str(c.item()).isdecimal() for c in np.nditer(board))), 'board must contain only digits'
         self.board = board
         self.polyomino_degrees = polyomino_degrees
-        self.polyominoes = polyominoes(self.polyomino_degrees)
+        self.polyominoes = polyominoes_with_shape_id(self.polyomino_degrees)
 
         self.block_numbers = set([int(c.item()) for c in np.nditer(board)])
         self.blocks = {i: set() for i in self.block_numbers}
@@ -233,23 +160,3 @@ class Board:
             print('[\n' + '\n'.join(['  ' + str(res[row].tolist()) + ',' for row in range(self.V)]) + '\n]')
             pass
         return generic_solve_all(self, board_to_solution, callback=callback if verbose_callback else None, verbose=verbose, max_solutions=max_solutions)
-
-    def solve_then_constrain(self, verbose: bool = True):
-        tic = time.time()
-        all_solutions = []
-        while True:
-            solutions = self.solve_and_print(verbose=False, verbose_callback=verbose, max_solutions=1)
-            if len(solutions) == 0:
-                break
-            all_solutions.extend(solutions)
-            assignment = solutions[0].assignment
-            # constrain the board to not return the same solution again
-            lits = [self.model_vars[p].Not() if assignment[p] == 1 else self.model_vars[p] for p in assignment.keys()]
-            self.model.AddBoolOr(lits)
-            self.model.ClearHints()
-            for k, v in solutions[0].all_other_variables['fc'].items():
-                self.model.AddHint(self.fc[k], v)
-        print(f'Solutions found: {len(all_solutions)}')
-        toc = time.time()
-        print(f'Time taken: {toc - tic:.2f} seconds')
-        return all_solutions

puzzle_solver/puzzles/pearl/pearl.py

@@ -5,7 +5,7 @@ from ortools.sat.python import cp_model
 from ortools.sat.python.cp_model import LinearExpr as lxp
 
 from puzzle_solver.core.utils import Pos, get_all_pos, set_char, in_bounds, Direction, get_next_pos, get_char, get_opposite_direction
-from puzzle_solver.core.utils_ortools import and_constraint, or_constraint, generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_ortools import and_constraint, generic_solve_all, SingleSolution, force_connected_component
 
 
 class Board:
@@ -18,7 +18,6 @@ class Board:
         self.model = cp_model.CpModel()
         self.cell_active: dict[Pos, cp_model.IntVar] = {}
         self.cell_direction: dict[tuple[Pos, Direction], cp_model.IntVar] = {}
-        self.reach_layers: list[dict[Pos, cp_model.IntVar]] = []  # R_t[p] booleans, t = 0..T
 
         self.create_vars()
         self.add_all_constraints()
@@ -28,18 +27,11 @@ class Board:
             self.cell_active[pos] = self.model.NewBoolVar(f"a[{pos}]")
             for direction in Direction:
                 self.cell_direction[(pos, direction)] = self.model.NewBoolVar(f"b[{pos}]->({direction.name})")
-        # Percolation layers R_t (monotone flood fill)
-        T = self.V * self.H  # large enough to cover whole board
-        for t in range(T + 1):
-            Rt: dict[Pos, cp_model.IntVar] = {}
-            for pos in get_all_pos(self.V, self.H):
-                Rt[pos] = self.model.NewBoolVar(f"R[{t}][{pos}]")
-            self.reach_layers.append(Rt)
 
     def add_all_constraints(self):
         self.force_direction_constraints()
         self.force_wb_constraints()
-        self.connectivity_percolation()
+        self.force_connected_component()
 
     def force_wb_constraints(self):
         for pos in get_all_pos(self.V, self.H):
@@ -91,40 +83,16 @@ class Board:
                 else:
                     self.model.Add(self.cell_direction[(pos, direction)] == 0)
 
-    def connectivity_percolation(self):
-        """
-        Layered percolation:
-            - root is exactly the first cell
-            - R_t is monotone nondecreasing in t (R_t+1 >= R_t)
-            - A cell can 'turn on' at layer t+1 iff has a neighbor on at layer t and the neighbor is pointing to it (or is root)
-            - Final layer is all connected
-        """
-        # Seed: R0 = root
-        for i, pos in enumerate(get_all_pos(self.V, self.H)):
-            if i == 0:
-                self.model.Add(self.reach_layers[0][pos] == 1)  # first cell is root
-            else:
-                self.model.Add(self.reach_layers[0][pos] == 0)
-
-        for t in range(1, len(self.reach_layers)):
-            Rt_prev = self.reach_layers[t - 1]
-            Rt = self.reach_layers[t]
-            for p in get_all_pos(self.V, self.H):
-                # Rt[p] = Rt_prev[p] | (white[p] & Rt_prev[neighbour #1]) | (white[p] & Rt_prev[neighbour #2]) | ...
-                # Create helper (white[p] & Rt_prev[neighbour #X]) for each neighbor q
-                neigh_helpers: list[cp_model.IntVar] = []
-                for direction in Direction:
-                    q = get_next_pos(p, direction)
-                    if not in_bounds(q, self.V, self.H):
-                        continue
-                    a = self.model.NewBoolVar(f"A[{t}][{p}]<-({q})")
-                    and_constraint(self.model, target=a, cs=[Rt_prev[q], self.cell_direction[(q, get_opposite_direction(direction))]])
-                    neigh_helpers.append(a)
-                or_constraint(self.model, target=Rt[p], cs=[Rt_prev[p]] + neigh_helpers)
-
-        # every pearl must be reached by the final layer
-        for p in get_all_pos(self.V, self.H):
-            self.model.Add(self.reach_layers[-1][p] == 1).OnlyEnforceIf(self.cell_active[p])
+    def force_connected_component(self):
+        def is_neighbor(pd1: tuple[Pos, Direction], pd2: tuple[Pos, Direction]) -> bool:
+            p1, d1 = pd1
+            p2, d2 = pd2
+            if p1 == p2 and d1 != d2:  # same position, different direction, is neighbor
+                return True
+            if get_next_pos(p1, d1) == p2 and d2 == get_opposite_direction(d1):
+                return True
+            return False
+        force_connected_component(self.model, self.cell_direction, is_neighbor=is_neighbor)
 
 
     def solve_and_print(self, verbose: bool = True):

puzzle_solver/puzzles/range/range.py

@@ -2,7 +2,7 @@ import numpy as np
 from ortools.sat.python import cp_model
 
 from puzzle_solver.core.utils import Pos, get_all_pos, set_char, get_neighbors4, in_bounds, Direction, get_next_pos, get_char
-from puzzle_solver.core.utils_ortools import and_constraint, or_constraint, generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_ortools import and_constraint, or_constraint, generic_solve_all, SingleSolution, force_connected_component
 
 
 def get_ray(pos: Pos, V: int, H: int, direction: Direction) -> list[Pos]:
@@ -27,9 +27,6 @@ class Board:
         # Core vars
         self.b: dict[Pos, cp_model.IntVar] = {}  # 1=black, 0=white
         self.w: dict[Pos, cp_model.IntVar] = {}  # 1=white, 0=black
-        # Connectivity helpers
-        self.root: dict[Pos, cp_model.IntVar] = {}       # exactly one root; root <= w
-        self.reach_layers: list[dict[Pos, cp_model.IntVar]] = []  # R_t[p] booleans, t = 0..T
 
         self.create_vars()
         self.add_all_constraints()
@@ -41,18 +38,6 @@ class Board:
             self.w[pos] = self.model.NewBoolVar(f"w[{pos}]")
             self.model.AddExactlyOne([self.b[pos], self.w[pos]])
 
-        # Root
-        for pos in get_all_pos(self.V, self.H):
-            self.root[pos] = self.model.NewBoolVar(f"root[{pos}]")
-
-        # Percolation layers R_t (monotone flood fill)
-        T = self.V * self.H  # large enough to cover whole board
-        for t in range(T + 1):
-            Rt: dict[Pos, cp_model.IntVar] = {}
-            for pos in get_all_pos(self.V, self.H):
-                Rt[pos] = self.model.NewBoolVar(f"R[{t}][{pos}]")
-            self.reach_layers.append(Rt)
-
     def add_all_constraints(self):
         self.no_adjacent_blacks()
         self.white_connectivity_percolation()
@@ -69,41 +54,7 @@ class Board:
 
 
     def white_connectivity_percolation(self):
-        """
-        Layered percolation:
-          - root is exactly the first white cell
-          - R_t is monotone nondecreasing in t (R_t+1 >= R_t)
-          - A cell can 'turn on' at layer t+1 iff it's white and has a neighbor on at layer t (or is root)
-          - Final layer is equal to the white mask: R_T[p] == w[p]  => all whites are connected to the unique root
-        """
-        # to find unique solutions easily, we make only 1 possible root allowed; root is exactly the first white cell
-        prev_cells_black: list[cp_model.IntVar] = []
-        for pos in get_all_pos(self.V, self.H):
-            and_constraint(self.model, target=self.root[pos], cs=[self.w[pos]] + prev_cells_black)
-            prev_cells_black.append(self.b[pos])
-
-        # Seed: R0 = root
-        for pos in get_all_pos(self.V, self.H):
-            self.model.Add(self.reach_layers[0][pos] == self.root[pos])
-
-        T = len(self.reach_layers)
-        for t in range(1, T):
-            Rt_prev = self.reach_layers[t - 1]
-            Rt = self.reach_layers[t]
-            for p in get_all_pos(self.V, self.H):
-                # Rt[p] = Rt_prev[p] | (white[p] & Rt_prev[neighbour #1]) | (white[p] & Rt_prev[neighbour #2]) | ...
-                # Create helper (white[p] & Rt_prev[neighbour #X]) for each neighbor q
-                neigh_helpers: list[cp_model.IntVar] = []
-                for q in get_neighbors4(p, self.V, self.H):
-                    a = self.model.NewBoolVar(f"A[{t}][{p}]<-({q})")
-                    and_constraint(self.model, target=a, cs=[self.w[p], Rt_prev[q]])
-                    neigh_helpers.append(a)
-                or_constraint(self.model, target=Rt[p], cs=[Rt_prev[p]] + neigh_helpers)
-
-        # All whites must be reached by the final layer
-        RT = self.reach_layers[T - 1]
-        for p in get_all_pos(self.V, self.H):
-            self.model.Add(RT[p] == self.w[p])
+        force_connected_component(self.model, self.w)
 
     def range_clues(self):
         # For each numbered cell c with value k: