def test_ite_term(solver):
bvSort = solver.mkBitVectorSort(8)
intSort = solver.getIntegerSort()
boolSort = solver.getBooleanSort()
funSort1 = solver.mkFunctionSort(bvSort, intSort)
funSort2 = solver.mkFunctionSort(intSort, boolSort)
b = solver.mkTrue()
with pytest.raises(RuntimeError):
Term(solver).iteTerm(b, b)
with pytest.raises(RuntimeError):
b.iteTerm(Term(solver), b)
with pytest.raises(RuntimeError):
b.iteTerm(b, Term(solver))
b.iteTerm(b, b)
x = solver.mkVar(solver.mkBitVectorSort(8), "x")
b.iteTerm(x, x)
b.iteTerm(b, b)
with pytest.raises(RuntimeError):
b.iteTerm(x, b)
with pytest.raises(RuntimeError):
x.iteTerm(x, x)
with pytest.raises(RuntimeError):
x.iteTerm(x, b)
f = solver.mkVar(funSort1, "f")
with pytest.raises(RuntimeError):
f.iteTerm(b, b)
with pytest.raises(RuntimeError):
x.iteTerm(b, x)
p = solver.mkVar(funSort2, "p")
with pytest.raises(RuntimeError):
p.iteTerm(b, b)
with pytest.raises(RuntimeError):
p.iteTerm(x, b)
zero = solver.mkInteger(0)
with pytest.raises(RuntimeError):
zero.iteTerm(x, x)
with pytest.raises(RuntimeError):
zero.iteTerm(x, b)
f_x = solver.mkTerm(Kind.ApplyUf, f, x)
with pytest.raises(RuntimeError):
f_x.iteTerm(b, b)
with pytest.raises(RuntimeError):
f_x.iteTerm(b, x)
sum = solver.mkTerm(Kind.Add, f_x, f_x)
with pytest.raises(RuntimeError):
sum.iteTerm(x, x)
with pytest.raises(RuntimeError):
sum.iteTerm(b, x)
p_0 = solver.mkTerm(Kind.ApplyUf, p, zero)
p_0.iteTerm(b, b)
p_0.iteTerm(x, x)
with pytest.raises(RuntimeError):
p_0.iteTerm(x, b)
p_f_x = solver.mkTerm(Kind.ApplyUf, p, f_x)
p_f_x.iteTerm(b, b)
p_f_x.iteTerm(x, x)
with pytest.raises(RuntimeError):
p_f_x.iteTerm(x, b)
def test_get_id(solver):
n = Term(solver)
with pytest.raises(RuntimeError):
n.getId()
x = solver.mkVar(solver.getIntegerSort(), "x")
x.getId()
y = x
assert x.getId() == y.getId()
z = solver.mkVar(solver.getIntegerSort(), "z")
assert x.getId() != z.getId()
def test_add_rules(solver):
solver.setOption("sygus", "true")
boolean = solver.getBooleanSort()
integer = solver.getIntegerSort()
null_term = Term(solver)
start = solver.mkVar(boolean)
nts = solver.mkVar(boolean)
g = solver.mkGrammar([], [start])
g.addRules(start, {solver.mkBoolean(False)})
#Expecting errors
with pytest.raises(RuntimeError):
g.addRules(null_term, [solver.mkBoolean(False)])
with pytest.raises(RuntimeError):
g.addRules(start, [null_term])
with pytest.raises(RuntimeError):
g.addRules(nts, [solver.mkBoolean(False)])
with pytest.raises(RuntimeError):
g.addRules(start, [solver.mkInteger(0)])
with pytest.raises(RuntimeError):
g.addRules(start, [nts])
#Expecting no errors
solver.synthFun("f", {}, boolean, g)
#Expecting an error
with pytest.raises(RuntimeError):
g.addRules(start, solver.mkBoolean(False))
def test_not_term(solver):
bvSort = solver.mkBitVectorSort(8)
intSort = solver.getIntegerSort()
boolSort = solver.getBooleanSort()
funSort1 = solver.mkFunctionSort(bvSort, intSort)
funSort2 = solver.mkFunctionSort(intSort, boolSort)
with pytest.raises(RuntimeError):
Term(solver).notTerm()
b = solver.mkTrue()
b.notTerm()
x = solver.mkVar(solver.mkBitVectorSort(8), "x")
with pytest.raises(RuntimeError):
x.notTerm()
f = solver.mkVar(funSort1, "f")
with pytest.raises(RuntimeError):
f.notTerm()
p = solver.mkVar(funSort2, "p")
with pytest.raises(RuntimeError):
p.notTerm()
zero = solver.mkInteger(0)
with pytest.raises(RuntimeError):
zero.notTerm()
f_x = solver.mkTerm(Kind.ApplyUf, f, x)
with pytest.raises(RuntimeError):
f_x.notTerm()
sum = solver.mkTerm(Kind.Add, f_x, f_x)
with pytest.raises(RuntimeError):
sum.notTerm()
p_0 = solver.mkTerm(Kind.ApplyUf, p, zero)
p_0.notTerm()
p_f_x = solver.mkTerm(Kind.ApplyUf, p, f_x)
p_f_x.notTerm()
def test_add_any_variable(solver):
solver.setOption("sygus", "true")
boolean = solver.getBooleanSort()
null_term = Term(solver)
x = solver.mkVar(boolean)
start = solver.mkVar(boolean)
nts = solver.mkVar(boolean)
g1 = solver.mkGrammar({x}, {start})
g2 = solver.mkGrammar({}, {start})
g1.addAnyVariable(start)
g1.addAnyVariable(start)
g2.addAnyVariable(start)
with pytest.raises(RuntimeError):
g1.addAnyVariable(null_term)
with pytest.raises(RuntimeError):
g1.addAnyVariable(nts)
solver.synthFun("f", {}, boolean, g1)
with pytest.raises(RuntimeError):
g1.addAnyVariable(start)
def test_get_sort(solver):
bvSort = solver.mkBitVectorSort(8)
intSort = solver.getIntegerSort()
boolSort = solver.getBooleanSort()
funSort1 = solver.mkFunctionSort(bvSort, intSort)
funSort2 = solver.mkFunctionSort(intSort, boolSort)
n = Term(solver)
with pytest.raises(RuntimeError):
n.getSort()
x = solver.mkVar(bvSort, "x")
x.getSort()
assert x.getSort() == bvSort
y = solver.mkVar(bvSort, "y")
y.getSort()
assert y.getSort() == bvSort
f = solver.mkVar(funSort1, "f")
f.getSort()
assert f.getSort() == funSort1
p = solver.mkVar(funSort2, "p")
p.getSort()
assert p.getSort() == funSort2
zero = solver.mkInteger(0)
zero.getSort()
assert zero.getSort() == intSort
f_x = solver.mkTerm(Kind.ApplyUf, f, x)
f_x.getSort()
assert f_x.getSort() == intSort
f_y = solver.mkTerm(Kind.ApplyUf, f, y)
f_y.getSort()
assert f_y.getSort() == intSort
sum = solver.mkTerm(Kind.Add, f_x, f_y)
sum.getSort()
assert sum.getSort() == intSort
p_0 = solver.mkTerm(Kind.ApplyUf, p, zero)
p_0.getSort()
assert p_0.getSort() == boolSort
p_f_y = solver.mkTerm(Kind.ApplyUf, p, f_y)
p_f_y.getSort()
assert p_f_y.getSort() == boolSort
def test_term_children(solver):
# simple term 2+3
two = solver.mkInteger(2)
t1 = solver.mkTerm(Kind.Add, two, solver.mkInteger(3))
assert t1[0] == two
assert t1.getNumChildren() == 2
tnull = Term(solver)
with pytest.raises(RuntimeError):
tnull.getNumChildren()
# apply term f(2)
intSort = solver.getIntegerSort()
fsort = solver.mkFunctionSort(intSort, intSort)
f = solver.mkConst(fsort, "f")
t2 = solver.mkTerm(Kind.ApplyUf, f, two)
# due to our higher-order view of terms, we treat f as a child of Kind.ApplyUf
assert t2.getNumChildren() == 2
assert t2[0] == f
assert t2[1] == two
with pytest.raises(RuntimeError):
tnull[0]
def test_eq(solver):
uSort = solver.mkUninterpretedSort("u")
x = solver.mkVar(uSort, "x")
y = solver.mkVar(uSort, "y")
z = Term(solver)
assert x == x
assert not x != x
assert not x == y
assert x != y
assert not (x == z)
assert x != z
def test_get_kind(solver):
uSort = solver.mkUninterpretedSort("u")
intSort = solver.getIntegerSort()
boolSort = solver.getBooleanSort()
funSort1 = solver.mkFunctionSort(uSort, intSort)
funSort2 = solver.mkFunctionSort(intSort, boolSort)
n = Term(solver)
with pytest.raises(RuntimeError):
n.getKind()
x = solver.mkVar(uSort, "x")
x.getKind()
y = solver.mkVar(uSort, "y")
y.getKind()
f = solver.mkVar(funSort1, "f")
f.getKind()
p = solver.mkVar(funSort2, "p")
p.getKind()
zero = solver.mkInteger(0)
zero.getKind()
f_x = solver.mkTerm(Kind.ApplyUf, f, x)
f_x.getKind()
f_y = solver.mkTerm(Kind.ApplyUf, f, y)
f_y.getKind()
sum = solver.mkTerm(Kind.Add, f_x, f_y)
sum.getKind()
p_0 = solver.mkTerm(Kind.ApplyUf, p, zero)
p_0.getKind()
p_f_y = solver.mkTerm(Kind.ApplyUf, p, f_y)
p_f_y.getKind()
# Sequence kinds do not exist internally, test that the API properly
# converts them back.
seqSort = solver.mkSequenceSort(intSort)
s = solver.mkConst(seqSort, "s")
ss = solver.mkTerm(Kind.SeqConcat, s, s)
assert ss.getKind() == Kind.SeqConcat
def test_substitute(solver):
x = solver.mkConst(solver.getIntegerSort(), "x")
one = solver.mkInteger(1)
ttrue = solver.mkTrue()
xpx = solver.mkTerm(Kind.Add, x, x)
onepone = solver.mkTerm(Kind.Add, one, one)
assert xpx.substitute(x, one) == onepone
assert onepone.substitute(one, x) == xpx
# incorrect due to type
with pytest.raises(RuntimeError):
xpx.substitute(one, ttrue)
# simultaneous substitution
y = solver.mkConst(solver.getIntegerSort(), "y")
xpy = solver.mkTerm(Kind.Add, x, y)
xpone = solver.mkTerm(Kind.Add, y, one)
es = []
rs = []
es.append(x)
rs.append(y)
es.append(y)
rs.append(one)
assert xpy.substitute(es, rs) == xpone
# incorrect substitution due to arity
rs.pop()
with pytest.raises(RuntimeError):
xpy.substitute(es, rs)
# incorrect substitution due to types
rs.append(ttrue)
with pytest.raises(RuntimeError):
xpy.substitute(es, rs)
# null cannot substitute
tnull = Term(solver)
with pytest.raises(RuntimeError):
tnull.substitute(one, x)
with pytest.raises(RuntimeError):
xpx.substitute(tnull, x)
with pytest.raises(RuntimeError):
xpx.substitute(x, tnull)
rs.pop()
rs.append(tnull)
with pytest.raises(RuntimeError):
xpy.substitute(es, rs)
es.clear()
rs.clear()
es.append(x)
rs.append(y)
with pytest.raises(RuntimeError):
tnull.substitute(es, rs)
es.append(tnull)
rs.append(one)
with pytest.raises(RuntimeError):
xpx.substitute(es, rs)
def test_datatype_specialized_cons(solver):
# Create mutual datatypes corresponding to this definition block:
# DATATYPE
# plist[X] = pcons(car: X, cdr: plist[X]) | pnil
# END
# Make unresolved types as placeholders
unresTypes = set([])
unresList = solver.mkSortConstructorSort("plist", 1)
unresTypes.add(unresList)
v = []
x = solver.mkParamSort("X")
v.append(x)
plist = solver.mkDatatypeDecl("plist", v)
args = [x]
urListX = unresList.instantiate(args)
pcons = solver.mkDatatypeConstructorDecl("pcons")
pcons.addSelector("car", x)
pcons.addSelector("cdr", urListX)
plist.addConstructor(pcons)
nil5 = solver.mkDatatypeConstructorDecl("pnil")
plist.addConstructor(nil5)
dtdecls = [plist]
# make the datatype sorts
dtsorts = solver.mkDatatypeSorts(dtdecls, unresTypes)
assert len(dtsorts) == 1
d = dtsorts[0].getDatatype()
nilc = d[0]
isort = solver.getIntegerSort()
iargs = [isort]
listInt = dtsorts[0].instantiate(iargs)
testConsTerm = Term(solver)
# get the specialized constructor term for list[Int]
testConsTerm = nilc.getInstantiatedConstructorTerm(listInt)
assert testConsTerm != nilc.getConstructorTerm()
# error to get the specialized constructor term for Int
with pytest.raises(RuntimeError):
nilc.getInstantiatedConstructorTerm(isort)
def test_has_get_symbol(solver):
n = Term(solver)
t = solver.mkBoolean(True)
c = solver.mkConst(solver.getBooleanSort(), "|\\|")
with pytest.raises(RuntimeError):
n.hasSymbol()
assert not t.hasSymbol()
assert c.hasSymbol()
with pytest.raises(RuntimeError):
n.getSymbol()
with pytest.raises(RuntimeError):
t.getSymbol()
assert c.getSymbol() == "|\\|"
def test_add_any_constant(solver):
solver.setOption("sygus", "true")
boolean = solver.getBooleanSort()
null_term = Term(solver)
start = solver.mkVar(boolean)
nts = solver.mkVar(boolean)
g = solver.mkGrammar({}, {start})
g.addAnyConstant(start)
g.addAnyConstant(start)
with pytest.raises(RuntimeError):
g.addAnyConstant(null_term)
with pytest.raises(RuntimeError):
g.addAnyConstant(nts)
solver.synthFun("f", {}, boolean, g)
with pytest.raises(RuntimeError):
g.addAnyConstant(start)
def test_eq_term(solver):
bvSort = solver.mkBitVectorSort(8)
intSort = solver.getIntegerSort()
boolSort = solver.getBooleanSort()
funSort1 = solver.mkFunctionSort(bvSort, intSort)
funSort2 = solver.mkFunctionSort(intSort, boolSort)
b = solver.mkTrue()
with pytest.raises(RuntimeError):
Term(solver).eqTerm(b)
with pytest.raises(RuntimeError):
b.eqTerm(Term(solver))
b.eqTerm(b)
x = solver.mkVar(solver.mkBitVectorSort(8), "x")
with pytest.raises(RuntimeError):
x.eqTerm(b)
x.eqTerm(x)
f = solver.mkVar(funSort1, "f")
with pytest.raises(RuntimeError):
f.eqTerm(b)
with pytest.raises(RuntimeError):
f.eqTerm(x)
f.eqTerm(f)
p = solver.mkVar(funSort2, "p")
with pytest.raises(RuntimeError):
p.eqTerm(b)
with pytest.raises(RuntimeError):
p.eqTerm(x)
with pytest.raises(RuntimeError):
p.eqTerm(f)
p.eqTerm(p)
zero = solver.mkInteger(0)
with pytest.raises(RuntimeError):
zero.eqTerm(b)
with pytest.raises(RuntimeError):
zero.eqTerm(x)
with pytest.raises(RuntimeError):
zero.eqTerm(f)
with pytest.raises(RuntimeError):
zero.eqTerm(p)
zero.eqTerm(zero)
f_x = solver.mkTerm(Kind.ApplyUf, f, x)
with pytest.raises(RuntimeError):
f_x.eqTerm(b)
with pytest.raises(RuntimeError):
f_x.eqTerm(x)
with pytest.raises(RuntimeError):
f_x.eqTerm(f)
with pytest.raises(RuntimeError):
f_x.eqTerm(p)
f_x.eqTerm(zero)
f_x.eqTerm(f_x)
sum = solver.mkTerm(Kind.Add, f_x, f_x)
with pytest.raises(RuntimeError):
sum.eqTerm(b)
with pytest.raises(RuntimeError):
sum.eqTerm(x)
with pytest.raises(RuntimeError):
sum.eqTerm(f)
with pytest.raises(RuntimeError):
sum.eqTerm(p)
sum.eqTerm(zero)
sum.eqTerm(f_x)
sum.eqTerm(sum)
p_0 = solver.mkTerm(Kind.ApplyUf, p, zero)
p_0.eqTerm(b)
with pytest.raises(RuntimeError):
p_0.eqTerm(x)
with pytest.raises(RuntimeError):
p_0.eqTerm(f)
with pytest.raises(RuntimeError):
p_0.eqTerm(p)
with pytest.raises(RuntimeError):
p_0.eqTerm(zero)
with pytest.raises(RuntimeError):
p_0.eqTerm(f_x)
with pytest.raises(RuntimeError):
p_0.eqTerm(sum)
p_0.eqTerm(p_0)
p_f_x = solver.mkTerm(Kind.ApplyUf, p, f_x)
p_f_x.eqTerm(b)
with pytest.raises(RuntimeError):
p_f_x.eqTerm(x)
with pytest.raises(RuntimeError):
p_f_x.eqTerm(f)
with pytest.raises(RuntimeError):
p_f_x.eqTerm(p)
with pytest.raises(RuntimeError):
p_f_x.eqTerm(zero)
with pytest.raises(RuntimeError):
p_f_x.eqTerm(f_x)
with pytest.raises(RuntimeError):
p_f_x.eqTerm(sum)
p_f_x.eqTerm(p_0)
p_f_x.eqTerm(p_f_x)
def test_is_null(solver):
x = Term(solver)
assert x.isNull()
x = solver.mkVar(solver.mkBitVectorSort(4), "x")
assert not x.isNull()
