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