multi-puzzle-solver 0.9.24__py3-none-any.whl → 0.9.26__py3-none-any.whl

{multi_puzzle_solver-0.9.24.dist-info → multi_puzzle_solver-0.9.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-puzzle-solver
-Version: 0.9.24
+Version: 0.9.26
 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
@@ -326,6 +326,16 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
       <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/rectangles_solved.png" alt="Rectangles" width="140">
     </a>
   </td>
+  <td align="center">
+    <a href="#palisade-puzzle-type-43"><b>Palisade</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/palisade_solved.png" alt="Palisade" width="140">
+    </a>
+  </td>
+  <td align="center">
+    <a href="#flip-puzzle-type-44"><b>Flip</b><br><br>
+      <img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/flip_unsolved.png" alt="Flip" width="140">
+    </a>
+  </td>
 </tr>
 </table>
 
@@ -383,6 +393,8 @@ These are all the puzzles that are implemented in this repo. <br> Click on any o
   - [Yin-Yang (Puzzle Type #40)](#yin-yang-puzzle-type-40)
   - [Binairo (Puzzle Type #41)](#binairo-puzzle-type-41)
   - [Rectangles (Puzzle Type #42)](#rectangles-puzzle-type-42)
+  - [Palisade (Puzzle Type #43)](#palisade-puzzle-type-43)
+  - [Flip (Puzzle Type #44)](#flip-puzzle-type-44)
   - [Why SAT / CP-SAT?](#why-sat--cp-sat)
   - [Testing](#testing)
   - [Contributing](#contributing)
@@ -3317,9 +3329,13 @@ Applying the solution to the puzzle visually:
 
 ## Slitherlink (Puzzle Type #39)
 
-Also known as Fences and Loop the Loop
+Also known as Fences, Loop the Loop, and Loopy
 
-* [**Play online**](https://www.puzzle-loop.com)
+* [**Play online 1**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/loopy.html)
+
+* [**Play online 2**](https://www.puzzle-loop.com)
+
+* [**Instructions**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/doc/loopy.html#loopy)
 
 * [**Solver Code**][39]
 
@@ -3720,6 +3736,158 @@ Applying the solution to the puzzle visually:
 
 ---
 
+## Palisade (Puzzle Type #43)
+
+* [**Play online**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/palisade.html)
+
+* [**Instructions**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/doc/palisade.html#palisade)
+
+* [**Solver Code**][43]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+You're given a grid of N squares and a region size M, some of which contain numbers. Your goal is to subdivide the grid into (N/M) contiguous regions, where every region is of size M, such that each square containing a number is adjacent to exactly that many edges (including those between the inside and the outside of the grid). 
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/palisade_unsolved.png" alt="Palisade unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+(Note: it takes a few seconds for the model to be built if the region size is larger than 8 and around 10 seconds for a region size of 10)
+
+```python
+import numpy as np
+from puzzle_solver import palisade_solver as solver
+board = np.array([
+    ['2', ' ', ' ', ' ', ' ', '3', ' ', ' ', '1', '1', '3', ' ', ' ', ' ', ' '],
+    ['3', '2', '1', ' ', '2', '3', ' ', ' ', ' ', ' ', ' ', '2', ' ', '0', ' '],
+    [' ', ' ', ' ', '1', '1', ' ', ' ', '1', ' ', ' ', ' ', '1', ' ', ' ', ' '],
+    [' ', '3', '2', ' ', ' ', ' ', ' ', '2', '3', ' ', ' ', ' ', '1', ' ', ' '],
+    [' ', '0', '1', ' ', '2', ' ', ' ', '0', ' ', ' ', ' ', '1', ' ', '3', '2'],
+    ['1', '0', ' ', ' ', ' ', '2', '2', ' ', '2', ' ', '3', ' ', '0', '2', ' '],
+    [' ', ' ', ' ', ' ', ' ', '3', ' ', ' ', ' ', '2', ' ', ' ', ' ', ' ', ' '],
+    [' ', '1', ' ', ' ', ' ', '3', '1', ' ', '1', ' ', ' ', ' ', ' ', '1', ' '],
+    [' ', ' ', ' ', '0', ' ', ' ', '0', ' ', ' ', '1', '2', ' ', ' ', ' ', '3'],
+    [' ', ' ', ' ', ' ', ' ', ' ', '1', ' ', ' ', '2', ' ', ' ', '1', '2', '1'],
+    [' ', ' ', ' ', ' ', '1', ' ', '2', '3', '1', ' ', ' ', ' ', '2', ' ', '1'],
+    ['2', ' ', '1', ' ', '2', '2', '1', ' ', ' ', '2', ' ', ' ', ' ', ' ', ' '],
+])
+binst = solver.Board(board, region_size=10)
+solutions = binst.solve_and_print()
+```
+
+**Script Output**
+
+```python
+Solution found
+    0   0   0   0   0   0   0   0   0   0   1   1   1   1   1  
+    0   1   2   3   4   5   6   7   8   9   0   1   2   3   4
+  ┌───────────────────┬───────────────────────┬───────────────┐
+ 0│ 2   ·   ·   ·   · │ 3   ·   ·   1   1   3 │ ·   ·   ·   · │
+  │   ┌───────────┐   ├───────┬───┐       ┌───┴───┐           │
+ 1│ 3 │ 2   1   · │ 2 │ 3   · │ · │ ·   · │ ·   2 │ ·   0   · │
+  ├───┘           │   └───┐   │   └───┐   └───┐   └───┐       │
+ 2│ ·   ·   ·   1 │ 1   · │ · │ 1   · │ ·   · │ 1   · │ ·   · │
+  │   ┌───┐       │   ┌───┘   │   ┌───┴───────┘       └───┐   │
+ 3│ · │ 3 │ 2   · │ · │ ·   · │ 2 │ 3   ·   ·   ·   1   · │ · │
+  ├───┘   └───────┼───┘   ┌───┘   └───┬───────────────┬───┴───┤
+ 4│ ·   0   1   · │ 2   · │ ·   0   · │ ·   ·   1   · │ 3   2 │
+  │           ┌───┘       │           │   ┌───┐       └───┐   │
+ 5│ 1   0   · │ ·   ·   2 │ 2   ·   2 │ · │ 3 │ ·   0   2 │ · │
+  │       ┌───┴───────────┼───┬───────┴───┤   ├───┐       │   │
+ 6│ ·   · │ ·   ·   ·   3 │ · │ ·   ·   2 │ · │ · │ ·   · │ · │
+  ├───────┘   ┌───────────┤   └───┐       │   │   └───────┘   │
+ 7│ ·   1   · │ ·   ·   3 │ 1   · │ 1   · │ · │ ·   ·   1   · │
+  │       ┌───┘       ┌───┘       │       │   └───────┐   ┌───┤
+ 8│ ·   · │ ·   0   · │ ·   0   · │ ·   1 │ 2   ·   · │ · │ 3 │
+  │   ┌───┘       ┌───┤           ├───┐   └───┐       ├───┘   │
+ 9│ · │ ·   ·   · │ · │ ·   1   · │ · │ 2   · │ ·   1 │ 2   1 │
+  ├───┤   ┌───────┘   ├───────┐   │   └───┐   │       │       │
+10│ · │ · │ ·   ·   1 │ ·   2 │ 3 │ 1   · │ · │ ·   2 │ ·   1 │
+  │   └───┘           │       └───┘       ├───┴───────┘       │
+11│ 2   ·   1   ·   2 │ 2   1   ·   ·   2 │ ·   ·   ·   ·   · │
+  └───────────────────┴───────────────────┴───────────────────┘
+Solutions found: 1
+status: OPTIMAL
+Time taken: 11.94 seconds
+```
+
+**Solved puzzle**
+
+Applying the solution to the puzzle visually:
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/palisade_solved.png" alt="Palisade solved" width="500">
+
+---
+
+## Flip (Puzzle Type #44)
+
+* [**Play online**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/flip.html)
+
+* [**Instructions**](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/doc/flip.html#flip)
+
+* [**Solver Code**][44]
+
+<details>
+  <summary><strong>Rules</strong></summary>
+
+You have a grid of squares, some light and some dark. Your aim is to light all the squares up at the same time. You can choose any square and flip its state from light to dark or dark to light, but when you do so, other squares around it change state as well. 
+
+</details>
+
+**Unsolved puzzle**
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/flip_unsolved.png" alt="Flip unsolved" width="500">
+
+Code to utilize this package and solve the puzzle:
+
+(Note: the solver also supports random mapping of squares to the neighbors they flip, see the test cases in `tests/test_flip.py` for usage examples)
+
+```python
+import numpy as np
+from puzzle_solver import flip_solver as solver
+board = np.array([
+    ['B', 'W', 'W', 'W', 'W', 'W', 'W'],
+    ['B', 'B', 'W', 'W', 'W', 'B', 'B'],
+    ['W', 'B', 'W', 'W', 'B', 'B', 'W'],
+    ['B', 'B', 'B', 'W', 'W', 'B', 'W'],
+    ['W', 'W', 'B', 'B', 'W', 'B', 'W'],
+    ['B', 'W', 'B', 'B', 'W', 'W', 'W'],
+    ['B', 'W', 'B', 'W', 'W', 'B', 'B'],
+])
+binst = solver.Board(board=board)
+solutions = binst.solve_and_print()
+```
+
+**Script Output**
+
+The output tells you which squares to tap to solve the puzzle.
+
+```python
+Solution found
+[['T' ' ' 'T' 'T' 'T' ' ' ' ']
+ [' ' ' ' ' ' 'T' ' ' 'T' ' ']
+ [' ' 'T' ' ' ' ' 'T' ' ' ' ']
+ ['T' ' ' 'T' ' ' ' ' 'T' ' ']
+ [' ' ' ' ' ' 'T' ' ' ' ' 'T']
+ ['T' ' ' 'T' ' ' 'T' 'T' 'T']
+ [' ' ' ' ' ' ' ' ' ' 'T' 'T']]
+Solutions found: 1
+status: OPTIMAL
+```
+
+**Solved puzzle**
+
+This picture won't mean much as the game is about the sequence of moves not the final frame as shown here.
+
+<img src="https://raw.githubusercontent.com/Ar-Kareem/puzzle_solver/master/images/flip_solved.png" alt="Flip solved" width="500">
+
+---
+
 ---
 
 ## Why SAT / CP-SAT?
@@ -3813,3 +3981,5 @@ Issues and PRs welcome!
 [40]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/yin_yang "puzzle_solver/src/puzzle_solver/puzzles/yin_yang at master · Ar-Kareem/puzzle_solver · GitHub"
 [41]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/binairo "puzzle_solver/src/puzzle_solver/puzzles/binairo at master · Ar-Kareem/puzzle_solver · GitHub"
 [42]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/rectangles "puzzle_solver/src/puzzle_solver/puzzles/rectangles at master · Ar-Kareem/puzzle_solver · GitHub"
+[43]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/palisade "puzzle_solver/src/puzzle_solver/puzzles/palisade at master · Ar-Kareem/puzzle_solver · GitHub"
+[44]: https://github.com/Ar-Kareem/puzzle_solver/tree/master/src/puzzle_solver/puzzles/flip "puzzle_solver/src/puzzle_solver/puzzles/flip at master · Ar-Kareem/puzzle_solver · GitHub"

{multi_puzzle_solver-0.9.24.dist-info → multi_puzzle_solver-0.9.26.dist-info}/RECORD

@@ -1,6 +1,6 @@
-puzzle_solver/__init__.py,sha256=y6x9mMvglHDRKhkRXIudfXFgJ0KGBPo3jqi1YT_B6wc,3071
-puzzle_solver/core/utils.py,sha256=BH4b-GZLfYWWZ4QPt1UcuwSX3ntE3bInJtwHd7RnVf4,13459
-puzzle_solver/core/utils_ortools.py,sha256=2xEL9cMEKmNhRD9lhr2nGdZ3Lbmc9cnHY8xv6iLhUr0,10542
+puzzle_solver/__init__.py,sha256=ScIPz0Gi0xGaY-v7N0JcfFgKUvfdSF3lUggAh8yagdg,3201
+puzzle_solver/core/utils.py,sha256=LyrdhExCcdp7jWJJv1cu2urgS2gpcI44OsIipPeBAeQ,14113
+puzzle_solver/core/utils_ortools.py,sha256=_i8cixHOB5XGqqcr-493bOiZgYJidnvxQMEfj--Trns,10278
 puzzle_solver/puzzles/aquarium/aquarium.py,sha256=BUfkAS2d9eG3TdMoe1cOGGeNYgKUebRvn-z9nsC9gvE,5708
 puzzle_solver/puzzles/battleships/battleships.py,sha256=RuYCrs4j0vUjlU139NRYYP-uNPAgO0V7hAzbsHrRwD8,7446
 puzzle_solver/puzzles/binairo/binairo.py,sha256=sRtflnlGrN8xQ64beRZBGr74R8KptzxYDdFgXuW27pM,4595
@@ -12,6 +12,7 @@ puzzle_solver/puzzles/chess_range/chess_solo.py,sha256=U3v766UsZHx_dC3gxqU90VbjA
 puzzle_solver/puzzles/chess_sequence/chess_sequence.py,sha256=6ap3Wouf2PxHV4P56B9ol1QT98Ym6VHaxorQZWl6LnY,13692
 puzzle_solver/puzzles/dominosa/dominosa.py,sha256=Nmb7pn8U27QJwGy9F3wo8ylqo2_U51OAo3GN2soaNpc,7195
 puzzle_solver/puzzles/filling/filling.py,sha256=vrOIil285_r3IQ0F4c9mUBWMRVlPH4vowog_z1tCGdI,5567
+puzzle_solver/puzzles/flip/flip.py,sha256=ZngJLUhRNc7qqo2wtNLdMPx4u9w9JTUge27PmdXyDCw,3985
 puzzle_solver/puzzles/galaxies/galaxies.py,sha256=p10lpmW0FjtneFCMEjG1FSiEpQuvD8zZG9FG8zYGoes,5582
 puzzle_solver/puzzles/galaxies/parse_map/parse_map.py,sha256=v5TCrdREeOB69s9_QFgPHKA7flG69Im1HVzIdxH0qQc,9355
 puzzle_solver/puzzles/guess/guess.py,sha256=sH-NlYhxM3DNbhk4eGde09kgM0KaDvSbLrpHQiwcFGo,10791
@@ -21,13 +22,14 @@ puzzle_solver/puzzles/inertia/parse_map/parse_map.py,sha256=A9JQTNqamUdzlwqks0XQ
 puzzle_solver/puzzles/kakurasu/kakurasu.py,sha256=VNGMJnBHDi6WkghLObRLhUvkmrPaGphTTUDMC0TkQvQ,2064
 puzzle_solver/puzzles/keen/keen.py,sha256=tDb6C5S3Q0JAKPsdw-84WQ6PxRADELZHr_BK8FDH-NA,5039
 puzzle_solver/puzzles/light_up/light_up.py,sha256=iSA1rjZMFsnI0V0Nxivxox4qZkB7PvUrROSHXcoUXds,4541
-puzzle_solver/puzzles/lits/lits.py,sha256=6Yp9EqhQpuWz_rc_rXtu9dG_pUrmBAhWj1Q9IyAfxPk,7891
+puzzle_solver/puzzles/lits/lits.py,sha256=3fPIkhAIUz8JokcfaE_ZM3b0AFEnf5xPzGJ2qnm8SWY,7099
 puzzle_solver/puzzles/magnets/magnets.py,sha256=-Wl49JD_PKeq735zQVMQ3XSQX6gdHiY-7PKw-Sh16jw,6474
 puzzle_solver/puzzles/map/map.py,sha256=sxc57tapB8Tsgam-yoDitln1o-EB_SbIYvO6WEYy3us,2582
 puzzle_solver/puzzles/minesweeper/minesweeper.py,sha256=LiQVOGkWCsc1WtX8CdPgL_WwAcaeUFuoi5_eqH8U2Og,5876
 puzzle_solver/puzzles/mosaic/mosaic.py,sha256=QX_nVpVKQg8OfaUcqFk9tKqsDyVqvZc6-XWvfI3YcSw,2175
 puzzle_solver/puzzles/nonograms/nonograms.py,sha256=1jmDTOCnmivmBlwtMDyyk3TVqH5IjapzLn7zLQ4qubk,6056
 puzzle_solver/puzzles/norinori/norinori.py,sha256=uC8vXAw35xsTmpmTeKqYW7tbcssms9LCcXFBONtV2Ng,4743
+puzzle_solver/puzzles/palisade/palisade.py,sha256=GTtzuc1OZCm3D5p-Po7LzK1d-whJkNSZ9G9rWr3vFMc,4966
 puzzle_solver/puzzles/pearl/pearl.py,sha256=OhzpMYpxqvR3GCd5NH4ETT0NO4X753kRi6p5omYLChM,6798
 puzzle_solver/puzzles/range/range.py,sha256=rruvD5ZSaOgvQuX6uGV_Dkr82nSiWZ5kDz03_j7Tt24,4425
 puzzle_solver/puzzles/rectangles/rectangles.py,sha256=V7p6GSCwYrFfILDWiLLUbX08WlnPbQKdhQm8bMa2Mgw,7060
@@ -35,7 +37,7 @@ puzzle_solver/puzzles/signpost/signpost.py,sha256=-0_S6ycwzwlUf9-ZhP127Rgo5gMBOH
 puzzle_solver/puzzles/singles/singles.py,sha256=3wACiUa1Vmh2ce6szQ2hPjyBuH7aHiQ888p4R2jFkW4,3342
 puzzle_solver/puzzles/slant/slant.py,sha256=xF-N4PuXYfx638NP1f1mi6YncIZB4mLtXtdS79XyPbg,6122
 puzzle_solver/puzzles/slant/parse_map/parse_map.py,sha256=dxnALSDXe9wU0uSD0QEXnzoh1q801mj1ePTNLtG0n60,4796
-puzzle_solver/puzzles/slitherlink/slitherlink.py,sha256=_P5IyDKs8gP9aubCW5QStOv4TGf0Hkq7ybyjkxw5n_U,6856
+puzzle_solver/puzzles/slitherlink/slitherlink.py,sha256=N3jv1Z-yYFlQDinii-DZfuJvLUsn9fT0h5Kyruxjn94,7017
 puzzle_solver/puzzles/star_battle/star_battle.py,sha256=IX6w4H3sifN01kPPtrAVRCK0Nl_xlXXSHvJKw8K1EuE,3718
 puzzle_solver/puzzles/star_battle/star_battle_shapeless.py,sha256=lj05V0Y3A3NjMo1boMkPIwBhMtm6SWydjgAMeCf5EIo,225
 puzzle_solver/puzzles/stitches/stitches.py,sha256=iK8t02q43gH3FPbuIDn4dK0sbaOgZOnw8yHNRNvNuIU,6534
@@ -51,7 +53,7 @@ puzzle_solver/puzzles/unruly/unruly.py,sha256=sDF0oKT50G-NshyW2DYrvAgD9q9Ku9ANUy
 puzzle_solver/puzzles/yin_yang/yin_yang.py,sha256=WrRdNhmKhIARdGOt_36gpRxRzrfLGv3wl7igBpPFM64,5259
 puzzle_solver/puzzles/yin_yang/parse_map/parse_map.py,sha256=drjfoHqmFf6U-ZQUwrBbfGINRxDQpgbvy4U3D9QyMhM,6617
 puzzle_solver/utils/visualizer.py,sha256=tsX1yEKwmwXBYuBJpx_oZGe2UUt1g5yV73G3UbtmvtE,6817
-multi_puzzle_solver-0.9.24.dist-info/METADATA,sha256=mcSsOot7iHAhhc2fangljbrIpGvDsuwc80_ifFRXJ7s,202273
-multi_puzzle_solver-0.9.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-multi_puzzle_solver-0.9.24.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
-multi_puzzle_solver-0.9.24.dist-info/RECORD,,
+multi_puzzle_solver-0.9.26.dist-info/METADATA,sha256=iVRpKnMdTJNLrbdh9eP19RsPCloN1iEFwtlvcwy_peg,211081
+multi_puzzle_solver-0.9.26.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+multi_puzzle_solver-0.9.26.dist-info/top_level.txt,sha256=exwVUQa-anK9vYrpKzBPvH8bX43iElWI4VeNiAyBGJY,14
+multi_puzzle_solver-0.9.26.dist-info/RECORD,,

puzzle_solver/__init__.py

@@ -8,6 +8,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.flip import flip as flip_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
@@ -20,6 +21,7 @@ from puzzle_solver.puzzles.minesweeper import minesweeper as minesweeper_solver
 from puzzle_solver.puzzles.mosaic import mosaic as mosaic_solver
 from puzzle_solver.puzzles.nonograms import nonograms as nonograms_solver
 from puzzle_solver.puzzles.norinori import norinori as norinori_solver
+from puzzle_solver.puzzles.palisade import palisade as palisade_solver
 from puzzle_solver.puzzles.lits import lits as lits_solver
 from puzzle_solver.puzzles.pearl import pearl as pearl_solver
 from puzzle_solver.puzzles.range import range as range_solver
@@ -43,4 +45,4 @@ from puzzle_solver.puzzles.yin_yang import yin_yang as yin_yang_solver
 
 from puzzle_solver.puzzles.inertia.parse_map.parse_map import main as inertia_image_parser
 
-__version__ = '0.9.24'
+__version__ = '0.9.26'

puzzle_solver/core/utils.py

@@ -42,7 +42,9 @@ def get_next_pos(cur_pos: Pos, direction: Union[Direction, Direction8]) -> Pos:
     return get_pos(cur_pos.x+delta_x, cur_pos.y+delta_y)
 
 
-def get_neighbors4(pos: Pos, V: int, H: int) -> Iterable[Pos]:
+def get_neighbors4(pos: Pos, V: int, H: int, include_self: bool = False) -> Iterable[Pos]:
+    if include_self:
+        yield pos
     for dx, dy in ((1,0),(-1,0),(0,1),(0,-1)):
         p2 = get_pos(x=pos.x+dx, y=pos.y+dy)
         if in_bounds(p2, V, H):
@@ -133,7 +135,7 @@ def get_deltas(direction: Union[Direction, Direction8]) -> Tuple[int, int]:
         raise ValueError(f'invalid direction: {direction}')
 
 
-def polyominoes(N):
+def polyominoes(N) -> set[Shape]:
     """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).
 
@@ -165,7 +167,7 @@ def polyominoes(N):
     shapes: set[FastShape] = {frozenset({(0, 0)})}
     for i in range(1, N):
         next_shapes: set[FastShape] = set()
-        directions = ((1,0),(-1,0),(0,1)) if i > 1 else (((1,0),(0,1)))  # cannot take left on first step, if confused read: https://louridas.github.io/rwa/assignments/polyominoes/
+        directions = ((1,0),(-1,0),(0,1),(0,-1)) if i > 1 else (((1,0),(0,1)))  # cannot take left on first step, if confused read: https://louridas.github.io/rwa/assignments/polyominoes/
         for s in shapes:
             # frontier of a single shape: all 4-neighbors of existing cells not already in the shape
             frontier = set()
@@ -239,125 +241,145 @@ def render_grid(cell_flags: np.ndarray,
     center_char: np.ndarray of shape (N, N) with the center of the cells, or a string to use for all cells, or None to not show centers.
     scale_x: horizontal stretch factor (>=1). Try 2 or 3 for squarer cells.
     """
-    if cell_flags is not None:
-        N = cell_flags.shape[0]
-        H = np.zeros((N+1, N), dtype=bool)
-        V = np.zeros((N, N+1), dtype=bool)
-        for r in range(N):
-            for c in range(N):
-                s = cell_flags[r, c]
-                if 'U' in s: H[r, c]   = True          # edge between (r,c) and (r, c+1) above the cell
-                if 'D' in s: H[r+1, c] = True          # edge below the cell
-                if 'L' in s: V[r, c]   = True          # edge left of the cell
-                if 'R' in s: V[r, c+1] = True          # edge right of the cell
-    assert H is not None and V is not None, 'H and V must be provided'
+    assert cell_flags is not None and cell_flags.ndim == 2
+    R, C = cell_flags.shape
+
+    # Edge presence arrays (note the rectangular shapes)
+    H = np.zeros((R+1, C), dtype=bool)  # horizontal edges between rows
+    V = np.zeros((R, C+1), dtype=bool)  # vertical edges between cols
+    for r in range(R):
+        for c in range(C):
+            s = cell_flags[r, c]
+            if 'U' in s: H[r,   c] = True
+            if 'D' in s: H[r+1, c] = True
+            if 'L' in s: V[r,   c] = True
+            if 'R' in s: V[r, c+1] = True
+
     # Bitmask for corner connections
-    U, R, D, L = 1, 2, 4, 8
+    U, Rb, D, Lb = 1, 2, 4, 8
     JUNCTION = {
         0: ' ',
         U: '│', D: '│', U|D: '│',
-        L: '─', R: '─', L|R: '─',
-        U|R: '└', R|D: '┌', D|L: '┐', L|U: '┘',
-        U|D|L: '┤', U|D|R: '├', L|R|U: '┴', L|R|D: '┬',
-        U|R|D|L: '┼',
+        Lb: '─', Rb: '─', Lb|Rb: '─',
+        U|Rb: '└', Rb|D: '┌', D|Lb: '┐', Lb|U: '┘',
+        U|D|Lb: '┤', U|D|Rb: '├', Lb|Rb|U: '┴', Lb|Rb|D: '┬',
+        U|Rb|D|Lb: '┼',
     }
 
     assert scale_x >= 1
-    N = V.shape[0]
-    assert H.shape == (N+1, N) and V.shape == (N, N+1)
+    assert H.shape == (R+1, C) and V.shape == (R, C+1)
 
-    rows = 2*N + 1
-    cols = 2*N*scale_x + 1                 # stretched width
+    rows = 2*R + 1
+    cols = 2*C*scale_x + 1
     canvas = [[' ']*cols for _ in range(rows)]
 
-    def x_corner(c):     # x of corner column c
+    def x_corner(c):     # x of corner column c  (0..C)
         return (2*c) * scale_x
-    def x_between(c,k):  # kth in-between column (1..scale_x) between c and c+1 corners
+    def x_between(c,k):  # kth in-between col (1..2*scale_x-1) between corners c and c+1
         return (2*c) * scale_x + k
 
     # horizontal edges: fill the stretched band between corners with '─'
-    for r in range(N+1):
+    for r in range(R+1):
         rr = 2*r
-        for c in range(N):
+        for c in range(C):
             if H[r, c]:
-                # previously: for k in range(1, scale_x*2, 2):
-                for k in range(1, scale_x*2):          # 1..(2*scale_x-1), no gaps
+                for k in range(1, scale_x*2):  # 1..(2*scale_x-1)
                     canvas[rr][x_between(c, k)] = '─'
 
-    # vertical edges: draw at the corner columns (no horizontal stretching needed)
-    for r in range(N):
+    # vertical edges: at the corner columns
+    for r in range(R):
         rr = 2*r + 1
-        for c in range(N+1):
+        for c in range(C+1):
             if V[r, c]:
                 canvas[rr][x_corner(c)] = '│'
 
-    # junctions at corners
-    for r in range(N+1):
+    # junctions at every corner grid point
+    for r in range(R+1):
         rr = 2*r
-        for c in range(N+1):
+        for c in range(C+1):
             m = 0
             if r > 0   and V[r-1, c]: m |= U
-            if c < N   and H[r, c]:   m |= R
-            if r < N   and V[r, c]:   m |= D
-            if c > 0   and H[r, c-1]: m |= L
+            if c < C   and H[r, c]:   m |= Rb
+            if r < R   and V[r, c]:   m |= D
+            if c > 0   and H[r, c-1]: m |= Lb
             canvas[rr][x_corner(c)] = JUNCTION[m]
 
-    # centers
-    # ── Centers (now safe for multi-character strings) ──────────────────────
-    # We render center text within the interior span (between corner columns),
-    # centered if it fits; otherwise we truncate to the span width.
+    # centers (safe for multi-character strings)
     def put_center_text(rr: int, c: int, text: str):
-        # interior span (exclusive of the corner columns)
         left  = x_corner(c) + 1
         right = x_corner(c+1) - 1
         if right < left:
-            return  # no interior space (shouldn’t happen when scale_x>=1)
+            return
         span_width = right - left + 1
-
         s = str(text)
         if len(s) > span_width:
-            s = s[:span_width]  # hard truncate if it doesn't fit
-        # center within the span
+            s = s[:span_width]  # truncate to protect borders
         start = left + (span_width - len(s)) // 2
         for i, ch in enumerate(s):
             canvas[rr][start + i] = ch
 
     if center_char is not None:
-        for r in range(N):
+        for r in range(R):
             rr = 2*r + 1
-            for c in range(N):
+            for c in range(C):
                 val = center_char if isinstance(center_char, str) else center_char[r, c]
                 put_center_text(rr, c, '' if val is None else str(val))
 
-    # turn canvas rows into strings
+    # rows -> strings
     art_rows = [''.join(row) for row in canvas]
-
     if not show_axes:
         return '\n'.join(art_rows)
 
-    # ── Axes ────────────────────────────────────────────────────────────────
-    gut = max(2, len(str(N-1)))       # left gutter width
+    # Axes labels: row indices on the left, column indices on top (handle C, not R)
+    gut = max(2, len(str(R-1)))  # gutter width based on row index width
     gutter = ' ' * gut
     top_tens = list(gutter + ' ' * cols)
     top_ones = list(gutter + ' ' * cols)
 
-    for c in range(N):
+    for c in range(C):
         xc_center = x_corner(c) + scale_x
-        if N >= 10:
+        if C >= 10:
             top_tens[gut + xc_center] = str((c // 10) % 10)
         top_ones[gut + xc_center] = str(c % 10)
 
-    # tiny corner labels
     if gut >= 2:
         top_tens[gut-2:gut] = list('  ')
         top_ones[gut-2:gut] = list('  ')
 
     labeled = []
     for r, line in enumerate(art_rows):
-        if r % 2 == 1:                     # cell-center row
+        if r % 2 == 1:  # cell-center row
             label = str(r//2).rjust(gut)
         else:
             label = ' ' * gut
         labeled.append(label + line)
 
     return ''.join(top_tens) + '\n' + ''.join(top_ones) + '\n' + '\n'.join(labeled)
+
+def id_board_to_wall_board(id_board: np.array, border_is_wall = True) -> np.array:
+    """In many instances, we have a 2d array where cell values are arbitrary ids
+    and we want to convert it to a 2d array where cell values are walls "U", "D", "L", "R" to represent the edges that separate me from my neighbors that have different ids.
+    Args:
+        id_board: np.array of shape (N, N) with arbitrary ids.
+        border_is_wall: if True, the edges of the board are considered to be walls.
+    Returns:
+        np.array of shape (N, N) with walls "U", "D", "L", "R".
+    """
+    res = np.full((id_board.shape[0], id_board.shape[1]), '', dtype=object)
+    V, H = id_board.shape
+    def append_char(pos: Pos, s: str):
+        set_char(res, pos, get_char(res, pos) + s)
+    def handle_pos_direction(pos: Pos, direction: Direction, s: str):
+        pos2 = get_next_pos(pos, direction)
+        if in_bounds(pos2, V, H):
+            if get_char(id_board, pos2) != get_char(id_board, pos):
+                append_char(pos, s)
+        else:
+            if border_is_wall:
+                append_char(pos, s)
+    for pos in get_all_pos(V, H):
+        handle_pos_direction(pos, Direction.LEFT, 'L')
+        handle_pos_direction(pos, Direction.RIGHT, 'R')
+        handle_pos_direction(pos, Direction.UP, 'U')
+        handle_pos_direction(pos, Direction.DOWN, 'D')
+    return res

puzzle_solver/core/utils_ortools.py

@@ -146,16 +146,12 @@ def force_connected_component(model: cp_model.CpModel, vars_to_force: dict[Any,
     for p in keys_in_order:
         model.Add(node_height[p] > 0).OnlyEnforceIf(vs[p])
 
-    all_new_vars: dict[str, cp_model.IntVar] = {}
-    for k, v in is_root.items():
-        all_new_vars[f"{prefix_name}is_root[{k}]"] = v
-    for k, v in prefix_zero.items():
-        all_new_vars[f"{prefix_name}prefix_zero[{k}]"] = v
-    for k, v in node_height.items():
-        all_new_vars[f"{prefix_name}node_height[{k}]"] = v
-    for k, v in max_neighbor_height.items():
-        all_new_vars[f"{prefix_name}max_neighbor_height[{k}]"] = v
-
+    all_new_vars = {
+        "is_root": is_root,
+        "prefix_zero": prefix_zero,
+        "node_height": node_height,
+        "max_neighbor_height": max_neighbor_height,
+    }
     return all_new_vars
 
 

puzzle_solver/puzzles/flip/flip.py

@@ -0,0 +1,77 @@
+from typing import Any, Optional
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_neighbors4, set_char, get_char, Direction, get_next_pos
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+class Board:
+    def __init__(self, board: np.array, random_mapping: Optional[dict[Pos, Any]] = None):
+        assert board.ndim == 2, f'board must be 2d, got {board.ndim}'
+        assert all((c.item() in ['B', 'W']) for c in np.nditer(board)), 'board must contain only B or W'
+        self.board = board
+        self.V, self.H = board.shape
+
+        if random_mapping is None:
+            self.tap_mapping: dict[Pos, set[Pos]] = {pos: list(get_neighbors4(pos, self.V, self.H, include_self=True)) for pos in get_all_pos(self.V, self.H)}
+        else:
+            mapping_value = list(random_mapping.values())[0]
+            if isinstance(mapping_value, (set, list, tuple)) and isinstance(list(mapping_value)[0], Pos):
+                self.tap_mapping: dict[Pos, set[Pos]] = {pos: set(random_mapping[pos]) for pos in get_all_pos(self.V, self.H)}
+            elif isinstance(mapping_value, (set, list, tuple)) and isinstance(list(mapping_value)[0], str):  # strings like "L", "UR", etc.
+                def _to_pos(pos: Pos, s: str) -> Pos:
+                    d = {'L': Direction.LEFT, 'R': Direction.RIGHT, 'U': Direction.UP, 'D': Direction.DOWN}[s[0]]
+                    r = get_next_pos(pos, d)
+                    if len(s) == 1:
+                        return r
+                    else:
+                        return _to_pos(r, s[1:])
+                self.tap_mapping: dict[Pos, set[Pos]] = {pos: set(_to_pos(pos, s) for s in random_mapping[pos]) for pos in get_all_pos(self.V, self.H)}
+            else:
+                raise ValueError(f'invalid random_mapping: {random_mapping}')
+            for k, v in self.tap_mapping.items():
+                if k not in v:
+                    v.add(k)
+
+
+        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'tap:{pos}')
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):
+            # the state of a position is its starting state + if it is tapped + if any pos pointing to it is tapped
+            c = get_char(self.board, pos)
+            pos_that_will_turn_me = [k for k,v in self.tap_mapping.items() if pos in v]
+            literals = [self.model_vars[p] for p in pos_that_will_turn_me]
+            if c == 'W':  # if started as white then needs an even number of taps while xor checks for odd number
+                literals.append(self.model.NewConstant(True))
+            elif c == 'B':
+                pass
+            else:
+                raise ValueError(f'invalid character: {c}')
+            self.model.AddBoolXOr(literals)
+
+    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, 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 in get_all_pos(self.V, self.H):
+                c = get_char(self.board, pos)
+                c = 'T' if single_res.assignment[pos] == 1 else ' '
+                set_char(res, pos, c)
+            print(res)
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/lits/lits.py

@@ -1,7 +1,5 @@
-import json
-import time
 from dataclasses import dataclass
-from typing import Optional, Union
+from typing import Optional
 
 from ortools.sat.python import cp_model
 import numpy as np
@@ -14,19 +12,6 @@ from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution,
 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
@@ -63,7 +48,6 @@ class Board:
     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):
@@ -84,7 +68,6 @@ class Board:
                     body=body,
                     disallow_same_shape=disallow_same_shape,
                 ))
-        # print('shapes on board:', len(self.shapes_on_board))
 
     def add_all_constraints(self):
         # RULES:
@@ -99,11 +82,9 @@ class 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
@@ -118,7 +99,6 @@ class Board:
         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):
@@ -138,8 +118,6 @@ class Board:
             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
@@ -147,10 +125,7 @@ class Board:
             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)
+            return SingleSolution(assignment=assignment)
         def callback(single_res: SingleSolution):
             print("Solution found")
             res = np.full((self.V, self.H), ' ', dtype=str)
@@ -158,5 +133,4 @@ class Board:
                 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/palisade/palisade.py

@@ -0,0 +1,104 @@
+from dataclasses import dataclass
+from collections import defaultdict
+
+import numpy as np
+from ortools.sat.python import cp_model
+
+from puzzle_solver.core.utils import Pos, get_all_pos, get_pos, id_board_to_wall_board, render_grid, set_char, in_bounds, get_next_pos, Direction, polyominoes
+from puzzle_solver.core.utils_ortools import generic_solve_all, SingleSolution
+
+
+
+# a shape on the 2d board is just a set of positions
+Shape = frozenset[Pos]
+
+@dataclass(frozen=True)
+class ShapeOnBoard:
+    is_active: cp_model.IntVar
+    shape: Shape
+    shape_id: int
+    body: set[Pos]
+
+
+def get_valid_translations(shape: Shape, board: np.array) -> set[Pos]:
+    # give a shape and a board, return all valid translations of the shape that are fully contained in the board AND consistent with the clues on the board
+    shape_list = list(shape)
+    shape_borders = []  # will contain the number of borders for each pos in the shape; this has to be consistent with the clues on the board
+    for pos in shape_list:
+        v = 0
+        for direction in Direction:
+            next_pos = get_next_pos(pos, direction)
+            if not in_bounds(next_pos, board.shape[0], board.shape[1]) or next_pos not in shape:
+                v += 1
+        shape_borders.append(v)
+    shape_list = [(p.x, p.y) for p in shape_list]
+    # min x/y is always 0
+    max_x = max(p[0] for p in shape_list)
+    max_y = max(p[1] for p in shape_list)
+
+    for dy in range(0, board.shape[0] - max_y):
+        for dx in range(0, board.shape[1] - max_x):
+            body = tuple((p[0] + dx, p[1] + dy) for p in shape_list)
+            for i, p in enumerate(body):
+                c = board[p[1], p[0]]
+                if c != ' ' and c != str(shape_borders[i]):  # there is a clue and it doesn't match my translated shape, skip
+                    break
+            else:
+                yield frozenset(get_pos(x=p[0], y=p[1]) for p in body)
+
+
+
+class Board:
+    def __init__(self, board: np.array, region_size: int):
+        assert region_size >= 1 and isinstance(region_size, int), 'region_size must be an integer greater than or equal to 1'
+        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.region_size = region_size
+        self.region_count = (self.V * self.H) // self.region_size
+        assert self.region_count * self.region_size == self.V * self.H, f'region_size must be a factor of the board size, got {self.region_size} and {self.region_count}'
+
+        self.polyominoes = polyominoes(self.region_size)
+
+        self.model = cp_model.CpModel()
+        self.shapes_on_board: list[ShapeOnBoard] = []  # will contain every possible shape on the board based on polyomino degrees
+        self.pos_to_shapes: dict[Pos, set[ShapeOnBoard]] = defaultdict(set)
+        self.create_vars()
+        self.add_all_constraints()
+
+    def create_vars(self):
+        for shape in self.polyominoes:
+            for body in get_valid_translations(shape, self.board):
+                uid = len(self.shapes_on_board)
+                shape_on_board = ShapeOnBoard(
+                    is_active=self.model.NewBoolVar(f'{uid}:is_active'),
+                    shape=shape,
+                    shape_id=uid,
+                    body=body,
+                )
+                self.shapes_on_board.append(shape_on_board)
+                for pos in body:
+                    self.pos_to_shapes[pos].add(shape_on_board)
+
+    def add_all_constraints(self):
+        for pos in get_all_pos(self.V, self.H):  # each position has exactly one shape active
+            self.model.AddExactlyOne(shape.is_active for shape in self.pos_to_shapes[pos])
+
+    def solve_and_print(self, verbose: bool = True):
+        def board_to_solution(board: Board, solver: cp_model.CpSolverSolutionCallback) -> SingleSolution:
+            assignment: dict[Pos, int] = {}
+            for shape in board.shapes_on_board:
+                if solver.Value(shape.is_active) == 1:
+                    for pos in shape.body:
+                        assignment[pos] = shape.shape_id
+            return SingleSolution(assignment=assignment)
+        def callback(single_res: SingleSolution):
+            print("Solution found")
+            id_board = np.full((self.V, self.H), ' ', dtype=object)
+            for pos in get_all_pos(self.V, self.H):
+                region_idx = single_res.assignment[pos]
+                set_char(id_board, pos, region_idx)
+            board = np.where(self.board == ' ', '·', self.board)
+            print(render_grid(id_board_to_wall_board(id_board), center_char=board))
+        return generic_solve_all(self, board_to_solution, callback=callback if verbose else None, verbose=verbose)

puzzle_solver/puzzles/slitherlink/slitherlink.py

@@ -20,6 +20,10 @@ class Board:
         self.cell_borders_to_corners: dict[CellBorder, set[Corner]] = defaultdict(set)  # for every cell border, a set of all corners it is connected to
         self.corners_to_cell_borders: dict[Corner, set[CellBorder]] = defaultdict(set)  # opposite direction
 
+        # 2N^2 + 2N edges
+        # 4*edges (fully connected component)
+        # model variables = edges (on/off) + 4*edges (fully connected component)
+        # = 9N^2 + 9N
         self.model = cp_model.CpModel()
         self.model_vars: dict[CellBorder, cp_model.IntVar] = {}  # one entry for every unique variable in the model
         self.cell_borders: dict[CellBorder, cp_model.IntVar] = {}  # for every position and direction, one entry for that edge (thus the same edge variables are used in opposite directions of neighboring cells)
@@ -87,10 +91,11 @@ class Board:
             if not val.isdecimal():
                 continue
             self.model.Add(sum(variables) == int(val))
+
+        corner_sum_domain = cp_model.Domain.FromValues([0, 2])  # sum of edges touching a corner is 0 or 2
         for corner in self.corner_vars:  # a corder always has 0 or 2 active edges
-            g = self.model.NewBoolVar(f'corner_gate_{corner}')
-            self.model.Add(sum(self.corner_vars[corner]) == 0).OnlyEnforceIf(g.Not())
-            self.model.Add(sum(self.corner_vars[corner]) == 2).OnlyEnforceIf(g)
+            self.model.AddLinearExpressionInDomain(sum(self.corner_vars[corner]), corner_sum_domain)
+
         # single connected component
         def is_neighbor(cb1: CellBorder, cb2: CellBorder) -> bool:
             cb1_corners = self.cell_borders_to_corners[cb1]