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