Node AbstractionModule::substituteArguments(TNode signature, TNode apply, unsigned& index, TNodeTNodeMap& seen) {
if (seen.find(signature) != seen.end()) {
return seen[signature];
}
if (signature.getKind() == kind::SKOLEM) {
// return corresponding argument and increment counter
seen[signature] = apply[index];
return apply[index++];
}
if (signature.getNumChildren() == 0) {
Assert (signature.getKind() != kind::VARIABLE &&
signature.getKind() != kind::SKOLEM);
seen[signature] = signature;
return signature;
}
NodeBuilder<> builder(signature.getKind());
if (signature.getMetaKind() == kind::metakind::PARAMETERIZED) {
builder << signature.getOperator();
}
for (unsigned i = 0; i < signature.getNumChildren(); ++i) {
Node child = substituteArguments(signature[i], apply, index, seen);
builder << child;
}
Node result = builder;
seen[signature]= result;
return result;
}
bool ITESimplifier::leavesAreConst(TNode e, TheoryId tid)
{
Assert((e.getKind() == kind::ITE && !e.getType().isBoolean()) ||
Theory::theoryOf(e) != THEORY_BOOL);
if (e.isConst()) {
return true;
}
hash_map<Node, bool, NodeHashFunction>::iterator it;
it = d_leavesConstCache.find(e);
if (it != d_leavesConstCache.end()) {
return (*it).second;
}
if (!containsTermITE(e) && Theory::isLeafOf(e, tid)) {
d_leavesConstCache[e] = false;
return false;
}
Assert(e.getNumChildren() > 0);
size_t k = 0, sz = e.getNumChildren();
if (e.getKind() == kind::ITE) {
k = 1;
}
for (; k < sz; ++k) {
if (!leavesAreConst(e[k], tid)) {
d_leavesConstCache[e] = false;
return false;
}
}
d_leavesConstCache[e] = true;
return true;
}
Node BvToBoolPreprocessor::liftNode(TNode current) {
Node result;
if (hasLiftCache(current)) {
result = getLiftCache(current);
}else if (isConvertibleBvAtom(current)) {
result = convertBvAtom(current);
addToLiftCache(current, result);
} else {
if (current.getNumChildren() == 0) {
result = current;
} else {
NodeBuilder<> builder(current.getKind());
if (current.getMetaKind() == kind::metakind::PARAMETERIZED) {
builder << current.getOperator();
}
for (unsigned i = 0; i < current.getNumChildren(); ++i) {
Node converted = liftNode(current[i]);
Assert (converted.getType() == current[i].getType());
builder << converted;
}
result = builder;
addToLiftCache(current, result);
}
}
Assert (result != Node());
Assert(result.getType() == current.getType());
Debug("bv-to-bool") << "BvToBoolPreprocessor::liftNode " << current << " => \n" << result << "\n";
return result;
}
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);
}
}
Node AbstractionModule::computeSignatureRec(TNode node, NodeNodeMap& cache) {
if (cache.find(node) != cache.end()) {
return cache.find(node)->second;
}
if (node.getNumChildren() == 0) {
if (node.getKind() == kind::CONST_BITVECTOR)
return node;
Node sig = getSignatureSkolem(node);
cache[node] = sig;
return sig;
}
NodeBuilder<> builder(node.getKind());
if (node.getMetaKind() == kind::metakind::PARAMETERIZED) {
builder << node.getOperator();
}
for (unsigned i = 0; i < node.getNumChildren(); ++i) {
Node converted = computeSignatureRec(node[i], cache);
builder << converted;
}
Node result = builder;
cache[node] = result;
return result;
}
bool CVC4::theory::bv::utils::isEqualityTerm(TNode term, TNodeBoolMap& cache) {
term = term.getKind() == kind::NOT ? term[0] : term;
TNodeBoolMap::const_iterator it = cache.find(term);
if (it != cache.end()) {
return it->second;
}
if (term.getNumChildren() == 0)
return true;
if (theory::Theory::theoryOf(theory::THEORY_OF_TERM_BASED, term) == THEORY_BV) {
Kind k = term.getKind();
if (k != kind::CONST_BITVECTOR &&
k != kind::EQUAL &&
term.getMetaKind() != kind::metakind::VARIABLE) {
cache[term] = false;
return false;
}
}
for (unsigned i = 0; i < term.getNumChildren(); ++i) {
if (!isEqualityTerm(term[i], cache)) {
cache[term] = false;
return false;
}
}
cache[term]= true;
return true;
}
void AlgebraicSolver::processAssertions(std::vector<WorklistElement>& worklist, SubstitutionEx& subst) {
bool changed = true;
while(changed) {
// d_bv->spendResource();
changed = false;
for (unsigned i = 0; i < worklist.size(); ++i) {
// apply current substitutions
Node current = subst.apply(worklist[i].node);
unsigned current_id = worklist[i].id;
Node subst_expl = subst.explain(worklist[i].node);
worklist[i] = WorklistElement(Rewriter::rewrite(current), current_id);
// explanation for this assertion
Node old_expl = d_explanations[current_id];
Node new_expl = mergeExplanations(subst_expl, old_expl);
storeExplanation(current_id, new_expl);
// use the new substitution to solve
if(solve(worklist[i].node, new_expl, subst)) {
changed = true;
}
}
// check for concat slicings
for (unsigned i = 0; i < worklist.size(); ++i) {
TNode fact = worklist[i].node;
unsigned current_id = worklist[i].id;
if (fact.getKind() != kind::EQUAL)
continue;
TNode left = fact[0];
TNode right = fact[1];
if (left.getKind() != kind::BITVECTOR_CONCAT ||
right.getKind() != kind::BITVECTOR_CONCAT ||
left.getNumChildren() != right.getNumChildren())
continue;
bool can_slice = true;
for (unsigned j = 0; j < left.getNumChildren(); ++j) {
if (utils::getSize(left[j]) != utils::getSize(right[j]))
can_slice = false;
}
if (!can_slice)
continue;
for (unsigned j = 0; j < left.getNumChildren(); ++j) {
Node eq_j = utils::mkNode(kind::EQUAL, left[j], right[j]);
unsigned id = d_explanations.size();
TNode expl = d_explanations[current_id];
storeExplanation(expl);
worklist.push_back(WorklistElement(eq_j, id));
d_ids[eq_j] = id;
}
worklist[i] = WorklistElement(utils::mkTrue(), worklist[i].id);
changed = true;
}
Assert (d_explanations.size() == worklist.size());
}
}
bool TheoryUFTim::equiv(TNode x, TNode y) {
Assert(x.getKind() == kind::APPLY_UF);
Assert(y.getKind() == kind::APPLY_UF);
if(x.getNumChildren() != y.getNumChildren()) {
return false;
}
if(x.getOperator() != y.getOperator()) {
return false;
}
// intentionally don't look at operator
TNode::iterator xIter = x.begin();
TNode::iterator yIter = y.begin();
while(xIter != x.end()) {
if(!sameCongruenceClass(*xIter, *yIter)) {
return false;
}
++xIter;
++yIter;
}
return true;
}
Node ModelPostprocessor::rewriteAs(TNode n, TypeNode asType) {
if(n.getType().isSubtypeOf(asType)) {
// good to go, we have the right type
return n;
}
if(!n.isConst()) {
// we don't handle non-const right now
return n;
}
if(asType.isBoolean()) {
if(n.getType().isBitVector(1u)) {
// type mismatch: should only happen for Boolean-term conversion under
// datatype constructor applications; rewrite from BV(1) back to Boolean
bool tf = (n.getConst<BitVector>().getValue() == 1);
return NodeManager::currentNM()->mkConst(tf);
}
if(n.getType().isDatatype() && n.getType().hasAttribute(BooleanTermAttr())) {
// type mismatch: should only happen for Boolean-term conversion under
// datatype constructor applications; rewrite from datatype back to Boolean
Assert(n.getKind() == kind::APPLY_CONSTRUCTOR);
Assert(n.getNumChildren() == 0);
// we assume (by construction) false is first; see boolean_terms.cpp
bool tf = (Datatype::indexOf(n.getOperator().toExpr()) == 1);
Debug("boolean-terms") << "+++ rewriteAs " << n << " : " << asType << " ==> " << tf << endl;
return NodeManager::currentNM()->mkConst(tf);
}
}
if(n.getType().isBoolean()) {
bool tf = n.getConst<bool>();
if(asType.isBitVector(1u)) {
return NodeManager::currentNM()->mkConst(BitVector(1u, tf ? 1u : 0u));
}
if(asType.isDatatype() && asType.hasAttribute(BooleanTermAttr())) {
const Datatype& asDatatype = asType.getConst<Datatype>();
return NodeManager::currentNM()->mkNode(kind::APPLY_CONSTRUCTOR, (tf ? asDatatype[0] : asDatatype[1]).getConstructor());
}
}
if(n.getType().isRecord() && asType.isRecord()) {
Debug("boolean-terms") << "+++ got a record - rewriteAs " << n << " : " << asType << endl;
const Record& rec CVC4_UNUSED = n.getType().getConst<Record>();
const Record& asRec = asType.getConst<Record>();
Assert(rec.getNumFields() == asRec.getNumFields());
Assert(n.getNumChildren() == asRec.getNumFields());
NodeBuilder<> b(n.getKind());
b << asType;
for(size_t i = 0; i < n.getNumChildren(); ++i) {
b << rewriteAs(n[i], TypeNode::fromType(asRec[i].second));
}
Node out = b;
Debug("boolean-terms") << "+++ returning record " << out << endl;
return out;
}
RewriteResponse QuantifiersRewriter::postRewrite(TNode in) {
Trace("quantifiers-rewrite-debug") << "post-rewriting " << in << " " << in.hasAttribute(NestedQuantAttribute()) << std::endl;
if( in.getKind()==kind::EXISTS || in.getKind()==kind::FORALL ){
RewriteStatus status = REWRITE_DONE;
Node ret = in;
//get the arguments
std::vector< Node > args;
for( int i=0; i<(int)in[0].getNumChildren(); i++ ){
args.push_back( in[0][i] );
}
//get the instantiation pattern list
Node ipl;
if( in.getNumChildren()==3 ){
ipl = in[2];
}
//get the body
if( in.getKind()==EXISTS ){
std::vector< Node > children;
children.push_back( in[0] );
children.push_back( in[1].negate() );
if( in.getNumChildren()==3 ){
children.push_back( in[2] );
}
ret = NodeManager::currentNM()->mkNode( FORALL, children );
ret = ret.negate();
status = REWRITE_AGAIN_FULL;
}else{
bool isNested = in.hasAttribute(NestedQuantAttribute());
for( int op=0; op<COMPUTE_LAST; op++ ){
if( doOperation( in, isNested, op ) ){
ret = computeOperation( in, op );
if( ret!=in ){
status = REWRITE_AGAIN_FULL;
break;
}
}
}
}
//print if changed
if( in!=ret ){
if( in.hasAttribute(NestedQuantAttribute()) ){
setNestedQuantifiers( ret, in.getAttribute(NestedQuantAttribute()) );
}
Trace("quantifiers-rewrite") << "*** rewrite " << in << std::endl;
Trace("quantifiers-rewrite") << " to " << std::endl;
Trace("quantifiers-rewrite") << ret << std::endl;
}
return RewriteResponse( status, ret );
}
return RewriteResponse(REWRITE_DONE, in);
}
Node TheoryEngineModelBuilder::normalize(TheoryModel* m, TNode r, std::map< Node, Node >& constantReps, bool evalOnly)
{
std::map<Node, Node>::iterator itMap = constantReps.find(r);
if (itMap != constantReps.end()) {
return (*itMap).second;
}
NodeMap::iterator it = d_normalizedCache.find(r);
if (it != d_normalizedCache.end()) {
return (*it).second;
}
Node retNode = r;
if (r.getNumChildren() > 0) {
std::vector<Node> children;
if (r.getMetaKind() == kind::metakind::PARAMETERIZED) {
children.push_back(r.getOperator());
}
bool childrenConst = true;
for (size_t i=0; i < r.getNumChildren(); ++i) {
Node ri = r[i];
if (!ri.isConst()) {
if (m->d_equalityEngine.hasTerm(ri)) {
ri = m->d_equalityEngine.getRepresentative(ri);
itMap = constantReps.find(ri);
if (itMap != constantReps.end()) {
ri = (*itMap).second;
}
else if (evalOnly) {
ri = normalize(m, r[i], constantReps, evalOnly);
}
}
else {
ri = normalize(m, ri, constantReps, evalOnly);
}
if (!ri.isConst()) {
childrenConst = false;
}
}
children.push_back(ri);
}
retNode = NodeManager::currentNM()->mkNode( r.getKind(), children );
if (childrenConst) {
retNode = Rewriter::rewrite(retNode);
Assert(retNode.getKind() == kind::APPLY_UF || retNode.isConst());
}
}
d_normalizedCache[r] = retNode;
return retNode;
}
Node RePairAssocCommutativeOperators::case_assoccomm(TNode n){
Kind k = n.getKind();
Assert(isAssociateCommutative(k));
Assert(n.getMetaKind() != kind::metakind::PARAMETERIZED);
unsigned N = n.getNumChildren();
Assert(N >= 2);
Node last = rePairAssocCommutativeOperators( n[N-1]);
Node nextToLast = rePairAssocCommutativeOperators(n[N-2]);
NodeManager* nm = NodeManager::currentNM();
Node last2 = nm->mkNode(k, nextToLast, last);
if(N <= 2){
return last2;
} else{
Assert(N > 2);
Node prevRound = last2;
for(unsigned prevPos = N-2; prevPos > 0; --prevPos){
unsigned currPos = prevPos-1;
Node curr = rePairAssocCommutativeOperators(n[currPos]);
Node round = nm->mkNode(k, curr, prevRound);
prevRound = round;
}
return prevRound;
}
}
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;
}
bool InequalitySolver::isInequalityOnly(TNode node) {
if (node.getKind() == kind::NOT) {
node = node[0];
}
if (node.getAttribute(IneqOnlyComputedAttribute())) {
return node.getAttribute(IneqOnlyAttribute());
}
if (node.getKind() != kind::EQUAL &&
node.getKind() != kind::BITVECTOR_ULT &&
node.getKind() != kind::BITVECTOR_ULE &&
node.getKind() != kind::CONST_BITVECTOR &&
node.getKind() != kind::SELECT &&
node.getKind() != kind::STORE &&
node.getMetaKind() != kind::metakind::VARIABLE) {
// not worth caching
return false;
}
bool res = true;
for (unsigned i = 0; res && i < node.getNumChildren(); ++i) {
res = res && isInequalityOnly(node[i]);
}
node.setAttribute(IneqOnlyComputedAttribute(), true);
node.setAttribute(IneqOnlyAttribute(), res);
return res;
}
bool InequalitySolver::isInequalityOnly(TNode node) {
if (d_ineqOnlyCache.find(node) != d_ineqOnlyCache.end()) {
return d_ineqOnlyCache[node];
}
if (node.getKind() == kind::NOT) {
node = node[0];
}
if (node.getKind() != kind::EQUAL &&
node.getKind() != kind::BITVECTOR_ULT &&
node.getKind() != kind::BITVECTOR_ULE &&
node.getKind() != kind::CONST_BITVECTOR &&
node.getKind() != kind::SELECT &&
node.getKind() != kind::STORE &&
node.getMetaKind() != kind::metakind::VARIABLE) {
return false;
}
bool res = true;
for (unsigned i = 0; i < node.getNumChildren(); ++i) {
res = res && isInequalityOnly(node[i]);
}
d_ineqOnlyCache[node] = res;
return res;
}
Node TheoryBuiltinRewriter::blastDistinct(TNode in) {
Assert(in.getKind() == kind::DISTINCT);
if(in.getNumChildren() == 2) {
// if this is the case exactly 1 != pair will be generated so the
// AND is not required
Node eq = NodeManager::currentNM()->mkNode(in[0].getType().isBoolean() ? kind::IFF : kind::EQUAL, in[0], in[1]);
Node neq = NodeManager::currentNM()->mkNode(kind::NOT, eq);
return neq;
}
// assume that in.getNumChildren() > 2 => diseqs.size() > 1
vector<Node> diseqs;
for(TNode::iterator i = in.begin(); i != in.end(); ++i) {
TNode::iterator j = i;
while(++j != in.end()) {
Node eq = NodeManager::currentNM()->mkNode((*i).getType().isBoolean() ? kind::IFF : kind::EQUAL, *i, *j);
Node neq = NodeManager::currentNM()->mkNode(kind::NOT, eq);
diseqs.push_back(neq);
}
}
Node out = NodeManager::currentNM()->mkNode(kind::AND, diseqs);
return out;
}
Node TheoryStringsRewriter::rewriteConcatString( TNode node ) {
Trace("strings-prerewrite") << "Strings::rewriteConcatString start " << node << std::endl;
Node retNode = node;
std::vector<Node> node_vec;
Node preNode = Node::null();
for(unsigned int i=0; i<node.getNumChildren(); ++i) {
Node tmpNode = node[i];
if(node[i].getKind() == kind::STRING_CONCAT) {
tmpNode = rewriteConcatString(node[i]);
if(tmpNode.getKind() == kind::STRING_CONCAT) {
unsigned int j=0;
if(!preNode.isNull()) {
if(tmpNode[0].isConst()) {
preNode = NodeManager::currentNM()->mkConst( preNode.getConst<String>().concat( tmpNode[0].getConst<String>() ) );
node_vec.push_back( preNode );
preNode = Node::null();
++j;
} else {
node_vec.push_back( preNode );
preNode = Node::null();
node_vec.push_back( tmpNode[0] );
++j;
}
}
for(; j<tmpNode.getNumChildren() - 1; ++j) {
node_vec.push_back( tmpNode[j] );
}
tmpNode = tmpNode[j];
}
}
if(!tmpNode.isConst()) {
if(preNode != Node::null()) {
if(preNode.getKind() == kind::CONST_STRING && preNode.getConst<String>().isEmptyString() ) {
preNode = Node::null();
} else {
node_vec.push_back( preNode );
preNode = Node::null();
}
}
node_vec.push_back( tmpNode );
} else {
if(preNode.isNull()) {
preNode = tmpNode;
} else {
preNode = NodeManager::currentNM()->mkConst( preNode.getConst<String>().concat( tmpNode.getConst<String>() ) );
}
}
}
if(preNode != Node::null()) {
node_vec.push_back( preNode );
}
if(node_vec.size() > 1) {
retNode = NodeManager::currentNM()->mkNode(kind::STRING_CONCAT, node_vec);
} else {
retNode = node_vec[0];
}
Trace("strings-prerewrite") << "Strings::rewriteConcatString end " << retNode << std::endl;
return retNode;
}
std::set<Node> listToSet(TNode l){
std::set<Node> ret;
while(l.getKind() == OR){
Assert(l.getNumChildren() == 2);
ret.insert(l[0]);
l = l[1];
}
return ret;
}
void AlgebraicSolver::setConflict(TNode conflict) {
Node final_conflict = conflict;
if (options::bitvectorQuickXplain() &&
conflict.getKind() == kind::AND &&
conflict.getNumChildren() > 4) {
final_conflict = d_quickXplain->minimizeConflict(conflict);
}
d_bv->setConflict(final_conflict);
}
void AbsDef::construct_def_entry( FirstOrderModelAbs * m, TNode q, TNode n, int v, unsigned depth ) {
d_value = v;
if( depth<n.getNumChildren() ){
TypeNode tn = q.isNull() ? n[depth].getType() : m->getVariable( q, depth ).getType();
unsigned dom = m->d_domain[tn] ;
d_def[dom].construct_def_entry( m, q, n, v, depth+1 );
d_default = dom;
}
}
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;
}
void Relevancy::computeITEs(TNode n, IteList &l)
{
Debug("jh-ite") << " computeITEs( " << n << ", &l)\n";
for(unsigned i=0; i<n.getNumChildren(); ++i) {
SkolemMap::iterator it2 = d_iteAssertions.find(n[i]);
if(it2 != d_iteAssertions.end())
l.push_back(it2->second);
computeITEs(n[i], l);
}
}
/**
* Returns 0, if the two are equal,
* 1 if s is a generalization of t
* 2 if t is a generalization of s
* -1 if the two cannot be unified
*
* @param s
* @param t
*
* @return
*/
int AbstractionModule::comparePatterns(TNode s, TNode t) {
if (s.getKind() == kind::SKOLEM &&
t.getKind() == kind::SKOLEM) {
return 0;
}
if (s.getKind() == kind::CONST_BITVECTOR &&
t.getKind() == kind::CONST_BITVECTOR) {
if (s == t) {
return 0;
} else {
return -1;
}
}
if (s.getKind() == kind::SKOLEM &&
t.getKind() == kind::CONST_BITVECTOR) {
return 1;
}
if (s.getKind() == kind::CONST_BITVECTOR &&
t.getKind() == kind::SKOLEM) {
return 2;
}
if (s.getNumChildren() != t.getNumChildren() ||
s.getKind() != t.getKind())
return -1;
int unify = 0;
for (unsigned i = 0; i < s.getNumChildren(); ++i) {
int unify_i = comparePatterns(s[i], t[i]);
if (unify_i < 0)
return -1;
if (unify == 0) {
unify = unify_i;
} else if (unify != unify_i && unify_i != 0) {
return -1;
}
}
return unify;
}
uint64_t CVC4::theory::bv::utils::numNodes(TNode node, NodeSet& seen) {
if (seen.find(node) != seen.end())
return 0;
uint64_t size = 1;
for (unsigned i = 0; i < node.getNumChildren(); ++i) {
size += numNodes(node[i], seen);
}
seen.insert(node);
return size;
}
bool JustificationHeuristic::handleAndOrHard(TNode node,
SatValue desiredVal) {
Assert( (node.getKind() == kind::AND and desiredVal == SAT_VALUE_TRUE) or
(node.getKind() == kind::OR and desiredVal == SAT_VALUE_FALSE) );
int numChildren = node.getNumChildren();
for(int i = 0; i < numChildren; ++i)
if (findSplitterRec(node[i], desiredVal))
return true;
return false;
}
bool Relevancy::handleOrTrue(TNode node, SatValue desiredVal) {
Debug("jh-findSplitterRec") << " handleOrTrue (" << node << ", "
<< desiredVal << std::endl;
Assert( (node.getKind() == kind::AND and desiredVal == SAT_VALUE_FALSE) or
(node.getKind() == kind::OR and desiredVal == SAT_VALUE_TRUE) );
int n = node.getNumChildren();
SatValue desiredValInverted = invertValue(desiredVal);
for(int i = 0; i < n; ++i) {
if ( tryGetSatValue(node[i]) != desiredValInverted ) {
// PRE RELEVANCY return findSplitterRec(node[i], desiredVal);
bool ret = findSplitterRec(node[i], desiredVal);
if(ret) {
// Splitter could be found... so can't justify this node
if(!d_multipleBacktrace)
return true;
}
else {
// Splitter couldn't be found... should be justified
return false;
}
}
}
// Multiple backtrace is on, so must have reached here because
// everything had splitter
if(d_multipleBacktrace) return true;
if(Debug.isOn("jh-findSplitterRec")) {
Debug("jh-findSplitterRec") << " * ** " << std::endl;
Debug("jh-findSplitterRec") << node.getKind() << " "
<< node << std::endl;
for(unsigned i = 0; i < node.getNumChildren(); ++i)
Debug("jh-findSplitterRec") << "child: " << tryGetSatValue(node[i])
<< std::endl;
Debug("jh-findSplitterRec") << "node: " << tryGetSatValue(node)
<< std::endl;
}
Assert(false, "No controlling input found");
return false;
}
void CVC4::theory::bv::utils::collectVariables(TNode node, NodeSet& vars) {
if (vars.find(node) != vars.end())
return;
if (Theory::isLeafOf(node, THEORY_BV) && node.getKind() != kind::CONST_BITVECTOR) {
vars.insert(node);
return;
}
for (unsigned i = 0; i < node.getNumChildren(); ++i) {
collectVariables(node[i], vars);
}
}
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 collectAtoms(TNode node, CVC4::NodeSet& seen) {
if (seen.find(node) != seen.end())
return;
if (theory::Theory::theoryOf(node) != theory::THEORY_BOOL || node.isVar()) {
seen.insert(node);
return;
}
for (unsigned i = 0; i < node.getNumChildren(); ++i) {
collectAtoms(node[i], seen);
}
}
void AbstractionModule::makeFreshArgs(TNode func, std::vector<Node>& fresh_args) {
Assert (fresh_args.size() == 0);
Assert (func.getKind() == kind::APPLY_UF);
TNodeNodeMap d_map;
for (unsigned i = 0; i < func.getNumChildren(); ++i) {
TNode arg = func[i];
if (arg.isConst()) {
fresh_args.push_back(arg);
continue;
}
Assert (arg.getMetaKind() == kind::metakind::VARIABLE);
TNodeNodeMap::iterator it = d_map.find(arg);
if (it != d_map.end()) {
fresh_args.push_back(it->second);
} else {
Node skolem = utils::mkVar(utils::getSize(arg));
d_map[arg] = skolem;
fresh_args.push_back(skolem);
}
}
Assert (fresh_args.size() == func.getNumChildren());
}
