def geometry_free_solve_(ddn1, ddn2, ws, station_data, sta1, sta2, prn1, prn2, ticks):
lambda_1 = lambda_1s[prn1[0]]
lambda_2 = lambda_2s[prn1[0]]
# Φ_i - R_i = B_i + err with B_i = b_i + λ_1*N_1 - λ_2*N_2
B_i = bias(tec.geometry_free)
sol = Optimize()
# sol = Solver()
errs = Reals('err_11 err_12 err_21 err_22')
n1s = Ints('n1_11 n1_12 n1_21 n1_22')
n2s = Ints('n2_11 n2_12 n2_21 n2_22')
sol.add(n1s[0] - n1s[1] - n1s[2] + n1s[3] == ddn1)
sol.add(n2s[0] - n2s[1] - n2s[2] + n2s[3] == ddn2)
for i, (sta, prn) in enumerate(product([sta1, sta2], [prn1, prn2])):
sol.add(n1s[i] - n2s[i] == ws[i])
B_i_samples = []
for tick in ticks:
B_i_samples.append( B_i(station_data[sta][prn][tick])[0] )
B_i_avg = numpy.mean(B_i_samples)
# B_i_avg = B_i_samples[0]
print(B_i_avg, numpy.std(B_i_samples))
sol.add(lambda_1 * ToReal(n1s[i]) - lambda_2 * ToReal(n2s[i]) + errs[i] > B_i_avg)
sol.add(lambda_1 * ToReal(n1s[i]) - lambda_2 * ToReal(n2s[i]) - errs[i] < B_i_avg)
"""
sol.add(errs[0] < .9)
sol.add(errs[1] < .9)
sol.add(errs[2] < .9)
sol.add(errs[3] < .9)
"""
#sol.add(errs[0] + errs[1] + errs[2] + errs[3] < 17)
objective = sol.minimize(errs[0] + errs[1] + errs[2] + errs[3])
if sol.check() != sat:
return None
sol.lower(objective)
if sol.check() != sat:
return None
# sol.add(errs[0] + errs[1] + errs[2] + errs[3] < 2)
# can't do L2 norm with z3, L1 will have to do...
# sol.(errs[0] + errs[1] + errs[2] + errs[3])
return (
[sol.model()[n1s[i]].as_long() for i in range(4)],
[sol.model()[n2s[i]].as_long() for i in range(4)],
[frac_to_float(sol.model()[errs[i]]) for i in range(4)],
)
def maximize_distance(bots):
o = Optimize()
z3_abs = lambda k: If(k >= 0, k, -k)
z3_in_ranges = [Int('in_range_of_bot_' + str(i)) for i in xrange(len(bots))]
z3_x, z3_y, z3_z = (Int('x'), Int('y'), Int('z'))
z3_sum = Int('sum')
z3_dist = Int('dist')
for i, (x, y, z, r) in enumerate(bots):
o.add(z3_in_ranges[i] == If(distance((z3_x, z3_y, z3_z), (x, y, z), z3_abs) <= r, 1, 0))
o.add(z3_sum == sum(z3_in_ranges))
o.add(z3_dist == distance((z3_x, z3_y, z3_z), (0, 0, 0), z3_abs))
h1, h2 = o.maximize(z3_sum), o.minimize(z3_dist)
o.check()
# o.lower(h1), o.upper(h1)
lower, upper = o.lower(h2), o.upper(h2)
# o.model()[z3_x], o.model()[z3_y], o.model()[z3_z]
if str(lower) != str(upper): raise Exception('lower ({}) != upper ({})'.format(lower, upper))
return (lower, upper)
def dd_solve_(dd, vr1s1, vr1s2, vr2s1, vr2s2, wavelength, ionosphere=False):
sol = Optimize()
r1s1, r1s2, r2s1, r2s2 = Ints('r1s1 r1s2 r2s1 r2s2')
# err = Real('err')
err1, err2, err3, err4 = Reals('err1 err2 err3 err4')
# sol.add(err > 0)
if ionosphere:
ion = Real('ion')
sol.add(ion > 0)
sol.add(ion < 25)
else:
ion = 0
sol.add(r1s1 - r1s2 - r2s1 + r2s2 == dd)
sol.add(ToReal(r1s1)*wavelength + err1 > vr1s1 - ion)
sol.add(ToReal(r1s1)*wavelength - err1 < vr1s1 - ion)
sol.add(ToReal(r1s2)*wavelength + err2 > vr1s2 - ion)
sol.add(ToReal(r1s2)*wavelength - err2 < vr1s2 - ion)
sol.add(ToReal(r2s1)*wavelength + err3 > vr2s1 - ion)
sol.add(ToReal(r2s1)*wavelength - err3 < vr2s1 - ion)
sol.add(ToReal(r2s2)*wavelength + err4 > vr2s2 - ion)
sol.add(ToReal(r2s2)*wavelength - err4 < vr2s2 - ion)
objective = sol.minimize(err1 + err2 + err3 + err4)
if sol.check() != sat:
return None
sol.lower(objective)
if sol.check() != sat:
return None
return (
[sol.model()[r].as_long() for r in [r1s1, r1s2, r2s1, r2s2]],
[frac_to_float(sol.model()[err]) for err in [err1, err2, err3, err4]],
frac_to_float(sol.model()[ion]) if ionosphere else 0
)
def find_optimal_space(nanobots):
(x, y, z) = (Int('x'), Int('y'), Int('z'))
in_ranges = [
Int('in_range_{}'.format(i)) for i in range(len(nanobots))
]
range_count = Int('sum')
optimiser = Optimize()
for i, nanobot in enumerate(nanobots):
optimiser.add(in_ranges[i] == If(zabs(x - nanobot.x) + zabs(y - nanobot.y) + zabs(z - nanobot.z) <= nanobot.r, 1, 0))
optimiser.add(range_count == sum(in_ranges))
dist_from_zero = Int('dist')
optimiser.add(dist_from_zero == zabs(x) + zabs(y) + zabs(z))
optimiser.maximize(range_count)
result = optimiser.minimize(dist_from_zero)
optimiser.check()
return optimiser.lower(result)
PbGe([(is_bomb[r + dr][c + dc], 1) for (dr, dc) in rectangle(h, w)], 1)
for (r, c) in rectangle(H - h + 1, W - w + 1)
]
# Clauses
s = Optimize()
s.add(at_least_one_bomb_for_each_rectangle(2, 3))
s.add(at_least_one_bomb_for_each_rectangle(3, 2))
# Objective
num_bombs = Sum([If(is_bomb[r][c], 1, 0) for (r, c) in rectangle(H, W)])
min_bombs = s.minimize(num_bombs)
if s.check() == sat:
assert s.lower(min_bombs) == 6
print("The minimum number of bombs satisfying the constraints == %s." %
s.lower(min_bombs))
print(diagram(s.model()))
else:
print("Z3 failed to find a solution.")
# http://forum.stratego.com/topic/1134-stratego-quizz-and-training-forum/?p=11661
# http://forum.stratego.com/topic/1146-stratego-quizz-and-training-forum-answers/?p=11813
# http://forum.stratego.com/topic/1134-stratego-quizz-and-training-forum/?p=441745
print(
"The minimum number of bombs on a Stratego setup area such that each 2x3, 3x2 and 1x6 rectangle has at least one bomb."
)
# Extra clause
s.add(at_least_one_bomb_for_each_rectangle(1, 6))
print('Part 1:', inRange)
def abs(x):
return If(x >= 0, x, -x)
def manhattan3d(start, finish):
sX, sY, sZ = start
fX, fY, fZ = finish
return abs(sX - fX) + abs(sY - fY) + abs(sZ - fZ)
x = Int('x')
y = Int('y')
z = Int('z')
counts = [Int('count_' + str(i)) for i in range(len(bots))]
numInRange = Int('num')
distanceFromOrigin = Int('dist')
o = Optimize()
o.add([counts[i] == bots[i].canReachPoint(x, y, z) for i in range(len(bots))])
o.add(numInRange == sum(counts))
o.add(distanceFromOrigin == abs(x) + abs(y) + abs(z))
o.maximize(numInRange)
heuristic = o.minimize(distanceFromOrigin)
o.check()
print("Part 2:", o.lower(heuristic))
with open('../input/23.txt') as f:
nanobots = [list(map(int, re.findall(r'-?\d+', line))) for line in f]
x, y, z, r = max(nanobots, key=lambda x: x[-1])
print(sum(
abs(x - a) + abs(y - b) + abs(z - c) <= r for a, b, c, _ in nanobots))
from z3 import Int, If, Optimize
def Abs(x):
return If(x >= 0, x, -x)
def Dist(x, y, z, a, b, c):
return Abs(x - a) + Abs(y - b) + Abs(z - c)
X = x, y, z = Int('x'), Int('y'), Int('z')
cost = Int('cost')
constraint = x * 0
for *Y, r in nanobots:
constraint += If(Dist(*X, *Y) <= r, 1, 0)
opt = Optimize()
opt.add(cost == constraint)
h1 = opt.maximize(cost)
h2 = opt.minimize(Dist(*(0, 0, 0), *X))
opt.check()
print(opt.lower(h2))
scout_moves_from = np.array([
list(
chain(zip(repeat(r), L_scout_moves_from(r, c)),
zip(repeat(r), R_scout_moves_from(r, c)),
zip(D_scout_moves_from(r, c), repeat(c)),
zip(U_scout_moves_from(r, c), repeat(c)))) for (r, c) in board()
]).reshape(H, W)
each_square_occupied_or_threatened_by_scout = [
Or(is_scout[r][c],
Or([is_scout[dr][dc] for (dr, dc) in scout_moves_from[r, c]]))
for (r, c) in board() if (r, c) not in lakes()
]
# Clauses
s = Optimize()
s.add(no_scouts_in_lakes)
s.add(each_square_occupied_or_threatened_by_scout)
# Objective
num_scouts = Sum([If(is_scout[r][c], 1, 0) for (r, c) in board()])
min_scouts = s.minimize(num_scouts)
if s.check() == sat:
assert s.lower(min_scouts) == 8
print("The minimum number of scouts satisfying the constraints == %s." %
s.lower(min_scouts))
print(diagram(s.model()))
else:
print("Z3 failed to find a solution.")
import re
from z3 import Int, If, Optimize
def Abs(x):
return If(x >= 0, x, -x)
def Dist(x, y, z, a, b, c):
return Abs(x-a) + Abs(y-b) + Abs(z-c)
with open('../inputs/23.txt') as f:
bots = [list(map(int, re.findall(r'-?\d+', l))) for l in f]
mx, my, mz, mr = max(bots, key=lambda x: x[-1])
print('Day 23 part 1: ' + str(sum(abs(bx - mx) + abs(by - my) + abs(bz - mz) < mr for bx, by, bz, br in bots)))
X = x, y, z = Int('x'), Int('y'), Int('z')
cost = Int('cost')
constraint = x * 0
for *Y, r in bots:
constraint += If(Dist(*X, *Y) <= r, 1, 0)
opt = Optimize()
opt.add(cost == constraint)
h1 = opt.maximize(cost)
h2 = opt.minimize(Dist(*(0, 0, 0), *X))
opt.check()
print('Day 23 part 2: ' + str(opt.lower(h2)))
