//! ==> NOT EXISTS (vars): e IFF FORALL (vars) NOT e
Theorem QuantTheoremProducer::rewriteNotExists(const Expr& e) {
if(CHECK_PROOFS) {
CHECK_SOUND(e.isNot() && e[0].isExists(),
"rewriteNotExists: expr must be NOT FORALL:\n"
+e.toString());
}
Proof pf;
if(withProof())
pf = newPf("rewrite_not_exists", e);
return newRWTheorem(e, e.getEM()->newClosureExpr(FORALL, e[0].getVars(),
!e[0].getBody()),
Assumptions::emptyAssump(), pf);
}
//! convert (forall (x) ... forall (y)) into (forall (x y)...)
//! convert (exists (x) ... exists (y)) into (exists (x y)...)
Theorem QuantTheoremProducer::pullVarOut(const Theorem& t1){
const Expr thm_expr=t1.getExpr();
if(CHECK_PROOFS) {
CHECK_SOUND(thm_expr.isForall() || thm_expr.isExists(),
"pullVarOut: "
+thm_expr.toString());
}
const Expr outBody = thm_expr.getBody();
// if(((outBody.isAnd() && outBody[1].isForall()) ||
// (outBody.isImpl() && outBody[1].isForall()) ||
// (outBody.isNot() && outBody[0].isAnd() && outBody[0][1].isExists()) )){
// return t1;
// }
if (thm_expr.isForall()){
if((outBody.isNot() && outBody[0].isAnd() && outBody[0][1].isExists())){
vector<Expr> bVarsOut = thm_expr.getVars();
const Expr innerExists =outBody[0][1];
const Expr innerBody = innerExists.getBody();
vector<Expr> bVarsIn = innerExists.getVars();
for(vector<Expr>::iterator i=bVarsIn.begin(), iend=bVarsIn.end(); i!=iend; i++){
bVarsOut.push_back(*i);
}
Proof pf;
if(withProof()) {
vector<Expr> es;
vector<Proof> pfs;
es.push_back(thm_expr);
es.insert(es.end(), bVarsIn.begin(), bVarsIn.end());
pfs.push_back(t1.getProof());
pf= newPf("pullVarOut", es, pfs);
}
Expr newbody;
newbody=(outBody[0][0].notExpr()).orExpr(innerBody.notExpr());
Expr newQuantExpr;
newQuantExpr = d_theoryQuant->getEM()->newClosureExpr(FORALL, bVarsOut, newbody);
return(newTheorem(newQuantExpr, t1.getAssumptionsRef(), pf));
}
else if ((outBody.isAnd() && outBody[1].isForall()) ||
(outBody.isImpl() && outBody[1].isForall())){
vector<Expr> bVarsOut = thm_expr.getVars();
const Expr innerForall=outBody[1];
const Expr innerBody = innerForall.getBody();
vector<Expr> bVarsIn = innerForall.getVars();
for(vector<Expr>::iterator i=bVarsIn.begin(), iend=bVarsIn.end(); i!=iend; i++){
bVarsOut.push_back(*i);
}
Proof pf;
if(withProof()) {
vector<Expr> es;
vector<Proof> pfs;
es.push_back(thm_expr);
es.insert(es.end(), bVarsIn.begin(), bVarsIn.end());
pfs.push_back(t1.getProof());
pf= newPf("pullVarOut", es, pfs);
}
Expr newbody;
if(outBody.isAnd()){
newbody=outBody[0].andExpr(innerBody);
}
else if(outBody.isImpl()){
newbody=outBody[0].impExpr(innerBody);
}
Expr newQuantExpr;
newQuantExpr = d_theoryQuant->getEM()->newClosureExpr(FORALL, bVarsOut, newbody);
return(newTheorem(newQuantExpr, t1.getAssumptionsRef(), pf));
}
return t1; // case cannot be handled now.
}
else if (thm_expr.isExists()){
if ((outBody.isAnd() && outBody[1].isExists()) ||
(outBody.isImpl() && outBody[1].isExists())){
vector<Expr> bVarsOut = thm_expr.getVars();
const Expr innerExists = outBody[1];
const Expr innerBody = innerExists.getBody();
vector<Expr> bVarsIn = innerExists.getVars();
for(vector<Expr>::iterator i=bVarsIn.begin(), iend=bVarsIn.end(); i!=iend; i++){
bVarsOut.push_back(*i);
}
Proof pf;
if(withProof()) {
vector<Expr> es;
vector<Proof> pfs;
es.push_back(thm_expr);
es.insert(es.end(), bVarsIn.begin(), bVarsIn.end());
pfs.push_back(t1.getProof());
pf= newPf("pullVarOut", es, pfs);
}
Expr newbody;
if(outBody.isAnd()){
newbody=outBody[0].andExpr(innerBody);
}
else if(outBody.isImpl()){
newbody=outBody[0].impExpr(innerBody);
}
Expr newQuantExpr;
newQuantExpr = d_theoryQuant->getEM()->newClosureExpr(EXISTS, bVarsOut, newbody);
return(newTheorem(newQuantExpr, t1.getAssumptionsRef(), pf));
}
}
return t1;
}
Lit CNF_Manager::translateExprRec(const Expr& e, CNF_Formula& cnf, const Theorem& thmIn)
{
if (e.isFalse()) return Lit::getFalse();
if (e.isTrue()) return Lit::getTrue();
if (e.isNot()) return !translateExprRec(e[0], cnf, thmIn);
ExprHashMap<Var>::iterator iMap = d_cnfVars.find(e);
if (e.isTranslated()) {
DebugAssert(iMap != d_cnfVars.end(), "Translated expr should be in map");
return Lit((*iMap).second);
}
else e.setTranslated(d_bottomScope);
Var v(int(d_varInfo.size()));
bool translateOnly = false;
if (iMap != d_cnfVars.end()) {
v = (*iMap).second;
translateOnly = true;
d_varInfo[v].fanouts.clear();
}
else {
d_varInfo.resize(v+1);
d_varInfo.back().expr = e;
d_cnfVars[e] = v;
}
Expr::iterator i, iend;
bool isAnd = false;
switch (e.getKind()) {
case AND:
isAnd = true;
case OR: {
vector<Lit> lits;
unsigned idx;
for (i = e.begin(), iend = e.end(); i != iend; ++i) {
lits.push_back(translateExprRec(*i, cnf, thmIn));
}
// DebugAssert(concreteExpr(e,Lit(v)) == e,"why here");
for (idx = 0; idx < lits.size(); ++idx) {
cnf.newClause();
cnf.addLiteral(Lit(v),isAnd);
cnf.addLiteral(lits[idx], !isAnd);
// DebugAssert(concreteExpr(e[idx],lits[idx]) == e[idx], "why here");
std::string reasonStr = (isAnd ? "and_mid" : "or_mid");
Expr after = e[idx] ;
cnf.getCurrentClause().setClauseTheorem(d_rules->CNFtranslate(e, after, reasonStr, idx)); // by yeting
}
cnf.newClause();
cnf.addLiteral(Lit(v),!isAnd);
for (idx = 0; idx < lits.size(); ++idx) {
cnf.addLiteral(lits[idx], isAnd);
}
std::string reasonStr = (isAnd ? "and_final" : "or_final") ;
Expr after = e ;
cnf.getCurrentClause().setClauseTheorem(d_rules->CNFtranslate(e, after, reasonStr, 0)); // by yeting
break;
}
case IMPLIES: {
Lit arg0 = translateExprRec(e[0], cnf, thmIn);
Lit arg1 = translateExprRec(e[1], cnf, thmIn);
// DebugAssert(concreteExpr(e, Lit(v)) == e, "why here");
// DebugAssert(concreteExpr(e[0], arg0) == e[0], "why here");
// DebugAssert(concreteExpr(e[1], arg1) == e[1], "why here");
cnf.newClause();
cnf.addLiteral(Lit(v));
cnf.addLiteral(arg0);
cnf.getCurrentClause().setClauseTheorem( d_rules->CNFtranslate(e, e, "imp", 0)); // by yeting
cnf.newClause();
cnf.addLiteral(Lit(v));
cnf.addLiteral(arg1,true);
cnf.getCurrentClause().setClauseTheorem( d_rules->CNFtranslate(e, e, "imp", 1)); // by yeting
cnf.newClause();
cnf.addLiteral(Lit(v),true);
cnf.addLiteral(arg0,true);
cnf.addLiteral(arg1);
cnf.getCurrentClause().setClauseTheorem( d_rules->CNFtranslate(e, e, "imp", 2)); // by yeting
break;
}
case IFF: {
Lit arg0 = translateExprRec(e[0], cnf, thmIn);
Lit arg1 = translateExprRec(e[1], cnf, thmIn);
// DebugAssert(concreteExpr(e, Lit(v)) == e, "why here");
// DebugAssert(concreteExpr(e[0], arg0) == e[0], "why here");
// DebugAssert(concreteExpr(e[1], arg1) == e[1], "why here");
cnf.newClause();
cnf.addLiteral(Lit(v));
cnf.addLiteral(arg0);
cnf.addLiteral(arg1);
cnf.getCurrentClause().setClauseTheorem(d_rules->CNFtranslate(e, e, "iff", 0)); // by yeting
cnf.newClause();
cnf.addLiteral(Lit(v));
cnf.addLiteral(arg0,true);
cnf.addLiteral(arg1,true);
cnf.getCurrentClause().setClauseTheorem(d_rules->CNFtranslate(e, e, "iff", 1)); // by yeting
cnf.newClause();
cnf.addLiteral(Lit(v),true);
cnf.addLiteral(arg0,true);
cnf.addLiteral(arg1);
cnf.getCurrentClause().setClauseTheorem(d_rules->CNFtranslate(e, e, "iff", 2)); // by yeting
cnf.newClause();
cnf.addLiteral(Lit(v),true);
cnf.addLiteral(arg0);
cnf.addLiteral(arg1,true);
cnf.getCurrentClause().setClauseTheorem(d_rules->CNFtranslate(e, e, "iff", 3)); // by yeting
break;
}
case XOR: {
Lit arg0 = translateExprRec(e[0], cnf, thmIn);
Lit arg1 = translateExprRec(e[1], cnf, thmIn);
// DebugAssert(concreteExpr(e, Lit(v)) == e, "why here");
// DebugAssert(concreteExpr(e[0], arg0) == e[0], "why here");
// DebugAssert(concreteExpr(e[1], arg1) == e[1], "why here");
cnf.newClause();
cnf.addLiteral(Lit(v),true);
cnf.addLiteral(arg0);
cnf.addLiteral(arg1);
cnf.getCurrentClause().setClauseTheorem(d_rules->CNFtranslate(e, e, "xor", 0)); // by yeting
cnf.newClause();
cnf.addLiteral(Lit(v),true);
cnf.addLiteral(arg0,true);
cnf.addLiteral(arg1,true);
cnf.getCurrentClause().setClauseTheorem(d_rules->CNFtranslate(e, e, "xor", 1)); // by yeting
cnf.newClause();
cnf.addLiteral(Lit(v));
cnf.addLiteral(arg0,true);
cnf.addLiteral(arg1);
cnf.getCurrentClause().setClauseTheorem(d_rules->CNFtranslate(e, e, "xor", 2)); // by yeting
cnf.newClause();
cnf.addLiteral(Lit(v));
cnf.addLiteral(arg0);
cnf.addLiteral(arg1,true);
cnf.getCurrentClause().setClauseTheorem(d_rules->CNFtranslate(e, e, "xor", 3)); // by yeting
break;
}
case ITE:
{
Lit arg0 = translateExprRec(e[0], cnf, thmIn);
Lit arg1 = translateExprRec(e[1], cnf, thmIn);
Lit arg2 = translateExprRec(e[2], cnf, thmIn);
Expr aftere0 = concreteExpr(e[0], arg0);
Expr aftere1 = concreteExpr(e[1], arg1);
Expr aftere2 = concreteExpr(e[2], arg2);
vector<Expr> after ;
after.push_back(aftere0);
after.push_back(aftere1);
after.push_back(aftere2);
Theorem e0thm;
Theorem e1thm;
Theorem e2thm;
{ e0thm = d_iteMap[e[0]];
if (e0thm.isNull()) e0thm = d_commonRules->reflexivityRule(e[0]);
e1thm = d_iteMap[e[1]];
if (e1thm.isNull()) e1thm = d_commonRules->reflexivityRule(e[1]);
e2thm = d_iteMap[e[2]];
if (e2thm.isNull()) e2thm = d_commonRules->reflexivityRule(e[2]);
}
vector<Theorem> thms ;
thms.push_back(e0thm);
thms.push_back(e1thm);
thms.push_back(e2thm);
cnf.newClause();
cnf.addLiteral(Lit(v),true);
cnf.addLiteral(arg0);
cnf.addLiteral(arg2);
cnf.getCurrentClause().setClauseTheorem(d_rules->CNFITEtranslate(e, after,thms, 1)); // by yeting
cnf.newClause();
cnf.addLiteral(Lit(v));
cnf.addLiteral(arg0);
cnf.addLiteral(arg2,true);
cnf.getCurrentClause().setClauseTheorem(d_rules->CNFITEtranslate(e, after,thms, 2)); // by yeting
cnf.newClause();
cnf.addLiteral(Lit(v));
cnf.addLiteral(arg0,true);
cnf.addLiteral(arg1,true);
cnf.getCurrentClause().setClauseTheorem(d_rules->CNFITEtranslate(e, after,thms, 3)); // by yeting
cnf.newClause();
cnf.addLiteral(Lit(v),true);
cnf.addLiteral(arg0,true);
cnf.addLiteral(arg1);
cnf.getCurrentClause().setClauseTheorem(d_rules->CNFITEtranslate(e, after,thms, 4)); // by yeting
cnf.newClause();
cnf.addLiteral(Lit(v));
cnf.addLiteral(arg1,true);
cnf.addLiteral(arg2,true);
cnf.getCurrentClause().setClauseTheorem(d_rules->CNFITEtranslate(e, after,thms, 5)); // by yeting
cnf.newClause();
cnf.addLiteral(Lit(v),true);
cnf.addLiteral(arg1);
cnf.addLiteral(arg2);
cnf.getCurrentClause().setClauseTheorem(d_rules->CNFITEtranslate(e, after,thms, 6)); // by yeting
break;
}
default:
{
DebugAssert(!e.isAbsAtomicFormula() || d_varInfo[v].expr == e,
"Corrupted Varinfo");
if (e.isAbsAtomicFormula()) {
registerAtom(e, thmIn);
return Lit(v);
}
Theorem thm = replaceITErec(e, v, translateOnly);
const Expr& e2 = thm.getRHS();
DebugAssert(e2.isAbsAtomicFormula(), "Expected AbsAtomicFormula");
if (e2.isTranslated()) {
// Ugly corner case: we happen to create an expression that has been
// created before. We remove the current variable and fix up the
// translation stack.
if (translateOnly) {
DebugAssert(v == d_cnfVars[e2], "Expected literal match");
}
else {
d_varInfo.resize(v);
while (!d_translateQueueVars.empty() &&
d_translateQueueVars.back() == v) {
d_translateQueueVars.pop_back();
}
DebugAssert(d_cnfVars.find(e2) != d_cnfVars.end(),
"Expected existing literal");
v = d_cnfVars[e2];
d_cnfVars[e] = v;
while (d_translateQueueVars.size() < d_translateQueueThms.size()) {
d_translateQueueVars.push_back(v);
}
}
}
else {
e2.setTranslated(d_bottomScope);
// Corner case: don't register reflexive equality
if (!e2.isEq() || e2[0] != e2[1]) registerAtom(e2, thmIn);
if (!translateOnly) {
if (d_cnfVars.find(e2) == d_cnfVars.end()) {
d_varInfo[v].expr = e2;
d_cnfVars[e2] = v;
}
else {
// Same corner case in an untranslated expr
d_varInfo.resize(v);
while (!d_translateQueueVars.empty() &&
d_translateQueueVars.back() == v) {
d_translateQueueVars.pop_back();
}
v = d_cnfVars[e2];
d_cnfVars[e] = v;
while (d_translateQueueVars.size() < d_translateQueueThms.size()) {
d_translateQueueVars.push_back(v);
}
}
}
}
return Lit(v);
}
}
// Record fanins / fanouts
Lit l;
for (i = e.begin(), iend = e.end(); i != iend; ++i) {
l = getCNFLit(*i);
DebugAssert(!l.isNull(), "Expected non-null literal");
if (!translateOnly) d_varInfo[v].fanins.push_back(l);
if (l.isVar()) d_varInfo[l.getVar()].fanouts.push_back(v);
}
return Lit(v);
}
