How to solve this exclusion/inclusion problem with z3py? - z3py

Question

Thanks to community help I have come up with this code:
from z3 import *
Color, (Red, Green, Blue) = EnumSort('Color', ('Red', 'Green', 'Blue'))
Size, (Big, Medium, Small) = EnumSort('Size', ('Big', 'Medium', 'Small'))
h1c, h2c, h3c = Consts('h1c h2c h3c', Color)
h1s, h2s, h3s = Consts('h1s h2s h3s', Size)
s = Solver()
myvars = [h1c, h2c, h3c, h1s, h2s, h3s]
s.add(Distinct([h1c, h2c, h3c]))
s.add(Distinct([h1s, h2s, h3s]))
s.add(h3s == Medium)
s.add(h3c == Red)
res = s.check()
n = 1
while (res == sat):
print("%d. " % n),
m = s.model()
block = []
for var in myvars:
v = m.evaluate(var, model_completion=True)
print("%s = %-5s " % (var, v)),
block.append(var != v)
s.add(Or(block))
n = n + 1
res = s.check()
This solves the problem, where only one house can be, for example, Medium size and Red color. And other combinations stay as variations.
However what I also want is a condition, that the House why is, for Example, Green is Small. Not pointing initially to particular house. This would exclude all variations where Green or Small is not combined (Green can not be Medium, and Small can not be Red, etc.)... But also keep the distinct so, for example, only one house can be Green and Small. So later if I say house 1 is Green or Small, then for house 1 is this one variation and no other houses (variations) can be Green or Small.
Example after 1st condition (Green is Small):
h1 = Green + Small
h2 = Green + Small
h3 = Green + Small
h1 = Red + Medium
h1 = Red + Big
h2 = Red + Medium
h2 = Red + Big
h3 = Red + Medium
h3 = Red + Big
h1 = Blue + Medium
h1 = Blue + Big
h2 = Blue + Medium
h2 = Blue + Big
h3 = Blue + Medium
h3 = Blue + Big ( I might missed something)
Example after 2nd condition (House 1 is Small/Green):
h1 = Green + Small
h2 = Red + Medium
h2 = Red + Big
h3 = Red + Medium
h3 = Red + Big
h2 = Blue + Medium
h2 = Blue + Big
h3 = Blue + Medium
h3 = Blue + Big ( I might missed something)
I have been looking into Functions and children variable, but see no way how to compare Any variable in stack. I think the code needs to be totally reorganized?

Answer 1

#JohanC's answer is just fine, but I do agree with the OP that these sorts of constraints can get really out of hand and impossible to manage if you don't approach them in a systematic way. I found that creating dictionaries and your own abstractions can really help. Note that this isn't really z3/z3py specific, but in general for programming. For instance, here's how I would code your problem:
from z3 import *
Color, (Red, Green, Blue) = EnumSort('Color', ('Red', 'Green', 'Blue'))
Size, (Big, Medium, Small) = EnumSort('Size', ('Big', 'Medium', 'Small'))
# Create a house and store properties in a dictionary
def mkHouse(name):
return { 'name' : name
, 'color': Const(name + "_color", Color)
, 'size' : Const(name + "_size", Size)
}
allHouses = [mkHouse(n) for n in ["house1", "house2", "house3"]]
s = Solver ()
# Assert sizes and colors are different
s.add(Distinct([h['color'] for h in allHouses]))
s.add(Distinct([h['size'] for h in allHouses]))
def forallHouses(pred):
cond = True
for house in allHouses:
cond = And(cond, pred(house))
s.add(cond)
# Assert that Green house is small. Note the implication.
forallHouses(lambda h: Implies(h['color'] == Green, h['size'] == Small))
# Assert that If a house is Red, then it cannot be Medium
forallHouses(lambda h: Implies(h['color'] == Red, h['size'] != Medium))
# Collect the solutions:
res = s.check()
n = 1
while (res == sat):
print("Solution %d: " % n)
m = s.model()
block = []
for house in allHouses:
hcolor = m.evaluate(house['color'], model_completion=True)
hsize = m.evaluate(house['size'], model_completion=True)
print(" %-5s = %-5s %-5s" % (house['name'], hcolor, hsize))
block.append(Or(house['color'] != hcolor, house['size'] != hsize))
s.add(Or(block))
n = n + 1
res = s.check()
Note the use of a dictionary to keep track of the name, size, and color of the house. You can add new properties as you wish, and everything stays local for easy manipulation and extraction later on. In particular, the function forallHouses captures the essence of what you're trying to say: You want to say something about each individual house, and it captures this via a lambda-function.
In the above example, I asserted the Green house is Small and Red house is not Medium. (This implies the Red house must be big, something z3 discovers for us.) When I run it, I get:
Solution 1:
house1 = Blue Medium
house2 = Green Small
house3 = Red Big
Solution 2:
house1 = Green Small
house2 = Red Big
house3 = Blue Medium
Solution 3:
house1 = Green Small
house2 = Blue Medium
house3 = Red Big
Solution 4:
house1 = Red Big
house2 = Blue Medium
house3 = Green Small
Solution 5:
house1 = Red Big
house2 = Green Small
house3 = Blue Medium
Solution 6:
house1 = Blue Medium
house2 = Red Big
house3 = Green Small
Which I believe is in line with what you are trying to achieve. Hopefully, you can start from this skeleton and turn it into something that you can use as you model more complicated constraints.

Answer 2

One way or another you'd need to add a condition:
s.add(Or(And(h1c == Green, h1s == Small),
And(h2c == Green, h2s == Small),
And(h3c == Green, h3s == Small)))
Everything can be written a bit more flexible with arrays:
from z3 import EnumSort, Consts, Solver, Distinct, Or, And, sat
Color, (Red, Green, Blue) = EnumSort('Color', ('Red', 'Green', 'Blue'))
Size, (Big, Medium, Small) = EnumSort('Size', ('Big', 'Medium', 'Small'))
hc = Consts('h1c h2c h3c', Color)
hs = Consts('h1s h2s h3s', Size)
s = Solver()
s.add(Distinct(hc))
s.add(Distinct(hs))
s.add(Or([And(hci == Green, hsi == Small) for hci, hsi in zip(hc, hs)]))
res = s.check()
n = 1
while (res == sat):
print(f"{n:-2d}.", end=" ")
m = s.model()
block = []
for i, (hci, hsi) in enumerate (zip(hc, hs), start=1):
hci_v = m.evaluate(hci, model_completion=True)
hsi_v = m.evaluate(hsi, model_completion=True)
print(f'{f"h{i}:{hci_v}+{hsi_v}":<15}', end="")
block.append(hci != hci_v)
block.append(hsi != hsi_v)
print()
s.add(Or(block))
n += 1
res = s.check()
Result:
1. h1:Blue+Big h2:Green+Small h3:Red+Medium
2. h1:Green+Small h2:Red+Medium h3:Blue+Big
3. h1:Red+Medium h2:Blue+Big h3:Green+Small
4. h1:Red+Big h2:Blue+Medium h3:Green+Small
5. h1:Blue+Big h2:Red+Medium h3:Green+Small
6. h1:Blue+Medium h2:Red+Big h3:Green+Small
7. h1:Blue+Medium h2:Green+Small h3:Red+Big
8. h1:Red+Big h2:Green+Small h3:Blue+Medium
9. h1:Red+Medium h2:Green+Small h3:Blue+Big
10. h1:Green+Small h2:Blue+Medium h3:Red+Big
11. h1:Green+Small h2:Blue+Big h3:Red+Medium
12. h1:Green+Small h2:Red+Big h3:Blue+Medium
PS: An approach that simplifies the condition that the small house is green, is to change the representation. Instead of representing the color and the size for each of the houses, one could represent the house number for each of the colors and each of the sizes. This will need additional conditions that each of the colors should be either 1,2 or 3. And the same condition for the sizes:
from z3 import Ints, Solver, Distinct, Or, And, sat
Red, Green, Blue = Ints('Red Green Blue')
Big, Medium, Small = Ints('Big Medium Small')
colors = [Red, Green, Blue]
sizes = [Big, Medium, Small]
s = Solver()
s.add(Distinct(colors))
s.add(Distinct(sizes))
s.add(And([Or([color == i for i in (1, 2, 3)]) for color in colors]))
s.add(And([Or([size == i for i in (1, 2, 3)]) for size in sizes]))
s.add(Green == Small)
res = s.check()
n = 1
while (res == sat):
print(f"{n:-2d}.", end=" ")
m = s.model()
block = []
for x in colors + sizes:
x_v = m.evaluate(x, model_completion=True).as_long()
print(f"{x}:h{x_v}", end=" ")
block.append(x != x_v)
print()
s.add(Or(block))
n += 1
res = s.check()
Result:
1. Red:h3 Green:h2 Blue:h1 Big:h3 Medium:h1 Small:h2
2. Red:h2 Green:h3 Blue:h1 Big:h2 Medium:h1 Small:h3
3. Red:h2 Green:h3 Blue:h1 Big:h1 Medium:h2 Small:h3
4. Red:h1 Green:h2 Blue:h3 Big:h1 Medium:h3 Small:h2
5. Red:h3 Green:h2 Blue:h1 Big:h1 Medium:h3 Small:h2
6. Red:h1 Green:h3 Blue:h2 Big:h1 Medium:h2 Small:h3
7. Red:h3 Green:h1 Blue:h2 Big:h3 Medium:h2 Small:h1
8. Red:h3 Green:h1 Blue:h2 Big:h2 Medium:h3 Small:h1
9. Red:h1 Green:h3 Blue:h2 Big:h2 Medium:h1 Small:h3
10. Red:h1 Green:h2 Blue:h3 Big:h3 Medium:h1 Small:h2
11. Red:h2 Green:h1 Blue:h3 Big:h2 Medium:h3 Small:h1
12. Red:h2 Green:h1 Blue:h3 Big:h3 Medium:h2 Small:h1
If necessary, the output could be reformatted to the same format as the first solution. Whether one solution is "less workaround" or "clearer" or "easier to maintain" seems a very subjective question. Converting a problem into a format for a SAT/SMT solver is always kind of tricky.