Node CVC4::theory::bv::mergeExplanations(const std::vector<Node>& expls) { TNodeSet literals; for (unsigned i = 0; i < expls.size(); ++i) { TNode expl = expls[i]; Assert (expl.getType().isBoolean()); if (expl.getKind() == kind::AND) { for (unsigned i = 0; i < expl.getNumChildren(); ++i) { TNode child = expl[i]; if (child == utils::mkTrue()) continue; literals.insert(child); } } else if (expl != utils::mkTrue()) { literals.insert(expl); } } if (literals.size() == 0) return utils::mkTrue(); if (literals.size() == 1) return *literals.begin(); NodeBuilder<> nb(kind::AND); for (TNodeSet::const_iterator it = literals.begin(); it!= literals.end(); ++it) { nb << *it; } return nb; }
void AbstractionModule::collectArguments(TNode node, TNode signature, std::vector<Node>& args, TNodeSet& seen) { if (seen.find(node)!= seen.end()) return; if (node.getKind() == kind::VARIABLE || node.getKind() == kind::CONST_BITVECTOR) { // a constant in the node can either map to an argument of the abstraction // or can be hard-coded and part of the abstraction if (signature.getKind() == kind::SKOLEM) { args.push_back(node); seen.insert(node); } else { Assert (signature.getKind() == kind::CONST_BITVECTOR); } // return; } Assert (node.getKind() == signature.getKind() && node.getNumChildren() == signature.getNumChildren()); for (unsigned i = 0; i < node.getNumChildren(); ++i) { collectArguments(node[i], signature[i], args, seen); seen.insert(node); } }
void ArithStaticLearner::staticLearning(TNode n, NodeBuilder<>& learned){ vector<TNode> workList; workList.push_back(n); TNodeSet processed; //Contains an underapproximation of nodes that must hold. TNodeSet defTrue; defTrue.insert(n); while(!workList.empty()) { n = workList.back(); bool unprocessedChildren = false; for(TNode::iterator i = n.begin(), iend = n.end(); i != iend; ++i) { if(processed.find(*i) == processed.end()) { // unprocessed child workList.push_back(*i); unprocessedChildren = true; } } if(n.getKind() == AND && defTrue.find(n) != defTrue.end() ){ for(TNode::iterator i = n.begin(), iend = n.end(); i != iend; ++i) { defTrue.insert(*i); } } if(unprocessedChildren) { continue; } workList.pop_back(); // has node n been processed in the meantime ? if(processed.find(n) != processed.end()) { continue; } processed.insert(n); process(n,learned, defTrue); } }
unsigned QuickXPlain::selectUnsatCore(unsigned low, unsigned high, std::vector<TNode>& conflict) { Assert(!d_solver->getConflict().isNull() && d_solver->inConflict()); Node query_confl = d_solver->getConflict(); // conflict wasn't actually minimized if (query_confl.getNumChildren() == high - low + 1) { return high; } TNodeSet nodes; for (unsigned i = low; i <= high; i++) { nodes.insert(conflict[i]); } unsigned write = low; for (unsigned i = 0; i < query_confl.getNumChildren(); ++i) { TNode current = query_confl[i]; // the conflict can have nodes in lower decision levels if (nodes.find(current) != nodes.end()) { conflict[write++] = current; nodes.erase(nodes.find(current)); } } // if all of the nodes in the conflict were on a lower level if (write == low) { return low; } Assert (write != 0); unsigned new_high = write - 1; for (TNodeSet::const_iterator it = nodes.begin(); it != nodes.end(); ++it) { conflict[write++] = *it; } Assert (write -1 == high); Assert (new_high <= high); return new_high; }
void AbstractionModule::collectArgumentTypes(TNode sig, std::vector<TypeNode>& types, TNodeSet& seen) { if (seen.find(sig) != seen.end()) return; if (sig.getKind() == kind::SKOLEM) { types.push_back(sig.getType()); seen.insert(sig); return; } for (unsigned i = 0; i < sig.getNumChildren(); ++i) { collectArgumentTypes(sig[i], types, seen); seen.insert(sig); } }
bool AbstractionModule::isConjunctionOfAtomsRec(TNode node, TNodeSet& seen) { if (seen.find(node)!= seen.end()) return true; if (!node.getType().isBitVector()) { return (node.getKind() == kind::AND || utils::isBVPredicate(node)); } if (node.getNumChildren() == 0) return true; for (unsigned i = 0; i < node.getNumChildren(); ++i) { if (!isConjunctionOfAtomsRec(node[i], seen)) return false; } seen.insert(node); return true; }
bool hasExpensiveBVOperatorsRec(TNode fact, TNodeSet& seen) { if (fact.getKind() == kind::BITVECTOR_MULT || fact.getKind() == kind::BITVECTOR_UDIV_TOTAL || fact.getKind() == kind::BITVECTOR_UREM_TOTAL) { return true; } if (seen.find(fact) != seen.end()) return false; if (fact.getNumChildren() == 0) return false; for (unsigned i = 0; i < fact.getNumChildren(); ++i) { bool difficult = hasExpensiveBVOperatorsRec(fact[i], seen); if (difficult) return true; } seen.insert(fact); return false; }
void ExtractSkolemizer::collectExtracts(TNode node, TNodeSet& seen) { if (seen.find(node) != seen.end()) { return; } if (node.getKind() == kind::BITVECTOR_EXTRACT && node[0].getMetaKind() == kind::metakind::VARIABLE) { unsigned high = utils::getExtractHigh(node); unsigned low = utils::getExtractLow(node); TNode var = node[0]; storeExtract(var, high, low); seen.insert(node); return; } if (node.getNumChildren() == 0) return; for (unsigned i = 0; i < node.getNumChildren(); ++i) { collectExtracts(node[i], seen); } seen.insert(node); }