def test_iterative_get_free_variables(self): f = Symbol("x") for _ in xrange(1000): f = And(f, f) cone = f.get_free_variables() self.assertEqual(cone, set([Symbol("x")]))
def test_basic(self): varA = Symbol("A") f = And(varA, Not(varA)) self.assertEqual(f.size(), 4) self.assertEqual(f.size(SizeOracle.MEASURE_TREE_NODES), 4) self.assertEqual(f.size(SizeOracle.MEASURE_DAG_NODES), 3) self.assertEqual(varA.size(SizeOracle.MEASURE_LEAVES), 1) self.assertEqual(f.size(SizeOracle.MEASURE_DEPTH), 3) self.assertEqual(f.size(SizeOracle.MEASURE_SYMBOLS), 1)
def test_leaf(self): varA = Symbol("A") self.assertEqual(varA.size(), 1) self.assertEqual(varA.size(SizeOracle.MEASURE_TREE_NODES), 1) self.assertEqual(varA.size(SizeOracle.MEASURE_DAG_NODES), 1) self.assertEqual(varA.size(SizeOracle.MEASURE_LEAVES), 1) self.assertEqual(varA.size(SizeOracle.MEASURE_DEPTH), 1) self.assertEqual(varA.size(SizeOracle.MEASURE_SYMBOLS), 1)
def add_lt(x_str, v): global solver x = Symbol(x_str, REAL) solver.push() solver.add_assertion(x < v)
def add_opposite_eq(neg_obj_str, obj_str): global solver solver.push() neg_obj = Symbol(neg_obj_str, REAL) obj = Symbol(obj_str, REAL) solver.add_assertion(obj + neg_obj == 0)
def get_ceil(model, x_str): x = Symbol(x_str, REAL) ceilvalue = math.ceil(float(model.get_value(x).simplify())) return str(ceilvalue)
def get_model_value(model, x_str): x = Symbol(x_str, REAL) return str(model[x])
def __init__(self, name): assert name in X86StackRegister.register_names self.name = name self.sym = Symbol(name, INT)
def test_node_id(self): x = Symbol("x") y = Symbol("y") xx = Symbol("x") self.assertEqual(x.node_id(), xx.node_id()) self.assertNotEqual(x.node_id(), y.node_id())
def test_msat_bool_back_conversion(self): f = Symbol("A") with Solver(name='msat') as solver: solver.solve() val = solver.get_value(Symbol("A")) self.assertTrue(val.is_bool_constant())
def test_function_smtlib_print(self): f_t = FunctionType(BOOL, [BOOL]) f0 = Symbol('f 0', f_t) f0_of_false = Function(f0, [Bool(False)]) s = to_smtlib(f0_of_false, False) self.assertEqual(s, '(|f 0| false)')
def test_empty_string_symbol(self): with self.assertRaises(PysmtValueError): Symbol("")
def test_substitute_to_real(self): p = Symbol("p", INT) f = LT(ToReal(p), Real(0)) new_f = f.substitute({p: Real(1)}).simplify() self.assertEqual(new_f, Bool(False))
def test_cnf_as_set(self): r = cnf_as_set(Symbol("x")) self.assertTrue(type(r) == frozenset)
def test_error(self): varA = Symbol("A") with self.assertRaises(NotImplementedError): varA.size("non-existent")
def test_prenex_simple_forall(self): a, b = (Symbol(x) for x in "ab") f = Or(b, ForAll([b], Implies(a, b))) prenex = prenex_normal_form(f) self.assertTrue(prenex.is_forall()) self.assertValid(Iff(f, prenex), logic=BOOL)
def setUp(self): TestCase.setUp(self) self.x, self.y = Symbol("x"), Symbol("y")
def test_real(self): f = Plus([Real(1), Symbol("x", REAL), Symbol("y", REAL)]) self.assertEqual(f.to_smtlib(daggify=False), "(+ 1.0 x y)") self.assertEqual(f.to_smtlib(daggify=True), "(let ((.def_0 (+ 1.0 x y))) .def_0)")
# # In this example, we use four theories supported by pySMT: # BitVectors, Integers, Reals, and Arrays. # # from pysmt.shortcuts import Symbol, BV, Real, And, BVToNatural, ToReal from pysmt.shortcuts import get_model from pysmt.typing import BV8, REAL, INT, ArrayType # 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
def variables(n): # the Boolean network is represented by n*2^n Boolean variables return [[Symbol("x{}_{}".format(i + 1, j + 1)) for j in range(n)] for i in range(2**n)]
def test_toreal(self): p = Symbol("p", INT) rp = ToReal(p) rp_string = self.print_to_string(rp) self.assertEqual(rp_string, "(to_real p)")
def is_int(model, x_str): x = Symbol(x_str, REAL) tmp = (model.get_value(x) - Real(math.floor(float(model.get_value(x))))).simplify().is_zero() return tmp
def test_real(self): f = Plus([Real(1), Symbol("x", REAL), Symbol("y", REAL)]) f_string = self.print_to_string(f) self.assertEqual(f_string, "(+ 1.0 x y)")
def get_floor(model, x_str): x = Symbol(x_str, REAL) flvalue = math.floor(float(model.get_value(x).simplify())) return str(flvalue)
def test_boolean(self): x, y, z = Symbol("x"), Symbol("y"), Symbol("z") f = Or(And(Not(x), Iff(x, y)), Implies(x, z)) f_string = self.print_to_string(f) self.assertEqual(f_string, "(or (and (not x) (= x y)) (=> x z))")
def exclude_interval(x, a, b): global solver solver.push() var = Symbol(x, REAL) solver.add_assertion(Or(LE(var, Real(float(a))), GE(var, Real(float(b)))))
def comb_attack(self): # dis generator solver_name = 'yices' solver_obf = Solver(name=solver_name) solver_key = Solver(name=solver_name) self.solver_oracle = Solver(name=solver_name) attack_formulas = FormulaGenerator(self.oracle_cir, self.obf_cir) f = attack_formulas.dip_gen_ckt # f = simplify(f) solver_obf.add_assertion(f) f = attack_formulas.key_inequality_ckt # f = simplify(f) solver_obf.add_assertion(f) for l in self.oracle_cir.wire_objs: self.solver_oracle.add_assertion(l.formula) dip_list = [] stateful_keys = [] iteration = 0 while 1: # query dip generator if solver_obf.solve(): dip_formula = [] dip_boolean = [] for l in self.oracle_cir.input_wires: s = Symbol(l.name) if solver_obf.get_py_value(s): dip_formula.append(s) dip_boolean.append(TRUE()) else: dip_formula.append(Not(s)) dip_boolean.append(FALSE()) logging.info(dip_formula) # query oracle dip_out = self.query_oracle(dip_formula) logging.info(dip_out) # check for stateful condition if dip_formula in dip_list: # ban stateful key logging.info("found a repeated dip!") # check outputs for both keys key = None for l in self.obf_cir.output_wires: s1 = Symbol(l.name + '@dc1') s2 = Symbol(l.name + '@dc2') if solver_obf.get_py_value( s1) != solver_obf.get_py_value(s2): if solver_obf.get_py_value( s1) != self.solver_oracle.get_py_value( Symbol(l.name)): key = '0' else: key = '1' break if key == None: logging.critical( 'something is wrong when banning keys') # find assigned keys key_list = [] for l in self.obf_cir.key_wires: k = Symbol(l.name + '_' + key) if solver_obf.get_py_value(k): key_list.append(k) else: key_list.append(Not(k)) stateful_keys.append(key_list) # ban the stateful key f = Not(And(key_list)) solver_obf.add_assertion(f) solver_key.add_assertion(f) if len(stateful_keys) % 5000 == 0: logging.warning('current stateful keys: {}'.format( len(stateful_keys))) continue else: dip_list.append(dip_formula) # add dip checker f = [] f.append( attack_formulas.gen_dip_chk(iteration * 2, '_0', dip_boolean)) f.append( attack_formulas.gen_dip_chk(iteration * 2 + 1, '_1', dip_boolean)) for i in range(len(self.obf_cir.output_wires)): l = self.obf_cir.output_wires[i].name f.append( And( Iff(dip_out[i], Symbol(l + '@{}'.format(iteration * 2))), Iff(dip_out[i], Symbol(l + '@{}'.format(iteration * 2 + 1))))) f = And(f) solver_obf.add_assertion(f) solver_key.add_assertion(f) iteration += 1 logging.warning('iteration: {}'.format(iteration)) else: logging.warning('print keys') logging.warning('stateful keys: {}'.format(len(stateful_keys))) if solver_key.solve(): key = '' for l in self.obf_cir.key_wires: if solver_key.get_py_value(Symbol(l.name + '_0')): key += '1' else: key += '0' print("key=%s" % key) else: logging.critical('key solver returned UNSAT') return
def get_float(model, x, accuracy): val = model.get_py_value(Symbol(x, REAL)) decdigits = int(-math.log(accuracy, 10)) + 2 return float(val)
from pysmt.shortcuts import Symbol, LE, GE, And, Int from pysmt.typing import INT h = Symbol("H", INT) # domain = (1 <= h) & (10 >= h) domain = And(LE(Int(1), h), GE(Int(10), h))
def test_prenex_simple_exists(self): a, b = (Symbol(x) for x in "ab") f = And(b, Exists([b], Implies(a, b))) prenex = prenex_normal_form(f) self.assertTrue(prenex.is_exists()) self.assertValid(Iff(f, prenex), logic=BOOL)
def setUp(self): self.x, self.y = Symbol("x"), Symbol("y")
def test_prenex_negated_forall(self): a, b = (Symbol(x) for x in "ab") f = Implies(ForAll([b], Implies(a, b)), b) prenex = prenex_normal_form(f) self.assertTrue(prenex.is_exists()) self.assertValid(Iff(f, prenex), logic=BOOL)
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
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())
def get_full_example_formulae(environment=None): """Return a list of Examples using the given environment.""" if environment is None: environment = get_env() with environment: x = Symbol("x", BOOL) y = Symbol("y", BOOL) p = Symbol("p", INT) q = Symbol("q", INT) r = Symbol("r", REAL) s = Symbol("s", REAL) aii = Symbol("aii", ARRAY_INT_INT) arb = Symbol("arb", ArrayType(REAL, BV8)) abb = Symbol("abb", ArrayType(BV8, BV8)) nested_a = Symbol("a_arb_aii", ArrayType(ArrayType(REAL, BV8), ARRAY_INT_INT)) rf = Symbol("rf", FunctionType(REAL, [REAL, REAL])) rg = Symbol("rg", FunctionType(REAL, [REAL])) ih = Symbol("ih", FunctionType(INT, [REAL, INT])) ig = Symbol("ig", FunctionType(INT, [INT])) bf = Symbol("bf", FunctionType(BOOL, [BOOL])) bg = Symbol("bg", FunctionType(BOOL, [BOOL])) bv8 = Symbol("bv1", BV8) bv16 = Symbol("bv2", BV16) result = [ # Formula, is_valid, is_sat, is_qf Example(hr="(x & y)", expr=And(x, y), is_valid=False, is_sat=True, logic=pysmt.logics.QF_BOOL), Example(hr="(x <-> y)", expr=Iff(x, y), is_valid=False, is_sat=True, logic=pysmt.logics.QF_BOOL), Example(hr="((x | y) & (! (x | y)))", expr=And(Or(x, y), Not(Or(x, y))), is_valid=False, is_sat=False, logic=pysmt.logics.QF_BOOL), Example(hr="(x & (! y))", expr=And(x, Not(y)), is_valid=False, is_sat=True, logic=pysmt.logics.QF_BOOL), Example(hr="(False -> True)", expr=Implies(FALSE(), TRUE()), is_valid=True, is_sat=True, logic=pysmt.logics.QF_BOOL), # # LIA # Example(hr="((q < p) & (x -> y))", expr=And(GT(p, q), Implies(x, y)), is_valid=False, is_sat=True, logic=pysmt.logics.QF_IDL), Example(hr="(((p + q) = 5) & (q < p))", expr=And(Equals(Plus(p, q), Int(5)), GT(p, q)), is_valid=False, is_sat=True, logic=pysmt.logics.QF_LIA), Example(hr="((q <= p) | (p <= q))", expr=Or(GE(p, q), LE(p, q)), is_valid=True, is_sat=True, logic=pysmt.logics.QF_IDL), Example(hr="(! (p < (q * 2)))", expr=Not(LT(p, Times(q, Int(2)))), is_valid=False, is_sat=True, logic=pysmt.logics.QF_LIA), Example(hr="(p < (p - (5 - 2)))", expr=GT(Minus(p, Minus(Int(5), Int(2))), p), is_valid=False, is_sat=False, logic=pysmt.logics.QF_IDL), Example(hr="((x ? 7 : ((p + -1) * 3)) = q)", expr=Equals( Ite(x, Int(7), Times(Plus(p, Int(-1)), Int(3))), q), is_valid=False, is_sat=True, logic=pysmt.logics.QF_LIA), Example(hr="(p < (q + 1))", expr=LT(p, Plus(q, Int(1))), is_valid=False, is_sat=True, logic=pysmt.logics.QF_LIA), # # LRA # Example(hr="((s < r) & (x -> y))", expr=And(GT(r, s), Implies(x, y)), is_valid=False, is_sat=True, logic=pysmt.logics.QF_RDL), Example(hr="(((r + s) = 28/5) & (s < r))", expr=And(Equals(Plus(r, s), Real(Fraction("5.6"))), GT(r, s)), is_valid=False, is_sat=True, logic=pysmt.logics.QF_LRA), Example(hr="((s <= r) | (r <= s))", expr=Or(GE(r, s), LE(r, s)), is_valid=True, is_sat=True, logic=pysmt.logics.QF_RDL), Example(hr="(! ((r * 2.0) < (s * 2.0)))", expr=Not(LT(Div(r, Real((1, 2))), Times(s, Real(2)))), is_valid=False, is_sat=True, logic=pysmt.logics.QF_LRA), Example(hr="(! (r < (r - (5.0 - 2.0))))", expr=Not(GT(Minus(r, Minus(Real(5), Real(2))), r)), is_valid=True, is_sat=True, logic=pysmt.logics.QF_RDL), Example(hr="((x ? 7.0 : ((s + -1.0) * 3.0)) = r)", expr=Equals( Ite(x, Real(7), Times(Plus(s, Real(-1)), Real(3))), r), is_valid=False, is_sat=True, logic=pysmt.logics.QF_LRA), # # EUF # Example(hr="(bf(x) <-> bg(x))", expr=Iff(Function(bf, (x, )), Function(bg, (x, ))), is_valid=False, is_sat=True, logic=pysmt.logics.QF_UF), Example(hr="(rf(5.0, rg(r)) = 0.0)", expr=Equals(Function(rf, (Real(5), Function(rg, (r, )))), Real(0)), is_valid=False, is_sat=True, logic=pysmt.logics.QF_UFLRA), Example(hr="((rg(r) = (5.0 + 2.0)) <-> (rg(r) = 7.0))", expr=Iff(Equals(Function(rg, [r]), Plus(Real(5), Real(2))), Equals(Function(rg, [r]), Real(7))), is_valid=True, is_sat=True, logic=pysmt.logics.QF_UFLRA), Example( hr="((r = (s + 1.0)) & (rg(s) = 5.0) & (rg((r - 1.0)) = 7.0))", expr=And([ Equals(r, Plus(s, Real(1))), Equals(Function(rg, [s]), Real(5)), Equals(Function(rg, [Minus(r, Real(1))]), Real(7)) ]), is_valid=False, is_sat=False, logic=pysmt.logics.QF_UFLRA), # # BV # Example(hr="((1_32 & 0_32) = 0_32)", expr=Equals(BVAnd(BVOne(32), BVZero(32)), BVZero(32)), is_valid=True, is_sat=True, logic=pysmt.logics.QF_BV), Example(hr="((! 2_3) = 5_3)", expr=Equals(BVNot(BV("010")), BV("101")), is_valid=True, is_sat=True, logic=pysmt.logics.QF_BV), Example(hr="((7_3 xor 0_3) = 0_3)", expr=Equals(BVXor(BV("111"), BV("000")), BV("000")), is_valid=False, is_sat=False, logic=pysmt.logics.QF_BV), Example(hr="((bv1::bv1) u< 0_16)", expr=BVULT(BVConcat(bv8, bv8), BVZero(16)), is_valid=False, is_sat=False, logic=pysmt.logics.QF_BV), Example(hr="(1_32[0:7] = 1_8)", expr=Equals(BVExtract(BVOne(32), end=7), BVOne(8)), is_valid=True, is_sat=True, logic=pysmt.logics.QF_BV), Example(hr="(0_8 u< (((bv1 + 1_8) * 5_8) u/ 5_8))", expr=BVUGT( BVUDiv(BVMul(BVAdd(bv8, BVOne(8)), BV(5, width=8)), BV(5, width=8)), BVZero(8)), is_valid=False, is_sat=True, logic=pysmt.logics.QF_BV), Example(hr="(0_16 u<= bv2)", expr=BVUGE(bv16, BVZero(16)), is_valid=True, is_sat=True, logic=pysmt.logics.QF_BV), Example(hr="(0_16 s<= bv2)", expr=BVSGE(bv16, BVZero(16)), is_valid=False, is_sat=True, logic=pysmt.logics.QF_BV), Example( hr="((0_32 u< (5_32 u% 2_32)) & ((5_32 u% 2_32) u<= 1_32))", expr=And( BVUGT(BVURem(BV(5, width=32), BV(2, width=32)), BVZero(32)), BVULE(BVURem(BV(5, width=32), BV(2, width=32)), BVOne(32))), is_valid=True, is_sat=True, logic=pysmt.logics.QF_BV), Example(hr="((((1_32 + (- ...)) << 1_32) >> 1_32) = 1_32)", expr=Equals( BVLShr(BVLShl(BVAdd(BVOne(32), BVNeg(BVOne(32))), 1), 1), BVOne(32)), is_valid=False, is_sat=False, logic=pysmt.logics.QF_BV), Example(hr="((1_32 - 1_32) = 0_32)", expr=Equals(BVSub(BVOne(32), BVOne(32)), BVZero(32)), is_valid=True, is_sat=True, logic=pysmt.logics.QF_BV), # Rotations Example(hr="(((1_32 ROL 1) ROR 1) = 1_32)", expr=Equals(BVRor(BVRol(BVOne(32), 1), 1), BVOne(32)), is_valid=True, is_sat=True, logic=pysmt.logics.QF_BV), # Extensions Example(hr="((0_5 ZEXT 11) = (0_1 SEXT 15))", expr=Equals(BVZExt(BVZero(5), 11), BVSExt(BVZero(1), 15)), is_valid=True, is_sat=True, logic=pysmt.logics.QF_BV), Example(hr="((bv2 - bv2) = 0_16)", expr=Equals(BVSub(bv16, bv16), BVZero(16)), is_valid=True, is_sat=True, logic=pysmt.logics.QF_BV), Example(hr="((bv2 - bv2)[0:7] = bv1)", expr=Equals(BVExtract(BVSub(bv16, bv16), 0, 7), bv8), is_valid=False, is_sat=True, logic=pysmt.logics.QF_BV), Example(hr="((bv2[0:7] bvcomp bv1) = 1_1)", expr=Equals(BVComp(BVExtract(bv16, 0, 7), bv8), BVOne(1)), is_valid=False, is_sat=True, logic=pysmt.logics.QF_BV), Example(hr="((bv2 bvcomp bv2) = 0_1)", expr=Equals(BVComp(bv16, bv16), BVZero(1)), is_valid=False, is_sat=False, logic=pysmt.logics.QF_BV), Example(hr="(bv2 s< bv2)", expr=BVSLT(bv16, bv16), is_valid=False, is_sat=False, logic=pysmt.logics.QF_BV), Example(hr="(bv2 s< 0_16)", expr=BVSLT(bv16, BVZero(16)), is_valid=False, is_sat=True, logic=pysmt.logics.QF_BV), Example(hr="((bv2 s< 0_16) | (0_16 s<= bv2))", expr=Or(BVSGT(BVZero(16), bv16), BVSGE(bv16, BVZero(16))), is_valid=True, is_sat=True, logic=pysmt.logics.QF_BV), Example(hr="(bv2 u< bv2)", expr=BVULT(bv16, bv16), is_valid=False, is_sat=False, logic=pysmt.logics.QF_BV), Example(hr="(bv2 u< 0_16)", expr=BVULT(bv16, BVZero(16)), is_valid=False, is_sat=False, logic=pysmt.logics.QF_BV), Example(hr="((bv2 | 0_16) = bv2)", expr=Equals(BVOr(bv16, BVZero(16)), bv16), is_valid=True, is_sat=True, logic=pysmt.logics.QF_BV), Example(hr="((bv2 & 0_16) = 0_16)", expr=Equals(BVAnd(bv16, BVZero(16)), BVZero(16)), is_valid=True, is_sat=True, logic=pysmt.logics.QF_BV), Example(hr="((0_16 s< bv2) & ((bv2 s/ 65535_16) s< 0_16))", expr=And(BVSLT(BVZero(16), bv16), BVSLT(BVSDiv(bv16, SBV(-1, 16)), BVZero(16))), is_valid=False, is_sat=True, logic=pysmt.logics.QF_BV), Example(hr="((0_16 s< bv2) & ((bv2 s% 1_16) s< 0_16))", expr=And(BVSLT(BVZero(16), bv16), BVSLT(BVSRem(bv16, BVOne(16)), BVZero(16))), is_valid=False, is_sat=False, logic=pysmt.logics.QF_BV), Example(hr="((bv2 u% 1_16) = 0_16)", expr=Equals(BVURem(bv16, BVOne(16)), BVZero(16)), is_valid=True, is_sat=True, logic=pysmt.logics.QF_BV), Example(hr="((bv2 s% 1_16) = 0_16)", expr=Equals(BVSRem(bv16, BVOne(16)), BVZero(16)), is_valid=True, is_sat=True, logic=pysmt.logics.QF_BV), Example(hr="((bv2 s% (- 1_16)) = 0_16)", expr=Equals(BVSRem(bv16, BVNeg(BVOne(16))), BVZero(16)), is_valid=True, is_sat=True, logic=pysmt.logics.QF_BV), Example(hr="((bv2 a>> 0_16) = bv2)", expr=Equals(BVAShr(bv16, BVZero(16)), bv16), is_valid=True, is_sat=True, logic=pysmt.logics.QF_BV), Example(hr="((0_16 s<= bv2) & ((bv2 a>> 1_16) = (bv2 >> 1_16)))", expr=And( BVSLE(BVZero(16), bv16), Equals(BVAShr(bv16, BVOne(16)), BVLShr(bv16, BVOne(16)))), is_valid=False, is_sat=True, logic=pysmt.logics.QF_BV), # # Quantification # Example(hr="(forall y . (x -> y))", expr=ForAll([y], Implies(x, y)), is_valid=False, is_sat=True, logic=pysmt.logics.BOOL), Example(hr="(forall p, q . ((p + q) = 0))", expr=ForAll([p, q], Equals(Plus(p, q), Int(0))), is_valid=False, is_sat=False, logic=pysmt.logics.LIA), Example( hr="(forall r, s . (((0.0 < r) & (0.0 < s)) -> ((r - s) < r)))", expr=ForAll([r, s], Implies(And(GT(r, Real(0)), GT(s, Real(0))), (LT(Minus(r, s), r)))), is_valid=True, is_sat=True, logic=pysmt.logics.LRA), Example(hr="(exists x, y . (x -> y))", expr=Exists([x, y], Implies(x, y)), is_valid=True, is_sat=True, logic=pysmt.logics.BOOL), Example(hr="(exists p, q . ((p + q) = 0))", expr=Exists([p, q], Equals(Plus(p, q), Int(0))), is_valid=True, is_sat=True, logic=pysmt.logics.LIA), Example(hr="(exists r . (forall s . (r < (r - s))))", expr=Exists([r], ForAll([s], GT(Minus(r, s), r))), is_valid=False, is_sat=False, logic=pysmt.logics.LRA), Example(hr="(forall r . (exists s . (r < (r - s))))", expr=ForAll([r], Exists([s], GT(Minus(r, s), r))), is_valid=True, is_sat=True, logic=pysmt.logics.LRA), Example(hr="(x & (forall r . ((r + s) = 5.0)))", expr=And(x, ForAll([r], Equals(Plus(r, s), Real(5)))), is_valid=False, is_sat=False, logic=pysmt.logics.LRA), Example(hr="(exists x . ((x <-> (5.0 < s)) & (s < 3.0)))", expr=Exists([x], (And(Iff(x, GT(s, Real(5))), LT(s, Real(3))))), is_valid=False, is_sat=True, logic=pysmt.logics.LRA), # # UFLIRA # Example(hr="((p < ih(r, q)) & (x -> y))", expr=And(GT(Function(ih, (r, q)), p), Implies(x, y)), is_valid=False, is_sat=True, logic=pysmt.logics.QF_UFLIRA), Example( hr= "(((p - 3) = q) -> ((p < ih(r, (... + ...))) | (ih(r, p) <= p)))", expr=Implies( Equals(Minus(p, Int(3)), q), Or(GT(Function(ih, (r, Plus(q, Int(3)))), p), LE(Function(ih, (r, p)), p))), is_valid=True, is_sat=True, logic=pysmt.logics.QF_UFLIRA), Example( hr= "(((ToReal((... - ...)) = r) & (ToReal(q) = r)) -> ((p < ih(ToReal(...), (... + ...))) | (ih(r, p) <= p)))", expr=Implies( And(Equals(ToReal(Minus(p, Int(3))), r), Equals(ToReal(q), r)), Or( GT( Function( ih, (ToReal(Minus(p, Int(3))), Plus(q, Int(3)))), p), LE(Function(ih, (r, p)), p))), is_valid=True, is_sat=True, logic=pysmt.logics.QF_UFLIRA), Example( hr= "(! (((ToReal(...) = r) & (ToReal(...) = r)) -> ((p < ...(..., ...)) | (...(..., ...) <= p))))", expr=Not( Implies( And(Equals(ToReal(Minus(p, Int(3))), r), Equals(ToReal(q), r)), Or( GT( Function(ih, (ToReal(Minus( p, Int(3))), Plus(q, Int(3)))), p), LE(Function(ih, (r, p)), p)))), is_valid=False, is_sat=False, logic=pysmt.logics.QF_UFLIRA), Example( hr= """("Did you know that any string works? #yolo" & "10" & "|#somesolverskeepthe||" & " ")""", expr=And(Symbol("Did you know that any string works? #yolo"), Symbol("10"), Symbol("|#somesolverskeepthe||"), Symbol(" ")), is_valid=False, is_sat=True, logic=pysmt.logics.QF_BOOL), # # Arrays # Example(hr="((q = 0) -> (aii[0 := 0] = aii[0 := q]))", expr=Implies( Equals(q, Int(0)), Equals(Store(aii, Int(0), Int(0)), Store(aii, Int(0), q))), is_valid=True, is_sat=True, logic=pysmt.logics.QF_ALIA), Example(hr="(aii[0 := 0][0] = 0)", expr=Equals(Select(Store(aii, Int(0), Int(0)), Int(0)), Int(0)), is_valid=True, is_sat=True, logic=pysmt.logics.QF_ALIA), Example(hr="((Array{Int, Int}(0)[1 := 1] = aii) & (aii[1] = 0))", expr=And(Equals(Array(INT, Int(0), {Int(1): Int(1)}), aii), Equals(Select(aii, Int(1)), Int(0))), is_valid=False, is_sat=False, logic=pysmt.logics.get_logic_by_name("QF_ALIA*")), Example( hr= "((a_arb_aii = Array{Array{Real, BV{8}}, Array{Int, Int}}(Array{Int, Int}(7))) -> (a_arb_aii[arb][42] = 7))", expr=Implies( Equals(nested_a, Array(ArrayType(REAL, BV8), Array(INT, Int(7)))), Equals(Select(Select(nested_a, arb), Int(42)), Int(7))), is_valid=True, is_sat=True, logic=pysmt.logics.get_logic_by_name("QF_AUFBVLIRA*")), Example(hr="(abb[bv1 := y_][bv1 := z_] = abb[bv1 := z_])", expr=Equals( Store(Store(abb, bv8, Symbol("y_", BV8)), bv8, Symbol("z_", BV8)), Store(abb, bv8, Symbol("z_", BV8))), is_valid=True, is_sat=True, logic=pysmt.logics.QF_ABV), Example(hr="((r / s) = (r * s))", expr=Equals(Div(r, s), Times(r, s)), is_valid=False, is_sat=True, logic=pysmt.logics.QF_NRA), Example(hr="(2.0 = (r * r))", expr=Equals(Real(2), Times(r, r)), is_valid=False, is_sat=True, logic=pysmt.logics.QF_NRA), Example(hr="((p ^ 2) = 0)", expr=Equals(Pow(p, Int(2)), Int(0)), is_valid=False, is_sat=True, logic=pysmt.logics.QF_NIA), Example(hr="((r ^ 2.0) = 0.0)", expr=Equals(Pow(r, Real(2)), Real(0)), is_valid=False, is_sat=True, logic=pysmt.logics.QF_NRA), Example(hr="((r * r * r) = 25.0)", expr=Equals(Times(r, r, r), Real(25)), is_valid=False, is_sat=True, logic=pysmt.logics.QF_NRA), Example(hr="((5.0 * r * 5.0) = 25.0)", expr=Equals(Times(Real(5), r, Real(5)), Real(25)), is_valid=False, is_sat=True, logic=pysmt.logics.QF_LRA), Example(hr="((p * p * p) = 25)", expr=Equals(Times(p, p, p), Int(25)), is_valid=False, is_sat=False, logic=pysmt.logics.QF_NIA), Example(hr="((5 * p * 5) = 25)", expr=Equals(Times(Int(5), p, Int(5)), Int(25)), is_valid=False, is_sat=True, logic=pysmt.logics.QF_LIA), Example(hr="(((1 - 1) * p * 1) = 0)", expr=Equals(Times(Minus(Int(1), Int(1)), p, Int(1)), Int(0)), is_valid=True, is_sat=True, logic=pysmt.logics.QF_LIA), # Huge Fractions: Example( hr= "((r * 1606938044258990275541962092341162602522202993782792835301376/7) = -20480000000000000000000000.0)", expr=Equals(Times(r, Real(Fraction(2**200, 7))), Real(-200**11)), is_valid=False, is_sat=True, logic=pysmt.logics.QF_LRA), Example(hr="(((r + 5.0 + s) * (s + 2.0 + r)) = 0.0)", expr=Equals( Times(Plus(r, Real(5), s), Plus(s, Real(2), r)), Real(0)), is_valid=False, is_sat=True, logic=pysmt.logics.QF_NRA), Example( hr= "(((p + 5 + q) * (p - (q - 5))) = ((p * p) + (10 * p) + 25 + (-1 * q * q)))", expr=Equals( Times(Plus(p, Int(5), q), Minus(p, Minus(q, Int(5)))), Plus(Times(p, p), Times(Int(10), p), Int(25), Times(Int(-1), q, q))), is_valid=True, is_sat=True, logic=pysmt.logics.QF_NIA), ] return result