Node FirstOrderModel::evaluateTermDefault( Node n, int& depIndex, std::vector< int >& childDepIndex, RepSetIterator* ri ){ depIndex = -1; if( n.getNumChildren()==0 ){ return n; }else{ //first we must evaluate the arguments std::vector< Node > children; if( n.getMetaKind()==kind::metakind::PARAMETERIZED ){ children.push_back( n.getOperator() ); } //for each argument, calculate its value, and the variables its value depends upon for( int i=0; i<(int)n.getNumChildren(); i++ ){ childDepIndex.push_back( -1 ); Node nn = evaluateTerm( n[i], childDepIndex[i], ri ); if( nn.isNull() ){ depIndex = ri->getNumTerms()-1; return nn; }else{ children.push_back( nn ); if( childDepIndex[i]>depIndex ){ depIndex = childDepIndex[i]; } } } //recreate the value Node val = NodeManager::currentNM()->mkNode( n.getKind(), children ); return val; } }
Node AbstractionModule::reverseAbstraction(Node assertion, NodeNodeMap& seen) { if (seen.find(assertion) != seen.end()) return seen[assertion]; if (isAbstraction(assertion)) { Node interp = getInterpretation(assertion); seen[assertion] = interp; Assert (interp.getType() == assertion.getType()); return interp; } if (assertion.getNumChildren() == 0) { seen[assertion] = assertion; return assertion; } NodeBuilder<> result(assertion.getKind()); if (assertion.getMetaKind() == kind::metakind::PARAMETERIZED) { result << assertion.getOperator(); } for (unsigned i = 0; i < assertion.getNumChildren(); ++i) { result << reverseAbstraction(assertion[i], seen); } Node res = result; seen[assertion] = res; return res; }
void InstantiationEngine::registerQuantifier( Node f ){ if( d_quantEngine->hasOwnership( f, this ) ){ //Notice() << "do cbqi " << f << " ? " << std::endl; if( options::cbqi() ){ Node ceBody = d_quantEngine->getTermDatabase()->getInstConstantBody( f ); if( !doCbqi( f ) ){ d_quantEngine->addTermToDatabase( ceBody, true ); } } //take into account user patterns if( f.getNumChildren()==3 ){ Node subsPat = d_quantEngine->getTermDatabase()->getInstConstantNode( f[2], f ); //add patterns for( int i=0; i<(int)subsPat.getNumChildren(); i++ ){ //Notice() << "Add pattern " << subsPat[i] << " for " << f << std::endl; if( subsPat[i].getKind()==INST_PATTERN ){ addUserPattern( f, subsPat[i] ); }else if( subsPat[i].getKind()==INST_NO_PATTERN ){ addUserNoPattern( f, subsPat[i] ); } } } } }
Node AlphaEquivalenceNode::registerNode( AlphaEquivalenceNode* aen, QuantifiersEngine* qe, Node q, std::vector< Node >& tt, std::vector< int >& arg_index ) { std::map< Node, bool > visited; while( !tt.empty() ){ if( tt.size()==arg_index.size()+1 ){ Node t = tt.back(); Node op; if( t.hasOperator() ){ if( visited.find( t )==visited.end() ){ visited[t] = true; op = t.getOperator(); arg_index.push_back( 0 ); }else{ op = t; arg_index.push_back( -1 ); } }else{ op = t; arg_index.push_back( 0 ); } Trace("aeq-debug") << op << " "; aen = &(aen->d_children[op][t.getNumChildren()]); }else{ Node t = tt.back(); int i = arg_index.back(); if( i==-1 || i==(int)t.getNumChildren() ){ tt.pop_back(); arg_index.pop_back(); }else{ tt.push_back( t[i] ); arg_index[arg_index.size()-1]++; } } } Node lem; Trace("aeq-debug") << std::endl; if( aen->d_quant.isNull() ){ aen->d_quant = q; }else{ if( q.getNumChildren()==2 ){ //lemma ( q <=> d_quant ) Trace("alpha-eq") << "Alpha equivalent : " << std::endl; Trace("alpha-eq") << " " << q << std::endl; Trace("alpha-eq") << " " << aen->d_quant << std::endl; lem = q.eqNode( aen->d_quant ); }else{ //do not reduce annotated quantified formulas based on alpha equivalence } } return lem; }
int getDepth( Node n ){ if( n.getNumChildren()==0 ){ return 0; }else{ int maxDepth = -1; for( int i=0; i<(int)n.getNumChildren(); i++ ){ int depth = getDepth( n[i] ); if( depth>maxDepth ){ maxDepth = depth; } } return maxDepth; } }
Node QuantifiersRewriter::computeElimSymbols( Node body ) { if( isLiteral( body ) ){ return body; }else{ bool childrenChanged = false; std::vector< Node > children; for( unsigned i=0; i<body.getNumChildren(); i++ ){ Node c = computeElimSymbols( body[i] ); if( i==0 && ( body.getKind()==IMPLIES || body.getKind()==XOR ) ){ c = c.negate(); } children.push_back( c ); childrenChanged = childrenChanged || c!=body[i]; } if( body.getKind()==IMPLIES ){ return NodeManager::currentNM()->mkNode( OR, children ); }else if( body.getKind()==XOR ){ return NodeManager::currentNM()->mkNode( IFF, children ); }else if( childrenChanged ){ return NodeManager::currentNM()->mkNode( body.getKind(), children ); }else{ return body; } } }
//general method for computing various rewrites Node QuantifiersRewriter::computeOperation( Node f, int computeOption ){ if( f.getKind()==FORALL ){ Trace("quantifiers-rewrite-debug") << "Compute operation " << computeOption << " on " << f << std::endl; std::vector< Node > args; for( int i=0; i<(int)f[0].getNumChildren(); i++ ){ args.push_back( f[0][i] ); } NodeBuilder<> defs(kind::AND); Node n = f[1]; Node ipl; if( f.getNumChildren()==3 ){ ipl = f[2]; } if( computeOption==COMPUTE_ELIM_SYMBOLS ){ n = computeElimSymbols( n ); }else if( computeOption==COMPUTE_MINISCOPING ){ //return directly return computeMiniscoping( args, n, ipl, f.hasAttribute(NestedQuantAttribute()) ); }else if( computeOption==COMPUTE_AGGRESSIVE_MINISCOPING ){ return computeAggressiveMiniscoping( args, n, f.hasAttribute(NestedQuantAttribute()) ); }else if( computeOption==COMPUTE_NNF ){ n = computeNNF( n ); }else if( computeOption==COMPUTE_SIMPLE_ITE_LIFT ){ n = computeSimpleIteLift( n ); }else if( computeOption==COMPUTE_PRENEX ){ n = computePrenex( n, args, true ); }else if( computeOption==COMPUTE_VAR_ELIMINATION ){ Node prev; do{ prev = n; n = computeVarElimination( n, args, ipl ); }while( prev!=n && !args.empty() ); }else if( computeOption==COMPUTE_CNF ){ //n = computeNNF( n ); n = computeCNF( n, args, defs, false ); ipl = Node::null(); }else if( computeOption==COMPUTE_SPLIT ) { return computeSplit(f, n, args ); } Trace("quantifiers-rewrite-debug") << "Compute Operation: return " << n << ", " << args.size() << std::endl; if( f[1]==n && args.size()==f[0].getNumChildren() ){ return f; }else{ if( args.empty() ){ defs << n; }else{ std::vector< Node > children; children.push_back( NodeManager::currentNM()->mkNode(kind::BOUND_VAR_LIST, args ) ); children.push_back( n ); if( !ipl.isNull() ){ children.push_back( ipl ); } defs << NodeManager::currentNM()->mkNode(kind::FORALL, children ); } return defs.getNumChildren()==1 ? defs.getChild( 0 ) : defs.constructNode(); } }else{ return f; } }
void QuantPhaseReq::computePhaseReqs( Node n, bool polarity, std::map< Node, int >& phaseReqs ){ bool newReqPol = false; bool newPolarity; if( n.getKind()==NOT ){ newReqPol = true; newPolarity = !polarity; }else if( n.getKind()==OR || n.getKind()==IMPLIES ){ if( !polarity ){ newReqPol = true; newPolarity = false; } }else if( n.getKind()==AND ){ if( polarity ){ newReqPol = true; newPolarity = true; } }else{ int val = polarity ? 1 : -1; if( phaseReqs.find( n )==phaseReqs.end() ){ phaseReqs[n] = val; }else if( val!=phaseReqs[n] ){ phaseReqs[n] = 0; } } if( newReqPol ){ for( int i=0; i<(int)n.getNumChildren(); i++ ){ if( n.getKind()==IMPLIES && i==0 ){ computePhaseReqs( n[i], !newPolarity, phaseReqs ); }else{ computePhaseReqs( n[i], newPolarity, phaseReqs ); } } } }
void InstStrategyAutoGenTriggers::addUserNoPattern( Node q, Node pat ) { Assert( pat.getKind()==INST_NO_PATTERN && pat.getNumChildren()==1 ); if( std::find( d_user_no_gen[q].begin(), d_user_no_gen[q].end(), pat[0] )==d_user_no_gen[q].end() ){ Trace("user-pat") << "Add user no-pattern: " << pat[0] << " for " << q << std::endl; d_user_no_gen[q].push_back( pat[0] ); } }
void InstStrategyUserPatterns::addUserPattern( Node q, Node pat ){ Assert( pat.getKind()==INST_PATTERN ); //add to generators bool usable = true; std::vector< Node > nodes; for( unsigned i=0; i<pat.getNumChildren(); i++ ){ Node pat_use = Trigger::getIsUsableTrigger( pat[i], q ); if( pat_use.isNull() ){ Trace("trigger-warn") << "User-provided trigger is not usable : " << pat << " because of " << pat[i] << std::endl; usable = false; break; }else{ nodes.push_back( pat_use ); } } if( usable ){ Trace("user-pat") << "Add user pattern: " << pat << " for " << q << std::endl; //check match option if( d_quantEngine->getInstUserPatMode()==USER_PAT_MODE_RESORT ){ d_user_gen_wait[q].push_back( nodes ); }else{ Trigger * t = Trigger::mkTrigger( d_quantEngine, q, nodes, true, Trigger::TR_MAKE_NEW ); if( t ){ d_user_gen[q].push_back( t ); }else{ Trace("trigger-warn") << "Failed to construct trigger : " << pat << " due to variable mismatch" << std::endl; } } } }
void PseudoBooleanProcessor::learnRewrittenGeq(Node assertion, bool negated, Node orig){ Assert(assertion.getKind() == kind::GEQ); Assert(assertion == Rewriter::rewrite(assertion)); // assume assertion is rewritten Node l = assertion[0]; Node r = assertion[1]; if(r.getKind() == kind::CONST_RATIONAL){ const Rational& rc = r.getConst<Rational>(); if(isIntVar(l)){ if(!negated && rc.isZero()){ // (>= x 0) addGeqZero(l, orig); }else if(negated && rc == Rational(2)){ addLeqOne(l, orig); } }else if(l.getKind() == kind::MULT && l.getNumChildren() == 2){ Node c = l[0], v = l[1]; if(c.getKind() == kind::CONST_RATIONAL && c.getConst<Rational>().isNegativeOne()){ if(isIntVar(v)){ if(!negated && rc.isNegativeOne()){ // (>= (* -1 x) -1) addLeqOne(v, orig); } } } } } if(!negated){ learnGeqSub(assertion); } }
bool InstStrategyCbqi::doCbqi( Node q ){ std::map< Node, bool >::iterator it = d_do_cbqi.find( q ); if( it==d_do_cbqi.end() ){ bool ret = false; if( d_quantEngine->getTermDatabase()->isQAttrQuantElim( q ) ){ ret = true; }else{ //if has an instantiation pattern, don't do it if( q.getNumChildren()==3 && options::eMatching() && options::userPatternsQuant()!=USER_PAT_MODE_IGNORE ){ ret = false; }else{ if( options::cbqiAll() ){ ret = true; }else{ //if quantifier has a non-arithmetic variable, then do not use cbqi //if quantifier has an APPLY_UF term, then do not use cbqi //Node cb = d_quantEngine->getTermDatabase()->getInstConstantBody( q ); std::map< Node, bool > visited; ret = !hasNonCbqiVariable( q ) && !hasNonCbqiOperator( q[1], visited ); } } } Trace("cbqi") << "doCbqi " << q << " returned " << ret << std::endl; d_do_cbqi[q] = ret; return ret; }else{ return it->second; } }
bool Balancer::balanceNode(Node& node, double runtime, const int kConfig) { WorkQueue work_queue; WorkRequest work_request; bool changed = false; const int kStrongest(3); if (kStrongest == kConfig) { changed = balanceNodeStrongest(node); } else { for (unsigned int gpu_index = 0; gpu_index < node.getNumChildren(); ++gpu_index) { // How much work does this device need? Node& gpu = node.getChild(gpu_index); int work_deficit = gpu.getTotalWorkNeeded(runtime, kConfig) - gpu.getBalCount(); if (0 > work_deficit) { // child has extra work int extra_blocks = abs(work_deficit); for (int block = 0; block < extra_blocks; ++block) { // move block from child to parent gpu.decrementBalCount(); node.incrementBalCount(); changed = true; } } else if (0 < work_deficit) { // child needs more work work_request.setTimeDiff(runtime - gpu.getBalTimeEst(0, kConfig)); work_request.setIndex(gpu_index); work_queue.push(work_request); } } /* at this point we have all extra blocks, and now we need to distribute blocks to children that need it */ while (0 < node.getBalCount() && // there are blocks left to give !work_queue.empty()) { // there are requests left to fill double time_diff = 0.0; //get largest request WorkRequest tmp = work_queue.top(); work_queue.pop(); node.decrementBalCount(); node.getChild(tmp.getIndex()).incrementBalCount(); time_diff = runtime - node.getChild(tmp.getIndex()).getBalTimeEst(0, kConfig); changed = true; // if there is still work left to do put it back on // the queue so that it will reorder correctly if (0 < time_diff) { tmp.setTimeDiff(time_diff); work_queue.push(tmp); } } } /* now we have balanced as much as we can and the only thing left is to get blocks from our parent, if we need them. */ return changed; //so we know to keep balancing }
Node QuantifiersEngine::getSubstitute( Node n, std::vector< Node >& terms ) { if( n.getKind()==INST_CONSTANT ) { Debug("check-inst") << "Substitute inst constant : " << n << std::endl; return terms[n.getAttribute(InstVarNumAttribute())]; } else { //if( !quantifiers::TermDb::hasInstConstAttr( n ) ){ //Debug("check-inst") << "No inst const attr : " << n << std::endl; //return n; //}else{ //Debug("check-inst") << "Recurse on : " << n << std::endl; std::vector< Node > cc; if( n.getMetaKind() == kind::metakind::PARAMETERIZED ) { cc.push_back( n.getOperator() ); } bool changed = false; for( unsigned i=0; i<n.getNumChildren(); i++ ) { Node c = getSubstitute( n[i], terms ); cc.push_back( c ); changed = changed || c!=n[i]; } if( changed ) { Node ret = NodeManager::currentNM()->mkNode( n.getKind(), cc ); return ret; } else { return n; } } }
void InstStrategyUserPatterns::addUserPattern( Node f, Node pat ){ Assert( pat.getKind()==INST_PATTERN ); //add to generators bool usable = true; std::vector< Node > nodes; for( int i=0; i<(int)pat.getNumChildren(); i++ ){ nodes.push_back( pat[i] ); if( pat[i].getKind()!=INST_CONSTANT && !Trigger::isUsableTrigger( pat[i], f ) ){ Trace("trigger-warn") << "User-provided trigger is not usable : " << pat << " because of " << pat[i] << std::endl; usable = false; break; } } if( usable ){ Trace("user-pat") << "Add user pattern: " << pat << " for " << f << std::endl; //extend to literal matching d_quantEngine->getPhaseReqTerms( f, nodes ); //check match option int matchOption = 0; if( d_quantEngine->getInstUserPatMode()==USER_PAT_MODE_RESORT ){ d_user_gen_wait[f].push_back( nodes ); }else{ d_user_gen[f].push_back( Trigger::mkTrigger( d_quantEngine, f, nodes, matchOption, true, Trigger::TR_MAKE_NEW, options::smartTriggers() ) ); } } }
void FirstOrderModel::initializeModelForTerm( Node n ){ if( n.getKind()==APPLY_UF ){ Node op = n.getOperator(); if( d_uf_model_tree.find( op )==d_uf_model_tree.end() ){ TypeNode tn = op.getType(); tn = tn[ (int)tn.getNumChildren()-1 ]; //only generate models for predicates and functions with uninterpreted range types if( tn==NodeManager::currentNM()->booleanType() || tn.isSort() ){ d_uf_model_tree[ op ] = uf::UfModelTree( op ); d_uf_model_gen[ op ].clear(); } } } /* if( n.getType().isArray() ){ while( n.getKind()==STORE ){ n = n[0]; } Node nn = getRepresentative( n ); if( d_array_model.find( nn )==d_array_model.end() ){ d_array_model[nn] = arrays::ArrayModel( nn, this ); } } */ for( int i=0; i<(int)n.getNumChildren(); i++ ){ initializeModelForTerm( n[i] ); } }
bool TermDb::isUnifiableInstanceOf( Node n1, Node n2, std::map< Node, Node >& subs ){ if( n1==n2 ){ return true; }else if( n2.getKind()==INST_CONSTANT ){ //if( !node_contains( n1, n2 ) ){ // return false; //} if( subs.find( n2 )==subs.end() ){ subs[n2] = n1; }else if( subs[n2]!=n1 ){ return false; } return true; }else if( n1.getKind()==n2.getKind() && n1.getMetaKind()==kind::metakind::PARAMETERIZED ){ if( n1.getOperator()!=n2.getOperator() ){ return false; } for( int i=0; i<(int)n1.getNumChildren(); i++ ){ if( !isUnifiableInstanceOf( n1[i], n2[i], subs ) ){ return false; } } return true; }else{ return false; } }
Node QuantifiersRewriter::computeClause( Node n ){ Assert( isClause( n ) ); if( isLiteral( n ) ){ return n; }else{ NodeBuilder<> t(OR); if( n.getKind()==NOT ){ if( n[0].getKind()==NOT ){ return computeClause( n[0][0] ); }else{ //De-Morgan's law Assert( n[0].getKind()==AND ); for( int i=0; i<(int)n[0].getNumChildren(); i++ ){ Node nn = computeClause( n[0][i].notNode() ); addNodeToOrBuilder( nn, t ); } } }else{ for( int i=0; i<(int)n.getNumChildren(); i++ ){ Node nn = computeClause( n[i] ); addNodeToOrBuilder( nn, t ); } } return t.constructNode(); } }
/** pre register quantifier */ void QuantDSplit::preRegisterQuantifier( Node q ) { int max_index = -1; int max_score = -1; if( q.getNumChildren()==3 ){ return; } Trace("quant-dsplit-debug") << "Check split quantified formula : " << q << std::endl; for( unsigned i=0; i<q[0].getNumChildren(); i++ ){ TypeNode tn = q[0][i].getType(); if( tn.isDatatype() ){ const Datatype& dt = ((DatatypeType)(tn).toType()).getDatatype(); if( dt.isRecursiveSingleton() ){ Trace("quant-dsplit-debug") << "Datatype " << dt.getName() << " is recursive singleton." << std::endl; }else{ int score = -1; if( options::quantDynamicSplit()==quantifiers::QUANT_DSPLIT_MODE_AGG ){ score = dt.isUFinite() ? 1 : -1; }else if( options::quantDynamicSplit()==quantifiers::QUANT_DSPLIT_MODE_DEFAULT ){ score = dt.isUFinite() ? 1 : -1; } Trace("quant-dsplit-debug") << "Datatype " << dt.getName() << " is score " << score << " (" << dt.isUFinite() << " " << dt.isFinite() << ")" << std::endl; if( score>max_score ){ max_index = i; max_score = score; } } } } if( max_index!=-1 ){ Trace("quant-dsplit-debug") << "Will split at index " << max_index << "." << std::endl; d_quant_to_reduce[q] = max_index; d_quantEngine->setOwner( q, this ); } }
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; }
void InstantiationEngine::registerQuantifier( Node f ){ //Notice() << "do cbqi " << f << " ? " << std::endl; Node ceBody = d_quantEngine->getTermDatabase()->getInstConstantBody( f ); if( !doCbqi( f ) ){ d_quantEngine->addTermToDatabase( ceBody, true ); } //take into account user patterns if( f.getNumChildren()==3 ){ Node subsPat = d_quantEngine->getTermDatabase()->getInstConstantNode( f[2], f ); //add patterns for( int i=0; i<(int)subsPat.getNumChildren(); i++ ){ //Notice() << "Add pattern " << subsPat[i] << " for " << f << std::endl; addUserPattern( f, subsPat[i] ); } } }
bool QModelBuilderInstGen::isUsableSelectionLiteral( Node n, int useOption ){ if( n.getKind()==FORALL ){ return false; }else if( n.getKind()!=APPLY_UF ){ for( int i=0; i<(int)n.getNumChildren(); i++ ){ //if it is a variable, then return false if( n[i].getAttribute(ModelBasisAttribute()) ){ return false; } } } for( int i=0; i<(int)n.getNumChildren(); i++ ){ if( !isUsableSelectionLiteral( n[i], useOption ) ){ return false; } } return true; }
int InstStrategyAutoGenTriggers::process( Node f, Theory::Effort effort, int e ){ int peffort = f.getNumChildren()==3 ? 2 : 1; //int peffort = f.getNumChildren()==3 ? 2 : 1; //int peffort = 1; if( e<peffort ){ return STATUS_UNFINISHED; }else{ bool gen = false; if( e==peffort ){ if( d_counter.find( f )==d_counter.end() ){ d_counter[f] = 0; gen = true; }else{ d_counter[f]++; gen = d_regenerate && d_counter[f]%d_regenerate_frequency==0; } }else{ gen = true; } if( gen ){ generateTriggers( f ); } Debug("quant-uf-strategy") << "Try auto-generated triggers... " << d_tr_strategy << " " << e << std::endl; //Notice() << "Try auto-generated triggers..." << std::endl; for( std::map< Trigger*, bool >::iterator itt = d_auto_gen_trigger[f].begin(); itt != d_auto_gen_trigger[f].end(); ++itt ){ Trigger* tr = itt->first; if( tr ){ bool processTrigger = itt->second; if( effort!=Theory::EFFORT_LAST_CALL && tr->isMultiTrigger() ){ #ifdef MULTI_TRIGGER_FULL_EFFORT_HALF processTrigger = d_counter[f]%2==0; #endif } if( processTrigger ){ //if( tr->isMultiTrigger() ) Debug("quant-uf-strategy-auto-gen-triggers") << " Process " << (*tr) << "..." << std::endl; InstMatch baseMatch; int numInst = tr->addInstantiations( baseMatch ); //if( tr->isMultiTrigger() ) Debug("quant-uf-strategy-auto-gen-triggers") << " Done, numInst = " << numInst << "." << std::endl; if( d_tr_strategy==Trigger::TS_MIN_TRIGGER ){ d_quantEngine->getInstantiationEngine()->d_statistics.d_instantiations_auto_gen_min += numInst; }else{ d_quantEngine->getInstantiationEngine()->d_statistics.d_instantiations_auto_gen += numInst; } if( tr->isMultiTrigger() ){ d_quantEngine->d_statistics.d_multi_trigger_instantiations += numInst; } //d_quantEngine->d_hasInstantiated[f] = true; } } } Debug("quant-uf-strategy") << "done." << std::endl; //Notice() << "done" << std::endl; } return STATUS_UNKNOWN; }
void QuantifiersEngine::setInstantiationLevelAttr( Node n, uint64_t level ){ if( !n.hasAttribute(InstLevelAttribute()) ){ InstLevelAttribute ila; n.setAttribute(ila,level); } for( int i=0; i<(int)n.getNumChildren(); i++ ){ setInstantiationLevelAttr( n[i], level ); } }
void QuantifiersRewriter::addNodeToOrBuilder( Node n, NodeBuilder<>& t ){ if( n.getKind()==OR ){ for( int i=0; i<(int)n.getNumChildren(); i++ ){ t << n[i]; } }else{ t << n; } }
void InstantiationEngine::registerQuantifier( Node f ){ if( d_quantEngine->hasOwnership( f, this ) ){ //for( unsigned i=0; i<d_instStrategies.size(); ++i ){ // d_instStrategies[i]->registerQuantifier( f ); //} //take into account user patterns if( f.getNumChildren()==3 ){ Node subsPat = d_quantEngine->getTermDatabase()->getInstConstantNode( f[2], f ); //add patterns for( int i=0; i<(int)subsPat.getNumChildren(); i++ ){ //Notice() << "Add pattern " << subsPat[i] << " for " << f << std::endl; if( subsPat[i].getKind()==INST_PATTERN ){ addUserPattern( f, subsPat[i] ); }else if( subsPat[i].getKind()==INST_NO_PATTERN ){ addUserNoPattern( f, subsPat[i] ); } } } } }
void getInstantiationConstants( Node n, std::vector< Node >& ics ){ if( n.getKind()==INST_CONSTANT ){ if( std::find( ics.begin(), ics.end(), n )==ics.end() ){ ics.push_back( n ); } }else{ for( unsigned i=0; i<n.getNumChildren(); i++ ){ getInstantiationConstants( n[i], ics ); } } }
void FirstOrderPropagation::collectLits( Node n, std::vector<Node> & lits ) { if( n.getKind()==FORALL ) { collectLits( n[1], lits ); } else if( n.getKind()==OR ) { for(unsigned j=0; j<n.getNumChildren(); j++) { collectLits(n[j], lits ); } } else { lits.push_back( n ); } }
void TermDb::computeVarContains2( Node n, Node parent ){ if( n.getKind()==INST_CONSTANT ){ if( std::find( d_var_contains[parent].begin(), d_var_contains[parent].end(), n )==d_var_contains[parent].end() ){ d_var_contains[parent].push_back( n ); } }else{ for( int i=0; i<(int)n.getNumChildren(); i++ ){ computeVarContains2( n[i], parent ); } } }
void QuantifiersRewriter::computeArgs( std::vector< Node >& args, std::vector< Node >& activeArgs, Node n ){ if( n.getKind()==BOUND_VARIABLE ){ if( std::find( args.begin(), args.end(), n )!=args.end() && std::find( activeArgs.begin(), activeArgs.end(), n )==activeArgs.end() ){ activeArgs.push_back( n ); } }else{ for( int i=0; i<(int)n.getNumChildren(); i++ ){ computeArgs( args, activeArgs, n[i] ); } } }