def make_loc_vars(prefix):
lInput = list(z3.Ints(id_arr(f'{prefix}_locInput', nInput), ctx))
lPR = [(list(
z3.Ints(id_arr(f'{prefix}_locParam_{i}', comp.arity),
ctx)), z3.Int(f'{prefix}_locReturn_{i}', ctx))
for i, comp in enumerate(lib)]
lOutput = z3.Int(f'{prefix}_locOutput', ctx)
return lInput, lPR, lOutput
def calVertical(pointA, pointB, pointC):
# t = z3.Reals("t")
# x, y, z = calLineEqut(pointA, pointB)
x, y, z = z3.Ints('x y z')
formula = (pointB[0] - pointA[0]) * (x - pointC[0])
formula += (pointB[1] - pointA[1]) * (y - pointC[1])
formula += (pointB[2] - pointA[2]) * (z - pointC[2])
formula = formula == 0
cal = z3.Solver()
cal.add(formula)
# # cal.add(x==6)
perhaps_list = [
x == 0, x == factorial - 1, y == 0, y == factorial - 1, z == 0,
z == factorial - 1
]
cal.add(x >= 0, x <= (factorial - 1))
cal.add(y >= 0, y <= (factorial - 1))
cal.add(z >= 0, z <= (factorial - 1))
for i in perhaps_list:
cal.push()
cal.add(i)
if cal.check() != z3.sat:
cal.pop()
continue
m = cal.model()
result = [m[x].as_long(), m[y].as_long(), m[z].as_long()]
if result == pointC:
cal.pop()
continue
return result
return False
def solve_23_part_2(nanobots: List[Nanobot]):
print('Starting up')
origin = (0, 0, 0)
x, y, z, in_range = z3.Ints('x y z in_range')
in_range = in_range * 0
print('Vars declared')
for bot in nanobots:
in_range += z3.If(z3distance(bot.loc_tuple(), (x, y, z)) <= bot.radius, 1, 0)
print('In range calc prep done')
optimizer = z3.Optimize()
print('Created optimizer, setting max/min functions')
optimizer.maximize(in_range)
optimizer.minimize(z3distance(origin, (x, y, z)))
print('Checking optimizer')
optimizer.check()
print('Getting model')
model = optimizer.model()
print('Returning values')
origin_loc = Point3d(0, 0, 0)
found_loc = Point3d(model[x].as_long(), model[y].as_long(), model[z].as_long())
distance_to_found_loc = manhattan_distance_3d(origin_loc, found_loc)
bots_at_loc = search_point(found_loc, nanobots)
print('Distance from {} to {}: {}. Bots in range: {}'.format(origin_loc, found_loc, distance_to_found_loc, len(bots_at_loc)))
return distance_to_found_loc
def ex1a():
# path condition leading to err1: 0 < i < 10 & i < 5 & i = 2
myi, myj, myk = z3.Ints('i j k')
inp = Input([myi, myj, myk], [2, 100, 1000])
bad_pathconds = [PathCond([0 < myi, myi < 10, myi < 5, myi == 2])]
return inp, bad_pathconds
def main():
# create the variables a and b.
a, b = z3.Ints('a b')
# create the variables a' and b'
a_p, b_p = z3.Ints('a_p b_p')
# now we will check the base case for the induction
# first create a solver object.
S = z3.Solver()
# create the init predicate.
Init = z3.And(a == 0, b == 1)
# create the property
prop = a <= b
# we want to check whether Init(X) ==> prop(X) is valid.
# we do this by checking whether Not(Init(X) ==> prop(X)) is UNSAT
S.add(z3.Not(z3.Implies(Init, prop)))
if S.check() == z3.sat:
print('Base case does not hold. Property is FALSE.')
print('Counterexample: ')
m = S.model()
print('\ta =', m.eval(a))
print('\tb =', m.eval(b))
else:
print('Base case HOLDS.')
# now we will check the inductive step.
# create a new solver object.
S = z3.Solver()
R = z3.And(a_p == b, b_p == a + b)
prop = a <= b
prop_p = a_p <= b_p
# we want to check if R(X, X') && prop(X) ==> prop(X')
# we will do this by checking if the negation of the above is UNSAT
S.add(z3.Not(z3.Implies(z3.And(prop, R), prop_p)))
if S.check() == z3.sat:
print('Inductive step does not hold. Property is UNDEF.')
print('Counterexample to induction:')
m = S.model()
print('\ta =', m.eval(a))
print('\tb =', m.eval(b))
print('\ta_p =', m.eval(a_p))
print('\tb_p =', m.eval(b_p))
else:
print('Inductive step HOLDS.')
def test_variable_order(self):
# Little more complex case, to see whether ordering of variables are
# kept right.
a, b, c = z3.Ints('a b c')
formula = z3.ForAll([c, a, b], z3.And(b > a, a > c))
self.assertEqual(z3.Not(z3.And(b > a, a > c)),
z3_utils.negated_body(formula))
def GenerateVar(cls, name, **fields):
if fields:
return collections.namedtuple(
name,
fields.keys(),
)(*z3.Ints(' '.join(fields.values())))
else:
return z3.Int(name)
def ex1b():
"""
violated path conditions to err2: 0 < i < 10 & i >= 5 & i = 3
can be fixed by changing i to #3
"""
myi, myj, myk = z3.Ints('i j k')
inp = Input([myi, myj, myk], [3, 100, 1000])
bad_pathconds = [PathCond([0 < myi, myi < 10, myi < 5, myi == 3])]
return inp, bad_pathconds
def ex3a():
y0, y1, y2, y3, y4, y5 = z3.Ints('y0 y1 y2 y3 y4 y5')
inp = Input([y0, y1, y2, y3, y4, y5], [0, 1, 2, 5, 4, 5])
bad_pathconds = [
PathCond([y0 == y2]),
PathCond([y0 != y2, y1 == y3]),
PathCond([y0 != y2, y1 != y3, y2 == y4]),
PathCond([y0 != y2, y1 != y3, y2 != y4, y3 == y5])
]
return inp, bad_pathconds
def hard():
o = z3.Optimize()
x, y, z = z3.Ints("x y z")
for p, d in t:
o.add_soft(
z3.If(x > p[0], x - p[0], p[0] - x) +
z3.If(y > p[1], y - p[1], p[1] - y) +
z3.If(z > p[2], z - p[2], p[2] - z) <= d)
o.check()
m = o.model()
print(m.eval(x + y + z))
def best_point(nanos):
x, y, z, cost = z3.Ints("x y z cost")
cost = cost * 0
for c, r in nanos:
cost += z3.If(z3dist((x, y, z), c) <= r, 1, 0)
o = z3.Optimize()
o.maximize(cost)
o.minimize(z3dist((0, 0, 0), (x, y, z)))
o.check()
model = o.model()
return distance(
(0, 0, 0),
(model[x].as_long(), model[y].as_long(), model[z].as_long()))
def construnct_env(self, ides):
if isinstance(ides, Token):
ides = [ides]
else:
# convert ides to strings
ides = list(map((lambda x: x.value), ides.children))
# construct z3 symbols for all the ides
env_str = ' '.join(ides)
ide_symols = z3.Ints(env_str)
# construct the environment
for (i, ide) in enumerate(ides):
self.env[ide] = ide_symols[i]
def ex1c():
"""
violated path conditions to err1 + a fake one:
- 0 < i < 10 & i >= 5 & i = 3
- j >= 0
can be fixed by changing i to !3 and j to < 0
"""
myi, myj, myk = z3.Ints('i j k')
inp = Input([myi, myj, myk], [3, 100, 1000])
bad_pathconds = [
PathCond([0 < myi, myi < 10, myi < 5, myi == 3]),
PathCond([myj >= 0])
]
return inp, bad_pathconds
def main():
b, c = z3.Ints("b c")
a = z3.Array("a", z3.IntSort(), z3.IntSort())
f = z3.Function("f", z3.IntSort(), z3.IntSort())
solver = z3.Solver()
solver.add(c == b + z3.IntVal(2))
lhs = f(z3.Store(a, b, 3)[c - 2])
rhs = f(c - b + 1)
solver.add(lhs != rhs)
res = solver.check()
if res == z3.sat:
print("sat")
elif res == z3.unsat:
print("unsat")
else:
print("unknown")
def main():
b, c = z3.Ints('b c')
a = z3.Array('a', z3.IntSort(), z3.IntSort())
f = z3.Function('f', z3.IntSort(), z3.IntSort())
solver = z3.Solver()
solver.add(c == b + z3.IntVal(2))
lhs = f(z3.Store(a, b, 3)[c - 2])
rhs = f(c - b + 1)
solver.add(lhs <> rhs)
res = solver.check()
if res == z3.sat:
print 'sat'
elif res == z3.unsat:
print 'unsat'
else:
print 'unknown'
def vc_2_z3(vc: imp_ast.Exp):
if isinstance(vc, imp_ast.ExpNum):
return vc.num
if isinstance(vc, imp_ast.ExpVar):
return z3.Int(vc.var)
# TODO: your Exercise 5 code here, convert the generated
# vc to z3 constraints format,
# also do not forget to deal with ExpUni, Z3 is often
# able to handle formulas involving quantifiers. like:
# ForAll([x, y], f(x, y) == 0)
if isinstance(vc, imp_ast.ExpBop):
left = vc_2_z3(vc.left)
right = vc_2_z3(vc.right)
if vc.bop == imp_ast.BOp.ADD:
return left + right
elif vc.bop == imp_ast.BOp.MIN:
return left - right
elif vc.bop == imp_ast.BOp.MUL:
return left * right
elif vc.bop == imp_ast.BOp.DIV:
return left / right
elif vc.bop == imp_ast.BOp.EQ:
return left == right
elif vc.bop == imp_ast.BOp.NE:
return left != right
elif vc.bop == imp_ast.BOp.GT:
return left > right
elif vc.bop == imp_ast.BOp.GE:
return left >= right
elif vc.bop == imp_ast.BOp.LT:
return left < right
elif vc.bop == imp_ast.BOp.LE:
return left <= right
elif vc.bop == imp_ast.BOp.IM:
return z3.Implies(left, right)
elif vc.bop == imp_ast.BOp.AND:
return z3.And(left, right)
elif vc.bop == imp_ast.BOp.OR:
return z3.Or(left, right)
if isinstance(vc, imp_ast.ExpNeg):
return z3.Not(vc_2_z3(vc.exp))
if isinstance(vc, imp_ast.ExpUni):
exp = vc_2_z3(vc.exp)
return z3.ForAll(z3.Ints(list(vc.vars_set)), exp)
def getLinePonit(A, B):
x, y, z = z3.Ints('x y z')
cal = z3.Solver()
formula1 = (x - A[0]) * (B[1] - A[1]) == (y - A[1]) * (B[0] - A[0])
formula2 = (x - A[0]) * (B[2] - A[2]) == (z - A[2]) * (B[0] - A[0])
formula3 = (z - A[2]) * (B[1] - A[1]) == (y - A[1]) * (B[2] - A[2])
if A[0] - B[0] != 0 and A[1] - B[1] != 0 and A[2] - B[2] != 0:
cal.add(formula1)
cal.add(formula2)
cal.add(formula3)
if A[0] - B[0] == 0:
cal.add(x == A[0])
cal.add(formula3)
if A[1] - B[1] == 0:
cal.add(y == A[1])
cal.add(formula2)
if A[2] - B[2] == 0:
cal.add(z == A[2])
cal.add(formula1)
if A[0] - B[0] != 0:
while True:
tmp = random.randint(10, 200)
if tmp != A[0] and tmp != B[0]:
break
cal.add(x == tmp)
elif A[1] - B[1] != 0:
while True:
tmp = random.randint(10, 200)
if tmp != A[1] and tmp != B[1]:
break
cal.add(y == tmp)
elif A[2] - B[2] != 0:
while True:
tmp = random.randint(10, 200)
if tmp != A[2] and tmp != B[2]:
break
cal.add(z == tmp)
else:
return False
if cal.check() != z3.sat:
# print(cal)
return False
m = cal.model()
return [m[x].as_long(), m[y].as_long(), m[z].as_long()]
def list_of_length(length,
src,
trg,
with_data=True,
loc_prefix='a',
data_prefix='d'):
"""Return expression for a sequence of `length` pointers from `src` to `trg`.
Whether or not data allocation is included is controlled by the
`with_data` flag (True by default).
>>> x, y = sl.list.locs('x y'); list_of_length(2, x, y, loc_prefix = 'z_')
sl.sepcon(sl.sepcon(sl.list.next(x, z_1),
sl.list.next(z_1, y)),
sl.sepcon(sl.list.data(x, d0),
sl.list.data(z_1, d1)))
>>> list_of_length(2, x, y, loc_prefix = 'z_', with_data = False)
sl.sepcon(sl.list.next(x, z_1), sl.list.next(z_1, y))
"""
if length == 0:
return sl.list.eq(src, trg)
loc_fmt = loc_prefix + '{}'
tmp_locs = sl.list.locs(*map(loc_fmt.format, range(1, length)))
locs = [src] + tmp_locs + [trg]
ptr_ends = list(utils.consecutive_pairs(locs))
assert (len(ptr_ends) == length)
if length > 1:
expr = sl.sepcon(*(sl.list.next(*pair) for pair in ptr_ends))
else:
expr = sl.list.next(*ptr_ends[0])
if with_data:
data_fmt = data_prefix + '{}'
tmp_data = z3.Ints(' '.join(map(data_fmt.format, range(length))))
assert (len(tmp_data) == len(locs) - 1)
data_ptrs = zip(locs[:-1], tmp_data)
if length > 1:
data_expr = sl.sepcon(*(sl.list.data(*ptr) for ptr in data_ptrs))
else:
data_expr = sl.list.data(*next(data_ptrs))
expr = sl.sepcon(expr, data_expr)
return expr
def part2_z3(rules, my, others):
ok_others = []
for t in others:
if not invalid_fields(rules, t):
ok_others.append(t)
s = z3.Solver()
idxs = z3.Ints([f"idx_{i}" for i in range(len(rules))])
for i in idxs:
s.add(i >= 0, i < len(rules))
s.add(z3.Distinct(idxs))
cols = zip(*ok_others)
for i, col in enumerate(cols):
for (_, a_r, b_r), idx in zip(rules, idxs):
c = all(x in a_r or x in b_r for x in col)
if not c:
s.add(idx != i)
assert s.check() == z3.sat, "f**k"
m = s.model()
assignments = [(name, m[idx].as_long()) for (name, _, _), idx in zip(rules, idxs)]
r = 1
for name, column in assignments:
if "departure" not in name:
continue
r *= my[column]
return r
def euler185():
import z3
x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16 = z3.Ints(
"x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16")
#x1,x2,x3,x4,x5 = z3.Ints("x1 x2 x3 x4 x5")
variables = [
x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16
]
#variables = [x1,x2,x3,x4,x5]
def none_correct(arr):
return reduce(z3.And,
[arr[i] != variables[i] for i in range(len(arr))])
def one_correct(arr):
return reduce(z3.Or, [
reduce(z3.And, [
arr[j] != variables[j] if i != j else arr[j] == variables[j]
for j in range(len(arr))
]) for i in range(len(arr))
])
def two_correct(arr):
out = []
for i in range(len(arr)):
for j in range(len(arr)):
if i < j:
out.append(
reduce(z3.And, [
arr[k] == variables[k] if
(k == i or k == j) else arr[k] != variables[k]
for k in range(len(arr))
]))
return reduce(z3.Or, out)
def three_correct(arr):
out = []
for i in range(len(arr)):
for j in range(len(arr)):
for k in range(len(arr)):
if i < j < k:
out.append(
reduce(z3.And, [
arr[l] == variables[l] if
(l == i or l == j
or l == k) else arr[l] != variables[l]
for l in range(len(arr))
]))
return reduce(z3.Or, out)
s = []
for i in variables:
s.append(0 <= i)
s.append(i <= 9)
# s.append(z3.simplify(two_correct([int(i) for i in "90342"])))
# s.append(z3.simplify(none_correct([int(i) for i in "70794"])))
# s.append(z3.simplify(two_correct([int(i) for i in "39458"])))
# s.append(z3.simplify(one_correct([int(i) for i in "34109"])))
# s.append(z3.simplify(two_correct([int(i) for i in "51545"])))
# s.append(z3.simplify(one_correct([int(i) for i in "12531"])))
# print z3.solve(reduce(z3.And,s))
"""
5616185650518293 ;2 correct
3847439647293047 ;1 correct
5855462940810587 ;3 correct
9742855507068353 ;3 correct
4296849643607543 ;3 correct
3174248439465858 ;1 correct
4513559094146117 ;2 correct
7890971548908067 ;3 correct
8157356344118483 ;1 correct
2615250744386899 ;2 correct
8690095851526254 ;3 correct
6375711915077050 ;1 correct
6913859173121360 ;1 correct
6442889055042768 ;2 correct
2321386104303845 ;0 correct
2326509471271448 ;2 correct
5251583379644322 ;2 correct
1748270476758276 ;3 correct
4895722652190306 ;1 correct
3041631117224635 ;3 correct
1841236454324589 ;3 correct
2659862637316867 ;2 correct
"""
guesses = "5616185650518293 3847439647293047 5855462940810587 9742855507068353 4296849643607543 3174248439465858 4513559094146117 7890971548908067 8157356344118483 2615250744386899 8690095851526254 6375711915077050 6913859173121360 6442889055042768 2321386104303845 2326509471271448 5251583379644322 1748270476758276 4895722652190306 3041631117224635 1841236454324589 2659862637316867".split(
" ")
guesses = zip(
guesses,
[2, 1, 3, 3, 3, 1, 2, 3, 1, 2, 3, 1, 1, 2, 0, 2, 2, 3, 1, 3, 3, 2])
for (i, j) in guesses:
print i
if j == 0:
s.append(z3.simplify(none_correct([int(k) for k in i])))
elif j == 1:
s.append(z3.simplify(one_correct([int(k) for k in i])))
elif j == 2:
s.append(z3.simplify(two_correct([int(k) for k in i])))
else:
s.append(z3.simplify(three_correct([int(k) for k in i])))
return sorted(z3.solve(reduce(z3.And, s)))
bots.append(NanoBot(pos, r))
bots.sort()
# ------------------------------------------------
# part 1
# ------------------------------------------------
in_range = [bots[-1].in_range(b) for b in bots]
print(sum(in_range))
print('')
# ------------------------------------------------
# part 2
# ------------------------------------------------
zabs = lambda x: z3.If(x >= 0, x, -x)
x, y, z = z3.Ints('x y z')
o = z3.Optimize()
in_range = []
in_range_count = z3.Int('in_range_count')
for i, b in enumerate(bots):
in_range_f = z3.If(
zabs(b.pos[0] - x) + zabs(b.pos[1] - y) + zabs(b.pos[2] - z) <=
b.radius, 1, 0)
in_range_var = z3.Int('in_range_%04d' % i)
in_range.append(in_range_var)
o.add(in_range_var == in_range_f)
o.add(in_range_count == sum(in_range))
h1 = o.maximize(in_range_count)
h2 = o.minimize(zabs(x) + zabs(y) + zabs(z))
import z3
x, y, z, n = z3.Ints("x y z n")
e1 = y * z - z3.Int("18") * x - z3.Int("12") * y + z3.Int("2") * z == z3.Int(
"6")
e2 = (z * z) - z3.Int("12") * y + z3.Int("12") == z3.Int("6") * z
e3 = z3.Int("6") * n + z3.Int("6") == z
d1 = z == z3.Int("6") * n + z3.Int("6")
d2 = y == z3.Int("3") * n * n + z3.Int("3") * n + z3.Int("1")
d3 = x == n * n * n
e123 = z3.And(e1, e2, e3)
#z3.prove(z3.Implies(e123, d1))
#z3.prove(z3.Implies(e123, d2))
#z3.prove(z3.Implies(e123, d3))
from collections import namedtuple
import z3
# Figure 2
SymbolicPacket = namedtuple(
'SymbolicPacket', ['dstIp', 'srcIp', 'dstPort', 'srcPort', 'protocol'])
dstIp, srcIp, dstPort, srcPort, protocol = z3.Ints(
'dstIp srcIp dstPort srcPort protocol')
def z3Range(exp, low, high):
return z3.And(low <= exp, exp < high)
# (1)
symbolic_packet = SymbolicPacket(
z3Range(dstIp, 0, 2**32),
z3Range(srcIp, 0, 2**32),
z3Range(dstPort, 0, 2**16),
z3Range(srcPort, 0, 2**16),
z3Range(protocol, 0, 2**8)
)
def ex2a():
a0, a1, a2, a3, a4 = z3.Ints('a0 a1 a2 a3 a4')
inp = Input([a0, a1, a2, a3, a4], [0, 1, 2, 3, -1])
bad_pathconds = [PathCond([a0 != -1, a1 != -1, a2 != -1, a3 != -1])]
return inp, bad_pathconds
import z3
import logging
logger = logging.getLogger('optimize.py')
logging.basicConfig()
logger.setLevel(logging.INFO)
def hook():
#for debugging
logger.warning("HOOKING IPYTHON")
import IPython
IPython.embed()
s1 = z3.Solver()
x, y = z3.Ints('x y')
s1.add(x>y)
s1.add(x==4)
s = z3.Optimize()
s.add(*s1.assertions())
m = s.maximize(y)
s.check()
logger.info("max: %s", m)
hook()
# feel the need to specify apparently.
def POPCNT(bits, **kwargs):
# This is a variable-width version of the classic 0x5555/0x3333/0x0f0f/0xffff
# etc algorithm, to sum N bits in O(log2 N) steps
shift = 1
while shift < bits.size():
mask = sum(1 << x for x in range(bits.size()) if not x & shift)
bits = (bits & mask) + ((bits >> shift) & mask)
shift *= 2
return bits & ((1 << shift) - 1)
# Create z3 lambdas for comparison operations
_a, _b = z3.Ints('a b')
_MM_CMPINT_EQ = z3.Lambda([_a, _b], _a == _b) # 0
_MM_CMPINT_LT = z3.Lambda([_a, _b], _a < _b) # 1
_MM_CMPINT_LE = z3.Lambda([_a, _b], _a <= _b) # 2
_MM_CMPINT_FALSE = z3.Lambda([_a, _b], z3.BoolVal(False)) # 3
_MM_CMPINT_NE = z3.Lambda([_a, _b], _a != _b) # 4
_MM_CMPINT_NLT = z3.Lambda([_a, _b], _a >= _b) # 5
_MM_CMPINT_NLE = z3.Lambda([_a, _b], _a > _b) # 6
_MM_CMPINT_TRUE = z3.Lambda([_a, _b], z3.BoolVal(True)) # 7
# Zero/sign extension: just mark these values as signed/unsigned, the users
# of the values will use this later when the size of the target value is known
def ZeroExtend(v, **kwargs):
def part_2():
points, rs = load_input()
# just some playing with z3
# a = z3.Real('a')
# b = z3.Real('b')
# s = z3.Solver()
# s.add(a + b == 5)
# s.add(a - 2*b == 3)
# s.add(a - 2*b == 3)
# check_result = s.check()
# m = s.model()
# print(m[a])
# print(m[b])
# a = z3.Real('a')
# b = z3.Real('b')
# c = z3.Real('c')
# d = z3.Real('d')
# s = z3.Optimize()
# s.add()
# s.add(a <= 5)
# s.add(b <= 10)
# s.add(b >= c)
# s.add(a >= d)
# obj = s.maximize(a + b + c + d)
# while s.check() == z3.sat:
# m = s.model()
# print(m[a])
# print(m[b])
# print(m[c])
# print(m[d])
# print(obj.value())
# check_res = s.check()
# m = s.model()
# print(m[a])
# print(m[b])
# print(m[c])
# print(m[d])
# print(obj.value())
# x, y = z3.Ints('x y')
# opt = z3.Optimize()
# opt.set(priority='pareto')
# opt.add(x + y == 10, x >= 0, y >= 0)
# mx = opt.maximize(x)
# my = opt.maximize(y)
# while opt.check() == z3.sat:
# print(mx.value(), my.value())
# pass
# reaches = np.zeros((np.max(points[:, 0]), np.max(points[:, 1]), np.max(points[:, 2])))
# grid_indices = np.array(list(np.ndindex(reaches.shape)))
# for point, r in zip(points, rs):
# dists = spatial.distance.cdist(point[np.newaxis, :], grid_indices, metric='cityblock')
# reach = np.where(dists <= r)
# reached_points = grid_indices[reach[1], :][:, 0], grid_indices[reach[1], :][:, 1], grid_indices[reach[1], :][:, 2]
# reaches[reached_points] += 1
#
# best_point = np.unravel_index(np.argmax(reaches), reaches.shape)
# distance = spatial.distance.cityblock([0, 0, 0], best_point)
# for point, r in zip(points, rs):
# range_set = set()
# for p0 in range(point[0] - r, point[0] + r + 1):
# remain_dist = r - abs(p0 - point[0])
# for p1 in range(point[1] - remain_dist, point[1] + remain_dist + 1):
# remain_dist = r - (abs(p0 - point[0]) + abs(p1 - point[1]))
# for p2 in range(point[2] - remain_dist, point[2] + remain_dist + 1):
# range_set.add((p0, p1, p2))
# points_in_range.append(range_set)
# dense_dists = spatial.distance.pdist(points, metric='cityblock')
# distances = spatial.distance.squareform(dense_dists)
# sum_ranges = rs + rs[:, np.newaxis] - np.eye(rs.shape[0]) * rs * 2
# share_point = distances - sum_ranges
# share_point_dense = spatial.distance.squareform(share_point)
#
# print('dont share any point', np.sum(share_point_dense >= 0))
# print('share some points', np.sum(share_point_dense < 0))
# mean for prunning estimate
# centroid = np.mean(points, axis=0).astype(np.int32)
# in_range = spatial.distance.cdist(centroid[np.newaxis, :], points, metric='cityblock') <= rs
# np.sum(in_range)
def z3abs(x):
# z3.fpAbs is not working on integers, somehow, this works
return z3.If(x >= 0, x, -x)
coords = z3.Ints('x y z')
s = z3.Optimize()
in_ranges = z3.Ints(' '.join('p' + str(i) for i in range(len(points))))
for i, (point, r) in enumerate(zip(points, rs)):
# coords_diff = [z3abs(j - int(k)) for j, k in zip(coords, point)] # casting from numpy type to pure python
coords_diff = [z3abs(j - int(k)) for j, k in zip(coords, point)
] # casting from numpy type to pure python
manhattan_dist = z3.Sum(coords_diff)
s.add(z3.If(manhattan_dist <= int(r), 1, 0) == in_ranges[i])
dist_from_zero = z3.Int('dist')
# s.add(dist_from_zero == z3.Sum([z3abs(i) for i in coords]))
s.add(dist_from_zero == z3.Sum([z3abs(i) for i in coords]))
s.maximize(z3.Sum(in_ranges))
s.minimize(dist_from_zero)
res = s.check()
m = s.model()
print([m[i] for i in coords], m[dist_from_zero])
def newInts(quantity): inames = " ".join( map(lambda _: get_new_var(prefix="i") ,range(0,quantity)) ) return z3.Ints(inames)
import string
import numpy as np
import z3
dimension = 4
v = z3.Ints(' '.join(string.ascii_lowercase[:dimension**2]))
v = np.asarray(v).reshape(dimension, dimension)
s = z3.Solver()
for xij in v.flatten():
s.add(z3.And(0 <= xij, xij <= 9))
answer = z3.Int("answer")
s.add(z3.And(answer >= 0, answer <= 9 * dimension**2))
for i in range(dimension):
s.add(z3.Sum(v[i, :dimension].tolist()) == answer)
s.add(z3.Sum(v[:dimension, i].tolist()) == answer)
s.add(z3.Sum(v.diagonal().tolist()) == answer)
s.add(z3.Sum(np.fliplr(v).diagonal().tolist()) == answer)
count = 0
while s.check() == z3.sat:
m = s.model()
count += 1
s.add(z3.Or([f() != m[f] for f in m.decls() if f.arity() == 0]))
print(count)
def test_forall(self):
a, b = z3.Ints('a b')
formula = z3.ForAll([a, b], a > b)
self.assertEqual(z3.Not(a > b), z3_utils.negated_body(formula))
