def bounds(self):
"""Default bounds method. This is guaranteed to work, and should be fast
enough with small number of shapes. Subclasses with large numbers of
shapes may see performance benefits from overriding this method.
"""
if self._bounds is None:
left_edge = Min(shape.bounds.left_edge for shape in self.shapes)
right_edge = Max(shape.bounds.right_edge for shape in self.shapes)
top_edge = Min(shape.bounds.top_edge for shape in self.shapes)
bottom_edge = Max(shape.bounds.bottom_edge for shape in self.shapes)
self._bounds = Bounds(left_edge, right_edge, top_edge, bottom_edge)
return self._bounds
def feed_data(self, X, Y):
formula = []
for x, y in zip(X, Y):
x_formula = []
for i, (weight, bias) in self.net_formula.items():
if i == 0:
x_hidden = []
for r, w_r in enumerate(weight):
tmp = Plus([Plus(Times(w, Real(float(x[c]))), bias[r]) for c, w in enumerate(w_r)])
if self.activation == 'relu':
x_hidden.append(Max(tmp, Real(0)))
else:
x_hidden.append(tmp)
"""node_output = []
for c, w in enumerate(w_r):
var = Plus(Times(w, Real(float(x[c]))), bias[r])
exp_3 = Pow(var, Real(3))
#exp_5 = Pow(var, Real(5))
sen_2 = Times(Real(0.25), var)
sen_3 = Times(Real(0.02), exp_3)
#sen_4 = Times(Real(0.002), exp_5)
node_output.append(Plus(Real(0.5), sen_2, sen_3))#, sen_4))
matrix_addition = Plus(node_output[i] for i in range(len(node_output)))
x_hidden.append(matrix_addition)"""
x = x_hidden
else:
x_hidden = []
for r, w_r in enumerate(weight):
tmp = Plus([Plus(Times(w, x[c]), bias[r]) for c, w in enumerate(w_r)])
if self.activation == 'relu' and i < len(self.net_formula) - 1:
x_hidden.append(Max(tmp, Real(0)))
else:
x_hidden.append(tmp)
"""node_output = []
for c, w in enumerate(w_r):
var = Plus(Times(w, x[c]), bias[r])
exp_3 = Pow(var, Real(3))
#exp_5 = Pow(var, Real(5))
sen_2 = Times(Real(0.25), var)
sen_3 = Times(Real(0.02), exp_3)
#sen_4 = Times(Real(0.002), exp_5)
node_output.append(Plus(Real(0.5), sen_2, sen_3)) #, sen_4))
matrix_addition = Plus(node_output[i] for i in range(len(node_output)))
x_hidden.append(matrix_addition)"""
x = x_hidden
## Add activation function
if np.argmax(y) == 0:
x_formula.append(GE(x[0], x[1]))
else:
x_formula.append(GE(x[1], x[0]))
return And(x_formula)
def convert(self, abstract=False):
for i in range(self.nnet.inputSize):
x = Symbol("x%d" % i, REAL)
self.input_vars.append(x)
for i in range(self.nnet.outputSize):
y = Symbol("y%d" % i, REAL)
self.output_vars.append(y)
# for i,v in enumerate(self.input_vars):
# # normalized
# m = self.nnet.mins[i]
# l = GE(self.input_vars[i],
# Real((m - self.nnet.means[i])/self.nnet.ranges[i]))
# self.formulae.append(l)
# # normalized
# m = self.nnet.maxes[i]
# l = LE(self.input_vars[i],
# Real((m - self.nnet.means[i])/self.nnet.ranges[i]))
# self.formulae.append(l)
prev_layer_result = self.input_vars.copy()
layer_result = []
zero = Real(0)
self.relus_level.append(set())
for l in range(self.nnet.numLayers - 1):
self.relus_level.append(set())
for ls in range(self.nnet.layerSizes[l + 1]):
r = self.dot(self.nnet.weights[l][ls], prev_layer_result)
r = Plus(r, Real(float(self.nnet.biases[l][ls])))
relu_in = FreshSymbol(REAL)
self.formulae.append(Equals(relu_in, r))
if abstract:
relu_out = FreshSymbol(REAL)
r = relu_out
self.relus.append((relu_out, relu_in))
self.relus_level[l + 1].add((relu_out, relu_in))
else:
r = Max(relu_in, zero)
layer_result.append(r)
prev_layer_result = layer_result.copy()
layer_result.clear()
for i, y in enumerate(self.output_vars):
o = self.dot(self.nnet.weights[-1][i], prev_layer_result)
o = Plus(o, Real(float(self.nnet.biases[-1][i])))
# # undo normalization
# o = Times(o, Real(self.nnet.ranges[-1]))
# o = Plus(o, Real(self.nnet.means[-1]))
self.formulae.append(Equals(y, o))
self.parse_violation(self.violation_path)
def bounds(self):
xs = (self.pt1.x, self.pt2.x)
ys = (self.pt1.y, self.pt2.y)
left_edge, right_edge = Min(*xs), Max(*xs)
top_edge, bottom_edge = Min(*ys), Max(*ys)
return Bounds(left_edge, right_edge, top_edge, bottom_edge)
def init(self):
self.solver.add_assertion(And(self.formulae))
self.sat_checker.add_assertion(And(self.formulae))
for r1, r2 in self.relus:
self.sat_checker.add_assertion(Equals(r1, Max(r2, Real(0))))
def processor(config_file_name):
var_str = []
coefficients = []
constrnt_mins = []
constrnt_maxes = []
constraint_terms = []
num_vars = []
num_expr = []
terms = []
eqn_mins = []
eqn_maxes = []
readfile(config_file_name, var_str, coefficients, constrnt_mins,
constrnt_maxes, constraint_terms, num_vars, num_expr, eqn_mins,
eqn_maxes)
nvars = num_vars[0]
nexpr = num_expr[0]
symbols = [Symbol(X, REAL) for X in sorted(var_str)]
symbols.append(Symbol("c", REAL))
for x in itertools.combinations_with_replacement(symbols, 2):
terms.append(x)
for i in range(0, len(terms), 1):
terms[i] = list(terms[i])
for i in range(0, len(terms), 1):
if (Symbol("c", REAL) in terms[i]):
terms[i].remove(Symbol("c", REAL))
# [('x1', 'x1'), ('x1', 'x2'), ('x1', 'c'), ('x2', 'x2'), ('x2', 'c'), ('c', 'c')]
sorted(terms, key=lambda elem: elem[0])
#print(terms)
variables = set(symbols)
d = []
j = 0
for CONSTRAINT in constraint_terms:
C = []
for i in range(0, len(CONSTRAINT), 1):
if (symbols[i] == Symbol("c", REAL)):
C.append(Real(CONSTRAINT[i]))
else:
C.append(Times(Real(CONSTRAINT[i]), symbols[i]))
C = Plus(C)
d.append(
And(GE(C, Real(constrnt_mins[j])), LT(C, Real(constrnt_maxes[j]))))
j = j + 1
domains = And(d)
eqns = []
i = 0
for expr in coefficients:
cur = []
j = 0
for term in expr:
if (len(terms[j]) == 2):
cur.append(Times(Real(float(term)), Times(terms[j])))
elif (Symbol("c", REAL) in terms[j]):
cur.append(Real(float(term)))
else:
cur.append(Times(Real(float(term)), terms[j][0]))
j = j + 1
cur = Plus(cur)
eqns.append(cur)
i = i + 1
formulas = []
models = []
satisfiable = bool(True)
i = 0
for eqn in eqns:
p0 = And(domains, GE(Min(eqn), Real(float(eqn_mins[i]))))
p1 = And(domains, LT(Max(eqn), Real(float(eqn_maxes[i]))))
formulas.append(p0)
formulas.append(p1)
models.append(get_model(p0))
models.append(get_model(p1))
i = i + 1
out_str = ""
i = 0
j = 0
postfix = ["min satisfiability", "max satisfiability"]
pat = re.compile(r'\d+/\d+')
for model in models:
print("\tModel {} {}: ".format(str(i), postfix[j % 2]))
#formula_str = model.print#str(formulas[i].serialize())
cur_str = pysmt.shortcuts.simplify(formulas[j]).serialize().replace(
"&", "\n\t\t\t&")
cur_str = re.sub(
pat, lambda match: "{0}".format(
str(
float(str(match.group()).split("/")[0]) / float(
str(match.group()).split("/")[1]))), cur_str)
if model:
print("\t\tSerialization of the formula:")
print("\t\t\t" + cur_str)
#temp_strs = formula_str.split("&")
#for k in range(1,len(temp_strs)):
# temp_strs[k] = "& " + temp_strs[k]
#formula_strs = []
#for s in temp_strs:
# t = s.split(" + ")
# ts = []
# ts.append(t[0])
# for k in range(1,len(t)):
# ts.append(" + " + t[k])
# new_t = [a+b+c+d for a,b,c,d in zip(*[iter(ts)]*4)]
# final = ""
# for k in range(len(ts) - (len(ts) % 4), len(ts),1):
# final = final + ts[k]
# new_t.append(final)
# formula_strs.append(new_t)
#for s in formula_strs:
# print("\t\t\t%s" % s)
print("\t\tSolution: ")
model_str = str(model)
model_str = model_str.replace("\n", "\n\t\t\t")
print("\t\t\t%s" % model_str)
else:
print("\t\tSerialization of the formula: ")
print("\t\t\t%s" % cur_str)
print("\t\tNo solution found")
satisfiable = False
if j % 2 == 1:
i = i + 1
j = j + 1
print("\tResult: ")
if (satisfiable):
print("\t\tThe problem is satisfiable using the solutions given.")
else:
print("\t\tThe problem is not satisfiable")
return satisfiable
def main():
# Given variables =================================================
I = int(input())
J = int(input())
K = int(input())
T_MAX = int(input())
array_1D = Symbol("1D", ArrayType(INT, INT))
array_2D = Symbol("2D", ArrayType(INT, ArrayType(INT, INT)))
# T[j][k]
# Earliest start execution time of service k on server j
'''
T = Symbol("T", ArrayType(INT, ArrayType(INT, INT)))
for j in range(0, J):
T_row = array_1D
k = 0
for val in [int(x) for x in input().split()]:
# print(symbol_name("T", j, k), " -> ", str(val))
T_row = T_row.Store(Int(k), Int(val))
k = k + 1
T = T.Store(Int(j), T_row)
'''
T = Symbol("T", ArrayType(INT, ArrayType(INT, ArrayType(INT, INT))))
for i in range(0, I):
T_mat = array_2D
for j in range(0, J):
T_mat_row = array_1D
k = 0
for val in [int(x) for x in input().split()]:
# print(symbol_name("T", j, k), " -> ", str(val))
T_mat_row = T_mat_row.Store(Int(k), Int(val))
k = k + 1
T_mat = T_mat.Store(Int(j), T_mat_row)
T = T.Store(Int(i), T_mat)
# C[j][k]
# The computation time of service k on server j
C = Symbol("C", ArrayType(INT, ArrayType(INT, INT)))
for j in range(0, J):
C_row = array_1D
k = 0
for val in [int(x) for x in input().split()]:
# print(symbol_name("C", j, k), " -> ", str(val))
C_row = C_row.Store(Int(k), Int(val))
k = k + 1
C = C.Store(Int(j), C_row)
# Tv[j][j'][k]
# the transmission time (delivery) of service k from server j to server j'
Tv = Symbol("Tv", ArrayType(INT, ArrayType(INT, ArrayType(INT, INT))))
for j in range(0, J):
Tv_mat = array_2D
for jj in range(0, J):
Tv_mat_row = array_1D
k = 0
for val in [int(x) for x in input().split()]:
# print(symbol_name("Tv", j, jj, k), " -> ", str(val))
Tv_mat_row = Tv_mat_row.Store(Int(k), Int(val))
k = k + 1
Tv_mat = Tv_mat.Store(Int(jj), Tv_mat_row)
Tv = Tv.Store(Int(j), Tv_mat)
# D[i][k]
# Vehicle i's reception deadline for service k
# valid[i][k] == -1 iff vehicle i doesn't demand service k
D = Symbol("D", ArrayType(INT, ArrayType(INT, INT)))
valid = []
for i in range(0, I):
D_row = array_1D
k = 0
valid.append([])
for val in [int(x) for x in input().split()]:
# print(symbol_name("D", i, k), " -> ", str(val))
D_row = D_row.Store(Int(k), Int(val))
k = k + 1
if (val == -1): valid[-1].append(False)
else: valid[-1].append(True)
D = D.Store(Int(i), D_row)
# F[i][k]
# The required freshness of vehicle i for service k
F = Symbol("F", ArrayType(INT, ArrayType(INT, INT)))
for i in range(0, I):
F_row = array_1D
k = 0
for val in [int(x) for x in input().split()]:
# print(symbol_name("F", i, k), " -> ", str(val))
F_row = F_row.Store(Int(k), Int(val))
k = k + 1
F = F.Store(Int(i), F_row)
# R[i][j][t]
# if vehicle i is in the communication of server j at time t
'''
R = Symbol("R", ArrayType(INT, ArrayType(INT, ArrayType(INT, INT))))
for i in range(0, I):
R_mat = array_2D
for j in range(0, J):
R_mat_row = array_1D
t = 0
for val in [int(x) for x in input().split()]:
# print(symbol_name("R", i, j, t), " -> ", str(val))
R_mat_row = R_mat_row.Store(Int(t), Int(val))
t = t + 1
R_mat = R_mat.Store(Int(j), R_mat_row)
R = R.Store(Int(i), R_mat)
'''
R = Symbol("R", ArrayType(INT, ArrayType(INT, INT)))
for i in range(0, I):
R_mat = array_1D
R_it = input().split(',')
t = 0
for r in R_it:
cum_t = int(r.split()[0])
cur_j = int(r.split()[1])
for _ in range(cum_t):
R_mat = R_mat.Store(Int(t), Int(cur_j))
t += 1
R = R.Store(Int(i), R_mat)
# M[k]
# the required memory size (delivery) of service k
M = [int(x) for x in input().split()]
# M_bar[j]
# the memory size of server j
M_bar = [int(x) for x in input().split()]
start_time = time.time()
# Decision variables =================================================
class DV: # Decision variable
def __init__(self, i, k):
self.i_int = i
self.k_int = k
self.i = Int(i)
self.k = Int(k)
self.e = Symbol(symbol_name("e", i, k), INT)
self.d = Symbol(symbol_name("d", i, k), INT)
self.s = Symbol(symbol_name("s", i, k), INT)
self.t = Symbol(symbol_name("t", i, k), INT)
DV_set = set()
for i in range(0, I):
for k in range(0, K):
if valid[i][k]:
DV_set.add(DV(i, k))
# Constraints =================================================
# Variable domain
domain = And(
[And(GE(dv.e, Int(0)), LT(dv.e, Int(J))) for dv in DV_set] +
[And(GE(dv.d, Int(0)), LT(dv.d, Int(J))) for dv in DV_set] +
[And(GE(dv.s, Int(0)), LT(dv.s, Int(T_MAX))) for dv in DV_set] +
[And(GE(dv.t, Int(0)), LT(dv.t, Int(T_MAX))) for dv in DV_set])
# Execution constraint
eq1 = And([
Or(dv1.s + C.Select(dv1.e).Select(dv1.k) <= dv2.s,
dv1.s >= dv2.s + C.Select(dv2.e).Select(dv2.k),
And(dv1.k.Equals(dv2.k), dv1.s.Equals(dv2.s)))
for (dv1, dv2) in itertools.combinations(DV_set, 2)
])
# Timing constraint
#eq2 = And([T.Select(dv.e).Select(dv.k) <= dv.s for dv in DV_set])
eq2 = And(
[T.Select(dv.i).Select(dv.e).Select(dv.k) <= dv.s for dv in DV_set])
eq3 = And([
dv.s + C.Select(dv.e).Select(dv.k) +
Tv.Select(dv.e).Select(dv.d).Select(dv.k) <= dv.t for dv in DV_set
])
eq4 = And([dv.t <= D.Select(dv.i).Select(dv.k) for dv in DV_set])
eq5 = And([dv.t <= dv.s + F.Select(dv.i).Select(dv.k) for dv in DV_set])
#eq3_1 = And([Tv.Select(dv.e).Select(dv.d).Select(dv.k) >= 0])
# Pinpoint constraint
#eq6 = And([R.Select(dv.i).Select(dv.d).Select(dv.t).Equals(Int(1)) for dv in DV_set])
eq6 = And([R.Select(dv.i).Select(dv.t).Equals(dv.d) for dv in DV_set])
# Memory constraint
eq7 = And(Bool(True))
memory_sums = [] # for objective function
for t in range(0, T_MAX):
memory_sums.append(Int(0))
for j in range(0, J):
memory_sum = Int(0) # for a single server at time t
for dv in DV_set:
indicator = Symbol(
symbol_name("ind", j, t, dv.i_int, dv.k_int), INT)
existence_formula = And(
dv.d.Equals(j), t >= dv.s + C.Select(dv.e).Select(dv.k) +
Tv.Select(dv.e).Select(dv.d).Select(dv.k), t < dv.t)
# print(existence_formula.Iff(indicator.Equals(1)))
eq7 = eq7.And(Not(existence_formula).Iff(indicator.Equals(0)))
eq7 = eq7.And(existence_formula.Iff(indicator.Equals(1)))
memory_sum += M[dv.k_int] * indicator
eq7 = eq7.And(memory_sum <= M_bar[j])
memory_sums[-1] += memory_sum
# print(memory_sum)
# print(eq7)
# print(memory_sums[0])
# memory_sums[t] == the sum of memory usage of all server at time t
# # Decision version
# # Objective constraint
# obj = Max(memory_sums) <= 4
# model = get_model(And(domain, eq1, eq2, eq3, eq4, eq5, eq6, eq7, obj))
# print(model)
# Optimization version
# Minimize the maximum memory used
constraints = And(domain, eq1, eq2, eq3, eq4, eq5, eq6, eq7)
if (not is_sat(And(constraints,
Max(memory_sums) <= sum(M_bar)),
solver_name="z3")):
print("Unsat")
else:
if (is_sat(And(constraints, Max(memory_sums) <= 0), solver_name="z3")):
print(f"Objective value = 0")
#print(get_model(And(constraints, Max(memory_sums) <= 0)))
else:
l = 1
r = sum(M_bar) + 1
while l < r:
# print(f"{l}, {r}")
m = int((l + r) / 2)
if is_sat(And(constraints,
Max(memory_sums) <= m),
solver_name="z3"):
# print(m)
r = m
else:
l = m + 1
print(f"Objective value = {l}")
#print(get_model(And(constraints, Max(memory_sums) <= m)))
# print(is_sat(And(domain, eq1, eq2, eq3, eq4, eq5, eq6, eq7, obj)))
running_time = time.time() - start_time
outfile = open("time.out", "a")
outfile.write(f"{running_time}")
outfile.write("\n")