void InstStrategyCegqi::process( Node q, Theory::Effort effort, int e ) {
if( e==0 ){
CegInstantiator * cinst = getInstantiator( q );
Trace("inst-alg") << "-> Run cegqi for " << q << std::endl;
d_curr_quant = q;
if( !cinst->check() ){
d_incomplete_check = true;
d_check_vts_lemma_lc = true;
}
d_curr_quant = Node::null();
}else if( e==1 ){
//minimize the free delta heuristically on demand
if( d_check_vts_lemma_lc ){
Trace("inst-alg") << "-> Minimize delta heuristic, for " << q << std::endl;
d_check_vts_lemma_lc = false;
d_small_const = NodeManager::currentNM()->mkNode( MULT, d_small_const, d_small_const );
d_small_const = Rewriter::rewrite( d_small_const );
//heuristic for now, until we know how to do nested quantification
Node delta = d_quantEngine->getTermDatabase()->getVtsDelta( true, false );
if( !delta.isNull() ){
Trace("quant-vts-debug") << "Delta lemma for " << d_small_const << std::endl;
Node delta_lem_ub = NodeManager::currentNM()->mkNode( LT, delta, d_small_const );
d_quantEngine->getOutputChannel().lemma( delta_lem_ub );
}
std::vector< Node > inf;
d_quantEngine->getTermDatabase()->getVtsTerms( inf, true, false, false );
for( unsigned i=0; i<inf.size(); i++ ){
Trace("quant-vts-debug") << "Infinity lemma for " << inf[i] << " " << d_small_const << std::endl;
Node inf_lem_lb = NodeManager::currentNM()->mkNode( GT, inf[i], NodeManager::currentNM()->mkConst( Rational(1)/d_small_const.getConst<Rational>() ) );
d_quantEngine->getOutputChannel().lemma( inf_lem_lb );
}
}
}
}
void InstStrategyCegqi::registerCounterexampleLemma( Node q, Node lem ) {
//must register with the instantiator
//must explicitly remove ITEs so that we record dependencies
std::vector< Node > ce_vars;
for( unsigned i=0; i<d_quantEngine->getTermDatabase()->getNumInstantiationConstants( q ); i++ ){
ce_vars.push_back( d_quantEngine->getTermDatabase()->getInstantiationConstant( q, i ) );
}
std::vector< Node > lems;
lems.push_back( lem );
CegInstantiator * cinst = getInstantiator( q );
cinst->registerCounterexampleLemma( lems, ce_vars );
for( unsigned i=0; i<lems.size(); i++ ){
Trace("cbqi-debug") << "Counterexample lemma " << i << " : " << lems[i] << std::endl;
d_quantEngine->addLemma( lems[i], false );
}
}
int InstStrategyCegqi::process( Node f, Theory::Effort effort, int e ) {
if( e<2 ){
return STATUS_UNFINISHED;
}else if( e==2 ){
CegInstantiator * cinst;
std::map< Node, CegInstantiator * >::iterator it = d_cinst.find( f );
if( it==d_cinst.end() ){
cinst = new CegInstantiator( d_quantEngine, d_out );
if( d_n_delta.isNull() ){
d_n_delta = NodeManager::currentNM()->mkSkolem( "delta", NodeManager::currentNM()->realType(), "delta for cegqi inst strategy" );
Node delta_lem = NodeManager::currentNM()->mkNode( GT, d_n_delta, NodeManager::currentNM()->mkConst( Rational( 0 ) ) );
d_quantEngine->getOutputChannel().lemma( delta_lem );
}
cinst->d_n_delta = d_n_delta;
for( int i=0; i<d_quantEngine->getTermDatabase()->getNumInstantiationConstants( f ); i++ ){
cinst->d_vars.push_back( d_quantEngine->getTermDatabase()->getInstantiationConstant( f, i ) );
}
d_cinst[f] = cinst;
}else{
cinst = it->second;
}
if( d_check_delta_lemma ){
Trace("inst-alg") << "-> Get delta lemmas for cegqi..." << std::endl;
d_check_delta_lemma = false;
std::vector< Node > dlemmas;
cinst->getDeltaLemmas( dlemmas );
Trace("inst-alg") << "...got " << dlemmas.size() << " delta lemmas." << std::endl;
if( !dlemmas.empty() ){
bool addedLemma = false;
for( unsigned i=0; i<dlemmas.size(); i++ ){
if( addLemma( dlemmas[i] ) ){
addedLemma = true;
}
}
if( addedLemma ){
return STATUS_UNKNOWN;
}
}
}
Trace("inst-alg") << "-> Run cegqi for " << f << std::endl;
d_curr_quant = f;
cinst->check();
d_curr_quant = Node::null();
}
return STATUS_UNKNOWN;
}
