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;
}