Expr add(SetType t, Expr e) { if(setTypes.find(t) == setTypes.end() ) { // mark as processed setTypes.insert(t); Type elementType = t.getElementType(); ostringstream oss_type; oss_type << language::SetLanguage(language::output::LANG_SMTLIB_V2) << elementType; string elementTypeAsString = oss_type.str(); elementTypeAsString.erase( remove_if(elementTypeAsString.begin(), elementTypeAsString.end(), nonsense), elementTypeAsString.end()); // define-sort ostringstream oss_name; oss_name << language::SetLanguage(language::output::LANG_SMTLIB_V2) << "(Set " << elementType << ")"; string name = oss_name.str(); Type newt = em->mkArrayType(t.getElementType(), em->booleanType()); mapTypes[t] = newt; // diffent types vector<Type> t_t; t_t.push_back(t); t_t.push_back(t); vector<Type> elet_t; elet_t.push_back(elementType); elet_t.push_back(t); if(!enableAxioms) sout << "(define-fun emptyset" << elementTypeAsString << " " << " ()" << " " << name << " ( (as const " << name << ") false ) )" << endl; setoperators[ make_pair(t, kind::EMPTYSET) ] = em->mkVar( std::string("emptyset") + elementTypeAsString, t); if(!enableAxioms) sout << "(define-fun singleton" << elementTypeAsString << " " << " ( (x " << elementType << ") )" << " " << name << "" << " (store emptyset" << elementTypeAsString << " x true) )" << endl; setoperators[ make_pair(t, kind::SINGLETON) ] = em->mkVar( std::string("singleton") + elementTypeAsString, em->mkFunctionType( elementType, t ) ); if(!enableAxioms) sout << "(define-fun union" << elementTypeAsString << " " << " ( (s1 " << name << ") (s2 " << name << ") )" << " " << name << "" << " ((_ map or) s1 s2))" << endl; setoperators[ make_pair(t, kind::UNION) ] = em->mkVar( std::string("union") + elementTypeAsString, em->mkFunctionType( t_t, t ) ); if(!enableAxioms) sout << "(define-fun intersection" << elementTypeAsString << "" << " ( (s1 " << name << ") (s2 " << name << ") )" << " " << name << "" << " ((_ map and) s1 s2))" << endl; setoperators[ make_pair(t, kind::INTERSECTION) ] = em->mkVar( std::string("intersection") + elementTypeAsString, em->mkFunctionType( t_t, t ) ); if(!enableAxioms) sout << "(define-fun setminus" << elementTypeAsString << " " << " ( (s1 " << name << ") (s2 " << name << ") )" << " " << name << "" << " (intersection" << elementTypeAsString << " s1 ((_ map not) s2)))" << endl; setoperators[ make_pair(t, kind::SETMINUS) ] = em->mkVar( std::string("setminus") + elementTypeAsString, em->mkFunctionType( t_t, t ) ); if(!enableAxioms) sout << "(define-fun member" << elementTypeAsString << " " << " ( (x " << elementType << ")" << " (s " << name << "))" << " Bool" << " (select s x) )" << endl; setoperators[ make_pair(t, kind::MEMBER) ] = em->mkVar( std::string("member") + elementTypeAsString, em->mkPredicateType( elet_t ) ); if(!enableAxioms) sout << "(define-fun subset" << elementTypeAsString << " " << " ( (s1 " << name << ") (s2 " << name << ") )" << " Bool" <<" (= emptyset" << elementTypeAsString << " (setminus" << elementTypeAsString << " s1 s2)) )" << endl; setoperators[ make_pair(t, kind::SUBSET) ] = em->mkVar( std::string("subset") + elementTypeAsString, em->mkPredicateType( t_t ) ); if(enableAxioms) { int N = sizeof(setaxioms) / sizeof(setaxioms[0]); for(int i = 0; i < N; ++i) { string s = setaxioms[i]; ostringstream oss; oss << language::SetLanguage(language::output::LANG_SMTLIB_V2) << elementType; boost::replace_all(s, "HOLDA", elementTypeAsString); boost::replace_all(s, "HOLDB", oss.str()); if( s == "" ) continue; sout << s << endl; } } } Expr ret; if(e.getKind() == kind::EMPTYSET) { ret = setoperators[ make_pair(t, e.getKind()) ]; } else { vector<Expr> children = e.getChildren(); children.insert(children.begin(), setoperators[ make_pair(t, e.getKind()) ]); ret = em->mkExpr(kind::APPLY, children); } // cout << "returning " << ret << endl; return ret; }
int main() { ExprManager em; SmtEngine smt(&em); smt.setOption("produce-models", true); // Produce Models smt.setOption("output-language", "smtlib"); // output-language smt.setLogic("QF_AUFBV"); // Set the logic // Consider the following code (where size is some previously defined constant): // // // Assert (current_array[0] > 0); // for (unsigned i = 1; i < k; ++i) { // current_array[i] = 2 * current_array[i - 1]; // Assert (current_array[i-1] < current_array[i]); // } // // We want to check whether the assertion in the body of the for loop holds // throughout the loop. // Setting up the problem parameters unsigned k = 4; // number of unrollings (should be a power of 2) unsigned index_size = log2(k); // size of the index // Types Type elementType = em.mkBitVectorType(32); Type indexType = em.mkBitVectorType(index_size); Type arrayType = em.mkArrayType(indexType, elementType); // Variables Expr current_array = em.mkVar("current_array", arrayType); // Making a bit-vector constant Expr zero = em.mkConst(BitVector(index_size, 0u)); // Asserting that current_array[0] > 0 Expr current_array0 = em.mkExpr(kind::SELECT, current_array, zero); Expr current_array0_gt_0 = em.mkExpr(kind::BITVECTOR_SGT, current_array0, em.mkConst(BitVector(32, 0u))); smt.assertFormula(current_array0_gt_0); // Building the assertions in the loop unrolling Expr index = em.mkConst(BitVector(index_size, 0u)); Expr old_current = em.mkExpr(kind::SELECT, current_array, index); Expr two = em.mkConst(BitVector(32, 2u)); std::vector<Expr> assertions; for (unsigned i = 1; i < k; ++i) { index = em.mkConst(BitVector(index_size, Integer(i))); Expr new_current = em.mkExpr(kind::BITVECTOR_MULT, two, old_current); // current[i] = 2 * current[i-1] current_array = em.mkExpr(kind::STORE, current_array, index, new_current); // current[i-1] < current [i] Expr current_slt_new_current = em.mkExpr(kind::BITVECTOR_SLT, old_current, new_current); assertions.push_back(current_slt_new_current); old_current = em.mkExpr(kind::SELECT, current_array, index); } Expr query = em.mkExpr(kind::NOT, em.mkExpr(kind::AND, assertions)); cout << "Asserting " << query << " to CVC4 " << endl; smt.assertFormula(query); cout << "Expect sat. " << endl; cout << "CVC4: " << smt.checkSat(em.mkConst(true)) << endl; // Getting the model cout << "The satisfying model is: " << endl; cout << " current_array = " << smt.getValue(current_array) << endl; cout << " current_array[0] = " << smt.getValue(current_array0) << endl; return 0; }