def test_get_model_unsat(self): varA = Symbol("A", BOOL) varB = Symbol("B", BOOL) f = And(varA, Not(varB)) g = f.substitute({varB:varA}) res = get_model(g, logic=QF_BOOL) self.assertIsNone(res, "Formula was expected to be UNSAT") for solver in get_env().factory.all_solvers(logic=QF_BOOL): res = get_model(g, solver_name=solver) self.assertIsNone(res, "Formula was expected to be UNSAT")
def test_get_model_sat(self): varA = Symbol("A", BOOL) varX = Symbol("X", REAL) f = And(varA, Equals(varX, Real(8))) res = get_model(f, logic=QF_LRA) self.assertIsNotNone(res, "Formula was expected to be SAT") self.assertTrue(res.get_value(varA) == TRUE()) self.assertTrue(res.get_value(varX) == Real(8)) for solver in get_env().factory.all_solvers(logic=QF_LRA): res = get_model(f, solver_name=solver) self.assertIsNotNone(res, "Formula was expected to be SAT") self.assertTrue(res.get_value(varA) == TRUE()) self.assertTrue(res.get_value(varX) == Real(8))
def solve(self, simplify=False): formula = And(self.constraints) if simplify: formula = formula.simplify() model = get_model(formula) assert model is not None # check for unsatisfiability return model
def process(): varA = Symbol("A") varB = Symbol("B") f = And(varA, Not(varB)) print(f) print(is_sat(f)) hello = [Symbol(s, INT) for s in "hello"] world = [Symbol(s, INT) for s in "world"] letters = set(hello + world) domains = And(And(LE(Int(1), l), GE(Int(10), l)) for l in letters) print(domains,'domain') sum_hello = Plus(hello) sum_world = Plus(world) problem = And(Equals(sum_hello, sum_world), Equals(sum_hello, Int(36))) formula = And(domains, problem) print("Serialization of the formula:") print(formula) print(formula.serialize()) print(is_sat(formula)) print(get_model(formula))
def test_z3_model_iteration(self): x, y = Symbol("x"), Symbol("y") m = get_model(And(x, y), solver_name="z3") self.assertIsNotNone(m) for _, v in m: self.assertEqual(v, TRUE())
def vertex_cover_solver(graph, k): vertexes, edges = graph # vertex in vertex cover 1 otherwise 0 vertex_vars = [Symbol(v, INT) for v in vertexes] vertex_range = And( [And(GE(v, Int(0)), LE(v, Int(1))) for v in vertex_vars]) # size of vertex cover <= k sum_vertex = Plus(vertex_vars) vertex_constraint = LE(sum_vertex, Int(k)) # edge constraints # Plus(vi, vj) >= 1 for edge = (vi, vj) # cannot use Or(vi, vj), because variables are integers not boolean type edge_constraint = And([ GE(Plus([vertex_vars[lv], vertex_vars[rv]]), Int(1)) for (lv, rv) in edges ]) # combined formula formula = And(vertex_range, vertex_constraint, edge_constraint) model = get_model(formula) size = get_formula_size(formula) cover = set() if model: for i, node in enumerate(vertexes): if model.get_py_value(vertex_vars[i]): cover.add(node) return cover, formula, size else: return None, formula, size
def efsmt(y, phi, logic=AUTO, maxloops=None, esolver_name=None, fsolver_name=None, verbose=False): """Solves exists x. forall y. phi(x, y)""" y = set(y) x = phi.get_free_variables() - y with Solver(logic=logic, name=esolver_name) as esolver: esolver.add_assertion(Bool(True)) loops = 0 while maxloops is None or loops <= maxloops: loops += 1 eres = esolver.solve() if not eres: return False else: tau = {v: esolver.get_value(v) for v in x} sub_phi = phi.substitute(tau).simplify() if verbose: print("%d: Tau = %s" % (loops, tau)) fmodel = get_model(Not(sub_phi), logic=logic, solver_name=fsolver_name) if fmodel is None: return tau else: sigma = {v: fmodel[v] for v in y} sub_phi = phi.substitute(sigma).simplify() if verbose: print("%d: Sigma = %s" % (loops, sigma)) esolver.add_assertion(sub_phi) raise SolverReturnedUnknownResultError
def encode_and_run(g, counter_examples=None): fs, store = encode_games(g, counter_examples) f = reduce(op.and_, fs, TRUE()) model = get_model(f) if model is None: return Result(False, None, None, counter_examples) sol = {v: extract_ts(v, model, g, store) for v in fn.cat(g.model.vars)} return Result(True, 0, sol, counter_examples)
def check_in_language(tree_str, conf_file): cfg_f, cfg_r = read_features(conf_file) sent_t = Tree.parse(tree_str.strip(), trunc=False) symbols, all_constraints = get_sat_constraints(sent_t, cfg_f, cfg_r, {}, []) problem = And(all_constraints) model = get_model(problem) if model: return tree_to_str(sent_t) else: return None
def SMTSynthesizer(): """ Use SMT to solve the ordering of register loads based on call conventions """ print '> SMT synthesizer' # Use a SMT solver to figure out the order to pull register values from # user-space stack onto the kernel stack model = get_model(machine_desc) stack = sorted(regs.values(), key=lambda r: r.get_stack_index(model)) return X86StackRegister.pushqs(stack)
def get_model_or_print_ucore(formula): m = s.get_model(formula) if not m: print('unsat') from pysmt.rewritings import conjunctive_partition conj = conjunctive_partition(s.And(formula)) ucore = s.get_unsat_core(conj) print("UNSAT-Core size '%d'" % len(ucore)) for f in ucore: print(f.serialize()) return return m
def graph_color_ass_smt(G, h): n = len(G.nodes) x = [Symbol(f"x_{i}", INT) for i in range(n)] f = And( *(0 < v for v in x), *(v <= h for v in x), *(NotEquals(x[u],x[v]) for u, v in G.edges) ) model = get_model(f) if model: print(model) else: print("No solution found")
def solve(self, solver_name=None, get_assignment=False): """Solve the SMT problem. Return whether the decision problem is satisfiable. If get_assignment is set to True, solve() returns an assignment of the variables that makes the SMT problem satisfiable (if the problem is unsatisfiable, None is returned). This assignment is returned as a dictionary with the following entries: - differences: an ordered dictionary containing the sequence of differences. - weight: the weight of the characteristic. - op_weights: the weights of each operation with non-deterministic propagation. >>> from arxpy.bitvector.function import Function >>> from arxpy.diffcrypt.difference import XorDiff, DiffVar >>> from arxpy.diffcrypt.characteristic import Characteristic >>> from arxpy.diffcrypt.smt import SmtProblem >>> class MyFunction(Function): ... input_widths = [8, 8, 8] ... output_widths = [8, 8] ... @classmethod ... def eval(cls, x, y, k): ... return (y + k, (y + k) ^ x) >>> x, y, k = DiffVar("x", 8), DiffVar("y", 8), DiffVar("k", 8) >>> ch = Characteristic(MyFunction, XorDiff, [x, y, k]) >>> smt_problem = SmtProblem(ch, 0) >>> smt_problem.solve() True >>> smt_problem.solve(get_assignment=True) # doctest:+NORMALIZE_WHITESPACE {'differences': OrderedDict([(x, 0x80), (y, 0x00), (k, 0x80), (d0, 0x80), (d1, 0x00)]), 'weight': 0, 'op_weights': OrderedDict([(w_ky_d0, 0)])} """ sc.reset_env() pysmt_formula = sc.And(*[bv2pysmt(a) for a in self.assertions]) if not get_assignment: return sc.is_sat(pysmt_formula, solver_name, logic=logics.QF_BV) else: model = sc.get_model(pysmt_formula, solver_name, logic=logics.QF_BV) if model is None: return None else: return self._get_assignment(model)
def get_def_model(formula, vars_list, val): model_sat = get_model(formula) assert model_sat is not None model = {} for v in vars_list: if v not in model_sat: model[v] = val else: if model_sat.get_value(v) == TRUE(): model[v] = True else: model[v] = False return model
def decide_epidemic(source, size, m, p, limit, target, timesteps, p_infect): if source == 'generate': contact_network = networkx.watts_strogatz_graph(size, m, p) else: contact_network = networkx.read_adjlist(source) spread_graph = grow_connections_in_time(contact_network, timesteps, p_infect) formula, _, _ = construct_spread_formula_from_graph( spread_graph, limit, target) model = get_model(formula) if model: return True, model else: return False, None
def solveDecisionProblem(filename): global robots_info global task_info global task_utilities global k robots_info = {} task_info = {} task_utilities = {} k=0 file = open(filename, "r") mode = 0 for line in file: if line=='\n': mode+=1 elif mode==0: k = int(line.strip()) elif mode==1: task_line = line.split() task_info[task_line[0]] = [int(resource) for resource in task_line[2:]] task_utilities[task_line[0]] = int(task_line[1]) elif mode == 2: robot_line = line.split() robots_info[robot_line[0]] = [int(resource) for resource in robot_line[1:]] file.close() # Each robot may be assigned to at most one task # runs in time |Robots||Tasks||Tasks| oneTask = And([Symbol(robot+taskAssigned).Implies(Not(Symbol(robot+task))) for robot in robots_info.keys() for taskAssigned in task_info.keys() for task in task_info.keys() if (taskAssigned != task)]) # A task is satisfied if and only if all of its resource requirements are met # runs in time |Robots||Tasks||ResourceTypes| tasksSatisfied = And([Iff(Symbol(task +"Sat"), And([GE(Plus([Times(Ite(Symbol(robot+task),Int(1), Int(0)), Int(robots_info[robot][i])) for robot in robots_info.keys()]), Int(task_info[task][i])) for i in range(len(task_info[task]))])) for task in task_info.keys()]) # Is the decision problem satisfied # runs in time |Tasks| decisionProb = GE(Plus([Times(Ite(Symbol(task+"Sat"), Int(1), Int(0)), Int(task_utilities[task])) for task in task_info.keys()]), Int(k)) prob = And(oneTask, tasksSatisfied, decisionProb) model = get_model(prob) return model
def solve(problem): from pysmt.shortcuts import AllDifferent, And, Symbol, get_model from pysmt.typing import INT tree = parser.parse(problem) letters = sorted(get_letters(tree)) first_letters = get_first_letters(tree) symbols = {} for letter in letters: symbol = Symbol(letter, INT) symbols[letter] = symbol formula = make_formula(tree, symbols) clauses = [] for letter in letters: symbol = symbols[letter] if letter in first_letters: clauses.append(1 <= symbol) clauses.append(symbol < 10) else: clauses.append(0 <= symbol) clauses.append(symbol < 10) clauses.append(AllDifferent(*symbols.values())) clauses.append(formula) cp = And(clauses) return get_model(cp)
def scheduler(chip_power): total_power = 0 mem = [Symbol(M, INT) for M in mem_list] # print(mem_power_list.get(str(mem[0]))) domain = And([And(GE(l, Int(0)), LT(l, Int(2))) for l in mem]) # print(domain) sum_power = Plus([l * mem_power_list.get(str(l)) for l in mem]) # print(sum_power) problem = Equals(sum_power, Int(chip_power)) formula = And(domain, problem) # print(formula) model = get_model(formula) # print(model) if model != None: for l in mem: mem_test_time_list[str(l)] = mem_test_time_list[str(l)] - int( model.get_value(l).constant_value()) if int(model.get_value(l).constant_value()) == 1: print(str(l)) total_power = total_power + mem_power_list[str(l)] print("total power:", total_power) return True else: return False
def solve(self, solver_name=None, get_assignment=False): """Solve the pair of SMT problems simultaneously. Return whether the pair of decision problems are satisfiable. If get_assignment is set to True, solve() returns an assignment of the variables that makes the pair of SMT problems satisfiable (if one of the problems is unsatisfiable, None is returned). This assignment is returned as a pair of dictionaries, where the first dictionary is the assignment of the inner SMT problem and the second dictionary is the assignment of the outer SMT problem. >>> from arxpy.bitvector.operation import RotateLeft >>> from arxpy.bitvector.function import Function, CompositeFunction >>> from arxpy.diffcrypt.difference import XorDiff, DiffVar >>> from arxpy.diffcrypt.characteristic import Characteristic, CompositeCh >>> class MyInner(Function): ... input_widths = [8] ... output_widths = [8, 8] ... @classmethod ... def eval(cls, k): ... return (k, RotateLeft(k, 1)) >>> class MyOuter(Function): ... input_widths = [8, 8, 8, 8] ... output_widths = [8, 8] ... @classmethod ... def eval(cls, x, y, k0, k1): ... for ki in [k0, k1]: ... x, y = y + ki, (y + ki) ^ x ... return x, y >>> class MyComposite(CompositeFunction): ... input_widths = [8, 8, 8] ... output_widths = [8, 8] ... inner_func = MyInner ... outer_func = MyOuter >>> x, y, k = DiffVar("x", 8), DiffVar("y", 8), DiffVar("k", 8) >>> ch = CompositeCh(MyComposite, XorDiff, [x, y, k]) >>> smt_problem = CompositeSmtProblem(ch, [1, 1]) >>> smt_problem.solve() True >>> inner_assig, outer_assig = smt_problem.solve(get_assignment=True) >>> inner_assig # doctest:+NORMALIZE_WHITESPACE {'differences': OrderedDict([(k, 0x40), (i0, 0x80)]), 'weight': 0, 'op_weights': OrderedDict()} >>> outer_assig # doctest:+NORMALIZE_WHITESPACE {'differences': OrderedDict([(x, 0x40), (y, 0x00), (k, 0x40), (i0, 0x80), (o0, 0x40), (o1, 0x00), (o2, 0x80), (o3, 0xc0)]), 'weight': 1, 'op_weights': OrderedDict([(w_ky_o0, 1), (w_i0o1_o2, 0)])} """ sc.reset_env() i_f = sc.And(*[bv2pysmt(a) for a in self.inner_problem.assertions]) o_f = sc.And(*[bv2pysmt(a) for a in self.outer_problem.assertions]) pysmt_formula = sc.And(i_f, o_f) if not get_assignment: return sc.is_sat(pysmt_formula, solver_name, logic=logics.QF_BV) else: model = sc.get_model(pysmt_formula, solver_name, logic=logics.QF_BV) if model is None: return None else: inner_assig = self.inner_problem._get_assignment(model) outer_assig = self.outer_problem._get_assignment(model) return inner_assig, outer_assig
def generate_model(formula): """ This function will invoke PySMT APIs to solve the provided formula and return the byte list of the model Arguments: formula: smtlib formatted formula """ emitter.debug("extracting z3 model") model = get_model(formula) if model is None: return None path_script = "/tmp/z3_script_model" write_smtlib(formula, path_script) with open(path_script, "r") as script_file: script_lines = script_file.readlines() script = "".join(script_lines) var_list = set(re.findall("\(declare-fun (.+?) \(\)", script)) sym_var_list = dict() for var_name in var_list: # sym_var_list[var_name] = dict() if "const_" in var_name and not "const_arr" in var_name: sym_def = Symbol(var_name, BV32) if sym_def not in model: continue x = model[sym_def] byte_list = dict() default_value = x.bv_signed_value() byte_list[0] = default_value else: sym_def = Symbol(var_name, ArrayType(BV32, BV8)) if sym_def not in model: continue x = model[sym_def].simplify() byte_list = dict() value_array_map = x.array_value_assigned_values_map() default_value = int(str(x.array_value_default()).split("_")[0]) if not value_array_map: byte_list[0] = default_value else: for idx, val in value_array_map.items(): index = int(str(idx).split("_")[0]) value = int(str(val).split("_")[0]) byte_list[index] = value max_index = max(list(byte_list.keys())) if var_name in values.LIST_BIT_LENGTH: array_size = values.LIST_BIT_LENGTH[var_name] - 1 if var_name in ["A-data"]: array_size = max_index else: array_size = max_index + 1 # TODO: this could be wrong calculation if max_index == 0: array_size = 2 if var_name not in ["A-data"]: for i in range(0, array_size): if i not in byte_list: byte_list[i] = default_value if var_name not in ["A-data", "A-data-stat"]: for i in range(array_size - 1, -1, -1): if byte_list[i] == 0: byte_list.pop(i) else: break sym_var_list[var_name] = byte_list emitter.data("model var list", sym_var_list) return sym_var_list
# We create a map from BitVectors to Reals, so that each bitvector # value (interpreted as unary number) is equal to the Real # value. # # The map is represented by an Array of type BV8 -> Real map_type = ArrayType(BV8, REAL) my_map = Symbol("my_map", map_type) # Fill-up the map, by defining all 256 values: for i in range(0, 255): my_map = my_map.Store(BV(i, 8), Real(i)) # We want to find find a value for which our relation does not work. # In other words, we ask if there is a value for the bitvector # s.t. the corresponding value in the array is different from the # unary interpretation of the bitvector. bv_var = Symbol("bv", BV8) int_var = Symbol("int", INT) real_var = Symbol("real", REAL) f = And( # Convert the BV into INT int_var.Equals(BVToNatural(bv_var)), # Convert the INT into REAL real_var.Equals(ToReal(int_var)), # Compare the value stored in the map with the REAL value my_map.Select(bv_var).NotEquals(real_var) ) print(get_model(f)) # Indeed our range only gets up to 254!!!
def test_bv(self): mgr = get_env().formula_manager BV = mgr.BV # Constants one = BV(1, 32) zero = BV(0, 32) big = BV(127, 128) binary = BV("111") binary2 = BV("#b111") binary3 = BV(0b111, 3) # In this case we need to explicit the width self.assertEqual(binary, binary2) self.assertEqual(binary2, binary3) self.assertEqual(one, mgr.BVOne(32)) self.assertEqual(zero, mgr.BVZero(32)) # Type Equality self.assertTrue(BV32 != BV128) self.assertFalse(BV32 != BV32) self.assertFalse(BV32 == BV128) self.assertTrue(BV32 == BV32) with self.assertRaises(ValueError): # Negative numbers are not supported BV(-1, 10) with self.assertRaises(ValueError): # Number should fit in the width BV(10, 2) # Variables b128 = Symbol("b", BV128) # BV1, BV8 etc. are defined in pysmt.typing b32 = Symbol("b32", BV32) hexample = BV(0x10, 32) #s_one = BV(-1, 32) bcustom = Symbol("bc", BVType(42)) self.assertIsNotNone(hexample) self.assertIsNotNone(bcustom) #self.assertIsNotNone(s_one) self.assertEqual(bcustom.bv_width(), 42) self.assertEqual(hexample.constant_value(), 16) #self.assertEqual(str(s_one), "-1_32") not_zero32 = mgr.BVNot(zero) not_b128 = mgr.BVNot(b128) f1 = Equals(not_zero32, b32) f2 = Equals(not_b128, big) #print(f1) #print(f2) self.assertTrue(is_sat(f1, logic=QF_BV)) self.assertTrue(is_sat(f2, logic=QF_BV)) zero_and_one = mgr.BVAnd(zero, one) zero_or_one = mgr.BVOr(zero, one) zero_xor_one = mgr.BVXor(zero, one) zero_xor_one.simplify() self.assertTrue(zero_xor_one.is_bv_op()) # print(zero_and_one) # print(zero_or_one) # print(zero_xor_one) f1 = Equals(zero_and_one, b32) f2 = Equals(zero_or_one, b32) f3 = Equals(zero_xor_one, b32) f4 = Equals(zero_xor_one, one) self.assertTrue(is_sat(f1, logic=QF_BV), f1) self.assertTrue(is_sat(f2, logic=QF_BV), f2) self.assertTrue(is_sat(f3, logic=QF_BV), f3) self.assertTrue(is_valid(f4, logic=QF_BV), f4) with self.assertRaises(TypeError): mgr.BVAnd(b128, zero) f = mgr.BVAnd(b32, zero) f = mgr.BVOr(f, b32) f = mgr.BVXor(f, b32) f = Equals(f, zero) self.assertTrue(is_sat(f, logic=QF_BV), f) zero_one_64 = mgr.BVConcat(zero, one) one_zero_64 = mgr.BVConcat(one, zero) one_one_64 = mgr.BVConcat(one, one) self.assertTrue(zero_one_64.bv_width() == 64) f1 = Equals(mgr.BVXor(one_zero_64, zero_one_64), one_one_64) self.assertTrue(is_sat(f1, logic=QF_BV), f1) # MG: BV indexes grow to the left. # This is confusing and we should address this. extraction = mgr.BVExtract(zero_one_64, 32, 63) self.assertTrue(is_valid(Equals(extraction, zero))) #print(extraction) ult = mgr.BVULT(zero, one) neg = mgr.BVNeg(one) self.assertTrue(is_valid(ult, logic=QF_BV), ult) test_eq = Equals(neg, one) self.assertTrue(is_unsat(test_eq, logic=QF_BV)) # print(ult) # print(neg) f = zero addition = mgr.BVAdd(f, one) multiplication = mgr.BVMul(f, one) udiv = mgr.BVUDiv(f, one) self.assertTrue(is_valid(Equals(addition, one), logic=QF_BV), addition) self.assertTrue(is_valid(Equals(multiplication, zero), logic=QF_BV), multiplication) self.assertTrue(is_valid(Equals(udiv, zero), logic=QF_BV), udiv) # print(addition) # print(multiplication) # print(udiv) three = mgr.BV(3, 32) two = mgr.BV(2, 32) reminder = mgr.BVURem(three, two) shift_l_a = mgr.BVLShl(one, one) shift_l_b = mgr.BVLShl(one, 1) self.assertTrue(is_valid(Equals(reminder, one)), reminder) self.assertEqual(shift_l_a, shift_l_b) self.assertTrue(is_valid(Equals(shift_l_a, two))) # print(reminder) # print(shift_l_a) # print(shift_l_b) shift_r_a = mgr.BVLShr(one, one) shift_r_b = mgr.BVLShr(one, 1) self.assertEqual(shift_r_a, shift_r_b) self.assertTrue(is_valid(Equals(shift_r_a, zero))) rotate_l = mgr.BVRol(one, 3) rotate_r = mgr.BVRor(rotate_l, 3) self.assertTrue(is_valid(Equals(one, rotate_r))) # print(rotate_l) # print(rotate_r) zero_ext = mgr.BVZExt(one, 64) signed_ext = mgr.BVSExt(one, 64) signed_ext2 = mgr.BVSExt(mgr.BVNeg(one), 64) self.assertNotEqual(signed_ext2, signed_ext) self.assertTrue(is_valid(Equals(zero_ext, signed_ext), logic=QF_BV)) # print(zero_ext) # print(signed_ext) x = Symbol("x") g = And(x, mgr.BVULT(zero, one)) res = is_sat(g, logic=QF_BV) self.assertTrue(res) model = get_model(g, logic=QF_BV) self.assertTrue(model[x] == TRUE()) gt_1 = mgr.BVUGT(zero, one) gt_2 = mgr.BVULT(one, zero) self.assertEqual(gt_1, gt_2) gte_1 = mgr.BVULE(zero, one) gte_2 = mgr.BVUGE(one, zero) self.assertEqual(gte_1, gte_2) self.assertTrue(is_valid(gte_2, logic=QF_BV)) ide = Equals(mgr.BVNeg(BV(10, 32)), mgr.SBV(-10, 32)) self.assertValid(ide, logic=QF_BV) # These should work without exceptions mgr.SBV(-2, 2) mgr.SBV(-1, 2) mgr.SBV(0, 2) mgr.SBV(1, 2) # Overflow and Underflow with self.assertRaises(ValueError): mgr.SBV(2, 2) with self.assertRaises(ValueError): mgr.SBV(-3, 2) # These should work without exceptions mgr.BV(0, 2) mgr.BV(1, 2) mgr.BV(2, 2) mgr.BV(3, 2) # Overflow with self.assertRaises(ValueError): mgr.BV(4, 2) # No negative number allowed with self.assertRaises(ValueError): mgr.BV(-1, 2) # SBV should behave as BV for positive numbers self.assertEqual(mgr.SBV(10, 16), mgr.BV(10, 16)) return
def test_bv(self): mgr = self.env.formula_manager BV = mgr.BV # Constants one = BV(1, 32) zero = BV(0, 32) big = BV(127, 128) binary = BV("111") binary2 = BV("#b111") binary3 = BV(0b111, 3) # In this case we need to explicit the width self.assertEqual(binary, binary2) self.assertEqual(binary2, binary3) self.assertEqual(one, mgr.BVOne(32)) self.assertEqual(zero, mgr.BVZero(32)) # Type Equality self.assertTrue(BV32 != BV128) self.assertFalse(BV32 != BV32) self.assertFalse(BV32 == BV128) self.assertTrue(BV32 == BV32) with self.assertRaises(PysmtValueError): # Negative numbers are not supported BV(-1, 10) with self.assertRaises(PysmtValueError): # Number should fit in the width BV(10, 2) # Variables b128 = Symbol("b", BV128) # BV1, BV8 etc. are defined in pysmt.typing b32 = Symbol("b32", BV32) hexample = BV(0x10, 32) bcustom = Symbol("bc", BVType(42)) self.assertIsNotNone(hexample) self.assertIsNotNone(bcustom) self.assertEqual(bcustom.bv_width(), 42) self.assertEqual(hexample.constant_value(), 16) not_zero32 = mgr.BVNot(zero) not_b128 = mgr.BVNot(b128) self.assertTrue(not_b128.is_bv_not()) f1 = Equals(not_zero32, b32) f2 = Equals(not_b128, big) self.assertTrue(is_sat(f1, logic=QF_BV)) self.assertTrue(is_sat(f2, logic=QF_BV)) zero_and_one = mgr.BVAnd(zero, one) self.assertTrue(zero_and_one.is_bv_and()) zero_or_one = mgr.BVOr(zero, one) self.assertTrue(zero_or_one.is_bv_or()) zero_xor_one = mgr.BVXor(zero, one) self.assertTrue(zero_xor_one.is_bv_xor()) zero_xor_one.simplify() self.assertTrue(zero_xor_one.is_bv_op()) f1 = Equals(zero_and_one, b32) f2 = Equals(zero_or_one, b32) f3 = Equals(zero_xor_one, b32) f4 = Equals(zero_xor_one, one) self.assertTrue(is_sat(f1, logic=QF_BV), f1) self.assertTrue(is_sat(f2, logic=QF_BV), f2) self.assertTrue(is_sat(f3, logic=QF_BV), f3) self.assertTrue(is_valid(f4, logic=QF_BV), f4) with self.assertRaises(PysmtTypeError): mgr.BVAnd(b128, zero) f = mgr.BVAnd(b32, zero) f = mgr.BVOr(f, b32) f = mgr.BVXor(f, b32) f = Equals(f, zero) self.assertTrue(is_sat(f, logic=QF_BV), f) zero_one_64 = mgr.BVConcat(zero, one) one_zero_64 = mgr.BVConcat(one, zero) one_one_64 = mgr.BVConcat(one, one) self.assertTrue(one_one_64.is_bv_concat()) self.assertFalse(one_one_64.is_bv_and()) self.assertTrue(zero_one_64.bv_width() == 64) f1 = Equals(mgr.BVXor(one_zero_64, zero_one_64), one_one_64) self.assertTrue(is_sat(f1, logic=QF_BV), f1) # MG: BV indexes grow to the left. # This is confusing and we should address this. extraction = mgr.BVExtract(zero_one_64, 32, 63) self.assertTrue(is_valid(Equals(extraction, zero))) ult = mgr.BVULT(zero, one) self.assertTrue(ult.is_bv_ult()) neg = mgr.BVNeg(one) self.assertTrue(neg.is_bv_neg()) self.assertTrue(is_valid(ult, logic=QF_BV), ult) test_eq = Equals(neg, one) self.assertTrue(is_unsat(test_eq, logic=QF_BV)) f = zero addition = mgr.BVAdd(f, one) self.assertTrue(addition.is_bv_add()) multiplication = mgr.BVMul(f, one) self.assertTrue(multiplication.is_bv_mul()) udiv = mgr.BVUDiv(f, one) self.assertTrue(udiv.is_bv_udiv()) self.assertTrue(is_valid(Equals(addition, one), logic=QF_BV), addition) self.assertTrue(is_valid(Equals(multiplication, zero), logic=QF_BV), multiplication) self.assertTrue(is_valid(Equals(udiv, zero), logic=QF_BV), udiv) three = mgr.BV(3, 32) two = mgr.BV(2, 32) self.assertEqual(3, three.bv2nat()) reminder = mgr.BVURem(three, two) self.assertTrue(reminder.is_bv_urem()) shift_l_a = mgr.BVLShl(one, one) self.assertTrue(shift_l_a.is_bv_lshl()) shift_l_b = mgr.BVLShl(one, 1) self.assertTrue(is_valid(Equals(reminder, one)), reminder) self.assertEqual(shift_l_a, shift_l_b) self.assertTrue(is_valid(Equals(shift_l_a, two))) shift_r_a = mgr.BVLShr(one, one) self.assertTrue(shift_r_a.is_bv_lshr()) shift_r_b = mgr.BVLShr(one, 1) self.assertEqual(shift_r_a, shift_r_b) self.assertTrue(is_valid(Equals(shift_r_a, zero))) ashift_r_a = mgr.BVAShr(one, one) ashift_r_b = mgr.BVAShr(one, 1) self.assertEqual(ashift_r_a, ashift_r_b) self.assertTrue(ashift_r_a.is_bv_ashr()) rotate_l = mgr.BVRol(one, 3) self.assertTrue(rotate_l.is_bv_rol()) rotate_r = mgr.BVRor(rotate_l, 3) self.assertTrue(rotate_r.is_bv_ror()) self.assertTrue(is_valid(Equals(one, rotate_r))) zero_ext = mgr.BVZExt(one, 64) self.assertTrue(zero_ext.is_bv_zext()) signed_ext = mgr.BVSExt(one, 64) self.assertTrue(signed_ext.is_bv_sext()) signed_ext2 = mgr.BVSExt(mgr.BVNeg(one), 64) self.assertNotEqual(signed_ext2, signed_ext) self.assertTrue(is_valid(Equals(zero_ext, signed_ext), logic=QF_BV)) x = Symbol("x") g = And(x, mgr.BVULT(zero, one)) res = is_sat(g, logic=QF_BV) self.assertTrue(res) model = get_model(g, logic=QF_BV) self.assertTrue(model[x] == TRUE()) gt_1 = mgr.BVUGT(zero, one) gt_2 = mgr.BVULT(one, zero) self.assertEqual(gt_1, gt_2) gte_1 = mgr.BVULE(zero, one) gte_2 = mgr.BVUGE(one, zero) self.assertEqual(gte_1, gte_2) self.assertTrue(is_valid(gte_2, logic=QF_BV)) ide = Equals(mgr.BVNeg(BV(10, 32)), mgr.SBV(-10, 32)) self.assertValid(ide, logic=QF_BV) # These should work without exceptions mgr.SBV(-2, 2) mgr.SBV(-1, 2) mgr.SBV(0, 2) mgr.SBV(1, 2) # Overflow and Underflow with self.assertRaises(PysmtValueError): mgr.SBV(2, 2) with self.assertRaises(PysmtValueError): mgr.SBV(-3, 2) # These should work without exceptions mgr.BV(0, 2) mgr.BV(1, 2) mgr.BV(2, 2) mgr.BV(3, 2) # Overflow with self.assertRaises(PysmtValueError): mgr.BV(4, 2) # No negative number allowed with self.assertRaises(PysmtValueError): mgr.BV(-1, 2) # SBV should behave as BV for positive numbers self.assertEqual(mgr.SBV(10, 16), mgr.BV(10, 16)) # Additional is_bv_* tests f = mgr.BVSub(one, one) self.assertTrue(f.is_bv_sub()) f = mgr.BVSLT(one, one) self.assertTrue(f.is_bv_slt()) f = mgr.BVSLE(one, one) self.assertTrue(f.is_bv_sle()) f = mgr.BVComp(one, one) self.assertTrue(f.is_bv_comp()) f = mgr.BVSDiv(one, one) self.assertTrue(f.is_bv_sdiv()) f = mgr.BVSRem(one, one) self.assertTrue(f.is_bv_srem()) f = mgr.BVULE(one, one) self.assertTrue(f.is_bv_ule())
from pysmt.shortcuts import And, Symbol, LE, GE, Int, Equals, Plus, Times, is_sat, get_model from pysmt.typing import INT hello = [Symbol(s, INT) for s in "hello"] world = [Symbol(s, INT) for s in "world"] letters = set(hello+world) domains = And([And( LE(Int(1), l), GE(Int(10), l) ) for l in letters]) sum_hello = Plus(hello) sum_world = Plus(world) problem = And(Equals(sum_hello, sum_world), Equals(sum_hello, Int(25))) formula = And(domains, problem) print("Printing model:") print(get_model(formula))
And(ExactlyOne(color(i, c) for i in Houses) for c in Color), And(ExactlyOne(nat(i, c) for i in Houses) for c in Nat), And(ExactlyOne(pet(i, c) for i in Houses) for c in Pet), And(ExactlyOne(drink(i, c) for i in Houses) for c in Drink), And(ExactlyOne(smoke(i, c) for i in Houses) for c in Smoke), # And(ExactlyOne(color(i, c) for c in Color) for i in Houses), And(ExactlyOne(nat(i, c) for c in Nat) for i in Houses), And(ExactlyOne(pet(i, c) for c in Pet) for i in Houses), And(ExactlyOne(drink(i, c) for c in Drink) for i in Houses), And(ExactlyOne(smoke(i, c) for c in Smoke) for i in Houses), ) problem = And(domain, facts) model = get_model(problem) if model is None: print("UNSAT") # We first check whether the constraints on the domain and problem # are satisfiable in isolation. assert is_sat(facts) assert is_sat(domain) assert is_unsat(problem) # In isolation they are both fine, rules from both are probably # interacting. # # The problem is given by a nesting of And(). # conjunctive_partition can be used to obtain a "flat" # structure, i.e., a list of conjuncts.
# Otherwise IntToStr returns the empty string randint >= 0) return s, f # Create a strong passowrd from the initial one new_password, constr = strengthen_password(password_in) # If the input password is strong, if not, use the strengthen_password check = And(password_out.Equals(Ite(is_good_password(password_in), password_in, new_password)), constr) # Run the example by providing an example password to be checked import sys if len(sys.argv) >= 2: user_pass = sys.argv[1] else: print("Usage %s <password>" % sys.argv[0]) user_pass = "******" m1 = get_model(And(password_in.Equals(String(user_pass)), check)) print(m1[password_out]) # Is our 'strengthen' procedure always yielding a strong password? # Can you think of an input that would not be properly sanitized? m2 = get_model(And(check, Not(is_good_password(password_out)))) print(m2[password_in])
def app(args): # sample data from the corners of the unit HyperCube n_layers = 1 n_data = [10, 100, 1000, 10000, 100000] n_weight = [2, 4, 8, 16, 32] data_dimension = [2, 4, 8, 16, 32]#, 3, 4]#, 8, 16, 32, 64, 128, 256, 512, 1024] for n_weights, dim in zip(n_weight, data_dimension): for n_samples in n_data: data, labels = generate_iid_samples(dim, n_samples) if args.verbose: print ('generated data for dim={}: {}'.format(dim, list(zip(data, labels)))) training_symbols = [] label_symbols = [] # Create symbolic representation of data training_symbols = [Symbol('input_{}'.format(i), BOOL) for i in range(len(data))] label_symbols = [Symbol('label_{}'.format(i), REAL) for i in range(len(labels))] bin_x = np.array([np.binary_repr(sample, width=dim) for sample in data]) layers = [] layer_input = bin_x weights = [] for layer in range(n_layers): weight_symbols = [Symbol('weight_{}'.format(i), REAL) for i in range(n_weights)] weights.extend(weight_symbols) bias_symbol = Symbol('bias_{}'.format(layer), REAL) layer_domains = [] for i in range(len(layer_input)): # loop over data # \sum <w_ji, x_i> + b_i weight_input_i = Plus([Times(w_j, Real(int(x_j))) for w_j, x_j in zip(weight_symbols, layer_input[i])]) prod_bias_i = Plus(weight_input_i, bias_symbol) layer_domain = Equals(prod_bias_i, Real(labels[i])) layer_domains.append(layer_domain) layer = And(x for x in layer_domains) layers.append(layer) network_domain = And([x for x in layers]) dnn_problem = network_domain if args.verbose: print ('DNN [Boolean expression]: ', dnn_problem) print ('DNN [Satisfiable?]: ', is_sat(dnn_problem)) if is_sat(dnn_problem): model = get_model(dnn_problem) print (model) else: print ('[DNN] not satisfiable') break with Solver(name='msat') as solver: solver.add_assertion(dnn_problem) if solver.solve(): # extract_values weights = [float(solver.get_py_value(w)) for w in weights] bias = float(solver.get_py_value(bias_symbol)) # evaluate model on generated weights eval_smt_dnn(x=bin_x, w=weights, b=bias, y=labels)
# # could get 'dump', 'value', 'xf_index' # # print thecell.value, # xfx = sheet.cell_xf_index(row, col) # xf = book.xf_list[xfx] # bgx = xf.background.pattern_colour_index # # print bgx # color_set.add(bgx) # print(color_set) # return color_set # # if __name__ == "__main__": workers, jobs = load_data() k = IntervalTree() # for w in workers: # k = k|w.availability # # print(k) # # exit(0) print(workers) const = get_constraints(jobs, workers) formula = And(const) model = get_model(formula) if model: print(model) else: print("No solution found")
def timed_get_model(*args, **kwargs): return get_model(*args, **kwargs)
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
all_classes, #prereqs_init, prereqs_only, coreqs_only, already_taken_courses, not_yet_taken_courses, electives_courses, restrict_electives, csm101, fall_courses, spring_courses, other_courses) print("Generate model") model = get_model(facts_domain, solver_name=args.solver) #print model if model is None: print("UNSAT") print("Please verify that the student fields are correct.") # In isolation they are both fine, rules from both are probably # interacting. # # The problem is given by a nesting of And(). # conjunctive_partition can be used to obtain a "flat" # structure, i.e., a list of conjuncts. # from pysmt.rewritings import conjunctive_partition conj = conjunctive_partition(facts_domain) ucore = get_unsat_core(conj)
prefixes_f, prefixes_r, suffixes_f, suffixes_r = enumerate_fixes(train) G = build_distinguishability_graph(train, prefixes_r, suffixes_r) clique = dfa_clique_approx(G, train, prefixes_r) states = len(clique) state_limit = 13 total_time = 0 while True: print(f'Building problem for {states} states') x, y, z, model_c = min_dfa_setup_model(train, prefixes_f, prefixes_r, G, sigma, states) symmetry_c = break_dfa_symmetry_bfs(x, y, sigma, prefixes_r, states) # symmetry_c = break_dfa_symmetry_clique(x, clique) start_time = time.perf_counter() print(f'Starting solver: {len(model_c) + len(symmetry_c)} constraints') model = get_model(And(*model_c, *symmetry_c).simplify(), 'z3') end_time = time.perf_counter() solve_time = end_time - start_time total_time += solve_time print(f"Took {solve_time:.4f} seconds") if model: break states += 1 if states > state_limit: break print(f'Found solution with {states} states!') print(f'Took {total_time:.4f} seconds') dfa = extract_dfa(model, x, y, z, sigma, prefixes_r, states)
def iterate_to_find_satisfiable_solution(features, feature_implimentation_time, dependencies, sequential, developers, feature_developer, parallel_tasks, end_time): feature_time_map = {} i = 1 for fe in features: feature_time_map[fe] = { 'EndTime': Symbol('E' + str(i), INT), 'StartTime': Symbol('S' + str(i), INT), 'Duration': Int(feature_implimentation_time[i - 1]) } i += 1 b_greater = And( And(GE(feature_time_map[fe]['EndTime'], Int(0)), GE(feature_time_map[fe]['StartTime'], Int(0))) for fe in features) b_impli_time = And( Equals( Minus(feature_time_map[l]['EndTime'], feature_time_map[l] ['StartTime']), feature_time_map[l]['Duration']) for l in features) b_dependencies = And( GE(feature_time_map[depe[1]]['StartTime'], feature_time_map[depe[0]] ['EndTime']) for depe in dependencies) b_sequential = And( Or( GE(feature_time_map[seq[1]]['StartTime'], feature_time_map[seq[0]] ['EndTime']), GE(feature_time_map[seq[0]]['StartTime'], feature_time_map[seq[1]] ['EndTime'])) for seq in sequential) developer_feature_imp = {} for fet_dev in feature_developer: developer_feature_imp.setdefault(fet_dev[1], []).append(fet_dev[0]) and_relation = [] for val in developer_feature_imp.values(): if len(val) > 1: for comb in combinations(val, 2): and_relation.append( Or( GE(feature_time_map[comb[1]]['StartTime'], feature_time_map[comb[0]]['EndTime']), GE(feature_time_map[comb[0]]['StartTime'], feature_time_map[comb[1]]['EndTime']))) b_dev_pararale = And(and_relation) and_parallel = [] for val in parallel_tasks: and_parallel.append( And( LE(feature_time_map[val[0]]['StartTime'], feature_time_map[val[1]]['StartTime']), GE(feature_time_map[val[0]]['EndTime'], feature_time_map[val[1]]['StartTime']))) b_parallel = And(and_parallel) print('++++++++++++++Conditions++++++++++++++++') print('Start and End times should be grater than zero : ', b_greater) print('Difference between end and start times : ', b_impli_time) print('Some features should be implimented first : ', b_dependencies) print('Some features can not be executed parallelly : ', b_sequential) print('Some features need specific developers : ', b_dev_pararale) print('Some features need to be started before ending some features : ', b_parallel) print('++++++++++++++Release Dates++++++++++++++++') end_time = 1 max_end_time = sum(feature_implimentation_time) sloved = False for end in tqdm(range(max_end_time), 'running binary search to find shortest release date'): b_end_time = And( LE(fe['EndTime'], Int(end_time)) for fe in feature_time_map.values()) formula = And(b_greater, b_impli_time, b_dependencies, b_sequential, b_dev_pararale, b_end_time, b_parallel) if is_sat(formula): print('\n' + 'You have to spend at least', end_time, 'days to finish your next release') print('Therefore, the closest release date is :', (datetime.today() + timedelta(end_time)).strftime('%d/%m/%Y')) for key, val in feature_time_map.items(): print( 'Feature', key, ', Start Date :', (datetime.today() + timedelta( get_model(formula)[val['StartTime']].constant_value()) ).strftime('%d/%m/%Y'), '-> End Date : ', (datetime.today() + timedelta( get_model(formula)[val['EndTime']].constant_value()) ).strftime('%d/%m/%Y')) sloved = True break end_time += 1 if sloved == False: print("This problem is not solvable") # print(b_devlopers) # print(is_sat(b_devlopers)) return len(formula.serialize()), 'S' if is_sat(formula) else 'U'
from pysmt.shortcuts import Symbol, And, GE, LT, Plus, Equals, Int, get_model from pysmt.typing import INT hello = [Symbol(s, INT) for s in "hello"] world = [Symbol(s, INT) for s in "world"] letters = set(hello + world) domains = And([And(GE(l, Int(1)), LT(l, Int(10))) for l in letters]) print domains sum_hello = Plus(hello) # n-ary operators can take lists sum_world = Plus(world) # as arguments problem = And(Equals(sum_hello, sum_world), Equals(sum_hello, Int(25))) formula = And(domains, problem) print("Serialization of the formula:") print(formula) model = get_model(formula) if model: print(model) else: print("No solution found")
StrLength(s) >= 10, # And that randint is a natural number # Otherwise IntToStr returns the empty string randint >= 0) return s, f # Create a strong passowrd from the initial one new_password, constr = strengthen_password(password_in) # If the input password is strong, if not, use the strengthen_password check = And( password_out.Equals( Ite(is_good_password(password_in), password_in, new_password)), constr) # Run the example by providing an example password to be checked import sys if len(sys.argv) >= 2: user_pass = sys.argv[1] else: print("Usage %s <password>" % sys.argv[0]) user_pass = "******" m1 = get_model(And(password_in.Equals(String(user_pass)), check)) print(m1[password_out]) # Is our 'strengthen' procedure always yielding a strong password? # Can you think of an input that would not be properly sanitized? m2 = get_model(And(check, Not(is_good_password(password_out)))) print(m2[password_in])
def test_sample(self, sample): """ Check whether or not the encoding "predicts" the same class as the classifier given an input sample. """ # first, compute the scores for all classes as would be # predicted by the classifier # score arrays computed for each class csum = [[] for c in range(self.nofcl)] if self.optns.verb: print('testing sample:', list(sample)) sample_internal = list(self.xgb.transform(sample)[0]) # traversing all trees for i, tree in enumerate(self.ensemble.trees): # getting class id clid = i % self.nofcl # a score computed by the current tree score = scores_tree(tree, sample_internal) # this tree contributes to class with clid csum[clid].append(score) # final scores for each class cscores = [sum(scores) for scores in csum] # second, get the scores computed with the use of the encoding # asserting the sample hypos = [] if not self.intvs: for i, fval in enumerate(sample_internal): feat, vid = self.xgb.transform_inverse_by_index(i) fid = self.feats[feat] if vid == None: fvar = Symbol('f{0}'.format(fid), typename=REAL) hypos.append(Equals(fvar, Real(float(fval)))) else: fvar = Symbol('f{0}_{1}'.format(fid, vid), typename=BOOL) if int(fval) == 1: hypos.append(fvar) else: hypos.append(Not(fvar)) else: for i, fval in enumerate(sample_internal): feat, _ = self.xgb.transform_inverse_by_index(i) feat = 'f{0}'.format(self.feats[feat]) # determining the right interval and the corresponding variable for ub, fvar in zip(self.intvs[feat], self.ivars[feat]): if ub == '+' or fval < ub: hypos.append(fvar) break else: assert 0, 'No proper interval found for {0}'.format(feat) # now, getting the model escores = [] model = get_model(And(self.enc, *hypos), solver_name=self.optns.solver) for c in range(self.nofcl): v = Symbol('class{0}_score'.format(c), typename=REAL) escores.append(float(model.get_py_value(v))) assert all(map(lambda c, e: abs(c - e) <= 0.001, cscores, escores)), \ 'wrong prediction: {0} vs {1}'.format(cscores, escores) if self.optns.verb: print('xgb scores:', cscores) print('enc scores:', escores)
from pysmt.shortcuts import And, Symbol, LE, GE, Int, Equals, Plus, Times, is_sat, get_model from pysmt.typing import INT hello = [Symbol(s, INT) for s in "hello"] world = [Symbol(s, INT) for s in "world"] letters = set(hello + world) domains = And([And(LE(Int(1), l), GE(Int(10), l)) for l in letters]) sum_hello = Plus(hello) sum_world = Plus(world) problem = And(Equals(sum_hello, sum_world), Equals(sum_hello, Int(25))) formula = And(domains, problem) print("Printing model:") print(get_model(formula))