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

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)