Theorem QuantTheoremProducer::universalInst(const Theorem& t1, const vector<Expr>& terms){ Expr e = t1.getExpr(); const vector<Expr>& boundVars = e.getVars(); if(CHECK_PROOFS) { CHECK_SOUND(boundVars.size() == terms.size(), "Universal instantiation: size of terms array does " "not match quanitfied variables array size"); CHECK_SOUND(e.isForall(), "universal instantiation: expr must be FORALL:\n" +e.toString()); for(unsigned int i=0; i<terms.size(); i++) CHECK_SOUND(d_theoryQuant->getBaseType(boundVars[i]) == d_theoryQuant->getBaseType(terms[i]), "Universal instantiation: type mismatch"); } //build up a conjunction of type predicates for expression Expr tr = e.getEM()->trueExpr(); Expr typePred = tr; unsigned qlevel=0, qlevelMax = 0; for(unsigned int i=0; i<terms.size(); i++) { Expr p = d_theoryQuant->getTypePred(boundVars[i].getType(),terms[i]); if(p!=tr) { if(typePred==tr) typePred = p; else typePred = typePred.andExpr(p); } qlevel = d_theoryQuant->theoryCore()->getQuantLevelForTerm(terms[i]); if (qlevel > qlevelMax) qlevel = qlevelMax; } Expr inst = e.getBody().substExpr(e.getVars(), terms); // Expr inst = e.getBody().substExprQuant(e.getVars(), terms); // Expr inst = e.getBody().substExpr(e.getVars(), terms); Proof pf; if(withProof()) { vector<Proof> pfs; vector<Expr> es; pfs.push_back(t1.getProof()); es.push_back(e); es.push_back(Expr(RAW_LIST,terms)); // es.insert(es.end(), terms.begin(), terms.end()); es.push_back(inst); pf= newPf("universal_elimination3", es, pfs); } // Expr inst = e.getBody().substExpr(e.getVars(), terms); Expr imp; if( typePred == tr ) //just for easy life, yeting, change this asap imp = inst; else imp = typePred.impExpr(inst); Theorem ret = newTheorem(imp, t1.getAssumptionsRef(), pf); unsigned thmLevel = t1.getQuantLevel(); if(qlevel >= thmLevel) { ret.setQuantLevel(qlevel+1); } else{ // ret.setQuantLevel(thmLevel+1); ret.setQuantLevel(thmLevel+1); } // ret.setQuantLevel(qlevel+1); return ret; }
Theorem QuantTheoremProducer::partialUniversalInst(const Theorem& t1, const vector<Expr>& terms, int quantLevel){ cout<<"error in partial inst" << endl; Expr e = t1.getExpr(); const vector<Expr>& boundVars = e.getVars(); if(CHECK_PROOFS) { CHECK_SOUND(boundVars.size() >= terms.size(), "Universal instantiation: size of terms array does " "not match quanitfied variables array size"); CHECK_SOUND(e.isForall(), "universal instantiation: expr must be FORALL:\n" +e.toString()); for(unsigned int i=0; i<terms.size(); i++){ CHECK_SOUND(d_theoryQuant->getBaseType(boundVars[i]) == d_theoryQuant->getBaseType(terms[i]), "partial Universal instantiation: type mismatch"); } } //build up a conjunction of type predicates for expression Expr tr = e.getEM()->trueExpr(); Expr typePred = tr; for(unsigned int i=0; i<terms.size(); i++) { Expr p = d_theoryQuant->getTypePred(boundVars[i].getType(),terms[i]); if(p!=tr) { if(typePred==tr) typePred = p; else typePred = typePred.andExpr(p); } } Proof pf; if(withProof()) { vector<Proof> pfs; vector<Expr> es; pfs.push_back(t1.getProof()); es.push_back(e); es.insert(es.end(), terms.begin(), terms.end()); pf= newPf("partial_universal_instantiation", es, pfs); } if(terms.size() == boundVars.size()){ Expr inst = e.getBody().substExpr(e.getVars(), terms); Expr imp; if(typePred == tr) imp = inst; else imp = typePred.impExpr(inst); return(newTheorem(imp, t1.getAssumptionsRef(), pf)); } else{ vector<Expr> newBoundVars; for(size_t i=0; i<terms.size(); i++) { newBoundVars.push_back(boundVars[i]); } vector<Expr>leftBoundVars; for(size_t i=terms.size(); i<boundVars.size(); i++) { leftBoundVars.push_back(boundVars[i]); } Expr tempinst = e.getBody().substExpr(newBoundVars, terms); Expr inst = d_theoryQuant->getEM()->newClosureExpr(FORALL, leftBoundVars, tempinst); Expr imp; if(typePred == tr) imp = inst; else imp = typePred.impExpr(inst); Theorem res = (newTheorem(imp, t1.getAssumptionsRef(), pf)); int thmLevel = t1.getQuantLevel(); if(quantLevel >= thmLevel) { res.setQuantLevel(quantLevel+1); } else{ //k ret.setQuantLevel(thmLevel+1); res.setQuantLevel(thmLevel); } return res; } }
int main(int argc, char* argv[]) { try { // Check the arguments if (argc != 3) { cerr << "usage: sha1smt message output-file" << std::endl; return 1; } // Get the message to encode and the output file string msg = argv[1]; unsigned msgSize = msg.size(); ofstream output(argv[2]); output << expr::ExprSetDepth(-1) << expr::ExprSetLanguage(language::output::LANG_SMTLIB_V2); output << SetBenchmarkLogicCommand("QF_BV") << endl; output << SetBenchmarkStatusCommand(SMT_SATISFIABLE) << endl; // Make the variables the size of the string hashsmt::cvc4_uchar8 *cvc4input = new hashsmt::cvc4_uchar8[msgSize]; for (unsigned i = 0; i < msgSize; ++ i) { stringstream ss; ss << "x" << i; cvc4input[i] = hashsmt::cvc4_uchar8(ss.str()); output << DeclareFunctionCommand(ss.str(), cvc4input[i].getExpr(), cvc4input[i].getExpr().getType()) << endl; // Ouput the solution also Expr solution = (cvc4input[i] == hashsmt::cvc4_uchar8(msg.c_str()[i])); output << "; " << AssertCommand(solution) << endl; } // Do the cvc4 encoding hashsmt::sha1 cvc4encoder; cvc4encoder.process_bytes(cvc4input, msgSize); // Get the digest as bitvectors hashsmt::cvc4_uint32 cvc4digest[5]; cvc4encoder.get_digest(cvc4digest); // Do the actual sha1 encoding boost::uuids::detail::sha1 sha1encoder; sha1encoder.process_bytes(msg.c_str(), msgSize); unsigned sha1digest[5]; sha1encoder.get_digest(sha1digest); // Create the assertion Expr assertion; for (unsigned i = 0; i < 5; ++ i) { Expr conjunct = (cvc4digest[i] == hashsmt::cvc4_uint32(sha1digest[i])); if (i > 0) { assertion = assertion.andExpr(conjunct); } else { assertion = conjunct; } } output << AssertCommand(assertion) << endl; // Checksat command output << CheckSatCommand() << endl; delete cvc4input; } catch (CVC4::Exception& e) { cerr << e << endl; } }