def test_get_value_of_function_bool(self):
"""Proper handling of models with functions with bool args."""
hr = Symbol("hr", FunctionType(REAL, [BOOL, REAL, REAL]))
hb = Symbol("hb", FunctionType(BOOL, [BOOL, REAL, REAL]))
hr_0_1 = Function(hr, (TRUE(), Real(0), Real(1)))
hb_0_1 = Function(hb, (TRUE(), Real(0), Real(1)))
hbx = Function(hb, (Symbol("x"), Real(0), Real(1)))
f = GT(hr_0_1, Real(0))
g = hb_0_1
for sname in get_env().factory.all_solvers(logic=QF_UFLIRA):
with Solver(name=sname) as solver:
# First hr
solver.add_assertion(f)
res = solver.solve()
self.assertTrue(res)
v = solver.get_value(hr_0_1)
self.assertIsNotNone(solver.get_value(v))
# Now hb
solver.add_assertion(g)
res = solver.solve()
self.assertTrue(res)
v = solver.get_value(hb_0_1)
self.assertIsNotNone(v in [TRUE(), FALSE()])
# Hbx
solver.add_assertion(hbx)
res = solver.solve()
self.assertTrue(res)
v = solver.get_value(hbx)
self.assertIsNotNone(v in [TRUE(), FALSE()])
# Get model
model = solver.get_model()
self.assertIsNotNone(model)
def get_ordered_zero(self):
self.zero = None
self.firste = None
self.le = None
res = []
for g in self.curr._globals:
gstr = pretty_print_str(g)
if gstr == "zero":
gt = g.symbol_type()
assert (gt in self._enumsorts)
domain = self._enumsorts[gt]
eq = EqualsOrIff(g, domain[0])
res.append(eq)
self.zero = (domain[0], g)
elif gstr == "firste":
gt = g.symbol_type()
assert (gt in self._enumsorts)
domain = self._enumsorts[gt]
eq = EqualsOrIff(g, domain[1])
res.append(eq)
self.firste = (domain[1], g)
for pre in self.curr._le:
pret = pre.symbol_type()
orderedt = pret.param_types[0]
if orderedt in self._enumsorts:
self._ordered_sorts[orderedt] = pre
self.le = pre
domain = self._enumsorts[orderedt]
# end = 2
end = len(domain)
for i in range(end):
for j in range(i, end):
arg1 = domain[i]
arg2 = domain[j]
rel1 = Function(pre, [arg1, arg2])
rel2 = Function(pre, [arg2, arg1])
if (i == j):
res.append(rel1)
elif (i < j):
res.append(rel1)
res.append(Not(rel2))
elif (i > j):
res.append(Not(rel1))
res.append(rel2)
else:
assert (0)
if len(res) == 0:
return TRUE()
else:
print("\nZero axiom: ")
for v in res:
print("\t", end="")
pretty_print(v)
return And(res)
def __init__(self, doc: SmtLibDocument):
self.doc = doc
sym = get_env().formula_manager.get_symbol
#fsym = lambda ty: FreshSymbol(ty, template='?c%d')
nat = Type('Nat')
skf1 = FreshSymbol(FunctionType(nat, [nat]), template='skf%d')
self.ctor_pats = {
nat:
lambda ph:
[sym('zero'),
Function(sym('succ'), [Function(skf1, [ph])])]
}
def get_ordered_le(self):
self.reset_ordered_sort()
for g in self.curr._globals:
gstr = pretty_print_str(g)
print(gstr)
if gstr == "zero":
gt = g.symbol_type()
if gt in self._enumsorts:
self._ordered_min[gt] = g
elif gstr == "max":
gt = g.symbol_type()
if gt in self._enumsorts:
self._ordered_max[gt] = g
res = []
for pre in self.curr._le:
pret = pre.symbol_type()
orderedt = pret.param_types[0]
if orderedt in self._enumsorts:
self._ordered_sorts[orderedt] = pre
domain = self._enumsorts[orderedt]
for i in range(len(domain)):
for j in range(i, len(domain)):
arg1 = domain[i]
arg2 = domain[j]
rel1 = Function(pre, [arg1, arg2])
rel2 = Function(pre, [arg2, arg1])
if (i == j):
res.append(rel1)
elif (i < j):
res.append(rel1)
res.append(Not(rel2))
elif (i > j):
res.append(Not(rel1))
res.append(rel2)
else:
assert (0)
# for i in range(len(domain)-1, 0, -1):
# arg1 = domain[i]
# arg2 = domain[i-1]
# rel = Function(pre, [arg1, arg2])
# res.append(Not(rel))
if len(res) == 0:
return TRUE()
else:
print("\nOrdering axiom: ")
for v in res:
print("\t", end="")
pretty_print(v)
return And(res)
def test_substitution_on_functions(self):
i, r = FreshSymbol(INT), FreshSymbol(REAL)
f = Symbol("f", FunctionType(BOOL, [INT, REAL]))
phi = Function(f, [Plus(i, Int(1)), Minus(r, Real(2))])
phi_sub = substitute(phi, {i: Int(0)}).simplify()
self.assertEqual(phi_sub, Function(f, [Int(1), Minus(r, Real(2))]))
phi_sub = substitute(phi, {r: Real(0)}).simplify()
self.assertEqual(phi_sub, Function(f, [Plus(i, Int(1)), Real(-2)]))
phi_sub = substitute(phi, {r: Real(0), i: Int(0)}).simplify()
self.assertEqual(phi_sub, Function(f, [Int(1), Real(-2)]))
def test_function(self):
f1_type = FunctionType(REAL, [REAL, REAL])
f2_type = FunctionType(REAL, [])
p, q = Symbol("p", REAL), Symbol("q", REAL)
f1_symbol = Symbol("f1", f1_type)
f2_symbol = Symbol("f2", f2_type)
f1 = Function(f1_symbol, [p, q])
f2 = Function(f2_symbol, [])
f1_string = self.print_to_string(f1)
f2_string = self.print_to_string(f2)
self.assertEqual(f1_string, "(f1 p q)")
self.assertEqual(f2_string, "(f2)")
def test_normalization(self):
from pysmt.environment import Environment
env2 = Environment()
mgr2 = env2.formula_manager
ty = ArrayType(BOOL, REAL)
x = FreshSymbol(ty)
fty = FunctionType(BOOL, (ty, ))
f = FreshSymbol(fty)
g = Function(f, (x, ))
self.assertIsNotNone(g)
self.assertNotIn(g, mgr2)
g2 = mgr2.normalize(g)
self.assertIn(g2, mgr2)
# Since the types are from two different environments, they
# should be different.
x2 = g2.arg(0)
ty2 = x2.symbol_type()
self.assertFalse(ty2 is ty, ty)
fname = g2.function_name()
fty2 = fname.symbol_type()
self.assertFalse(fty2 is fty, fty)
# Test ArrayValue
h = Array(BVType(4), BV(0, 4))
h2 = mgr2.normalize(h)
self.assertEqual(h.array_value_index_type(),
h2.array_value_index_type())
self.assertFalse(h.array_value_index_type() is \
h2.array_value_index_type())
def export_rule_def(self, defun):
name, args, rettype, body = defun
ftype = FunctionType(rettype, [a.symbol_type() for a in args])
fsymb = Symbol(name, ftype)
yield self.export_func(fsymb)
eqop = Iff if rettype.is_bool_type() else Equals
for rule in self.export_rules(
ForAll(args, eqop(Function(fsymb, args), body))):
yield rule
def action_noop(self):
f = dict()
for s in self._states:
if s in self._pre2nex:
n = self._pre2nex[s]
s_type = s.symbol_type()
args = []
if s_type.is_function_type():
i = 0
for paramt in s_type.param_types:
i += 1
paramt_name = str(i) + ":" + str(paramt)
args.append(Symbol(paramt_name, paramt))
lhs = Function(s, args)
rhs = Function(n, args)
eq = ForAll(args, EqualsOrIff(lhs, rhs))
f[n] = eq
return f
def test_custom_types(self):
A = Type("A", 0)
a, b = Symbol("a", A), Symbol("b", A)
p = Symbol("p", INT)
fun = Symbol("g", FunctionType(A, [INT, A]))
app = Function(fun, [p, b])
f_a = Equals(a, app)
for n in self.all_solvers:
with Solver(name=n, logic=QF_UFLIA) as s:
s.add_assertion(f_a)
res = s.solve()
self.assertTrue(res)
def add_pred(self, formula, name):
args = []
types = []
if formula.is_quantifier():
for a in formula.quantifier_vars():
args.append(a)
types.append(a.symbol_type())
formula = formula.arg(0)
ft = FunctionType(BOOL, tuple(types))
f = Symbol(name, ft)
lhs = Function(f, args)
self._predicates[lhs] = formula
def test_get_value_of_function(self):
"""get_value on a function should raise an exception."""
h = Symbol("h", FunctionType(REAL, [REAL, REAL]))
h_0_0 = Function(h, (Real(0), Real(1)))
f = GT(h_0_0, Real(0))
for sname in get_env().factory.all_solvers(logic=QF_UFLIRA):
with Solver(name=sname) as solver:
solver.add_assertion(f)
res = solver.solve()
self.assertTrue(res)
with self.assertRaises(PysmtTypeError):
solver.get_value(h)
self.assertIsNotNone(solver.get_value(h_0_0))
def test_function(self):
f1_type = FunctionType(REAL, [REAL, REAL])
f2_type = FunctionType(REAL, [])
p, q = Symbol("p", REAL), Symbol("q", REAL)
f1_symbol = Symbol("f1", f1_type)
f2_symbol = Symbol("f2", f2_type)
f1 = Function(f1_symbol, [p, q])
f2 = Function(f2_symbol, [])
self.assertEqual(f1.to_smtlib(daggify=False), "(f1 p q)")
self.assertEqual(f2.to_smtlib(daggify=False), "f2")
self.assertEqual(f1.to_smtlib(daggify=True),
"(let ((.def_0 (f1 p q))) .def_0)")
self.assertEqual(f2.to_smtlib(daggify=True), "f2")
def test_functions(self):
vi = Symbol("At", INT)
vr = Symbol("Bt", REAL)
f = Symbol("f", FunctionType(INT, [REAL]))
g = Symbol("g", FunctionType(REAL, [INT]))
tc = get_env().stc
self.assertEqual(tc.walk(Function(f, [vr])), INT)
self.assertEqual(tc.walk(Function(g, [vi])), REAL)
self.assertEqual(tc.walk(Function(f, [Function(g, [vi])])), INT)
self.assertEqual(tc.walk(LE(Plus(vi, Function(f, [Real(4)])), Int(8))), BOOL)
self.assertEqual(tc.walk(LE(Plus(vr, Function(g, [Int(4)])), Real(8))), BOOL)
with self.assertRaises(PysmtTypeError):
LE(Plus(vr, Function(g, [Real(4)])), Real(8))
with self.assertRaises(PysmtTypeError):
LE(Plus(vi, Function(f, [Int(4)])), Int(8))
def test_function(self):
f1_type = FunctionType(REAL, [REAL, REAL])
f2_type = FunctionType(REAL, [])
p,q = Symbol("p", REAL), Symbol("q", REAL)
f1_symbol = Symbol("f1", f1_type)
f2_symbol = Symbol("f2", f2_type)
f1 = Function(f1_symbol, [p,q])
f2 = Function(f2_symbol, [])
self.assertEqual(f1.to_smtlib(daggify=False), "(f1 p q)")
self.assertEqual(f2.to_smtlib(daggify=False), "f2")
self.assertEqual(f1.to_smtlib(daggify=True), "(let ((.def_0 (f1 p q))) .def_0)")
self.assertEqual(f2.to_smtlib(daggify=True), "f2")
def _generalize_pattern(self, term):
head, args = term.function_name(), term.args()
pat_idxs = [
i for i, a in enumerate(args) if a.is_function_application()
]
if len(pat_idxs) > 1:
args1pat = list(args)
phs = []
for i in pat_idxs[1:]:
ph = FreshSymbol(get_type(args[i]), template='?splt%d')
phs.append(ph)
args1pat[i] = ph
headpat = SmtLibSExpression(Function(head, args1pat))
#print("=|>", pat_idxs, headpat, phs)
for ph in phs:
cases = list(self._get_cases(ph))
if len(cases) > 1:
yield [
headpat,
SExpression(['potential_split', ph] + cases)
]
def get_quorum_axiom(self):
res = []
pre = None
for g in self.curr._globals:
name = str(g)
if name.startswith("member:"):
pre = g
break
if pre != None:
pret = pre.symbol_type()
assert (len(pret.param_types) == 2)
tA = pret.param_types[0]
tQ = pret.param_types[1]
if tA in self._enumsorts and tQ in self._enumsorts:
domainA = self._enumsorts[tA]
domainQ = self._enumsorts[tQ]
assert (str(tQ).startswith("quorum:"))
qMap = {}
if (len(domainA) == 3) and (len(domainQ) == 3):
qMap[0] = set([0, 1])
qMap[1] = set([0, 2])
qMap[2] = set([1, 2])
elif (len(domainA) == 4) and (len(domainQ) == 4):
qMap[0] = set([0, 1, 2])
qMap[1] = set([0, 1, 3])
qMap[2] = set([0, 2, 3])
qMap[3] = set([1, 2, 3])
elif (len(domainA) == 5) and (len(domainQ) == 10):
qMap[0] = set([0, 1, 2])
qMap[1] = set([0, 1, 3])
qMap[2] = set([0, 1, 4])
qMap[3] = set([0, 2, 3])
qMap[4] = set([0, 2, 4])
qMap[5] = set([0, 3, 4])
qMap[6] = set([1, 2, 3])
qMap[7] = set([1, 2, 4])
qMap[8] = set([1, 3, 4])
qMap[9] = set([2, 3, 4])
else:
assert (0)
for k, v in qMap.items():
arg2 = domainQ[k]
for j in range(len(domainA)):
arg1 = domainA[j]
rel = Function(pre, [arg1, arg2])
val = j in v
if val:
res.append(rel)
else:
res.append(Not(rel))
if len(res) == 0:
return TRUE()
else:
print("\nQuorum axiom: ")
for v in res:
print("\t", end="")
pretty_print(v)
return And(res)
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)
ari = Symbol("ari", ArrayType(REAL, 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) = 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, (q + 3))) | (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((p - 3)) = r) & (ToReal(q) = r)) -> ((p < ih(ToReal((p - 3)), (q + 3))) | (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((p - 3)) = r) & (ToReal(q) = r)) -> ((p < ih(ToReal((p - 3)), (q + 3))) | (ih(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="((Array{Int, Int}(0)[1 := 3] = aii) & (aii[1] = 3))",
expr=And(Equals(Array(INT, Int(0), {Int(1): Int(3)}), aii),
Equals(Select(aii, Int(1)), Int(3))),
is_valid=False,
is_sat=True,
logic=pysmt.logics.get_logic_by_name("QF_ALIA*")),
Example(hr="((Array{Real, Int}(10) = ari) & (ari[6/5] = 0))",
expr=And(Equals(Array(REAL, Int(10)), ari),
Equals(Select(ari, Real((6, 5))), Int(0))),
is_valid=False,
is_sat=False,
logic=pysmt.logics.get_logic_by_name("QF_AUFBVLIRA*")),
Example(
hr=
"((Array{Real, Int}(0)[1.0 := 10][2.0 := 20][3.0 := 30][4.0 := 40] = ari) & (! ((ari[0.0] = 0) & (ari[1.0] = 10) & (ari[2.0] = 20) & (ari[3.0] = 30) & (ari[4.0] = 40))))",
expr=And(
Equals(
Array(
REAL, Int(0), {
Real(1): Int(10),
Real(2): Int(20),
Real(3): Int(30),
Real(4): Int(40)
}), ari),
Not(
And(Equals(Select(ari, Real(0)), Int(0)),
Equals(Select(ari, Real(1)), Int(10)),
Equals(Select(ari, Real(2)), Int(20)),
Equals(Select(ari, Real(3)), Int(30)),
Equals(Select(ari, Real(4)), Int(40))))),
is_valid=False,
is_sat=False,
logic=pysmt.logics.get_logic_by_name("QF_AUFBVLIRA*")),
Example(
hr=
"((Array{Real, Int}(0)[1.0 := 10][2.0 := 20][3.0 := 30][4.0 := 40][5.0 := 50] = ari) & (! ((ari[0.0] = 0) & (ari[1.0] = 10) & (ari[2.0] = 20) & (ari[3.0] = 30) & (ari[4.0] = 40) & (ari[5.0] = 50))))",
expr=And(
Equals(
Array(
REAL, Int(0), {
Real(1): Int(10),
Real(2): Int(20),
Real(3): Int(30),
Real(4): Int(40),
Real(5): Int(50)
}), ari),
Not(
And(Equals(Select(ari, Real(0)), Int(0)),
Equals(Select(ari, Real(1)), Int(10)),
Equals(Select(ari, Real(2)), Int(20)),
Equals(Select(ari, Real(3)), Int(30)),
Equals(Select(ari, Real(4)), Int(40)),
Equals(Select(ari, Real(5)), Int(50))))),
is_valid=False,
is_sat=False,
logic=pysmt.logics.get_logic_by_name("QF_AUFBVLIRA*")),
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
def symmetry_cube(self, cube, fIdx, reducePremise, dest=None):
# cube_str = pretty_serialize(Not(cube), mode=0)
cube_str = pretty_serialize(Not(cube), mode=0)
print("(clause)")
print("\t%s" % cube_str)
cvars = cube.get_enum_constants()
crels = cube.get_free_variables()
print("(relations)")
for r in crels:
print("\t%s" % pretty_serialize(r))
# assert(0)
subs = dict()
# print(cvars)
enum2qvar = dict()
# for v in cvars:
for v in sorted(cvars, key=str):
enumsort = v.constant_type()
if self.ordered == "partial" and enumsort in self.system._ordered_sorts:
continue
if self.ordered == "zero" and str(enumsort).startswith("epoch"):
# continue
assert(enumsort in self.system._enumsorts)
domain = self.system._enumsorts[enumsort]
zero = self.system.zero[1]
firste = self.system.firste[1]
le = self.system.le
if v == domain[0]:
subs[v] = zero
continue
elif v == domain[1]:
subs[v] = firste
continue
else:
rhs = firste
end = 2
try:
end = domain.index(v)
except ValueError:
assert(0)
for idx in range(end-1, 1, -2):
v2 = domain[idx]
if v2 in cvars:
rhs = v2
break
gt = Not(Function(le, [v, rhs]))
print("\tadding condition: %s" % pretty_print_str(gt))
cube = And(cube, gt)
# neq = And(Not(EqualsOrIff(v, zero)), Not(EqualsOrIff(v, firste)))
# cube = And(cube, neq)
# if (self.quorums != "none" and
# (str(enumsort).startswith("node") or str(enumsort).startswith("acceptor"))):
# continue
if (self.quorums != "none" and
(str(enumsort).startswith("quorum"))):
continue
if enumsort in self.system._enum2qvar:
qvar = []
if enumsort in enum2qvar:
qvar = enum2qvar[enumsort]
idx = len(qvar)
qv = self.system._enum2qvar[enumsort][idx]
qvar.append(qv)
enum2qvar[enumsort] = qvar
subs[v] = qv
antecedent = dict()
qvars = set()
fullsorts = []
# print(enum2qvar)
# print(self.system._enum2qvar)
minSz = 3
if experimentGeneralize:
minSz = 2
for enumsort, qvar in enum2qvar.items():
if (
# False and
# (str(enumsort).startswith("acceptor")
# or str(enumsort).startswith("node")
# or str(enumsort).startswith("quorum")
# ) and
# (str(enumsort).startswith("quorum")) and
(len(qvar) >= minSz) and
(len(qvar) == len(self.system._enum2qvar[enumsort]))):
fullsorts.append([enumsort, qvar])
antecedent[enumsort] = []
for i in range(len(qvar) - 1):
qvi = qvar[i]
qvars.add(qvi)
for j in range(i+1, len(qvar)):
if i != j:
deq = Not(EqualsOrIff(qvi, qvar[j]))
antecedent[enumsort].append(deq)
# print("adding: %s" % deq)
qvars.add(qvar[-1])
self.print_fullsorts(fullsorts)
cubeSym = cube
isorts = dict()
ivars = set()
if cubeSym.is_exists():
for v in cubeSym.quantifier_vars():
if v not in subs:
vs = v.symbol_type()
if vs not in isorts:
isorts[vs] = list()
idx = len(isorts[vs])
name = str(vs) + ":i" + str(idx)
isymbol = Symbol(name, vs)
isorts[vs].append(isymbol)
subs[v] = isymbol
ivars.add(isymbol)
qvars.add(isymbol)
cubeSym = cubeSym.args()[0]
cubeSym = cubeSym.simple_substitute(subs)
cubeSet = flatten_cube(cubeSym)
# self.reduce_antecedent(cubeSet, qvars, antecedent, fIdx)
print("(cube: std)")
for c in cubeSet:
print("\t%s" % pretty_serialize(c, mode=0))
if common.gopts.opt > 0 and reducePremise:
push_time()
antecedent, reduceSz, varSet = self.reduce_antecedent2(cubeSym, qvars, enum2qvar, fIdx)
self.update_time_stat("time-antecedent", pop_time())
print()
if self.ordered == "partial":
cubeSet = self.boost_ordered(cubeSet, antecedent, qvars, fIdx)
eqMap = dict()
if common.gopts.const > 0:
eqMap, cubeSet, antecedent, fullsorts = self.propagate_eq(cubeSet, antecedent, ivars, qvars, fullsorts)
if True:
cubeSetSimple = cubeSet.copy()
for v in antecedent.values():
for c in v:
cubeSetSimple.add(c)
cubeSimple = And(cubeSetSimple)
if len(qvars) != 0:
cubeSimple = Exists(qvars, cubeSimple)
cubesOut = list()
if (self.system.gen == "univ") or (len(fullsorts) == 0) or (len(crels) <= 1) or (len(cubeSet) < minSz):
cubesOut.append((cubeSimple, "univ"))
else:
uqvars = set()
cubeSet2 = cubeSet.copy()
for fs in fullsorts:
enumsort = fs[0]
qvar = fs[1]
qvarSet = set()
for q in qvar:
qvarSet.add(q)
qvart = fs[0]
uSymbol = Symbol("V:"+str(qvart), qvart)
qv2cubes = {}
qv2ucubes = {}
for q in qvar:
qv2cubes[q] = set()
qv2ucubes[q] = set()
ucubes = set()
for c in cubeSet:
cvars = c.get_free_variables()
cqvars = cvars.intersection(qvarSet)
# cqvars = c.get_filtered_nodes(qvarSet)
for q in cqvars:
tmp_subs = {}
tmp_subs[q] = uSymbol
uc = c.substitute(tmp_subs)
ucubes.add(uc)
qv2cubes[q].add(c)
qv2ucubes[q].add(uc)
print("qv2cubes #%d" % len(qv2cubes))
for k, v in qv2cubes.items():
print("\t%s -> %s" % (pretty_serialize(k), pretty_print_set(v, mode=0)))
print("qv2ucubes #%d" % len(qv2ucubes))
for k, v in qv2ucubes.items():
print("\t%s -> %s" % (pretty_serialize(k), pretty_print_set(v, mode=0)))
ucubes2qv = {}
emptyIdx = 1
for qv, ucubes in qv2ucubes.items():
uIdx = emptyIdx
uc = TRUE()
if len(ucubes) == 0:
emptyIdx += 1
elif qv in self.system.curr._states:
emptyIdx += 1
print("\t(creating separate cell for %s)" % pretty_serialize(qv))
else:
uIdx = 0
ucubes_sorted = sorted(ucubes, key=str)
uc = And(ucubes_sorted)
k = (uIdx, uc)
if k not in ucubes2qv:
ucubes2qv[k] = set()
ucubes2qv[k].add(qv)
print("ucubes2qv #%d" % len(ucubes2qv))
singles = []
multiples = []
for k, v in ucubes2qv.items():
if len(v) == 1:
singles.append(k)
elif len(v) >= minSz:
multiples.append(k)
print("\t%s -> %s" % (pretty_serialize(k[1]), pretty_print_set(v, mode=0)))
print("(partition) #%d %s -> { " % (len(ucubes2qv), enumsort), end="")
for v in ucubes2qv.values():
for d in v:
print("%s, " % pretty_serialize(d), end="")
print("| ", end="")
print("}")
nsingles = len(singles)
nmultiples = len(multiples)
ncells = len(ucubes2qv)
print("\t#%d singles, #%d multiples (out of #%d cells)" % (nsingles, nmultiples, ncells))
if len(ucubes2qv) == 1:
for rhs in ucubes2qv.values():
if len(rhs) != len(qvar):
print("found single part with incomplete instances")
assert(0)
if qvar[0].is_symbol():
uqvars.add(qvar[0])
antecedent.pop(enumsort, None)
for cubes in qv2cubes.values():
for cube in cubes:
cubeSet2.discard(cube)
for _, uc in ucubes2qv.keys():
tmp_subs = {}
tmp_subs[uSymbol] = qvar[0]
uc = uc.simple_substitute(tmp_subs)
ucList = flatten_cube(uc)
for v in ucList:
cubeSet2.add(v)
for q in qvar:
qvars.discard(q)
cubeSet = cubeSet2
elif (ncells == (nsingles + nmultiples)
and nmultiples == 1
and nsingles == 1
):
# elif (len(ucubes2qv) == 2
# and (len(qvar) > minSz)
# # and (not self.system.is_epr())
# ):
# elif len(ucubes2qv) == 2 and (len(qvar) > minSz) and (not self.system.is_epr()):
qsingle = []
qmulti = None
for k in singles:
assert(k in ucubes2qv)
qg = ucubes2qv[k]
assert(len(qg) == 1)
for q in qg:
qsingle.append(q)
for k in multiples:
assert(k in ucubes2qv)
qg = ucubes2qv[k]
assert(len(qg) >= minSz)
if len(qg) == (len(qvar) - len(qsingle)):
qmulti = qg
if len(qsingle) != 0 and qmulti != None:
ucsingle = {}
ucmulti = set()
for qs in qsingle:
ucsingle[qs] = set()
tmp_subs = {}
tmp_subs[uSymbol] = qs
for uc in qv2ucubes[qs]:
uc = uc.simple_substitute(tmp_subs)
ucsingle[qs].add(uc)
qm = sorted(qmulti, key=str)[0]
tmp_subs = {}
tmp_subs[uSymbol] = qm
for uc in qv2ucubes[qm]:
uc = uc.simple_substitute(tmp_subs)
ucmulti.add(uc)
print("ucsingle:")
for k, rhs in ucsingle.items():
print("\t%s:" % pretty_serialize(k))
for v in rhs:
print("\t\t%s" % pretty_serialize(v))
print("ucmulti:")
for v in ucmulti:
print("\t%s" % pretty_serialize(v))
if qm.is_symbol():
uqvars.add(qm)
if enumsort in antecedent:
newAnt = []
for v in antecedent[enumsort]:
vvars = v.get_free_variables()
vmvars = vvars.intersection(qmulti)
if len(vmvars) == 0:
newAnt.append(v)
antecedent.pop(enumsort, None)
if len(newAnt) != 0:
antecedent[enumsort] = newAnt
for q in qmulti:
for cube in qv2cubes[q]:
cubeSet2.discard(cube)
# for v in ucsingle:
# cubeSet2.add(v)
for q in qmulti:
qvars.discard(q)
eqM = []
for qs in qsingle:
eqM.append(EqualsOrIff(qs, qm))
sEqm = Or(eqM)
for v in ucmulti:
vNew = Or(sEqm, v)
cubeSet2.add(vNew)
cubeSet = cubeSet2
eqvars2 = set()
forwardArcs = 0
reverseArcs = 0
if len(uqvars) != 0:
if (self.system.gen != "fe"):
for u in qvars:
ut = u.symbol_type()
for e in uqvars:
et = e.symbol_type()
if (self.system.gen == "fef"):
if ut != et or True:
eqvars2.add(u)
else:
print("\t(epr check: forward)", end="")
if not self.system.allowed_arc(ut, et):
forwardArcs += 1
print("\t(epr check: reverse)", end="")
if not self.system.allowed_arc(et, ut):
reverseArcs += 1
eqvars2.add(u)
for u in eqvars2:
if u in qvars:
qvars.remove(u)
cubeSet = cubeSet2
for v in antecedent.values():
for c in v:
cubeSet.add(c)
cubesOut = list()
if (self.system.gen == "fef") and (len(uqvars) != 0) and (len(eqvars2) != 0):
fancy = "fef"
cubeSym = None
count = 0
innerVars = list(eqvars2)
while True or (len(innerVars) != 0):
count += 1
preCube = set()
postCube = set()
postVars = set()
for q in uqvars:
postVars.add(q)
for q in innerVars:
postVars.add(q)
for c in cubeSet:
argvars = c.get_free_variables()
argvars = argvars.intersection(postVars)
if len(argvars) == 0:
preCube.add(c)
else:
postCube.add(c)
postCube = sorted(postCube, key=str)
preCube = sorted(preCube, key=str)
cubeSym = And(postCube)
if len(innerVars) != 0:
cubeSym = Exists(innerVars, cubeSym)
if len(uqvars) != 0:
cubeSym = ForAll(uqvars, cubeSym)
if len(preCube) != 0:
cubeSym = And(And(preCube), cubeSym)
if len(qvars) != 0:
cubeSym = Exists(qvars, cubeSym)
print("(#%d: quantifier-reduced) " % count)
print("\t%s" % pretty_serialize(Not(cubeSym), mode=0))
# notCubeSym_formula = self.get_formula_qf(Not(cubeSym))
# print("\t(quantifier-free version)")
# notCubeSym_formulaList = flatten_and(notCubeSym_formula)
# for v in notCubeSym_formulaList:
# print("\t\t%s" % pretty_serialize(v))
solver = self.get_framesolver(fIdx)
cubeSym_formula = self.get_formula_qf(cubeSym)
print("\t(#%d: quantifier-rearrangement) " % count, end="")
result = self.solve_formula(solver, cubeSym_formula)
if not result:
cubesOut.append((cubeSym, fancy))
break
if len(innerVars) != 0:
u = innerVars.pop(0)
qvars.add(u)
else:
break
assert(len(cubesOut) != 0)
cubesOut.reverse()
# if len(cubesOut) == 0:
# preCube = set()
# postCube = set()
# postVars = set()
# for q in uqvars:
# postVars.add(q)
# for q in innerVars:
# postVars.add(q)
# for c in cubeSet:
# argvars = c.get_free_variables()
# argvars = argvars.intersection(postVars)
# if False and len(argvars) == 0:
# preCube.add(c)
# else:
# postCube.add(c)
# postCube = sorted(postCube, key=str)
# preCube = sorted(preCube, key=str)
# cubeSym2 = And(postCube)
# if len(uqvars) != 0:
# cubeSym2 = ForAll(uqvars, cubeSym2)
# if len(innerVars) != 0:
# cubeSym2 = Exists(innerVars, cubeSym2)
# if len(preCube) != 0:
# cubeSym2 = And(And(preCube), cubeSym2)
# if len(qvars) != 0:
# cubeSym2 = Exists(qvars, cubeSym2)
# cubesOut.append((cubeSym2, fancy))
else:
preCube = set()
postCube = set()
if len(uqvars) == 0:
postCube = cubeSet
else:
postVars = set()
for q in uqvars:
postVars.add(q)
for q in eqvars2:
postVars.add(q)
for c in cubeSet:
argvars = c.get_free_variables()
argvars = argvars.intersection(postVars)
if len(argvars) == 0:
preCube.add(c)
else:
postCube.add(c)
postCube = sorted(postCube, key=str)
preCube = sorted(preCube, key=str)
cubeSym = And(postCube)
if len(eqvars2) != 0:
cubeSym = Exists(eqvars2, cubeSym)
if len(uqvars) != 0:
cubeSym = ForAll(uqvars, cubeSym)
if len(preCube) != 0:
cubeSym = And(And(preCube), cubeSym)
if len(qvars) != 0:
cubeSym = Exists(qvars, cubeSym)
fancy = "univ"
if (len(uqvars) != 0):
fancy = "epr"
cubesOut.append((cubeSym, fancy))
if fancy:
if len(eqvars2) != 0:
cubeSym2 = And(postCube)
if len(uqvars) != 0:
cubeSym2 = ForAll(uqvars, cubeSym2)
if len(eqvars2) != 0:
cubeSym2 = Exists(eqvars2, cubeSym2)
if len(preCube) != 0:
cubeSym2 = And(And(preCube), cubeSym2)
if len(qvars) != 0:
cubeSym2 = Exists(qvars, cubeSym2)
print("(epr reduced)")
print("\t%s" % pretty_serialize(Not(cubeSym), mode=0))
print("(non-epr version)")
print("\t%s" % pretty_serialize(Not(cubeSym2), mode=0))
result = False
if (reverseArcs != 0):
print("\tBoth verions not allowed!")
if (self.system.gen == "epr_strict"):
result = True
if not result:
solver = self.get_framesolver(fIdx)
print("(epr-reduction) ", end="")
cubeSym_formula = self.get_formula_qf(cubeSym)
result = self.solve_formula(solver, cubeSym_formula)
if result:
print("\tEPR-reduction is not allowed!")
cubesOut.pop()
if (self.system.gen == "epr_strict") or (self.system.gen == "epr_loose"):
print("\tLearning universal version instead.")
cubesOut.append((cubeSimple, "univ"))
else:
print("\tLearning non-epr version instead.")
cubesOut.append((cubeSym2, "non-epr"))
# assert(0)
if common.gopts.const > 0:
for i in range(len(cubesOut)):
cubeTop = cubesOut[i]
cubeEq = self.propagate_eq_post(cubeTop[0])
cubesOut[i] = (cubeEq, cubeTop[1])
print("(boosted clause)")
print("\t%s" % pretty_serialize(Not(cubesOut[0][0]), mode=0))
print("---------------------------")
print("(original clause)")
print("\t%s" % cube_str)
print("(learnt sym-boosted clause)")
print("\t%s" % pretty_serialize(Not(cubesOut[0][0]), mode=0))
print("---------------------------")
else:
cubesOut = get_uniform(self, fullsorts, cubeSet, qvars, antecedent)
return cubesOut
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 _construct_k_inductive_query(self, euf):
return Or(
[And(guard, GT(Function(euf, self._characteristic_functional._pysmt_program_variables_argument), arith))
for (guard, arith) in self._upper_bound_dnf_for_k_inductive_query])
def probably_expr_to_pysmt(expr,
pysmt_infinity_variable=None,
treat_minus_as_monus=False,
monus_euf=None,
toReal=False):
"""
Convert a Probably expression to a pysmt expression.
Infinity must not occur in a composed arithmetic expression.
:param expr: The Propbably expression that is to be converted.
:param pysmt_infinity_variable: The pysmt variable used to represent infinity.
:param toReal: Whether variables and NatLitExpr shall be cast to Real or not.
:param treat_minus_as_monus: Whether to repalace every expression of the form a - b by monus_euf(a,b)
:param monus_euf: The uninterpreted function that is to be used for monus.
:return: The resulting PySMT expression.
"""
env = get_env()
if isinstance(expr, BoolLitExpr):
if expr.value == True:
return TRUE()
elif expr.value == False:
return FALSE()
else:
raise Exception("Unkown expression value.")
elif isinstance(expr, NatLitExpr):
return Int(expr.value) if not toReal else Real(expr.value)
elif isinstance(expr, FloatLitExpr):
# This value might be infinity
if expr.is_infinite():
if pysmt_infinity_variable == None:
raise Exception(
"If infinity occurs in an arithmetic expression, then pysmt_infinity_variable must not be none."
)
return pysmt_infinity_variable
else:
return Real(expr.to_fraction())
elif isinstance(expr, VarExpr):
return env.formula_manager.get_symbol(
expr.var) if not toReal else ToReal(
env.formula_manager.get_symbol(expr.var))
elif isinstance(expr, TickExpr):
if not isinstance(expr.expr, NatLitExpr):
raise Exception(
"Currently we allow for constants in tick(..) expressions only."
)
else:
return probably_expr_to_pysmt(expr.expr, pysmt_infinity_variable,
treat_minus_as_monus, monus_euf,
toReal)
elif isinstance(expr, BinopExpr):
if expr.operator == Binop.OR:
return Or(
probably_expr_to_pysmt(expr.lhs, pysmt_infinity_variable,
treat_minus_as_monus, monus_euf,
toReal),
probably_expr_to_pysmt(expr.rhs, pysmt_infinity_variable,
treat_minus_as_monus, monus_euf,
toReal))
if expr.operator == Binop.AND:
return And(
probably_expr_to_pysmt(expr.lhs, pysmt_infinity_variable,
treat_minus_as_monus, monus_euf,
toReal),
probably_expr_to_pysmt(expr.rhs, pysmt_infinity_variable,
treat_minus_as_monus, monus_euf,
toReal))
if expr.operator == Binop.LEQ:
return LE(
probably_expr_to_pysmt(expr.lhs, pysmt_infinity_variable,
treat_minus_as_monus, monus_euf,
toReal),
probably_expr_to_pysmt(expr.rhs, pysmt_infinity_variable,
treat_minus_as_monus, monus_euf,
toReal))
if expr.operator == Binop.LE:
return LT(
probably_expr_to_pysmt(expr.lhs, pysmt_infinity_variable,
treat_minus_as_monus, monus_euf,
toReal),
probably_expr_to_pysmt(expr.rhs, pysmt_infinity_variable,
treat_minus_as_monus, monus_euf,
toReal))
if expr.operator == Binop.EQ:
lhs = probably_expr_to_pysmt(expr.lhs, pysmt_infinity_variable,
treat_minus_as_monus, monus_euf,
toReal)
rhs = probably_expr_to_pysmt(expr.rhs, pysmt_infinity_variable,
treat_minus_as_monus, monus_euf,
toReal)
return EqualsOrIff(lhs, rhs)
if expr.operator == Binop.PLUS:
summand_1 = probably_expr_to_pysmt(expr.lhs,
pysmt_infinity_variable,
treat_minus_as_monus, monus_euf,
toReal)
summand_2 = probably_expr_to_pysmt(expr.rhs,
pysmt_infinity_variable,
treat_minus_as_monus, monus_euf,
toReal)
if summand_1 == pysmt_infinity_variable or summand_2 == pysmt_infinity_variable:
raise Exception(
"Infinity must not occur in a composed arithmetic expression."
)
return Plus(summand_1, summand_2)
if expr.operator == Binop.MINUS:
min_1 = probably_expr_to_pysmt(expr.lhs, pysmt_infinity_variable,
treat_minus_as_monus, monus_euf,
toReal)
min_2 = probably_expr_to_pysmt(expr.rhs, pysmt_infinity_variable,
treat_minus_as_monus, monus_euf,
toReal)
if min_1 == pysmt_infinity_variable or min_2 == pysmt_infinity_variable:
raise Exception(
"Infinity must not occur in a composed arithmetic expression."
)
# Do we have to treat minus as monus?
if treat_minus_as_monus:
if monus_euf == None:
raise Exception(
"If minus is to be treated as monus, then a monus_euf has to be provided."
)
monus_expr = Function(monus_euf, (min_1, min_2))
if toReal:
encountered_real_monus_pairs.add((min_1, min_2))
else:
encountered_monus_pairs.add((min_1, min_2))
return monus_expr
else:
return Minus(min_1, min_2)
if expr.operator == Binop.TIMES:
fac_1 = probably_expr_to_pysmt(expr.lhs, pysmt_infinity_variable,
treat_minus_as_monus, monus_euf,
toReal)
fac_2 = probably_expr_to_pysmt(expr.rhs, pysmt_infinity_variable,
treat_minus_as_monus, monus_euf,
toReal)
if fac_1 == pysmt_infinity_variable or fac_2 == pysmt_infinity_variable:
raise Exception(
"Infinity must not occur in a composed arithmetic expression."
)
return Times(fac_1, fac_2)
elif isinstance(expr, UnopExpr):
if expr.operator == Unop.NEG:
return Not(
probably_expr_to_pysmt(expr.expr, pysmt_infinity_variable,
treat_minus_as_monus, monus_euf,
toReal))
elif expr.operator == Unop.IVERSON:
return probably_expr_to_pysmt(expr.expr, pysmt_infinity_variable,
treat_minus_as_monus, monus_euf,
toReal)
else:
raise Exception("Unsupported Unop Operator")
else:
raise Exception("Invalid expression {expr}")
def _prepare_first_formulae(self):
"""
Prepare formulae for checking 1-inductivity, i.e., whether Phi(I) <= I holds.
"""
# Let I be the candidate upper bound.
# The first goal is to generate formulae that encode P_1 = Phi(I)
# Get P_1
first_bmc_euf = self._bmc_formula_generator.get_eufs()[0]
# K-inductive query involves P_1
self._k_inductive_query = self._construct_k_inductive_query(first_bmc_euf)
# Loop terminate formulae for P_1
self._loop_terminated_formulae = self._bmc_formula_generator.get_loop_terminate_formulae().copy()
# Loop execute formulae for P_2 are the same as for BMC
self._loop_execute_formulae = self._bmc_formula_generator.get_loop_execute_formulae().copy()
# Formulae ensuring that K_1 is the minimum of P_1 and I
self._pointwise_minimum_formulae = set()
arg = substitution_to_argument_tuple(self._characteristic_functional.get_pysmt_program_variables(), {})
for (guard_P, prob_sub_tick_triple) in self._characteristic_functional.get_loop_execute_guard_and_prob_sub_pairs():
for (guard_I, arith_I) in self._upper_bound_dnf:
# guardP AND guard_I and P_1(sub) <= arithI implies K_1(sub) = P_1(sub)
self._pointwise_minimum_formulae.add(self._simplifier.simplify(Implies(And([guard_P, guard_I, LE(Function(first_bmc_euf, arg), arith_I)]),
Equals(Function(self._eufs[0], arg), Function(first_bmc_euf, arg)))))
self._pointwise_minimum_formulae.add(self._simplifier.simplify(
Implies(And([guard_P, guard_I, GT(Function(first_bmc_euf, arg), arith_I)]),
Equals(Function(self._eufs[0], arg), arith_I))))
#self._pointwise_minimum_formulae.add(self._simplifier.simplify(
# Implies(And([guard_P, guard_I, GT(Function(first_bmc_euf, arg), arith_I)]),
# Equals(Function(self._eufs[0], arg), Function(first_bmc_euf, arg)))))
for (guard_P, arith_P) in self._characteristic_functional.get_loop_terminated_guard_and_arith_exp_pairs():
for (guard_I, arith_I) in self._upper_bound_dnf:
# guardP AND guard_I and P_1(sub) <= arithI implies K_1(sub) = P_1(sub)
self._pointwise_minimum_formulae.add(self._simplifier.simplify(Implies(And([guard_P, guard_I, LE(arith_P, arith_I)]),
Equals(Function(self._eufs[0], arg), arith_P))))
self._pointwise_minimum_formulae.add(
self._simplifier.simplify(Implies(And([guard_P, guard_I, GT(arith_P, arith_I)]),
Equals(Function(self._eufs[0], arg), arith_I))))
#self._pointwise_minimum_formulae.add(
# self._simplifier.simplify(Implies(And([guard_P, guard_I, GT(arith_P, arith_I)]),
# Equals(Function(self._eufs[0], arg), arith_P))))
# Next, wee need P_2 to encode the DNF of I ..
second_bmc_euf = self._bmc_formula_generator.get_eufs()[1]
self._continuation_formulae = { Implies(guard,
Equals(Function(second_bmc_euf, self._characteristic_functional.get_pysmt_program_variables_argument()), arith))
for (guard, arith) in self._upper_bound_dnf}
# and to apply the loop_execute_substitutions
new_continuation_formulae = set()
for sub in self._characteristic_functional.get_loop_execute_substitutions():
new_continuation_formulae.update(substitute_all_formulae(self._continuation_formulae, sub, self._euf_substituter, self._simplify_formulae, self._simplifier))
self._continuation_formulae = new_continuation_formulae
# Increment BMC unrolling depth for monus formulae
# In contrast to BMC, we need the next level of monus/rmonus formulae since the 1-induction check already
# involves loop execute formulae (for P_1 and P_2).
# TODO: Optimize and prohibit bmc from generating loop_terminate and zero_step_not_terminate formulae
self._first_monus_formulae = self._bmc_formula_generator.get_monus_formulae().copy()
self._first_rmonus_formulae = self._bmc_formula_generator.get_rmonus_formulae().copy()
self._incremental_bmc._increment_unrolling_depth(True)
# Now P_1 (self._loop_execute_formulae + self._loop_terminated_formulae + self._continuation_formurlae) encodes Phi(I).
# Recall that Psi_I(I) = Phi(I) min I
logger.debug("\n" * 2)
logger.debug("Loop terminated formulae: \n %s" % [form.serialize() for form in self._loop_terminated_formulae])
logger.debug("Loop execute formulae: \n %s" % [form.serialize() for form in self._loop_execute_formulae])
logger.debug("Continuation formulae: \n %s" % [form.serialize() for form in
self._continuation_formulae])
logger.debug("The pointwise minimum formulae are: \n %s" % [form.serialize() for form in
self._pointwise_minimum_formulae])
def get_example_formulae(environment=None):
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)
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]))
bv8 = Symbol("bv1", BV8)
bv16 = Symbol("bv2", BV16)
result = [
# Formula, is_valid, is_sat, is_qf
# x /\ y
Example(expr=And(x, y),
is_valid=False,
is_sat=True,
logic=pysmt.logics.QF_BOOL),
# x <-> y
Example(expr=Iff(x, y),
is_valid=False,
is_sat=True,
logic=pysmt.logics.QF_BOOL),
# (x \/ y ) /\ ! ( x \/ y )
Example(expr=And(Or(x, y), Not(Or(x, y))),
is_valid=False,
is_sat=False,
logic=pysmt.logics.QF_BOOL),
# (x /\ !y)
Example(expr=And(x, Not(y)),
is_valid=False,
is_sat=True,
logic=pysmt.logics.QF_BOOL),
# False -> True
Example(expr=Implies(FALSE(), TRUE()),
is_valid=True,
is_sat=True,
logic=pysmt.logics.QF_BOOL),
#
# LIA
#
# (p > q) /\ x -> y
Example(expr=And(GT(p, q), Implies(x, y)),
is_valid=False,
is_sat=True,
logic=pysmt.logics.QF_IDL),
# (p + q) = 5 /\ (p > q)
Example(expr=And(Equals(Plus(p, q), Int(5)), GT(p, q)),
is_valid=False,
is_sat=True,
logic=pysmt.logics.QF_LIA),
# (p >= q) \/ ( p <= q)
Example(expr=Or(GE(p, q), LE(p, q)),
is_valid=True,
is_sat=True,
logic=pysmt.logics.QF_IDL),
# !( p < q * 2 )
Example(expr=Not(LT(p, Times(q, Int(2)))),
is_valid=False,
is_sat=True,
logic=pysmt.logics.QF_LIA),
# p - (5 - 2) > p
Example(expr=GT(Minus(p, Minus(Int(5), Int(2))), p),
is_valid=False,
is_sat=False,
logic=pysmt.logics.QF_IDL),
# x ? 7: (p + -1) * 3 = q
Example(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(expr=LT(p, Plus(q, Int(1))),
is_valid=False,
is_sat=True,
logic=pysmt.logics.QF_LIA),
#
# LRA
#
# (r > s) /\ x -> y
Example(expr=And(GT(r, s), Implies(x, y)),
is_valid=False,
is_sat=True,
logic=pysmt.logics.QF_RDL),
# (r + s) = 5.6 /\ (r > s)
Example(expr=And(Equals(Plus(r, s), Real(Fraction("5.6"))),
GT(r, s)),
is_valid=False,
is_sat=True,
logic=pysmt.logics.QF_LRA),
# (r >= s) \/ ( r <= s)
Example(expr=Or(GE(r, s), LE(r, s)),
is_valid=True,
is_sat=True,
logic=pysmt.logics.QF_RDL),
# !( (r / (1/2)) < s * 2 )
Example(expr=Not(LT(Div(r, Real((1, 2))), Times(s, Real(2)))),
is_valid=False,
is_sat=True,
logic=pysmt.logics.QF_LRA),
# ! ( r - (5 - 2) > r )
Example(expr=Not(GT(Minus(r, Minus(Real(5), Real(2))), r)),
is_valid=True,
is_sat=True,
logic=pysmt.logics.QF_RDL),
# x ? 7: (s + -1) * 3 = r
Example(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
#
# rf(5, rg(2)) = 0
Example(expr=Equals(Function(rf, (Real(5), Function(rg, (r, )))),
Real(0)),
is_valid=False,
is_sat=True,
logic=pysmt.logics.QF_UFLRA),
# (rg(r) = 5 + 2) <-> (rg(r) = 7)
Example(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),
# (r = s + 1) & (rg(s) = 5) & (rg(r - 1) = 7)
Example(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
#
# bv_one & bv_zero == bv_zero
Example(expr=Equals(BVAnd(BVOne(32), BVZero(32)), BVZero(32)),
is_valid=True,
is_sat=True,
logic=pysmt.logics.QF_BV),
# ~(010) == 101
Example(expr=Equals(BVNot(BV("010")), BV("101")),
is_valid=True,
is_sat=True,
logic=pysmt.logics.QF_BV),
# "111" xor "000" == "000"
Example(expr=Equals(BVXor(BV("111"), BV("000")), BV("000")),
is_valid=False,
is_sat=False,
logic=pysmt.logics.QF_BV),
# bv8 :: bv8 < bv_zero
Example(expr=BVULT(BVConcat(bv8, bv8), BVZero(16)),
is_valid=False,
is_sat=False,
logic=pysmt.logics.QF_BV),
# bv_one[:7] == bv_one
Example(expr=Equals(BVExtract(BVOne(32), end=7), BVOne(8)),
is_valid=True,
is_sat=True,
logic=pysmt.logics.QF_BV),
# (((bv8 + bv_one) * bv(5)) / bv(5)) > bv(0)
Example(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),
# bv16 >=u bv(0)
Example(expr=BVUGE(bv16, BVZero(16)),
is_valid=True,
is_sat=True,
logic=pysmt.logics.QF_BV),
# bv16 >=s bv(0)
Example(expr=BVSGE(bv16, BVZero(16)),
is_valid=False,
is_sat=True,
logic=pysmt.logics.QF_BV),
# (BV(5) rem BV(2) > bv_zero) /\ (BV(5) rem BV(2) < bv_one)
Example(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),
# ((bv_one + (- bv_one)) << 1) >> 1 == bv_one
Example(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),
# bv_one - bv_one == bv_zero
Example(expr=Equals(BVSub(BVOne(32), BVOne(32)), BVZero(32)),
is_valid=True,
is_sat=True,
logic=pysmt.logics.QF_BV),
# Rotations
Example(expr=Equals(BVRor(BVRol(BVOne(32), 1), 1), BVOne(32)),
is_valid=True,
is_sat=True,
logic=pysmt.logics.QF_BV),
# Extensions
Example(expr=Equals(BVZExt(BVZero(5), 11), BVSExt(BVZero(1), 15)),
is_valid=True,
is_sat=True,
logic=pysmt.logics.QF_BV),
# bv16 - bv16 = 0_16
Example(expr=Equals(BVSub(bv16, bv16), BVZero(16)),
is_valid=True,
is_sat=True,
logic=pysmt.logics.QF_BV),
# (bv16 - bv16)[0:7] = bv8
Example(expr=Equals(BVExtract(BVSub(bv16, bv16), 0, 7), bv8),
is_valid=False,
is_sat=True,
logic=pysmt.logics.QF_BV),
# (bv16[0,7] comp bv8) = bv1
Example(expr=Equals(BVComp(BVExtract(bv16, 0, 7), bv8), BVOne(1)),
is_valid=False,
is_sat=True,
logic=pysmt.logics.QF_BV),
# (bv16 comp bv16) = bv0
Example(expr=Equals(BVComp(bv16, bv16), BVZero(1)),
is_valid=False,
is_sat=False,
logic=pysmt.logics.QF_BV),
# (bv16 s< bv16)
Example(expr=BVSLT(bv16, bv16),
is_valid=False,
is_sat=False,
logic=pysmt.logics.QF_BV),
# (bv16 s< 0_16)
Example(expr=BVSLT(bv16, BVZero(16)),
is_valid=False,
is_sat=True,
logic=pysmt.logics.QF_BV),
# (bv16 u< bv16)
Example(expr=BVULT(bv16, bv16),
is_valid=False,
is_sat=False,
logic=pysmt.logics.QF_BV),
# (bv16 s< 0_16)
Example(expr=BVULT(bv16, BVZero(16)),
is_valid=False,
is_sat=False,
logic=pysmt.logics.QF_BV),
# (bv16 | 0_16) = bv16
Example(expr=Equals(BVOr(bv16, BVZero(16)), bv16),
is_valid=True,
is_sat=True,
logic=pysmt.logics.QF_BV),
# (bv16 & 0_16) = 0_16
Example(expr=Equals(BVAnd(bv16, BVZero(16)), BVZero(16)),
is_valid=True,
is_sat=True,
logic=pysmt.logics.QF_BV),
# 0_16 s< bv16 & ((bv16 s/ -1) s< 0)
Example(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),
# 0_16 s< bv16 & ((bv16 s% -1) s< 0)
Example(expr=And(BVSLT(BVZero(16), bv16),
BVSLT(BVSRem(bv16, BVOne(16)), BVZero(16))),
is_valid=False,
is_sat=False,
logic=pysmt.logics.QF_BV),
# bv16 u% 1 = 0_16
Example(expr=Equals(BVURem(bv16, BVOne(16)), BVZero(16)),
is_valid=True,
is_sat=True,
logic=pysmt.logics.QF_BV),
# bv16 s% 1 = 0_16
Example(expr=Equals(BVSRem(bv16, BVOne(16)), BVZero(16)),
is_valid=True,
is_sat=True,
logic=pysmt.logics.QF_BV),
# bv16 s% -1 = 0_16
Example(expr=Equals(BVSRem(bv16, BVNeg(BVOne(16))), BVZero(16)),
is_valid=True,
is_sat=True,
logic=pysmt.logics.QF_BV),
# bv16 a>> 0 = bv16
Example(expr=Equals(BVAShr(bv16, BVZero(16)), bv16),
is_valid=True,
is_sat=True,
logic=pysmt.logics.QF_BV),
# 0 s<= bv16 & bv16 a>> 1 = bv16 >> 1
Example(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
#
# forall y . x -> y
Example(expr=ForAll([y], Implies(x, y)),
is_valid=False,
is_sat=True,
logic=pysmt.logics.BOOL),
# forall p,q . p + q = 0
Example(expr=ForAll([p, q], Equals(Plus(p, q), Int(0))),
is_valid=False,
is_sat=False,
logic=pysmt.logics.LIA),
# forall r,s . ((r > 0) & (s > 0)) -> (r - s < r)
Example(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),
# exists x,y . x -> y
Example(expr=Exists([x, y], Implies(x, y)),
is_valid=True,
is_sat=True,
logic=pysmt.logics.BOOL),
# exists p,q . p + q = 0
Example(expr=Exists([p, q], Equals(Plus(p, q), Int(0))),
is_valid=True,
is_sat=True,
logic=pysmt.logics.LIA),
# exists r . forall s . (r - s > r)
Example(expr=Exists([r], ForAll([s], GT(Minus(r, s), r))),
is_valid=False,
is_sat=False,
logic=pysmt.logics.LRA),
# forall r . exists s . (r - s > r)
Example(expr=ForAll([r], Exists([s], GT(Minus(r, s), r))),
is_valid=True,
is_sat=True,
logic=pysmt.logics.LRA),
# x /\ forall r. (r + s = 5)
Example(expr=And(x, ForAll([r], Equals(Plus(r, s), Real(5)))),
is_valid=False,
is_sat=False,
logic=pysmt.logics.LRA),
#
# UFLIRA
#
# ih(r,q) > p /\ (x -> y)
Example(expr=And(GT(Function(ih, (r, q)), p), Implies(x, y)),
is_valid=False,
is_sat=True,
logic=pysmt.logics.QF_UFLIRA),
# ( (p - 3) = q ) -> ( ih(r, q + 3) > p \/ ih(r, p) <= p )
Example(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),
# ( (ToReal(p - 3) = r) /\ (ToReal(q) = r) ) ->
# ( ( ih(ToReal(p - 3), q + 3) > p ) \/ (ih(r, p) <= p) )
Example(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),
# ! ( (ToReal(p - 3) = r /\ ToReal(q) = r) ->
# ( ih(ToReal(p - 3), q + 3) > p \/
# ih(r,p) <= p ) )
Example(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),
# Test complex names
Example(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),
]
return result