bool EqualitySolver::NotifyClass::eqNotifyTriggerEquality(TNode equality, bool value) { BVDebug("bitvector::equality") << "NotifyClass::eqNotifyTriggerEquality(" << equality << ", " << (value ? "true" : "false" )<< ")" << std::endl; if (value) { return d_solver.storePropagation(equality); } else { return d_solver.storePropagation(equality.notNode()); } }

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 CoreSolver::decomposeFact(TNode fact) { Debug("bv-slicer") << "CoreSolver::decomposeFact fact=" << fact << endl; // FIXME: are this the right things to assert? // assert decompositions since the equality engine does not know the semantics of // concat: // a == a_1 concat ... concat a_k // b == b_1 concat ... concat b_k TNode eq = fact.getKind() == kind::NOT? fact[0] : fact; TNode a = eq[0]; TNode b = eq[1]; Node new_a = getBaseDecomposition(a); Node new_b = getBaseDecomposition(b); Assert (utils::getSize(new_a) == utils::getSize(new_b) && utils::getSize(new_a) == utils::getSize(a)); NodeManager* nm = NodeManager::currentNM(); Node a_eq_new_a = nm->mkNode(kind::EQUAL, a, new_a); Node b_eq_new_b = nm->mkNode(kind::EQUAL, b, new_b); bool ok = true; ok = assertFactToEqualityEngine(a_eq_new_a, utils::mkTrue()); if (!ok) return false; ok = assertFactToEqualityEngine(b_eq_new_b, utils::mkTrue()); if (!ok) return false; ok = assertFactToEqualityEngine(fact, fact); if (!ok) return false; if (fact.getKind() == kind::EQUAL) { // assert the individual equalities as well // a_i == b_i if (new_a.getKind() == kind::BITVECTOR_CONCAT && new_b.getKind() == kind::BITVECTOR_CONCAT) { Assert (new_a.getNumChildren() == new_b.getNumChildren()); for (unsigned i = 0; i < new_a.getNumChildren(); ++i) { Node eq_i = nm->mkNode(kind::EQUAL, new_a[i], new_b[i]); ok = assertFactToEqualityEngine(eq_i, fact); if (!ok) return false; } } } return true; }

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

void TDecisionTree::TNode::CopyNode(const TNode& Node) { CleanUp(); CutFtrN = Node.CutFtrN; CutFtrVal = Node.CutFtrVal; NExamples = Node.NExamples; ClassHist = Node.ClassHist; FtrHist = Node.FtrHist; if (Node.HasLeft()) { Left = new TNode(Tree); Left->CopyNode(*Node.Left); } if (Node.HasRight()) { Right = new TNode(Tree); Right->CopyNode(*Node.Right); } }

void Relevancy::setJustified(TNode n) { Debug("decision") << " marking [" << n.getId() << "]"<< n << "as justified" << std::endl; d_justified.insert(n); if(options::decisionComputeRelevancy()) { d_relevancy[n] = d_maxRelevancy[n]; updateRelevancy(n); } }

void InequalitySolver::preRegister(TNode node) { Kind kind = node.getKind(); if (kind == kind::EQUAL || kind == kind::BITVECTOR_ULE || kind == kind::BITVECTOR_ULT) { d_ineqTerms.insert(node[0]); d_ineqTerms.insert(node[1]); } }

void TheoryQuantifiers::preRegisterTerm(TNode n) { Debug("quantifiers-prereg") << "TheoryQuantifiers::preRegisterTerm() " << n << endl; if( n.getKind()==FORALL ){ if( !options::cbqi() || options::recurseCbqi() || !TermUtil::hasInstConstAttr(n) ){ getQuantifiersEngine()->registerQuantifier( n ); Debug("quantifiers-prereg") << "TheoryQuantifiers::preRegisterTerm() done " << n << endl; } } }

Node TheoryBuiltinRewriter::blastChain(TNode in) { Assert(in.getKind() == kind::CHAIN); Kind chainedOp = in.getOperator().getConst<Chain>().getOperator(); if(in.getNumChildren() == 2) { // if this is the case exactly 1 pair will be generated so the // AND is not required return NodeManager::currentNM()->mkNode(chainedOp, in[0], in[1]); } else { NodeBuilder<> conj(kind::AND); for(TNode::iterator i = in.begin(), j = i + 1; j != in.end(); ++i, ++j) { conj << NodeManager::currentNM()->mkNode(chainedOp, *i, *j); } return conj; } }

vector<string> QueryEvaluator::getSymbolsUsedBy(TNode * node) { vector<string> results; int size = node->getNumChildren(); for (int i=0; i<size; i++) { TNode * child = node->getChildAtIndex(i); if (child->getType()==QuerySymbol) { results.push_back(child->getValue()); } vector<string> sub_results = getSymbolsUsedBy(child); for (size_t j=0; j<sub_results.size(); j++) { if (find(results.begin(), results.end(), sub_results[j])==results.end()) results.push_back(sub_results[j]); } } return results; }

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 SharedTermsDatabase::isKnown(TNode literal) const { bool polarity = literal.getKind() != kind::NOT; TNode equality = polarity ? literal : literal[0]; if (polarity) { return d_equalityEngine.areEqual(equality[0], equality[1]); } else { return d_equalityEngine.areDisequal(equality[0], equality[1], false); } }

/** * return value as the model suggested. The history state must be historified * or the history's level should be 0. when level == 0 but idx != 0, the * history is a psuedo unigram state used for this model to combine another * bigram cache language model */ double CThreadSlm::rawTransfer(TState history, unsigned int wid, TState& result) { unsigned int lvl = history.getLevel(); unsigned int pos = history.getIdx(); double cost = (m_UseLogPr)?0.0:1.0; // NON_Word id must be dealed with special, let it transfer to root // without any cost if (ID_NOT_WORD == wid) { result = 0; return cost; } while (true) { //for psuedo cache model unigram state TNode* pn = ((TNode *)m_Levels[lvl]) + ((lvl)?pos:0); unsigned int t = (pn+1)->ch(); if (lvl < m_N-1) { TNode* pBase =(TNode*)m_Levels[lvl+1]; unsigned int idx = find_id(pBase, pn->ch(), t, wid); if (idx != t) { result.setIdx(idx); result.setLevel(lvl+1); double pr = m_prTable[pBase[idx].pr()]; return (m_UseLogPr)?(cost+pr):(cost*pr); } } else { TLeaf* pBase =(TLeaf*)m_Levels[lvl+1]; unsigned int idx = find_id(pBase, pn->ch(), t, wid); if (idx != t) { result.setIdx(idx); result.setLevel(lvl+1); double pr = m_prTable[pBase[idx].pr()]; return (m_UseLogPr)?(cost+pr):(cost*pr); } } if (m_UseLogPr) cost += m_bowTable[pn->bow()]; else cost *= m_bowTable[pn->bow()]; if (lvl == 0) break; lvl = pn->bol(); pos = pn->bon(); } result.setLevel(0); result.setIdx(0); if (m_UseLogPr) return cost + m_prTable[((TNode *)m_Levels[0])->pr()]; else return cost * m_prTable[((TNode *)m_Levels[0])->pr()]; }

Node TheoryUF::ppRewrite(TNode node) { if (node.getKind() != kind::APPLY_UF) { return node; } // perform the callbacks requested by TheoryUF::registerPpRewrite() RegisterPpRewrites::iterator c = d_registeredPpRewrites.find(node.getOperator()); if (c == d_registeredPpRewrites.end()) { return node; } else { Node res = c->second->ppRewrite(node); if (res != node) { return ppRewrite(res); } else { return res; } } }

bool BvToBoolPreprocessor::isConvertibleBvTerm(TNode node) { if (!node.getType().isBitVector() || node.getType().getBitVectorSize() != 1) return false; Kind kind = node.getKind(); if (kind == kind::CONST_BITVECTOR || kind == kind::ITE || kind == kind::BITVECTOR_AND || kind == kind::BITVECTOR_OR || kind == kind::BITVECTOR_NOT || kind == kind::BITVECTOR_XOR || kind == kind::BITVECTOR_COMP) { return true; } return false; }

bool BvToBoolPreprocessor::isConvertibleBvAtom(TNode node) { Kind kind = node.getKind(); return (kind == kind::EQUAL && node[0].getType().isBitVector() && node[0].getType().getBitVectorSize() == 1 && node[1].getType().isBitVector() && node[1].getType().getBitVectorSize() == 1 && node[0].getKind() != kind::BITVECTOR_EXTRACT && node[1].getKind() != kind::BITVECTOR_EXTRACT); }

// static RewriteResponse TheorySetsRewriter::preRewrite(TNode node) { NodeManager* nm = NodeManager::currentNM(); // do nothing if(node.getKind() == kind::EQUAL && node[0] == node[1]) return RewriteResponse(REWRITE_DONE, nm->mkConst(true)); // Further optimization, if constants but differing ones return RewriteResponse(REWRITE_DONE, node); }

void EqualitySolver::preRegister(TNode node) { if (!d_useEqualityEngine) return; if (node.getKind() == kind::EQUAL) { d_equalityEngine.addTriggerEquality(node); } else { d_equalityEngine.addTerm(node); } }

bool BVQuickCheck::addAssertion(TNode assertion) { Assert (assertion.getType().isBoolean()); d_bitblaster->bbAtom(assertion); // assert to sat solver and run bcp to detect easy conflicts bool ok = d_bitblaster->assertToSat(assertion, true); if (!ok) { setConflict(); } return ok; }

void ExtractSkolemizer::storeExtract(TNode var, unsigned high, unsigned low) { Assert (var.getMetaKind() == kind::metakind::VARIABLE); if (d_varToExtract.find(var) == d_varToExtract.end()) { d_varToExtract[var] = ExtractList(utils::getSize(var)); } VarExtractMap::iterator it = d_varToExtract.find(var); ExtractList& el = it->second; Extract e(high, low); el.addExtract(e); }

bool Relevancy::handleOrFalse(TNode node, SatValue desiredVal) { Debug("jh-findSplitterRec") << " handleOrFalse (" << node << ", " << desiredVal << std::endl; Assert( (node.getKind() == kind::AND and desiredVal == SAT_VALUE_TRUE) or (node.getKind() == kind::OR and desiredVal == SAT_VALUE_FALSE) ); int n = node.getNumChildren(); bool ret = false; for(int i = 0; i < n; ++i) { if (findSplitterRec(node[i], desiredVal)) { if(!options::decisionComputeRelevancy()) return true; else ret = true; } } return ret; }

ULONG TNode::expand(ULONG nItem, BOOL bItemexpanded /*= TRUE*/, BOOL bexpand /*= TRUE*/) { TNode* pNode = getAt(nItem, bItemexpanded); ULONG nNodeItems = 0; if (pNode != NULL) { if (!bexpand) { nNodeItems = pNode->getItems(bItemexpanded); } pNode->expand(bexpand); if (bexpand) { nNodeItems = pNode->getItems(bItemexpanded); } return nNodeItems; } return 0; }

bool PropEngine::properExplanation(TNode node, TNode expl) const { if(! d_cnfStream->hasLiteral(node)) { Trace("properExplanation") << "properExplanation(): Failing because node " << "being explained doesn't have a SAT literal ?!" << std::endl << "properExplanation(): The node is: " << node << std::endl; return false; } SatLiteral nodeLit = d_cnfStream->getLiteral(node); for(TNode::kinded_iterator i = expl.begin(kind::AND), i_end = expl.end(kind::AND); i != i_end; ++i) { if(! d_cnfStream->hasLiteral(*i)) { Trace("properExplanation") << "properExplanation(): Failing because one of explanation " << "nodes doesn't have a SAT literal" << std::endl << "properExplanation(): The explanation node is: " << *i << std::endl; return false; } SatLiteral iLit = d_cnfStream->getLiteral(*i); if(iLit == nodeLit) { Trace("properExplanation") << "properExplanation(): Failing because the node" << std::endl << "properExplanation(): " << node << std::endl << "properExplanation(): cannot be made to explain itself!" << std::endl; return false; } if(! d_satSolver->properExplanation(nodeLit, iLit)) { Trace("properExplanation") << "properExplanation(): SAT solver told us that node" << std::endl << "properExplanation(): " << *i << std::endl << "properExplanation(): is not part of a proper explanation node for" << std::endl << "properExplanation(): " << node << std::endl << "properExplanation(): Perhaps it one of the two isn't assigned or the explanation" << std::endl << "properExplanation(): node wasn't propagated before the node being explained" << std::endl; return false; } } return true; }

void BitblastSolver::setConflict(TNode conflict) { Node final_conflict = conflict; if (options::bitvectorQuickXplain() && conflict.getKind() == kind::AND) { // std::cout << "Original conflict " << conflict.getNumChildren() << "\n"; final_conflict = d_quickXplain->minimizeConflict(conflict); //std::cout << "Minimized conflict " << final_conflict.getNumChildren() << "\n"; } d_bv->setConflict(final_conflict); }

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

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

Node InequalityGraph::makeDiseqSplitLemma(TNode diseq) { Assert (diseq.getKind() == kind::NOT && diseq[0].getKind() == kind::EQUAL); TNode a = diseq[0][0]; TNode b = diseq[0][1]; Node a_lt_b = utils::mkNode(kind::BITVECTOR_ULT, a, b); Node b_lt_a = utils::mkNode(kind::BITVECTOR_ULT, b, a); Node eq = diseq[0]; Node lemma = utils::mkNode(kind::OR, a_lt_b, b_lt_a, eq); return lemma; }

void EagerBitblaster::collectModelInfo(TheoryModel* m, bool fullModel) { TNodeSet::iterator it = d_variables.begin(); for (; it!= d_variables.end(); ++it) { TNode var = *it; if (d_bv->isLeaf(var) || isSharedTerm(var) || (var.isVar() && var.getType().isBoolean())) { // only shared terms could not have been bit-blasted Assert (hasBBTerm(var) || isSharedTerm(var)); Node const_value = getModelFromSatSolver(var, fullModel); if(const_value != Node()) { Debug("bitvector-model") << "EagerBitblaster::collectModelInfo (assert (= " << var << " " << const_value << "))\n"; m->assertEquality(var, const_value, true); } } } }

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

void PropEngine::assertLemma(TNode node, bool negated, bool removable) { //Assert(d_inCheckSat, "Sat solver should be in solve()!"); Debug("prop::lemmas") << "assertLemma(" << node << ")" << endl; if(Dump.isOn("lemmas")) { Dump("lemmas") << AssertCommand(node.toExpr()); } // Assert as removable d_cnfStream->convertAndAssert(node, removable, negated); }