def find_hl(data, domain, active_indices, solver): # Constants n_r = len(domain.real_vars) real_features = [[row[v] for v in domain.real_vars] for row, _ in data] labels = [row[1] for row in data] # Variables a_r = [smt.Symbol("a_r[{}]".format(r), REAL) for r in range(n_r)] b = smt.Symbol("b", REAL) # Constraints for i in active_indices: x_r, label = real_features[i], labels[i] sum_coefficients = smt.Plus( [a_r[r] * smt.Real(x_r[r]) for r in range(n_r)]) if label: solver.add_assertion(sum_coefficients + DELTA <= b) else: solver.add_assertion(sum_coefficients - DELTA > b) if not solver.solve(): return None model = solver.get_model() x_vars = [domain.get_symbol(domain.real_vars[r]) for r in range(n_r)] return smt.Plus([model.get_value(a_r[r]) * x_vars[r] for r in range(n_r)]) <= model.get_value(b)
def generate_half_space_sample(domain, real_count): samples = [get_sample(domain) for _ in range(real_count)] coefficients, offset = Learner.fit_hyperplane(domain, samples) coefficients = [smt.Real(float(coefficients[i][0])) * domain.get_symbol(domain.real_vars[i]) for i in range(real_count)] if random.random() < 0.5: return smt.Plus(*coefficients) <= offset else: return smt.Plus(*coefficients) >= offset
def ast_to_smt(self, node): """ :type node: Node """ def convert_children(number=None): if number is not None and len(node.children) != number: raise Exception( "The number of children ({}) differed from {}".format( len(node.children), number)) return [self.ast_to_smt(child) for child in node.children] if node.name == "ite": return smt.Ite(*convert_children(3)) elif node.name == "~": return smt.Not(*convert_children(1)) elif node.name == "^": return smt.Pow(*convert_children(2)) elif node.name == "&": return smt.And(*convert_children()) elif node.name == "|": return smt.Or(*convert_children()) elif node.name == "*": return smt.Times(*convert_children()) elif node.name == "+": return smt.Plus(*convert_children()) elif node.name == "-": return smt.Minus(*convert_children(2)) elif node.name == "<=": return smt.LE(*convert_children(2)) elif node.name == ">=": return smt.GE(*convert_children(2)) elif node.name == "<": return smt.LT(*convert_children(2)) elif node.name == ">": return smt.GT(*convert_children(2)) elif node.name == "=": return smt.Equals(*convert_children(2)) elif node.name == "const": c_type, c_value = [child.name for child in node.children] if c_type == "bool": return smt.Bool(bool(c_value)) elif c_type == "real": return smt.Real(float(c_value)) else: raise Exception("Unknown constant type {}".format(c_type)) elif node.name == "var": v_type, v_name = [child.name for child in node.children] if v_type == "bool": v_smt_type = smt.BOOL elif v_type == "real": v_smt_type = smt.REAL else: raise Exception("Unknown variable type {}".format(v_type)) return smt.Symbol(v_name, v_smt_type) else: raise RuntimeError("Unrecognized node type '{}'".format(node.name))
def _exp_to_smt(self, expression): if isinstance(expression, sympy.Add): return smt.Plus([self._exp_to_smt(arg) for arg in expression.args]) elif isinstance(expression, sympy.Mul): return smt.Times(*[self._exp_to_smt(arg) for arg in expression.args]) elif isinstance(expression, sympy.Symbol): return smt.Symbol(str(expression), INT) try: expression = int(expression) return smt.Int(expression) except ValueError: pass raise RuntimeError("Could not parse {} of type {}".format(expression, type(expression)))
def dual_paths_distinct(n): booleans = [] # ["A{}".format(i) for i in range(n)] domain = Domain.make(booleans, ["x{}".format(i) for i in range(n)], real_bounds=(0, 1)) bool_vars = domain.get_bool_symbols() real_vars = domain.get_real_symbols() terms = [] for i in range(n): v1, v2 = random.sample(real_vars, 2) terms.append(v1 * random.random() <= v2 * random.random()) paths = [] for i in range(n): paths.append(smt.Ite(smt.And(*random.sample(bool_vars + terms, n)), smt.Real(i), smt.Real(0))) return Density(domain, domain.get_bounds(), smt.Plus(*paths))
def _test_to_smt(self, operator): operator = operator.to_canonical() # FIXME Integer rounding only applicable if x >= 0 def to_symbol(s): return smt.Symbol(s, typename=smt.types.INT) import math items = [smt.Times(smt.Int(int(math.floor(v))), to_symbol(k)) for k, v in operator.lhs.items()] lhs = smt.Plus([smt.Int(0)] + items) rhs = smt.Int(int(math.floor(operator.rhs))) assert operator.symbol == "<=" return smt.LE(lhs, rhs)
def affine(self, a): """ return some positive rescaling of the affine expression s.t. the rescaled expression has integer coefficients safe, since positive rescaling preserves all of a >= 0, a > 0, and a == 0 """ # find the lcm of the offset denominator # and all coefficient denominators mult = a.offset.denominator for t in a.terms: mult = _lcm(mult, t.coeff.denominator) # now, we can produce an integral affine equation, # by rescaling through with `mult` a = a * Fraction(mult) # Finally, convert this to an SMT formula assert a.offset.denominator == 1 f = SMT.Int(a.offset.numerator) for t in a.terms: assert t.coeff.denominator == 1 sym = self._ctxt.get(t.var) assert sym is not None, f"expected variable name '{t.var}'" term = SMT.Times(SMT.Int(t.coeff.numerator), sym) f = SMT.Plus(f, term) return f
def walk_plus(self, args): return smt.Plus(*self.walk_smt_multiple(args))
def balancer_flow_formula(junctions, width, length): formula = [] belts = [[ Belt(s.Symbol(f'b{i}[{x}].rho', t.REAL), s.Symbol(f'b{i}[{x}].v', t.REAL)) for x in range(length + 1) ] for i in range(width)] for beltway in belts: for belt in beltway: formula.extend(domain(belt)) if not s.is_sat(s.And(formula)): raise Exception('Domain is not SAT :/') # Balancing rules. junctions_by_x = [[] for x in range(length + 1)] for (x, y1, y2) in junctions: junctions_by_x[x].append((y1, y2)) inn = x - 1 out = x input_rho = s.Plus(belts[y1][inn].rho, belts[y2][inn].rho) # We want to put half of the input on each output. half_input = s.Div(input_rho, s.Real(2)) # If output velocity is less than the half_input that we would like to # assign to it, we've filled it. Velocity is a hard limit, because it's out # of influence of this splitter. We'll set the output density to 1 in that # case. Aside: The flux is the min of that and the velocity, so if # out-velocity is the limiting factor, it won't change the flux calculation # to just assign rho_out = v_out. # # Now, the excess that we couldn't assign has to go somewhere: (1) to the # other output belt; if that's full, (2) feed back up the chain by reducing # input velocities. excess_from_1 = s.Max(s.Real(0), s.Minus(half_input, belts[y1][out].v)) excess_from_2 = s.Max(s.Real(0), s.Minus(half_input, belts[y2][out].v)) # This formula is most accurate for assignment > velocity (density will # equal 1), but it doesn't change the flux calculation just toset rho to # the velocity when velocity limits flow. (So you should be able to replace # the Ite by v_out and be OK.) formula.append( s.Equals( belts[y1][out].rho, s.Ite(half_input + excess_from_2 > belts[y1][out].v, s.Real(1), half_input + excess_from_2))) formula.append( s.Equals( belts[y2][out].rho, s.Ite(half_input + excess_from_1 > belts[y2][out].v, s.Real(1), half_input + excess_from_1))) output_v = s.Plus(belts[y1][out].v, belts[y2][out].v) half_output = s.Div(output_v, s.Real(2)) unused_density_from_1 = s.Max(s.Real(0), s.Minus(half_output, belts[y1][inn].rho)) unused_density_from_2 = s.Max(s.Real(0), s.Minus(half_output, belts[y2][inn].rho)) formula.append( s.Equals( belts[y1][inn].v, s.Ite(half_output + unused_density_from_2 > belts[y1][inn].rho, s.Real(1), half_output + unused_density_from_2))) formula.append( s.Equals( belts[y2][inn].v, s.Ite(half_output + unused_density_from_1 > belts[y2][inn].rho, s.Real(1), half_output + unused_density_from_1))) # Conservation of flux at each junction. input_flux = s.Plus(belts[y1][inn].flux, belts[y2][inn].flux) output_flux = s.Plus(belts[y1][out].flux, belts[y2][out].flux) formula.append(s.Equals(input_flux, output_flux)) # Any belts not involved in a junction are pass-throughs. Their successive # values must remain equal. thru_belts = [ list( set(range(width)) - {y1 for y1, y2 in junctions_by_x[x]} - {y2 for y1, y2 in junctions_by_x[x]}) for x in range(length + 1) ] for x, thru in enumerate(thru_belts[1:]): for y in thru: formula.append(s.Equals(belts[y][x].rho, belts[y][x + 1].rho)) formula.append(s.Equals(belts[y][x].v, belts[y][x + 1].v)) return formula, belts
def prove_properties(junctions): width = max(max(y1 for _, y1, _ in junctions), max(y2 for _, _, y2 in junctions)) + 1 length = max(x for x, _, _ in junctions) formula, belts = balancer_flow_formula(junctions, width, length) supply = s.Plus(beltway[0].rho for beltway in belts) demand = s.Plus(beltway[-1].v for beltway in belts) max_theoretical_throughput = s.Min(supply, demand) actual_throughput = s.Plus(beltway[-1].flux for beltway in belts) fully_balanced_output = [] max_flux = s.Max(b[-1].flux for b in belts) for i, b1 in enumerate(belts): fully_balanced_output.append( s.Or(s.Equals(b1[-1].flux, max_flux), s.Equals(b1[-1].flux, b1[-1].v))) fully_balanced_output = s.And(fully_balanced_output) fully_balanced_input = [] max_flux = s.Max(b[0].flux for b in belts) for i, b1 in enumerate(belts): fully_balanced_input.append( s.Or(s.Equals(b1[0].flux, max_flux), s.Equals(b1[0].flux, b1[0].rho))) fully_balanced_input = s.And(fully_balanced_input) with s.Solver() as solver: solver.add_assertion(s.And(formula)) solver.push() solver.add_assertion( s.Not(s.Equals(max_theoretical_throughput, actual_throughput))) if not solver.solve(): print("It's throughput-unlimited!") else: print("It's throughput-limited; here's an example:") m = solver.get_model() inputs = tuple(m.get_py_value(beltway[0].rho) for beltway in belts) outputs = tuple(m.get_py_value(beltway[-1].v) for beltway in belts) print(f'Input lane densities: ({", ".join(map(str, inputs))})') print(f'Output lane velocities: ({", ".join(map(str, outputs))})') check_balancer_flow(junctions, inputs, outputs) solver.pop() solver.push() solver.add_assertion(s.Not(fully_balanced_input)) if not solver.solve(): print("It's input-balanced!") else: print("It's input-imbalanced; here's an example:") m = solver.get_model() inputs = tuple(m.get_py_value(beltway[0].rho) for beltway in belts) outputs = tuple(m.get_py_value(beltway[-1].v) for beltway in belts) print(f'Input lane densities: ({", ".join(map(str, inputs))})') print(f'Output lane velocities: ({", ".join(map(str, outputs))})') check_balancer_flow(junctions, inputs, outputs) solver.pop() solver.push() solver.add_assertion(s.Not(fully_balanced_output)) if solver.solve: print("It's output-balanced!") else: print("It's output-imbalanced; here's an example:") m = solver.get_model() inputs = tuple(m.get_py_value(beltway[0].rho) for beltway in belts) outputs = tuple(m.get_py_value(beltway[-1].v) for beltway in belts) print(f'Input lane densities: ({", ".join(map(str, inputs))})') print(f'Output lane velocities: ({", ".join(map(str, outputs))})') check_balancer_flow(junctions, inputs, outputs)
def generate_half_space(domain, real_count): coefficients = [smt.Real(random.random() * 2 - 1) * domain.get_symbol(domain.real_vars[i]) for i in range(real_count)] return smt.LE(smt.Plus(*coefficients), smt.Real(random.random() * 2 - 1))
def __getExpressionTree(symbolicExpression): # TODO LATER: take into account bitwise shift operations args = [] castType = None if len(symbolicExpression.args) > 0: for symbolicArg in symbolicExpression.args: arg, type = Solver.__getExpressionTree(symbolicArg) args.append(arg) if castType is None: castType = type else: if castType.literal == 'Integer': if type.literal == 'Real': castType = type # TODO LATER: consider other possible castings if castType.literal == 'Real': for i in range(len(args)): args[i] = pysmt.ToReal(args[i]) if isinstance(symbolicExpression, sympy.Not): if castType.literal == 'Integer': return pysmt.Equals(args[0], pysmt.Int(0)), Type('Bool') elif castType.literal == 'Real': return pysmt.Equals(args[0], pysmt.Real(0)), Type('Bool') elif castType.literal == 'Bool': return pysmt.Not(args[0]), Type('Bool') else: # castType.literal == 'BitVector' return pysmt.BVNot(args[0]), Type('BitVector') elif isinstance(symbolicExpression, sympy.Lt): return pysmt.LT(args[0], args[1]), Type('Bool') elif isinstance(symbolicExpression, sympy.Gt): return pysmt.GT(args[0], args[1]), Type('Bool') elif isinstance(symbolicExpression, sympy.Ge): return pysmt.GE(args[0], args[1]), Type('Bool') elif isinstance(symbolicExpression, sympy.Le): return pysmt.LE(args[0], args[1]), Type('Bool') elif isinstance(symbolicExpression, sympy.Eq): return pysmt.Equals(args[0], args[1]), Type('Bool') elif isinstance(symbolicExpression, sympy.Ne): return pysmt.NotEquals(args[0], args[1]), Type('Bool') elif isinstance(symbolicExpression, sympy.And): if castType.literal == 'Bool': return pysmt.And(args[0], args[1]), Type('Bool') else: # type.literal == 'BitVector' return pysmt.BVAnd(args[0], args[1]), castType elif isinstance(symbolicExpression, sympy.Or): if castType.literal == 'Bool': return pysmt.Or(args[0], args[1]), Type('Bool') else: # type.literal == 'BitVector' return pysmt.BVOr(args[0], args[1]), castType elif isinstance(symbolicExpression, sympy.Xor): return pysmt.BVXor(args[0], args[1]), castType elif isinstance(symbolicExpression, sympy.Add): return pysmt.Plus(args), castType elif isinstance(symbolicExpression, sympy.Mul): return pysmt.Times(args), castType elif isinstance(symbolicExpression, sympy.Pow): return pysmt.Pow(args[0], args[1]), castType # TODO LATER: deal with missing modulo operator from pysmt else: if isinstance(symbolicExpression, sympy.Symbol): symbolType = Variable.symbolTypes[symbolicExpression.name] literal = symbolType.getTypeForSolver() designator = symbolType.designatorExpr1 type = Type(literal, designator) return Solver.__encodeTerminal(symbolicExpression, type), type elif isinstance(symbolicExpression, sympy.Integer): type = Type('Integer') return Solver.__encodeTerminal(symbolicExpression, type), type elif isinstance(symbolicExpression, sympy.Rational): type = Type('Real') return Solver.__encodeTerminal(symbolicExpression, type), type elif isinstance(symbolicExpression, sympy.Float): type = Type('Real') return Solver.__encodeTerminal(symbolicExpression, type), type else: type = Type('Real') return Solver.__encodeTerminal(symbolicExpression, type), type
def learn_partial(self, solver, domain, data, new_active_indices): # Constants n_b_original = len(domain.bool_vars) n_b = n_b_original * 2 n_r = len(domain.real_vars) n_h_original = self.half_space_count if n_r > 0 else 0 n_h = n_h_original * 2 if self.allow_negations else n_h_original n_c = self.conjunction_count n_d = len(data) real_features = [[row[v] for v in domain.real_vars] for row, _ in data] bool_features = [[row[v] for v in domain.bool_vars] for row, _ in data] labels = [row[1] for row in data] # Variables a_hr = [[ smt.Symbol("a_hr[{}][{}]".format(h, r), REAL) for r in range(n_r) ] for h in range(n_h_original)] b_h = [ smt.Symbol("b_h[{}]".format(h), REAL) for h in range(n_h_original) ] s_ch = [[smt.Symbol("s_ch[{}][{}]".format(c, h)) for h in range(n_h)] for c in range(n_c)] s_cb = [[smt.Symbol("s_cb[{}][{}]".format(c, b)) for b in range(n_b)] for c in range(n_c)] # Aux variables s_ih = [[smt.Symbol("s_ih[{}][{}]".format(i, h)) for h in range(n_h)] for i in range(n_d)] s_ic = [[smt.Symbol("s_ic[{}][{}]".format(i, c)) for c in range(n_c)] for i in range(n_d)] # Constraints for i in new_active_indices: x_r, x_b, label = real_features[i], bool_features[i], labels[i] for h in range(n_h_original): sum_coefficients = smt.Plus( [a_hr[h][r] * smt.Real(x_r[r]) for r in range(n_r)]) solver.add_assertion( smt.Iff(s_ih[i][h], sum_coefficients <= b_h[h])) for h in range(n_h_original, n_h): solver.add_assertion( smt.Iff(s_ih[i][h], ~s_ih[i][h - n_h_original])) for c in range(n_c): solver.add_assertion( smt.Iff( s_ic[i][c], smt.And([smt.TRUE()] + [(~s_ch[c][h] | s_ih[i][h]) for h in range(n_h)] + [ ~s_cb[c][b] for b in range(n_b_original) if not x_b[b] ] + [ ~s_cb[c][b] for b in range(n_b_original, n_b) if x_b[b - n_b_original] ]))) if label: solver.add_assertion(smt.Or([s_ic[i][c] for c in range(n_c)])) else: solver.add_assertion(smt.And([~s_ic[i][c] for c in range(n_c)])) solver.solve() model = solver.get_model() x_vars = [domain.get_symbol(domain.real_vars[r]) for r in range(n_r)] half_spaces = [ smt.Plus( [model.get_value(a_hr[h][r]) * x_vars[r] for r in range(n_r)]) <= model.get_value(b_h[h]) for h in range(n_h_original) ] + [ smt.Plus( [model.get_value(a_hr[h][r]) * x_vars[r] for r in range(n_r)]) > model.get_value(b_h[h]) for h in range(n_h - n_h_original) ] b_vars = [ domain.get_symbol(domain.bool_vars[b]) for b in range(n_b_original) ] bool_literals = [b_vars[b] for b in range(n_b_original)] bool_literals += [~b_vars[b] for b in range(n_b - n_b_original)] conjunctions = [[ half_spaces[h] for h in range(n_h) if model.get_py_value(s_ch[c][h]) ] + [ bool_literals[b] for b in range(n_b) if model.get_py_value(s_cb[c][b]) ] for c in range(n_c)] return smt.Or([smt.And(conjunction) for conjunction in conjunctions])
SMT.GT(variables[i + 2], SMT.Int(0))), SMT.Equals(variables[i + 1], SMT.Int(1)))) solver = SMT.Solver(name="z3") print("constraints:") for c in constraints: print(c) solver.add_assertion(c) # add equations # 24727*a_1 + 75235*b_1 + 50508*c_1 = 75235*a_2 + 125743*b_2 + 176251*c_2 solver.add_assertion( SMT.Equals( SMT.Plus( SMT.Plus(SMT.Times(SMT.Int(125743), variables[4]), SMT.Times(SMT.Int(75235), variables[3])), SMT.Times(SMT.Int(176251), variables[5])), SMT.Plus( SMT.Plus(SMT.Times(SMT.Int(75235), variables[1]), SMT.Times(SMT.Int(24727), variables[0])), SMT.Times(SMT.Int(50508), variables[2])))) # 75235*a_2 + 125743*b_2 + 176251*c_2 = 125743*a_3 + 301994*b_3 + 16785921*c solver.add_assertion( SMT.Equals( SMT.Plus( SMT.Plus(SMT.Times(SMT.Int(301994), variables[7]), SMT.Times(SMT.Int(125743), variables[6])), SMT.Times(SMT.Int(16785921), variables[8])), SMT.Plus( SMT.Plus(SMT.Times(SMT.Int(125743), variables[4]),
def learn_partial(self, solver, domain: Domain, data: np.ndarray, labels: np.ndarray, new_active_indices: Set): # Constants n_b_original = len(domain.bool_vars) n_b = n_b_original * 2 n_r = len(domain.real_vars) n_h_original = self.half_space_count if n_r > 0 else 0 n_h = n_h_original * 2 if self.allow_negations else n_h_original n_c = self.conjunction_count n_d = data.shape[0] real_indices = np.array( [domain.var_types[v] == smt.REAL for v in domain.variables]) real_features = data[:, real_indices] bool_features = data[:, np.logical_not(real_indices)] # Variables a_hr = [[ smt.Symbol("a_hr[{}][{}]".format(h, r), REAL) for r in range(n_r) ] for h in range(n_h_original)] b_h = [ smt.Symbol("b_h[{}]".format(h), REAL) for h in range(n_h_original) ] s_ch = [[smt.Symbol("s_ch[{}][{}]".format(c, h)) for h in range(n_h)] for c in range(n_c)] s_cb = [[smt.Symbol("s_cb[{}][{}]".format(c, b)) for b in range(n_b)] for c in range(n_c)] # Aux variables s_ih = [[smt.Symbol("s_ih[{}][{}]".format(i, h)) for h in range(n_h)] for i in range(n_d)] s_ic = [[smt.Symbol("s_ic[{}][{}]".format(i, c)) for c in range(n_c)] for i in range(n_d)] def pair(real: bool, c: int, index: int) -> Tuple[FNode, FNode]: if real: return s_ch[c][index], s_ch[c][index + n_h_original] else: return s_cb[c][index], s_cb[c][index + n_b_original] def order_equal(pair1, pair2): x_t, x_f, y_t, y_f = pair1 + pair2 return smt.Iff(x_t, y_t) & smt.Iff(x_f, y_f) def order_geq(pair1, pair2): x_t, x_f, y_t, y_f = pair1 + pair2 return x_t | y_f | ((~x_f) & (~y_t)) def pairs(c: int) -> List[Tuple[FNode, FNode]]: return [pair(True, c, i) for i in range(n_h_original) ] + [pair(False, c, i) for i in range(n_b_original)] def order_geq_lex(c1: int, c2: int): pairs_c1, pairs_c2 = pairs(c1), pairs(c2) assert len(pairs_c1) == len(pairs_c2) constraints = smt.TRUE() for j in range(len(pairs_c1)): condition = smt.TRUE() for i in range(j): condition &= order_equal(pairs_c1[i], pairs_c2[i]) constraints &= smt.Implies(condition, order_geq(pairs_c1[j], pairs_c2[j])) return constraints # Constraints for i in new_active_indices: x_r, x_b, label = [float(val) for val in real_features[i] ], bool_features[i], labels[i] for h in range(n_h_original): sum_coefficients = smt.Plus( [a_hr[h][r] * smt.Real(x_r[r]) for r in range(n_r)]) solver.add_assertion( smt.Iff(s_ih[i][h], sum_coefficients <= b_h[h])) for h in range(n_h_original, n_h): solver.add_assertion( smt.Iff(s_ih[i][h], ~s_ih[i][h - n_h_original])) for c in range(n_c): solver.add_assertion( smt.Iff( s_ic[i][c], smt. Or([smt.FALSE()] + [(s_ch[c][h] & s_ih[i][h]) for h in range(n_h)] + [s_cb[c][b] for b in range(n_b_original) if x_b[b]] + [ s_cb[c][b] for b in range(n_b_original, n_b) if not x_b[b - n_b_original] ]))) # --- [start] symmetry breaking --- # Mutually exclusive if "m" in self.symmetries: for c in range(n_c): for h in range(n_h_original): solver.add_assertion(~(s_ch[c][h] & s_ch[c][h + n_h_original])) for b in range(n_b_original): solver.add_assertion(~(s_cb[c][b] & s_cb[c][b + n_b_original])) # Normalized if "n" in self.symmetries: for h in range(n_h_original): solver.add_assertion( smt.Equals(b_h[h], smt.Real(1.0)) | smt.Equals(b_h[h], smt.Real(0.0))) # Vertical symmetries if "v" in self.symmetries: for c in range(n_c - 1): solver.add_assertion(order_geq_lex(c, c + 1)) # Horizontal symmetries if "h" in self.symmetries: for h in range(n_h_original - 1): solver.add_assertion(a_hr[h][0] >= a_hr[h + 1][0]) # --- [end] symmetry breaking --- if label: solver.add_assertion(smt.And([s_ic[i][c] for c in range(n_c)])) else: solver.add_assertion(smt.Or([~s_ic[i][c] for c in range(n_c)])) solver.solve() model = solver.get_model() x_vars = [domain.get_symbol(domain.real_vars[r]) for r in range(n_r)] half_spaces = [ smt.Plus( [model.get_value(a_hr[h][r]) * x_vars[r] for r in range(n_r)]) <= model.get_value(b_h[h]) for h in range(n_h_original) ] + [ smt.Plus( [model.get_value(a_hr[h][r]) * x_vars[r] for r in range(n_r)]) > model.get_value(b_h[h]) for h in range(n_h - n_h_original) ] b_vars = [ domain.get_symbol(domain.bool_vars[b]) for b in range(n_b_original) ] bool_literals = [b_vars[b] for b in range(n_b_original)] bool_literals += [~b_vars[b] for b in range(n_b - n_b_original)] conjunctions = [[ half_spaces[h] for h in range(n_h) if model.get_py_value(s_ch[c][h]) ] + [ bool_literals[b] for b in range(n_b) if model.get_py_value(s_cb[c][b]) ] for c in range(n_c)] return smt.And([smt.Or(conjunction) for conjunction in conjunctions])
def find_cnf(data, domain, active_indices, solver, n_c, n_h): # Constants n_b_original = len(domain.bool_vars) n_b = n_b_original * 2 n_r = len(domain.real_vars) n_d = len(data) real_features = [[row[v] for v in domain.real_vars] for row, _ in data] bool_features = [[row[v] for v in domain.bool_vars] for row, _ in data] labels = [row[1] for row in data] # Variables a_hr = [[ smt.Symbol("a_hr[{}][{}]".format(h, r), REAL) for r in range(n_r) ] for h in range(n_h)] b_h = [smt.Symbol("b_h[{}]".format(h), REAL) for h in range(n_h)] s_ch = [[smt.Symbol("s_ch[{}][{}]".format(c, h)) for h in range(n_h)] for c in range(n_c)] s_cb = [[smt.Symbol("s_cb[{}][{}]".format(c, b)) for b in range(n_b)] for c in range(n_c)] # Aux variables s_ih = [[smt.Symbol("s_ih[{}][{}]".format(i, h)) for h in range(n_h)] for i in range(n_d)] s_ic = [[smt.Symbol("s_ic[{}][{}]".format(i, c)) for c in range(n_c)] for i in range(n_d)] # Constraints for i in active_indices: x_r, x_b, label = real_features[i], bool_features[i], labels[i] for h in range(n_h): sum_coefficients = smt.Plus( [a_hr[h][r] * smt.Real(x_r[r]) for r in range(n_r)]) if label: solver.add_assertion( smt.Iff(s_ih[i][h], sum_coefficients + DELTA <= b_h[h])) else: solver.add_assertion( smt.Iff(s_ih[i][h], sum_coefficients - DELTA <= b_h[h])) for c in range(n_c): solver.add_assertion( smt.Iff( s_ic[i][c], smt.Or([smt.FALSE()] + [(s_ch[c][h] & s_ih[i][h]) for h in range(n_h)] + [s_cb[c][b] for b in range(n_b_original) if x_b[b]] + [ s_cb[c][b] for b in range(n_b_original, n_b) if not x_b[b - n_b_original] ]))) if label: solver.add_assertion(smt.And([s_ic[i][c] for c in range(n_c)])) else: solver.add_assertion(smt.Or([~s_ic[i][c] for c in range(n_c)])) if not solver.solve(): return None model = solver.get_model() x_vars = [domain.get_symbol(domain.real_vars[r]) for r in range(n_r)] half_spaces = [ smt.Plus([model.get_value(a_hr[h][r]) * x_vars[r] for r in range(n_r)]) <= model.get_value(b_h[h]) for h in range(n_h) ] b_vars = [ domain.get_symbol(domain.bool_vars[b]) for b in range(n_b_original) ] bool_literals = [b_vars[b] for b in range(n_b_original)] bool_literals += [~b_vars[b] for b in range(n_b - n_b_original)] conjunctions = [ [half_spaces[h] for h in range(n_h) if model.get_py_value(s_ch[c][h])] + [ bool_literals[b] for b in range(n_b) if model.get_py_value(s_cb[c][b]) ] for c in range(n_c) ] return smt.And([smt.Or(conjunction) for conjunction in conjunctions])
def initialize(self, mdp, colors, hole_options, reward_name, okay_states, target_states, threshold, relation): logger.warning("This approach has been tested sparsely.") prob0E, prob1A = stormpy.compute_prob01min_states( mdp, okay_states, target_states) sink_states = ~okay_states assert len(mdp.initial_states) == 1 self.state_vars = [ smt.Symbol("p_{}".format(i), smt.REAL) for i in range(mdp.nr_states) ] self.state_prob1_vars = [ smt.Symbol("asure_{}".format(i)) for i in range(mdp.nr_states) ] self.state_probpos_vars = [ smt.Symbol("x_{}".format(i)) for i in range(mdp.nr_states) ] self.state_order_vars = [ smt.Symbol("r_{}".format(i), smt.REAL) for i in range(mdp.nr_states) ] self.option_vars = dict() for h, opts in hole_options.items(): self.option_vars[h] = { index: smt.Symbol("h_{}_{}".format(h, opt)) for index, opt in enumerate(opts) } self.transition_system = [] logger.debug("Obtain rewards if necessary") rewards = mdp.reward_models[reward_name] if reward_name else None if rewards: assert not rewards.has_transition_rewards state_rewards = rewards.has_state_rewards action_rewards = rewards.has_state_action_rewards logger.debug( "Model has state rewards: {}, has state/action rewards {}". format(state_rewards, action_rewards)) self.transition_system.append( self.state_prob1_vars[mdp.initial_states[0]]) threshold_inequality, action_constraint_inequality = self._to_smt_relation( relation) # TODO or GE self.transition_system.append( threshold_inequality(self.state_vars[mdp.initial_states[0]], smt.Real(float(threshold)))) state_order_domain_constraint = smt.And([ smt.And(smt.GE(var, smt.Real(0)), smt.LE(var, smt.Real(1))) for var in self.state_order_vars ]) self.transition_system.append(state_order_domain_constraint) #TODO how to ensure that prob is zero if there is no path. select_parameter_value_constraints = [] for h, opts in self.option_vars.items(): select_parameter_value_constraints.append( smt.Or(ov for ov in opts.values())) for i, opt1 in enumerate(opts.values()): for opt2 in list(opts.values())[i + 1:]: select_parameter_value_constraints.append( smt.Not(smt.And(opt1, opt2))) #logger.debug("Consistency: {}".format(smt.And(select_parameter_value_constraints))) self.transition_system.append( smt.And(select_parameter_value_constraints)) for state in mdp.states: if sink_states.get(state.id): assert rewards is None self.transition_system.append( smt.Equals(self.state_vars[state.id], smt.REAL(0))) #logger.debug("Constraint: {}".format(self.transition_system[-1])) self.transition_system.append( smt.Not(self.state_prob1_vars[state.id])) #logger.debug("Constraint: {}".format(self.transition_system[-1])) self.transition_system.append( smt.Equals(self.state_order_vars[state.id], smt.Real(0))) #logger.debug("Constraint: {}".format(self.transition_system[-1])) elif target_states.get(state.id): self.transition_system.append( smt.Equals(self.state_order_vars[state.id], smt.Real(1))) #logger.debug("Constraint: {}".format(self.transition_system[-1])) self.transition_system.append(self.state_prob1_vars[state.id]) #logger.debug("Constraint: {}".format(self.transition_system[-1])) if rewards is None: self.transition_system.append( smt.Equals(self.state_vars[state.id], smt.Real(1))) #logger.debug("Constraint: {}".format(self.transition_system[-1])) else: self.transition_system.append( self.state_probpos_vars[state.id]) #logger.debug("Constraint: {}".format(self.transition_system[-1])) self.transition_system.append( smt.Equals(self.state_vars[state.id], smt.Real(0))) #logger.debug("Constraint: {}".format(self.transition_system[-1])) else: state_in_prob1A = False state_in_prob0E = False if prob0E.get(state.id): state_in_prob0E = True else: self.transition_system.append( smt.Equals(self.state_order_vars[state.id], smt.Real(1))) #logger.debug("Constraint: {}".format(self.transition_system[-1])) self.transition_system.append( self.state_probpos_vars[state.id]) #logger.debug("Constraint: {}".format(self.transition_system[-1])) if rewards and not state_in_prob0E: if prob1A.get(state.id): self.transition_system.append( self.state_prob1_vars[state.id]) logger.debug("Constraint: {}".format( self.transition_system[-1])) state_in_prob1A = True for action in state.actions: action_index = mdp.nondeterministic_choice_indices[ state.id] + action.id #logger.debug("Action index: {}".format(action_index)) precondition = smt.And([ self.option_vars[hole][list(option)[0]] for hole, option in colors.get(action_index, dict()).items() ]) reward_value = None if rewards: reward_const = (rewards.get_state_reward( state.id) if state_rewards else 0.0) + ( rewards.get_state_action_reward(action_index) if action_rewards else 0.0) reward_value = smt.Real(reward_const) act_constraint = action_constraint_inequality( self.state_vars[state.id], smt.Plus([ smt.Times(smt.Real(t.value()), self. state_vars[t.column]) for t in action.transitions ] + [reward_value] if reward_value else [])) full_act_constraint = act_constraint if state_in_prob0E: if not rewards: full_act_constraint = smt.And( smt.Implies(self.state_probpos_vars[state.id], act_constraint), smt.Implies( smt.Not(self.state_probpos_vars), smt.Equals(self.state_vars[state.id], smt.Real(0)))) self.transition_system.append( smt.Implies( precondition, smt.Iff( self.state_probpos_vars[state.id], smt.Or([ smt.And( self.state_probpos_vars[t.column], smt.LT( self.state_order_vars[ state.id], self.state_order_vars[ t.column])) for t in action.transitions ])))) #logger.debug("Constraint: {}".format(self.transition_system[-1])) if rewards and not state_in_prob1A: # prob_one(state) <-> probpos AND for all succ prob_one(succ) self.transition_system.append( smt.Implies( precondition, smt.Iff( self.state_prob1_vars[state.id], smt.And([ self.state_prob1_vars[t.column] for t in action.transitions ] + [self.state_probpos_vars[state.id]])))) #logger.debug("Constraint: {}".format(self.transition_system[-1])) self.transition_system.append( smt.Implies(precondition, full_act_constraint)) #logger.debug("Constraint: {}".format(self.transition_system[-1])) if rewards: self.transition_system.append( smt.And([smt.GE(sv, smt.Real(0)) for sv in self.state_vars])) else: self.transition_system.append( smt.And([ smt.And(smt.GE(sv, smt.Real(0)), smt.LE(sv, smt.Real(1))) for sv in self.state_vars ])) #print(self.transition_system) formula = smt.And(self.transition_system) logger.info("Start SMT solver") model = smt.get_model(formula) if model: logger.info("SAT: Found {}".format(model)) else: logger.info("UNSAT.")