multi-puzzle-solver 0.9.14__tar.gz → 0.9.15__tar.gz

{multi_puzzle_solver-0.9.14 → multi_puzzle_solver-0.9.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-puzzle-solver
-Version: 0.9.14
+Version: 0.9.15
 Summary: Efficient solvers for numerous popular and esoteric logic puzzles using CP-SAT
 Author: Ar-Kareem
 Project-URL: Homepage, https://github.com/Ar-Kareem/puzzle_solver

{multi_puzzle_solver-0.9.14 → multi_puzzle_solver-0.9.15}/src/multi_puzzle_solver.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-puzzle-solver
-Version: 0.9.14
+Version: 0.9.15
 Summary: Efficient solvers for numerous popular and esoteric logic puzzles using CP-SAT
 Author: Ar-Kareem
 Project-URL: Homepage, https://github.com/Ar-Kareem/puzzle_solver

{multi_puzzle_solver-0.9.14 → multi_puzzle_solver-0.9.15}/src/multi_puzzle_solver.egg-info/SOURCES.txt

@@ -17,6 +17,8 @@ src/puzzle_solver/puzzles/chess_range/chess_range.py
 src/puzzle_solver/puzzles/chess_range/chess_solo.py
 src/puzzle_solver/puzzles/dominosa/dominosa.py
 src/puzzle_solver/puzzles/filling/filling.py
+src/puzzle_solver/puzzles/galaxies/galaxies.py
+src/puzzle_solver/puzzles/galaxies/parse_map/parse_map.py
 src/puzzle_solver/puzzles/guess/guess.py
 src/puzzle_solver/puzzles/inertia/inertia.py
 src/puzzle_solver/puzzles/inertia/tsp.py
@@ -55,6 +57,7 @@ tests/test_chess_range.py
 tests/test_chess_solo.py
 tests/test_dominosa.py
 tests/test_filling.py
+tests/test_galaxies.py
 tests/test_guess.py
 tests/test_inertia.py
 tests/test_kakurasu.py

{multi_puzzle_solver-0.9.14 → multi_puzzle_solver-0.9.15}/src/puzzle_solver/__init__.py

@@ -7,6 +7,7 @@ from puzzle_solver.puzzles.chess_range import chess_solo as chess_solo_solver
 from puzzle_solver.puzzles.chess_range import chess_melee as chess_melee_solver
 from puzzle_solver.puzzles.dominosa import dominosa as dominosa_solver
 from puzzle_solver.puzzles.filling import filling as filling_solver
+from puzzle_solver.puzzles.galaxies import galaxies as galaxies_solver
 from puzzle_solver.puzzles.guess import guess as guess_solver
 from puzzle_solver.puzzles.inertia import inertia as inertia_solver
 from puzzle_solver.puzzles.kakurasu import kakurasu as kakurasu_solver
@@ -35,4 +36,4 @@ from puzzle_solver.puzzles.unruly import unruly as unruly_solver
 
 from puzzle_solver.puzzles.inertia.parse_map.parse_map import main as inertia_image_parser
 
-__version__ = '0.9.14'
+__version__ = '0.9.15'

{multi_puzzle_solver-0.9.14 → multi_puzzle_solver-0.9.15}/src/puzzle_solver/core/utils_ortools.py

@@ -97,6 +97,8 @@ def force_connected_component(model: cp_model.CpModel, vars_to_force: dict[Any,
 
     vs = vars_to_force
     v_count = len(vs)
+    if v_count <= 2:  # graph must have at least 3 nodes to possibly be disconnected
+        return {}
     # =V model variables, one for each variable
     is_root: dict[Pos, cp_model.IntVar] = {}  # =V, defines the unique root 
     prefix_zero: dict[Pos, cp_model.IntVar] = {}  # =V, used for picking the unique root
@@ -128,7 +130,7 @@ def force_connected_component(model: cp_model.CpModel, vars_to_force: dict[Any,
     for p in keys_in_order:
         and_constraint(model, is_root[p], [vs[p], prefix_zero[p]])
     # Exactly one root:
-    model.Add(sum(is_root.values()) == 1)
+    model.Add(sum(is_root.values()) <= 1)
 
     # For each node i, consider only neighbors
     for i, pi in enumerate(keys_in_order):

multi_puzzle_solver-0.9.15/src/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)

multi_puzzle_solver-0.9.15/src/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')

multi_puzzle_solver-0.9.15/tests/test_galaxies.py

@@ -0,0 +1,84 @@
+import numpy as np
+
+from puzzle_solver import galaxies_solver as solver
+from puzzle_solver.core.utils import get_pos
+
+
+def test_ground():
+    # 15 x 15 unreasonable
+    # https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/galaxies.html#15x15:eofodowmumgzzdkopzlpzkzaezrhefoezejvdtxrzmpgozzemxjdcigcqzrk
+    galaxies = np.array([
+        ['  ', '  ', '00', '  ', '  ', '01', '01', '02', '02', '03', '03', '  ', '04', '04', '  '],
+        ['05', '05', '  ', '  ', '06', '01', '01', '02', '02', '  ', '  ', '  ', '07', '  ', '  '],
+        ['08', '  ', '  ', '  ', '06', '  ', '09', '09', '  ', '  ', '10', '  ', '  ', '  ', '  '],
+        ['  ', '  ', '  ', '  ', '  ', '  ', '11', '11', '12', '  ', '  ', '  ', '  ', '13', '13'],
+        ['14', '  ', '  ', '  ', '15', '  ', '11', '11', '  ', '  ', '  ', '  ', '16', '  ', '  '],
+        ['  ', '17', '  ', '  ', '15', '  ', '  ', '  ', '  ', '  ', '  ', '  ', '16', '  ', '18'],
+        ['  ', '17', '19', '  ', '  ', '  ', '  ', '  ', '  ', '20', '  ', '  ', '  ', '21', '18'],
+        ['  ', '22', '  ', '  ', '23', '  ', '  ', '  ', '  ', '20', '  ', '24', '24', '21', '25'],
+        ['26', '27', '27', '28', '28', '29', '  ', '  ', '  ', '  ', '  ', '  ', '  ', '30', '30'],
+        ['  ', '27', '27', '28', '28', '31', '31', '  ', '  ', '  ', '  ', '32', '  ', '30', '30'],
+        ['  ', '  ', '  ', '33', '33', '31', '31', '34', '  ', '  ', '35', '  ', '  ', '  ', '  '],
+        ['36', '  ', '  ', '33', '33', '  ', '  ', '34', '  ', '  ', '  ', '  ', '  ', '37', '  '],
+        ['  ', '  ', '38', '38', '  ', '39', '  ', '40', '40', '41', '41', '42', '  ', '37', '  '],
+        ['43', '44', '38', '38', '45', '45', '46', '40', '40', '41', '41', '42', '  ', '  ', '  '],
+        ['43', '  ', '  ', '  ', '  ', '  ', '  ', '47', '  ', '  ', '  ', '  ', '48', '48', '  ']
+    ])
+    binst = solver.Board(galaxies=galaxies)
+    solutions = binst.solve_and_print()
+    assert len(solutions) == 1, f'unique solutions != 1, == {len(solutions)}'
+
+
+
+def test_easy():
+    # 5x5 example
+    # https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/galaxies.html#5x5:cfjglmlcg
+    galaxies = [
+        (get_pos(x=1, y=0),),
+        (get_pos(x=4, y=0),),
+        (get_pos(x=0, y=1),),
+        (get_pos(x=3, y=1), get_pos(x=4, y=1)),
+        (get_pos(x=0, y=2), get_pos(x=1, y=2)),
+        (get_pos(x=2, y=2), get_pos(x=3, y=2), get_pos(x=2, y=3), get_pos(x=3, y=3)),
+        (get_pos(x=1, y=3), get_pos(x=1, y=4)),
+        (get_pos(x=4, y=3),),
+        (get_pos(x=0, y=4),),
+    ]
+    binst = solver.Board(V=5, H=5, galaxies=galaxies)
+    solutions = binst.solve_and_print()
+    assert len(solutions) == 1, f'unique solutions != 1, == {len(solutions)}'
+
+
+
+def test_dummy():
+    # 3x3 toy example
+    # https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/galaxies.html#3x3:acn
+    galaxies = [
+        (get_pos(x=0, y=0),),
+        (get_pos(x=1, y=0), get_pos(x=2, y=0)),
+        (get_pos(x=1, y=1), get_pos(x=1, y=2)),
+    ]
+    binst = solver.Board(V=3, H=3, galaxies=galaxies)
+    solutions = binst.solve_and_print()
+    assert len(solutions) == 1, f'unique solutions != 1, == {len(solutions)}'
+    ground = np.array([
+        [0, 1, 1],
+        [2, 2, 2],
+        [2, 2, 2],
+    ])
+    ground_assignment = {get_pos(x=x, y=y): ground[y][x] for x in range(ground.shape[1]) for y in range(ground.shape[0])}
+    solution = solutions[0].assignment
+    assert set(solution.keys()) == set(ground_assignment.keys()), f'solution keys != ground assignment keys, {set(solution.keys()) ^ set(ground_assignment.keys())} \n\n\n{solution} \n\n\n{ground_assignment}'
+    for pos in solution.keys():
+        assert solution[pos] == ground_assignment[pos], f'solution[{pos}] != ground_assignment[{pos}], {solution[pos]} != {ground_assignment[pos]}'
+
+
+def test_bbb():
+    solver.BBBB().solve_and_print()
+
+
+if __name__ == '__main__':
+    # test_bbb()
+    test_dummy()
+    # test_easy()
+    test_ground()