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

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:

puzzle_solver/puzzles/singles/singles.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, get_char, set_char, get_neighbors4, get_all_pos_to_idx_dict, get_row_pos, get_col_pos
-from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, and_constraint, or_constraint
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
 
 
 class Board:
@@ -17,34 +17,26 @@ class Board:
 
         self.model = cp_model.CpModel()
         self.B = {} # black squares
+        self.W = {} # white squares
         self.Num = {} # value of squares (Num = N + idx if black, else board[pos])
-        # 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()
 
     def create_vars(self):
         for pos in get_all_pos(self.V, self.H):
-            self.B[pos] = self.model.NewBoolVar(f'{pos}')
+            self.B[pos] = self.model.NewBoolVar(f'B:{pos}')
+            self.W[pos] = self.model.NewBoolVar(f'W:{pos}')
+            # either black or white
+            self.model.AddExactlyOne([self.B[pos], self.W[pos]])
             self.Num[pos] = self.model.NewIntVar(0, 2*self.N, f'{pos}')
             self.model.Add(self.Num[pos] == self.N + self.idx_of[pos]).OnlyEnforceIf(self.B[pos])
             self.model.Add(self.Num[pos] == int(get_char(self.board, pos))).OnlyEnforceIf(self.B[pos].Not())
-        # 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)
-        for t in range(self.N + 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.no_number_appears_twice()
-        self.white_connectivity_percolation()
+        self.force_connected_component()
 
     def no_adjacent_blacks(self):
         # no two black squares are adjacent 
@@ -61,42 +53,9 @@ class Board:
             var_list = [self.Num[pos] for pos in get_col_pos(col, self.V)]
             self.model.AddAllDifferent(var_list)
 
-    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.B[pos].Not()] + 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.B[p].Not(), Rt_prev[q]])
-                    neigh_helpers.append(a)
-                or_constraint(self.model, target=Rt[p], cs=[Rt_prev[p]] + neigh_helpers)
+    def force_connected_component(self):
+        force_connected_component(self.model, self.W)
 
-        # 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.B[p].Not())
 
 
     def solve_and_print(self, verbose: bool = True):

puzzle_solver/puzzles/tracks/tracks.py

@@ -3,7 +3,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_char, Direction, in_bounds, get_next_pos, get_row_pos, get_col_pos, get_opposite_direction
-from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, and_constraint, or_constraint
+from puzzle_solver.core.utils_ortools import force_connected_component, generic_solve_all, SingleSolution
 
 
 class Board:
@@ -25,7 +25,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()
@@ -35,19 +34,13 @@ class Board:
             self.cell_active[pos] = self.model.NewBoolVar(f'{pos}')
             for direction in Direction:
                 self.cell_direction[(pos, direction)] = self.model.NewBoolVar(f'{pos}:{direction}')
-        # Percolation layers R_t (monotone flood fill)
-        for t in range(self.V * self.H + 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_hints()
         self.force_sides()
         self.force_0_or_2_active()
         self.force_direction_constraints()
-        self.force_percolation()
+        self.force_connected_component()
 
 
     def force_hints(self):
@@ -108,38 +101,16 @@ class Board:
         for pos in get_row_pos(0, self.H):
             self.model.Add(self.cell_direction[(pos, Direction.UP)] == 0)
 
-    def force_percolation(self):
-        """
-        Layered percolation:
-          - root is exactly the first cell in the first column
-          - R_t is monotone nondecreasing in t (R_t+1 >= R_t)
-          - A cell can 'turn on' at layer t+1 iff it's active and has a neighbor on AND pointing to it at layer t
-          - Final layer is equal to the active mask: R_T[p] == active[p]  => all active cells are connected to the unique root
-        """
-        # only the start position is a root
-        self.model.Add(self.reach_layers[0][self.first_col_start_pos] == 1)
-        for pos in get_all_pos(self.V, self.H):
-            if pos != self.first_col_start_pos:
-                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] | (active[p] & Rt_prev[neighbour #1]) | (active[p] & Rt_prev[neighbour #2]) | ...
-                # Create helper (active[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=[self.cell_active[p], 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 avtive track must be reachible -> single connected component
-        for pos in get_all_pos(self.V, self.H):
-            self.model.Add(self.reach_layers[-1][pos] == 1).OnlyEnforceIf(self.cell_active[pos])
+    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:  # 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)