def test_nested(): formula = (smt.Symbol("x", smt.REAL) * smt.Real(2) + smt.Real(5.125)) * smt.Real(-1.25) positive = (smt.Symbol("x", smt.REAL) * smt.Real(2) + smt.Real(5.125)) * smt.Real(1.25) result = make_coefficients_positive(formula) assert Polynomial.from_smt(positive) == Polynomial.from_smt(result)
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 example4(domain): x, y = smt.Symbol("x", REAL), smt.Symbol("y", REAL) return domain, ( ((106.452209182 < 58.3305562428 * x + 162.172448357 * y) | (-82.1173457701 < -121.782718841 * x + -45.7311195244 * y)) & ((58.3305562428 * x + 162.172448357 * y <= 106.452209182) | (-121.782718841 * x + -45.7311195244 * y <= -82.1173457701)))
def example3(domain): x, y = smt.Symbol("x", REAL), smt.Symbol("y", REAL) return domain, ( ((5.03100425089 < 4.72202520763 * x + 4.11473198213 * y) | (-4.6261635019 < -5.93640712709 * x + -5.87100650773 * y)) & ((5.03100425089 < 4.72202520763 * x + 4.11473198213 * y) | (-4.6261635019 < -5.93640712709 * x + -5.87100650773 * y)))
def test_simpleSymbol_true(self): symbol_name = "b" checker = SmtChecker({symbol_name: True}) self.assertTrue(checker.walk_smt(smt.Symbol(symbol_name))) checker = SmtChecker({symbol_name: smt.Bool(True)}) self.assertTrue(checker.walk_smt(smt.Symbol(symbol_name)))
def test_simpleSymbol_false(self): symbol_name = "b" checker = SmtChecker({symbol_name: False}) self.assertFalse(checker.walk_smt(smt.Symbol(symbol_name))) checker = SmtChecker({symbol_name: smt.Bool(False)}) self.assertFalse(checker.walk_smt(smt.Symbol(symbol_name)))
def test_convert_weight(): x, y = smt.Symbol("x", smt.REAL), smt.Symbol("y", smt.REAL) a = smt.Symbol("a", smt.BOOL) weight_function = (smt.Ite( (a & (x > 0) & (x < 10) & (x * 2 <= 20) & (y > 0) & (y < 10)) | (x > 0) & (x < y) & (y < 20), x + y, x * y, ) + 2)
def __init__(self, value=SMYBOLIC, *, name=AUTOMATIC): if name is not AUTOMATIC and value is not SMYBOLIC: raise TypeError('Can only name symbolic variables') elif name is not AUTOMATIC: if not isinstance(name, str): raise TypeError('Name must be string') elif name in _name_table: raise ValueError(f'Name {name} already in use') _name_table[name] = self T = BVType(self.size) if value is SMYBOLIC: if name is AUTOMATIC: value = shortcuts.FreshSymbol(T) else: value = shortcuts.Symbol(name, T) elif isinstance(value, pysmt.fnode.FNode): t = value.get_type() if t is not T: raise TypeError(f'Expected {T} not {t}') elif isinstance(value, type(self)): value = value._value elif isinstance(value, int): value = shortcuts.BV(value, self.size) else: raise TypeError(f"Can't coerce {value} to SMTFPVector") self._name = name self._value = value
def get_variable_groups_poly( cls, weight: Polynomial, real_vars: List[str] ) -> List[Tuple[Set[str], Polynomial]]: if isinstance(weight, Polynomial): if len(real_vars) > 0: result = [] found_vars = weight.variables for v in real_vars: if v not in found_vars: result.append(({v}, Polynomial.from_constant(1))) return result + cls.get_variable_groups_poly(weight, []) if len(weight.poly_dict) > 1: return [(weight.variables, weight)] elif len(weight.poly_dict) == 0: return [(set(), Polynomial.from_constant(0))] else: result = defaultdict(lambda: Polynomial.from_constant(1)) for name, value in weight.poly_dict.items(): if len(name) == 0: result[frozenset()] *= Polynomial.from_constant(value) else: for v in name: result[frozenset((v,))] *= Polynomial.from_smt( smt.Symbol(v, smt.REAL) ) result[frozenset()] *= Polynomial.from_constant(value) return list(result.items()) else: raise NotImplementedError
def sympy2pysmt(expr, expr_type=None): if type(expr ) == Poly: # turn Poly instances into generic sympy expressions expr = expr.as_expr() op = type(expr) if len(expr.free_symbols) == 0: if expr.is_Boolean: return smt.Bool(bool(expr)) elif expr.is_number: return smt.Real(float(expr)) elif op == sym.Symbol: if expr_type is None: raise ValueError( "Can't create a pysmt Symbol without type information") return smt.Symbol(expr.name, expr_type) elif op in SYM2SMT: if expr_type is None: expr_type = OP_TYPE[op] smtargs = [sympy2pysmt(c, expr_type) for c in expr.args] return SYM2SMT[op](*smtargs) raise NotImplementedError(f"SYMPY -> PYSMT Not implemented for op: {op}")
def query_oracle(self, dis_formula): self.solver_oracle.reset_assertions() c0 = self.attack_formulas.oracle_ckt_at_frame(0) for i in range(len(c0)): self.solver_oracle.add_assertion(c0[i]) dis_out = [] for d in range(1, self.unroll_depth + 1): c0 = self.attack_formulas.oracle_ckt_at_frame(d) for i in range(len(c0)): self.solver_oracle.add_assertion(c0[i]) self.solver_oracle.add_assertion(pystm.And(dis_formula[d - 1])) if not self.solver_oracle.is_sat(pystm.TRUE()): logging.critical('something is wrong in oracle query') exit() else: dip_out = [] # for w in self.oracle_cir.output_wires: for w in self.obf_cir.output_wires: f = pystm.Symbol(w + '@{}'.format(d)) dip_out.append(self.solver_oracle.get_value(f)) dis_out.append(dip_out) logging.info(dis_out) return dis_out
def to_sbv(self, size: int) -> SMTBitVector: cls = type(self) ufs = _uf_table[cls]['to_usbv'] if size not in ufs: name = '.'.join((cls.__name__, f'to_sbv[{size}]')) ufs[size] = shortcuts.Symbol( name, FunctionType(BVType(size), (BVType(self.size), ))) return SMTBitVector[size](ufs[size](self._value))
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 test_convert_support(): x, y = smt.Symbol("x", smt.REAL), smt.Symbol("y", smt.REAL) a = smt.Symbol("a", smt.BOOL) formula = (x < 0) | (~a & (x < -1)) | smt.Ite(a, x < 4, x < 8) # Convert formula into abstracted one (replacing inequalities) env, repl_formula, literal_info = extract_and_replace_literals(formula) result = compile_to_sdd(formula=repl_formula, literals=literal_info, vtree=None) recovered = recover_formula(sdd_node=result, literals=literal_info, env=env) # print(pretty_print(recovered)) with smt.Solver() as solver: solver.add_assertion(~smt.Iff(formula, recovered)) # print(pretty_print(formula)) # print(pretty_print(recovered)) assert not solver.solve( ), f"Expected UNSAT but found model {solver.get_model()}"
def check(self, sys): styp = type(sys) if styp is BD.VarIntro: smtsym = SMT.Symbol(repr(sys.name), SMT.INT) self._ctxt.set(sys.name, smtsym) self.check(sys.cont) elif styp is BD.RelIntro: Rtyp = SMT.FunctionType(SMT.BOOL, [SMT.INT for i in range(0, sys.n_args)]) smtsym = SMT.Symbol(repr(sys.name), Rtyp) self._ctxt.set(sys.name, smtsym) self.check(sys.cont) elif styp is BD.Guard: pred = self.formula(sys.pred) self._slv.add_assertion(pred) self.check(sys.cont) elif styp is BD.Both: # make sure we can backtrack from the first branch self._slv.push() self._ctxt.push() self.check(sys.lhs) self._ctxt.pop() self._slv.pop() # now the second branch we can just proceed self.check(sys.rhs) elif styp is BD.Check: pred = SMT.Not(self.formula(sys.pred)) failure = self._slv.is_sat(pred) if failure: mapping = self._get_solution(pred) self._err(sys, f"Out of Bounds Access:\n{mapping}") # continue regardless self.check(sys.cont) elif styp is BD.NullSys: pass
def __encodeTerminal(symbolicExpression, type): if isinstance(symbolicExpression, sympy.Symbol): if type.literal == 'Integer': return pysmt.Symbol(symbolicExpression.name, pysmt.INT) elif type.literal == 'Real': return pysmt.Symbol(symbolicExpression.name, pysmt.REAL) elif type.literal == 'Bool': return pysmt.Symbol(symbolicExpression.name, pysmt.BOOL) else: # type.literal == 'BitVector' return pysmt.Symbol(symbolicExpression.name, pysmt.BVType(type.size)) else: if type.literal == 'Integer': return pysmt.Int(symbolicExpression.p) elif type.literal == 'Real': if isinstance(symbolicExpression, sympy.Rational): return pysmt.Real(symbolicExpression.p / symbolicExpression.q) else: # isinstance(symbolicExpression, sympy.Float) return pysmt.Real(symbolicExpression) elif type.literal == 'Bool': return pysmt.Bool(symbolicExpression) else: # type.literal == 'BitVector' return pysmt.BV(symbolicExpression, type.size)
def __init_subclass__(cls): _uf_table[cls] = ufs = dict() T = BVType(cls.size) for method_name, *args in _SIGS: args = [T if x is None else x for x in args] rtype = args[-1] params = args[:-1] name = '.'.join((cls.__name__, method_name)) ufs[method_name] = shortcuts.Symbol(name, FunctionType(rtype, params)) ufs['to_sbv'] = dict() ufs['to_ubv'] = dict()
def query_dip_generator(self): dis_boolean = [] for d in range(1, self.unroll_depth + 1): dip_boolean = [] for w in self.obf_cir.input_wires: f = pystm.Symbol(w + '@{}'.format(d)) if self.solver_obf.get_py_value(f): dip_boolean.append(pystm.TRUE()) else: dip_boolean.append(pystm.FALSE()) dis_boolean.append(dip_boolean) return dis_boolean
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 __init__(self, value=SMYBOLIC, *, name=AUTOMATIC, prefix=AUTOMATIC): if (name is not AUTOMATIC or prefix is not AUTOMATIC) and value is not SMYBOLIC: raise TypeError('Can only name symbolic variables') elif name is not AUTOMATIC and prefix is not AUTOMATIC: raise ValueError('Can only set either name or prefix not both') elif name is not AUTOMATIC: if not isinstance(name, str): raise TypeError('Name must be string') elif name in _name_table: raise ValueError(f'Name {name} already in use') elif _name_re.fullmatch(name): warnings.warn( 'Name looks like an auto generated name, this might break things' ) _name_table[name] = self elif prefix is not AUTOMATIC: name = _gen_name(prefix) _name_table[name] = self elif name is AUTOMATIC and value is SMYBOLIC: name = _gen_name() _name_table[name] = self if value is SMYBOLIC: self._value = smt.Symbol(name, BOOL) elif isinstance(value, pysmt.fnode.FNode): if value.get_type().is_bool_type(): self._value = value else: raise TypeError(f'Expected bool type not {value.get_type()}') elif isinstance(value, SMTBit): if name is not AUTOMATIC and name != value.name: warnings.warn( 'Changing the name of a SMTBit does not cause a new underlying smt variable to be created' ) self._value = value._value elif isinstance(value, bool): self._value = smt.Bool(value) elif isinstance(value, int): if value not in {0, 1}: raise ValueError( 'Bit must have value 0 or 1 not {}'.format(value)) self._value = smt.Bool(bool(value)) elif hasattr(value, '__bool__'): self._value = smt.Bool(bool(value)) else: raise TypeError("Can't coerce {} to Bit".format(type(value))) self._name = name self._value = smt.simplify(self._value)
def print_keys(self): # logging.warning('print keys') # add initial states c0, c1 = self.attack_formulas.obf_ckt_at_frame(0) for i in range(len(c0)): self.solver_key.add_assertion(c0[i]) self.solver_key.add_assertion(c1[i]) if self.solver_key.solve(): key = '' for w in self.obf_cir.key_wires: k = w + '_0' if self.solver_key.get_py_value(pystm.Symbol(k)): key += '1' else: key += '0' logging.warning('iterations={}, highest depth={}'.format(self.iteration, self.highest_depth)) # logging.warning("key=%s" % key[::-1]) logging.warning("key=%s" % key) else: logging.warning('something is wrong! could not find a correct key')
def test_bv2pysmt(self): bvx, bvy = Variable("x", 8), Variable("y", 8) psx, psy = bv2pysmt(bvx), bv2pysmt(bvy) self.assertEqual(bv2pysmt(Constant(0, 8)), sc.BV(0, 8)) self.assertEqual(psx, sc.Symbol("x", typing.BVType(8))) self.assertEqual(bv2pysmt(~bvx), sc.BVNot(psx)) self.assertEqual(bv2pysmt(bvx & bvy), sc.BVAnd(psx, psy)) self.assertEqual(bv2pysmt(bvx | bvy), sc.BVOr(psx, psy)) self.assertEqual(bv2pysmt(bvx ^ bvy), sc.BVXor(psx, psy)) self.assertEqual(bv2pysmt(BvComp(bvx, bvy)), sc.Equals(psx, psy)) self.assertEqual(bv2pysmt(BvNot(BvComp(bvx, bvy))), sc.Not(sc.Equals(psx, psy))) self.assertEqual(bv2pysmt(bvx < bvy), sc.BVULT(psx, psy)) self.assertEqual(bv2pysmt(bvx <= bvy), sc.BVULE(psx, psy)) self.assertEqual(bv2pysmt(bvx > bvy), sc.BVUGT(psx, psy)) self.assertEqual(bv2pysmt(bvx >= bvy), sc.BVUGE(psx, psy)) self.assertEqual(bv2pysmt(bvx << bvy), sc.BVLShl(psx, psy)) self.assertEqual(bv2pysmt(bvx >> bvy), sc.BVLShr(psx, psy)) self.assertEqual(bv2pysmt(RotateLeft(bvx, 1)), sc.BVRol(psx, 1)) self.assertEqual(bv2pysmt(RotateRight(bvx, 1)), sc.BVRor(psx, 1)) self.assertEqual(bv2pysmt(bvx[4:2]), sc.BVExtract(psx, 2, 4)) self.assertEqual(bv2pysmt(Concat(bvx, bvy)), sc.BVConcat(psx, psy)) # zeroextend reduces to Concat # self.assertEqual(bv2pysmt(ZeroExtend(bvx, 2)), sc.BVZExt(psx, 2)) self.assertEqual(bv2pysmt(Repeat(bvx, 2)), psx.BVRepeat(2)) self.assertEqual(bv2pysmt(-bvx), sc.BVNeg(psx)) self.assertEqual(bv2pysmt(bvx + bvy), sc.BVAdd(psx, psy)) # bvsum reduces to add # self.assertEqual(bv2pysmt(bvx - bvy), sc.BVSub(psx, psy)) self.assertEqual(bv2pysmt(bvx * bvy), sc.BVMul(psx, psy)) self.assertEqual(bv2pysmt(bvx / bvy), sc.BVUDiv(psx, psy)) self.assertEqual(bv2pysmt(bvx % bvy), sc.BVURem(psx, psy))
def symbol(self, name): return smt.Symbol(name, REAL)
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 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 to_symbol(s): return smt.Symbol(s, typename=smt.types.INT)
def walk_symbol(self, name, v_type): return smt.Symbol(name, v_type)
def example1(domain): x, y = smt.Symbol("x", REAL), smt.Symbol("y", REAL) return domain, (x + y <= 0.5)
def example6(domain): x, y = smt.Symbol("x", REAL), smt.Symbol("y", REAL) return domain, ( ((-1.27554738321 < 2.00504448571 * x + -2.40276942762 * y) | (4.56336137649 < 11.0066321223 * x + -9.72098326672 * y)) & (11.0066321223 * x + -9.72098326672 * y <= 4.56336137649))
def example5(domain): x, y = smt.Symbol("x", REAL), smt.Symbol("y", REAL) return domain, ( ((-1.81491574069 < 2.82223533496 * x + -2.86421413834 * y) | (1.74295350642 < 5.75692214636 * x + -5.67797696689 * y)) & (5.75692214636 * x + -5.67797696689 * y <= 1.74295350642))