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