def main():
slv = pycvc4.Solver()
slv.setOption("produce-models", "true")
# Setting an invalid option
try:
slv.setOption("non-existing", "true")
return 1
except:
pass
# Creating a term with an invalid type
try:
integer = slv.getIntegerSort()
x = slv.mkConst("x", integer)
invalidTerm = em.mkTerm(AND, x, x)
slv.checkSat(invalidTerm)
return 1
except:
pass
# Asking for a model after unsat result
try:
slv.checkSat(slv.mkBoolean(False))
slv.getModel()
return 1
except:
pass
return 0
def test_add_rules():
solver = pycvc4.Solver()
boolean = solver.getBooleanSort()
integer = solver.getIntegerSort()
nullTerm = pycvc4.Term(solver)
start = solver.mkVar(boolean)
nts = solver.mkVar(boolean)
g = solver.mkSygusGrammar([], [start])
g.addRules(start, {solver.mkBoolean(False)})
#Expecting errors
with pytest.raises(Exception):
g.addRules(nullTerm, solver.mkBoolean(False))
with pytest.raises(Exception):
g.addRules(start, {nullTerm})
with pytest.raises(Exception):
g.addRules(nts, {solver.mkBoolean(False)})
with pytest.raises(Exception):
g.addRules(start, {solver.mkReal(0)})
#Expecting no errors
solver.synthFun("f", {}, boolean, g)
#Expecting an error
with pytest.raises(Exception):
g.addRules(start, solver.mkBoolean(False))
def testAddAnyVariable():
solver = pycvc4.Solver()
boolean = solver.getBooleanSort()
nullTerm = pycvc4.Term(solver)
x = solver.mkVar(boolean)
start = solver.mkVar(boolean)
nts = solver.mkVar(boolean)
g1 = solver.mkSygusGrammar({x}, {start})
g2 = solver.mkSygusGrammar({}, {start})
g1.addAnyVariable(start)
g1.addAnyVariable(start)
g2.addAnyVariable(start)
with pytest.raises(Exception):
g1.addAnyVariable(nullTerm)
with pytest.raises(Exception):
g1.addAnyVariable(nts)
solver.synthFun("f", {}, boolean, g1)
with pytest.raises(Exception):
g1.addAnyVariable(start)
def testGetTupleSorts():
solver = pycvc4.Solver()
tupleSort = solver.mkTupleSort([solver.getIntegerSort(), solver.getIntegerSort()])
tupleSort.getTupleSorts()
bvSort = solver.mkBitVectorSort(32)
with pytest.raises(Exception):
bvSort.getTupleSorts()
def testGetBVSize():
solver = pycvc4.Solver()
bvSort = solver.mkBitVectorSort(32)
bvSort.getBVSize()
setSort = solver.mkSetSort(solver.getIntegerSort())
with pytest.raises(Exception):
setSort.getBVSize()
def testIsUninterpretedSortParameterized():
solver = pycvc4.Solver()
uSort = solver.mkUninterpretedSort("u")
uSort.isUninterpretedSortParameterized()
bvSort = solver.mkBitVectorSort(32)
with pytest.raises(Exception):
bvSort.isUninterpretedSortParameterized()
def testGetUninterpretedSortParamSorts():
solver = pycvc4.Solver()
uSort = solver.mkUninterpretedSort("u")
uSort.getUninterpretedSortParamSorts()
bvSort = solver.mkBitVectorSort(32)
with pytest.raises(Exception):
bvSort.getUninterpretedSortParamSorts()
def testGetFPSignificandSize():
solver = pycvc4.Solver()
fpSort = solver.mkFloatingPointSort(4, 8)
fpSort.getFPSignificandSize()
setSort = solver.mkSetSort(solver.getIntegerSort())
with pytest.raises(Exception):
setSort.getFPSignificandSize()
def testGetUninterpretedSortConstructorArity():
solver = pycvc4.Solver()
sSort = solver.mkSortConstructorSort("s", 2)
sSort.getSortConstructorArity()
bvSort = solver.mkBitVectorSort(32)
with pytest.raises(Exception):
bvSort.getSortConstructorArity()
def testGetArrayElementSort():
solver = pycvc4.Solver()
elementSort = solver.mkBitVectorSort(32)
indexSort = solver.mkBitVectorSort(32)
arraySort = solver.mkArraySort(indexSort, elementSort)
arraySort.getArrayElementSort()
with pytest.raises(Exception):
indexSort.getArrayElementSort()
def testGetFunctionCodomainSort():
solver = pycvc4.Solver()
funSort = solver.mkFunctionSort(solver.mkUninterpretedSort("u"),
solver.getIntegerSort())
funSort.getFunctionCodomainSort()
bvSort = solver.mkBitVectorSort(32)
with pytest.raises(Exception):
bvSort.getFunctionCodomainSort()
def test_getitem():
solver = pycvc4.Solver()
intsort = solver.getIntegerSort()
x = solver.mkConst(intsort, 'x')
y = solver.mkConst(intsort, 'y')
xpy = solver.mkTerm(kinds.Plus, x, y)
assert xpy[0] == x
assert xpy[1] == y
def testGetSequenceElementSort():
solver = pycvc4.Solver()
seqSort = solver.mkSequenceSort(solver.getIntegerSort())
seqSort.getSequenceElementSort()
bvSort = solver.mkBitVectorSort(32)
assert not bvSort.isSequence()
with pytest.raises(Exception):
bvSort.getSetElementSort()
def testGetString():
solver = pycvc4.Solver()
s1 = '"test\n"😃\\u{a}'
t1 = solver.mkString(s1)
assert s1 == t1.toPythonObj()
s2 = '❤️CVC4❤️'
t2 = solver.mkString(s2)
assert s2 == t2.toPythonObj()
def testGetReal():
solver = pycvc4.Solver()
half = solver.mkReal("1/2")
assert half.toPythonObj() == Fraction(1, 2)
neg34 = solver.mkReal("-3/4")
assert neg34.toPythonObj() == Fraction(-3, 4)
neg1 = solver.mkInteger("-1")
assert neg1.toPythonObj() == -1
def testSortCompare():
solver = pycvc4.Solver()
boolSort = solver.getBooleanSort()
intSort = solver.getIntegerSort()
bvSort = solver.mkBitVectorSort(32)
bvSort2 = solver.mkBitVectorSort(32)
assert bvSort >= bvSort2
assert bvSort <= bvSort2
assert (intSort > boolSort) != (intSort < boolSort)
assert (intSort > bvSort or intSort == bvSort) == (intSort >= bvSort)
def test_is_const():
solver = pycvc4.Solver()
intsort = solver.getIntegerSort()
one = solver.mkReal(1)
x = solver.mkConst(intsort, 'x')
xpone = solver.mkTerm(kinds.Plus, x, one)
onepone = solver.mkTerm(kinds.Plus, one, one)
assert not x.isConst()
assert one.isConst()
assert not xpone.isConst()
assert not onepone.isConst()
def test_eq():
solver = pycvc4.Solver()
usort = solver.mkUninterpretedSort('u')
x = solver.mkConst(usort, 'x')
y = solver.mkConst(usort, 'y')
z = x
assert x == x
assert x == z
assert not (x != x)
assert x != y
assert y != z
def testGetFPExponentSize():
solver = pycvc4.Solver()
if solver.supportsFloatingPoint():
fpSort = solver.mkFloatingPointSort(4, 8)
fpSort.getFPExponentSize()
setSort = solver.mkSetSort(solver.getIntegerSort())
with pytest.raises(Exception):
setSort.getFPExponentSize()
else:
with pytest.raises(Exception):
solver.mkFloatingPointSort(4, 8)
def test_get_kind():
solver = pycvc4.Solver()
intsort = solver.getIntegerSort()
x = solver.mkConst(intsort, 'x')
y = solver.mkConst(intsort, 'y')
xpy = solver.mkTerm(kinds.Plus, x, y)
assert xpy.getKind() == kinds.Plus
funsort = solver.mkFunctionSort(intsort, intsort)
f = solver.mkConst(funsort, 'f')
assert f.getKind() == kinds.Constant
fx = solver.mkTerm(kinds.ApplyUf, f, x)
assert fx.getKind() == kinds.ApplyUf
def testGetArray():
solver = pycvc4.Solver()
arrsort = solver.mkArraySort(solver.getRealSort(), solver.getRealSort())
zero_array = solver.mkConstArray(arrsort, solver.mkInteger(0))
stores = solver.mkTerm(kinds.Store, zero_array, solver.mkInteger(1), solver.mkInteger(2))
stores = solver.mkTerm(kinds.Store, stores, solver.mkInteger(2), solver.mkInteger(3))
stores = solver.mkTerm(kinds.Store, stores, solver.mkInteger(4), solver.mkInteger(5))
array_dict = stores.toPythonObj()
assert array_dict[1] == 2
assert array_dict[2] == 3
assert array_dict[4] == 5
# an index that wasn't stored at should give zero
assert array_dict[8] == 0
def testGetDatatypeArity():
solver = pycvc4.Solver()
# create datatype sort, check should not fail
dtypeSpec = solver.mkDatatypeDecl("list")
cons = solver.mkDatatypeConstructorDecl("cons")
cons.addSelector("head", solver.getIntegerSort())
dtypeSpec.addConstructor(cons)
nil = solver.mkDatatypeConstructorDecl("nil")
dtypeSpec.addConstructor(nil)
dtypeSort = solver.mkDatatypeSort(dtypeSpec)
dtypeSort.getDatatypeArity()
# create bv sort, check should fail
bvSort = solver.mkBitVectorSort(32)
with pytest.raises(Exception):
bvSort.getDatatypeArity()
def test_get_sort():
solver = pycvc4.Solver()
intsort = solver.getIntegerSort()
bvsort8 = solver.mkBitVectorSort(8)
x = solver.mkConst(intsort, 'x')
y = solver.mkConst(intsort, 'y')
a = solver.mkConst(bvsort8, 'a')
b = solver.mkConst(bvsort8, 'b')
assert x.getSort() == intsort
assert solver.mkTerm(kinds.Plus, x, y).getSort() == intsort
assert a.getSort() == bvsort8
assert solver.mkTerm(kinds.BVConcat, a, b).getSort() == solver.mkBitVectorSort(16)
def testGetDatatype():
solver = pycvc4.Solver()
dtypeSpec = solver.mkDatatypeDecl("list")
cons = solver.mkDatatypeConstructorDecl("cons")
cons.addSelector("head", solver.getIntegerSort())
dtypeSpec.addConstructor(cons)
nil = solver.mkDatatypeConstructorDecl("nil")
dtypeSpec.addConstructor(nil)
dtypeSort = solver.mkDatatypeSort(dtypeSpec)
# expecting no Error
dtypeSort.getDatatype()
bvSort = solver.mkBitVectorSort(32)
with pytest.raises(Exception):
# expect an exception
bvSort.getDatatype()
def testDatatypeSorts():
solver = pycvc4.Solver()
intSort = solver.getIntegerSort()
# create datatype sort to test
dtypeSpec = solver.mkDatatypeDecl("list")
cons = solver.mkDatatypeConstructorDecl("cons")
cons.addSelector("head", intSort)
cons.addSelectorSelf("tail")
dtypeSpec.addConstructor(cons)
nil = solver.mkDatatypeConstructorDecl("nil")
dtypeSpec.addConstructor(nil)
dtypeSort = solver.mkDatatypeSort(dtypeSpec)
dt = dtypeSort.getDatatype()
assert not dtypeSort.isConstructor()
with pytest.raises(Exception):
dtypeSort.getConstructorCodomainSort()
with pytest.raises(Exception):
dtypeSort.getConstructorDomainSorts()
with pytest.raises(Exception):
dtypeSort.getConstructorArity()
# get constructor
dcons = dt[0]
consTerm = dcons.getConstructorTerm()
consSort = consTerm.getSort()
assert consSort.isConstructor()
assert not consSort.isTester()
assert not consSort.isSelector()
assert consSort.getConstructorArity() == 2
consDomSorts = consSort.getConstructorDomainSorts()
assert consDomSorts[0] == intSort
assert consDomSorts[1] == dtypeSort
assert consSort.getConstructorCodomainSort() == dtypeSort
# get tester
isConsTerm = dcons.getTesterTerm()
assert isConsTerm.getSort().isTester()
# get selector
dselTail = dcons[1]
tailTerm = dselTail.getSelectorTerm()
assert tailTerm.getSort().isSelector()
def test_const_sequence_elements():
solver = pycvc4.Solver()
realsort = solver.getRealSort()
seqsort = solver.mkSequenceSort(realsort)
s = solver.mkEmptySequence(seqsort)
assert s.getKind() == kinds.ConstSequence
# empty sequence has zero elements
cs = s.getConstSequenceElements()
assert len(cs) == 0
# A seq.unit app is not a constant sequence (regardless of whether it is
# applied to a constant).
su = solver.mkTerm(kinds.SeqUnit, solver.mkReal(1))
try:
su.getConstSequenceElements()
assert False
except:
assert True
def testSortSubtyping():
solver = pycvc4.Solver()
intSort = solver.getIntegerSort()
realSort = solver.getRealSort()
assert intSort.isSubsortOf(realSort)
assert not realSort.isSubsortOf(intSort)
assert intSort.isComparableTo(realSort)
assert realSort.isComparableTo(intSort)
arraySortII = solver.mkArraySort(intSort, intSort)
arraySortIR = solver.mkArraySort(intSort, realSort)
assert not arraySortII.isComparableTo(intSort)
# we do not support subtyping for arrays
assert not arraySortII.isComparableTo(arraySortIR)
setSortI = solver.mkSetSort(intSort)
setSortR = solver.mkSetSort(realSort)
# we support subtyping for sets
assert setSortI.isSubsortOf(setSortR)
assert setSortR.isComparableTo(setSortI)
def test_get_kind():
solver = pycvc4.Solver()
intsort = solver.getIntegerSort()
x = solver.mkConst(intsort, 'x')
y = solver.mkConst(intsort, 'y')
xpy = solver.mkTerm(kinds.Plus, x, y)
assert xpy.getKind() == kinds.Plus
funsort = solver.mkFunctionSort(intsort, intsort)
f = solver.mkConst(funsort, 'f')
assert f.getKind() == kinds.Constant
fx = solver.mkTerm(kinds.ApplyUf, f, x)
assert fx.getKind() == kinds.ApplyUf
# 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(kinds.SeqConcat, s, s)
assert ss.getKind() == kinds.SeqConcat
def test_get_op():
solver = pycvc4.Solver()
intsort = solver.getIntegerSort()
funsort = solver.mkFunctionSort(intsort, intsort)
x = solver.mkConst(intsort, 'x')
f = solver.mkConst(funsort, 'f')
fx = solver.mkTerm(kinds.ApplyUf, f, x)
assert not x.hasOp()
try:
op = x.getOp()
assert False
except:
assert True
assert fx.hasOp()
assert fx.getOp().getKind() == kinds.ApplyUf
# equivalent check
assert fx.getOp() == solver.mkOp(kinds.ApplyUf)
def testAddAnyConstant():
solver = pycvc4.Solver()
boolean = solver.getBooleanSort()
nullTerm = pycvc4.Term(solver)
start = solver.mkVar(boolean)
nts = solver.mkVar(boolean)
g = solver.mkSygusGrammar({}, {start})
g.addAnyConstant(start)
g.addAnyConstant(start)
with pytest.raises(Exception):
g.addAnyConstant(nullTerm)
with pytest.raises(Exception):
g.addAnyConstant(nts)
solver.synthFun("f", {}, boolean, g)
with pytest.raises(Exception):
g.addAnyConstant(start)
