New blog post: Z3 puzzle solving
parent
b1d58005c1
commit
7ab27b8c58

@ 6,6 +6,10 @@




<h1 id="header"><img src="favicon.ico" id="favicon">FliegendeWurst's corner of the WWW</h1>




Interesting tidbits:




<a href="./z3logicpuzzlesolving.html">Solving a logic puzzle using an SMT solver</a>




Check out my projects:




<ul>





@ 0,0 +1,214 @@


"""


Python program to solve a logic puzzle.


Full blog post: https://fliegendewurst.github.io/z3logicpuzzlesolving.html


Puzzle description: https://www.zeit.de/zeitmagazin/2022/32/logelei


🄯 FliegendeWurst 2022


This work is licensed under a Creative Commons Attribution 4.0 International License.


http://creativecommons.org/licenses/by/4.0/


"""




from z3 import *


import math




s = Solver()




# n*n grid


n = 6




grid = [[FreshInt() for x in range(n)] for y in range(n)]




def print_solution(m, print_grid=True):


for k in range(num_sums):


print(" " * (3*num_sums + 2), end="")


for x in range(n):


val = m[sums_v[x][k]].as_long()


if val == 1:


print(" ", end=" ")


else:


print(f"{val: >2}", end=" ")


print()


print()


print(" " * (3*num_sums + 1), end="")


print("" * (3*n))


y = 0


for row in grid:


for sum_h in sums_h[y]:


val = m[sum_h].as_long()


if val == 1:


print(" ", end=" ")


else:


print(f"{val: >2}", end=" ")


print("", end=" ")


x = 0


for cell in row:


val = m[cell].as_long()


if val == 0 or not print_grid:


val = " "


print(f"{val: >2}", end=" ")


x += 1


print()


y += 1




def distinct_if_nonzero(x):


for i in range(len(x)):


for j in range(i+1, len(x)):


cell_i = x[i]


cell_j = x[j]


s.add(If(And(cell_i != 0, cell_j != 0), cell_i != cell_j, True))




# empty grid cell = 0


# other numbers have to be in [1,2,3,4,5]


# no duplicate digits in any row / column


for row in grid:


for cell in row:


s.add(cell >= 0)


s.add(cell <= 5)


distinct_if_nonzero(row)




for column in [[grid[y][x] for y in range(n)] for x in range(n)]:


distinct_if_nonzero(column)




# each row and column has at most math.ceil(n/2) segments


# if there are less, they are indicated by 1


num_sums = math.ceil(n / 2)


sums_h = [[FreshInt() for i in range(num_sums)] for y in range(n)]


sums_v = [[FreshInt() for i in range(num_sums)] for x in range(n)]


# for each pattern of used digits in a row, determine the sums


# iterate over each row of the grid


for y in range(n):


# iterate over each binary pattern


for p in range(2**n):


# match condition of this pattern


mc = True


# will contain a list of variables for each segment


segments = []


start_next_segment = True


# iterate over each grid cell


for x in range(n):


# check that binary digit in the pattern


if (p >> x) & 1 == 1:


mc = And(mc, grid[y][x] != 0)


if start_next_segment:


segments.append([grid[y][x]])


start_next_segment = False


else:


segments[1].append(grid[y][x])


else:


mc = And(mc, grid[y][x] == 0)


start_next_segment = True


# specify sums value


for k in range(num_sums):


if k < len(segments):


off_by_one = Or(


sums_h[y][k] == sum(segments[k]) + 1,


sums_h[y][k] == sum(segments[k])  1


)


s.add(If(mc, off_by_one, True))


else:


s.add(If(mc, sums_h[y][k] == 1, True))




# for each pattern of used digits in a columns, determine the sums


for x in range(n):


for p in range(2**n):


# match condition


mc = True


segments = []


start_next_segment = True


for y in range(n):


if (p >> y) & 1 == 1:


mc = And(mc, grid[y][x] != 0)


if start_next_segment:


segments.append([grid[y][x]])


start_next_segment = False


else:


segments[1].append(grid[y][x])


else:


mc = And(mc, grid[y][x] == 0)


start_next_segment = True


# specify sums value


#print(f"{p:b}"[::1], segments)


for k in range(num_sums):


if k < len(segments):


off_by_one = Or(


sums_v[x][k] == sum(segments[k]) + 1,


sums_v[x][k] == sum(segments[k])  1


)


s.add(If(mc, off_by_one, True))


else:


s.add(If(mc, sums_v[x][k] == 1, True))




res = s.check()


print(res)




def add_spec(spec_h, spec_v):


for a, b in zip(spec_h, sums_h):


for x, y in zip(a, b):


s.add(x == y)


for a, b in zip(spec_v, sums_v):


for x, y in zip(a, b):


s.add(x == y)


spec_h = [


[2, 13, 1],


[5, 3, 6],


[8, 7, 1],


[4, 4, 1],


[5, 5, 1],


[9, 0, 1]


]




spec_v = [


[11, 1, 1],


[4, 5, 1],


[7, 7, 1],


[2, 7, 3],


[4, 4, 5],


[10, 2, 1]


]


s.push()


add_spec(spec_h, spec_v)




res = s.check()


print(res)




while res == sat:


m = s.model()


print_solution(m)


# find another solution, if possible


c = False


for row in grid:


for cell in row:


c = Or(c, cell != m[cell].as_long())


s.add(c)


res = s.check()


print("no other solutions")


s.pop()




# try to find another puzzle with a unique solution


while True:


s.push()


print("new push")


print(s.check())


m = s.model()


# condition c: keep found offbyone sums configuration


# condition c2: to ban this sums configuration


c = True


c2 = False


for l in [*sums_h, *sums_v]:


for x in l:


c = And(c, x == m[x].as_long())


c2 = Or(c2, x != m[x].as_long())


s.add(c)


# try to find another solution


c = False


for row in grid:


for cell in row:


c = Or(c, cell != m[cell].as_long())


s.add(c)


res = s.check()


print(res)


if res == unsat:


print("found another puzzle with unique solution")


print_solution(m, print_grid=False)


input("continue? [press enter]")


s.pop()


s.add(c2)


@ 2,6 +2,7 @@


<head>


<title>Raspberry Pi temperature monitoring + calendar</title>


<meta charset="utf8">


<meta name="viewport" content="width=devicewidth,initialscale=1.0"/>


<link rel="shortcut icon" href="favicon.ico">


<link rel="stylesheet" href="main.css">


</head>




Binary file not shown.
After Width:  Height:  Size: 31 KiB 
Binary file not shown.

@ 0,0 +1,261 @@


<!DOCTYPE html>


<head>


<title>Solving a logic puzzle using an SMT solver</title>


<meta charset="utf8">


<meta name="viewport" content="width=devicewidth,initialscale=1.0"/>


<link rel="shortcut icon" href="favicon.ico">


<link rel="stylesheet" href="main.css">


</head>




<body>


<h1 id="header"><img src="favicon.ico" id="favicon"/><a href="/">FliegendeWurst's corner of the WWW</a></h1>




<h2>Solving a logic puzzle using an SMT solver</h2>




<article>




In this blog post, I'll describe how to solve a logic puzzle using Z3, an automated SMT solver.




<h3>The puzzle</h3>




<p>


You are given a rectangular grid where each cell may either contain a number (between 1 and 5) or be empty.


Each number may only be used once in each row and column.


In each row, the empty cells split the numbered cells into segments.


The sums of these segments are indicated to the left of the grid.


The same applies to the columns of the grid (sums are indicated above the grid).


But there's a twist: due to a transmission error, all of the sums are off by one!


The (already solved) 4by4 grid below illustrates these constraints.


<br>




<img src="./samplepuzzle.png" alt="example puzzle" width="400px">




</p>




<p>


I originally found this puzzle in <a href="https://www.zeit.de/zeitmagazin/2022/32/logelei">an edition of the ZEIT</a>, a weekly German newspaper.


See the previous link for a more difficult puzzle. It is solvable without computer assistance, but quite tricky!


</p>




<h3>Prerequisites</h3>




To follow along, you'll first need to install <a href="https://www.python.org/">Python</a>.


Then, you need to install the <a href="https://pypi.org/project/z3solver/">Z3 Python bindings</a>.


The precise installation steps vary by operating system, check the official documentation for more details.




<h3>Defining the board</h3>




In the following, I will describe the code required to explain the puzzle to Z3.


First, we need to import the z3 Python module. To avoid prefixing every constructor with <span class="monospace">z3.</span>, we import all symbols into the local namespace. We also import the math module (we will need it later).


We also create a new Solver object for later use.


<pre>


from z3 import *


import math




s = Solver()


</pre>


Problems are specified by creating a bunch of variables (booleans, integers, ...) and constraints on these variables.


Z3 will then produce a <i>model</i> that assigns a value to each variable if the constraints are satisfiable.


Since we are interested in the values of the grid cells, we create an integer variable for each cell.


<a href="https://z3prover.github.io/api/html/z3.z3.html#FreshInt">FreshInt</a> returns a new integer variable that isn't identical to any other previously created variable.


<pre>


# n*n grid


n = 6




grid = [[FreshInt() for x in range(n)] for y in range(n)]


</pre>




<h3>Specifying the constraints</h3>




Empty grid cells will be indicated by a value of zero. All other cells need to be filled with a number between one and five.


To implement this constraint, we iterate over each row and cell of the grid and add the constraint (integer value must be at least 0 and at most 5) to the solver.


<pre>


for row in grid:


for cell in row:


s.add(cell >= 0)


s.add(cell <= 5)


</pre>




For each row/column, the numbers used must be unique.


This is modeled by pairwise inequality of the variables making up that row or column.


Of course, a value of zero (= empty grid cell) may appear more than once.




We define a function <span class="monospace">distinct_if_nonzero</span> that, given a list of variables, adds constraints to ensure that any two variables are not equal if both of them are nonzero.


This is done by supplying three parameters to the <span class="monospace">If</span> function: the condition, the constraint if the condition is true, the constraint if the condition is false.


<pre>


def distinct_if_nonzero(x):


for i in range(len(x)):


for j in range(i+1, len(x)):


cell_i = x[i]


cell_j = x[j]


s.add(If(And(cell_i != 0, cell_j != 0), cell_i != cell_j, True))


</pre>


Then we simply apply this function to each row and column of the grid.


<pre>


for row in grid:


distinct_if_nonzero(row)




for column in [[grid[y][x] for y in range(n)] for x in range(n)]:


distinct_if_nonzero(column)


</pre>




The sums indicated next to the grid are represented by integer variables.


It is quite obvious that the maximum number of segments possible in each row is achieved if every second cell is filled with a number.


As such, we only need to keep track of that many segment sums.


<pre>


num_sums = math.ceil(n / 2)


sums_h = [[FreshInt() for i in range(num_sums)] for y in range(n)]


sums_v = [[FreshInt() for i in range(num_sums)] for x in range(n)]


</pre>




Connecting these sums to the cell variables is done by considering each binary pattern <span class="monospace">p</span> of numbered / not numbered cells.


<pre>


# iterate over each row of the grid


for y in range(n):


# iterate over each binary pattern


for p in range(2**n):


# match condition of this pattern


mc = True


# will contain a list of variables for each segment


segments = []


start_next_segment = True


# iterate over each grid cell


for x in range(n):


# check that binary digit in the pattern


if (p >> x) & 1 == 1:


mc = And(mc, grid[y][x] != 0)


if start_next_segment:


segments.append([grid[y][x]])


start_next_segment = False


else:


segments[1].append(grid[y][x])


else:


mc = And(mc, grid[y][x] == 0)


start_next_segment = True


# specify sums value of each segment


for k in range(num_sums):


if k < len(segments):


off_by_one = Or(


sums_h[y][k] == sum(segments[k]) + 1,


sums_h[y][k] == sum(segments[k])  1


)


s.add(If(mc, off_by_one, True))


else:


s.add(If(mc, sums_h[y][k] == 1, True))


</pre>


The same is done for the columns of the grid. For brevity, that code is omitted from this post. The full source code is linked at the end of the article.




<h3>Finding and displaying a solution</h3>




We still need to encode the offbyone sums given in the puzzle as constraints.


This is fairly simple:


<pre>


def add_spec(spec_h, spec_v):


for a, b in zip(spec_h, sums_h):


for x, y in zip(a, b):


s.add(x == y)


for a, b in zip(spec_v, sums_v):


for x, y in zip(a, b):


s.add(x == y)


spec_h = [


[2, 13, 1],


[5, 3, 6],


[8, 7, 1],


[4, 4, 1],


[5, 5, 1],


[9, 0, 1]


]




spec_v = [


[11, 1, 1],


[4, 5, 1],


[7, 7, 1],


[2, 7, 3],


[4, 4, 5],


[10, 2, 1]


]


s.push()


add_spec(spec_h, spec_v)


</pre>


Note that we used <span class="monospace">s.push()</span> to create a nested constraint context.


Any constraints added after this call may be removed by calling <span class="monospace">s.pop()</span>.


We will make use of this later to generate new puzzles (with new offbyone sums).




<p>


Now that we have specified all of our contraints, we may ask Z3 to determine the validity of our model.


<span class="monospace">s.check()</span> may return <span class="monospace">sat</span>, <span class="monospace">unsat</span> or <span class="monospace">unknown</span>.


<span class="monospace">sat</span> indicates that the problem is <i>satisfiable</i> (there is a variable assignment that fulfills all constraints), <span class="monospace">unsat</span> indicates that no such assignment is possible.


Z3 only returns <span class="monospace">unknown</span> if it is not able to deduce whether the problem is satisfiable or not (e.g., due to incomplete theories).


</p>




<p>


The loop below uses a simple trick to enumerate all solutions to the puzzle: after one solution is found, add a constraint that at least one grid cell must be different.


</p>




<pre>


res = s.check()


print(res)




while res == sat:


m = s.model()


print_solution(m)


# find another solution, if possible


c = False


for row in grid:


for cell in row:


c = Or(c, cell != m[cell].as_long())


s.add(c)


res = s.check()


print("no other solutions")


s.pop()


</pre>




<h3>Generating puzzles with a unique solution</h3>




<p>


Generating new puzzles is surprisingly easy at this point.


It boils down to <i>not</i> constraining the offbyone sums.


Z3 will still generate a model that fits all of the puzzle rules.


To determine whether a newlyfound puzzle has a unique solution, we first need to add the new offbyone sums to Z3.


Additionally, we mandate that at least one grid cell needs to differ.


If no other solution is found, we know that the puzzle has a unique solution.


Otherwise, we add a constraint that bans this particular offbyone sums configuration (this ensures we always try new puzzles).


</p>




<pre>


# try to find another puzzle with a unique solution


while True:


s.push()


print("new push")


print(s.check())


m = s.model()


# condition c: keep found offbyone sums configuration


# condition c2: to ban this sums configuration


c = True


c2 = False


for l in [*sums_h, *sums_v]:


for x in l:


c = And(c, x == m[x].as_long())


c2 = Or(c2, x != m[x].as_long())


s.add(c)


# try to find another solution


c = False


for row in grid:


for cell in row:


c = Or(c, cell != m[cell].as_long())


s.add(c)


res = s.check()


print(res)


if res == unsat:


print("found another puzzle with unique solution")


print_solution(m, print_grid=False)


input("continue? [press enter]")


s.pop()


s.add(c2)


</pre>




<a href="./logelei_off_by_one_sums.py">Full source code</a>




<div class="entryfooter">Posted 30th November 2022</div>




</article>

Loading…
Reference in New Issue