multi-puzzle-solver 1.1.8__py3-none-any.whl

puzzle_solver/puzzles/lits/lits.py

@@ -0,0 +1,138 @@
+from dataclasses import dataclass
+from typing import Optional
+
+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
+from puzzle_solver.core.utils_visualizer import combined_function, id_board_to_wall_fn
+
+
+# a shape on the 2d board is just a set of positions
+Shape = frozenset[Pos]
+
+
+@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}')
+
+    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,
+                ))
+
+    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
+        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'
+            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)
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            res = np.full((self.V, self.H), ' ', dtype=object)
+            for pos, val in single_res.assignment.items():
+                set_char(res, pos, '▒▒▒' if val == 1 else ' ')
+            print(combined_function(self.V, self.H,
+                cell_flags=id_board_to_wall_fn(self.board),
+                center_char=lambda r, c: res[r][c]))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose_callback else None, verbose=verbose, max_solutions=max_solutions)

puzzle_solver/puzzles/magnets/magnets.py

@@ -0,0 +1,96 @@
+from dataclasses import dataclass
+
+import numpy as np
+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, get_char, get_pos, get_next_pos, Direction, get_row_pos, get_col_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function, id_board_to_wall_fn
+
+
+@dataclass(frozen=True)
+class MagnetOnBoard:
+    uid: str
+    is_active: cp_model.IntVar
+    str_rep: tuple[tuple[Pos, str], ...]
+
+
+class Board:
+    def __init__(self, board: np.array, top_pos: np.array, top_neg: np.array, side_pos: np.array, side_neg: np.array):
+        assert (len(side_pos), len(top_pos)) == board.shape, 'side_pos and top_pos must be the same shape as the board'
+        assert (len(side_neg), len(top_neg)) == board.shape, 'side_neg and top_neg must be the same shape as the board'
+        self.board = board
+        self.top_pos, self.top_neg = top_pos, top_neg
+        self.side_pos, self.side_neg = side_pos, side_neg
+
+        self.V, self.H = board.shape
+        self.model = cp_model.CpModel()
+        self.magnets: set[MagnetOnBoard] = set()
+        self.pos_vars: dict[tuple[Pos, str], MagnetOnBoard] = {}
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for col_i in range(self.H):  # vertical magnets
+            row_i = 0
+            while row_i < self.V - 1:
+                pos_1 = get_pos(x=col_i, y=row_i)
+                if get_char(self.board, pos_1) != 'V':
+                    row_i += 1
+                    continue
+                pos_2 = get_next_pos(pos_1, Direction.DOWN)
+                self.add_magnet(pos_1, pos_2)
+                row_i += 2  # skip next cell since it's already covered by this magnet
+        for row_i in range(self.V):  # horizontal magnets
+            col_i = 0
+            while col_i < self.H - 1:
+                pos_1 = get_pos(x=col_i, y=row_i)
+                if get_char(self.board, pos_1) != 'H':
+                    col_i += 1
+                    continue
+                pos_2 = get_next_pos(pos_1, Direction.RIGHT)
+                self.add_magnet(pos_1, pos_2)
+                col_i += 2  # skip next cell since it's already covered by this magnet
+
+    def add_magnet(self, pos1: Pos, pos2: Pos):
+        for v1, v2 in [('+', '-'), ('-', '+'), ('x', 'x')]:
+            magnet = MagnetOnBoard(uid=f'{pos1}:{pos2}:{v1}{v2}', is_active=self.model.NewBoolVar(f'{pos1}:{pos2}:{v1}{v2}'), str_rep=((pos1, v1), (pos2, v2)))
+            self.pos_vars[(pos1, v1)] = magnet
+            self.pos_vars[(pos2, v2)] = magnet
+            self.magnets.add(magnet)
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):  # each position has exactly one magnet
+            self.model.AddExactlyOne([self.pos_vars[(pos, v)].is_active for v in ['+', '-', 'x']])
+        for pos in get_all_pos(self.V, self.H):  # orthogonal positions can't both be + or -
+            for v in ['+', '-']:
+                magnet = self.pos_vars.get((pos, v))
+                if magnet is None:
+                    continue
+                for direction in [Direction.DOWN, Direction.RIGHT]:
+                    next_magnet = self.pos_vars.get((get_next_pos(pos, direction), v))
+                    if next_magnet is None:
+                        continue
+                    self.model.AddBoolOr([magnet.is_active.Not(), next_magnet.is_active.Not()])  # ~magnet ∨ ~next_magnet
+        for row in range(self.V):  # force side counts
+            if self.side_pos[row] != -1:
+                self.model.Add(lxp.Sum([self.pos_vars[(pos, '+')].is_active for pos in get_row_pos(row, self.H) if (pos, '+') in self.pos_vars]) == self.side_pos[row])
+            if self.side_neg[row] != -1:
+                self.model.Add(lxp.Sum([self.pos_vars[(pos, '-')].is_active for pos in get_row_pos(row, self.H) if (pos, '-') in self.pos_vars]) == self.side_neg[row])
+        for col in range(self.H):  # force top counts
+            if self.top_pos[col] != -1:
+                self.model.Add(lxp.Sum([self.pos_vars[(pos, '+')].is_active for pos in get_col_pos(col, self.V) if (pos, '+') in self.pos_vars]) == self.top_pos[col])
+            if self.top_neg[col] != -1:
+                self.model.Add(lxp.Sum([self.pos_vars[(pos, '-')].is_active for pos in get_col_pos(col, self.V) if (pos, '-') in self.pos_vars]) == self.top_neg[col])
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: (magnet.uid, s) for magnet in board.magnets for (pos, s) in magnet.str_rep if solver.BooleanValue(magnet.is_active)})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(V=self.V, H=self.H,
+                center_char=lambda r, c: single_res.assignment[get_pos(x=c, y=r)][1],
+                cell_flags=id_board_to_wall_fn(np.array([[single_res.assignment.get(get_pos(x=c, y=r), (None, ' '))[0] for c in range(self.H)] for r in range(self.V)])),
+            ))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/map/map.py

@@ -0,0 +1,56 @@
+import json
+from dataclasses import dataclass
+
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils_ortools import generic_solve_all
+
+
+@dataclass(frozen=True)
+class SingleSolution:
+    assignment: dict[int, int]
+
+    def get_hashable_solution(self) -> str:
+        return json.dumps(self.assignment, sort_keys=True)
+
+
+class Board:
+    def __init__(self, regions: dict[int, set[int]], fixed_colors: dict[int, str]):
+        self.regions = regions
+        self.fixed_colors = fixed_colors
+        self.N = len(regions)
+        assert max(max(region) for region in regions.values() if region) == self.N - 1, 'region indices must be 0..N-1'
+        assert set(fixed_colors.keys()).issubset(set(range(self.N))), 'fixed colors must be a subset of region indices'
+        assert all(color in ['Y', 'R', 'G', 'B'] for color in fixed_colors.values()), 'fixed colors must be Y, R, G, or B'
+        self.color_to_int = {c: i for i, c in enumerate(set(fixed_colors.values()))}
+        self.int_to_color = {i: c for c, i in self.color_to_int.items()}
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[int, cp_model.IntVar] = {}
+
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for region_idx in self.regions.keys():
+            self.model_vars[region_idx] = self.model.NewIntVar(0, 3, f'{region_idx}')
+
+    def add_all_constraints(self):
+        # fix given colors
+        for region_idx, color in self.fixed_colors.items():
+            self.model.Add(self.model_vars[region_idx] == self.color_to_int[color])
+        # neighboring regions must have different colors
+        for region_idx, region_connections in self.regions.items():
+            for other_region_idx in region_connections:  # neighboring regions must have different colors
+                self.model.Add(self.model_vars[region_idx] != self.model_vars[other_region_idx])
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[int, int] = {}
+            for region_idx, var in board.model_vars.items():
+                assignment[region_idx] = solver.Value(var)
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print({k: self.int_to_color[v] for k, v in single_res.assignment.items()})
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/mathema_grids/mathema_grids.py

@@ -0,0 +1,119 @@
+from dataclasses import dataclass
+import numpy as np
+from ortools.sat.python import cp_model
+from ortools.util.python import sorted_interval_list
+
+from puzzle_solver.core.utils import Direction, Pos, get_char, get_next_pos, get_row_pos, get_col_pos, in_bounds, set_char
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+@dataclass
+class var_with_bounds:
+    var: cp_model.IntVar
+    min_value: int
+    max_value: int
+
+
+def _div_bounds(a_min: int, a_max: int, b_min: int, b_max: int) -> tuple[int, int]:
+    assert not (b_min == 0 and b_max == 0), "Denominator interval cannot be [0, 0]."
+    denoms = [b_min, b_max]
+    if 0 in denoms:
+        denoms.remove(0)
+    if b_min <= -1:
+        denoms += [-1]
+    if b_max >= 1:
+        denoms += [1]
+    candidates = [a_min // d for d in denoms] + [a_max // d for d in denoms]
+    return min(candidates), max(candidates)
+
+
+class Board:
+    def __init__(self, board: np.array, digits: list[int]):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        self.board = board
+        self.V, self.H = board.shape
+        assert self.V >= 3 and self.V % 2 == 1, f'board must have at least 3 rows and an odd number of rows. Got {self.V} rows.'
+        assert self.H >= 3 and self.H % 2 == 1, f'board must have at least 3 columns and an odd number of columns. Got {self.H} columns.'
+        self.digits = digits
+        self.domain_values = sorted_interval_list.Domain.FromValues(self.digits)
+        self.domain_values_no_zero = sorted_interval_list.Domain.FromValues([d for d in self.digits if d != 0])
+
+        self.model = cp_model.CpModel()
+        self.model_vars: dict[Pos, cp_model.IntVar] = {}
+        self.create_vars()
+        assert len(self.model_vars) == len(self.digits), f'len(model_vars) != len(digits), {len(self.model_vars)} != {len(self.digits)}'
+        self.model.AddAllDifferent(list(self.model_vars.values()))
+
+    def create_vars(self):
+        for row in range(0, self.V-2, 2):
+            line_pos = [pos for pos in get_row_pos(row, self.H)]
+            self.parse_line(line_pos)
+        for col in range(0, self.H-2, 2):
+            line_pos = [pos for pos in get_col_pos(col, self.V)]
+            self.parse_line(line_pos)
+
+    def parse_line(self, line_pos: list[Pos]) -> list[int]:
+        last_num = get_char(self.board, line_pos[-1])
+        equal_sign = get_char(self.board, line_pos[-2])
+        assert equal_sign == '=', f'last element of line must be =, got {equal_sign}'
+        line_pos = line_pos[:-2]
+        operators = [get_char(self.board, pos) for pos in line_pos[1::2]]
+        assert all(c.strip() in ['+', '-', '*', '/'] for c in operators), f'even indices of line must be operators, got {operators}'
+        digits_pos = line_pos[::2]
+        running_var = self.get_var(digits_pos[0], fixed=get_char(self.board, digits_pos[0]))
+        for pos, operator in zip(digits_pos[1:], operators):
+            running_var = self.apply_operator(operator, running_var, self.get_var(pos, fixed=get_char(self.board, pos)))
+        self.model.Add(running_var.var == int(last_num))
+        return running_var
+
+    def get_var(self, pos: Pos, fixed: str) -> var_with_bounds:
+        if pos not in self.model_vars:
+            domain = self.domain_values_no_zero if self.might_be_denominator(pos) else self.domain_values
+            self.model_vars[pos] = self.model.NewIntVarFromDomain(domain, f'{pos}')
+        if fixed.strip():
+            self.model.Add(self.model_vars[pos] == int(fixed))
+        return var_with_bounds(var=self.model_vars[pos], min_value=min(self.digits), max_value=max(self.digits))
+
+    def might_be_denominator(self, pos: Pos) -> bool:
+        "Important since if the variable might be a denominator and the domain includes 0 then ortools immediately sets the model as INVALID"
+        above_pos = get_next_pos(pos, Direction.UP)
+        left_pos = get_next_pos(pos, Direction.LEFT)
+        above_operator = get_char(self.board, above_pos) if in_bounds(above_pos, self.V, self.H) else None
+        left_operator = get_char(self.board, left_pos) if in_bounds(left_pos, self.V, self.H) else None
+        return above_operator == '/' or left_operator == '/'
+
+    def apply_operator(self, operator: str, a: var_with_bounds, b: var_with_bounds) -> var_with_bounds:
+        assert operator in ['+', '-', '*', '/'], f'invalid operator: {operator}'
+        if operator == "+":
+            lo = a.min_value + b.min_value
+            hi = a.max_value + b.max_value
+            res = self.model.NewIntVar(lo, hi, "sum")
+            self.model.Add(res == a.var + b.var)
+        elif operator == "-":
+            lo = a.min_value - b.max_value
+            hi = a.max_value - b.min_value
+            res = self.model.NewIntVar(lo, hi, "diff")
+            self.model.Add(res == a.var - b.var)
+        elif operator == "*":
+            cands = [a.min_value*b.min_value, a.min_value*b.max_value, a.max_value*b.min_value, a.max_value*b.max_value]
+            lo, hi = min(cands), max(cands)
+            res = self.model.NewIntVar(lo, hi, "prod")
+            self.model.AddMultiplicationEquality(res, [a.var, b.var])
+        elif operator == "/":
+            self.model.Add(b.var != 0)
+            lo, hi = _div_bounds(a.min_value, a.max_value, b.min_value, b.max_value)
+            res = self.model.NewIntVar(lo, hi, "quot")
+            self.model.AddDivisionEquality(res, a.var, b.var)
+        return var_with_bounds(res, lo, hi)
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: solver.Value(var) for pos, var in board.model_vars.items()})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            output_board = self.board.copy()
+            for pos, var in single_res.assignment.items():
+                set_char(output_board, pos, str(var))
+            print(combined_function(self.V, self.H, center_char=lambda r, c: str(output_board[r, c])))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/mathrax/mathrax.py

@@ -0,0 +1,93 @@
+from typing import Optional
+
+import numpy as np
+from ortools.sat.python import cp_model
+from ortools.util.python import sorted_interval_list
+
+from puzzle_solver.core.utils import Direction8, Pos, get_all_pos, get_char, Direction, get_col_pos, get_next_pos, get_pos, get_row_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+def add_opcode_constraint(model: cp_model.CpModel, vlist: list[cp_model.IntVar], opcode: str, result: int):
+    assert opcode in ['+', '-', '*', '/'], "Invalid opcode"
+    assert opcode not in ['-', '/'] or len(vlist) == 2, f"Opcode '{opcode}' requires exactly 2 variables"
+    if opcode == '+':
+        model.Add(sum(vlist) == result)
+    elif opcode == '*':
+        model.AddMultiplicationEquality(result, vlist)
+    elif opcode == '-':
+        # either vlist[0] - vlist[1] == result OR vlist[1] - vlist[0] == result
+        b = model.NewBoolVar('sub_gate')
+        model.Add(vlist[0] - vlist[1] == result).OnlyEnforceIf(b)
+        model.Add(vlist[1] - vlist[0] == result).OnlyEnforceIf(b.Not())
+    elif opcode == '/':
+        # either v0 / v1 == result or v1 / v0 == result
+        b = model.NewBoolVar('div_gate')
+        # Ensure no division by zero
+        model.Add(vlist[0] != 0)
+        model.Add(vlist[1] != 0)
+        # case 1: v0 / v1 == result → v0 == v1 * result
+        model.Add(vlist[0] == vlist[1] * result).OnlyEnforceIf(b)
+        # case 2: v1 / v0 == result → v1 == v0 * result
+        model.Add(vlist[1] == vlist[0] * result).OnlyEnforceIf(b.Not())
+
+
+class Board:
+    def __init__(self, circle_board: np.array, board: Optional[np.array] = None):
+        assert circle_board.ndim == 2, f'circle_board must be 2d, got {circle_board.ndim}'
+        self.circle_board = circle_board
+        self.board = board
+        self.V, self.H = circle_board.shape
+        self.V += 1
+        self.H += 1
+        assert board is None or board.shape == (self.V, self.H), f'board must be {(self.V, self.H)}, got {board.shape}'
+        self.N = max(self.V, self.H)
+
+        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(1, self.N, f'{pos}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V-1, self.H-1):  # enforce circles
+            tl = self.model_vars[pos]
+            tr = self.model_vars[get_next_pos(pos, Direction.RIGHT)]
+            bl = self.model_vars[get_next_pos(pos, Direction.DOWN)]
+            br = self.model_vars[get_next_pos(pos, Direction8.DOWN_RIGHT)]
+            c = get_char(self.circle_board, pos).strip()
+            if c == 'E':  # all are even
+                domain = sorted_interval_list.Domain.FromValues(list(range(2, self.N+1, 2)))
+                for v in [tl, tr, bl, br]:
+                    self.model.AddLinearExpressionInDomain(v, domain)
+            elif c == 'O':  # all are odd
+                domain = sorted_interval_list.Domain.FromValues(list(range(1, self.N+1, 2)))
+                for v in [tl, tr, bl, br]:
+                    self.model.AddLinearExpressionInDomain(v, domain)
+            elif c:
+                result, opcode = c[:-1], c[-1]
+                opcode = opcode.replace('x', '*')
+                add_opcode_constraint(self.model, [tl, br], opcode, int(result))
+                add_opcode_constraint(self.model, [tr, bl], opcode, int(result))
+        for row in range(self.V):  # every row is unique
+            self.model.AddAllDifferent([self.model_vars[p] for p in get_row_pos(row, self.H)])
+        for col in range(self.H):  # every column is unique
+            self.model.AddAllDifferent([self.model_vars[p] for p in get_col_pos(col, self.V)])
+        if self.board is not None:
+            for pos in get_all_pos(self.V, self.H):
+                c = get_char(self.board, pos).strip()
+                if c:
+                    self.model.Add(self.model_vars[pos] == int(c))
+
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: solver.Value(board.model_vars[pos]) for pos in get_all_pos(board.V, board.H)})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, center_char=lambda r, c: str(single_res.assignment[get_pos(x=c, y=r)]).strip()))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/minesweeper/minesweeper.py

@@ -0,0 +1,123 @@
+import time
+from typing import Union, Optional
+
+import numpy as np
+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, get_char, set_char, get_neighbors8
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+class Board:
+    def __init__(self, board: np.array, mine_count: Optional[int] = None):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all(isinstance(i.item(), str) and (str(i.item()) in [' ', 'F', 'S', 'M', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9']) for i in np.nditer(board)), 'board must be either F, S, M, 0-9 or space'
+        self.board = board
+        self.V = board.shape[0]
+        self.H = board.shape[1]
+        self.mine_count = mine_count
+        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.NewBoolVar(f'{pos}')
+
+    def add_all_constraints(self):
+        if self.mine_count is not None:
+            self.model.Add(lxp.Sum(list(self.model_vars.values())) == self.mine_count)
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.board, pos)
+            if c in ['F', ' ']:
+                continue
+            if c == 'S':  # safe position but neighbors are unknown
+                self.model.Add(self.model_vars[pos] == 0)
+                continue
+            if c == 'M':  # mine position but neighbors are unknown
+                self.model.Add(self.model_vars[pos] == 1)
+                continue
+            # clue indicates safe position AND neighbors are known
+            c = int(c)
+            self.model.Add(lxp.Sum([self.model_vars[n] for n in get_neighbors8(pos, self.V, self.H, include_self=False)]) == c)
+            self.model.Add(self.model_vars[pos] == 0)
+
+
+def _is_feasible(board: np.array, pos: Pos = None, value: str = None, mine_count: int = None) -> bool:
+    """Returns True if the board is feasible after setting the value at the position"""
+    board = board.copy()
+    if pos is not None and value is not None:
+        set_char(board, pos, str(value))
+    board = Board(board, mine_count=mine_count)
+    def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+        return SingleSolution(assignment={pos: solver.value(var) for pos, var in board.model_vars.items()})
+    return len(generic_solve_all(board, board_to_solution, max_solutions=1, verbose=False)) >= 1
+
+def _is_safe(board: np.array, pos: Pos, mine_count: Optional[int] = None) -> Union[bool, None]:
+    """Returns a True if the position is safe, False if it is a mine, otherwise None"""
+    safe_feasible = _is_feasible(board, pos, 'S', mine_count=mine_count)
+    mine_feasible = _is_feasible(board, pos, 'M', mine_count=mine_count)
+    if safe_feasible and mine_feasible:
+        return None
+    if safe_feasible:
+        return True
+    if mine_feasible:
+        return False
+    raise ValueError(f"Position {pos} has both safe and mine infeasible")
+
+def give_next_guess(board: np.array, mine_count: Optional[int] = None, verbose: bool = True):
+    tic = time.time()
+    is_feasible = _is_feasible(board, mine_count=mine_count)
+    if not is_feasible:
+        raise ValueError("Board is not feasible")
+    V = board.shape[0]
+    H = board.shape[1]
+    check_positions = set()  # any position that is unknown and has a neighbor with a clue or flag
+    flag_positions = set()
+    for pos in get_all_pos(V, H):
+        neighbors8 = get_neighbors8(pos, V, H, include_self=False)
+        if get_char(board, pos) not in [' ', 'F']:
+            continue
+        if get_char(board, pos) == 'F' or any(get_char(board, n) != ' ' for n in neighbors8):
+            check_positions.add(pos)
+        if get_char(board, pos) == 'F':
+            flag_positions.add(pos)
+    pos_dict = {pos: _is_safe(board, pos, mine_count) for pos in check_positions}
+    safe_positions = {pos for pos, is_safe in pos_dict.items() if is_safe is True}
+    mine_positions = {pos for pos, is_safe in pos_dict.items() if is_safe is False}
+    new_garuneed_mine_positions = mine_positions - flag_positions
+    wrong_flag_positions = flag_positions - mine_positions
+    if verbose:
+        if len(safe_positions) > 0:
+            print(f"Found {len(safe_positions)} new guaranteed safe positions")
+            print(safe_positions)
+            print('#'*10)
+        if len(mine_positions) == 0:
+            print("No guaranteed mine positions")
+            print('#'*10)
+        if len(new_garuneed_mine_positions) > 0:
+            print(f"Found {len(new_garuneed_mine_positions)} new guaranteed mine positions")
+            print(new_garuneed_mine_positions)
+            print('#'*10)
+        if len(wrong_flag_positions) > 0:
+            print("WARNING | "*4 + "WARNING")
+            print(f"Found {len(wrong_flag_positions)} wrong flag positions")
+            print(wrong_flag_positions)
+            print('#'*10)
+        toc = time.time()
+        print(f"Time taken: {toc - tic:.2f} seconds")
+    return safe_positions, new_garuneed_mine_positions, wrong_flag_positions
+
+def print_board(board: np.array, safe_positions: set[Pos], new_garuneed_mine_positions: set[Pos], wrong_flag_positions: set[Pos]):
+    res = np.full((board.shape[0], board.shape[1]), ' ', dtype=object)
+    for pos in get_all_pos(board.shape[0], board.shape[1]):
+        if pos in safe_positions:
+            set_char(res, pos, 'S')
+        elif pos in new_garuneed_mine_positions:
+            set_char(res, pos, 'M')
+        elif get_char(board, pos) == 'F' and pos not in wrong_flag_positions:
+            set_char(res, pos, 'F')
+    print(res)

puzzle_solver/puzzles/mosaic/mosaic.py

@@ -0,0 +1,38 @@
+import numpy as np
+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, get_char, get_neighbors8, get_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+from puzzle_solver.core.utils_visualizer import combined_function
+
+
+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 space or digits'
+        self.board = board
+        self.V, self.H = board.shape
+        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.NewBoolVar(f'{pos}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            c = get_char(self.board, pos)
+            if not str(c).isdecimal():
+                continue
+            self.model.Add(lxp.Sum([self.model_vars[n] for n in get_neighbors8(pos, self.V, self.H, include_self=True)]) == int(c))
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            return SingleSolution(assignment={pos: solver.Value(var) for pos, var in board.model_vars.items()})
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            print(combined_function(self.V, self.H, is_shaded=lambda r, c: single_res.assignment[get_pos(x=c, y=r)] == 1, center_char=lambda r, c: str(self.board[r, c]), text_on_shaded_cells=False))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)