def testAddAnyVariable():
solver = pycvc5.Solver()
boolean = solver.getBooleanSort()
nullTerm = pycvc5.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 test_add_rules():
solver = pycvc5.Solver()
boolean = solver.getBooleanSort()
integer = solver.getIntegerSort()
nullTerm = pycvc5.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.mkInteger(0)})
#Expecting no errors
solver.synthFun("f", {}, boolean, g)
#Expecting an error
with pytest.raises(Exception):
g.addRules(start, solver.mkBoolean(False))
def main():
slv = pycvc5.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_getitem():
solver = pycvc5.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 test_sort_scoped_tostring(solver):
name = "uninterp-sort"
bvsort8 = solver.mkBitVectorSort(8)
uninterp_sort = solver.mkUninterpretedSort(name)
assert str(bvsort8) == "(_ BitVec 8)"
assert str(uninterp_sort) == name
solver2 = pycvc5.Solver()
assert str(bvsort8) == "(_ BitVec 8)"
assert str(uninterp_sort) == name
def testGetString():
solver = pycvc5.Solver()
s1 = '"test\n"😃\\u{a}'
t1 = solver.mkString(s1)
assert s1 == t1.toPythonObj()
s2 = '❤️cvc5❤️'
t2 = solver.mkString(s2)
assert s2 == t2.toPythonObj()
def testGetReal():
solver = pycvc5.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 test_eq():
solver = pycvc5.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 testGetValueInt():
solver = pycvc5.Solver()
solver.setOption("produce-models", "true")
intsort = solver.getIntegerSort()
x = solver.mkConst(intsort, "x")
solver.assertFormula(solver.mkTerm(kinds.Equal, x, solver.mkInteger(6)))
r = solver.checkSat()
assert r.isSat()
xval = solver.getValue(x)
assert xval.toPythonObj() == 6
def testGetArray():
solver = pycvc5.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 test_get_sort():
solver = pycvc5.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 testGetValueReal():
solver = pycvc5.Solver()
solver.setOption("produce-models", "true")
realsort = solver.getRealSort()
x = solver.mkConst(realsort, "x")
y = solver.mkConst(realsort, "y")
solver.assertFormula(solver.mkTerm(kinds.Equal, x, solver.mkReal("6")))
solver.assertFormula(solver.mkTerm(kinds.Equal, y, solver.mkReal("8.33")))
r = solver.checkSat()
assert r.isSat()
xval = solver.getValue(x)
yval = solver.getValue(y)
assert xval.toPythonObj() == Fraction("6")
assert yval.toPythonObj() == Fraction("8.33")
def sat_initialize(self):
''' Use this design space as a baseline for future refinements. '''
DesignSpace.solver_depth = 0
if "pycvc5" in sys.modules:
DesignSpace.use_cvc = True
else:
DesignSpace.use_python_z3 = True
DesignSpace.solver_clauses = []
if DesignSpace.use_python_z3:
logger.debug("Using Python Z3 for SMT solving.")
DesignSpace.solver = z3.Solver()
DesignSpace.solver_vars = [
z3.Int(hole_index) for hole_index in self.hole_indices
]
for hole_index, hole in enumerate(self):
var = DesignSpace.solver_vars[hole_index]
clauses = [var == option for option in hole.options]
DesignSpace.solver_clauses.append(clauses)
elif DesignSpace.use_cvc:
logger.debug("Using CVC5 for SMT solving.")
DesignSpace.solver = pycvc5.Solver()
DesignSpace.solver.setOption("produce-models", "true")
DesignSpace.solver.setOption("produce-assertions", "true")
# DesignSpace.solver.setLogic("ALL")
# DesignSpace.solver.setLogic("QF_ALL")
DesignSpace.solver.setLogic("QF_DT")
# DesignSpace.solver.setLogic("QF_UFDT")
# DesignSpace.solver.setLogic("QF_UFLIA")
intSort = DesignSpace.solver.getIntegerSort()
DesignSpace.solver_vars = [
DesignSpace.solver.mkConst(intSort, str(hole_index))
for hole_index in self.hole_indices
]
for hole_index, hole in enumerate(self):
var = DesignSpace.solver_vars[hole_index]
clauses = [
DesignSpace.solver.mkTerm(
pycvc5.Kind.Equal, var,
DesignSpace.solver.mkInteger(option))
for option in hole.options
]
DesignSpace.solver_clauses.append(clauses)
else:
raise RuntimeError("Need to enable at least one SMT solver.")
def test_const_sequence_elements():
solver = pycvc5.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 test_get_kind():
solver = pycvc5.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 testAddAnyConstant():
solver = pycvc5.Solver()
boolean = solver.getBooleanSort()
nullTerm = pycvc5.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)
def test_get_op():
solver = pycvc5.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 test_datatype_simply_rec():
solver = pycvc5.Solver()
# Create mutual datatypes corresponding to this definition block:
#
# DATATYPE
# wlist = leaf(data: list),
# list = cons(car: wlist, cdr: list) | nil,
# ns = elem(ndata: set(wlist)) | elemArray(ndata2: array(list, list))
# END;
# Make unresolved types as placeholders
unres_wlist = solver.mkUninterpretedSort('wlist')
unres_list = solver.mkUninterpretedSort('list')
unres_ns = solver.mkUninterpretedSort('ns')
unres_types = set([unres_wlist, unres_list, unres_ns])
wlist = solver.mkDatatypeDecl('wlist')
leaf = solver.mkDatatypeConstructorDecl('leaf')
leaf.addSelector('data', unres_list)
wlist.addConstructor(leaf)
dlist = solver.mkDatatypeDecl('list')
cons = solver.mkDatatypeConstructorDecl('cons')
cons.addSelector('car', unres_wlist)
cons.addSelector('cdr', unres_list)
dlist.addConstructor(cons)
nil = solver.mkDatatypeConstructorDecl("nil")
dlist.addConstructor(nil)
ns = solver.mkDatatypeDecl('ns')
elem = solver.mkDatatypeConstructorDecl('elem')
elem.addSelector('ndata', solver.mkSetSort(unres_wlist))
ns.addConstructor(elem)
elem_array = solver.mkDatatypeConstructorDecl('elemArray')
elem_array.addSelector('ndata', solver.mkArraySort(unres_list, unres_list))
ns.addConstructor(elem_array)
# this is well-founded and has no nested recursion
dtdecls = [wlist, dlist, ns]
dtsorts = solver.mkDatatypeSorts(dtdecls, unres_types)
assert len(dtsorts) == 3
assert dtsorts[0].getDatatype().isWellFounded()
assert dtsorts[1].getDatatype().isWellFounded()
assert dtsorts[2].getDatatype().isWellFounded()
assert not dtsorts[0].getDatatype().hasNestedRecursion()
assert not dtsorts[1].getDatatype().hasNestedRecursion()
assert not dtsorts[2].getDatatype().hasNestedRecursion()
# Create mutual datatypes corresponding to this definition block:
# DATATYPE
# ns2 = elem2(ndata: array(int,ns2)) | nil2
# END;
unres_ns2 = solver.mkUninterpretedSort('ns2')
unres_types = set([unres_ns2])
ns2 = solver.mkDatatypeDecl('ns2')
elem2 = solver.mkDatatypeConstructorDecl('elem2')
elem2.addSelector('ndata',
solver.mkArraySort(solver.getIntegerSort(), unres_ns2))
ns2.addConstructor(elem2)
nil2 = solver.mkDatatypeConstructorDecl('nil2')
ns2.addConstructor(nil2)
# this is not well-founded due to non-simple recursion
dtdecls = [ns2]
dtsorts = solver.mkDatatypeSorts(dtdecls, unres_types)
assert len(dtsorts) == 1
assert dtsorts[0].getDatatype()[0][0].getRangeSort().isArray()
elem_sort = dtsorts[0].getDatatype()[0][0].getRangeSort(
).getArrayElementSort()
assert elem_sort == dtsorts[0]
assert dtsorts[0].getDatatype().isWellFounded()
assert dtsorts[0].getDatatype().hasNestedRecursion()
# Create mutual datatypes corresponding to this definition block:
# DATATYPE
# list3 = cons3(car: ns3, cdr: list3) | nil3,
# ns3 = elem3(ndata: set(list3))
# END
unres_ns3 = solver.mkUninterpretedSort('ns3')
unres_list3 = solver.mkUninterpretedSort('list3')
unres_types = set([unres_ns3, unres_list3])
list3 = solver.mkDatatypeDecl('list3')
cons3 = solver.mkDatatypeConstructorDecl('cons3')
cons3.addSelector('car', unres_ns3)
cons3.addSelector('cdr', unres_list3)
list3.addConstructor(cons3)
nil3 = solver.mkDatatypeConstructorDecl('nil3')
list3.addConstructor(nil3)
ns3 = solver.mkDatatypeDecl('ns3')
elem3 = solver.mkDatatypeConstructorDecl('elem3')
elem3.addSelector('ndata', solver.mkSetSort(unres_list3))
ns3.addConstructor(elem3)
# both are well-founded and have nested recursion
dtdecls = [list3, ns3]
dtsorts = solver.mkDatatypeSorts(dtdecls, unres_types)
assert len(dtsorts) == 2
assert dtsorts[0].getDatatype().isWellFounded()
assert dtsorts[1].getDatatype().isWellFounded()
assert dtsorts[0].getDatatype().hasNestedRecursion()
assert dtsorts[1].getDatatype().hasNestedRecursion()
# Create mutual datatypes corresponding to this definition block:
# DATATYPE
# list4 = cons(car: set(ns4), cdr: list4) | nil,
# ns4 = elem(ndata: list4)
# END
unres_ns4 = solver.mkUninterpretedSort('ns4')
unres_list4 = solver.mkUninterpretedSort('list4')
unres_types = set([unres_ns4, unres_list4])
list4 = solver.mkDatatypeDecl('list4')
cons4 = solver.mkDatatypeConstructorDecl('cons4')
cons4.addSelector('car', solver.mkSetSort(unres_ns4))
cons4.addSelector('cdr', unres_list4)
list4.addConstructor(cons4)
nil4 = solver.mkDatatypeConstructorDecl('nil4')
list4.addConstructor(nil4)
ns4 = solver.mkDatatypeDecl('ns4')
elem4 = solver.mkDatatypeConstructorDecl('elem3')
elem4.addSelector('ndata', unres_list4)
ns4.addConstructor(elem4)
# both are well-founded and have nested recursion
dtdecls = [list4, ns4]
dtsorts = solver.mkDatatypeSorts(dtdecls, unres_types)
assert len(dtsorts) == 2
assert dtsorts[0].getDatatype().isWellFounded()
assert dtsorts[1].getDatatype().isWellFounded()
assert dtsorts[0].getDatatype().hasNestedRecursion()
assert dtsorts[1].getDatatype().hasNestedRecursion()
# Create mutual datatypes corresponding to this definition block:
# DATATYPE
# list5[X] = cons(car: X, cdr: list5[list5[X]]) | nil
# END
unres_list5 = solver.mkSortConstructorSort('list5', 1)
unres_types = set([unres_list5])
x = solver.mkParamSort('X')
v = [x]
list5 = solver.mkDatatypeDecl('list5', v)
args = [x]
ur_list_x = unres_list5.instantiate(args)
args = [ur_list_x]
ur_list_list_x = unres_list5.instantiate(args)
cons5 = solver.mkDatatypeConstructorDecl('cons5')
cons5.addSelector('car', x)
cons5.addSelector('cdr', ur_list_list_x)
list5.addConstructor(cons5)
nil5 = solver.mkDatatypeConstructorDecl('nil5')
list5.addConstructor(nil5)
# well-founded and has nested recursion
dtdecls = [list5]
dtsorts = solver.mkDatatypeSorts(dtdecls, unres_types)
assert len(dtsorts) == 1
assert dtsorts[0].getDatatype().isWellFounded()
assert dtsorts[0].getDatatype().hasNestedRecursion()
def solve(mask):
slv = pycvc5.Solver()
slv.setLogic("QF_ALL")
slv.setOption("produce-models", "true")
slv.setOption("output-language", "smt2")
bitvector64 = slv.mkBitVectorSort(64)
bitvector_ext = slv.mkOp(pycvc5.kinds.BVExtract, 63,
63 - popcount(mask) + 1)
bitvector_short = slv.mkBitVectorSort(popcount(mask))
set_ = slv.mkSetSort(slv.mkBitVectorSort(popcount(mask)))
shift32 = slv.mkBitVector(64, 32)
# masked_bb = [slv.mkBitVector(64, pdep(i, mask)) for i in range(2 ** popcount(mask))]
masked_bb_u = [
slv.mkTerm(pycvc5.kinds.BVShl,
slv.mkBitVector(64,
pdep(i, mask) // (2**32)), shift32)
for i in range(2**popcount(mask))
]
masked_bb_l = [
slv.mkBitVector(64,
pdep(i, mask) % (2**32))
for i in range(2**popcount(mask))
]
masked_bb = [
slv.mkTerm(pycvc5.kinds.BVAdd, masked_bb_u[i], masked_bb_l[i])
for i in range(2**popcount(mask))
]
magic_number = slv.mkConst(bitvector64, "magic_number")
imul_tmp = [
slv.mkTerm(pycvc5.kinds.BVMult, masked_bb[i], magic_number)
for i in range(2**popcount(mask))
]
result_index_short = [
slv.mkTerm(pycvc5.kinds.Singleton,
slv.mkTerm(bitvector_ext, imul_tmp[i]))
for i in range(2**popcount(mask))
]
target = [
slv.mkTerm(pycvc5.kinds.Singleton, slv.mkBitVector(popcount(mask), i))
for i in range(2**popcount(mask))
]
union1 = [slv.mkEmptySet(set_)]
union2 = [slv.mkEmptySet(set_)]
for i in range(2**popcount(mask)):
union1.append(
slv.mkTerm(pycvc5.kinds.Union, union1[i - 1],
result_index_short[i]))
union2.append(slv.mkTerm(pycvc5.kinds.Union, union2[i - 1], target[i]))
magic = slv.mkTerm(pycvc5.kinds.Equal, union1[-1], union2[-1])
print("solve start")
# print(f"{str(magic)}")
result = slv.checkSatAssuming(magic)
print(f"cvc5 reports: magic is {result}")
if result:
print(f"For instance, {slv.getValue(magic_number)} is a magic_number.")
def testGetSymbol():
solver = pycvc5.Solver()
solver.mkConst(solver.getBooleanSort(), "x")
def testGetBV():
solver = pycvc5.Solver()
three = solver.mkBitVector(8, 3)
assert three.toPythonObj() == 3
def test_term_scoped_to_string(solver):
intsort = solver.getIntegerSort()
x = solver.mkConst(intsort, "x")
assert str(x) == "x"
solver2 = pycvc5.Solver()
assert str(x) == "x"
#
# Copyright (c) 2009-2021 by the authors listed in the file AUTHORS
# in the top-level source directory and their institutional affiliations.
# All rights reserved. See the file COPYING in the top-level source
# directory for licensing information.
# #############################################################################
#
# A simple demonstration of the api capabilities of cvc5, adapted from quickstart.cpp
##
import pycvc5
from pycvc5 import kinds
if __name__ == "__main__":
# Create a solver
solver = pycvc5.Solver()
# We will ask the solver to produce models and unsat cores,
# hence these options should be turned on.
solver.setOption("produce-models", "true")
solver.setOption("produce-unsat-cores", "true")
# The simplest way to set a logic for the solver is to choose "ALL".
# This enables all logics in the solver.
# Alternatively, "QF_ALL" enables all logics without quantifiers.
# To optimize the solver's behavior for a more specific logic,
# use the logic name, e.g. "QF_BV" or "QF_AUFBV".
# Set the logic
solver.setLogic("ALL")
def solver():
return pycvc5.Solver()
def testGetBool():
solver = pycvc5.Solver()
t = solver.mkTrue()
f = solver.mkFalse()
assert t.toPythonObj() is True
assert f.toPythonObj() is False
# in the top-level source directory and their institutional affiliations.
# All rights reserved. See the file COPYING in the top-level source
# directory for licensing information.
# #############################################################################
#
# A simple demonstration of the solving capabilities of the cvc5
# sygus solver through the Python API. This is a direct
# translation of sygus-inv.cpp .
##
import utils
import pycvc5
from pycvc5 import kinds
if __name__ == "__main__":
slv = pycvc5.Solver()
# required options
slv.setOption("lang", "sygus2")
slv.setOption("incremental", "false")
# set the logic
slv.setLogic("LIA")
integer = slv.getIntegerSort()
boolean = slv.getBooleanSort()
zero = slv.mkInteger(0)
one = slv.mkInteger(1)
ten = slv.mkInteger(10)
def testGetInt():
solver = pycvc5.Solver()
two = solver.mkInteger(2)
assert two.toPythonObj() == 2
