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

puzzle_solver/puzzles/lits/lits.py

@@ -0,0 +1,162 @@
+import json
+import time
+from dataclasses import dataclass
+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, polyominoes_with_shape_id
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution, force_connected_component
+
+
+# a shape on the 2d board is just a set of positions
+Shape = frozenset[Pos]
+
+
+@dataclass(frozen=True)
+class SingleSolution:
+    assignment: dict[Pos, Union[str, int]]
+    all_other_variables: dict
+
+    def get_hashable_solution(self) -> str:
+        result = []
+        for pos, v in self.assignment.items():
+            result.append((pos.x, pos.y, v))
+        return json.dumps(result, sort_keys=True)
+
+
+
+@dataclass
+class ShapeOnBoard:
+    is_active: cp_model.IntVar
+    shape: Shape
+    shape_id: int
+    body: set[Pos]
+    disallow_same_shape: set[Pos]
+
+
+class Board:
+    def __init__(self, board: np.array, polyomino_degrees: int = 4):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        self.V = board.shape[0]
+        self.H = board.shape[1]
+        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_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}
+        for cell in get_all_pos(self.V, self.H):
+            self.blocks[int(get_char(self.board, cell))].add(cell)
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+        self.connected_components: dict[Pos, cp_model.IntVar] = {}
+        self.shapes_on_board: list[ShapeOnBoard] = []  # will contain every possible shape on the board based on polyomino degrees
+
+        self.create_vars()
+        self.init_shapes_on_board()
+        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}')
+        # print('base vars:', len(self.model_vars))
+
+    def init_shapes_on_board(self):
+        for idx, (shape, shape_id) in enumerate(self.polyominoes):
+            for translate in get_all_pos(self.V, self.H):  # body of shape is translated to be at pos
+                body = {get_pos(x=p.x + translate.x, y=p.y + translate.y) for p in shape}
+                if any(not in_bounds(p, self.V, self.H) for p in body):
+                    continue
+                # shape must be fully contained in one block
+                if len(set(get_char(self.board, p) for p in body)) > 1:
+                    continue
+                # 2 tetrominoes of matching types cannot touch each other horizontally or vertically. Rotations and reflections count as matching.
+                disallow_same_shape = set(get_next_pos(p, direction) for p in body for direction in Direction)
+                disallow_same_shape -= body
+                self.shapes_on_board.append(ShapeOnBoard(
+                    is_active=self.model.NewBoolVar(f'{idx}:{translate}:is_active'),
+                    shape=shape,
+                    shape_id=shape_id,
+                    body=body,
+                    disallow_same_shape=disallow_same_shape,
+                ))
+        # print('shapes on board:', len(self.shapes_on_board))
+
+    def add_all_constraints(self):
+        # RULES:
+        # 1- You have to place one tetromino in each region in such a way that:
+        # 2- 2 tetrominoes of matching types cannot touch each other horizontally or vertically. Rotations and reflections count as matching.
+        # 3- The shaded cells should form a single connected area.
+        # 4- 2x2 shaded areas are not allowed
+
+        # each cell must be part of a shape, every shape must be fully on the board. Core constraint, otherwise shapes on the board make no sense.
+        self.only_allow_shapes_on_board()
+
+        self.force_one_shape_per_block()  # Rule #1
+        self.disallow_same_shape_touching()  # Rule #2
+        self.fc = force_connected_component(self.model, self.model_vars)  # Rule #3
+        # print('force connected vars:', len(fc))
+        shape_2_by_2 = frozenset({Pos(0, 0), Pos(0, 1), Pos(1, 0), Pos(1, 1)})
+        self.disallow_shape(shape_2_by_2)  # Rule #4
+
+
+    def only_allow_shapes_on_board(self):
+        for shape_on_board in self.shapes_on_board:
+            # if shape is active then all its body cells must be active
+            self.model.Add(sum(self.model_vars[p] for p in shape_on_board.body) == len(shape_on_board.body)).OnlyEnforceIf(shape_on_board.is_active)
+        # each cell must be part of a shape
+        for p in get_all_pos(self.V, self.H):
+            shapes_on_p = [s for s in self.shapes_on_board if p in s.body]
+            self.model.Add(sum(s.is_active for s in shapes_on_p) == 1).OnlyEnforceIf(self.model_vars[p])
+
+    def force_one_shape_per_block(self):
+        # You have to place exactly one tetromino in each region
+        for block_i in self.block_numbers:
+            shapes_on_block = [s for s in self.shapes_on_board if s.body & self.blocks[block_i]]
+            assert all(s.body.issubset(self.blocks[block_i]) for s in shapes_on_block), 'expected all shapes on block to be fully contained in the block'
+            # print(f'shapes on block {block_i} has {len(shapes_on_block)} shapes')
+            self.model.Add(sum(s.is_active for s in shapes_on_block) == 1)
+
+    def disallow_same_shape_touching(self):
+        # if shape is active then it must not touch any other shape of the same type
+        for shape_on_board in self.shapes_on_board:
+            similar_shapes = [s for s in self.shapes_on_board if s.shape_id == shape_on_board.shape_id]
+            for s in similar_shapes:
+                if shape_on_board.disallow_same_shape & s.body:  # this shape disallows having s be on the board
+                    self.model.Add(s.is_active == 0).OnlyEnforceIf(shape_on_board.is_active)
+
+    def disallow_shape(self, shape_to_disallow: Shape):
+        # for every position in the board, force sum of body < len(body)
+        for translate in get_all_pos(self.V, self.H):
+            cur_body = {get_pos(x=p.x + translate.x, y=p.y + translate.y) for p in shape_to_disallow}
+            if any(not in_bounds(p, self.V, self.H) for p in cur_body):
+                continue
+            self.model.Add(sum(self.model_vars[p] for p in cur_body) < len(cur_body))
+
+
+
+
+    def solve_and_print(self, verbose: bool = True, max_solutions: Optional[int] = None, verbose_callback: Optional[bool] = None):
+        if verbose_callback is None:
+            verbose_callback = verbose
+        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)
+            all_other_variables = {
+                'fc': {k: solver.Value(v) for k, v in board.fc.items()}
+            }
+            return SingleSolution(assignment=assignment, all_other_variables=all_other_variables)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.V, self.H), ' ', dtype=str)
+            for pos, val in single_res.assignment.items():
+                c = 'X' if val == 1 else ' '
+                set_char(res, pos, c)
+            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)

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):