From: ajreynol Date: Thu, 31 Jul 2014 10:49:28 +0000 (+0200) Subject: New module for generating candidate equality conjectures used in inductive proofs... X-Git-Tag: cvc5-1.0.0~6683 X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=a9f4d3e2aed0c6d8d8b218c5f5d2bc95af2d45a6;p=cvc5.git New module for generating candidate equality conjectures used in inductive proofs. Filtering currently includes: LHS generalizes a term from an active conjecture, terms must be canonical, conjecture must be confirmed by a ground witness, and cannot be falsified by a ground witness. Refactoring of term database. QcfEngine now uses central data structure for term indexing. Add two options for quantifier instantiation : trigger selection mode --trigger-sel=mode, and --inst-no-entail which blocks all quantifier instantiations that are currently entailed (using an incomplete check). --- diff --git a/src/Makefile.am b/src/Makefile.am index 805ed6cb7..908e3de6c 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -327,6 +327,8 @@ libcvc4_la_SOURCES = \ theory/quantifiers/ambqi_builder.cpp \ theory/quantifiers/quant_conflict_find.h \ theory/quantifiers/quant_conflict_find.cpp \ + theory/quantifiers/conjecture_generator.h \ + theory/quantifiers/conjecture_generator.cpp \ theory/quantifiers/options_handlers.h \ theory/arith/theory_arith_type_rules.h \ theory/arith/type_enumerator.h \ diff --git a/src/theory/quantifiers/conjecture_generator.cpp b/src/theory/quantifiers/conjecture_generator.cpp new file mode 100644 index 000000000..462738cf8 --- /dev/null +++ b/src/theory/quantifiers/conjecture_generator.cpp @@ -0,0 +1,2009 @@ +/********************* */ +/*! \file subgoal_generator.cpp + ** \verbatim + ** Original author: Andrew Reynolds + ** Major contributors: none + ** Minor contributors (to current version): none + ** This file is part of the CVC4 project. + ** Copyright (c) 2009-2014 New York University and The University of Iowa + ** See the file COPYING in the top-level source directory for licensing + ** information.\endverbatim + ** + ** \brief conjecture generator class + ** + **/ + +#include "theory/quantifiers/conjecture_generator.h" +#include "theory/theory_engine.h" +#include "theory/quantifiers/options.h" +#include "theory/quantifiers/term_database.h" +#include "theory/quantifiers/trigger.h" +#include "theory/quantifiers/first_order_model.h" + +using namespace CVC4; +using namespace CVC4::kind; +using namespace CVC4::theory; +using namespace CVC4::theory::quantifiers; +using namespace std; + + +namespace CVC4 { + +void OpArgIndex::addTerm( ConjectureGenerator * s, TNode n, unsigned index ){ + if( index==n.getNumChildren() ){ + Assert( n.hasOperator() ); + if( std::find( d_ops.begin(), d_ops.end(), n.getOperator() )==d_ops.end() ){ + d_ops.push_back( n.getOperator() ); + d_op_terms.push_back( n ); + } + }else{ + d_child[s->getTermDatabase()->d_arg_reps[n][index]].addTerm( s, n, index+1 ); + } +} + +Node OpArgIndex::getGroundTerm( ConjectureGenerator * s, std::vector< TNode >& args ) { + if( d_ops.empty() ){ + for( std::map< TNode, OpArgIndex >::iterator it = d_child.begin(); it != d_child.end(); ++it ){ + std::map< TNode, Node >::iterator itf = s->d_ground_eqc_map.find( it->first ); + if( itf!=s->d_ground_eqc_map.end() ){ + args.push_back( itf->second ); + Node n = it->second.getGroundTerm( s, args ); + args.pop_back(); + if( !n.isNull() ){ + return n; + } + } + } + return Node::null(); + }else{ + std::vector< TNode > args2; + args2.push_back( d_ops[0] ); + args2.insert( args2.end(), args.begin(), args.end() ); + return NodeManager::currentNM()->mkNode( d_op_terms[0].getKind(), args2 ); + } +} + +void OpArgIndex::getGroundTerms( ConjectureGenerator * s, std::vector< TNode >& terms ) { + terms.insert( terms.end(), d_op_terms.begin(), d_op_terms.end() ); + for( std::map< TNode, OpArgIndex >::iterator it = d_child.begin(); it != d_child.end(); ++it ){ + if( s->isGroundEqc( it->first ) ){ + it->second.getGroundTerms( s, terms ); + } + } +} + + + +ConjectureGenerator::ConjectureGenerator( QuantifiersEngine * qe, context::Context* c ) : QuantifiersModule( qe ), +d_notify( *this ), +d_uequalityEngine(d_notify, c, "ConjectureGenerator::ee"), +d_ee_conjectures( c ){ + d_fullEffortCount = 0; + d_uequalityEngine.addFunctionKind( kind::APPLY_UF ); + d_uequalityEngine.addFunctionKind( kind::APPLY_CONSTRUCTOR ); + +} + +void ConjectureGenerator::eqNotifyNewClass( TNode t ){ + Trace("thm-ee-debug") << "UEE : new equivalence class " << t << std::endl; + d_upendingAdds.push_back( t ); +} + +void ConjectureGenerator::eqNotifyPreMerge(TNode t1, TNode t2) { + //get maintained representatives + TNode rt1 = t1; + TNode rt2 = t2; + std::map< Node, EqcInfo* >::iterator it1 = d_eqc_info.find( t1 ); + if( it1!=d_eqc_info.end() && !it1->second->d_rep.get().isNull() ){ + rt1 = it1->second->d_rep.get(); + } + std::map< Node, EqcInfo* >::iterator it2 = d_eqc_info.find( t2 ); + if( it2!=d_eqc_info.end() && !it2->second->d_rep.get().isNull() ){ + rt2 = it2->second->d_rep.get(); + } + Trace("thm-ee-debug") << "UEE : equality holds : " << t1 << " == " << t2 << std::endl; + Trace("thm-ee-debug") << " ureps : " << rt1 << " == " << rt2 << std::endl; + Trace("thm-ee-debug") << " normal : " << d_pattern_is_normal[rt1] << " " << d_pattern_is_normal[rt2] << std::endl; + Trace("thm-ee-debug") << " size : " << d_pattern_fun_sum[rt1] << " " << d_pattern_fun_sum[rt2] << std::endl; + + if( isUniversalLessThan( rt2, rt1 ) ){ + EqcInfo * ei; + if( it1==d_eqc_info.end() ){ + ei = getOrMakeEqcInfo( t1, true ); + }else{ + ei = it1->second; + } + ei->d_rep = t2; + } +} + +void ConjectureGenerator::eqNotifyPostMerge(TNode t1, TNode t2) { + +} + +void ConjectureGenerator::eqNotifyDisequal(TNode t1, TNode t2, TNode reason) { + Trace("thm-ee-debug") << "UEE : disequality holds : " << t1 << " != " << t2 << std::endl; + +} + + +ConjectureGenerator::EqcInfo::EqcInfo( context::Context* c ) : d_rep( c, Node::null() ){ + +} + +ConjectureGenerator::EqcInfo* ConjectureGenerator::getOrMakeEqcInfo( TNode n, bool doMake ) { + //Assert( getUniversalRepresentative( n )==n ); + std::map< Node, EqcInfo* >::iterator eqc_i = d_eqc_info.find( n ); + if( eqc_i!=d_eqc_info.end() ){ + return eqc_i->second; + }else if( doMake ){ + EqcInfo* ei = new EqcInfo( d_quantEngine->getSatContext() ); + d_eqc_info[n] = ei; + return ei; + }else{ + return NULL; + } +} + +void ConjectureGenerator::doPendingAddUniversalTerms() { + //merge all pending equalities + while( !d_upendingAdds.empty() ){ + Trace("sg-pending") << "Add " << d_upendingAdds.size() << " pending terms..." << std::endl; + std::vector< Node > pending; + pending.insert( pending.end(), d_upendingAdds.begin(), d_upendingAdds.end() ); + d_upendingAdds.clear(); + for( unsigned i=0; i eq_terms; + d_thm_index.getEquivalentTerms( t, eq_terms ); + if( !eq_terms.empty() ){ + Trace("thm-ee-add") << "UEE : Based on theorem database, it is equivalent to " << eq_terms.size() << " terms : " << std::endl; + //add equivalent terms as equalities to universal engine + for( unsigned i=0; id_rep.get().isNull() ){ + return ei->d_rep.get(); + }else{ + return r; + } + }else{ + return n; + } +} + +eq::EqualityEngine * ConjectureGenerator::getEqualityEngine() { + return d_quantEngine->getTheoryEngine()->getMasterEqualityEngine(); +} + +bool ConjectureGenerator::areEqual( TNode n1, TNode n2 ) { + eq::EqualityEngine * ee = getEqualityEngine(); + return n1==n2 || ( ee->hasTerm( n1 ) && ee->hasTerm( n2 ) && ee->areEqual( n1, n2 ) ); +} + +bool ConjectureGenerator::areDisequal( TNode n1, TNode n2 ) { + eq::EqualityEngine * ee = getEqualityEngine(); + return n1!=n2 && ee->hasTerm( n1 ) && ee->hasTerm( n2 ) && ee->areDisequal( n1, n2, false ); +} + +TNode ConjectureGenerator::getRepresentative( TNode n ) { + eq::EqualityEngine * ee = getEqualityEngine(); + if( ee->hasTerm( n ) ){ + return ee->getRepresentative( n ); + }else{ + return n; + } +} + +TermDb * ConjectureGenerator::getTermDatabase() { + return d_quantEngine->getTermDatabase(); +} + +bool ConjectureGenerator::needsCheck( Theory::Effort e ) { + if( e==Theory::EFFORT_FULL ){ + //d_fullEffortCount++; + return d_fullEffortCount%optFullCheckFrequency()==0; + }else{ + return false; + } +} + +void ConjectureGenerator::reset_round( Theory::Effort e ) { + +} + +Node ConjectureGenerator::getFreeVar( TypeNode tn, unsigned i ) { + Assert( !tn.isNull() ); + while( d_free_var[tn].size()<=i ){ + std::stringstream oss; + oss << tn; + std::stringstream os; + os << oss.str()[0] << i; + Node x = NodeManager::currentNM()->mkBoundVar( os.str().c_str(), tn ); + d_free_var_num[x] = d_free_var[tn].size(); + d_free_var[tn].push_back( x ); + } + return d_free_var[tn][i]; +} + + + +Node ConjectureGenerator::getCanonicalTerm( TNode n, std::map< TypeNode, unsigned >& var_count, std::map< TNode, TNode >& subs ) { + Trace("ajr-temp") << "get canonical term " << n << " " << n.getKind() << " " << n.hasOperator() << std::endl; + if( n.getKind()==BOUND_VARIABLE ){ + std::map< TNode, TNode >::iterator it = subs.find( n ); + if( it==subs.end() ){ + TypeNode tn = n.getType(); + //allocate variable + unsigned vn = var_count[tn]; + var_count[tn]++; + subs[n] = getFreeVar( tn, vn ); + return subs[n]; + }else{ + return it->second; + } + }else{ + std::vector< Node > children; + if( n.getKind()!=EQUAL ){ + if( n.hasOperator() ){ + TNode op = n.getOperator(); + if( std::find( d_funcs.begin(), d_funcs.end(), op )==d_funcs.end() ){ + return Node::null(); + } + children.push_back( op ); + }else{ + return Node::null(); + } + } + for( unsigned i=0; imkNode( n.getKind(), children ); + } +} + +bool ConjectureGenerator::isHandledTerm( TNode n ){ + return !n.getAttribute(NoMatchAttribute()) && inst::Trigger::isAtomicTrigger( n ) && ( n.getKind()!=APPLY_UF || n.getOperator().getKind()!=SKOLEM ); +} + +Node ConjectureGenerator::getGroundEqc( TNode r ) { + std::map< TNode, Node >::iterator it = d_ground_eqc_map.find( r ); + return it!=d_ground_eqc_map.end() ? it->second : Node::null(); +} + +bool ConjectureGenerator::isGroundEqc( TNode r ) { + return d_ground_eqc_map.find( r )!=d_ground_eqc_map.end(); +} + +bool ConjectureGenerator::isGroundTerm( TNode n ) { + return std::find( d_ground_terms.begin(), d_ground_terms.end(), n )!=d_ground_terms.end(); +} + +void ConjectureGenerator::check( Theory::Effort e ) { + if( e==Theory::EFFORT_FULL ){ + bool doCheck = d_fullEffortCount%optFullCheckFrequency()==0; + if( d_quantEngine->hasAddedLemma() ){ + doCheck = false; + }else{ + d_fullEffortCount++; + } + if( doCheck ){ + Trace("sg-engine") << "---Subgoal engine, effort = " << e << "--- " << std::endl; + eq::EqualityEngine * ee = getEqualityEngine(); + + Trace("sg-proc") << "Get eq classes..." << std::endl; + d_op_arg_index.clear(); + d_ground_eqc_map.clear(); + d_bool_eqc[0] = Node::null(); + d_bool_eqc[1] = Node::null(); + std::vector< TNode > eqcs; + d_em.clear(); + eq::EqClassesIterator eqcs_i = eq::EqClassesIterator( ee ); + while( !eqcs_i.isFinished() ){ + TNode r = (*eqcs_i); + eqcs.push_back( r ); + if( r.getType().isBoolean() ){ + if( areEqual( r, getTermDatabase()->d_true ) ){ + d_ground_eqc_map[r] = getTermDatabase()->d_true; + d_bool_eqc[0] = r; + }else if( areEqual( r, getTermDatabase()->d_false ) ){ + d_ground_eqc_map[r] = getTermDatabase()->d_false; + d_bool_eqc[1] = r; + } + } + d_em[r] = eqcs.size(); + eq::EqClassIterator ieqc_i = eq::EqClassIterator( r, ee ); + while( !ieqc_i.isFinished() ){ + TNode n = (*ieqc_i); + if( isHandledTerm( n ) ){ + d_op_arg_index[r].addTerm( this, n ); + } + ++ieqc_i; + } + ++eqcs_i; + } + Assert( !d_bool_eqc[0].isNull() ); + Assert( !d_bool_eqc[1].isNull() ); + d_urelevant_terms.clear(); + Trace("sg-proc") << "...done get eq classes" << std::endl; + + Trace("sg-proc") << "Determine ground EQC..." << std::endl; + bool success; + do{ + success = false; + for( unsigned i=0; i args; + Trace("sg-pat-debug") << "******* Get ground term for " << r << std::endl; + Node n; + if( getTermDatabase()->isInductionTerm( r ) ){ + n = d_op_arg_index[r].getGroundTerm( this, args ); + }else{ + n = r; + } + if( !n.isNull() ){ + Trace("sg-pat") << "Ground term for eqc " << r << " : " << std::endl; + Trace("sg-pat") << " " << n << std::endl; + d_ground_eqc_map[r] = n; + success = true; + }else{ + Trace("sg-pat-debug") << "...could not find ground term." << std::endl; + } + } + } + }while( success ); + //also get ground terms + d_ground_terms.clear(); + for( unsigned i=0; id_false ); + eq::EqClassIterator eqc_i = eq::EqClassIterator( r, ee ); + while( !eqc_i.isFinished() ){ + TNode n = (*eqc_i); + if( !n.getAttribute(NoMatchAttribute()) && ( n.getKind()!=EQUAL || isFalse ) ){ + if( firstTime ){ + Trace("sg-gen-eqc") << "e" << d_em[r] << " : { " << std::endl; + firstTime = false; + } + if( n.hasOperator() ){ + Trace("sg-gen-eqc") << " (" << n.getOperator(); + getTermDatabase()->computeArgReps( n ); + for( unsigned i=0; id_arg_reps[n].size(); i++ ){ + Trace("sg-gen-eqc") << " e" << d_em[getTermDatabase()->d_arg_reps[n][i]]; + } + Trace("sg-gen-eqc") << ") :: " << n << std::endl; + }else{ + Trace("sg-gen-eqc") << " " << n << std::endl; + } + } + ++eqc_i; + } + if( !firstTime ){ + Trace("sg-gen-eqc") << "}" << std::endl; + //print out ground term + std::map< TNode, Node >::iterator it = d_ground_eqc_map.find( r ); + if( it!=d_ground_eqc_map.end() ){ + Trace("sg-gen-eqc") << "- Ground term : " << it->second << std::endl; + } + } + } + } + + Trace("sg-proc") << "Compute relevant eqc..." << std::endl; + d_relevant_eqc[0].clear(); + d_relevant_eqc[1].clear(); + for( unsigned i=0; i::iterator it = d_ground_eqc_map.find( r ); + unsigned index = 1; + if( it==d_ground_eqc_map.end() ){ + index = 0; + } + //based on unproven conjectures? TODO + d_relevant_eqc[index].push_back( r ); + } + Trace("sg-gen-tg-debug") << "Initial relevant eqc : "; + for( unsigned i=0; i::iterator it = getTermDatabase()->d_func_map_trie.begin(); it != getTermDatabase()->d_func_map_trie.end(); ++it ){ + if( !getTermDatabase()->d_op_map[it->first].empty() ){ + Node nn = getTermDatabase()->d_op_map[it->first][0]; + if( isHandledTerm( nn ) && nn.getKind()!=APPLY_SELECTOR_TOTAL && !nn.getType().isBoolean() ){ + d_funcs.push_back( it->first ); + d_typ_funcs[tnull].push_back( it->first ); + d_typ_funcs[nn.getType()].push_back( it->first ); + for( unsigned i=0; ifirst].push_back( nn[i].getType() ); + } + d_func_kind[it->first] = nn.getKind(); + Trace("sg-rel-sig") << "Will enumerate function applications of : " << it->first << ", #args = " << d_func_args[it->first].size() << ", kind = " << nn.getKind() << std::endl; + getTermDatabase()->computeUfEqcTerms( it->first ); + } + } + } + //shuffle functions + for( std::map< TypeNode, std::vector< TNode > >::iterator it = d_typ_funcs.begin(); it !=d_typ_funcs.end(); ++it ){ + std::random_shuffle( it->second.begin(), it->second.end() ); + if( it->first.isNull() ){ + Trace("sg-gen-tg-debug") << "In this order : "; + for( unsigned i=0; isecond.size(); i++ ){ + Trace("sg-gen-tg-debug") << it->second[i] << " "; + } + Trace("sg-gen-tg-debug") << std::endl; + } + } + Trace("sg-proc") << "...done collect signature information" << std::endl; + + + Trace("sg-proc") << "Build theorem index..." << std::endl; + d_ue_canon.clear(); + d_thm_index.clear(); + std::vector< Node > provenConj; + quantifiers::FirstOrderModel* m = d_quantEngine->getModel(); + for( int i=0; igetNumAssertedQuantifiers(); i++ ){ + Node q = m->getAssertedQuantifier( i ); + Trace("sg-conjecture-debug") << "Is " << q << " a relevant theorem?" << std::endl; + Node conjEq; + if( q[1].getKind()==EQUAL ){ + bool isSubsume = false; + bool inEe = false; + for( unsigned r=0; r<2; r++ ){ + TNode nl = q[1][r==0 ? 0 : 1]; + TNode nr = q[1][r==0 ? 1 : 0]; + Node eq = nl.eqNode( nr ); + if( r==1 || std::find( d_conjectures.begin(), d_conjectures.end(), q )==d_conjectures.end() ){ + //must make it canonical + std::map< TypeNode, unsigned > var_count; + std::map< TNode, TNode > subs; + Trace("sg-proc-debug") << "get canonical " << eq << std::endl; + eq = getCanonicalTerm( eq, var_count, subs ); + } + if( !eq.isNull() ){ + if( r==0 ){ + inEe = d_ee_conjectures.find( q[1] )!=d_ee_conjectures.end(); + if( !inEe ){ + //add to universal equality engine + Node nl = getUniversalRepresentative( eq[0], true ); + Node nr = getUniversalRepresentative( eq[1], true ); + if( areUniversalEqual( nl, nr ) ){ + isSubsume = true; + //set inactive (will be ignored by other modules) + d_quantEngine->getModel()->setQuantifierActive( q, false ); + }else{ + Node exp; + d_ee_conjectures[q[1]] = true; + d_uequalityEngine.assertEquality( nl.eqNode( nr ), true, exp ); + } + } + Trace("sg-conjecture") << "*** CONJECTURE : currently proven" << (isSubsume ? " and subsumed" : ""); + Trace("sg-conjecture") << " : " << q[1] << std::endl; + provenConj.push_back( q ); + } + if( !isSubsume ){ + Trace("thm-db-debug") << "Adding theorem to database " << eq[0] << " == " << eq[1] << std::endl; + d_thm_index.addTheorem( eq[0], eq[1] ); + }else{ + break; + } + }else{ + break; + } + } + } + } + //examine status of other conjectures + for( unsigned i=0; i sk; + getTermDatabase()->getSkolemConstants( q, sk, true ); + Trace("sg-conjecture") << " CONJECTURE : "; + std::vector< Node > ce; + for( unsigned j=0; j::iterator git = d_ground_eqc_map.find( rk ); + //check if it is a ground term + if( git==d_ground_eqc_map.end() ){ + Trace("sg-conjecture") << "ACTIVE : " << q; + if( Trace.isOn("sg-gen-eqc") ){ + Trace("sg-conjecture") << " { "; + for( unsigned k=0; ksecond ); + } + } + if( disproven ){ + Trace("sg-conjecture") << "disproven : " << q << " : "; + for( unsigned i=0; i " << ce[i] << " "; + } + Trace("sg-conjecture") << std::endl; + } + } + } + Trace("thm-db") << "Theorem database is : " << std::endl; + d_thm_index.debugPrint( "thm-db" ); + Trace("thm-db") << std::endl; + Trace("sg-proc") << "...done build theorem index" << std::endl; + + //clear patterns + d_patterns.clear(); + d_pattern_var_id.clear(); + d_pattern_var_duplicate.clear(); + d_pattern_is_normal.clear(); + d_pattern_fun_id.clear(); + d_pattern_fun_sum.clear(); + d_rel_patterns.clear(); + d_rel_pattern_var_sum.clear(); + d_rel_pattern_typ_index.clear(); + d_rel_pattern_subs_index.clear(); + d_gen_lat_maximal.clear(); + d_gen_lat_child.clear(); + d_gen_lat_parent.clear(); + d_gen_depth.clear(); + + //the following generates a set of relevant terms + d_use_ccand_eqc = true; + for( unsigned i=0; i<2; i++ ){ + d_ccand_eqc[i].clear(); + d_ccand_eqc[i].push_back( d_relevant_eqc[i] ); + } + d_rel_term_count = 0; + //consider all functions + d_typ_tg_funcs.clear(); + for( std::map< TypeNode, std::vector< TNode > >::iterator it = d_typ_funcs.begin(); it != d_typ_funcs.end(); ++it ){ + d_typ_tg_funcs[it->first].insert( d_typ_tg_funcs[it->first].end(), it->second.begin(), it->second.end() ); + } + std::map< TypeNode, unsigned > rt_var_max; + std::vector< TypeNode > rt_types; + //map from generalization depth to maximum depth + //std::map< unsigned, unsigned > gdepth_to_tdepth; + for( unsigned depth=1; depth<3; depth++ ){ + Assert( d_tg_alloc.empty() ); + Trace("sg-proc") << "Generate terms at depth " << depth << "..." << std::endl; + Trace("sg-rel-term") << "Relevant terms of depth " << depth << " : " << std::endl; + //set up environment + d_var_id.clear(); + d_var_limit.clear(); + d_tg_id = 0; + d_tg_gdepth = 0; + d_tg_gdepth_limit = -1; + //consider all types + d_tg_alloc[0].reset( this, TypeNode::null() ); + while( d_tg_alloc[0].getNextTerm( this, depth ) ){ + Assert( d_tg_alloc[0].getGeneralizationDepth( this )==d_tg_gdepth ); + if( d_tg_alloc[0].getDepth( this )==depth ){ + //construct term + Node nn = d_tg_alloc[0].getTerm( this ); + if( getUniversalRepresentative( nn )==nn ){ + d_rel_term_count++; + Trace("sg-rel-term") << "*** Relevant term : "; + d_tg_alloc[0].debugPrint( this, "sg-rel-term", "sg-rel-term-debug2" ); + Trace("sg-rel-term") << std::endl; + + for( unsigned r=0; r<2; r++ ){ + Trace("sg-gen-tg-eqc") << "...from equivalence classes (" << r << ") : "; + int index = d_ccand_eqc[r].size()-1; + for( unsigned j=0; j typ_to_subs_index; + std::vector< TNode > gsubs_vars; + for( std::map< TypeNode, unsigned >::iterator it = d_var_id.begin(); it != d_var_id.end(); ++it ){ + if( it->second>0 ){ + typ_to_subs_index[it->first] = sum; + sum += it->second; + for( unsigned i=0; isecond; i++ ){ + gsubs_vars.push_back( getFreeVar( it->first, i ) ); + } + } + } + d_rel_pattern_var_sum[nn] = sum; + //register the pattern + registerPattern( nn, tnn ); + Assert( d_pattern_is_normal[nn] ); + Trace("sg-gen-tg-debug") << "...done collect pattern information" << std::endl; + + //compute generalization relation + Trace("sg-gen-tg-debug") << "Build generalization information..." << std::endl; + std::map< TNode, bool > patProc; + int maxGenDepth = -1; + unsigned i = d_rel_patterns[tnn].size()-1; + for( int j=(int)(i-1); j>=0; j-- ){ + TNode np = d_rel_patterns[tnn][j]; + if( patProc.find( np )==patProc.end() ){ + Trace("sg-gen-tg-debug2") << "Check if generalized by " << np << "..." << std::endl; + if( isGeneralization( np, nn ) ){ + Trace("sg-rel-terms-debug") << " is generalized by : " << np << std::endl; + d_gen_lat_child[np].push_back( nn ); + d_gen_lat_parent[nn].push_back( np ); + if( d_gen_depth[np]>maxGenDepth ){ + maxGenDepth = d_gen_depth[np]; + } + //don't consider the transitive closure of generalizes + Trace("sg-gen-tg-debug2") << "Add generalizations" << std::endl; + addGeneralizationsOf( np, patProc ); + Trace("sg-gen-tg-debug2") << "Done add generalizations" << std::endl; + }else{ + Trace("sg-gen-tg-debug2") << " is not generalized by : " << np << std::endl; + } + } + } + if( d_gen_lat_parent[nn].empty() ){ + d_gen_lat_maximal[tnn].push_back( nn ); + } + d_gen_depth[nn] = maxGenDepth+1; + Trace("sg-rel-term-debug") << " -> generalization depth is " << d_gen_depth[nn] << " <> " << depth << std::endl; + Trace("sg-gen-tg-debug") << "...done build generalization information" << std::endl; + + //record information about types + Trace("sg-gen-tg-debug") << "Collect type information..." << std::endl; + PatternTypIndex * pti = &d_rel_pattern_typ_index; + for( std::map< TypeNode, unsigned >::iterator it = d_var_id.begin(); it != d_var_id.end(); ++it ){ + pti = &pti->d_children[it->first][it->second]; + //record maximum + if( rt_var_max.find( it->first )==rt_var_max.end() || it->second>rt_var_max[it->first] ){ + rt_var_max[it->first] = it->second; + } + } + if( std::find( rt_types.begin(), rt_types.end(), tnn )==rt_types.end() ){ + rt_types.push_back( tnn ); + } + pti->d_terms.push_back( nn ); + Trace("sg-gen-tg-debug") << "...done collect type information" << std::endl; + + Trace("sg-gen-tg-debug") << "Build substitutions for ground EQC..." << std::endl; + std::vector< TNode > gsubs_terms; + gsubs_terms.resize( gsubs_vars.size() ); + int index = d_ccand_eqc[1].size()-1; + for( unsigned j=0; j > subs; + std::map< TNode, bool > rev_subs; + //only get ground terms + unsigned mode = optFilterConfirmationOnlyGround() ? 2 : 0; + d_tg_alloc[0].resetMatching( this, r, mode ); + while( d_tg_alloc[0].getNextMatch( this, r, subs, rev_subs ) ){ + //we will be building substitutions + bool firstTime = true; + for( std::map< TypeNode, std::map< unsigned, TNode > >::iterator it = subs.begin(); it != subs.end(); ++it ){ + unsigned tindex = typ_to_subs_index[it->first]; + for( std::map< unsigned, TNode >::iterator it2 = it->second.begin(); it2 != it->second.end(); ++it2 ){ + if( !firstTime ){ + Trace("sg-gen-tg-eqc") << ", "; + }else{ + firstTime = false; + Trace("sg-gen-tg-eqc") << " "; + } + Trace("sg-gen-tg-eqc") << it->first << ":x" << it2->first << " -> " << it2->second; + Assert( tindex+it2->firstfirst] = it2->second; + } + } + Trace("sg-gen-tg-eqc") << std::endl; + d_rel_pattern_subs_index[nn].addSubstitution( r, gsubs_vars, gsubs_terms ); + } + } + Trace("sg-gen-tg-debug") << "...done build substitutions for ground EQC" << std::endl; + }else{ + Trace("sg-gen-tg-debug") << "> not canonical : " << nn << std::endl; + } + }else{ + Trace("sg-gen-tg-debug") << "> produced term at previous depth : "; + d_tg_alloc[0].debugPrint( this, "sg-gen-tg-debug", "sg-gen-tg-debug" ); + Trace("sg-gen-tg-debug") << std::endl; + } + } + Trace("sg-proc") << "...done generate terms at depth " << depth << std::endl; + + + //now generate right hand sides + + + } + Trace("sg-stats") << "--------> Total relevant patterns : " << d_rel_term_count << std::endl; + + Trace("sg-proc") << "Generate properties..." << std::endl; + //set up environment + d_use_ccand_eqc = false; + d_var_id.clear(); + d_var_limit.clear(); + for( std::map< TypeNode, unsigned >::iterator it = rt_var_max.begin(); it != rt_var_max.end(); ++it ){ + d_var_id[ it->first ] = it->second; + d_var_limit[ it->first ] = it->second; + } + //set up environment for candidate conjectures + d_cconj_at_depth.clear(); + for( unsigned i=0; i<2; i++ ){ + d_cconj[i].clear(); + } + d_cconj_rhs_paired.clear(); + unsigned totalCount = 0; + for( unsigned depth=0; depth<5; depth++ ){ + //consider types from relevant terms + std::random_shuffle( rt_types.begin(), rt_types.end() ); + for( unsigned i=0; i=0; i-- ){ + processCandidateConjecture( d_cconj_at_depth[conj_depth][i], conj_depth ); + } + Assert( d_cconj_at_depth[conj_depth].size()==sz ); + d_cconj_at_depth[conj_depth].clear(); + } + Trace("sg-proc") << "...done process candidate conjectures at RHS term depth " << depth << std::endl; + } + Trace("sg-proc") << "...done generate properties" << std::endl; + + if( !d_waiting_conjectures.empty() ){ + Trace("sg-proc") << "Generated " << d_waiting_conjectures.size() << " conjectures." << std::endl; + d_conjectures.insert( d_conjectures.end(), d_waiting_conjectures.begin(), d_waiting_conjectures.end() ); + for( unsigned i=0; imkNode( OR, d_waiting_conjectures[i].negate(), d_waiting_conjectures[i] ); + d_quantEngine->getOutputChannel().lemma( lem ); + d_quantEngine->getOutputChannel().requirePhase( d_waiting_conjectures[i], false ); + } + d_waiting_conjectures.clear(); + } + + Trace("thm-ee") << "Universal equality engine is : " << std::endl; + eq::EqClassesIterator ueqcs_i = eq::EqClassesIterator( &d_uequalityEngine ); + while( !ueqcs_i.isFinished() ){ + TNode r = (*ueqcs_i); + bool firstTime = true; + TNode rr = getUniversalRepresentative( r ); + Trace("thm-ee") << " " << r; + if( rr!=r ){ Trace("thm-ee") << " [" << rr << "]"; } + Trace("thm-ee") << " : { "; + eq::EqClassIterator ueqc_i = eq::EqClassIterator( r, &d_uequalityEngine ); + while( !ueqc_i.isFinished() ){ + TNode n = (*ueqc_i); + if( r!=n ){ + if( firstTime ){ + Trace("thm-ee") << std::endl; + firstTime = false; + } + Trace("thm-ee") << " " << n << std::endl; + } + ++ueqc_i; + } + if( !firstTime ){ Trace("thm-ee") << " "; } + Trace("thm-ee") << "}" << std::endl; + ++ueqcs_i; + } + Trace("thm-ee") << std::endl; + } + } +} + +void ConjectureGenerator::registerQuantifier( Node q ) { + +} + +void ConjectureGenerator::assertNode( Node n ) { + +} + + +unsigned ConjectureGenerator::getNumTgVars( TypeNode tn ) { + //return d_var_tg.size(); + return d_var_id[tn]; +} + +bool ConjectureGenerator::allowVar( TypeNode tn ) { + std::map< TypeNode, unsigned >::iterator it = d_var_limit.find( tn ); + if( it==d_var_limit.end() ){ + return true; + }else{ + return d_var_id[tn]second; + } +} + +void ConjectureGenerator::addVar( TypeNode tn ) { + //d_var_tg.push_back( v ); + d_var_id[tn]++; + //d_var_eq_tg.push_back( std::vector< unsigned >() ); +} + +void ConjectureGenerator::removeVar( TypeNode tn ) { + d_var_id[tn]--; + //d_var_eq_tg.pop_back(); + //d_var_tg.pop_back(); +} + +unsigned ConjectureGenerator::getNumTgFuncs( TypeNode tn ) { + return d_typ_tg_funcs[tn].size(); +} + +TNode ConjectureGenerator::getTgFunc( TypeNode tn, unsigned i ) { + return d_typ_tg_funcs[tn][i]; +} + +bool ConjectureGenerator::considerCurrentTerm() { + Assert( !d_tg_alloc.empty() ); + + //if generalization depth is too large, don't consider it + unsigned i = d_tg_alloc.size(); + Trace("sg-gen-tg-debug") << "Consider term "; + d_tg_alloc[0].debugPrint( this, "sg-gen-tg-debug", "sg-gen-tg-debug" ); + Trace("sg-gen-tg-debug") << "? curr term size = " << d_tg_alloc.size() << ", last status = " << d_tg_alloc[i-1].d_status; + Trace("sg-gen-tg-debug") << std::endl; + + Assert( d_tg_alloc[0].getGeneralizationDepth( this )==d_tg_gdepth ); + + if( d_tg_gdepth_limit>=0 && d_tg_gdepth>(unsigned)d_tg_gdepth_limit ){ + Trace("sg-gen-consider-term") << "-> generalization depth of "; + d_tg_alloc[0].debugPrint( this, "sg-gen-consider-term", "sg-gen-tg-debug" ); + Trace("sg-gen-consider-term") << " is too high " << d_tg_gdepth << " " << d_tg_alloc[0].getGeneralizationDepth( this ) << ", do not consider." << std::endl; + return false; + } + + //----optimizations + if( d_tg_alloc[i-1].d_status==1 ){ + }else if( d_tg_alloc[i-1].d_status==2 ){ + }else if( d_tg_alloc[i-1].d_status==5 ){ + }else{ + Trace("sg-gen-tg-debug") << "Bad tg: " << &d_tg_alloc[i-1] << std::endl; + Assert( false ); + } + //if equated two variables, first check if context-independent TODO + //----end optimizations + + + //check based on which candidate equivalence classes match + if( d_use_ccand_eqc ){ + Trace("sg-gen-tg-debug") << "Filter based on relevant ground EQC"; + Trace("sg-gen-tg-debug") << ", #eqc to try = " << d_ccand_eqc[0][i-1].size() << "/" << d_ccand_eqc[1][i-1].size() << std::endl; + + Assert( d_ccand_eqc[0].size()>=2 ); + Assert( d_ccand_eqc[0].size()==d_ccand_eqc[1].size() ); + Assert( d_ccand_eqc[0].size()==d_tg_id+1 ); + Assert( d_tg_id==d_tg_alloc.size() ); + for( unsigned r=0; r<2; r++ ){ + d_ccand_eqc[r][i].clear(); + } + + //re-check feasibility of EQC + for( unsigned r=0; r<2; r++ ){ + for( unsigned j=0; j > subs; + std::map< TNode, bool > rev_subs; + unsigned mode; + if( r==0 ){ + mode = optReqDistinctVarPatterns() ? 1 : 0; + }else{ + mode = (optFilterConfirmation() && optFilterConfirmationOnlyGround() ) ? 2 : 0; + } + d_tg_alloc[0].resetMatching( this, d_ccand_eqc[r][i-1][j], mode ); + if( d_tg_alloc[0].getNextMatch( this, d_ccand_eqc[r][i-1][j], subs, rev_subs ) ){ + d_ccand_eqc[r][i].push_back( d_ccand_eqc[r][i-1][j] ); + } + } + } + for( unsigned r=0; r<2; r++ ){ + Trace("sg-gen-tg-debug") << "Current eqc of type " << r << " : "; + for( unsigned j=0; j() ); + } + d_tg_id++; + }else{ + for( unsigned r=0; r<2; r++ ){ + d_ccand_eqc[r].pop_back(); + } + d_tg_id--; + Assert( d_tg_alloc.find( d_tg_id )!=d_tg_alloc.end() ); + d_tg_alloc.erase( d_tg_id ); + } +} + +unsigned ConjectureGenerator::collectFunctions( TNode opat, TNode pat, std::map< TNode, unsigned >& funcs, + std::map< TypeNode, unsigned >& mnvn, std::map< TypeNode, unsigned >& mxvn ){ + if( pat.hasOperator() ){ + funcs[pat.getOperator()]++; + unsigned sum = 1; + for( unsigned i=0; i1 ){ + //duplicate variable + d_pattern_var_duplicate[opat]++; + }else{ + //check for max/min + TypeNode tn = pat.getType(); + unsigned vn = d_free_var_num[pat]; + std::map< TypeNode, unsigned >::iterator it = mnvn.find( tn ); + if( it!=mnvn.end() ){ + if( vnsecond ){ + d_pattern_is_normal[opat] = false; + mnvn[tn] = vn; + }else if( vn>mxvn[tn] ){ + if( vn!=mxvn[tn]+1 ){ + d_pattern_is_normal[opat] = false; + } + mxvn[tn] = vn; + } + }else{ + //first variable of this type + mnvn[tn] = vn; + mxvn[tn] = vn; + } + } + } + return 1; + } +} + +void ConjectureGenerator::registerPattern( Node pat, TypeNode tpat ) { + if( std::find( d_patterns[tpat].begin(), d_patterns[tpat].end(), pat )==d_patterns[tpat].end() ){ + d_patterns[TypeNode::null()].push_back( pat ); + d_patterns[tpat].push_back( pat ); + + Assert( d_pattern_fun_id.find( pat )==d_pattern_fun_id.end() ); + Assert( d_pattern_var_id.find( pat )==d_pattern_var_id.end() ); + + //collect functions + std::map< TypeNode, unsigned > mnvn; + d_pattern_fun_sum[pat] = collectFunctions( pat, pat, d_pattern_fun_id[pat], mnvn, d_pattern_var_id[pat] ); + if( d_pattern_is_normal.find( pat )==d_pattern_is_normal.end() ){ + d_pattern_is_normal[pat] = true; + } + } +} + +bool ConjectureGenerator::isGeneralization( TNode patg, TNode pat, std::map< TNode, TNode >& subs ) { + if( patg.getKind()==BOUND_VARIABLE ){ + std::map< TNode, TNode >::iterator it = subs.find( patg ); + if( it!=subs.end() ){ + return it->second==pat; + }else{ + subs[patg] = pat; + return true; + } + }else{ + Assert( patg.hasOperator() ); + if( !pat.hasOperator() || patg.getOperator()!=pat.getOperator() ){ + return false; + }else{ + Assert( patg.getNumChildren()==pat.getNumChildren() ); + for( unsigned i=0; i& patProc ) { + patProc[pat] = true; + for( unsigned k=0; k=optFullCheckConjectures() ){ + return; + } + TNode lhs = d_cconj[0][cid]; + TNode rhs = d_cconj[1][cid]; + if( !considerCandidateConjecture( lhs, rhs ) ){ + //push to children of generalization lattice + for( unsigned i=0; i >::iterator it = d_subs_confirmWitnessDomain.begin(); it != d_subs_confirmWitnessDomain.end(); ++it ){ + if( !firstTime ){ + Trace("sg-conjecture-debug") << ", "; + } + Trace("sg-conjecture-debug") << it->first << " : " << it->second.size() << "/" << d_pattern_fun_id[lhs][it->first]; + firstTime = false; + } + Trace("sg-conjecture-debug") << std::endl; + } + /* + if( getUniversalRepresentative( lhs )!=lhs ){ + std::cout << "bad universal representative LHS : " << lhs << " " << getUniversalRepresentative( lhs ) << std::endl; + exit(0); + } + if( getUniversalRepresentative( rhs )!=rhs ){ + std::cout << "bad universal representative RHS : " << rhs << " " << getUniversalRepresentative( rhs ) << std::endl; + exit(0); + } + */ + Assert( getUniversalRepresentative( rhs )==rhs ); + Assert( getUniversalRepresentative( lhs )==lhs ); + //make universal quantified formula + Assert( std::find( d_eq_conjectures[lhs].begin(), d_eq_conjectures[lhs].end(), rhs )==d_eq_conjectures[lhs].end() ); + d_eq_conjectures[lhs].push_back( rhs ); + d_eq_conjectures[rhs].push_back( lhs ); + std::vector< Node > bvs; + for( std::map< TypeNode, unsigned >::iterator it = d_pattern_var_id[lhs].begin(); it != d_pattern_var_id[lhs].end(); ++it ){ + for( unsigned i=0; i<=it->second; i++ ){ + bvs.push_back( getFreeVar( it->first, i ) ); + } + } + Node bvl = NodeManager::currentNM()->mkNode( BOUND_VAR_LIST, bvs ); + Node conj = NodeManager::currentNM()->mkNode( FORALL, bvl, lhs.eqNode( rhs ) ); + conj = Rewriter::rewrite( conj ); + Trace("sg-conjecture-debug") << " formula is : " << conj << std::endl; + d_waiting_conjectures.push_back( conj ); + } +} + +bool ConjectureGenerator::considerCandidateConjecture( TNode lhs, TNode rhs ) { + Trace("sg-cconj-debug") << "Consider candidate conjecture : " << lhs << " == " << rhs << "?" << std::endl; + if( lhs==rhs ){ + Trace("sg-cconj-debug") << " -> trivial." << std::endl; + return false; + }else{ + if( lhs.getKind()==APPLY_CONSTRUCTOR && rhs.getKind()==APPLY_CONSTRUCTOR ){ + Trace("sg-cconj-debug") << " -> irrelevant by syntactic analysis." << std::endl; + return false; + } + //variables of LHS must subsume variables of RHS + for( std::map< TypeNode, unsigned >::iterator it = d_pattern_var_id[rhs].begin(); it != d_pattern_var_id[rhs].end(); ++it ){ + std::map< TypeNode, unsigned >::iterator itl = d_pattern_var_id[lhs].find( it->first ); + if( itl!=d_pattern_var_id[lhs].end() ){ + if( itl->secondsecond ){ + Trace("sg-cconj-debug") << " -> variables of sort " << it->first << " are not subsumed." << std::endl; + return false; + }else{ + Trace("sg-cconj-debug2") << " variables of sort " << it->first << " are : " << itl->second << " vs " << it->second << std::endl; + } + }else{ + Trace("sg-cconj-debug") << " -> has no variables of sort " << it->first << "." << std::endl; + return false; + } + } + //currently active conjecture? + std::map< Node, std::vector< Node > >::iterator iteq = d_eq_conjectures.find( lhs ); + if( iteq!=d_eq_conjectures.end() ){ + if( std::find( iteq->second.begin(), iteq->second.end(), rhs )!=iteq->second.end() ){ + Trace("sg-cconj-debug") << " -> already are considering this conjecture." << std::endl; + return false; + } + } + Trace("sg-cconj") << "Consider possible candidate conjecture : " << lhs << " == " << rhs << "?" << std::endl; + //find witness for counterexample, if possible + if( optFilterConfirmation() || optFilterFalsification() ){ + Assert( d_rel_pattern_var_sum.find( lhs )!=d_rel_pattern_var_sum.end() ); + Trace("sg-cconj-debug") << "Notify substitutions over " << d_rel_pattern_var_sum[lhs] << " variables." << std::endl; + std::map< TNode, TNode > subs; + d_subs_confirmCount = 0; + d_subs_confirmWitnessRange.clear(); + d_subs_confirmWitnessDomain.clear(); + if( !d_rel_pattern_subs_index[lhs].notifySubstitutions( this, subs, rhs, d_rel_pattern_var_sum[lhs] ) ){ + Trace("sg-cconj") << " -> found witness that falsifies the conjecture." << std::endl; + return false; + } + if( optFilterConfirmation() ){ + if( d_subs_confirmCount==0 ){ + Trace("sg-cconj") << " -> not confirmed by a ground substitutions." << std::endl; + return false; + } + } + if( optFilterConfirmationDomain() ){ + for( std::map< TNode, std::vector< TNode > >::iterator it = d_subs_confirmWitnessDomain.begin(); it != d_subs_confirmWitnessDomain.end(); ++it ){ + Assert( d_pattern_fun_id[lhs].find( it->first )!=d_pattern_fun_id[lhs].end() ); + unsigned req = d_pattern_fun_id[lhs][it->first]; + std::map< TNode, unsigned >::iterator itrf = d_pattern_fun_id[rhs].find( it->first ); + if( itrf!=d_pattern_fun_id[rhs].end() ){ + req = itrf->second>req ? itrf->second : req; + } + if( it->second.size() did not find at least " << d_pattern_fun_id[lhs][it->first] << " different values in ground substitutions for variable " << it->first << "." << std::endl; + return false; + } + } + } + } + + Trace("sg-cconj") << " -> SUCCESS." << std::endl; + if( optFilterConfirmation() || optFilterFalsification() ){ + Trace("sg-cconj") << " confirmed = " << d_subs_confirmCount << ", #witnesses range = " << d_subs_confirmWitnessRange.size() << "." << std::endl; + for( std::map< TNode, std::vector< TNode > >::iterator it = d_subs_confirmWitnessDomain.begin(); it != d_subs_confirmWitnessDomain.end(); ++it ){ + Trace("sg-cconj") << " #witnesses for " << it->first << " : " << it->second.size() << std::endl; + } + } + + return true; + } +} + + + +bool ConjectureGenerator::processCandidateConjecture2( TNode rhs, TypeNode tn, unsigned depth ) { + for( unsigned j=0; j >::iterator it = d_subs_confirmWitnessDomain.begin(); it != d_subs_confirmWitnessDomain.end(); ++it ){ + if( !firstTime ){ + Trace("sg-conjecture-debug") << ", "; + } + Trace("sg-conjecture-debug") << it->first << " : " << it->second.size() << "/" << d_pattern_fun_id[lhs][it->first]; + firstTime = false; + } + Trace("sg-conjecture-debug") << std::endl; + } + if( getUniversalRepresentative( lhs )!=lhs ){ + Trace("ajr-temp") << "bad universal representative : " << lhs << " " << getUniversalRepresentative( lhs ) << std::endl; + } + Assert( getUniversalRepresentative( rhs )==rhs ); + Assert( getUniversalRepresentative( lhs )==lhs ); + //make universal quantified formula + Assert( std::find( d_eq_conjectures[lhs].begin(), d_eq_conjectures[lhs].end(), rhs )==d_eq_conjectures[lhs].end() ); + d_eq_conjectures[lhs].push_back( rhs ); + d_eq_conjectures[rhs].push_back( lhs ); + std::vector< Node > bvs; + for( std::map< TypeNode, unsigned >::iterator it = d_pattern_var_id[lhs].begin(); it != d_pattern_var_id[lhs].end(); ++it ){ + for( unsigned i=0; i<=it->second; i++ ){ + bvs.push_back( getFreeVar( it->first, i ) ); + } + } + Node bvl = NodeManager::currentNM()->mkNode( BOUND_VAR_LIST, bvs ); + Node conj = NodeManager::currentNM()->mkNode( FORALL, bvl, lhs.eqNode( rhs ) ); + conj = Rewriter::rewrite( conj ); + Trace("sg-conjecture-debug") << " formula is : " << conj << std::endl; + d_waiting_conjectures.push_back( conj ); + return true; + } +} + + + + + + +bool ConjectureGenerator::notifySubstitution( TNode glhs, std::map< TNode, TNode >& subs, TNode rhs ) { + if( Trace.isOn("sg-cconj-debug") ){ + Trace("sg-cconj-debug") << "Ground eqc for LHS : " << glhs << ", based on substituion: " << std::endl; + for( std::map< TNode, TNode >::iterator it = subs.begin(); it != subs.end(); ++it ){ + Assert( getRepresentative( it->second )==it->second ); + Trace("sg-cconj-debug") << " " << it->first << " -> " << it->second << std::endl; + } + } + Trace("sg-cconj-debug") << "Evaluate RHS : : " << rhs << std::endl; + //get the representative of rhs with substitution subs + TNode grhs = getTermDatabase()->evaluateTerm( rhs, subs, true ); + Trace("sg-cconj-debug") << "...done evaluating term, got : " << grhs << std::endl; + if( !grhs.isNull() ){ + if( glhs!=grhs ){ + if( optFilterFalsification() ){ + Trace("sg-cconj-debug") << "Ground eqc for RHS : " << grhs << std::endl; + //check based on ground terms + std::map< TNode, Node >::iterator itl = d_ground_eqc_map.find( glhs ); + if( itl!=d_ground_eqc_map.end() ){ + std::map< TNode, Node >::iterator itr = d_ground_eqc_map.find( grhs ); + if( itr!=d_ground_eqc_map.end() ){ + Trace("sg-cconj-debug") << "We have ground terms " << itl->second << " and " << itr->second << "." << std::endl; + if( itl->second.isConst() && itr->second.isConst() ){ + Trace("sg-cconj-debug") << "...disequal constants." << std::endl; + Trace("sg-cconj-witness") << " Witness of falsification : " << itl->second << " != " << itr->second << ", substutition is : " << std::endl; + for( std::map< TNode, TNode >::iterator it = subs.begin(); it != subs.end(); ++it ){ + Trace("sg-cconj-witness") << " " << it->first << " -> " << it->second << std::endl; + } + return false; + } + } + } + } + /* + if( getEqualityEngine()->areDisequal( glhs, grhs, false ) ){ + Trace("sg-cconj-debug") << "..." << glhs << " and " << grhs << " are disequal." << std::endl; + return false; + }else{ + Trace("sg-cconj-debug") << "..." << glhs << " and " << grhs << " are not disequal." << std::endl; + } + */ + }else{ + Trace("sg-cconj-witness") << " Witnessed " << glhs << " == " << grhs << ", substutition is : " << std::endl; + for( std::map< TNode, TNode >::iterator it = subs.begin(); it != subs.end(); ++it ){ + Trace("sg-cconj-witness") << " " << it->first << " -> " << it->second << std::endl; + if( std::find( d_subs_confirmWitnessDomain[it->first].begin(), d_subs_confirmWitnessDomain[it->first].end(), it->second )==d_subs_confirmWitnessDomain[it->first].end() ){ + d_subs_confirmWitnessDomain[it->first].push_back( it->second ); + } + } + d_subs_confirmCount++; + if( std::find( d_subs_confirmWitnessRange.begin(), d_subs_confirmWitnessRange.end(), glhs )==d_subs_confirmWitnessRange.end() ){ + d_subs_confirmWitnessRange.push_back( glhs ); + } + Trace("sg-cconj-debug") << "RHS is identical." << std::endl; + } + }else{ + Trace("sg-cconj-debug") << "(could not ground eqc for RHS)." << std::endl; + } + return true; +} + + +void TermGenerator::reset( ConjectureGenerator * s, TypeNode tn ) { + Assert( d_children.empty() ); + d_typ = tn; + d_status = 0; + d_status_num = 0; + d_children.clear(); + Trace("sg-gen-tg-debug2") << "...add to context " << this << std::endl; + d_id = s->d_tg_id; + s->changeContext( true ); +} + +bool TermGenerator::getNextTerm( ConjectureGenerator * s, unsigned depth ) { + if( Trace.isOn("sg-gen-tg-debug2") ){ + Trace("sg-gen-tg-debug2") << this << " getNextTerm depth " << depth << " : status = " << d_status << ", num = " << d_status_num; + if( d_status==5 ){ + TNode f = s->getTgFunc( d_typ, d_status_num ); + Trace("sg-gen-tg-debug2") << ", f = " << f; + Trace("sg-gen-tg-debug2") << ", #args = " << s->d_func_args[f].size(); + Trace("sg-gen-tg-debug2") << ", childNum = " << d_status_child_num; + Trace("sg-gen-tg-debug2") << ", #children = " << d_children.size(); + } + Trace("sg-gen-tg-debug2") << std::endl; + } + + if( d_status==0 ){ + d_status++; + if( !d_typ.isNull() ){ + if( s->allowVar( d_typ ) ){ + //allocate variable + d_status_num = s->d_var_id[d_typ]; + s->addVar( d_typ ); + Trace("sg-gen-tg-debug2") << this << " ...return unique var #" << d_status_num << std::endl; + return s->considerCurrentTerm() ? true : getNextTerm( s, depth ); + }else{ + //check allocating new variable + d_status++; + d_status_num = -1; + s->d_tg_gdepth++; + return getNextTerm( s, depth ); + } + }else{ + d_status = 4; + d_status_num = -1; + return getNextTerm( s, depth ); + } + }else if( d_status==2 ){ + //cleanup previous information + //if( d_status_num>=0 ){ + // s->d_var_eq_tg[d_status_num].pop_back(); + //} + //check if there is another variable + if( (d_status_num+1)<(int)s->getNumTgVars( d_typ ) ){ + d_status_num++; + //we have equated two variables + //s->d_var_eq_tg[d_status_num].push_back( d_id ); + Trace("sg-gen-tg-debug2") << this << "...consider other var #" << d_status_num << std::endl; + return s->considerCurrentTerm() ? true : getNextTerm( s, depth ); + }else{ + s->d_tg_gdepth--; + d_status++; + return getNextTerm( s, depth ); + } + }else if( d_status==4 ){ + d_status++; + if( depth>0 && (d_status_num+1)<(int)s->getNumTgFuncs( d_typ ) ){ + d_status_num++; + d_status_child_num = 0; + Trace("sg-gen-tg-debug2") << this << "...consider function " << s->getTgFunc( d_typ, d_status_num ) << std::endl; + s->d_tg_gdepth++; + if( !s->considerCurrentTerm() ){ + s->d_tg_gdepth--; + //don't consider this function + d_status--; + }else{ + //we have decided on a function application + } + return getNextTerm( s, depth ); + }else{ + //do not choose function applications at depth 0 + d_status++; + return getNextTerm( s, depth ); + } + }else if( d_status==5 ){ + //iterating over arguments + TNode f = s->getTgFunc( d_typ, d_status_num ); + if( d_status_child_num<0 ){ + //no more arguments + s->d_tg_gdepth--; + d_status--; + return getNextTerm( s, depth ); + }else if( d_status_child_num==(int)s->d_func_args[f].size() ){ + d_status_child_num--; + return s->considerTermCanon( d_id ) ? true : getNextTerm( s, depth ); + //return true; + }else{ + Assert( d_status_child_num<(int)s->d_func_args[f].size() ); + if( d_status_child_num==(int)d_children.size() ){ + d_children.push_back( s->d_tg_id ); + Assert( s->d_tg_alloc.find( s->d_tg_id )==s->d_tg_alloc.end() ); + s->d_tg_alloc[d_children[d_status_child_num]].reset( s, s->d_func_args[f][d_status_child_num] ); + return getNextTerm( s, depth ); + }else{ + Assert( d_status_child_num+1==(int)d_children.size() ); + if( s->d_tg_alloc[d_children[d_status_child_num]].getNextTerm( s, depth-1 ) ){ + d_status_child_num++; + return getNextTerm( s, depth ); + }else{ + d_children.pop_back(); + d_status_child_num--; + return getNextTerm( s, depth ); + } + } + } + }else if( d_status==1 || d_status==3 ){ + if( d_status==1 ){ + s->removeVar( d_typ ); + Assert( d_status_num==(int)s->d_var_id[d_typ] ); + //check if there is only one feasible equivalence class. if so, don't make pattern any more specific. + //unsigned i = s->d_ccand_eqc[0].size()-1; + //if( s->d_ccand_eqc[0][i].size()==1 && s->d_ccand_eqc[1][i].empty() ){ + // Trace("ajr-temp") << "Apply this!" << std::endl; + // d_status = 6; + // return getNextTerm( s, depth ); + //} + s->d_tg_gdepth++; + } + d_status++; + d_status_num = -1; + return getNextTerm( s, depth ); + }else{ + //clean up + Assert( d_children.empty() ); + Trace("sg-gen-tg-debug2") << "...remove from context " << this << std::endl; + s->changeContext( false ); + Assert( d_id==s->d_tg_id ); + return false; + } +} + +void TermGenerator::resetMatching( ConjectureGenerator * s, TNode eqc, unsigned mode ) { + d_match_status = 0; + d_match_status_child_num = 0; + d_match_children.clear(); + d_match_children_end.clear(); + d_match_mode = mode; +} + +bool TermGenerator::getNextMatch( ConjectureGenerator * s, TNode eqc, std::map< TypeNode, std::map< unsigned, TNode > >& subs, std::map< TNode, bool >& rev_subs ) { + if( Trace.isOn("sg-gen-tg-match") ){ + Trace("sg-gen-tg-match") << "Matching "; + debugPrint( s, "sg-gen-tg-match", "sg-gen-tg-match" ); + Trace("sg-gen-tg-match") << " with eqc e" << s->d_em[eqc] << "..." << std::endl; + Trace("sg-gen-tg-match") << " mstatus = " << d_match_status; + if( d_status==5 ){ + TNode f = s->getTgFunc( d_typ, d_status_num ); + Trace("sg-gen-tg-debug2") << ", f = " << f; + Trace("sg-gen-tg-debug2") << ", #args = " << s->d_func_args[f].size(); + Trace("sg-gen-tg-debug2") << ", mchildNum = " << d_match_status_child_num; + Trace("sg-gen-tg-debug2") << ", #mchildren = " << d_match_children.size(); + } + Trace("sg-gen-tg-debug2") << ", current substitution : {"; + for( std::map< TypeNode, std::map< unsigned, TNode > >::iterator itt = subs.begin(); itt != subs.end(); ++itt ){ + for( std::map< unsigned, TNode >::iterator it = itt->second.begin(); it != itt->second.end(); ++it ){ + Trace("sg-gen-tg-debug2") << " " << it->first << " -> e" << s->d_em[it->second]; + } + } + Trace("sg-gen-tg-debug2") << " } " << std::endl; + } + if( d_status==1 ){ + //a variable + if( d_match_status==0 ){ + d_match_status++; + if( d_match_mode>=2 ){ + //only ground terms + if( !s->isGroundEqc( eqc ) ){ + return false; + } + } + if( d_match_mode%2==1 ){ + std::map< TNode, bool >::iterator it = rev_subs.find( eqc ); + if( it==rev_subs.end() ){ + rev_subs[eqc] = true; + }else{ + return false; + } + } + Assert( subs[d_typ].find( d_status_num )==subs[d_typ].end() ); + subs[d_typ][d_status_num] = eqc; + return true; + }else{ + //clean up + subs[d_typ].erase( d_status_num ); + if( d_match_mode%2==1 ){ + rev_subs.erase( eqc ); + } + return false; + } + }else if( d_status==2 ){ + if( d_match_status==0 ){ + d_match_status++; + Assert( d_status_num<(int)s->getNumTgVars( d_typ ) ); + std::map< unsigned, TNode >::iterator it = subs[d_typ].find( d_status_num ); + Assert( it!=subs[d_typ].end() ); + return it->second==eqc; + }else{ + return false; + } + }else if( d_status==5 ){ + //Assert( d_match_children.size()<=d_children.size() ); + //enumerating over f-applications in eqc + if( d_match_status_child_num<0 ){ + return false; + }else if( d_match_status==0 ){ + //set up next binding + if( d_match_status_child_num==(int)d_match_children.size() ){ + if( d_match_status_child_num==0 ){ + //initial binding + TNode f = s->getTgFunc( d_typ, d_status_num ); + std::map< TNode, TermArgTrie >::iterator it = s->getTermDatabase()->d_func_map_eqc_trie[f].d_data.find( eqc ); + if( it!=s->getTermDatabase()->d_func_map_eqc_trie[f].d_data.end() ){ + d_match_children.push_back( it->second.d_data.begin() ); + d_match_children_end.push_back( it->second.d_data.end() ); + }else{ + d_match_status++; + d_match_status_child_num--; + return getNextMatch( s, eqc, subs, rev_subs ); + } + }else{ + d_match_children.push_back( d_match_children[d_match_status_child_num-1]->second.d_data.begin() ); + d_match_children_end.push_back( d_match_children[d_match_status_child_num-1]->second.d_data.end() ); + } + } + d_match_status++; + Assert( d_match_status_child_num+1==(int)d_match_children.size() ); + if( d_match_children[d_match_status_child_num]==d_match_children_end[d_match_status_child_num] ){ + //no more arguments to bind + d_match_children.pop_back(); + d_match_children_end.pop_back(); + d_match_status_child_num--; + return getNextMatch( s, eqc, subs, rev_subs ); + }else{ + if( d_match_status_child_num==(int)d_children.size() ){ + //successfully matched all children + d_match_children.pop_back(); + d_match_children_end.pop_back(); + d_match_status_child_num--; + return true;//return d_match_children[d_match_status]!=d_match_children_end[d_match_status]; + }else{ + //do next binding + s->d_tg_alloc[d_children[d_match_status_child_num]].resetMatching( s, d_match_children[d_match_status_child_num]->first, d_match_mode ); + return getNextMatch( s, eqc, subs, rev_subs ); + } + } + }else{ + Assert( d_match_status==1 ); + Assert( d_match_status_child_num+1==(int)d_match_children.size() ); + Assert( d_match_children[d_match_status_child_num]!=d_match_children_end[d_match_status_child_num] ); + d_match_status--; + if( s->d_tg_alloc[d_children[d_match_status_child_num]].getNextMatch( s, d_match_children[d_match_status_child_num]->first, subs, rev_subs ) ){ + d_match_status_child_num++; + return getNextMatch( s, eqc, subs, rev_subs ); + }else{ + //iterate + d_match_children[d_match_status_child_num]++; + return getNextMatch( s, eqc, subs, rev_subs ); + } + } + } + Assert( false ); + return false; +} + +unsigned TermGenerator::getDepth( ConjectureGenerator * s ) { + if( d_status==5 ){ + unsigned maxd = 0; + for( unsigned i=0; id_tg_alloc[d_children[i]].getDepth( s ); + if( d>maxd ){ + maxd = d; + } + } + return 1+maxd; + }else{ + return 0; + } +} + +unsigned TermGenerator::getGeneralizationDepth( ConjectureGenerator * s ) { + if( d_status==5 ){ + unsigned sum = 1; + for( unsigned i=0; id_tg_alloc[d_children[i]].getGeneralizationDepth( s ); + } + return sum; + }else if( d_status==2 ){ + return 1; + }else{ + Assert( d_status==1 ); + return 0; + } +} + +Node TermGenerator::getTerm( ConjectureGenerator * s ) { + if( d_status==1 || d_status==2 ){ + Assert( !d_typ.isNull() ); + return s->getFreeVar( d_typ, d_status_num ); + }else if( d_status==5 ){ + Node f = s->getTgFunc( d_typ, d_status_num ); + if( d_children.size()==s->d_func_args[f].size() ){ + std::vector< Node > children; + children.push_back( f ); + for( unsigned i=0; id_tg_alloc[d_children[i]].getTerm( s ); + if( nc.isNull() ){ + return Node::null(); + }else{ + //Assert( nc.getType()==s->d_func_args[f][i] ); + children.push_back( nc ); + } + } + return NodeManager::currentNM()->mkNode( s->d_func_kind[f], children ); + } + }else{ + Assert( false ); + } + return Node::null(); +} + +/* +int TermGenerator::getActiveChild( ConjectureGenerator * s ) { + if( d_status==1 || d_status==2 ){ + return d_id; + }else if( d_status==5 ){ + Node f = s->getTgFunc( d_typ, d_status_num ); + int i = d_children.size()-1; + if( d_children.size()==s->d_func_args[f].size() ){ + if( d_children.empty() ){ + return d_id; + }else{ + int cac = s->d_tg_alloc[d_children[i]].getActiveChild( s ); + return cac==(int)d_children[i] ? d_id : cac; + } + }else if( !d_children.empty() ){ + return s->d_tg_alloc[d_children[i]].getActiveChild( s ); + } + }else{ + Assert( false ); + } + return -1; +} +*/ + +void TermGenerator::debugPrint( ConjectureGenerator * s, const char * c, const char * cd ) { + Trace(cd) << "[*" << d_id << "," << d_status << "]:"; + if( d_status==1 || d_status==2 ){ + Trace(c) << s->getFreeVar( d_typ, d_status_num ); + }else if( d_status==5 ){ + TNode f = s->getTgFunc( d_typ, d_status_num ); + Trace(c) << "(" << f; + for( unsigned i=0; id_tg_alloc[d_children[i]].debugPrint( s, c, cd ); + } + if( d_children.size()d_func_args[f].size() ){ + Trace(c) << " ..."; + } + Trace(c) << ")"; + }else{ + Trace(c) << "???"; + } +} + + +void SubstitutionIndex::addSubstitution( TNode eqc, std::vector< TNode >& vars, std::vector< TNode >& terms, unsigned i ) { + if( i==vars.size() ){ + d_var = eqc; + }else{ + Assert( d_var.isNull() || d_var==vars[i] ); + d_var = vars[i]; + d_children[terms[i]].addSubstitution( eqc, vars, terms, i+1 ); + } +} + +bool SubstitutionIndex::notifySubstitutions( ConjectureGenerator * s, std::map< TNode, TNode >& subs, TNode rhs, unsigned numVars, unsigned i ) { + if( i==numVars ){ + Assert( d_children.empty() ); + return s->notifySubstitution( d_var, subs, rhs ); + }else{ + Assert( i==0 || !d_children.empty() ); + for( std::map< TNode, SubstitutionIndex >::iterator it = d_children.begin(); it != d_children.end(); ++it ){ + Trace("sg-cconj-debug2") << "Try " << d_var << " -> " << it->first << " (" << i << "/" << numVars << ")" << std::endl; + subs[d_var] = it->first; + if( !it->second.notifySubstitutions( s, subs, rhs, numVars, i+1 ) ){ + return false; + } + } + return true; + } +} + + +void TheoremIndex::addTheorem( std::vector< TNode >& lhs_v, std::vector< unsigned >& lhs_arg, TNode rhs ){ + if( lhs_v.empty() ){ + if( std::find( d_terms.begin(), d_terms.end(), rhs )==d_terms.end() ){ + d_terms.push_back( rhs ); + } + }else{ + unsigned index = lhs_v.size()-1; + if( lhs_arg[index]==lhs_v[index].getNumChildren() ){ + lhs_v.pop_back(); + lhs_arg.pop_back(); + addTheorem( lhs_v, lhs_arg, rhs ); + }else{ + lhs_arg[index]++; + addTheoremNode( lhs_v[index][lhs_arg[index]-1], lhs_v, lhs_arg, rhs ); + } + } +} + +void TheoremIndex::addTheoremNode( TNode curr, std::vector< TNode >& lhs_v, std::vector< unsigned >& lhs_arg, TNode rhs ){ + Trace("thm-db-debug") << "Adding conjecture for subterm " << curr << "..." << std::endl; + if( curr.hasOperator() ){ + lhs_v.push_back( curr ); + lhs_arg.push_back( 0 ); + d_children[curr.getOperator()].addTheorem( lhs_v, lhs_arg, rhs ); + }else{ + Assert( curr.getKind()==kind::BOUND_VARIABLE ); + Assert( d_var.isNull() || d_var==curr ); + d_var = curr; + d_children[curr].addTheorem( lhs_v, lhs_arg, rhs ); + } +} + +void TheoremIndex::getEquivalentTerms( std::vector< TNode >& n_v, std::vector< unsigned >& n_arg, + std::map< TNode, TNode >& smap, std::vector< TNode >& vars, std::vector< TNode >& subs, + std::vector< Node >& terms ) { + Trace("thm-db-debug") << "Get equivalent terms " << n_v.size() << " " << n_arg.size() << std::endl; + if( n_v.empty() ){ + Trace("thm-db-debug") << "Number of terms : " << d_terms.size() << std::endl; + //apply substutitions to RHS's + for( unsigned i=0; i& n_v, std::vector< unsigned >& n_arg, + std::map< TNode, TNode >& smap, std::vector< TNode >& vars, std::vector< TNode >& subs, + std::vector< Node >& terms ) { + Trace("thm-db-debug") << "Get equivalent based on subterm " << curr << "..." << std::endl; + if( curr.hasOperator() ){ + Trace("thm-db-debug") << "Check based on operator..." << std::endl; + std::map< TNode, TheoremIndex >::iterator it = d_children.find( curr.getOperator() ); + if( it!=d_children.end() ){ + n_v.push_back( curr ); + n_arg.push_back( 0 ); + it->second.getEquivalentTerms( n_v, n_arg, smap, vars, subs, terms ); + } + Trace("thm-db-debug") << "...done check based on operator" << std::endl; + } + if( !d_var.isNull() ){ + Trace("thm-db-debug") << "Check for substitution with " << d_var << "..." << std::endl; + if( curr.getType()==d_var.getType() ){ + //add to substitution if possible + bool success = false; + std::map< TNode, TNode >::iterator it = smap.find( d_var ); + if( it==smap.end() ){ + smap[d_var] = curr; + vars.push_back( d_var ); + subs.push_back( curr ); + success = true; + }else if( it->second==curr ){ + success = true; + }else{ + //also check modulo equality (in universal equality engine) + } + Trace("thm-db-debug") << "...check for substitution with " << d_var << ", success = " << success << "." << std::endl; + if( success ){ + d_children[d_var].getEquivalentTerms( n_v, n_arg, smap, vars, subs, terms ); + } + } + } +} + +void TheoremIndex::debugPrint( const char * c, unsigned ind ) { + for( std::map< TNode, TheoremIndex >::iterator it = d_children.begin(); it != d_children.end(); ++it ){ + for( unsigned i=0; ifirst << std::endl; + it->second.debugPrint( c, ind+1 ); + } + if( !d_terms.empty() ){ + for( unsigned i=0; i d_child; + std::vector< TNode > d_ops; + std::vector< TNode > d_op_terms; + void addTerm( ConjectureGenerator * s, TNode n, unsigned index = 0 ); + Node getGroundTerm( ConjectureGenerator * s, std::vector< TNode >& args ); + void getGroundTerms( ConjectureGenerator * s, std::vector< TNode >& terms ); +}; + +class PatternTypIndex +{ +public: + std::vector< TNode > d_terms; + std::map< TypeNode, std::map< unsigned, PatternTypIndex > > d_children; + void clear() { + d_terms.clear(); + d_children.clear(); + } +}; + +class SubstitutionIndex +{ +public: + //current variable, or ground EQC if d_children.empty() + TNode d_var; + std::map< TNode, SubstitutionIndex > d_children; + //add substitution + void addSubstitution( TNode eqc, std::vector< TNode >& vars, std::vector< TNode >& terms, unsigned i = 0 ); + //notify substitutions + bool notifySubstitutions( ConjectureGenerator * s, std::map< TNode, TNode >& subs, TNode rhs, unsigned numVars, unsigned i = 0 ); +}; + +class TermGenerator +{ +public: + TermGenerator(){} + TypeNode d_typ; + unsigned d_id; + //1 : consider as unique variable + //2 : consider equal to another variable + //5 : consider a function application + unsigned d_status; + int d_status_num; + //for function applications: the number of children you have built + int d_status_child_num; + //children (pointers to TermGenerators) + std::vector< unsigned > d_children; + //possible eqc for this term + //std::vector< TNode > d_eqc; + + //match status + unsigned d_match_status; + int d_match_status_child_num; + //match mode + //1 : different variables must have different matches + //2 : variables must map to ground terms + //3 : both 1 and 2 + unsigned d_match_mode; + //children + std::vector< std::map< TNode, TermArgTrie >::iterator > d_match_children; + std::vector< std::map< TNode, TermArgTrie >::iterator > d_match_children_end; + + void reset( ConjectureGenerator * s, TypeNode tn ); + bool getNextTerm( ConjectureGenerator * s, unsigned depth ); + void resetMatching( ConjectureGenerator * s, TNode eqc, unsigned mode ); + bool getNextMatch( ConjectureGenerator * s, TNode eqc, std::map< TypeNode, std::map< unsigned, TNode > >& subs, std::map< TNode, bool >& rev_subs ); + + unsigned getDepth( ConjectureGenerator * s ); + unsigned getGeneralizationDepth( ConjectureGenerator * s ); + Node getTerm( ConjectureGenerator * s ); + + void debugPrint( ConjectureGenerator * s, const char * c, const char * cd ); +}; + + +class TheoremIndex +{ +private: + void addTheorem( std::vector< TNode >& lhs_v, std::vector< unsigned >& lhs_arg, TNode rhs ); + void addTheoremNode( TNode curr, std::vector< TNode >& lhs_v, std::vector< unsigned >& lhs_arg, TNode rhs ); + void getEquivalentTerms( std::vector< TNode >& n_v, std::vector< unsigned >& n_arg, + std::map< TNode, TNode >& smap, std::vector< TNode >& vars, std::vector< TNode >& subs, + std::vector< Node >& terms ); + void getEquivalentTermsNode( Node curr, std::vector< TNode >& n_v, std::vector< unsigned >& n_arg, + std::map< TNode, TNode >& smap, std::vector< TNode >& vars, std::vector< TNode >& subs, + std::vector< Node >& terms ); +public: + TNode d_var; + std::map< TNode, TheoremIndex > d_children; + std::vector< Node > d_terms; + + void addTheorem( TNode lhs, TNode rhs ) { + std::vector< TNode > v; + std::vector< unsigned > a; + addTheoremNode( lhs, v, a, rhs ); + } + void getEquivalentTerms( TNode n, std::vector< Node >& terms ) { + std::vector< TNode > nv; + std::vector< unsigned > na; + std::map< TNode, TNode > smap; + std::vector< TNode > vars; + std::vector< TNode > subs; + getEquivalentTermsNode( n, nv, na, smap, vars, subs, terms ); + } + void clear(){ + d_var = Node::null(); + d_children.clear(); + d_terms.clear(); + } + void debugPrint( const char * c, unsigned ind = 0 ); +}; + + + +class ConjectureGenerator : public QuantifiersModule +{ + friend class OpArgIndex; + friend class PatGen; + friend class PatternGenEqc; + friend class PatternGen; + friend class SubsEqcIndex; + friend class TermGenerator; + typedef context::CDChunkList NodeList; + typedef context::CDHashMap< Node, Node, NodeHashFunction > NodeMap; + typedef context::CDHashMap< Node, bool, NodeHashFunction > BoolMap; +//this class maintains a congruence closure for *universal* facts +private: + //notification class for equality engine + class NotifyClass : public eq::EqualityEngineNotify { + ConjectureGenerator& d_sg; + public: + NotifyClass(ConjectureGenerator& sg): d_sg(sg) {} + bool eqNotifyTriggerEquality(TNode equality, bool value) { return true; } + bool eqNotifyTriggerPredicate(TNode predicate, bool value) { return true; } + bool eqNotifyTriggerTermEquality(TheoryId tag, TNode t1, TNode t2, bool value) { return true; } + void eqNotifyConstantTermMerge(TNode t1, TNode t2) { } + void eqNotifyNewClass(TNode t) { d_sg.eqNotifyNewClass(t); } + void eqNotifyPreMerge(TNode t1, TNode t2) { d_sg.eqNotifyPreMerge(t1, t2); } + void eqNotifyPostMerge(TNode t1, TNode t2) { d_sg.eqNotifyPostMerge(t1, t2); } + void eqNotifyDisequal(TNode t1, TNode t2, TNode reason) {d_sg.eqNotifyDisequal(t1, t2, reason); } + };/* class ConjectureGenerator::NotifyClass */ + /** The notify class */ + NotifyClass d_notify; + class EqcInfo{ + public: + EqcInfo( context::Context* c ); + //representative + context::CDO< Node > d_rep; + }; + /** get or make eqc info */ + EqcInfo* getOrMakeEqcInfo( TNode n, bool doMake = false ); + /** (universal) equaltity engine */ + eq::EqualityEngine d_uequalityEngine; + /** pending adds */ + std::vector< Node > d_upendingAdds; + /** relevant terms */ + std::map< Node, bool > d_urelevant_terms; + /** information necessary for equivalence classes */ + std::map< Node, EqcInfo* > d_eqc_info; + /** called when a new equivalance class is created */ + void eqNotifyNewClass(TNode t); + /** called when two equivalance classes will merge */ + void eqNotifyPreMerge(TNode t1, TNode t2); + /** called when two equivalance classes have merged */ + void eqNotifyPostMerge(TNode t1, TNode t2); + /** called when two equivalence classes are made disequal */ + void eqNotifyDisequal(TNode t1, TNode t2, TNode reason); + /** add pending universal terms, merge equivalence classes */ + void doPendingAddUniversalTerms(); + /** are universal equal */ + bool areUniversalEqual( TNode n1, TNode n2 ); + /** are universal disequal */ + bool areUniversalDisequal( TNode n1, TNode n2 ); + /** get universal representative */ + TNode getUniversalRepresentative( TNode n, bool add = false ); + /** set relevant */ + void setUniversalRelevant( TNode n ); + /** ordering for universal terms */ + bool isUniversalLessThan( TNode rt1, TNode rt2 ); + + /** the nodes we have reported as canonical representative */ + std::vector< TNode > d_ue_canon; + /** is reported canon */ + bool isReportedCanon( TNode n ); + /** mark that term has been reported as canonical rep */ + void markReportedCanon( TNode n ); + +private: //information regarding the conjectures + /** list of all conjectures */ + std::vector< Node > d_conjectures; + /** list of all waiting conjectures */ + std::vector< Node > d_waiting_conjectures; + /** map of equality conjectures */ + std::map< Node, std::vector< Node > > d_eq_conjectures; + /** currently existing conjectures in equality engine */ + BoolMap d_ee_conjectures; + /** conjecture index */ + TheoremIndex d_thm_index; + /** the relevant equivalence classes based on the conjectures */ + std::vector< TNode > d_relevant_eqc[2]; +private: //information regarding the signature we are enumerating conjectures for + //all functions + std::vector< TNode > d_funcs; + //functions per type + std::map< TypeNode, std::vector< TNode > > d_typ_funcs; + //function to kind map + std::map< TNode, Kind > d_func_kind; + //type of each argument of the function + std::map< TNode, std::vector< TypeNode > > d_func_args; + //free variables + std::map< TypeNode, std::vector< Node > > d_free_var; + //map from free variable to FV# + std::map< TNode, unsigned > d_free_var_num; + // get canonical free variable #i of type tn + Node getFreeVar( TypeNode tn, unsigned i ); + // get maximum free variable numbers + void getMaxFreeVarNum( TNode n, std::map< TypeNode, unsigned >& mvn ); + // get canonical term, return null if it contains a term apart from handled signature + Node getCanonicalTerm( TNode n, std::map< TypeNode, unsigned >& var_count, std::map< TNode, TNode >& subs ); +private: //information regarding the terms + //relevant patterns (the LHS's) + std::map< TypeNode, std::vector< Node > > d_rel_patterns; + //total number of unique variables + std::map< TNode, unsigned > d_rel_pattern_var_sum; + //by types + PatternTypIndex d_rel_pattern_typ_index; + // substitution to ground EQC index + std::map< TNode, SubstitutionIndex > d_rel_pattern_subs_index; + //patterns (the RHS's) + std::map< TypeNode, std::vector< Node > > d_patterns; + //patterns to # variables per type + std::map< TNode, std::map< TypeNode, unsigned > > d_pattern_var_id; + // # duplicated variables + std::map< TNode, unsigned > d_pattern_var_duplicate; + // is normal pattern? (variables allocated in canonical way left to right) + std::map< TNode, bool > d_pattern_is_normal; + // patterns to a count of # operators (variables and functions) + std::map< TNode, std::map< TNode, unsigned > > d_pattern_fun_id; + // term size + std::map< TNode, unsigned > d_pattern_fun_sum; + // collect functions + unsigned collectFunctions( TNode opat, TNode pat, std::map< TNode, unsigned >& funcs, + std::map< TypeNode, unsigned >& mnvn, std::map< TypeNode, unsigned >& mxvn ); + // add pattern + void registerPattern( Node pat, TypeNode tpat ); +private: //for debugging + unsigned d_rel_term_count; + std::map< TNode, unsigned > d_em; +public: //environment for term enumeration + //the current number of enumerated variables per type + std::map< TypeNode, unsigned > d_var_id; + //the limit of number of variables per type to enumerate + std::map< TypeNode, unsigned > d_var_limit; + //the functions we can currently generate + std::map< TypeNode, std::vector< TNode > > d_typ_tg_funcs; + //the equivalence classes (if applicable) that match the currently generated term + bool d_use_ccand_eqc; + std::vector< std::vector< TNode > > d_ccand_eqc[2]; + //the term generation objects + unsigned d_tg_id; + std::map< unsigned, TermGenerator > d_tg_alloc; + unsigned d_tg_gdepth; + int d_tg_gdepth_limit; + //std::vector< std::vector< unsigned > > d_var_eq_tg; + //access functions + unsigned getNumTgVars( TypeNode tn ); + bool allowVar( TypeNode tn ); + void addVar( TypeNode tn ); + void removeVar( TypeNode tn ); + unsigned getNumTgFuncs( TypeNode tn ); + TNode getTgFunc( TypeNode tn, unsigned i ); + bool considerCurrentTerm(); + bool considerTermCanon( unsigned tg_id ); + void changeContext( bool add ); +public: //for generalization lattice + //id of maximal nodes + std::map< TypeNode, std::vector< TNode > > d_gen_lat_maximal; + //generalization lattice + std::map< TNode, std::vector< TNode > > d_gen_lat_child; + std::map< TNode, std::vector< TNode > > d_gen_lat_parent; + //generalization depth + std::map< TNode, int > d_gen_depth; + //generalizations + bool isGeneralization( TNode patg, TNode pat ) { + std::map< TNode, TNode > subs; + return isGeneralization( patg, pat, subs ); + } + bool isGeneralization( TNode patg, TNode pat, std::map< TNode, TNode >& subs ); + void addGeneralizationsOf( TNode pat, std::map< TNode, bool >& patProc ); + + //from generalization depth to relevant patterns + std::map< TypeNode, std::map< unsigned, std::vector< TNode > > > d_rel_patterns_at_depth; + + +public: //for property enumeration + //conjectures to process at a particular depth + std::map< unsigned, std::vector< unsigned > > d_cconj_at_depth; + //RHS, LHS + std::vector< TNode > d_cconj[2]; + // RHS paired + std::map< TNode, std::vector< TNode > > d_cconj_rhs_paired; + //add candidate conjecture + void addCandidateConjecture( TNode lhs, TNode rhs, unsigned depth ); + //process candidate conjecture at depth + void processCandidateConjecture( unsigned cid, unsigned depth ); + + //process candidate conjecture at depth + bool processCandidateConjecture2( TNode rhs, TypeNode tn, unsigned depth ); + //process candidate conjecture + bool processCandidateConjecture2( TNode lhs, TNode rhs ); + + //whether it should be considered + bool considerCandidateConjecture( TNode lhs, TNode rhs ); + //notified of a substitution + bool notifySubstitution( TNode glhs, std::map< TNode, TNode >& subs, TNode rhs ); + //confirmation count + unsigned d_subs_confirmCount; + //individual witnesses (for range) + std::vector< TNode > d_subs_confirmWitnessRange; + //individual witnesses (for domain) + std::map< TNode, std::vector< TNode > > d_subs_confirmWitnessDomain; +public: //for ground equivalence classes + eq::EqualityEngine * getEqualityEngine(); + bool areDisequal( TNode n1, TNode n2 ); + bool areEqual( TNode n1, TNode n2 ); + TNode getRepresentative( TNode n ); + TermDb * getTermDatabase(); +private: //information about ground equivalence classes + TNode d_bool_eqc[2]; + std::map< TNode, Node > d_ground_eqc_map; + std::vector< TNode > d_ground_terms; + //operator independent term index + std::map< TNode, OpArgIndex > d_op_arg_index; + //is handled term + bool isHandledTerm( TNode n ); + Node getGroundEqc( TNode r ); + bool isGroundEqc( TNode r ); + bool isGroundTerm( TNode n ); + // count of full effort checks + unsigned d_fullEffortCount; +public: + ConjectureGenerator( QuantifiersEngine * qe, context::Context* c ); + /* needs check */ + bool needsCheck( Theory::Effort e ); + /* reset at a round */ + void reset_round( Theory::Effort e ); + /* Call during quantifier engine's check */ + void check( Theory::Effort e ); + /* Called for new quantifiers */ + void registerQuantifier( Node q ); + void assertNode( Node n ); + /** Identify this module (for debugging, dynamic configuration, etc..) */ + std::string identify() const { return "ConjectureGenerator"; } + +//options +private: + bool optReqDistinctVarPatterns(); + bool optFilterFalsification(); + bool optFilterConfirmation(); + bool optFilterConfirmationDomain(); + bool optFilterConfirmationOnlyGround(); + bool optWaitForFullCheck(); + unsigned optFullCheckFrequency(); + unsigned optFullCheckConjectures(); +}; + + +} +} +} + +#endif diff --git a/src/theory/quantifiers/first_order_model.cpp b/src/theory/quantifiers/first_order_model.cpp index 1421c639f..0a0d4eba8 100644 --- a/src/theory/quantifiers/first_order_model.cpp +++ b/src/theory/quantifiers/first_order_model.cpp @@ -115,6 +115,24 @@ Node FirstOrderModel::getSomeDomainElement(TypeNode tn){ return d_rep_set.d_type_reps[tn][0]; } +void FirstOrderModel::reset_round() { + d_quant_active.clear(); +} + +void FirstOrderModel::setQuantifierActive( TNode q, bool active ) { + d_quant_active[q] = active; +} + +bool FirstOrderModel::isQuantifierActive( TNode q ) { + std::map< TNode, bool >::iterator it = d_quant_active.find( q ); + if( it==d_quant_active.end() ){ + return true; + }else{ + return it->second; + } +} + + FirstOrderModelIG::FirstOrderModelIG(QuantifiersEngine * qe, context::Context* c, std::string name) : FirstOrderModel(qe, c,name) { diff --git a/src/theory/quantifiers/first_order_model.h b/src/theory/quantifiers/first_order_model.h index 76c3946ce..6ad04a1e6 100644 --- a/src/theory/quantifiers/first_order_model.h +++ b/src/theory/quantifiers/first_order_model.h @@ -92,6 +92,19 @@ public: } /** get some domain element */ Node getSomeDomainElement(TypeNode tn); +private: + //list of inactive quantified formulas + std::map< TNode, bool > d_quant_active; +public: + /** reset round */ + void reset_round(); + /** set quantified formula active/inactive + * a quantified formula may be set inactive if for instance: + * - it is entailed by other quantified formulas + */ + void setQuantifierActive( TNode q, bool active ); + /** is quantified formula active */ + bool isQuantifierActive( TNode q ); };/* class FirstOrderModel */ diff --git a/src/theory/quantifiers/inst_match_generator.cpp b/src/theory/quantifiers/inst_match_generator.cpp index c024d0bab..6faa5ffca 100644 --- a/src/theory/quantifiers/inst_match_generator.cpp +++ b/src/theory/quantifiers/inst_match_generator.cpp @@ -618,13 +618,7 @@ int InstMatchGeneratorSimple::addInstantiations( Node f, InstMatch& baseMatch, Q m.add( baseMatch ); int addedLemmas = 0; - if( d_match_pattern.getType()==NodeManager::currentNM()->booleanType() ){ - for( int i=0; i<2; i++ ){ - addInstantiations( m, qe, addedLemmas, 0, &(qe->getTermDatabase()->d_pred_map_trie[i][ d_op ]) ); - } - }else{ - addInstantiations( m, qe, addedLemmas, 0, &(qe->getTermDatabase()->d_func_map_trie[ d_op ]) ); - } + addInstantiations( m, qe, addedLemmas, 0, &(qe->getTermDatabase()->d_func_map_trie[ d_op ]) ); return addedLemmas; } @@ -646,7 +640,7 @@ void InstMatchGeneratorSimple::addInstantiations( InstMatch& m, QuantifiersEngin }else{ if( d_match_pattern[argIndex].getKind()==INST_CONSTANT ){ int v = d_var_num[argIndex]; - for( std::map< Node, quantifiers::TermArgTrie >::iterator it = tat->d_data.begin(); it != tat->d_data.end(); ++it ){ + for( std::map< TNode, quantifiers::TermArgTrie >::iterator it = tat->d_data.begin(); it != tat->d_data.end(); ++it ){ Node t = it->first; Node prev = m.get( v ); //using representatives, just check if equal @@ -658,7 +652,7 @@ void InstMatchGeneratorSimple::addInstantiations( InstMatch& m, QuantifiersEngin } }else{ Node r = qe->getEqualityQuery()->getRepresentative( d_match_pattern[argIndex] ); - std::map< Node, quantifiers::TermArgTrie >::iterator it = tat->d_data.find( r ); + std::map< TNode, quantifiers::TermArgTrie >::iterator it = tat->d_data.find( r ); if( it!=tat->d_data.end() ){ addInstantiations( m, qe, addedLemmas, argIndex+1, &(it->second) ); } diff --git a/src/theory/quantifiers/instantiation_engine.cpp b/src/theory/quantifiers/instantiation_engine.cpp index 3dd4423de..2167c7c7d 100644 --- a/src/theory/quantifiers/instantiation_engine.cpp +++ b/src/theory/quantifiers/instantiation_engine.cpp @@ -53,7 +53,13 @@ void InstantiationEngine::finishInit(){ }else{ d_isup = NULL; } - d_i_ag = new InstStrategyAutoGenTriggers( d_quantEngine, Trigger::TS_ALL, 3 ); + int tstrt = Trigger::TS_ALL; + if( options::triggerSelMode()==TRIGGER_SEL_MIN ){ + tstrt = Trigger::TS_MIN_TRIGGER; + }else if( options::triggerSelMode()==TRIGGER_SEL_MAX ){ + tstrt = Trigger::TS_MAX_TRIGGER; + } + d_i_ag = new InstStrategyAutoGenTriggers( d_quantEngine, tstrt, 3 ); d_i_ag->setGenerateAdditional( true ); addInstStrategy( d_i_ag ); //addInstStrategy( new InstStrategyAddFailSplits( this, ie ) ); @@ -214,9 +220,12 @@ void InstantiationEngine::check( Theory::Effort e ){ << d_quantEngine->getModel()->getNumAssertedQuantifiers() << std::endl; for( int i=0; i<(int)d_quantEngine->getModel()->getNumAssertedQuantifiers(); i++ ){ Node n = d_quantEngine->getModel()->getAssertedQuantifier( i ); - //it is not active if we have found the skolemized negation is unsat + //it is not active if it corresponds to a rewrite rule: we will process in rewrite engine if( TermDb::isRewriteRule( n ) ){ d_quant_active[n] = false; + }else if( !d_quantEngine->getModel()->isQuantifierActive( n ) ){ + d_quant_active[n] = false; + //it is not active if we have found the skolemized negation is unsat }else if( options::cbqi() && hasAddedCbqiLemma( n ) ){ Node cel = d_quantEngine->getTermDatabase()->getCounterexampleLiteral( n ); bool active, value; @@ -248,7 +257,6 @@ void InstantiationEngine::check( Theory::Effort e ){ Debug("quantifiers") << ", ce is asserted"; } Debug("quantifiers") << std::endl; - //it is not active if it corresponds to a rewrite rule: we will process in rewrite engine }else{ d_quant_active[n] = true; if( !TermDb::hasInstConstAttr(n) ){ diff --git a/src/theory/quantifiers/modes.h b/src/theory/quantifiers/modes.h index 112e052c2..26978c8f9 100644 --- a/src/theory/quantifiers/modes.h +++ b/src/theory/quantifiers/modes.h @@ -107,6 +107,15 @@ typedef enum { USER_PAT_MODE_IGNORE, } UserPatMode; +typedef enum { + /** default for trigger selection */ + TRIGGER_SEL_DEFAULT, + /** only consider minimal terms for triggers */ + TRIGGER_SEL_MIN, + /** only consider maximal terms for triggers */ + TRIGGER_SEL_MAX, +} TriggerSelMode; + }/* CVC4::theory::quantifiers namespace */ }/* CVC4::theory namespace */ diff --git a/src/theory/quantifiers/options b/src/theory/quantifiers/options index 1cdf5e8bd..e23e70174 100644 --- a/src/theory/quantifiers/options +++ b/src/theory/quantifiers/options @@ -63,6 +63,8 @@ option relevantTriggers --relevant-triggers bool :default false prefer triggers that are more relevant based on SInE style analysis option relationalTriggers --relational-triggers bool :default false choose relational triggers such as x = f(y), x >= f(y) +option triggerSelMode --trigger-sel CVC4::theory::quantifiers::TriggerSelMode :default CVC4::theory::quantifiers::TRIGGER_SEL_DEFAULT :read-write :include "theory/quantifiers/modes.h" :handler CVC4::theory::quantifiers::stringToTriggerSelMode :handler-include "theory/quantifiers/options_handlers.h" + selection mode for triggers # Whether to consider terms in the bodies of quantifiers for matching option registerQuantBodyTerms --register-quant-body-terms bool :default false @@ -76,6 +78,9 @@ option instMaxLevel --inst-max-level=N int :default -1 option eagerInstQuant --eager-inst-quant bool :default false apply quantifier instantiation eagerly +option instNoEntail --inst-no-entail bool :read-write :default false + do not consider instances of quantified formulas that are currently entailed + option fullSaturateQuant --full-saturate-quant bool :default false when all other quantifier instantiation strategies fail, instantiate with ground terms from relevant domain, then arbitrary ground terms before answering unknown @@ -140,6 +145,8 @@ option rrOneInstPerRound --rr-one-inst-per-round bool :default false add one instance of rewrite rule per round option dtStcInduction --dt-stc-ind bool :default false - apply strengthening for existential quantification over datatypes based on structural induction + apply strengthening for existential quantification over datatypes based on structural +option conjectureGen --conjecture-gen bool :default false + generate candidate conjectures for inductive strengthening endmodule diff --git a/src/theory/quantifiers/options_handlers.h b/src/theory/quantifiers/options_handlers.h index 38567d166..86d0c27e4 100644 --- a/src/theory/quantifiers/options_handlers.h +++ b/src/theory/quantifiers/options_handlers.h @@ -152,6 +152,19 @@ ignore \n\ + Ignore user-provided patterns. \n\ \n\ "; +static const std::string triggerSelModeHelp = "\ +User pattern modes currently supported by the --trigger-sel option:\n\ +\n\ +default \n\ ++ Default, consider all subterms of quantified formulas for trigger selection.\n\ +\n\ +min \n\ ++ Consider only minimal subterms that meet criteria for triggers.\n\ +\n\ +max \n\ ++ Consider only maximal subterms that meet criteria for triggers. \n\ +\n\ +"; inline InstWhenMode stringToInstWhenMode(std::string option, std::string optarg, SmtEngine* smt) throw(OptionException) { if(optarg == "pre-full") { return INST_WHEN_PRE_FULL; @@ -296,6 +309,21 @@ inline UserPatMode stringToUserPatMode(std::string option, std::string optarg, S optarg + "'. Try --user-pat help."); } } +inline TriggerSelMode stringToTriggerSelMode(std::string option, std::string optarg, SmtEngine* smt) throw(OptionException) { + if(optarg == "default" || optarg == "all" ) { + return TRIGGER_SEL_DEFAULT; + } else if(optarg == "min") { + return TRIGGER_SEL_MIN; + } else if(optarg == "max") { + return TRIGGER_SEL_MAX; + } else if(optarg == "help") { + puts(triggerSelModeHelp.c_str()); + exit(1); + } else { + throw OptionException(std::string("unknown option for --trigger-sel: `") + + optarg + "'. Try --trigger-sel help."); + } +} }/* CVC4::theory::quantifiers namespace */ }/* CVC4::theory namespace */ }/* CVC4 namespace */ diff --git a/src/theory/quantifiers/quant_conflict_find.cpp b/src/theory/quantifiers/quant_conflict_find.cpp old mode 100644 new mode 100755 index c6e881986..4e4d92d28 --- a/src/theory/quantifiers/quant_conflict_find.cpp +++ b/src/theory/quantifiers/quant_conflict_find.cpp @@ -1,2529 +1,2247 @@ -/********************* */ -/*! \file quant_conflict_find.cpp - ** \verbatim - ** Original author: Andrew Reynolds - ** Major contributors: Morgan Deters - ** Minor contributors (to current version): none - ** This file is part of the CVC4 project. - ** Copyright (c) 2009-2014 New York University and The University of Iowa - ** See the file COPYING in the top-level source directory for licensing - ** information.\endverbatim - ** - ** \brief quant conflict find class - ** - **/ - -#include - -#include "theory/quantifiers/quant_conflict_find.h" -#include "theory/quantifiers/quant_util.h" -#include "theory/theory_engine.h" -#include "theory/quantifiers/options.h" -#include "theory/quantifiers/term_database.h" -#include "theory/quantifiers/trigger.h" - -using namespace CVC4; -using namespace CVC4::kind; -using namespace CVC4::theory; -using namespace CVC4::theory::quantifiers; -using namespace std; - -namespace CVC4 { - -Node QcfNodeIndex::existsTerm( TNode n, std::vector< TNode >& reps, int index ) { - if( index==(int)reps.size() ){ - if( d_children.empty() ){ - return Node::null(); - }else{ - return d_children.begin()->first; - } - }else{ - std::map< TNode, QcfNodeIndex >::iterator it = d_children.find( reps[index] ); - if( it==d_children.end() ){ - return Node::null(); - }else{ - return it->second.existsTerm( n, reps, index+1 ); - } - } -} - -Node QcfNodeIndex::addTerm( TNode n, std::vector< TNode >& reps, int index ) { - if( index==(int)reps.size() ){ - if( d_children.empty() ){ - d_children[ n ].clear(); - return n; - }else{ - return d_children.begin()->first; - } - }else{ - return d_children[reps[index]].addTerm( n, reps, index+1 ); - } -} - - -void QcfNodeIndex::debugPrint( const char * c, int t ) { - for( std::map< TNode, QcfNodeIndex >::iterator it = d_children.begin(); it != d_children.end(); ++it ){ - if( !it->first.isNull() ){ - for( int j=0; jfirst << " : " << std::endl; - it->second.debugPrint( c, t+1 ); - } - } -} - - -void QuantInfo::initialize( Node q, Node qn ) { - d_q = q; - for( unsigned i=0; iisValid() ){ - /* - for( unsigned j=0; jsetInvalid(); - break; - } - } - */ - if( d_mg->isValid() ){ - for( unsigned j=q[0].getNumChildren(); jisValid() ){ - Trace("qcf-invalid") << "QCF invalid : cannot match for " << d_vars[j] << std::endl; - d_mg->setInvalid(); - break; - }else{ - std::vector< int > bvars; - d_var_mg[j]->determineVariableOrder( this, bvars ); - } - } - } - if( d_mg->isValid() ){ - std::vector< int > bvars; - d_mg->determineVariableOrder( this, bvars ); - } - } - }else{ - Trace("qcf-invalid") << "QCF invalid : body of formula cannot be processed." << std::endl; - } - Trace("qcf-qregister-summary") << "QCF register : " << ( d_mg->isValid() ? "VALID " : "INVALID" ) << " : " << q << std::endl; -} - -void QuantInfo::registerNode( Node n, bool hasPol, bool pol, bool beneathQuant ) { - Trace("qcf-qregister-debug2") << "Register : " << n << std::endl; - if( n.getKind()==FORALL ){ - registerNode( n[1], hasPol, pol, true ); - }else{ - if( !MatchGen::isHandledBoolConnective( n ) ){ - if( n.hasBoundVar() ){ - //literals - if( n.getKind()==EQUAL ){ - for( unsigned i=0; id_parent = qcf; - //qcf->d_child[i] = qcfc; - registerNode( n[i], newHasPol, newPol, beneathQuant ); - } - } - } -} - -void QuantInfo::flatten( Node n, bool beneathQuant ) { - Trace("qcf-qregister-debug2") << "Flatten : " << n << std::endl; - if( n.hasBoundVar() ){ - if( n.getKind()==BOUND_VARIABLE ){ - d_inMatchConstraint[n] = true; - } - //if( MatchGen::isHandledUfTerm( n ) || n.getKind()==ITE ){ - if( d_var_num.find( n )==d_var_num.end() ){ - Trace("qcf-qregister-debug2") << "Add FLATTEN VAR : " << n << std::endl; - d_var_num[n] = d_vars.size(); - d_vars.push_back( n ); - d_match.push_back( TNode::null() ); - d_match_term.push_back( TNode::null() ); - if( n.getKind()==ITE ){ - registerNode( n, false, false ); - }else{ - for( unsigned i=0; i >::iterator it = d_var_constraint[r].begin(); - it != d_var_constraint[r].end(); ++it ){ - for( unsigned j=0; jsecond.size(); j++ ){ - Node rr = it->second[j]; - if( !isVar( rr ) ){ - rr = p->getRepresentative( rr ); - } - if( addConstraint( p, it->first, rr, r==0 )==-1 ){ - d_var_constraint[0].clear(); - d_var_constraint[1].clear(); - //quantified formula is actually equivalent to true - Trace("qcf-qregister") << "Quantifier is equivalent to true!!!" << std::endl; - d_mg->d_children.clear(); - d_mg->d_n = NodeManager::currentNM()->mkConst( true ); - d_mg->d_type = MatchGen::typ_ground; - return; - } - } - } - } - d_mg->reset_round( p ); - for( std::map< int, MatchGen * >::iterator it = d_var_mg.begin(); it != d_var_mg.end(); ++it ){ - it->second->reset_round( p ); - } - //now, reset for matching - d_mg->reset( p, false, this ); -} - -int QuantInfo::getCurrentRepVar( int v ) { - if( v!=-1 && !d_match[v].isNull() ){ - int vn = getVarNum( d_match[v] ); - if( vn!=-1 ){ - //int vr = getCurrentRepVar( vn ); - //d_match[v] = d_vars[vr]; - //return vr; - return getCurrentRepVar( vn ); - } - } - return v; -} - -TNode QuantInfo::getCurrentValue( TNode n ) { - int v = getVarNum( n ); - if( v==-1 ){ - return n; - }else{ - if( d_match[v].isNull() ){ - return n; - }else{ - Assert( getVarNum( d_match[v] )!=v ); - return getCurrentValue( d_match[v] ); - } - } -} - -TNode QuantInfo::getCurrentExpValue( TNode n ) { - int v = getVarNum( n ); - if( v==-1 ){ - return n; - }else{ - if( d_match[v].isNull() ){ - return n; - }else{ - Assert( getVarNum( d_match[v] )!=v ); - if( d_match_term[v].isNull() ){ - return getCurrentValue( d_match[v] ); - }else{ - return d_match_term[v]; - } - } - } -} - -bool QuantInfo::getCurrentCanBeEqual( QuantConflictFind * p, int v, TNode n, bool chDiseq ) { - //check disequalities - std::map< int, std::map< TNode, int > >::iterator itd = d_curr_var_deq.find( v ); - if( itd!=d_curr_var_deq.end() ){ - for( std::map< TNode, int >::iterator it = itd->second.begin(); it != itd->second.end(); ++it ){ - Node cv = getCurrentValue( it->first ); - Debug("qcf-ccbe") << "compare " << cv << " " << n << std::endl; - if( cv==n ){ - return false; - }else if( chDiseq && !isVar( n ) && !isVar( cv ) ){ - //they must actually be disequal if we are looking for conflicts - if( !p->areDisequal( n, cv ) ){ - //TODO : check for entailed disequal - - return false; - } - } - } - } - return true; -} - -int QuantInfo::addConstraint( QuantConflictFind * p, int v, TNode n, bool polarity ) { - v = getCurrentRepVar( v ); - int vn = getVarNum( n ); - vn = vn==-1 ? -1 : getCurrentRepVar( vn ); - n = getCurrentValue( n ); - return addConstraint( p, v, n, vn, polarity, false ); -} - -int QuantInfo::addConstraint( QuantConflictFind * p, int v, TNode n, int vn, bool polarity, bool doRemove ) { - //for handling equalities between variables, and disequalities involving variables - Debug("qcf-match-debug") << "- " << (doRemove ? "un" : "" ) << "constrain : " << v << " -> " << n << " (cv=" << getCurrentValue( n ) << ")"; - Debug("qcf-match-debug") << ", (vn=" << vn << "), polarity = " << polarity << std::endl; - Assert( doRemove || n==getCurrentValue( n ) ); - Assert( doRemove || v==getCurrentRepVar( v ) ); - Assert( doRemove || vn==getCurrentRepVar( getVarNum( n ) ) ); - if( polarity ){ - if( vn!=v ){ - if( doRemove ){ - if( vn!=-1 ){ - //if set to this in the opposite direction, clean up opposite instead - // std::map< int, TNode >::iterator itmn = d_match.find( vn ); - if( d_match[vn]==d_vars[v] ){ - return addConstraint( p, vn, d_vars[v], v, true, true ); - }else{ - //unsetting variables equal - std::map< int, std::map< TNode, int > >::iterator itd = d_curr_var_deq.find( vn ); - if( itd!=d_curr_var_deq.end() ){ - //remove disequalities owned by this - std::vector< TNode > remDeq; - for( std::map< TNode, int >::iterator it = itd->second.begin(); it != itd->second.end(); ++it ){ - if( it->second==v ){ - remDeq.push_back( it->first ); - } - } - for( unsigned i=0; i::iterator itm = d_match.find( v ); - - if( vn!=-1 ){ - Debug("qcf-match-debug") << " ...Variable bound to variable" << std::endl; - //std::map< int, TNode >::iterator itmn = d_match.find( vn ); - if( d_match[v].isNull() ){ - //setting variables equal - bool alreadySet = false; - if( !d_match[vn].isNull() ){ - alreadySet = true; - Assert( !isVar( d_match[vn] ) ); - } - - //copy or check disequalities - std::map< int, std::map< TNode, int > >::iterator itd = d_curr_var_deq.find( v ); - if( itd!=d_curr_var_deq.end() ){ - for( std::map< TNode, int >::iterator it = itd->second.begin(); it != itd->second.end(); ++it ){ - Node dv = getCurrentValue( it->first ); - if( !alreadySet ){ - if( d_curr_var_deq[vn].find( dv )==d_curr_var_deq[vn].end() ){ - d_curr_var_deq[vn][dv] = v; - } - }else{ - if( !p->areMatchDisequal( d_match[vn], dv ) ){ - Debug("qcf-match-debug") << " -> fail, conflicting disequality" << std::endl; - return -1; - } - } - } - } - if( alreadySet ){ - n = getCurrentValue( n ); - } - }else{ - if( d_match[vn].isNull() ){ - Debug("qcf-match-debug") << " ...Reverse direction" << std::endl; - //set the opposite direction - return addConstraint( p, vn, d_vars[v], v, true, false ); - }else{ - Debug("qcf-match-debug") << " -> Both variables bound, compare" << std::endl; - //are they currently equal - return p->areMatchEqual( d_match[v], d_match[vn] ) ? 0 : -1; - } - } - }else{ - Debug("qcf-match-debug") << " ...Variable bound to ground" << std::endl; - if( d_match[v].isNull() ){ - }else{ - //compare ground values - Debug("qcf-match-debug") << " -> Ground value, compare " << d_match[v] << " "<< n << std::endl; - return p->areMatchEqual( d_match[v], n ) ? 0 : -1; - } - } - if( setMatch( p, v, n ) ){ - Debug("qcf-match-debug") << " -> success" << std::endl; - return 1; - }else{ - Debug("qcf-match-debug") << " -> fail, conflicting disequality" << std::endl; - return -1; - } - } - }else{ - Debug("qcf-match-debug") << " -> redundant, variable identity" << std::endl; - return 0; - } - }else{ - if( vn==v ){ - Debug("qcf-match-debug") << " -> fail, variable identity" << std::endl; - return -1; - }else{ - if( doRemove ){ - Assert( d_curr_var_deq[v].find( n )!=d_curr_var_deq[v].end() ); - d_curr_var_deq[v].erase( n ); - return 1; - }else{ - if( d_curr_var_deq[v].find( n )==d_curr_var_deq[v].end() ){ - //check if it respects equality - //std::map< int, TNode >::iterator itm = d_match.find( v ); - if( !d_match[v].isNull() ){ - TNode nv = getCurrentValue( n ); - if( !p->areMatchDisequal( nv, d_match[v] ) ){ - Debug("qcf-match-debug") << " -> fail, conflicting disequality" << std::endl; - return -1; - } - } - d_curr_var_deq[v][n] = v; - Debug("qcf-match-debug") << " -> success" << std::endl; - return 1; - }else{ - Debug("qcf-match-debug") << " -> redundant disequality" << std::endl; - return 0; - } - } - } - } -} - -bool QuantInfo::isConstrainedVar( int v ) { - if( d_curr_var_deq.find( v )!=d_curr_var_deq.end() && !d_curr_var_deq[v].empty() ){ - return true; - }else{ - Node vv = getVar( v ); - //for( std::map< int, TNode >::iterator it = d_match.begin(); it != d_match.end(); ++it ){ - for( unsigned i=0; i >::iterator it = d_curr_var_deq.begin(); it != d_curr_var_deq.end(); ++it ){ - for( std::map< TNode, int >::iterator it2 = it->second.begin(); it2 != it->second.end(); ++it2 ){ - if( it2->first==vv ){ - return true; - } - } - } - return false; - } -} - -bool QuantInfo::setMatch( QuantConflictFind * p, int v, TNode n ) { - if( getCurrentCanBeEqual( p, v, n ) ){ - Debug("qcf-match-debug") << "-- bind : " << v << " -> " << n << ", checked " << d_curr_var_deq[v].size() << " disequalities" << std::endl; - d_match[v] = n; - return true; - }else{ - return false; - } -} - -bool QuantInfo::isMatchSpurious( QuantConflictFind * p ) { - for( int i=0; i::iterator it = d_match.find( i ); - if( !d_match[i].isNull() ){ - if( !getCurrentCanBeEqual( p, i, d_match[i], p->d_effort==QuantConflictFind::effort_conflict ) ){ - return true; - } - } - } - return false; -} - -bool QuantInfo::isTConstraintSpurious( QuantConflictFind * p, std::vector< Node >& terms ) { - if( !d_tconstraints.empty() ){ - //check constraints - for( std::map< Node, bool >::iterator it = d_tconstraints.begin(); it != d_tconstraints.end(); ++it ){ - //apply substitution to the tconstraint - Node cons = it->first.substitute( p->getQuantifiersEngine()->getTermDatabase()->d_vars[d_q].begin(), - p->getQuantifiersEngine()->getTermDatabase()->d_vars[d_q].end(), - terms.begin(), terms.end() ); - cons = it->second ? cons : cons.negate(); - if( !entailmentTest( p, cons, p->d_effort==QuantConflictFind::effort_conflict ) ){ - return true; - } - } - } - return false; -} - -bool QuantInfo::entailmentTest( QuantConflictFind * p, Node lit, bool chEnt ) { - Trace("qcf-tconstraint-debug") << "Check : " << lit << std::endl; - Node rew = Rewriter::rewrite( lit ); - if( rew==p->d_false ){ - Trace("qcf-tconstraint-debug") << "...constraint " << lit << " is disentailed (rewrites to false)." << std::endl; - return false; - }else if( rew!=p->d_true ){ - //if checking for conflicts, we must be sure that the constraint is entailed - if( chEnt ){ - //check if it is entailed - Trace("qcf-tconstraint-debug") << "Check entailment of " << rew << "..." << std::endl; - std::pair et = p->getQuantifiersEngine()->getTheoryEngine()->entailmentCheck(THEORY_OF_TYPE_BASED, rew ); - ++(p->d_statistics.d_entailment_checks); - Trace("qcf-tconstraint-debug") << "ET result : " << et.first << " " << et.second << std::endl; - if( !et.first ){ - Trace("qcf-tconstraint-debug") << "...cannot show entailment of " << rew << "." << std::endl; - return false; - }else{ - return true; - } - }else{ - Trace("qcf-tconstraint-debug") << "...does not need to be entailed." << std::endl; - return true; - } - }else{ - Trace("qcf-tconstraint-debug") << "...rewrites to true." << std::endl; - return true; - } -} - -bool QuantInfo::completeMatch( QuantConflictFind * p, std::vector< int >& assigned, bool doContinue ) { - //assign values for variables that were unassigned (usually not necessary, but handles corner cases) - bool doFail = false; - bool success = true; - if( doContinue ){ - doFail = true; - success = false; - }else{ - //solve for interpreted symbol matches - // this breaks the invariant that all introduced constraints are over existing terms - for( int i=(int)(d_tsym_vars.size()-1); i>=0; i-- ){ - int index = d_tsym_vars[i]; - TNode v = getCurrentValue( d_vars[index] ); - int slv_v = -1; - if( v==d_vars[index] ){ - slv_v = index; - } - Trace("qcf-tconstraint-debug") << "Solve " << d_vars[index] << " = " << v << " " << d_vars[index].getKind() << std::endl; - if( d_vars[index].getKind()==PLUS || d_vars[index].getKind()==MULT ){ - Kind k = d_vars[index].getKind(); - std::vector< TNode > children; - for( unsigned j=0; jd_effort!=QuantConflictFind::effort_conflict ){ - break; - } - }else{ - Node z = p->getZero( k ); - if( !z.isNull() ){ - Trace("qcf-tconstraint-debug") << "...set " << d_vars[vn] << " = " << z << std::endl; - assigned.push_back( vn ); - if( !setMatch( p, vn, z ) ){ - success = false; - break; - } - } - } - }else{ - Trace("qcf-tconstraint-debug") << "...sum value " << vv << std::endl; - children.push_back( vv ); - } - }else{ - Trace("qcf-tconstraint-debug") << "...sum " << d_vars[index][j] << std::endl; - children.push_back( d_vars[index][j] ); - } - } - if( success ){ - if( slv_v!=-1 ){ - Node lhs; - if( children.empty() ){ - lhs = p->getZero( k ); - }else if( children.size()==1 ){ - lhs = children[0]; - }else{ - lhs = NodeManager::currentNM()->mkNode( k, children ); - } - Node sum; - if( v==d_vars[index] ){ - sum = lhs; - }else{ - if( p->d_effort==QuantConflictFind::effort_conflict ){ - Kind kn = k; - if( d_vars[index].getKind()==PLUS ){ - kn = MINUS; - } - if( kn!=k ){ - sum = NodeManager::currentNM()->mkNode( kn, v, lhs ); - } - } - } - if( !sum.isNull() ){ - assigned.push_back( slv_v ); - Trace("qcf-tconstraint-debug") << "...set " << d_vars[slv_v] << " = " << sum << std::endl; - if( !setMatch( p, slv_v, sum ) ){ - success = false; - } - p->d_tempCache.push_back( sum ); - } - }else{ - //must show that constraint is met - Node sum = NodeManager::currentNM()->mkNode( k, children ); - Node eq = sum.eqNode( v ); - if( !entailmentTest( p, eq ) ){ - success = false; - } - p->d_tempCache.push_back( sum ); - } - } - } - - if( !success ){ - break; - } - } - if( success ){ - //check what is left to assign - d_unassigned.clear(); - d_unassigned_tn.clear(); - std::vector< int > unassigned[2]; - std::vector< TypeNode > unassigned_tn[2]; - for( int i=0; i=0 && (int)d_una_index<(int)d_unassigned.size() ) || invalidMatch || doFail ){ - invalidMatch = false; - if( !doFail && d_una_index==(int)d_una_eqc_count.size() ){ - //check if it has now been assigned - if( d_una_indexreset( p, true, this ); - d_una_eqc_count.push_back( 0 ); - } - }else{ - d_una_eqc_count.push_back( 0 ); - } - }else{ - bool failed = false; - if( !doFail ){ - if( d_una_indexgetNextMatch( p, this ) ){ - Trace("qcf-check-unassign") << "Succeeded match with mg at " << d_una_index << std::endl; - d_una_index++; - }else{ - failed = true; - Trace("qcf-check-unassign") << "Failed match with mg at " << d_una_index << std::endl; - } - }else{ - Assert( doFail || d_una_index==(int)d_una_eqc_count.size()-1 ); - if( d_una_eqc_count[d_una_index]<(int)p->d_eqcs[d_unassigned_tn[d_una_index]].size() ){ - int currIndex = d_una_eqc_count[d_una_index]; - d_una_eqc_count[d_una_index]++; - Trace("qcf-check-unassign") << d_unassigned[d_una_index] << "->" << p->d_eqcs[d_unassigned_tn[d_una_index]][currIndex] << std::endl; - if( setMatch( p, d_unassigned[d_una_index], p->d_eqcs[d_unassigned_tn[d_una_index]][currIndex] ) ){ - d_match_term[d_unassigned[d_una_index]] = TNode::null(); - Trace("qcf-check-unassign") << "Succeeded match " << d_una_index << std::endl; - d_una_index++; - }else{ - Trace("qcf-check-unassign") << "Failed match " << d_una_index << std::endl; - invalidMatch = true; - } - }else{ - failed = true; - Trace("qcf-check-unassign") << "No more matches " << d_una_index << std::endl; - } - } - } - if( doFail || failed ){ - do{ - if( !doFail ){ - d_una_eqc_count.pop_back(); - }else{ - doFail = false; - } - d_una_index--; - }while( d_una_index>=0 && d_una_eqc_count[d_una_index]==-1 ); - } - } - } - success = d_una_index>=0; - if( success ){ - doFail = true; - Trace("qcf-check-unassign") << " Try: " << std::endl; - for( unsigned i=0; i " << d_match[ui] << std::endl; - } - } - } - }while( success && isMatchSpurious( p ) ); - } - if( success ){ - for( unsigned i=0; i " << d_match[ui] << std::endl; - } - } - return true; - }else{ - for( unsigned i=0; i& terms ){ - for( unsigned i=0; igetCurrentValue( qi->d_match[i] ); - int repVar = getCurrentRepVar( i ); - Node cv; - //std::map< int, TNode >::iterator itmt = qi->d_match_term.find( repVar ); - if( !d_match_term[repVar].isNull() ){ - cv = d_match_term[repVar]; - }else{ - cv = d_match[repVar]; - } - Debug("qcf-check-inst") << "INST : " << i << " -> " << cv << ", from " << d_match[i] << std::endl; - terms.push_back( cv ); - } -} - -void QuantInfo::revertMatch( std::vector< int >& assigned ) { - for( unsigned i=0; i "; - if( !d_match[i].isNull() ){ - Trace(c) << d_match[i]; - }else{ - Trace(c) << "(unassigned) "; - } - if( !d_curr_var_deq[i].empty() ){ - Trace(c) << ", DEQ{ "; - for( std::map< TNode, int >::iterator it = d_curr_var_deq[i].begin(); it != d_curr_var_deq[i].end(); ++it ){ - Trace(c) << it->first << " "; - } - Trace(c) << "}"; - } - if( !d_match_term[i].isNull() && d_match_term[i]!=d_match[i] ){ - Trace(c) << ", EXP : " << d_match_term[i]; - } - Trace(c) << std::endl; - } - if( !d_tconstraints.empty() ){ - Trace(c) << "ADDITIONAL CONSTRAINTS : " << std::endl; - for( std::map< Node, bool >::iterator it = d_tconstraints.begin(); it != d_tconstraints.end(); ++it ){ - Trace(c) << " " << it->first << " -> " << it->second << std::endl; - } - } -} - -MatchGen::MatchGen( QuantInfo * qi, Node n, bool isVar ){ - Trace("qcf-qregister-debug") << "Make match gen for " << n << ", isVar = " << isVar << std::endl; - std::vector< Node > qni_apps; - d_qni_size = 0; - if( isVar ){ - Assert( qi->d_var_num.find( n )!=qi->d_var_num.end() ); - if( n.getKind()==ITE ){ - d_type = typ_ite_var; - d_type_not = false; - d_n = n; - d_children.push_back( MatchGen( qi, d_n[0] ) ); - if( d_children[0].isValid() ){ - d_type = typ_ite_var; - for( unsigned i=1; i<=2; i++ ){ - Node nn = n.eqNode( n[i] ); - d_children.push_back( MatchGen( qi, nn ) ); - d_children[d_children.size()-1].d_qni_bound_except.push_back( 0 ); - if( !d_children[d_children.size()-1].isValid() ){ - setInvalid(); - break; - } - } - }else{ - d_type = typ_invalid; - } - }else{ - d_type = isHandledUfTerm( n ) ? typ_var : typ_tsym; - d_qni_var_num[0] = qi->getVarNum( n ); - d_qni_size++; - d_type_not = false; - d_n = n; - //Node f = getOperator( n ); - for( unsigned j=0; jisVar( nn ) ){ - int v = qi->d_var_num[nn]; - Trace("qcf-qregister-debug") << " is var #" << v << std::endl; - d_qni_var_num[d_qni_size] = v; - //qi->addFuncParent( v, f, j ); - }else{ - Trace("qcf-qregister-debug") << " is gterm " << nn << std::endl; - d_qni_gterm[d_qni_size] = nn; - } - d_qni_size++; - } - } - }else{ - if( n.hasBoundVar() ){ - d_type_not = false; - d_n = n; - if( d_n.getKind()==NOT ){ - d_n = d_n[0]; - d_type_not = !d_type_not; - } - - if( isHandledBoolConnective( d_n ) ){ - //non-literals - d_type = typ_formula; - for( unsigned i=0; id_qinfo[q].isVar( cn[0] ) || p->d_qinfo[q].isVar( cn[1] ) ); - //make it a built-in constraint instead - for( unsigned i=0; i<2; i++ ){ - if( p->d_qinfo[q].isVar( cn[i] ) ){ - int v = p->d_qinfo[q].getVarNum( cn[i] ); - Node cno = cn[i==0 ? 1 : 0]; - p->d_qinfo[q].d_var_constraint[ cIsNot ? 0 : 1 ][v].push_back( cno ); - break; - } - } - d_children.pop_back(); - } - */ - } - }else{ - d_type = typ_invalid; - //literals - if( isHandledUfTerm( d_n ) ){ - Assert( qi->isVar( d_n ) ); - d_type = typ_pred; - }else if( d_n.getKind()==BOUND_VARIABLE ){ - Assert( d_n.getType().isBoolean() ); - d_type = typ_bool_var; - }else if( d_n.getKind()==EQUAL || options::qcfTConstraint() ){ - for( unsigned i=0; iisVar( d_n[i] ) ){ - Trace("qcf-qregister-debug") << "ERROR : not var " << d_n[i] << std::endl; - } - Assert( qi->isVar( d_n[i] ) ); - if( d_n.getKind()!=EQUAL && qi->isVar( d_n[i] ) ){ - d_qni_var_num[i+1] = qi->d_var_num[d_n[i]]; - } - }else{ - d_qni_gterm[i] = d_n[i]; - } - } - d_type = d_n.getKind()==EQUAL ? typ_eq : typ_tconstraint; - Trace("qcf-tconstraint") << "T-Constraint : " << d_n << std::endl; - } - } - }else{ - //we will just evaluate - d_n = n; - d_type = typ_ground; - } - //if( d_type!=typ_invalid ){ - //determine an efficient children ordering - //if( !d_children.empty() ){ - //for( unsigned i=0; i& cbvars ) { - int v = qi->getVarNum( n ); - if( v!=-1 && std::find( cbvars.begin(), cbvars.end(), v )==cbvars.end() ){ - cbvars.push_back( v ); - } - for( unsigned i=0; i& bvars ) { - Trace("qcf-qregister-debug") << "Determine variable order " << d_n << std::endl; - bool isCom = d_type==typ_formula && ( d_n.getKind()==OR || d_n.getKind()==AND || d_n.getKind()==IFF ); - std::map< int, std::vector< int > > c_to_vars; - std::map< int, std::vector< int > > vars_to_c; - std::map< int, int > vb_count; - std::map< int, int > vu_count; - std::vector< bool > assigned; - Trace("qcf-qregister-debug") << "Calculate bound variables..." << std::endl; - for( unsigned i=0; i::iterator it = d_qni_gterm.begin(); it != d_qni_gterm.end(); ++it ){ - d_qni_gterm_rep[it->first] = p->getRepresentative( it->second ); - } - if( d_type==typ_ground ){ - int e = p->evaluate( d_n ); - if( e==1 ){ - d_ground_eval[0] = p->d_true; - }else if( e==-1 ){ - d_ground_eval[0] = p->d_false; - } - }else if( d_type==typ_eq ){ - for( unsigned i=0; ievaluateTerm( d_n[i] ); - } - } - } - d_qni_bound_cons.clear(); - d_qni_bound_cons_var.clear(); - d_qni_bound.clear(); -} - -void MatchGen::reset( QuantConflictFind * p, bool tgt, QuantInfo * qi ) { - d_tgt = d_type_not ? !tgt : tgt; - Debug("qcf-match") << " Reset for : " << d_n << ", type : "; - debugPrintType( "qcf-match", d_type ); - Debug("qcf-match") << ", tgt = " << d_tgt << ", children = " << d_children.size() << " " << d_children_order.size() << std::endl; - d_qn.clear(); - d_qni.clear(); - d_qni_bound.clear(); - d_child_counter = -1; - d_tgt_orig = d_tgt; - - //set up processing matches - if( d_type==typ_invalid ){ - //do nothing - }else if( d_type==typ_ground ){ - if( d_ground_eval[0]==( d_tgt ? p->d_true : p->d_false ) ){ - d_child_counter = 0; - } - }else if( d_type==typ_bool_var ){ - //get current value of the variable - TNode n = qi->getCurrentValue( d_n ); - int vn = qi->getCurrentRepVar( qi->getVarNum( n ) ); - if( vn==-1 ){ - //evaluate the value, see if it is compatible - int e = p->evaluate( n ); - if( ( e==1 && d_tgt ) || ( e==0 && !d_tgt ) ){ - d_child_counter = 0; - } - }else{ - //unassigned, set match to true/false - d_qni_bound[0] = vn; - qi->setMatch( p, vn, d_tgt ? p->d_true : p->d_false ); - d_child_counter = 0; - } - if( d_child_counter==0 ){ - d_qn.push_back( NULL ); - } - }else if( d_type==typ_var ){ - Assert( isHandledUfTerm( d_n ) ); - Node f = getOperator( p, d_n ); - Debug("qcf-match-debug") << " reset: Var will match operators of " << f << std::endl; - QcfNodeIndex * qni = p->getQcfNodeIndex( Node::null(), f ); - if( qni!=NULL ){ - d_qn.push_back( qni ); - } - d_matched_basis = false; - }else if( d_type==typ_tsym || d_type==typ_tconstraint ){ - for( std::map< int, int >::iterator it = d_qni_var_num.begin(); it != d_qni_var_num.end(); ++it ){ - int repVar = qi->getCurrentRepVar( it->second ); - if( qi->d_match[repVar].isNull() ){ - Debug("qcf-match-debug") << "Force matching on child #" << it->first << ", which is var #" << repVar << std::endl; - d_qni_bound[it->first] = repVar; - } - } - d_qn.push_back( NULL ); - }else if( d_type==typ_pred || d_type==typ_eq ){ - //add initial constraint - Node nn[2]; - int vn[2]; - if( d_type==typ_pred ){ - nn[0] = qi->getCurrentValue( d_n ); - vn[0] = qi->getCurrentRepVar( qi->getVarNum( nn[0] ) ); - nn[1] = p->getRepresentative( d_tgt ? p->d_true : p->d_false ); - vn[1] = -1; - d_tgt = true; - }else{ - for( unsigned i=0; i<2; i++ ){ - TNode nc; - std::map< int, TNode >::iterator it = d_qni_gterm_rep.find( i ); - if( it!=d_qni_gterm_rep.end() ){ - nc = it->second; - }else{ - nc = d_n[i]; - } - nn[i] = qi->getCurrentValue( nc ); - vn[i] = qi->getCurrentRepVar( qi->getVarNum( nn[i] ) ); - } - } - bool success; - if( vn[0]==-1 && vn[1]==-1 ){ - //Trace("qcf-explain") << " reset : " << d_n << " check ground values " << nn[0] << " " << nn[1] << " (tgt=" << d_tgt << ")" << std::endl; - Debug("qcf-match-debug") << " reset: check ground values " << nn[0] << " " << nn[1] << " (" << d_tgt << ")" << std::endl; - //just compare values - if( d_tgt ){ - success = p->areMatchEqual( nn[0], nn[1] ); - }else{ - if( p->d_effort==QuantConflictFind::effort_conflict ){ - success = p->areDisequal( nn[0], nn[1] ); - }else{ - success = p->areMatchDisequal( nn[0], nn[1] ); - } - } - }else{ - //otherwise, add a constraint to a variable - if( vn[1]!=-1 && vn[0]==-1 ){ - //swap - Node t = nn[1]; - nn[1] = nn[0]; - nn[0] = t; - vn[0] = vn[1]; - vn[1] = -1; - } - Debug("qcf-match-debug") << " reset: add constraint " << vn[0] << " -> " << nn[1] << " (vn=" << vn[1] << ")" << std::endl; - //add some constraint - int addc = qi->addConstraint( p, vn[0], nn[1], vn[1], d_tgt, false ); - success = addc!=-1; - //if successful and non-redundant, store that we need to cleanup this - if( addc==1 ){ - //Trace("qcf-explain") << " reset: " << d_n << " add constraint " << vn[0] << " -> " << nn[1] << " (vn=" << vn[1] << ")" << ", d_tgt = " << d_tgt << std::endl; - for( unsigned i=0; i<2; i++ ){ - if( vn[i]!=-1 && std::find( d_qni_bound_except.begin(), d_qni_bound_except.end(), i )==d_qni_bound_except.end() ){ - d_qni_bound[vn[i]] = vn[i]; - } - } - d_qni_bound_cons[vn[0]] = nn[1]; - d_qni_bound_cons_var[vn[0]] = vn[1]; - } - } - //if successful, we will bind values to variables - if( success ){ - d_qn.push_back( NULL ); - } - }else{ - if( d_children.empty() ){ - //add dummy - d_qn.push_back( NULL ); - }else{ - if( d_tgt && d_n.getKind()==FORALL ){ - //do nothing - }else{ - //reset the first child to d_tgt - d_child_counter = 0; - getChild( d_child_counter )->reset( p, d_tgt, qi ); - } - } - } - d_binding = false; - d_wasSet = true; - Debug("qcf-match") << " reset: Finished reset for " << d_n << ", success = " << ( !d_qn.empty() || d_child_counter!=-1 ) << std::endl; -} - -bool MatchGen::getNextMatch( QuantConflictFind * p, QuantInfo * qi ) { - Debug("qcf-match") << " Get next match for : " << d_n << ", type = "; - debugPrintType( "qcf-match", d_type ); - Debug("qcf-match") << ", children = " << d_children.size() << ", binding = " << d_binding << std::endl; - if( d_type==typ_invalid || d_type==typ_ground ){ - if( d_child_counter==0 ){ - d_child_counter = -1; - return true; - }else{ - d_wasSet = false; - return false; - } - }else if( d_type==typ_var || d_type==typ_eq || d_type==typ_pred || d_type==typ_bool_var || d_type==typ_tconstraint || d_type==typ_tsym ){ - bool success = false; - bool terminate = false; - do { - bool doReset = false; - bool doFail = false; - if( !d_binding ){ - if( doMatching( p, qi ) ){ - Debug("qcf-match-debug") << " - Matching succeeded" << std::endl; - d_binding = true; - d_binding_it = d_qni_bound.begin(); - doReset = true; - //for tconstraint, add constraint - if( d_type==typ_tconstraint ){ - std::map< Node, bool >::iterator it = qi->d_tconstraints.find( d_n ); - if( it==qi->d_tconstraints.end() ){ - qi->d_tconstraints[d_n] = d_tgt; - //store that we added this constraint - d_qni_bound_cons[0] = d_n; - }else if( d_tgt!=it->second ){ - success = false; - terminate = true; - } - } - }else{ - Debug("qcf-match-debug") << " - Matching failed" << std::endl; - success = false; - terminate = true; - } - }else{ - doFail = true; - } - if( d_binding ){ - //also need to create match for each variable we bound - success = true; - Debug("qcf-match-debug") << " Produce matches for bound variables by " << d_n << ", type = "; - debugPrintType( "qcf-match-debug", d_type ); - Debug("qcf-match-debug") << "..." << std::endl; - - while( ( success && d_binding_it!=d_qni_bound.end() ) || doFail ){ - std::map< int, MatchGen * >::iterator itm; - if( !doFail ){ - Debug("qcf-match-debug") << " check variable " << d_binding_it->second << std::endl; - itm = qi->d_var_mg.find( d_binding_it->second ); - } - if( doFail || ( d_binding_it->first!=0 && itm!=qi->d_var_mg.end() ) ){ - Debug("qcf-match-debug") << " we had bound variable " << d_binding_it->second << ", reset = " << doReset << std::endl; - if( doReset ){ - itm->second->reset( p, true, qi ); - } - if( doFail || !itm->second->getNextMatch( p, qi ) ){ - do { - if( d_binding_it==d_qni_bound.begin() ){ - Debug("qcf-match-debug") << " failed." << std::endl; - success = false; - }else{ - --d_binding_it; - Debug("qcf-match-debug") << " decrement..." << std::endl; - } - }while( success && ( d_binding_it->first==0 || qi->d_var_mg.find( d_binding_it->second )==qi->d_var_mg.end() ) ); - doReset = false; - doFail = false; - }else{ - Debug("qcf-match-debug") << " increment..." << std::endl; - ++d_binding_it; - doReset = true; - } - }else{ - Debug("qcf-match-debug") << " skip..." << d_binding_it->second << std::endl; - ++d_binding_it; - doReset = true; - } - } - if( !success ){ - d_binding = false; - }else{ - terminate = true; - if( d_binding_it==d_qni_bound.begin() ){ - d_binding = false; - } - } - } - }while( !terminate ); - //if not successful, clean up the variables you bound - if( !success ){ - if( d_type==typ_eq || d_type==typ_pred ){ - //clean up the constraints you added - for( std::map< int, TNode >::iterator it = d_qni_bound_cons.begin(); it != d_qni_bound_cons.end(); ++it ){ - if( !it->second.isNull() ){ - Debug("qcf-match") << " Clean up bound var " << it->first << (d_tgt ? "!" : "") << " = " << it->second << std::endl; - std::map< int, int >::iterator itb = d_qni_bound_cons_var.find( it->first ); - int vn = itb!=d_qni_bound_cons_var.end() ? itb->second : -1; - //Trace("qcf-explain") << " cleanup: " << d_n << " remove constraint " << it->first << " -> " << it->second << " (vn=" << vn << ")" << ", d_tgt = " << d_tgt << std::endl; - qi->addConstraint( p, it->first, it->second, vn, d_tgt, true ); - } - } - d_qni_bound_cons.clear(); - d_qni_bound_cons_var.clear(); - d_qni_bound.clear(); - }else{ - //clean up the matches you set - for( std::map< int, int >::iterator it = d_qni_bound.begin(); it != d_qni_bound.end(); ++it ){ - Debug("qcf-match") << " Clean up bound var " << it->second << std::endl; - Assert( it->secondgetNumVars() ); - qi->d_match[ it->second ] = TNode::null(); - qi->d_match_term[ it->second ] = TNode::null(); - } - d_qni_bound.clear(); - } - if( d_type==typ_tconstraint ){ - //remove constraint if applicable - if( d_qni_bound_cons.find( 0 )!=d_qni_bound_cons.end() ){ - qi->d_tconstraints.erase( d_n ); - d_qni_bound_cons.clear(); - } - } - /* - if( d_type==typ_var && p->d_effort==QuantConflictFind::effort_mc && !d_matched_basis ){ - d_matched_basis = true; - Node f = getOperator( d_n ); - TNode mbo = p->getQuantifiersEngine()->getTermDatabase()->getModelBasisOpTerm( f ); - if( qi->setMatch( p, d_qni_var_num[0], mbo ) ){ - success = true; - d_qni_bound[0] = d_qni_var_num[0]; - } - } - */ - } - Debug("qcf-match") << " ...finished matching for " << d_n << ", success = " << success << std::endl; - d_wasSet = success; - return success; - }else if( d_type==typ_formula || d_type==typ_ite_var ){ - bool success = false; - if( d_child_counter<0 ){ - if( d_child_counter<-1 ){ - success = true; - d_child_counter = -1; - } - }else{ - while( !success && d_child_counter>=0 ){ - //transition system based on d_child_counter - if( d_n.getKind()==OR || d_n.getKind()==AND ){ - if( (d_n.getKind()==AND)==d_tgt ){ - //all children must match simultaneously - if( getChild( d_child_counter )->getNextMatch( p, qi ) ){ - if( d_child_counter<(int)(getNumChildren()-1) ){ - d_child_counter++; - Debug("qcf-match-debug") << " Reset child " << d_child_counter << " of " << d_n << std::endl; - getChild( d_child_counter )->reset( p, d_tgt, qi ); - }else{ - success = true; - } - }else{ - //if( std::find( d_independent.begin(), d_independent.end(), d_child_counter )!=d_independent.end() ){ - // d_child_counter--; - //}else{ - d_child_counter--; - //} - } - }else{ - //one child must match - if( !getChild( d_child_counter )->getNextMatch( p, qi ) ){ - if( d_child_counter<(int)(getNumChildren()-1) ){ - d_child_counter++; - Debug("qcf-match-debug") << " Reset child " << d_child_counter << " of " << d_n << ", one match" << std::endl; - getChild( d_child_counter )->reset( p, d_tgt, qi ); - }else{ - d_child_counter = -1; - } - }else{ - success = true; - } - } - }else if( d_n.getKind()==IFF ){ - //construct match based on both children - if( d_child_counter%2==0 ){ - if( getChild( 0 )->getNextMatch( p, qi ) ){ - d_child_counter++; - getChild( 1 )->reset( p, d_child_counter==1, qi ); - }else{ - if( d_child_counter==0 ){ - d_child_counter = 2; - getChild( 0 )->reset( p, !d_tgt, qi ); - }else{ - d_child_counter = -1; - } - } - } - if( d_child_counter>=0 && d_child_counter%2==1 ){ - if( getChild( 1 )->getNextMatch( p, qi ) ){ - success = true; - }else{ - d_child_counter--; - } - } - }else if( d_n.getKind()==ITE ){ - if( d_child_counter%2==0 ){ - int index1 = d_child_counter==4 ? 1 : 0; - if( getChild( index1 )->getNextMatch( p, qi ) ){ - d_child_counter++; - getChild( d_child_counter==5 ? 2 : (d_tgt==(d_child_counter==1) ? 1 : 2) )->reset( p, d_tgt, qi ); - }else{ - if( d_child_counter==4 || ( d_type==typ_ite_var && d_child_counter==2 ) ){ - d_child_counter = -1; - }else{ - d_child_counter +=2; - getChild( d_child_counter==2 ? 0 : 1 )->reset( p, d_child_counter==2 ? !d_tgt : d_tgt, qi ); - } - } - } - if( d_child_counter>=0 && d_child_counter%2==1 ){ - int index2 = d_child_counter==5 ? 2 : (d_tgt==(d_child_counter==1) ? 1 : 2); - if( getChild( index2 )->getNextMatch( p, qi ) ){ - success = true; - }else{ - d_child_counter--; - } - } - }else if( d_n.getKind()==FORALL ){ - if( getChild( d_child_counter )->getNextMatch( p, qi ) ){ - success = true; - }else{ - d_child_counter = -1; - } - } - } - d_wasSet = success; - Debug("qcf-match") << " ...finished construct match for " << d_n << ", success = " << success << std::endl; - return success; - } - } - Debug("qcf-match") << " ...already finished for " << d_n << std::endl; - return false; -} - -bool MatchGen::getExplanation( QuantConflictFind * p, QuantInfo * qi, std::vector< Node >& exp ) { - if( d_type==typ_eq ){ - Node n[2]; - for( unsigned i=0; i<2; i++ ){ - Trace("qcf-explain") << "Explain term " << d_n[i] << "..." << std::endl; - n[i] = getExplanationTerm( p, qi, d_n[i], exp ); - } - Node eq = n[0].eqNode( n[1] ); - if( !d_tgt_orig ){ - eq = eq.negate(); - } - exp.push_back( eq ); - Trace("qcf-explain") << "Explanation for " << d_n << " (tgt=" << d_tgt_orig << ") is " << eq << ", set = " << d_wasSet << std::endl; - return true; - }else if( d_type==typ_pred ){ - Trace("qcf-explain") << "Explain term " << d_n << "..." << std::endl; - Node n = getExplanationTerm( p, qi, d_n, exp ); - if( !d_tgt_orig ){ - n = n.negate(); - } - exp.push_back( n ); - Trace("qcf-explain") << "Explanation for " << d_n << " (tgt=" << d_tgt_orig << ") is " << n << ", set = " << d_wasSet << std::endl; - return true; - }else if( d_type==typ_formula ){ - Trace("qcf-explain") << "Explanation get for " << d_n << ", counter = " << d_child_counter << ", tgt = " << d_tgt_orig << ", set = " << d_wasSet << std::endl; - if( d_n.getKind()==OR || d_n.getKind()==AND ){ - if( (d_n.getKind()==AND)==d_tgt ){ - for( unsigned i=0; igetExplanation( p, qi, exp ) ){ - return false; - } - } - }else{ - return getChild( d_child_counter )->getExplanation( p, qi, exp ); - } - }else if( d_n.getKind()==IFF ){ - for( unsigned i=0; i<2; i++ ){ - if( !getChild( i )->getExplanation( p, qi, exp ) ){ - return false; - } - } - }else if( d_n.getKind()==ITE ){ - for( unsigned i=0; i<3; i++ ){ - bool isActive = ( ( i==0 && d_child_counter!=5 ) || - ( i==1 && d_child_counter!=( d_tgt ? 3 : 1 ) ) || - ( i==2 && d_child_counter!=( d_tgt ? 1 : 3 ) ) ); - if( isActive ){ - if( !getChild( i )->getExplanation( p, qi, exp ) ){ - return false; - } - } - } - }else{ - return false; - } - return true; - }else{ - return false; - } -} - -Node MatchGen::getExplanationTerm( QuantConflictFind * p, QuantInfo * qi, Node t, std::vector< Node >& exp ) { - Node v = qi->getCurrentExpValue( t ); - if( isHandledUfTerm( t ) ){ - for( unsigned i=0; i0 ); - bool invalidMatch; - do { - invalidMatch = false; - Debug("qcf-match-debug") << " Do matching " << d_n << " " << d_qn.size() << " " << d_qni.size() << std::endl; - if( d_qn.size()==d_qni.size()+1 ) { - int index = (int)d_qni.size(); - //initialize - TNode val; - std::map< int, int >::iterator itv = d_qni_var_num.find( index ); - if( itv!=d_qni_var_num.end() ){ - //get the representative variable this variable is equal to - int repVar = qi->getCurrentRepVar( itv->second ); - Debug("qcf-match-debug") << " Match " << index << " is a variable " << itv->second << ", which is repVar " << repVar << std::endl; - //get the value the rep variable - //std::map< int, TNode >::iterator itm = qi->d_match.find( repVar ); - if( !qi->d_match[repVar].isNull() ){ - val = qi->d_match[repVar]; - Debug("qcf-match-debug") << " Variable is already bound to " << val << std::endl; - }else{ - //binding a variable - d_qni_bound[index] = repVar; - std::map< TNode, QcfNodeIndex >::iterator it = d_qn[index]->d_children.begin(); - if( it != d_qn[index]->d_children.end() ) { - d_qni.push_back( it ); - //set the match - if( qi->setMatch( p, d_qni_bound[index], it->first ) ){ - Debug("qcf-match-debug") << " Binding variable" << std::endl; - if( d_qn.size()second ); - } - }else{ - Debug("qcf-match") << " Binding variable, currently fail." << std::endl; - invalidMatch = true; - } - }else{ - Debug("qcf-match-debug") << " Binding variable, fail, no more variables to bind" << std::endl; - d_qn.pop_back(); - } - } - }else{ - Debug("qcf-match-debug") << " Match " << index << " is ground term" << std::endl; - Assert( d_qni_gterm.find( index )!=d_qni_gterm.end() ); - Assert( d_qni_gterm_rep.find( index )!=d_qni_gterm_rep.end() ); - val = d_qni_gterm_rep[index]; - Assert( !val.isNull() ); - } - if( !val.isNull() ){ - //constrained by val - std::map< TNode, QcfNodeIndex >::iterator it = d_qn[index]->d_children.find( val ); - if( it!=d_qn[index]->d_children.end() ){ - Debug("qcf-match-debug") << " Match" << std::endl; - d_qni.push_back( it ); - if( d_qn.size()second ); - } - }else{ - Debug("qcf-match-debug") << " Failed to match" << std::endl; - d_qn.pop_back(); - } - } - }else{ - Assert( d_qn.size()==d_qni.size() ); - int index = d_qni.size()-1; - //increment if binding this variable - bool success = false; - std::map< int, int >::iterator itb = d_qni_bound.find( index ); - if( itb!=d_qni_bound.end() ){ - d_qni[index]++; - if( d_qni[index]!=d_qn[index]->d_children.end() ){ - success = true; - if( qi->setMatch( p, itb->second, d_qni[index]->first ) ){ - Debug("qcf-match-debug") << " Bind next variable" << std::endl; - if( d_qn.size()second ); - } - }else{ - Debug("qcf-match-debug") << " Bind next variable, currently fail" << std::endl; - invalidMatch = true; - } - }else{ - qi->d_match[ itb->second ] = TNode::null(); - qi->d_match_term[ itb->second ] = TNode::null(); - Debug("qcf-match-debug") << " Bind next variable, no more variables to bind" << std::endl; - } - }else{ - //TODO : if it equal to something else, also try that - } - //if not incrementing, move to next - if( !success ){ - d_qn.pop_back(); - d_qni.pop_back(); - } - } - }while( ( !d_qn.empty() && d_qni.size()!=d_qni_size ) || invalidMatch ); - if( d_qni.size()==d_qni_size ){ - //Assert( !d_qni[d_qni.size()-1]->second.d_children.empty() ); - //Debug("qcf-match-debug") << " We matched " << d_qni[d_qni.size()-1]->second.d_children.begin()->first << std::endl; - Assert( !d_qni[d_qni.size()-1]->second.d_children.empty() ); - TNode t = d_qni[d_qni.size()-1]->second.d_children.begin()->first; - Debug("qcf-match-debug") << " " << d_n << " matched " << t << std::endl; - qi->d_match_term[d_qni_var_num[0]] = t; - //set the match terms - for( std::map< int, int >::iterator it = d_qni_bound.begin(); it != d_qni_bound.end(); ++it ){ - Debug("qcf-match-debug") << " position " << it->first << " bounded " << it->second << " / " << qi->d_q[0].getNumChildren() << std::endl; - //if( it->second<(int)qi->d_q[0].getNumChildren() ){ //if it is an actual variable, we are interested in knowing the actual term - if( it->first>0 ){ - Assert( !qi->d_match[ it->second ].isNull() ); - Assert( p->areEqual( t[it->first-1], qi->d_match[ it->second ] ) ); - qi->d_match_term[it->second] = t[it->first-1]; - } - //} - } - } - } - } - return !d_qn.empty(); -} - -void MatchGen::debugPrintType( const char * c, short typ, bool isTrace ) { - if( isTrace ){ - switch( typ ){ - case typ_invalid: Trace(c) << "invalid";break; - case typ_ground: Trace(c) << "ground";break; - case typ_eq: Trace(c) << "eq";break; - case typ_pred: Trace(c) << "pred";break; - case typ_formula: Trace(c) << "formula";break; - case typ_var: Trace(c) << "var";break; - case typ_ite_var: Trace(c) << "ite_var";break; - case typ_bool_var: Trace(c) << "bool_var";break; - } - }else{ - switch( typ ){ - case typ_invalid: Debug(c) << "invalid";break; - case typ_ground: Debug(c) << "ground";break; - case typ_eq: Debug(c) << "eq";break; - case typ_pred: Debug(c) << "pred";break; - case typ_formula: Debug(c) << "formula";break; - case typ_var: Debug(c) << "var";break; - case typ_ite_var: Debug(c) << "ite_var";break; - case typ_bool_var: Debug(c) << "bool_var";break; - } - } -} - -void MatchGen::setInvalid() { - d_type = typ_invalid; - d_children.clear(); -} - -bool MatchGen::isHandledBoolConnective( TNode n ) { - return n.getType().isBoolean() && ( n.getKind()==OR || n.getKind()==AND || n.getKind()==IFF || n.getKind()==ITE || n.getKind()==FORALL || n.getKind()==NOT ); -} - -bool MatchGen::isHandledUfTerm( TNode n ) { - //return n.getKind()==APPLY_UF || n.getKind()==STORE || n.getKind()==SELECT || - // n.getKind()==APPLY_CONSTRUCTOR || n.getKind()==APPLY_SELECTOR_TOTAL || n.getKind()==APPLY_TESTER; - return inst::Trigger::isAtomicTriggerKind( n.getKind() ); -} - -Node MatchGen::getOperator( QuantConflictFind * p, Node n ) { - if( isHandledUfTerm( n ) ){ - return p->getQuantifiersEngine()->getTermDatabase()->getOperator( n ); - }else{ - return Node::null(); - } -} - -bool MatchGen::isHandled( TNode n ) { - if( n.getKind()!=BOUND_VARIABLE && n.hasBoundVar() ){ - if( !isHandledBoolConnective( n ) && !isHandledUfTerm( n ) && n.getKind()!=EQUAL && n.getKind()!=ITE ){ - return false; - } - for( unsigned i=0; imkConst(true); - d_false = NodeManager::currentNM()->mkConst(false); -} - -Node QuantConflictFind::mkEqNode( Node a, Node b ) { - if( a.getType().isBoolean() ){ - return a.iffNode( b ); - }else{ - return a.eqNode( b ); - } -} - -//-------------------------------------------------- registration - -void QuantConflictFind::registerQuantifier( Node q ) { - if( !TermDb::isRewriteRule( q ) ){ - d_quants.push_back( q ); - d_quant_id[q] = d_quants.size(); - Trace("qcf-qregister") << "Register "; - debugPrintQuant( "qcf-qregister", q ); - Trace("qcf-qregister") << " : " << q << std::endl; - //make QcfNode structure - Trace("qcf-qregister") << "- Get relevant equality/disequality pairs, calculate flattening..." << std::endl; - d_qinfo[q].initialize( q, q[1] ); - - //debug print - Trace("qcf-qregister") << "- Flattened structure is :" << std::endl; - Trace("qcf-qregister") << " "; - debugPrintQuantBody( "qcf-qregister", q, q[1] ); - Trace("qcf-qregister") << std::endl; - if( d_qinfo[q].d_vars.size()>q[0].getNumChildren() ){ - Trace("qcf-qregister") << " with additional constraints : " << std::endl; - for( unsigned j=q[0].getNumChildren(); jQuantConflictFind::effort_conflict ){ - // ret = -1; - //} - }else if( n.getKind()==NOT ){ - return -evaluate( n[0] ); - }else if( n.getKind()==ITE ){ - int cev1 = evaluate( n[0] ); - int cevc[2] = { 0, 0 }; - for( unsigned i=0; i<2; i++ ){ - if( ( i==0 && cev1!=-1 ) || ( i==1 && cev1!=1 ) ){ - cevc[i] = evaluate( n[i+1] ); - if( cev1!=0 ){ - ret = cevc[i]; - break; - }else if( cevc[i]==0 ){ - break; - } - } - } - if( ret==0 && cevc[0]!=0 && cevc[0]==cevc[1] ){ - ret = cevc[0]; - } - }else if( n.getKind()==IFF ){ - int cev1 = evaluate( n[0] ); - if( cev1!=0 ){ - int cev2 = evaluate( n[1] ); - if( cev2!=0 ){ - ret = cev1==cev2 ? 1 : -1; - } - } - - }else{ - int ssval = 0; - if( n.getKind()==OR ){ - ssval = 1; - }else if( n.getKind()==AND ){ - ssval = -1; - } - bool isUnk = false; - for( unsigned i=0; i::iterator it = d_qinfo[q].d_rel_eqr.begin(); it != d_qinfo[q].d_rel_eqr.end(); ++it ){ - // it->first->d_active.set( true ); - //} - } -} - -eq::EqualityEngine * QuantConflictFind::getEqualityEngine() { - //return ((uf::TheoryUF*)d_quantEngine->getTheoryEngine()->theoryOf( theory::THEORY_UF ))->getEqualityEngine(); - return d_quantEngine->getTheoryEngine()->getMasterEqualityEngine(); -} -bool QuantConflictFind::areEqual( Node n1, Node n2 ) { - return getEqualityEngine()->hasTerm( n1 ) && getEqualityEngine()->hasTerm( n2 ) && getEqualityEngine()->areEqual( n1,n2 ); -} -bool QuantConflictFind::areDisequal( Node n1, Node n2 ) { - return n1!=n2 && getEqualityEngine()->hasTerm( n1 ) && getEqualityEngine()->hasTerm( n2 ) && getEqualityEngine()->areDisequal( n1,n2, false ); -} -Node QuantConflictFind::getRepresentative( Node n ) { - if( getEqualityEngine()->hasTerm( n ) ){ - return getEqualityEngine()->getRepresentative( n ); - }else{ - return n; - } -} -Node QuantConflictFind::evaluateTerm( Node n ) { - if( MatchGen::isHandledUfTerm( n ) ){ - Node f = MatchGen::getOperator( this, n ); - Node nn; - computeUfTerms( f ); - if( getEqualityEngine()->hasTerm( n ) ){ - computeArgReps( n ); - nn = d_uf_terms[f].existsTerm( n, d_arg_reps[n] ); - }else{ - std::vector< TNode > args; - for( unsigned i=0; id_diseq.begin(); it != eqc_b->d_diseq.end(); ++it ){ - if( (*it).second ){ - Node n = (*it).first; - EqcInfo * eqc_n = getEqcInfo( n, false ); - Assert( eqc_n ); - if( !eqc_n->isDisequal( a ) ){ - Assert( !eqc_a->isDisequal( n ) ); - eqc_n->setDisequal( a ); - eqc_a->setDisequal( n ); - //setEqual( eqc_a, eqc_b, a, n, false ); - } - eqc_n->setDisequal( b, false ); - } - } - ////move all previous EqcRegistry's regarding equalities within b - //for( NodeBoolMap::iterator it = eqc_b->d_rel_eqr_e.begin(); it != eqc_b->d_rel_eqr_e.end(); ++it ){ - // if( (*it).second ){ - // eqc_a->d_rel_eqr_e[(*it).first] = true; - // } - //} - } - //process new equalities - //setEqual( eqc_a, eqc_b, a, b, true ); - Trace("qcf-proc2") << "QCF : finished merge : " << a << " " << b << std::endl; - } - */ -} - -/** assert disequal */ -void QuantConflictFind::assertDisequal( Node a, Node b ) { - /* - a = getRepresentative( a ); - b = getRepresentative( b ); - Trace("qcf-proc") << "QCF : assert disequal : " << a << " " << b << std::endl; - EqcInfo * eqc_a = getEqcInfo( a ); - EqcInfo * eqc_b = getEqcInfo( b ); - if( !eqc_a->isDisequal( b ) ){ - Assert( !eqc_b->isDisequal( a ) ); - eqc_b->setDisequal( a ); - eqc_a->setDisequal( b ); - //setEqual( eqc_a, eqc_b, a, b, false ); - } - Trace("qcf-proc2") << "QCF : finished assert disequal : " << a << " " << b << std::endl; - */ -} - -//-------------------------------------------------- check function - -void QuantConflictFind::reset_round( Theory::Effort level ) { - d_needs_computeRelEqr = true; -} - -/** check */ -void QuantConflictFind::check( Theory::Effort level ) { - Trace("qcf-check") << "QCF : check : " << level << std::endl; - if( d_conflict ){ - Trace("qcf-check2") << "QCF : finished check : already in conflict." << std::endl; - if( level>=Theory::EFFORT_FULL ){ - Trace("qcf-warn") << "ALREADY IN CONFLICT? " << level << std::endl; - //Assert( false ); - } - }else{ - int addedLemmas = 0; - if( d_performCheck ){ - ++(d_statistics.d_inst_rounds); - double clSet = 0; - int prevEt = 0; - if( Trace.isOn("qcf-engine") ){ - prevEt = d_statistics.d_entailment_checks.getData(); - clSet = double(clock())/double(CLOCKS_PER_SEC); - Trace("qcf-engine") << "---Conflict Find Engine Round, effort = " << level << "---" << std::endl; - } - computeRelevantEqr(); - - //determine order for quantified formulas - std::vector< Node > qorder; - std::map< Node, bool > qassert; - //mark which are asserted - for( unsigned i=0; id_mg->isValid() ){ - Trace("qcf-check") << "Check quantified formula "; - debugPrintQuant("qcf-check", q); - Trace("qcf-check") << " : " << q << "..." << std::endl; - - Trace("qcf-check-debug") << "Reset round..." << std::endl; - qi->reset_round( this ); - //try to make a matches making the body false - Trace("qcf-check-debug") << "Get next match..." << std::endl; - while( qi->d_mg->getNextMatch( this, qi ) ){ - Trace("qcf-check") << "*** Produced match at effort " << e << " : " << std::endl; - qi->debugPrintMatch("qcf-check"); - Trace("qcf-check") << std::endl; - std::vector< int > assigned; - if( !qi->isMatchSpurious( this ) ){ - if( qi->completeMatch( this, assigned ) ){ - /* - if( options::qcfExp() && d_effort==effort_conflict ){ - std::vector< Node > exp; - if( qi->d_mg->getExplanation( this, qi, exp ) ){ - Trace("qcf-check-exp") << "Base explanation is : " << std::endl; - for( unsigned c=0; c c_exp; - eq::EqualityEngine* ee = ((uf::TheoryUF*)d_quantEngine->getTheoryEngine()->theoryOf( THEORY_UF ))->getEqualityEngine() ; - for( unsigned c=0; careDisequal( lit[0], lit[1], true ) ){ - exit( 98 ); - }else if( pol && !ee->areEqual( lit[0], lit[1] ) ){ - exit( 99 ); - } - ee->explainEquality( lit[0], lit[1], pol, c_exp ); - }else{ - if( !ee->areEqual( lit, pol ? d_true : d_false ) ){ - exit( pol ? 96 : 97 ); - } - ee->explainPredicate( lit, pol, c_exp ); - } - } - std::vector< Node > c_lem; - Trace("qcf-check-exp") << "Actual explanation is : " << std::endl; - for( unsigned c=0; cmkNode( OR, c_lem ); - Trace("qcf-conflict") << "QCF conflict : " << conf << std::endl; - d_quantEngine->addLemma( conf, false ); - d_conflict.set( true ); - ++(d_statistics.d_conflict_inst); - ++addedLemmas; - break; - } - } - */ - std::vector< Node > terms; - qi->getMatch( terms ); - if( !qi->isTConstraintSpurious( this, terms ) ){ - if( Debug.isOn("qcf-check-inst") ){ - //if( e==effort_conflict ){ - Node inst = d_quantEngine->getInstantiation( q, terms ); - Debug("qcf-check-inst") << "Check instantiation " << inst << "..." << std::endl; - Assert( evaluate( inst )!=1 ); - Assert( evaluate( inst )==-1 || e>effort_conflict ); - //} - } - if( d_quantEngine->addInstantiation( q, terms, false ) ){ - Trace("qcf-check") << " ... Added instantiation" << std::endl; - Trace("qcf-inst") << "*** Was from effort " << e << " : " << std::endl; - qi->debugPrintMatch("qcf-inst"); - Trace("qcf-inst") << std::endl; - ++addedLemmas; - if( e==effort_conflict ){ - d_quant_order.insert( d_quant_order.begin(), q ); - d_conflict.set( true ); - ++(d_statistics.d_conflict_inst); - break; - }else if( e==effort_prop_eq ){ - ++(d_statistics.d_prop_inst); - } - }else{ - Trace("qcf-check") << " ... Failed to add instantiation" << std::endl; - //Assert( false ); - } - } - //clean up assigned - qi->revertMatch( assigned ); - d_tempCache.clear(); - }else{ - Trace("qcf-check") << " ... Spurious instantiation (cannot assign unassigned variables)" << std::endl; - } - }else{ - Trace("qcf-check") << " ... Spurious instantiation (match is inconsistent)" << std::endl; - } - } - if( d_conflict ){ - break; - } - } - } - if( addedLemmas>0 ){ - d_quantEngine->flushLemmas(); - break; - } - } - if( Trace.isOn("qcf-engine") ){ - double clSet2 = double(clock())/double(CLOCKS_PER_SEC); - Trace("qcf-engine") << "Finished conflict find engine, time = " << (clSet2-clSet); - if( addedLemmas>0 ){ - Trace("qcf-engine") << ", effort = " << ( d_effort==effort_conflict ? "conflict" : ( d_effort==effort_prop_eq ? "prop_eq" : "mc" ) ); - Trace("qcf-engine") << ", addedLemmas = " << addedLemmas; - } - Trace("qcf-engine") << std::endl; - int currEt = d_statistics.d_entailment_checks.getData(); - if( currEt!=prevEt ){ - Trace("qcf-engine") << " Entailment checks = " << ( currEt - prevEt ) << std::endl; - } - } - } - Trace("qcf-check2") << "QCF : finished check : " << level << std::endl; - } -} - -bool QuantConflictFind::needsCheck( Theory::Effort level ) { - d_performCheck = false; - if( options::quantConflictFind() && !d_conflict ){ - if( level==Theory::EFFORT_LAST_CALL ){ - d_performCheck = options::qcfWhenMode()==QCF_WHEN_MODE_LAST_CALL; - }else if( level==Theory::EFFORT_FULL ){ - d_performCheck = options::qcfWhenMode()==QCF_WHEN_MODE_DEFAULT; - }else if( level==Theory::EFFORT_STANDARD ){ - d_performCheck = options::qcfWhenMode()==QCF_WHEN_MODE_STD; - } - } - return d_performCheck; -} - -void QuantConflictFind::computeRelevantEqr() { - if( d_needs_computeRelEqr ){ - d_needs_computeRelEqr = false; - Trace("qcf-check") << "Compute relevant equalities..." << std::endl; - d_uf_terms.clear(); - d_eqc_uf_terms.clear(); - d_eqcs.clear(); - d_model_basis.clear(); - d_arg_reps.clear(); - //double clSet = 0; - //if( Trace.isOn("qcf-opt") ){ - // clSet = double(clock())/double(CLOCKS_PER_SEC); - //} - - //long nTermst = 0; - //long nTerms = 0; - //long nEqc = 0; - - //which nodes are irrelevant for disequality matches - std::map< TNode, bool > irrelevant_dnode; - //now, store matches - eq::EqClassesIterator eqcs_i = eq::EqClassesIterator( getEqualityEngine() ); - while( !eqcs_i.isFinished() ){ - //nEqc++; - Node r = (*eqcs_i); - TypeNode rtn = r.getType(); - if( options::qcfMode()==QCF_MC ){ - std::map< TypeNode, std::vector< TNode > >::iterator itt = d_eqcs.find( rtn ); - if( itt==d_eqcs.end() ){ - Node mb = getQuantifiersEngine()->getTermDatabase()->getModelBasisTerm( rtn ); - if( !getEqualityEngine()->hasTerm( mb ) ){ - Trace("qcf-warn") << "WARNING: Model basis term does not exist!" << std::endl; - Assert( false ); - } - Node mbr = getRepresentative( mb ); - if( mbr!=r ){ - d_eqcs[rtn].push_back( mbr ); - } - d_eqcs[rtn].push_back( r ); - d_model_basis[rtn] = mb; - }else{ - itt->second.push_back( r ); - } - }else{ - d_eqcs[rtn].push_back( r ); - } - /* - eq::EqClassIterator eqc_i = eq::EqClassIterator( r, getEqualityEngine() ); - while( !eqc_i.isFinished() ){ - TNode n = (*eqc_i); - if( n.hasBoundVar() ){ - std::cout << "BAD TERM IN DB : " << n << std::endl; - exit( 199 ); - } - ++eqc_i; - } - - */ - - //if( r.getType().isInteger() ){ - // Trace("qcf-mv") << "Model value for eqc(" << r << ") : " << d_quantEngine->getValuation().getModelValue( r ) << std::endl; - //} - //EqcInfo * eqcir = getEqcInfo( r, false ); - //get relevant nodes that we are disequal from - /* - std::vector< Node > deqc; - if( eqcir ){ - for( NodeBoolMap::iterator it = eqcir->d_diseq.begin(); it != eqcir->d_diseq.end(); ++it ){ - if( (*it).second ){ - //Node rd = (*it).first; - //if( rd!=getRepresentative( rd ) ){ - // std::cout << "Bad rep!" << std::endl; - // exit( 0 ); - //} - deqc.push_back( (*it).first ); - } - } - } - */ - //process disequalities - /* - eq::EqClassIterator eqc_i = eq::EqClassIterator( r, getEqualityEngine() ); - while( !eqc_i.isFinished() ){ - TNode n = (*eqc_i); - if( n.getKind()!=EQUAL ){ - nTermst++; - //node_to_rep[n] = r; - //if( n.getNumChildren()>0 ){ - // if( n.getKind()!=APPLY_UF ){ - // std::cout << n.getKind() << " " << n.getOperator() << " " << n << std::endl; - // } - //} - if( !quantifiers::TermDb::hasBoundVarAttr( n ) ){ //temporary - - bool isRedundant; - std::map< TNode, std::vector< TNode > >::iterator it_na; - TNode fn; - if( MatchGen::isHandledUfTerm( n ) ){ - Node f = MatchGen::getOperator( this, n ); - computeArgReps( n ); - it_na = d_arg_reps.find( n ); - Assert( it_na!=d_arg_reps.end() ); - Node nadd = d_eqc_uf_terms[f].d_children[r].addTerm( n, d_arg_reps[n] ); - isRedundant = (nadd!=n); - d_uf_terms[f].addTerm( n, d_arg_reps[n] ); - }else{ - isRedundant = false; - } - nTerms += isRedundant ? 0 : 1; - }else{ - if( Debug.isOn("qcf-nground") ){ - Debug("qcf-nground") << "Non-ground term in eqc : " << n << std::endl; - Assert( false ); - } - } - } - ++eqc_i; - } - */ - ++eqcs_i; - } - /* - if( Trace.isOn("qcf-opt") ){ - double clSet2 = double(clock())/double(CLOCKS_PER_SEC); - Trace("qcf-opt") << "Compute rel eqc : " << std::endl; - Trace("qcf-opt") << " " << nEqc << " equivalence classes. " << std::endl; - Trace("qcf-opt") << " " << nTerms << " / " << nTermst << " terms." << std::endl; - Trace("qcf-opt") << " Time : " << (clSet2-clSet) << std::endl; - } - */ - } -} - -void QuantConflictFind::computeArgReps( TNode n ) { - if( d_arg_reps.find( n )==d_arg_reps.end() ){ - Assert( MatchGen::isHandledUfTerm( n ) ); - for( unsigned j=0; jgetTermDatabase()->getNumGroundTerms( f ); - for( unsigned i=0; igetTermDatabase()->d_op_map[f][i]; - if( getEqualityEngine()->hasTerm( n ) && !n.getAttribute(NoMatchAttribute()) ){ - Node r = getRepresentative( n ); - computeArgReps( n ); - d_eqc_uf_terms[f].d_children[r].addTerm( n, d_arg_reps[n] ); - d_uf_terms[f].addTerm( n, d_arg_reps[n] ); - } - } - } -} - -//-------------------------------------------------- debugging - - -void QuantConflictFind::debugPrint( const char * c ) { - //print the equivalance classes - Trace(c) << "----------EQ classes" << std::endl; - eq::EqClassesIterator eqcs_i = eq::EqClassesIterator( getEqualityEngine() ); - while( !eqcs_i.isFinished() ){ - Node n = (*eqcs_i); - //if( !n.getType().isInteger() ){ - Trace(c) << " - " << n << " : {"; - eq::EqClassIterator eqc_i = eq::EqClassIterator( n, getEqualityEngine() ); - bool pr = false; - while( !eqc_i.isFinished() ){ - Node nn = (*eqc_i); - if( nn.getKind()!=EQUAL && nn!=n ){ - Trace(c) << (pr ? "," : "" ) << " " << nn; - pr = true; - } - ++eqc_i; - } - Trace(c) << (pr ? " " : "" ) << "}" << std::endl; - /* - EqcInfo * eqcn = getEqcInfo( n, false ); - if( eqcn ){ - Trace(c) << " DEQ : {"; - pr = false; - for( NodeBoolMap::iterator it = eqcn->d_diseq.begin(); it != eqcn->d_diseq.end(); ++it ){ - if( (*it).second ){ - Trace(c) << (pr ? "," : "" ) << " " << (*it).first; - pr = true; - } - } - Trace(c) << (pr ? " " : "" ) << "}" << std::endl; - } - //} - */ - ++eqcs_i; - } -} - -void QuantConflictFind::debugPrintQuant( const char * c, Node q ) { - Trace(c) << "Q" << d_quant_id[q]; -} - -void QuantConflictFind::debugPrintQuantBody( const char * c, Node q, Node n, bool doVarNum ) { - if( n.getNumChildren()==0 ){ - Trace(c) << n; - }else if( doVarNum && d_qinfo[q].d_var_num.find( n )!=d_qinfo[q].d_var_num.end() ){ - Trace(c) << "?x" << d_qinfo[q].d_var_num[n]; - }else{ - Trace(c) << "("; - if( n.getKind()==APPLY_UF ){ - Trace(c) << n.getOperator(); - }else{ - Trace(c) << n.getKind(); - } - for( unsigned i=0; i::iterator it = d_zero.find( k ); - if( it==d_zero.end() ){ - Node nn; - if( k==PLUS ){ - nn = NodeManager::currentNM()->mkConst( Rational(0) ); - } - d_zero[k] = nn; - return nn; - }else{ - return it->second; - } -} - - -} +/********************* */ +/*! \file quant_conflict_find.cpp + ** \verbatim + ** Original author: Andrew Reynolds + ** Major contributors: none + ** Minor contributors (to current version): none + ** This file is part of the CVC4 project. + ** Copyright (c) 2009-2014 New York University and The University of Iowa + ** See the file COPYING in the top-level source directory for licensing + ** information.\endverbatim + ** + ** \brief quant conflict find class + ** + **/ + +#include + +#include "theory/quantifiers/quant_conflict_find.h" +#include "theory/quantifiers/quant_util.h" +#include "theory/theory_engine.h" +#include "theory/quantifiers/options.h" +#include "theory/quantifiers/term_database.h" +#include "theory/quantifiers/trigger.h" + +using namespace CVC4; +using namespace CVC4::kind; +using namespace CVC4::theory; +using namespace CVC4::theory::quantifiers; +using namespace std; + +namespace CVC4 { + + + +void QuantInfo::initialize( Node q, Node qn ) { + d_q = q; + for( unsigned i=0; iisValid() ){ + /* + for( unsigned j=0; jsetInvalid(); + break; + } + } + */ + if( d_mg->isValid() ){ + for( unsigned j=q[0].getNumChildren(); jisValid() ){ + Trace("qcf-invalid") << "QCF invalid : cannot match for " << d_vars[j] << std::endl; + d_mg->setInvalid(); + break; + }else{ + std::vector< int > bvars; + d_var_mg[j]->determineVariableOrder( this, bvars ); + } + } + } + if( d_mg->isValid() ){ + std::vector< int > bvars; + d_mg->determineVariableOrder( this, bvars ); + } + } + }else{ + Trace("qcf-invalid") << "QCF invalid : body of formula cannot be processed." << std::endl; + } + Trace("qcf-qregister-summary") << "QCF register : " << ( d_mg->isValid() ? "VALID " : "INVALID" ) << " : " << q << std::endl; +} + +void QuantInfo::registerNode( Node n, bool hasPol, bool pol, bool beneathQuant ) { + Trace("qcf-qregister-debug2") << "Register : " << n << std::endl; + if( n.getKind()==FORALL ){ + registerNode( n[1], hasPol, pol, true ); + }else{ + if( !MatchGen::isHandledBoolConnective( n ) ){ + if( n.hasBoundVar() ){ + //literals + if( n.getKind()==EQUAL ){ + for( unsigned i=0; id_parent = qcf; + //qcf->d_child[i] = qcfc; + registerNode( n[i], newHasPol, newPol, beneathQuant ); + } + } + } +} + +void QuantInfo::flatten( Node n, bool beneathQuant ) { + Trace("qcf-qregister-debug2") << "Flatten : " << n << std::endl; + if( n.hasBoundVar() ){ + if( n.getKind()==BOUND_VARIABLE ){ + d_inMatchConstraint[n] = true; + } + //if( MatchGen::isHandledUfTerm( n ) || n.getKind()==ITE ){ + if( d_var_num.find( n )==d_var_num.end() ){ + Trace("qcf-qregister-debug2") << "Add FLATTEN VAR : " << n << std::endl; + d_var_num[n] = d_vars.size(); + d_vars.push_back( n ); + d_match.push_back( TNode::null() ); + d_match_term.push_back( TNode::null() ); + if( n.getKind()==ITE ){ + registerNode( n, false, false ); + }else{ + for( unsigned i=0; i >::iterator it = d_var_constraint[r].begin(); + it != d_var_constraint[r].end(); ++it ){ + for( unsigned j=0; jsecond.size(); j++ ){ + Node rr = it->second[j]; + if( !isVar( rr ) ){ + rr = p->getRepresentative( rr ); + } + if( addConstraint( p, it->first, rr, r==0 )==-1 ){ + d_var_constraint[0].clear(); + d_var_constraint[1].clear(); + //quantified formula is actually equivalent to true + Trace("qcf-qregister") << "Quantifier is equivalent to true!!!" << std::endl; + d_mg->d_children.clear(); + d_mg->d_n = NodeManager::currentNM()->mkConst( true ); + d_mg->d_type = MatchGen::typ_ground; + return; + } + } + } + } + d_mg->reset_round( p ); + for( std::map< int, MatchGen * >::iterator it = d_var_mg.begin(); it != d_var_mg.end(); ++it ){ + it->second->reset_round( p ); + } + //now, reset for matching + d_mg->reset( p, false, this ); +} + +int QuantInfo::getCurrentRepVar( int v ) { + if( v!=-1 && !d_match[v].isNull() ){ + int vn = getVarNum( d_match[v] ); + if( vn!=-1 ){ + //int vr = getCurrentRepVar( vn ); + //d_match[v] = d_vars[vr]; + //return vr; + return getCurrentRepVar( vn ); + } + } + return v; +} + +TNode QuantInfo::getCurrentValue( TNode n ) { + int v = getVarNum( n ); + if( v==-1 ){ + return n; + }else{ + if( d_match[v].isNull() ){ + return n; + }else{ + Assert( getVarNum( d_match[v] )!=v ); + return getCurrentValue( d_match[v] ); + } + } +} + +TNode QuantInfo::getCurrentExpValue( TNode n ) { + int v = getVarNum( n ); + if( v==-1 ){ + return n; + }else{ + if( d_match[v].isNull() ){ + return n; + }else{ + Assert( getVarNum( d_match[v] )!=v ); + if( d_match_term[v].isNull() ){ + return getCurrentValue( d_match[v] ); + }else{ + return d_match_term[v]; + } + } + } +} + +bool QuantInfo::getCurrentCanBeEqual( QuantConflictFind * p, int v, TNode n, bool chDiseq ) { + //check disequalities + std::map< int, std::map< TNode, int > >::iterator itd = d_curr_var_deq.find( v ); + if( itd!=d_curr_var_deq.end() ){ + for( std::map< TNode, int >::iterator it = itd->second.begin(); it != itd->second.end(); ++it ){ + Node cv = getCurrentValue( it->first ); + Debug("qcf-ccbe") << "compare " << cv << " " << n << std::endl; + if( cv==n ){ + return false; + }else if( chDiseq && !isVar( n ) && !isVar( cv ) ){ + //they must actually be disequal if we are looking for conflicts + if( !p->areDisequal( n, cv ) ){ + //TODO : check for entailed disequal + + return false; + } + } + } + } + return true; +} + +int QuantInfo::addConstraint( QuantConflictFind * p, int v, TNode n, bool polarity ) { + v = getCurrentRepVar( v ); + int vn = getVarNum( n ); + vn = vn==-1 ? -1 : getCurrentRepVar( vn ); + n = getCurrentValue( n ); + return addConstraint( p, v, n, vn, polarity, false ); +} + +int QuantInfo::addConstraint( QuantConflictFind * p, int v, TNode n, int vn, bool polarity, bool doRemove ) { + //for handling equalities between variables, and disequalities involving variables + Debug("qcf-match-debug") << "- " << (doRemove ? "un" : "" ) << "constrain : " << v << " -> " << n << " (cv=" << getCurrentValue( n ) << ")"; + Debug("qcf-match-debug") << ", (vn=" << vn << "), polarity = " << polarity << std::endl; + Assert( doRemove || n==getCurrentValue( n ) ); + Assert( doRemove || v==getCurrentRepVar( v ) ); + Assert( doRemove || vn==getCurrentRepVar( getVarNum( n ) ) ); + if( polarity ){ + if( vn!=v ){ + if( doRemove ){ + if( vn!=-1 ){ + //if set to this in the opposite direction, clean up opposite instead + // std::map< int, TNode >::iterator itmn = d_match.find( vn ); + if( d_match[vn]==d_vars[v] ){ + return addConstraint( p, vn, d_vars[v], v, true, true ); + }else{ + //unsetting variables equal + std::map< int, std::map< TNode, int > >::iterator itd = d_curr_var_deq.find( vn ); + if( itd!=d_curr_var_deq.end() ){ + //remove disequalities owned by this + std::vector< TNode > remDeq; + for( std::map< TNode, int >::iterator it = itd->second.begin(); it != itd->second.end(); ++it ){ + if( it->second==v ){ + remDeq.push_back( it->first ); + } + } + for( unsigned i=0; i::iterator itm = d_match.find( v ); + + if( vn!=-1 ){ + Debug("qcf-match-debug") << " ...Variable bound to variable" << std::endl; + //std::map< int, TNode >::iterator itmn = d_match.find( vn ); + if( d_match[v].isNull() ){ + //setting variables equal + bool alreadySet = false; + if( !d_match[vn].isNull() ){ + alreadySet = true; + Assert( !isVar( d_match[vn] ) ); + } + + //copy or check disequalities + std::map< int, std::map< TNode, int > >::iterator itd = d_curr_var_deq.find( v ); + if( itd!=d_curr_var_deq.end() ){ + for( std::map< TNode, int >::iterator it = itd->second.begin(); it != itd->second.end(); ++it ){ + Node dv = getCurrentValue( it->first ); + if( !alreadySet ){ + if( d_curr_var_deq[vn].find( dv )==d_curr_var_deq[vn].end() ){ + d_curr_var_deq[vn][dv] = v; + } + }else{ + if( !p->areMatchDisequal( d_match[vn], dv ) ){ + Debug("qcf-match-debug") << " -> fail, conflicting disequality" << std::endl; + return -1; + } + } + } + } + if( alreadySet ){ + n = getCurrentValue( n ); + } + }else{ + if( d_match[vn].isNull() ){ + Debug("qcf-match-debug") << " ...Reverse direction" << std::endl; + //set the opposite direction + return addConstraint( p, vn, d_vars[v], v, true, false ); + }else{ + Debug("qcf-match-debug") << " -> Both variables bound, compare" << std::endl; + //are they currently equal + return p->areMatchEqual( d_match[v], d_match[vn] ) ? 0 : -1; + } + } + }else{ + Debug("qcf-match-debug") << " ...Variable bound to ground" << std::endl; + if( d_match[v].isNull() ){ + }else{ + //compare ground values + Debug("qcf-match-debug") << " -> Ground value, compare " << d_match[v] << " "<< n << std::endl; + return p->areMatchEqual( d_match[v], n ) ? 0 : -1; + } + } + if( setMatch( p, v, n ) ){ + Debug("qcf-match-debug") << " -> success" << std::endl; + return 1; + }else{ + Debug("qcf-match-debug") << " -> fail, conflicting disequality" << std::endl; + return -1; + } + } + }else{ + Debug("qcf-match-debug") << " -> redundant, variable identity" << std::endl; + return 0; + } + }else{ + if( vn==v ){ + Debug("qcf-match-debug") << " -> fail, variable identity" << std::endl; + return -1; + }else{ + if( doRemove ){ + Assert( d_curr_var_deq[v].find( n )!=d_curr_var_deq[v].end() ); + d_curr_var_deq[v].erase( n ); + return 1; + }else{ + if( d_curr_var_deq[v].find( n )==d_curr_var_deq[v].end() ){ + //check if it respects equality + //std::map< int, TNode >::iterator itm = d_match.find( v ); + if( !d_match[v].isNull() ){ + TNode nv = getCurrentValue( n ); + if( !p->areMatchDisequal( nv, d_match[v] ) ){ + Debug("qcf-match-debug") << " -> fail, conflicting disequality" << std::endl; + return -1; + } + } + d_curr_var_deq[v][n] = v; + Debug("qcf-match-debug") << " -> success" << std::endl; + return 1; + }else{ + Debug("qcf-match-debug") << " -> redundant disequality" << std::endl; + return 0; + } + } + } + } +} + +bool QuantInfo::isConstrainedVar( int v ) { + if( d_curr_var_deq.find( v )!=d_curr_var_deq.end() && !d_curr_var_deq[v].empty() ){ + return true; + }else{ + Node vv = getVar( v ); + //for( std::map< int, TNode >::iterator it = d_match.begin(); it != d_match.end(); ++it ){ + for( unsigned i=0; i >::iterator it = d_curr_var_deq.begin(); it != d_curr_var_deq.end(); ++it ){ + for( std::map< TNode, int >::iterator it2 = it->second.begin(); it2 != it->second.end(); ++it2 ){ + if( it2->first==vv ){ + return true; + } + } + } + return false; + } +} + +bool QuantInfo::setMatch( QuantConflictFind * p, int v, TNode n ) { + if( getCurrentCanBeEqual( p, v, n ) ){ + Debug("qcf-match-debug") << "-- bind : " << v << " -> " << n << ", checked " << d_curr_var_deq[v].size() << " disequalities" << std::endl; + d_match[v] = n; + return true; + }else{ + return false; + } +} + +bool QuantInfo::isMatchSpurious( QuantConflictFind * p ) { + for( int i=0; i::iterator it = d_match.find( i ); + if( !d_match[i].isNull() ){ + if( !getCurrentCanBeEqual( p, i, d_match[i], p->d_effort==QuantConflictFind::effort_conflict ) ){ + return true; + } + } + } + return false; +} + +bool QuantInfo::isTConstraintSpurious( QuantConflictFind * p, std::vector< Node >& terms ) { + if( !d_tconstraints.empty() ){ + //check constraints + for( std::map< Node, bool >::iterator it = d_tconstraints.begin(); it != d_tconstraints.end(); ++it ){ + //apply substitution to the tconstraint + Node cons = it->first.substitute( p->getQuantifiersEngine()->getTermDatabase()->d_vars[d_q].begin(), + p->getQuantifiersEngine()->getTermDatabase()->d_vars[d_q].end(), + terms.begin(), terms.end() ); + cons = it->second ? cons : cons.negate(); + if( !entailmentTest( p, cons, p->d_effort==QuantConflictFind::effort_conflict ) ){ + return true; + } + } + } + return false; +} + +bool QuantInfo::entailmentTest( QuantConflictFind * p, Node lit, bool chEnt ) { + Trace("qcf-tconstraint-debug") << "Check : " << lit << std::endl; + Node rew = Rewriter::rewrite( lit ); + if( rew==p->d_false ){ + Trace("qcf-tconstraint-debug") << "...constraint " << lit << " is disentailed (rewrites to false)." << std::endl; + return false; + }else if( rew!=p->d_true ){ + //if checking for conflicts, we must be sure that the constraint is entailed + if( chEnt ){ + //check if it is entailed + Trace("qcf-tconstraint-debug") << "Check entailment of " << rew << "..." << std::endl; + std::pair et = p->getQuantifiersEngine()->getTheoryEngine()->entailmentCheck(THEORY_OF_TYPE_BASED, rew ); + ++(p->d_statistics.d_entailment_checks); + Trace("qcf-tconstraint-debug") << "ET result : " << et.first << " " << et.second << std::endl; + if( !et.first ){ + Trace("qcf-tconstraint-debug") << "...cannot show entailment of " << rew << "." << std::endl; + return false; + }else{ + return true; + } + }else{ + Trace("qcf-tconstraint-debug") << "...does not need to be entailed." << std::endl; + return true; + } + }else{ + Trace("qcf-tconstraint-debug") << "...rewrites to true." << std::endl; + return true; + } +} + +bool QuantInfo::completeMatch( QuantConflictFind * p, std::vector< int >& assigned, bool doContinue ) { + //assign values for variables that were unassigned (usually not necessary, but handles corner cases) + bool doFail = false; + bool success = true; + if( doContinue ){ + doFail = true; + success = false; + }else{ + //solve for interpreted symbol matches + // this breaks the invariant that all introduced constraints are over existing terms + for( int i=(int)(d_tsym_vars.size()-1); i>=0; i-- ){ + int index = d_tsym_vars[i]; + TNode v = getCurrentValue( d_vars[index] ); + int slv_v = -1; + if( v==d_vars[index] ){ + slv_v = index; + } + Trace("qcf-tconstraint-debug") << "Solve " << d_vars[index] << " = " << v << " " << d_vars[index].getKind() << std::endl; + if( d_vars[index].getKind()==PLUS || d_vars[index].getKind()==MULT ){ + Kind k = d_vars[index].getKind(); + std::vector< TNode > children; + for( unsigned j=0; jd_effort!=QuantConflictFind::effort_conflict ){ + break; + } + }else{ + Node z = p->getZero( k ); + if( !z.isNull() ){ + Trace("qcf-tconstraint-debug") << "...set " << d_vars[vn] << " = " << z << std::endl; + assigned.push_back( vn ); + if( !setMatch( p, vn, z ) ){ + success = false; + break; + } + } + } + }else{ + Trace("qcf-tconstraint-debug") << "...sum value " << vv << std::endl; + children.push_back( vv ); + } + }else{ + Trace("qcf-tconstraint-debug") << "...sum " << d_vars[index][j] << std::endl; + children.push_back( d_vars[index][j] ); + } + } + if( success ){ + if( slv_v!=-1 ){ + Node lhs; + if( children.empty() ){ + lhs = p->getZero( k ); + }else if( children.size()==1 ){ + lhs = children[0]; + }else{ + lhs = NodeManager::currentNM()->mkNode( k, children ); + } + Node sum; + if( v==d_vars[index] ){ + sum = lhs; + }else{ + if( p->d_effort==QuantConflictFind::effort_conflict ){ + Kind kn = k; + if( d_vars[index].getKind()==PLUS ){ + kn = MINUS; + } + if( kn!=k ){ + sum = NodeManager::currentNM()->mkNode( kn, v, lhs ); + } + } + } + if( !sum.isNull() ){ + assigned.push_back( slv_v ); + Trace("qcf-tconstraint-debug") << "...set " << d_vars[slv_v] << " = " << sum << std::endl; + if( !setMatch( p, slv_v, sum ) ){ + success = false; + } + p->d_tempCache.push_back( sum ); + } + }else{ + //must show that constraint is met + Node sum = NodeManager::currentNM()->mkNode( k, children ); + Node eq = sum.eqNode( v ); + if( !entailmentTest( p, eq ) ){ + success = false; + } + p->d_tempCache.push_back( sum ); + } + } + } + + if( !success ){ + break; + } + } + if( success ){ + //check what is left to assign + d_unassigned.clear(); + d_unassigned_tn.clear(); + std::vector< int > unassigned[2]; + std::vector< TypeNode > unassigned_tn[2]; + for( int i=0; i=0 && (int)d_una_index<(int)d_unassigned.size() ) || invalidMatch || doFail ){ + invalidMatch = false; + if( !doFail && d_una_index==(int)d_una_eqc_count.size() ){ + //check if it has now been assigned + if( d_una_indexreset( p, true, this ); + d_una_eqc_count.push_back( 0 ); + } + }else{ + d_una_eqc_count.push_back( 0 ); + } + }else{ + bool failed = false; + if( !doFail ){ + if( d_una_indexgetNextMatch( p, this ) ){ + Trace("qcf-check-unassign") << "Succeeded match with mg at " << d_una_index << std::endl; + d_una_index++; + }else{ + failed = true; + Trace("qcf-check-unassign") << "Failed match with mg at " << d_una_index << std::endl; + } + }else{ + Assert( doFail || d_una_index==(int)d_una_eqc_count.size()-1 ); + if( d_una_eqc_count[d_una_index]<(int)p->d_eqcs[d_unassigned_tn[d_una_index]].size() ){ + int currIndex = d_una_eqc_count[d_una_index]; + d_una_eqc_count[d_una_index]++; + Trace("qcf-check-unassign") << d_unassigned[d_una_index] << "->" << p->d_eqcs[d_unassigned_tn[d_una_index]][currIndex] << std::endl; + if( setMatch( p, d_unassigned[d_una_index], p->d_eqcs[d_unassigned_tn[d_una_index]][currIndex] ) ){ + d_match_term[d_unassigned[d_una_index]] = TNode::null(); + Trace("qcf-check-unassign") << "Succeeded match " << d_una_index << std::endl; + d_una_index++; + }else{ + Trace("qcf-check-unassign") << "Failed match " << d_una_index << std::endl; + invalidMatch = true; + } + }else{ + failed = true; + Trace("qcf-check-unassign") << "No more matches " << d_una_index << std::endl; + } + } + } + if( doFail || failed ){ + do{ + if( !doFail ){ + d_una_eqc_count.pop_back(); + }else{ + doFail = false; + } + d_una_index--; + }while( d_una_index>=0 && d_una_eqc_count[d_una_index]==-1 ); + } + } + } + success = d_una_index>=0; + if( success ){ + doFail = true; + Trace("qcf-check-unassign") << " Try: " << std::endl; + for( unsigned i=0; i " << d_match[ui] << std::endl; + } + } + } + }while( success && isMatchSpurious( p ) ); + } + if( success ){ + for( unsigned i=0; i " << d_match[ui] << std::endl; + } + } + return true; + }else{ + for( unsigned i=0; i& terms ){ + for( unsigned i=0; igetCurrentValue( qi->d_match[i] ); + int repVar = getCurrentRepVar( i ); + Node cv; + //std::map< int, TNode >::iterator itmt = qi->d_match_term.find( repVar ); + if( !d_match_term[repVar].isNull() ){ + cv = d_match_term[repVar]; + }else{ + cv = d_match[repVar]; + } + Debug("qcf-check-inst") << "INST : " << i << " -> " << cv << ", from " << d_match[i] << std::endl; + terms.push_back( cv ); + } +} + +void QuantInfo::revertMatch( std::vector< int >& assigned ) { + for( unsigned i=0; i "; + if( !d_match[i].isNull() ){ + Trace(c) << d_match[i]; + }else{ + Trace(c) << "(unassigned) "; + } + if( !d_curr_var_deq[i].empty() ){ + Trace(c) << ", DEQ{ "; + for( std::map< TNode, int >::iterator it = d_curr_var_deq[i].begin(); it != d_curr_var_deq[i].end(); ++it ){ + Trace(c) << it->first << " "; + } + Trace(c) << "}"; + } + if( !d_match_term[i].isNull() && d_match_term[i]!=d_match[i] ){ + Trace(c) << ", EXP : " << d_match_term[i]; + } + Trace(c) << std::endl; + } + if( !d_tconstraints.empty() ){ + Trace(c) << "ADDITIONAL CONSTRAINTS : " << std::endl; + for( std::map< Node, bool >::iterator it = d_tconstraints.begin(); it != d_tconstraints.end(); ++it ){ + Trace(c) << " " << it->first << " -> " << it->second << std::endl; + } + } +} + +MatchGen::MatchGen( QuantInfo * qi, Node n, bool isVar ){ + Trace("qcf-qregister-debug") << "Make match gen for " << n << ", isVar = " << isVar << std::endl; + std::vector< Node > qni_apps; + d_qni_size = 0; + if( isVar ){ + Assert( qi->d_var_num.find( n )!=qi->d_var_num.end() ); + if( n.getKind()==ITE ){ + d_type = typ_ite_var; + d_type_not = false; + d_n = n; + d_children.push_back( MatchGen( qi, d_n[0] ) ); + if( d_children[0].isValid() ){ + d_type = typ_ite_var; + for( unsigned i=1; i<=2; i++ ){ + Node nn = n.eqNode( n[i] ); + d_children.push_back( MatchGen( qi, nn ) ); + d_children[d_children.size()-1].d_qni_bound_except.push_back( 0 ); + if( !d_children[d_children.size()-1].isValid() ){ + setInvalid(); + break; + } + } + }else{ + d_type = typ_invalid; + } + }else{ + d_type = isHandledUfTerm( n ) ? typ_var : typ_tsym; + d_qni_var_num[0] = qi->getVarNum( n ); + d_qni_size++; + d_type_not = false; + d_n = n; + //Node f = getOperator( n ); + for( unsigned j=0; jisVar( nn ) ){ + int v = qi->d_var_num[nn]; + Trace("qcf-qregister-debug") << " is var #" << v << std::endl; + d_qni_var_num[d_qni_size] = v; + //qi->addFuncParent( v, f, j ); + }else{ + Trace("qcf-qregister-debug") << " is gterm " << nn << std::endl; + d_qni_gterm[d_qni_size] = nn; + } + d_qni_size++; + } + } + }else{ + if( n.hasBoundVar() ){ + d_type_not = false; + d_n = n; + if( d_n.getKind()==NOT ){ + d_n = d_n[0]; + d_type_not = !d_type_not; + } + + if( isHandledBoolConnective( d_n ) ){ + //non-literals + d_type = typ_formula; + for( unsigned i=0; id_qinfo[q].isVar( cn[0] ) || p->d_qinfo[q].isVar( cn[1] ) ); + //make it a built-in constraint instead + for( unsigned i=0; i<2; i++ ){ + if( p->d_qinfo[q].isVar( cn[i] ) ){ + int v = p->d_qinfo[q].getVarNum( cn[i] ); + Node cno = cn[i==0 ? 1 : 0]; + p->d_qinfo[q].d_var_constraint[ cIsNot ? 0 : 1 ][v].push_back( cno ); + break; + } + } + d_children.pop_back(); + } + */ + } + }else{ + d_type = typ_invalid; + //literals + if( isHandledUfTerm( d_n ) ){ + Assert( qi->isVar( d_n ) ); + d_type = typ_pred; + }else if( d_n.getKind()==BOUND_VARIABLE ){ + Assert( d_n.getType().isBoolean() ); + d_type = typ_bool_var; + }else if( d_n.getKind()==EQUAL || options::qcfTConstraint() ){ + for( unsigned i=0; iisVar( d_n[i] ) ){ + Trace("qcf-qregister-debug") << "ERROR : not var " << d_n[i] << std::endl; + } + Assert( qi->isVar( d_n[i] ) ); + if( d_n.getKind()!=EQUAL && qi->isVar( d_n[i] ) ){ + d_qni_var_num[i+1] = qi->d_var_num[d_n[i]]; + } + }else{ + d_qni_gterm[i] = d_n[i]; + } + } + d_type = d_n.getKind()==EQUAL ? typ_eq : typ_tconstraint; + Trace("qcf-tconstraint") << "T-Constraint : " << d_n << std::endl; + } + } + }else{ + //we will just evaluate + d_n = n; + d_type = typ_ground; + } + //if( d_type!=typ_invalid ){ + //determine an efficient children ordering + //if( !d_children.empty() ){ + //for( unsigned i=0; i& cbvars ) { + int v = qi->getVarNum( n ); + if( v!=-1 && std::find( cbvars.begin(), cbvars.end(), v )==cbvars.end() ){ + cbvars.push_back( v ); + } + for( unsigned i=0; i& bvars ) { + Trace("qcf-qregister-debug") << "Determine variable order " << d_n << std::endl; + bool isCom = d_type==typ_formula && ( d_n.getKind()==OR || d_n.getKind()==AND || d_n.getKind()==IFF ); + std::map< int, std::vector< int > > c_to_vars; + std::map< int, std::vector< int > > vars_to_c; + std::map< int, int > vb_count; + std::map< int, int > vu_count; + std::vector< bool > assigned; + Trace("qcf-qregister-debug") << "Calculate bound variables..." << std::endl; + for( unsigned i=0; i::iterator it = d_qni_gterm.begin(); it != d_qni_gterm.end(); ++it ){ + d_qni_gterm_rep[it->first] = p->getRepresentative( it->second ); + } + if( d_type==typ_ground ){ + int e = p->evaluate( d_n ); + if( e==1 ){ + d_ground_eval[0] = p->d_true; + }else if( e==-1 ){ + d_ground_eval[0] = p->d_false; + } + }else if( d_type==typ_eq ){ + for( unsigned i=0; ievaluateTerm( d_n[i] ); + } + } + } + d_qni_bound_cons.clear(); + d_qni_bound_cons_var.clear(); + d_qni_bound.clear(); +} + +void MatchGen::reset( QuantConflictFind * p, bool tgt, QuantInfo * qi ) { + d_tgt = d_type_not ? !tgt : tgt; + Debug("qcf-match") << " Reset for : " << d_n << ", type : "; + debugPrintType( "qcf-match", d_type ); + Debug("qcf-match") << ", tgt = " << d_tgt << ", children = " << d_children.size() << " " << d_children_order.size() << std::endl; + d_qn.clear(); + d_qni.clear(); + d_qni_bound.clear(); + d_child_counter = -1; + d_tgt_orig = d_tgt; + + //set up processing matches + if( d_type==typ_invalid ){ + //do nothing + }else if( d_type==typ_ground ){ + if( d_ground_eval[0]==( d_tgt ? p->d_true : p->d_false ) ){ + d_child_counter = 0; + } + }else if( d_type==typ_bool_var ){ + //get current value of the variable + TNode n = qi->getCurrentValue( d_n ); + int vn = qi->getCurrentRepVar( qi->getVarNum( n ) ); + if( vn==-1 ){ + //evaluate the value, see if it is compatible + int e = p->evaluate( n ); + if( ( e==1 && d_tgt ) || ( e==0 && !d_tgt ) ){ + d_child_counter = 0; + } + }else{ + //unassigned, set match to true/false + d_qni_bound[0] = vn; + qi->setMatch( p, vn, d_tgt ? p->d_true : p->d_false ); + d_child_counter = 0; + } + if( d_child_counter==0 ){ + d_qn.push_back( NULL ); + } + }else if( d_type==typ_var ){ + Assert( isHandledUfTerm( d_n ) ); + Node f = getOperator( p, d_n ); + Debug("qcf-match-debug") << " reset: Var will match operators of " << f << std::endl; + TermArgTrie * qni = p->getTermDatabase()->getTermArgTrie( Node::null(), f ); + if( qni!=NULL ){ + d_qn.push_back( qni ); + } + d_matched_basis = false; + }else if( d_type==typ_tsym || d_type==typ_tconstraint ){ + for( std::map< int, int >::iterator it = d_qni_var_num.begin(); it != d_qni_var_num.end(); ++it ){ + int repVar = qi->getCurrentRepVar( it->second ); + if( qi->d_match[repVar].isNull() ){ + Debug("qcf-match-debug") << "Force matching on child #" << it->first << ", which is var #" << repVar << std::endl; + d_qni_bound[it->first] = repVar; + } + } + d_qn.push_back( NULL ); + }else if( d_type==typ_pred || d_type==typ_eq ){ + //add initial constraint + Node nn[2]; + int vn[2]; + if( d_type==typ_pred ){ + nn[0] = qi->getCurrentValue( d_n ); + vn[0] = qi->getCurrentRepVar( qi->getVarNum( nn[0] ) ); + nn[1] = p->getRepresentative( d_tgt ? p->d_true : p->d_false ); + vn[1] = -1; + d_tgt = true; + }else{ + for( unsigned i=0; i<2; i++ ){ + TNode nc; + std::map< int, TNode >::iterator it = d_qni_gterm_rep.find( i ); + if( it!=d_qni_gterm_rep.end() ){ + nc = it->second; + }else{ + nc = d_n[i]; + } + nn[i] = qi->getCurrentValue( nc ); + vn[i] = qi->getCurrentRepVar( qi->getVarNum( nn[i] ) ); + } + } + bool success; + if( vn[0]==-1 && vn[1]==-1 ){ + //Trace("qcf-explain") << " reset : " << d_n << " check ground values " << nn[0] << " " << nn[1] << " (tgt=" << d_tgt << ")" << std::endl; + Debug("qcf-match-debug") << " reset: check ground values " << nn[0] << " " << nn[1] << " (" << d_tgt << ")" << std::endl; + //just compare values + if( d_tgt ){ + success = p->areMatchEqual( nn[0], nn[1] ); + }else{ + if( p->d_effort==QuantConflictFind::effort_conflict ){ + success = p->areDisequal( nn[0], nn[1] ); + }else{ + success = p->areMatchDisequal( nn[0], nn[1] ); + } + } + }else{ + //otherwise, add a constraint to a variable + if( vn[1]!=-1 && vn[0]==-1 ){ + //swap + Node t = nn[1]; + nn[1] = nn[0]; + nn[0] = t; + vn[0] = vn[1]; + vn[1] = -1; + } + Debug("qcf-match-debug") << " reset: add constraint " << vn[0] << " -> " << nn[1] << " (vn=" << vn[1] << ")" << std::endl; + //add some constraint + int addc = qi->addConstraint( p, vn[0], nn[1], vn[1], d_tgt, false ); + success = addc!=-1; + //if successful and non-redundant, store that we need to cleanup this + if( addc==1 ){ + //Trace("qcf-explain") << " reset: " << d_n << " add constraint " << vn[0] << " -> " << nn[1] << " (vn=" << vn[1] << ")" << ", d_tgt = " << d_tgt << std::endl; + for( unsigned i=0; i<2; i++ ){ + if( vn[i]!=-1 && std::find( d_qni_bound_except.begin(), d_qni_bound_except.end(), i )==d_qni_bound_except.end() ){ + d_qni_bound[vn[i]] = vn[i]; + } + } + d_qni_bound_cons[vn[0]] = nn[1]; + d_qni_bound_cons_var[vn[0]] = vn[1]; + } + } + //if successful, we will bind values to variables + if( success ){ + d_qn.push_back( NULL ); + } + }else{ + if( d_children.empty() ){ + //add dummy + d_qn.push_back( NULL ); + }else{ + if( d_tgt && d_n.getKind()==FORALL ){ + //do nothing + }else{ + //reset the first child to d_tgt + d_child_counter = 0; + getChild( d_child_counter )->reset( p, d_tgt, qi ); + } + } + } + d_binding = false; + d_wasSet = true; + Debug("qcf-match") << " reset: Finished reset for " << d_n << ", success = " << ( !d_qn.empty() || d_child_counter!=-1 ) << std::endl; +} + +bool MatchGen::getNextMatch( QuantConflictFind * p, QuantInfo * qi ) { + Debug("qcf-match") << " Get next match for : " << d_n << ", type = "; + debugPrintType( "qcf-match", d_type ); + Debug("qcf-match") << ", children = " << d_children.size() << ", binding = " << d_binding << std::endl; + if( d_type==typ_invalid || d_type==typ_ground ){ + if( d_child_counter==0 ){ + d_child_counter = -1; + return true; + }else{ + d_wasSet = false; + return false; + } + }else if( d_type==typ_var || d_type==typ_eq || d_type==typ_pred || d_type==typ_bool_var || d_type==typ_tconstraint || d_type==typ_tsym ){ + bool success = false; + bool terminate = false; + do { + bool doReset = false; + bool doFail = false; + if( !d_binding ){ + if( doMatching( p, qi ) ){ + Debug("qcf-match-debug") << " - Matching succeeded" << std::endl; + d_binding = true; + d_binding_it = d_qni_bound.begin(); + doReset = true; + //for tconstraint, add constraint + if( d_type==typ_tconstraint ){ + std::map< Node, bool >::iterator it = qi->d_tconstraints.find( d_n ); + if( it==qi->d_tconstraints.end() ){ + qi->d_tconstraints[d_n] = d_tgt; + //store that we added this constraint + d_qni_bound_cons[0] = d_n; + }else if( d_tgt!=it->second ){ + success = false; + terminate = true; + } + } + }else{ + Debug("qcf-match-debug") << " - Matching failed" << std::endl; + success = false; + terminate = true; + } + }else{ + doFail = true; + } + if( d_binding ){ + //also need to create match for each variable we bound + success = true; + Debug("qcf-match-debug") << " Produce matches for bound variables by " << d_n << ", type = "; + debugPrintType( "qcf-match-debug", d_type ); + Debug("qcf-match-debug") << "..." << std::endl; + + while( ( success && d_binding_it!=d_qni_bound.end() ) || doFail ){ + std::map< int, MatchGen * >::iterator itm; + if( !doFail ){ + Debug("qcf-match-debug") << " check variable " << d_binding_it->second << std::endl; + itm = qi->d_var_mg.find( d_binding_it->second ); + } + if( doFail || ( d_binding_it->first!=0 && itm!=qi->d_var_mg.end() ) ){ + Debug("qcf-match-debug") << " we had bound variable " << d_binding_it->second << ", reset = " << doReset << std::endl; + if( doReset ){ + itm->second->reset( p, true, qi ); + } + if( doFail || !itm->second->getNextMatch( p, qi ) ){ + do { + if( d_binding_it==d_qni_bound.begin() ){ + Debug("qcf-match-debug") << " failed." << std::endl; + success = false; + }else{ + --d_binding_it; + Debug("qcf-match-debug") << " decrement..." << std::endl; + } + }while( success && ( d_binding_it->first==0 || qi->d_var_mg.find( d_binding_it->second )==qi->d_var_mg.end() ) ); + doReset = false; + doFail = false; + }else{ + Debug("qcf-match-debug") << " increment..." << std::endl; + ++d_binding_it; + doReset = true; + } + }else{ + Debug("qcf-match-debug") << " skip..." << d_binding_it->second << std::endl; + ++d_binding_it; + doReset = true; + } + } + if( !success ){ + d_binding = false; + }else{ + terminate = true; + if( d_binding_it==d_qni_bound.begin() ){ + d_binding = false; + } + } + } + }while( !terminate ); + //if not successful, clean up the variables you bound + if( !success ){ + if( d_type==typ_eq || d_type==typ_pred ){ + //clean up the constraints you added + for( std::map< int, TNode >::iterator it = d_qni_bound_cons.begin(); it != d_qni_bound_cons.end(); ++it ){ + if( !it->second.isNull() ){ + Debug("qcf-match") << " Clean up bound var " << it->first << (d_tgt ? "!" : "") << " = " << it->second << std::endl; + std::map< int, int >::iterator itb = d_qni_bound_cons_var.find( it->first ); + int vn = itb!=d_qni_bound_cons_var.end() ? itb->second : -1; + //Trace("qcf-explain") << " cleanup: " << d_n << " remove constraint " << it->first << " -> " << it->second << " (vn=" << vn << ")" << ", d_tgt = " << d_tgt << std::endl; + qi->addConstraint( p, it->first, it->second, vn, d_tgt, true ); + } + } + d_qni_bound_cons.clear(); + d_qni_bound_cons_var.clear(); + d_qni_bound.clear(); + }else{ + //clean up the matches you set + for( std::map< int, int >::iterator it = d_qni_bound.begin(); it != d_qni_bound.end(); ++it ){ + Debug("qcf-match") << " Clean up bound var " << it->second << std::endl; + Assert( it->secondgetNumVars() ); + qi->d_match[ it->second ] = TNode::null(); + qi->d_match_term[ it->second ] = TNode::null(); + } + d_qni_bound.clear(); + } + if( d_type==typ_tconstraint ){ + //remove constraint if applicable + if( d_qni_bound_cons.find( 0 )!=d_qni_bound_cons.end() ){ + qi->d_tconstraints.erase( d_n ); + d_qni_bound_cons.clear(); + } + } + /* + if( d_type==typ_var && p->d_effort==QuantConflictFind::effort_mc && !d_matched_basis ){ + d_matched_basis = true; + Node f = getOperator( d_n ); + TNode mbo = p->getQuantifiersEngine()->getTermDatabase()->getModelBasisOpTerm( f ); + if( qi->setMatch( p, d_qni_var_num[0], mbo ) ){ + success = true; + d_qni_bound[0] = d_qni_var_num[0]; + } + } + */ + } + Debug("qcf-match") << " ...finished matching for " << d_n << ", success = " << success << std::endl; + d_wasSet = success; + return success; + }else if( d_type==typ_formula || d_type==typ_ite_var ){ + bool success = false; + if( d_child_counter<0 ){ + if( d_child_counter<-1 ){ + success = true; + d_child_counter = -1; + } + }else{ + while( !success && d_child_counter>=0 ){ + //transition system based on d_child_counter + if( d_n.getKind()==OR || d_n.getKind()==AND ){ + if( (d_n.getKind()==AND)==d_tgt ){ + //all children must match simultaneously + if( getChild( d_child_counter )->getNextMatch( p, qi ) ){ + if( d_child_counter<(int)(getNumChildren()-1) ){ + d_child_counter++; + Debug("qcf-match-debug") << " Reset child " << d_child_counter << " of " << d_n << std::endl; + getChild( d_child_counter )->reset( p, d_tgt, qi ); + }else{ + success = true; + } + }else{ + //if( std::find( d_independent.begin(), d_independent.end(), d_child_counter )!=d_independent.end() ){ + // d_child_counter--; + //}else{ + d_child_counter--; + //} + } + }else{ + //one child must match + if( !getChild( d_child_counter )->getNextMatch( p, qi ) ){ + if( d_child_counter<(int)(getNumChildren()-1) ){ + d_child_counter++; + Debug("qcf-match-debug") << " Reset child " << d_child_counter << " of " << d_n << ", one match" << std::endl; + getChild( d_child_counter )->reset( p, d_tgt, qi ); + }else{ + d_child_counter = -1; + } + }else{ + success = true; + } + } + }else if( d_n.getKind()==IFF ){ + //construct match based on both children + if( d_child_counter%2==0 ){ + if( getChild( 0 )->getNextMatch( p, qi ) ){ + d_child_counter++; + getChild( 1 )->reset( p, d_child_counter==1, qi ); + }else{ + if( d_child_counter==0 ){ + d_child_counter = 2; + getChild( 0 )->reset( p, !d_tgt, qi ); + }else{ + d_child_counter = -1; + } + } + } + if( d_child_counter>=0 && d_child_counter%2==1 ){ + if( getChild( 1 )->getNextMatch( p, qi ) ){ + success = true; + }else{ + d_child_counter--; + } + } + }else if( d_n.getKind()==ITE ){ + if( d_child_counter%2==0 ){ + int index1 = d_child_counter==4 ? 1 : 0; + if( getChild( index1 )->getNextMatch( p, qi ) ){ + d_child_counter++; + getChild( d_child_counter==5 ? 2 : (d_tgt==(d_child_counter==1) ? 1 : 2) )->reset( p, d_tgt, qi ); + }else{ + if( d_child_counter==4 || ( d_type==typ_ite_var && d_child_counter==2 ) ){ + d_child_counter = -1; + }else{ + d_child_counter +=2; + getChild( d_child_counter==2 ? 0 : 1 )->reset( p, d_child_counter==2 ? !d_tgt : d_tgt, qi ); + } + } + } + if( d_child_counter>=0 && d_child_counter%2==1 ){ + int index2 = d_child_counter==5 ? 2 : (d_tgt==(d_child_counter==1) ? 1 : 2); + if( getChild( index2 )->getNextMatch( p, qi ) ){ + success = true; + }else{ + d_child_counter--; + } + } + }else if( d_n.getKind()==FORALL ){ + if( getChild( d_child_counter )->getNextMatch( p, qi ) ){ + success = true; + }else{ + d_child_counter = -1; + } + } + } + d_wasSet = success; + Debug("qcf-match") << " ...finished construct match for " << d_n << ", success = " << success << std::endl; + return success; + } + } + Debug("qcf-match") << " ...already finished for " << d_n << std::endl; + return false; +} + +bool MatchGen::getExplanation( QuantConflictFind * p, QuantInfo * qi, std::vector< Node >& exp ) { + if( d_type==typ_eq ){ + Node n[2]; + for( unsigned i=0; i<2; i++ ){ + Trace("qcf-explain") << "Explain term " << d_n[i] << "..." << std::endl; + n[i] = getExplanationTerm( p, qi, d_n[i], exp ); + } + Node eq = n[0].eqNode( n[1] ); + if( !d_tgt_orig ){ + eq = eq.negate(); + } + exp.push_back( eq ); + Trace("qcf-explain") << "Explanation for " << d_n << " (tgt=" << d_tgt_orig << ") is " << eq << ", set = " << d_wasSet << std::endl; + return true; + }else if( d_type==typ_pred ){ + Trace("qcf-explain") << "Explain term " << d_n << "..." << std::endl; + Node n = getExplanationTerm( p, qi, d_n, exp ); + if( !d_tgt_orig ){ + n = n.negate(); + } + exp.push_back( n ); + Trace("qcf-explain") << "Explanation for " << d_n << " (tgt=" << d_tgt_orig << ") is " << n << ", set = " << d_wasSet << std::endl; + return true; + }else if( d_type==typ_formula ){ + Trace("qcf-explain") << "Explanation get for " << d_n << ", counter = " << d_child_counter << ", tgt = " << d_tgt_orig << ", set = " << d_wasSet << std::endl; + if( d_n.getKind()==OR || d_n.getKind()==AND ){ + if( (d_n.getKind()==AND)==d_tgt ){ + for( unsigned i=0; igetExplanation( p, qi, exp ) ){ + return false; + } + } + }else{ + return getChild( d_child_counter )->getExplanation( p, qi, exp ); + } + }else if( d_n.getKind()==IFF ){ + for( unsigned i=0; i<2; i++ ){ + if( !getChild( i )->getExplanation( p, qi, exp ) ){ + return false; + } + } + }else if( d_n.getKind()==ITE ){ + for( unsigned i=0; i<3; i++ ){ + bool isActive = ( ( i==0 && d_child_counter!=5 ) || + ( i==1 && d_child_counter!=( d_tgt ? 3 : 1 ) ) || + ( i==2 && d_child_counter!=( d_tgt ? 1 : 3 ) ) ); + if( isActive ){ + if( !getChild( i )->getExplanation( p, qi, exp ) ){ + return false; + } + } + } + }else{ + return false; + } + return true; + }else{ + return false; + } +} + +Node MatchGen::getExplanationTerm( QuantConflictFind * p, QuantInfo * qi, Node t, std::vector< Node >& exp ) { + Node v = qi->getCurrentExpValue( t ); + if( isHandledUfTerm( t ) ){ + for( unsigned i=0; i0 ); + bool invalidMatch; + do { + invalidMatch = false; + Debug("qcf-match-debug") << " Do matching " << d_n << " " << d_qn.size() << " " << d_qni.size() << std::endl; + if( d_qn.size()==d_qni.size()+1 ) { + int index = (int)d_qni.size(); + //initialize + TNode val; + std::map< int, int >::iterator itv = d_qni_var_num.find( index ); + if( itv!=d_qni_var_num.end() ){ + //get the representative variable this variable is equal to + int repVar = qi->getCurrentRepVar( itv->second ); + Debug("qcf-match-debug") << " Match " << index << " is a variable " << itv->second << ", which is repVar " << repVar << std::endl; + //get the value the rep variable + //std::map< int, TNode >::iterator itm = qi->d_match.find( repVar ); + if( !qi->d_match[repVar].isNull() ){ + val = qi->d_match[repVar]; + Debug("qcf-match-debug") << " Variable is already bound to " << val << std::endl; + }else{ + //binding a variable + d_qni_bound[index] = repVar; + std::map< TNode, TermArgTrie >::iterator it = d_qn[index]->d_data.begin(); + if( it != d_qn[index]->d_data.end() ) { + d_qni.push_back( it ); + //set the match + if( qi->setMatch( p, d_qni_bound[index], it->first ) ){ + Debug("qcf-match-debug") << " Binding variable" << std::endl; + if( d_qn.size()second ); + } + }else{ + Debug("qcf-match") << " Binding variable, currently fail." << std::endl; + invalidMatch = true; + } + }else{ + Debug("qcf-match-debug") << " Binding variable, fail, no more variables to bind" << std::endl; + d_qn.pop_back(); + } + } + }else{ + Debug("qcf-match-debug") << " Match " << index << " is ground term" << std::endl; + Assert( d_qni_gterm.find( index )!=d_qni_gterm.end() ); + Assert( d_qni_gterm_rep.find( index )!=d_qni_gterm_rep.end() ); + val = d_qni_gterm_rep[index]; + Assert( !val.isNull() ); + } + if( !val.isNull() ){ + //constrained by val + std::map< TNode, TermArgTrie >::iterator it = d_qn[index]->d_data.find( val ); + if( it!=d_qn[index]->d_data.end() ){ + Debug("qcf-match-debug") << " Match" << std::endl; + d_qni.push_back( it ); + if( d_qn.size()second ); + } + }else{ + Debug("qcf-match-debug") << " Failed to match" << std::endl; + d_qn.pop_back(); + } + } + }else{ + Assert( d_qn.size()==d_qni.size() ); + int index = d_qni.size()-1; + //increment if binding this variable + bool success = false; + std::map< int, int >::iterator itb = d_qni_bound.find( index ); + if( itb!=d_qni_bound.end() ){ + d_qni[index]++; + if( d_qni[index]!=d_qn[index]->d_data.end() ){ + success = true; + if( qi->setMatch( p, itb->second, d_qni[index]->first ) ){ + Debug("qcf-match-debug") << " Bind next variable" << std::endl; + if( d_qn.size()second ); + } + }else{ + Debug("qcf-match-debug") << " Bind next variable, currently fail" << std::endl; + invalidMatch = true; + } + }else{ + qi->d_match[ itb->second ] = TNode::null(); + qi->d_match_term[ itb->second ] = TNode::null(); + Debug("qcf-match-debug") << " Bind next variable, no more variables to bind" << std::endl; + } + }else{ + //TODO : if it equal to something else, also try that + } + //if not incrementing, move to next + if( !success ){ + d_qn.pop_back(); + d_qni.pop_back(); + } + } + }while( ( !d_qn.empty() && d_qni.size()!=d_qni_size ) || invalidMatch ); + if( d_qni.size()==d_qni_size ){ + //Assert( !d_qni[d_qni.size()-1]->second.d_data.empty() ); + //Debug("qcf-match-debug") << " We matched " << d_qni[d_qni.size()-1]->second.d_children.begin()->first << std::endl; + Assert( !d_qni[d_qni.size()-1]->second.d_data.empty() ); + TNode t = d_qni[d_qni.size()-1]->second.d_data.begin()->first; + Debug("qcf-match-debug") << " " << d_n << " matched " << t << std::endl; + qi->d_match_term[d_qni_var_num[0]] = t; + //set the match terms + for( std::map< int, int >::iterator it = d_qni_bound.begin(); it != d_qni_bound.end(); ++it ){ + Debug("qcf-match-debug") << " position " << it->first << " bounded " << it->second << " / " << qi->d_q[0].getNumChildren() << std::endl; + //if( it->second<(int)qi->d_q[0].getNumChildren() ){ //if it is an actual variable, we are interested in knowing the actual term + if( it->first>0 ){ + Assert( !qi->d_match[ it->second ].isNull() ); + Assert( p->areEqual( t[it->first-1], qi->d_match[ it->second ] ) ); + qi->d_match_term[it->second] = t[it->first-1]; + } + //} + } + } + } + } + return !d_qn.empty(); +} + +void MatchGen::debugPrintType( const char * c, short typ, bool isTrace ) { + if( isTrace ){ + switch( typ ){ + case typ_invalid: Trace(c) << "invalid";break; + case typ_ground: Trace(c) << "ground";break; + case typ_eq: Trace(c) << "eq";break; + case typ_pred: Trace(c) << "pred";break; + case typ_formula: Trace(c) << "formula";break; + case typ_var: Trace(c) << "var";break; + case typ_ite_var: Trace(c) << "ite_var";break; + case typ_bool_var: Trace(c) << "bool_var";break; + } + }else{ + switch( typ ){ + case typ_invalid: Debug(c) << "invalid";break; + case typ_ground: Debug(c) << "ground";break; + case typ_eq: Debug(c) << "eq";break; + case typ_pred: Debug(c) << "pred";break; + case typ_formula: Debug(c) << "formula";break; + case typ_var: Debug(c) << "var";break; + case typ_ite_var: Debug(c) << "ite_var";break; + case typ_bool_var: Debug(c) << "bool_var";break; + } + } +} + +void MatchGen::setInvalid() { + d_type = typ_invalid; + d_children.clear(); +} + +bool MatchGen::isHandledBoolConnective( TNode n ) { + return n.getType().isBoolean() && ( n.getKind()==OR || n.getKind()==AND || n.getKind()==IFF || n.getKind()==ITE || n.getKind()==FORALL || n.getKind()==NOT ); +} + +bool MatchGen::isHandledUfTerm( TNode n ) { + //return n.getKind()==APPLY_UF || n.getKind()==STORE || n.getKind()==SELECT || + // n.getKind()==APPLY_CONSTRUCTOR || n.getKind()==APPLY_SELECTOR_TOTAL || n.getKind()==APPLY_TESTER; + return inst::Trigger::isAtomicTriggerKind( n.getKind() ); +} + +Node MatchGen::getOperator( QuantConflictFind * p, Node n ) { + if( isHandledUfTerm( n ) ){ + return p->getQuantifiersEngine()->getTermDatabase()->getOperator( n ); + }else{ + return Node::null(); + } +} + +bool MatchGen::isHandled( TNode n ) { + if( n.getKind()!=BOUND_VARIABLE && n.hasBoundVar() ){ + if( !isHandledBoolConnective( n ) && !isHandledUfTerm( n ) && n.getKind()!=EQUAL && n.getKind()!=ITE ){ + return false; + } + for( unsigned i=0; imkConst(true); + d_false = NodeManager::currentNM()->mkConst(false); +} + +Node QuantConflictFind::mkEqNode( Node a, Node b ) { + if( a.getType().isBoolean() ){ + return a.iffNode( b ); + }else{ + return a.eqNode( b ); + } +} + +//-------------------------------------------------- registration + +void QuantConflictFind::registerQuantifier( Node q ) { + if( !TermDb::isRewriteRule( q ) ){ + d_quants.push_back( q ); + d_quant_id[q] = d_quants.size(); + Trace("qcf-qregister") << "Register "; + debugPrintQuant( "qcf-qregister", q ); + Trace("qcf-qregister") << " : " << q << std::endl; + //make QcfNode structure + Trace("qcf-qregister") << "- Get relevant equality/disequality pairs, calculate flattening..." << std::endl; + d_qinfo[q].initialize( q, q[1] ); + + //debug print + Trace("qcf-qregister") << "- Flattened structure is :" << std::endl; + Trace("qcf-qregister") << " "; + debugPrintQuantBody( "qcf-qregister", q, q[1] ); + Trace("qcf-qregister") << std::endl; + if( d_qinfo[q].d_vars.size()>q[0].getNumChildren() ){ + Trace("qcf-qregister") << " with additional constraints : " << std::endl; + for( unsigned j=q[0].getNumChildren(); jQuantConflictFind::effort_conflict ){ + // ret = -1; + //} + }else if( n.getKind()==NOT ){ + return -evaluate( n[0] ); + }else if( n.getKind()==ITE ){ + int cev1 = evaluate( n[0] ); + int cevc[2] = { 0, 0 }; + for( unsigned i=0; i<2; i++ ){ + if( ( i==0 && cev1!=-1 ) || ( i==1 && cev1!=1 ) ){ + cevc[i] = evaluate( n[i+1] ); + if( cev1!=0 ){ + ret = cevc[i]; + break; + }else if( cevc[i]==0 ){ + break; + } + } + } + if( ret==0 && cevc[0]!=0 && cevc[0]==cevc[1] ){ + ret = cevc[0]; + } + }else if( n.getKind()==IFF ){ + int cev1 = evaluate( n[0] ); + if( cev1!=0 ){ + int cev2 = evaluate( n[1] ); + if( cev2!=0 ){ + ret = cev1==cev2 ? 1 : -1; + } + } + + }else{ + int ssval = 0; + if( n.getKind()==OR ){ + ssval = 1; + }else if( n.getKind()==AND ){ + ssval = -1; + } + bool isUnk = false; + for( unsigned i=0; i::iterator it = d_qinfo[q].d_rel_eqr.begin(); it != d_qinfo[q].d_rel_eqr.end(); ++it ){ + // it->first->d_active.set( true ); + //} + } +} + +eq::EqualityEngine * QuantConflictFind::getEqualityEngine() { + //return ((uf::TheoryUF*)d_quantEngine->getTheoryEngine()->theoryOf( theory::THEORY_UF ))->getEqualityEngine(); + return d_quantEngine->getTheoryEngine()->getMasterEqualityEngine(); +} +bool QuantConflictFind::areEqual( Node n1, Node n2 ) { + return getEqualityEngine()->hasTerm( n1 ) && getEqualityEngine()->hasTerm( n2 ) && getEqualityEngine()->areEqual( n1,n2 ); +} +bool QuantConflictFind::areDisequal( Node n1, Node n2 ) { + return n1!=n2 && getEqualityEngine()->hasTerm( n1 ) && getEqualityEngine()->hasTerm( n2 ) && getEqualityEngine()->areDisequal( n1,n2, false ); +} +Node QuantConflictFind::getRepresentative( Node n ) { + if( getEqualityEngine()->hasTerm( n ) ){ + return getEqualityEngine()->getRepresentative( n ); + }else{ + return n; + } +} +TermDb* QuantConflictFind::getTermDatabase() { + return d_quantEngine->getTermDatabase(); +} + +Node QuantConflictFind::evaluateTerm( Node n ) { + if( MatchGen::isHandledUfTerm( n ) ){ + Node f = MatchGen::getOperator( this, n ); + Node nn; + if( getEqualityEngine()->hasTerm( n ) ){ + nn = getTermDatabase()->existsTerm( f, n ); + }else{ + std::vector< TNode > args; + for( unsigned i=0; id_func_map_trie[f].existsTerm( args ); + } + if( !nn.isNull() ){ + Debug("qcf-eval") << "GT: Term " << nn << " for " << n << " hasTerm = " << getEqualityEngine()->hasTerm( n ) << std::endl; + return getRepresentative( nn ); + }else{ + Debug("qcf-eval") << "GT: No term for " << n << " hasTerm = " << getEqualityEngine()->hasTerm( n ) << std::endl; + return n; + } + }else if( n.getKind()==ITE ){ + int v = evaluate( n[0], false, false ); + if( v==1 ){ + return evaluateTerm( n[1] ); + }else if( v==-1 ){ + return evaluateTerm( n[2] ); + } + } + return getRepresentative( n ); +} + +/** new node */ +void QuantConflictFind::newEqClass( Node n ) { + //Trace("qcf-proc-debug") << "QCF : newEqClass : " << n << std::endl; + //Trace("qcf-proc2-debug") << "QCF : finished newEqClass : " << n << std::endl; +} + +/** merge */ +void QuantConflictFind::merge( Node a, Node b ) { + +} + +/** assert disequal */ +void QuantConflictFind::assertDisequal( Node a, Node b ) { + +} + +//-------------------------------------------------- check function + +void QuantConflictFind::reset_round( Theory::Effort level ) { + d_needs_computeRelEqr = true; +} + +/** check */ +void QuantConflictFind::check( Theory::Effort level ) { + Trace("qcf-check") << "QCF : check : " << level << std::endl; + if( d_conflict ){ + Trace("qcf-check2") << "QCF : finished check : already in conflict." << std::endl; + if( level>=Theory::EFFORT_FULL ){ + Trace("qcf-warn") << "ALREADY IN CONFLICT? " << level << std::endl; + //Assert( false ); + } + }else{ + int addedLemmas = 0; + if( d_performCheck ){ + ++(d_statistics.d_inst_rounds); + double clSet = 0; + int prevEt = 0; + if( Trace.isOn("qcf-engine") ){ + prevEt = d_statistics.d_entailment_checks.getData(); + clSet = double(clock())/double(CLOCKS_PER_SEC); + Trace("qcf-engine") << "---Conflict Find Engine Round, effort = " << level << "---" << std::endl; + } + computeRelevantEqr(); + + //determine order for quantified formulas + std::vector< Node > qorder; + std::map< Node, bool > qassert; + //mark which are asserted + for( unsigned i=0; id_mg->isValid() ){ + Trace("qcf-check") << "Check quantified formula "; + debugPrintQuant("qcf-check", q); + Trace("qcf-check") << " : " << q << "..." << std::endl; + + Trace("qcf-check-debug") << "Reset round..." << std::endl; + qi->reset_round( this ); + //try to make a matches making the body false + Trace("qcf-check-debug") << "Get next match..." << std::endl; + while( qi->d_mg->getNextMatch( this, qi ) ){ + Trace("qcf-check") << "*** Produced match at effort " << e << " : " << std::endl; + qi->debugPrintMatch("qcf-check"); + Trace("qcf-check") << std::endl; + std::vector< int > assigned; + if( !qi->isMatchSpurious( this ) ){ + if( qi->completeMatch( this, assigned ) ){ + std::vector< Node > terms; + qi->getMatch( terms ); + if( !qi->isTConstraintSpurious( this, terms ) ){ + if( Debug.isOn("qcf-check-inst") ){ + //if( e==effort_conflict ){ + Node inst = d_quantEngine->getInstantiation( q, terms ); + Debug("qcf-check-inst") << "Check instantiation " << inst << "..." << std::endl; + Assert( evaluate( inst )!=1 ); + Assert( evaluate( inst )==-1 || e>effort_conflict ); + //} + } + if( d_quantEngine->addInstantiation( q, terms, false ) ){ + Trace("qcf-check") << " ... Added instantiation" << std::endl; + Trace("qcf-inst") << "*** Was from effort " << e << " : " << std::endl; + qi->debugPrintMatch("qcf-inst"); + Trace("qcf-inst") << std::endl; + ++addedLemmas; + if( e==effort_conflict ){ + d_quant_order.insert( d_quant_order.begin(), q ); + d_conflict.set( true ); + ++(d_statistics.d_conflict_inst); + break; + }else if( e==effort_prop_eq ){ + ++(d_statistics.d_prop_inst); + } + }else{ + Trace("qcf-check") << " ... Failed to add instantiation" << std::endl; + //Assert( false ); + } + } + //clean up assigned + qi->revertMatch( assigned ); + d_tempCache.clear(); + }else{ + Trace("qcf-check") << " ... Spurious instantiation (cannot assign unassigned variables)" << std::endl; + } + }else{ + Trace("qcf-check") << " ... Spurious instantiation (match is inconsistent)" << std::endl; + } + } + if( d_conflict ){ + break; + } + } + } + if( addedLemmas>0 ){ + d_quantEngine->flushLemmas(); + break; + } + } + if( Trace.isOn("qcf-engine") ){ + double clSet2 = double(clock())/double(CLOCKS_PER_SEC); + Trace("qcf-engine") << "Finished conflict find engine, time = " << (clSet2-clSet); + if( addedLemmas>0 ){ + Trace("qcf-engine") << ", effort = " << ( d_effort==effort_conflict ? "conflict" : ( d_effort==effort_prop_eq ? "prop_eq" : "mc" ) ); + Trace("qcf-engine") << ", addedLemmas = " << addedLemmas; + } + Trace("qcf-engine") << std::endl; + int currEt = d_statistics.d_entailment_checks.getData(); + if( currEt!=prevEt ){ + Trace("qcf-engine") << " Entailment checks = " << ( currEt - prevEt ) << std::endl; + } + } + } + Trace("qcf-check2") << "QCF : finished check : " << level << std::endl; + } +} + +bool QuantConflictFind::needsCheck( Theory::Effort level ) { + d_performCheck = false; + if( options::quantConflictFind() && !d_conflict ){ + if( level==Theory::EFFORT_LAST_CALL ){ + d_performCheck = options::qcfWhenMode()==QCF_WHEN_MODE_LAST_CALL; + }else if( level==Theory::EFFORT_FULL ){ + d_performCheck = options::qcfWhenMode()==QCF_WHEN_MODE_DEFAULT; + }else if( level==Theory::EFFORT_STANDARD ){ + d_performCheck = options::qcfWhenMode()==QCF_WHEN_MODE_STD; + } + } + return d_performCheck; +} + +void QuantConflictFind::computeRelevantEqr() { + if( d_needs_computeRelEqr ){ + d_needs_computeRelEqr = false; + Trace("qcf-check") << "Compute relevant equalities..." << std::endl; + //d_uf_terms.clear(); + //d_eqc_uf_terms.clear(); + d_eqcs.clear(); + d_model_basis.clear(); + //d_arg_reps.clear(); + //double clSet = 0; + //if( Trace.isOn("qcf-opt") ){ + // clSet = double(clock())/double(CLOCKS_PER_SEC); + //} + + //long nTermst = 0; + //long nTerms = 0; + //long nEqc = 0; + + //which nodes are irrelevant for disequality matches + std::map< TNode, bool > irrelevant_dnode; + //now, store matches + eq::EqClassesIterator eqcs_i = eq::EqClassesIterator( getEqualityEngine() ); + while( !eqcs_i.isFinished() ){ + //nEqc++; + Node r = (*eqcs_i); + TypeNode rtn = r.getType(); + if( options::qcfMode()==QCF_MC ){ + std::map< TypeNode, std::vector< TNode > >::iterator itt = d_eqcs.find( rtn ); + if( itt==d_eqcs.end() ){ + Node mb = getQuantifiersEngine()->getTermDatabase()->getModelBasisTerm( rtn ); + if( !getEqualityEngine()->hasTerm( mb ) ){ + Trace("qcf-warn") << "WARNING: Model basis term does not exist!" << std::endl; + Assert( false ); + } + Node mbr = getRepresentative( mb ); + if( mbr!=r ){ + d_eqcs[rtn].push_back( mbr ); + } + d_eqcs[rtn].push_back( r ); + d_model_basis[rtn] = mb; + }else{ + itt->second.push_back( r ); + } + }else{ + d_eqcs[rtn].push_back( r ); + } + ++eqcs_i; + } + /* + if( Trace.isOn("qcf-opt") ){ + double clSet2 = double(clock())/double(CLOCKS_PER_SEC); + Trace("qcf-opt") << "Compute rel eqc : " << std::endl; + Trace("qcf-opt") << " " << nEqc << " equivalence classes. " << std::endl; + Trace("qcf-opt") << " " << nTerms << " / " << nTermst << " terms." << std::endl; + Trace("qcf-opt") << " Time : " << (clSet2-clSet) << std::endl; + } + */ + } +} + + +//-------------------------------------------------- debugging + + +void QuantConflictFind::debugPrint( const char * c ) { + //print the equivalance classes + Trace(c) << "----------EQ classes" << std::endl; + eq::EqClassesIterator eqcs_i = eq::EqClassesIterator( getEqualityEngine() ); + while( !eqcs_i.isFinished() ){ + Node n = (*eqcs_i); + //if( !n.getType().isInteger() ){ + Trace(c) << " - " << n << " : {"; + eq::EqClassIterator eqc_i = eq::EqClassIterator( n, getEqualityEngine() ); + bool pr = false; + while( !eqc_i.isFinished() ){ + Node nn = (*eqc_i); + if( nn.getKind()!=EQUAL && nn!=n ){ + Trace(c) << (pr ? "," : "" ) << " " << nn; + pr = true; + } + ++eqc_i; + } + Trace(c) << (pr ? " " : "" ) << "}" << std::endl; + /* + EqcInfo * eqcn = getEqcInfo( n, false ); + if( eqcn ){ + Trace(c) << " DEQ : {"; + pr = false; + for( NodeBoolMap::iterator it = eqcn->d_diseq.begin(); it != eqcn->d_diseq.end(); ++it ){ + if( (*it).second ){ + Trace(c) << (pr ? "," : "" ) << " " << (*it).first; + pr = true; + } + } + Trace(c) << (pr ? " " : "" ) << "}" << std::endl; + } + //} + */ + ++eqcs_i; + } +} + +void QuantConflictFind::debugPrintQuant( const char * c, Node q ) { + Trace(c) << "Q" << d_quant_id[q]; +} + +void QuantConflictFind::debugPrintQuantBody( const char * c, Node q, Node n, bool doVarNum ) { + if( n.getNumChildren()==0 ){ + Trace(c) << n; + }else if( doVarNum && d_qinfo[q].d_var_num.find( n )!=d_qinfo[q].d_var_num.end() ){ + Trace(c) << "?x" << d_qinfo[q].d_var_num[n]; + }else{ + Trace(c) << "("; + if( n.getKind()==APPLY_UF ){ + Trace(c) << n.getOperator(); + }else{ + Trace(c) << n.getKind(); + } + for( unsigned i=0; i::iterator it = d_zero.find( k ); + if( it==d_zero.end() ){ + Node nn; + if( k==PLUS ){ + nn = NodeManager::currentNM()->mkConst( Rational(0) ); + } + d_zero[k] = nn; + return nn; + }else{ + return it->second; + } +} + + +} diff --git a/src/theory/quantifiers/quant_conflict_find.h b/src/theory/quantifiers/quant_conflict_find.h old mode 100644 new mode 100755 index 0464c04e5..1f3635e78 --- a/src/theory/quantifiers/quant_conflict_find.h +++ b/src/theory/quantifiers/quant_conflict_find.h @@ -1,297 +1,260 @@ -/********************* */ -/*! \file quant_conflict_find.h - ** \verbatim - ** Original author: Andrew Reynolds - ** Major contributors: Morgan Deters - ** Minor contributors (to current version): none - ** This file is part of the CVC4 project. - ** Copyright (c) 2009-2014 New York University and The University of Iowa - ** See the file COPYING in the top-level source directory for licensing - ** information.\endverbatim - ** - ** \brief quantifiers conflict find class - **/ - -#include "cvc4_private.h" - -#ifndef QUANT_CONFLICT_FIND -#define QUANT_CONFLICT_FIND - -#include "context/cdhashmap.h" -#include "context/cdchunk_list.h" -#include "theory/quantifiers_engine.h" - -namespace CVC4 { -namespace theory { -namespace quantifiers { - -class QcfNode; - -class QuantConflictFind; - -class QcfNodeIndex { -public: - std::map< TNode, QcfNodeIndex > d_children; - void clear() { d_children.clear(); } - void debugPrint( const char * c, int t ); - Node existsTerm( TNode n, std::vector< TNode >& reps, int index = 0 ); - Node addTerm( TNode n, std::vector< TNode >& reps, int index = 0 ); -}; - -class QuantInfo; - -//match generator -class MatchGen { - friend class QuantInfo; -private: - //current children information - int d_child_counter; - //children of this object - std::vector< int > d_children_order; - unsigned getNumChildren() { return d_children.size(); } - MatchGen * getChild( int i ) { return &d_children[d_children_order[i]]; } - //MatchGen * getChild( int i ) { return &d_children[i]; } - //current matching information - std::vector< QcfNodeIndex * > d_qn; - std::vector< std::map< TNode, QcfNodeIndex >::iterator > d_qni; - bool doMatching( QuantConflictFind * p, QuantInfo * qi ); - //for matching : each index is either a variable or a ground term - unsigned d_qni_size; - std::map< int, int > d_qni_var_num; - std::map< int, TNode > d_qni_gterm; - std::map< int, TNode > d_qni_gterm_rep; - std::map< int, int > d_qni_bound; - std::vector< int > d_qni_bound_except; - std::map< int, TNode > d_qni_bound_cons; - std::map< int, int > d_qni_bound_cons_var; - std::map< int, int >::iterator d_binding_it; - //std::vector< int > d_independent; - bool d_matched_basis; - bool d_binding; - //int getVarBindingVar(); - std::map< int, Node > d_ground_eval; - //determine variable order - void determineVariableOrder( QuantInfo * qi, std::vector< int >& bvars ); - void collectBoundVar( QuantInfo * qi, Node n, std::vector< int >& cbvars ); -public: - //type of the match generator - enum { - typ_invalid, - typ_ground, - typ_pred, - typ_eq, - typ_formula, - typ_var, - typ_ite_var, - typ_bool_var, - typ_tconstraint, - typ_tsym, - }; - void debugPrintType( const char * c, short typ, bool isTrace = false ); -public: - MatchGen() : d_type( typ_invalid ){} - MatchGen( QuantInfo * qi, Node n, bool isVar = false ); - bool d_tgt; - bool d_tgt_orig; - bool d_wasSet; - Node d_n; - std::vector< MatchGen > d_children; - short d_type; - bool d_type_not; - void reset_round( QuantConflictFind * p ); - void reset( QuantConflictFind * p, bool tgt, QuantInfo * qi ); - bool getNextMatch( QuantConflictFind * p, QuantInfo * qi ); - bool getExplanation( QuantConflictFind * p, QuantInfo * qi, std::vector< Node >& exp ); - Node getExplanationTerm( QuantConflictFind * p, QuantInfo * qi, Node t, std::vector< Node >& exp ); - bool isValid() { return d_type!=typ_invalid; } - void setInvalid(); - - // is this term treated as UF application? - static bool isHandledBoolConnective( TNode n ); - static bool isHandledUfTerm( TNode n ); - static Node getOperator( QuantConflictFind * p, Node n ); - //can this node be handled by the algorithm - static bool isHandled( TNode n ); -}; - -//info for quantifiers -class QuantInfo { -private: - void registerNode( Node n, bool hasPol, bool pol, bool beneathQuant = false ); - void flatten( Node n, bool beneathQuant ); -private: //for completing match - std::vector< int > d_unassigned; - std::vector< TypeNode > d_unassigned_tn; - int d_unassigned_nvar; - int d_una_index; - std::vector< int > d_una_eqc_count; -public: - QuantInfo() : d_mg( NULL ) {} - ~QuantInfo() { delete d_mg; } - std::vector< TNode > d_vars; - std::map< TNode, int > d_var_num; - std::vector< int > d_tsym_vars; - std::map< TNode, bool > d_inMatchConstraint; - std::map< int, std::vector< Node > > d_var_constraint[2]; - int getVarNum( TNode v ) { return d_var_num.find( v )!=d_var_num.end() ? d_var_num[v] : -1; } - bool isVar( TNode v ) { return d_var_num.find( v )!=d_var_num.end(); } - int getNumVars() { return (int)d_vars.size(); } - TNode getVar( int i ) { return d_vars[i]; } - - MatchGen * d_mg; - Node d_q; - std::map< int, MatchGen * > d_var_mg; - void reset_round( QuantConflictFind * p ); -public: - //initialize - void initialize( Node q, Node qn ); - //current constraints - std::vector< TNode > d_match; - std::vector< TNode > d_match_term; - std::map< int, std::map< TNode, int > > d_curr_var_deq; - std::map< Node, bool > d_tconstraints; - int getCurrentRepVar( int v ); - TNode getCurrentValue( TNode n ); - TNode getCurrentExpValue( TNode n ); - bool getCurrentCanBeEqual( QuantConflictFind * p, int v, TNode n, bool chDiseq = false ); - int addConstraint( QuantConflictFind * p, int v, TNode n, bool polarity ); - int addConstraint( QuantConflictFind * p, int v, TNode n, int vn, bool polarity, bool doRemove ); - bool setMatch( QuantConflictFind * p, int v, TNode n ); - bool isMatchSpurious( QuantConflictFind * p ); - bool isTConstraintSpurious( QuantConflictFind * p, std::vector< Node >& terms ); - bool entailmentTest( QuantConflictFind * p, Node lit, bool chEnt = true ); - bool completeMatch( QuantConflictFind * p, std::vector< int >& assigned, bool doContinue = false ); - void revertMatch( std::vector< int >& assigned ); - void debugPrintMatch( const char * c ); - bool isConstrainedVar( int v ); -public: - void getMatch( std::vector< Node >& terms ); -}; - -class QuantConflictFind : public QuantifiersModule -{ - friend class QcfNodeIndex; - friend class MatchGen; - friend class QuantInfo; - typedef context::CDChunkList NodeList; - typedef context::CDHashMap NodeBoolMap; -private: - context::Context* d_c; - context::CDO< bool > d_conflict; - bool d_performCheck; - std::vector< Node > d_quant_order; - std::map< Kind, Node > d_zero; - //for storing nodes created during t-constraint solving (prevents memory leaks) - std::vector< Node > d_tempCache; -private: - std::map< Node, Node > d_op_node; - int d_fid_count; - std::map< Node, int > d_fid; - Node mkEqNode( Node a, Node b ); -public: //for ground terms - Node d_true; - Node d_false; - TNode getZero( Kind k ); -private: - Node evaluateTerm( Node n ); - int evaluate( Node n, bool pref = false, bool hasPref = false ); -private: - //currently asserted quantifiers - NodeList d_qassert; - std::map< Node, QuantInfo > d_qinfo; -private: //for equivalence classes - eq::EqualityEngine * getEqualityEngine(); - bool areDisequal( Node n1, Node n2 ); - bool areEqual( Node n1, Node n2 ); - Node getRepresentative( Node n ); - -/* - class EqcInfo { - public: - EqcInfo( context::Context* c ) : d_diseq( c ) {} - NodeBoolMap d_diseq; - bool isDisequal( Node n ) { return d_diseq.find( n )!=d_diseq.end() && d_diseq[n]; } - void setDisequal( Node n, bool val = true ) { d_diseq[n] = val; } - //NodeBoolMap& getRelEqr( int index ) { return index==0 ? d_rel_eqr_e : d_rel_eqr_d; } - }; - std::map< Node, EqcInfo * > d_eqc_info; - EqcInfo * getEqcInfo( Node n, bool doCreate = true ); -*/ - // operator -> index(terms) - std::map< TNode, QcfNodeIndex > d_uf_terms; - // operator -> index(eqc -> terms) - std::map< TNode, QcfNodeIndex > d_eqc_uf_terms; - //get qcf node index - QcfNodeIndex * getQcfNodeIndex( Node eqc, Node f ); - QcfNodeIndex * getQcfNodeIndex( Node f ); - // type -> list(eqc) - std::map< TypeNode, std::vector< TNode > > d_eqcs; - std::map< TypeNode, Node > d_model_basis; - //mapping from UF terms to representatives of their arguments - std::map< TNode, std::vector< TNode > > d_arg_reps; - //compute arg reps - void computeArgReps( TNode n ); - //compute - void computeUfTerms( TNode f ); -public: - enum { - effort_conflict, - effort_prop_eq, - effort_mc, - }; - short d_effort; - void setEffort( int e ) { d_effort = e; } - static short getMaxQcfEffort(); - bool areMatchEqual( TNode n1, TNode n2 ); - bool areMatchDisequal( TNode n1, TNode n2 ); -public: - QuantConflictFind( QuantifiersEngine * qe, context::Context* c ); - /** register quantifier */ - void registerQuantifier( Node q ); -public: - /** assert quantifier */ - void assertNode( Node q ); - /** new node */ - void newEqClass( Node n ); - /** merge */ - void merge( Node a, Node b ); - /** assert disequal */ - void assertDisequal( Node a, Node b ); - /** reset round */ - void reset_round( Theory::Effort level ); - /** check */ - void check( Theory::Effort level ); - /** needs check */ - bool needsCheck( Theory::Effort level ); -private: - bool d_needs_computeRelEqr; -public: - void computeRelevantEqr(); -private: - void debugPrint( const char * c ); - //for debugging - std::vector< Node > d_quants; - std::map< Node, int > d_quant_id; - void debugPrintQuant( const char * c, Node q ); - void debugPrintQuantBody( const char * c, Node q, Node n, bool doVarNum = true ); -public: - /** statistics class */ - class Statistics { - public: - IntStat d_inst_rounds; - IntStat d_conflict_inst; - IntStat d_prop_inst; - IntStat d_entailment_checks; - Statistics(); - ~Statistics(); - }; - Statistics d_statistics; - /** Identify this module */ - std::string identify() const { return "QcfEngine"; } -}; - -} -} -} - -#endif +/********************* */ +/*! \file quant_conflict_find.h + ** \verbatim + ** Original author: Andrew Reynolds + ** Major contributors: none + ** Minor contributors (to current version): none + ** This file is part of the CVC4 project. + ** Copyright (c) 2009-2014 New York University and The University of Iowa + ** See the file COPYING in the top-level source directory for licensing + ** information.\endverbatim + ** + ** \brief quantifiers conflict find class + **/ + +#include "cvc4_private.h" + +#ifndef QUANT_CONFLICT_FIND +#define QUANT_CONFLICT_FIND + +#include "context/cdhashmap.h" +#include "context/cdchunk_list.h" +#include "theory/quantifiers_engine.h" +#include "theory/quantifiers/term_database.h" + +namespace CVC4 { +namespace theory { +namespace quantifiers { + +class QuantConflictFind; +class QuantInfo; + +//match generator +class MatchGen { + friend class QuantInfo; +private: + //current children information + int d_child_counter; + //children of this object + std::vector< int > d_children_order; + unsigned getNumChildren() { return d_children.size(); } + MatchGen * getChild( int i ) { return &d_children[d_children_order[i]]; } + //MatchGen * getChild( int i ) { return &d_children[i]; } + //current matching information + std::vector< TermArgTrie * > d_qn; + std::vector< std::map< TNode, TermArgTrie >::iterator > d_qni; + bool doMatching( QuantConflictFind * p, QuantInfo * qi ); + //for matching : each index is either a variable or a ground term + unsigned d_qni_size; + std::map< int, int > d_qni_var_num; + std::map< int, TNode > d_qni_gterm; + std::map< int, TNode > d_qni_gterm_rep; + std::map< int, int > d_qni_bound; + std::vector< int > d_qni_bound_except; + std::map< int, TNode > d_qni_bound_cons; + std::map< int, int > d_qni_bound_cons_var; + std::map< int, int >::iterator d_binding_it; + //std::vector< int > d_independent; + bool d_matched_basis; + bool d_binding; + //int getVarBindingVar(); + std::map< int, Node > d_ground_eval; + //determine variable order + void determineVariableOrder( QuantInfo * qi, std::vector< int >& bvars ); + void collectBoundVar( QuantInfo * qi, Node n, std::vector< int >& cbvars ); +public: + //type of the match generator + enum { + typ_invalid, + typ_ground, + typ_pred, + typ_eq, + typ_formula, + typ_var, + typ_ite_var, + typ_bool_var, + typ_tconstraint, + typ_tsym, + }; + void debugPrintType( const char * c, short typ, bool isTrace = false ); +public: + MatchGen() : d_type( typ_invalid ){} + MatchGen( QuantInfo * qi, Node n, bool isVar = false ); + bool d_tgt; + bool d_tgt_orig; + bool d_wasSet; + Node d_n; + std::vector< MatchGen > d_children; + short d_type; + bool d_type_not; + void reset_round( QuantConflictFind * p ); + void reset( QuantConflictFind * p, bool tgt, QuantInfo * qi ); + bool getNextMatch( QuantConflictFind * p, QuantInfo * qi ); + bool getExplanation( QuantConflictFind * p, QuantInfo * qi, std::vector< Node >& exp ); + Node getExplanationTerm( QuantConflictFind * p, QuantInfo * qi, Node t, std::vector< Node >& exp ); + bool isValid() { return d_type!=typ_invalid; } + void setInvalid(); + + // is this term treated as UF application? + static bool isHandledBoolConnective( TNode n ); + static bool isHandledUfTerm( TNode n ); + static Node getOperator( QuantConflictFind * p, Node n ); + //can this node be handled by the algorithm + static bool isHandled( TNode n ); +}; + +//info for quantifiers +class QuantInfo { +private: + void registerNode( Node n, bool hasPol, bool pol, bool beneathQuant = false ); + void flatten( Node n, bool beneathQuant ); +private: //for completing match + std::vector< int > d_unassigned; + std::vector< TypeNode > d_unassigned_tn; + int d_unassigned_nvar; + int d_una_index; + std::vector< int > d_una_eqc_count; +public: + QuantInfo() : d_mg( NULL ) {} + ~QuantInfo() { delete d_mg; } + std::vector< TNode > d_vars; + std::map< TNode, int > d_var_num; + std::vector< int > d_tsym_vars; + std::map< TNode, bool > d_inMatchConstraint; + std::map< int, std::vector< Node > > d_var_constraint[2]; + int getVarNum( TNode v ) { return d_var_num.find( v )!=d_var_num.end() ? d_var_num[v] : -1; } + bool isVar( TNode v ) { return d_var_num.find( v )!=d_var_num.end(); } + int getNumVars() { return (int)d_vars.size(); } + TNode getVar( int i ) { return d_vars[i]; } + + MatchGen * d_mg; + Node d_q; + std::map< int, MatchGen * > d_var_mg; + void reset_round( QuantConflictFind * p ); +public: + //initialize + void initialize( Node q, Node qn ); + //current constraints + std::vector< TNode > d_match; + std::vector< TNode > d_match_term; + std::map< int, std::map< TNode, int > > d_curr_var_deq; + std::map< Node, bool > d_tconstraints; + int getCurrentRepVar( int v ); + TNode getCurrentValue( TNode n ); + TNode getCurrentExpValue( TNode n ); + bool getCurrentCanBeEqual( QuantConflictFind * p, int v, TNode n, bool chDiseq = false ); + int addConstraint( QuantConflictFind * p, int v, TNode n, bool polarity ); + int addConstraint( QuantConflictFind * p, int v, TNode n, int vn, bool polarity, bool doRemove ); + bool setMatch( QuantConflictFind * p, int v, TNode n ); + bool isMatchSpurious( QuantConflictFind * p ); + bool isTConstraintSpurious( QuantConflictFind * p, std::vector< Node >& terms ); + bool entailmentTest( QuantConflictFind * p, Node lit, bool chEnt = true ); + bool completeMatch( QuantConflictFind * p, std::vector< int >& assigned, bool doContinue = false ); + void revertMatch( std::vector< int >& assigned ); + void debugPrintMatch( const char * c ); + bool isConstrainedVar( int v ); +public: + void getMatch( std::vector< Node >& terms ); +}; + +class QuantConflictFind : public QuantifiersModule +{ + friend class MatchGen; + friend class QuantInfo; + typedef context::CDChunkList NodeList; + typedef context::CDHashMap NodeBoolMap; +private: + context::Context* d_c; + context::CDO< bool > d_conflict; + bool d_performCheck; + std::vector< Node > d_quant_order; + std::map< Kind, Node > d_zero; + //for storing nodes created during t-constraint solving (prevents memory leaks) + std::vector< Node > d_tempCache; +private: + std::map< Node, Node > d_op_node; + int d_fid_count; + std::map< Node, int > d_fid; + Node mkEqNode( Node a, Node b ); +public: //for ground terms + Node d_true; + Node d_false; + TNode getZero( Kind k ); +private: + Node evaluateTerm( Node n ); + int evaluate( Node n, bool pref = false, bool hasPref = false ); +private: + //currently asserted quantifiers + NodeList d_qassert; + std::map< Node, QuantInfo > d_qinfo; +private: //for equivalence classes + eq::EqualityEngine * getEqualityEngine(); + bool areDisequal( Node n1, Node n2 ); + bool areEqual( Node n1, Node n2 ); + Node getRepresentative( Node n ); + TermDb* getTermDatabase(); + // type -> list(eqc) + std::map< TypeNode, std::vector< TNode > > d_eqcs; + std::map< TypeNode, Node > d_model_basis; +public: + enum { + effort_conflict, + effort_prop_eq, + effort_mc, + }; + short d_effort; + void setEffort( int e ) { d_effort = e; } + static short getMaxQcfEffort(); + bool areMatchEqual( TNode n1, TNode n2 ); + bool areMatchDisequal( TNode n1, TNode n2 ); +public: + QuantConflictFind( QuantifiersEngine * qe, context::Context* c ); + /** register quantifier */ + void registerQuantifier( Node q ); +public: + /** assert quantifier */ + void assertNode( Node q ); + /** new node */ + void newEqClass( Node n ); + /** merge */ + void merge( Node a, Node b ); + /** assert disequal */ + void assertDisequal( Node a, Node b ); + /** reset round */ + void reset_round( Theory::Effort level ); + /** check */ + void check( Theory::Effort level ); + /** needs check */ + bool needsCheck( Theory::Effort level ); +private: + bool d_needs_computeRelEqr; +public: + void computeRelevantEqr(); +private: + void debugPrint( const char * c ); + //for debugging + std::vector< Node > d_quants; + std::map< Node, int > d_quant_id; + void debugPrintQuant( const char * c, Node q ); + void debugPrintQuantBody( const char * c, Node q, Node n, bool doVarNum = true ); +public: + /** statistics class */ + class Statistics { + public: + IntStat d_inst_rounds; + IntStat d_conflict_inst; + IntStat d_prop_inst; + IntStat d_entailment_checks; + Statistics(); + ~Statistics(); + }; + Statistics d_statistics; + /** Identify this module */ + std::string identify() const { return "QcfEngine"; } +}; + +} +} +} + +#endif diff --git a/src/theory/quantifiers/quantifiers_rewriter.cpp b/src/theory/quantifiers/quantifiers_rewriter.cpp index eb14b0abe..4c01e927d 100644 --- a/src/theory/quantifiers/quantifiers_rewriter.cpp +++ b/src/theory/quantifiers/quantifiers_rewriter.cpp @@ -1142,8 +1142,10 @@ Node QuantifiersRewriter::preSkolemizeQuantifiers( Node n, bool polarity, std::v //process body Node nn = preSkolemizeQuantifiers( n[1], polarity, fvTypes, fvs ); std::vector< Node > sk; + Node sub; + std::vector< unsigned > sub_vars; //return skolemized body - return TermDb::mkSkolemizedBody( n, nn, fvTypes, fvs, sk ); + return TermDb::mkSkolemizedBody( n, nn, fvTypes, fvs, sk, sub, sub_vars ); } }else{ //check if it contains a quantifier as a subterm diff --git a/src/theory/quantifiers/term_database.cpp b/src/theory/quantifiers/term_database.cpp index 9ea9ee962..0d5103db6 100644 --- a/src/theory/quantifiers/term_database.cpp +++ b/src/theory/quantifiers/term_database.cpp @@ -31,25 +31,39 @@ using namespace CVC4::theory::quantifiers; using namespace CVC4::theory::inst; -bool TermArgTrie::addTerm2( QuantifiersEngine* qe, Node n, int argIndex ){ - if( argIndex<(int)n.getNumChildren() ){ - Node r = qe->getEqualityQuery()->getRepresentative( n[ argIndex ] ); - std::map< Node, TermArgTrie >::iterator it = d_data.find( r ); +TNode TermArgTrie::existsTerm( std::vector< TNode >& reps, int argIndex ) { + if( argIndex==(int)reps.size() ){ + if( d_data.empty() ){ + return Node::null(); + }else{ + return d_data.begin()->first; + } + }else{ + std::map< TNode, TermArgTrie >::iterator it = d_data.find( reps[argIndex] ); if( it==d_data.end() ){ - d_data[r].addTerm2( qe, n, argIndex+1 ); + return Node::null(); + }else{ + return it->second.existsTerm( reps, argIndex+1 ); + } + } +} + +bool TermArgTrie::addTerm( TNode n, std::vector< TNode >& reps, int argIndex ){ + if( argIndex==(int)reps.size() ){ + if( d_data.empty() ){ + //store n in d_data (this should be interpretted as the "data" and not as a reference to a child) + d_data[n].clear(); return true; }else{ - return it->second.addTerm2( qe, n, argIndex+1 ); + return false; } }else{ - //store n in d_data (this should be interpretted as the "data" and not as a reference to a child) - d_data[n].d_data.clear(); - return false; + return d_data[reps[argIndex]].addTerm( n, reps, argIndex+1 ); } } void TermArgTrie::debugPrint( const char * c, Node n, unsigned depth ) { - for( std::map< Node, TermArgTrie >::iterator it = d_data.begin(); it != d_data.end(); ++it ){ + for( std::map< TNode, TermArgTrie >::iterator it = d_data.begin(); it != d_data.end(); ++it ){ for( unsigned i=0; ifirst << std::endl; it->second.debugPrint( c, n, depth+1 ); @@ -57,7 +71,8 @@ void TermArgTrie::debugPrint( const char * c, Node n, unsigned depth ) { } TermDb::TermDb( context::Context* c, context::UserContext* u, QuantifiersEngine* qe ) : d_quantEngine( qe ), d_op_ccount( u ) { - + d_true = NodeManager::currentNM()->mkConst( true ); + d_false = NodeManager::currentNM()->mkConst( false ); } /** ground terms */ @@ -143,65 +158,162 @@ void TermDb::addTerm( Node n, std::set< Node >& added, bool withinQuant ){ } } - void TermDb::reset( Theory::Effort effort ){ +void TermDb::computeArgReps( TNode n ) { + if( d_arg_reps.find( n )==d_arg_reps.end() ){ + eq::EqualityEngine * ee = d_quantEngine->getTheoryEngine()->getMasterEqualityEngine(); + for( unsigned j=0; jhasTerm( n[j] ) ? ee->getRepresentative( n[j] ) : n[j]; + d_arg_reps[n].push_back( r ); + } + } +} + +void TermDb::computeUfEqcTerms( TNode f ) { + if( d_func_map_eqc_trie.find( f )==d_func_map_eqc_trie.end() ){ + d_func_map_eqc_trie[f].clear(); + eq::EqualityEngine * ee = d_quantEngine->getTheoryEngine()->getMasterEqualityEngine(); + for( unsigned i=0; ihasTerm( n ) ? ee->getRepresentative( n ) : n; + d_func_map_eqc_trie[f].d_data[r].addTerm( n, d_arg_reps[n] ); + } + } + } +} + +TNode TermDb::evaluateTerm( TNode n, std::map< TNode, TNode >& subs, bool subsRep ) { + Trace("term-db-eval") << "evaluate term : " << n << std::endl; + eq::EqualityEngine * ee = d_quantEngine->getTheoryEngine()->getMasterEqualityEngine(); + if( ee->hasTerm( n ) ){ + Trace("term-db-eval") << "...exists in ee, return rep " << std::endl; + return ee->getRepresentative( n ); + }else if( n.getKind()==BOUND_VARIABLE ){ + Assert( subs.find( n )!=subs.end() ); + Trace("term-db-eval") << "...substitution is : " << subs[n] << std::endl; + if( subsRep ){ + Assert( ee->hasTerm( subs[n] ) ); + Assert( ee->getRepresentative( subs[n] )==subs[n] ); + return subs[n]; + }else{ + return evaluateTerm( subs[n], subs, subsRep ); + } + }else{ + if( n.hasOperator() ){ + TNode f = getOperator( n ); + if( !f.isNull() ){ + std::vector< TNode > args; + for( unsigned i=0; ihasTerm( nn ) ){ + Trace("term-db-eval") << "return rep " << std::endl; + return ee->getRepresentative( nn ); + }else{ + //Assert( false ); + } + } + } + } + return TNode::null(); + } +} + +bool TermDb::isEntailed( TNode n, std::map< TNode, TNode >& subs, bool subsRep, bool pol ) { + Trace("term-db-eval") << "Check entailed : " << n << ", pol = " << pol << std::endl; + Assert( n.getType().isBoolean() ); + if( n.getKind()==EQUAL ){ + TNode n1 = evaluateTerm( n[0], subs, subsRep ); + if( !n1.isNull() ){ + TNode n2 = evaluateTerm( n[1], subs, subsRep ); + if( !n2.isNull() ){ + eq::EqualityEngine * ee = d_quantEngine->getTheoryEngine()->getMasterEqualityEngine(); + Assert( ee->hasTerm( n1 ) ); + Assert( ee->hasTerm( n2 ) ); + if( pol ){ + return ee->areEqual( n1, n2 ); + }else{ + return ee->areDisequal( n1, n2, false ); + } + } + } + }else if( n.getKind()==APPLY_UF ){ + TNode n1 = evaluateTerm( n, subs, subsRep ); + if( !n1.isNull() ){ + eq::EqualityEngine * ee = d_quantEngine->getTheoryEngine()->getMasterEqualityEngine(); + Assert( ee->hasTerm( n1 ) ); + TNode n2 = pol ? d_true : d_false; + if( ee->hasTerm( n2 ) ){ + return ee->areEqual( n1, n2 ); + } + } + }else if( n.getKind()==NOT ){ + return isEntailed( n[0], subs, subsRep, !pol ); + }else if( n.getKind()==OR || n.getKind()==AND ){ + for( unsigned i=0; i >::iterator it = d_op_map.begin(); it != d_op_map.end(); ++it ){ d_op_nonred_count[ it->first ] = 0; if( !it->second.empty() ){ - if( it->second[0].getType().isBoolean() ){ - d_pred_map_trie[ 0 ][ it->first ].d_data.clear(); - d_pred_map_trie[ 1 ][ it->first ].d_data.clear(); - }else{ - d_func_map_trie[ it->first ].d_data.clear(); - for( int i=0; i<(int)it->second.size(); i++ ){ - Node n = it->second[i]; - computeModelBasisArgAttribute( n ); - if( !n.getAttribute(NoMatchAttribute()) ){ - if( !d_func_map_trie[ it->first ].addTerm( d_quantEngine, n ) ){ - NoMatchAttribute nma; - n.setAttribute(nma,true); - Debug("term-db-cong") << n << " is redundant." << std::endl; - congruentCount++; - }else{ - nonCongruentCount++; - d_op_nonred_count[ it->first ]++; - } - }else{ + for( unsigned i=0; isecond.size(); i++ ){ + Node n = it->second[i]; + computeModelBasisArgAttribute( n ); + if( !n.getAttribute(NoMatchAttribute()) ){ + computeArgReps( n ); + if( !d_func_map_trie[ it->first ].addTerm( n, d_arg_reps[n] ) ){ + NoMatchAttribute nma; + n.setAttribute(nma,true); + Debug("term-db-cong") << n << " is redundant." << std::endl; congruentCount++; - alreadyCongruentCount++; - } - } - } - } - } - for( int i=0; i<2; i++ ){ - Node n = NodeManager::currentNM()->mkConst( i==1 ); - if( d_quantEngine->getEqualityQuery()->getEngine()->hasTerm( n ) ){ - eq::EqClassIterator eqc( d_quantEngine->getEqualityQuery()->getEngine()->getRepresentative( n ), - d_quantEngine->getEqualityQuery()->getEngine() ); - while( !eqc.isFinished() ){ - Node en = (*eqc); - computeModelBasisArgAttribute( en ); - if( en.getKind()==APPLY_UF && !TermDb::hasInstConstAttr(en) ){ - if( !en.getAttribute(NoMatchAttribute()) ){ - Node op = getOperator( en ); - if( !d_pred_map_trie[i][op].addTerm( d_quantEngine, en ) ){ - NoMatchAttribute nma; - en.setAttribute(nma,true); - Debug("term-db-cong") << en << " is redundant." << std::endl; - congruentCount++; - }else{ - nonCongruentCount++; - d_op_nonred_count[ op ]++; - } }else{ - alreadyCongruentCount++; + nonCongruentCount++; + d_op_nonred_count[ it->first ]++; } + }else{ + congruentCount++; + alreadyCongruentCount++; } - ++eqc; } } } @@ -219,6 +331,39 @@ void TermDb::addTerm( Node n, std::set< Node >& added, bool withinQuant ){ } } +TermArgTrie * TermDb::getTermArgTrie( Node f ) { + std::map< Node, TermArgTrie >::iterator itut = d_func_map_trie.find( f ); + if( itut!=d_func_map_trie.end() ){ + return &itut->second; + }else{ + return NULL; + } +} + +TermArgTrie * TermDb::getTermArgTrie( Node eqc, Node f ) { + computeUfEqcTerms( f ); + std::map< Node, TermArgTrie >::iterator itut = d_func_map_eqc_trie.find( f ); + if( itut==d_func_map_eqc_trie.end() ){ + return NULL; + }else{ + if( eqc.isNull() ){ + return &itut->second; + }else{ + std::map< TNode, TermArgTrie >::iterator itute = itut->second.d_data.find( eqc ); + if( itute!=itut->second.d_data.end() ){ + return &itute->second; + }else{ + return NULL; + } + } + } +} + +TNode TermDb::existsTerm( Node f, Node n ) { + computeArgReps( n ); + return d_func_map_trie[f].existsTerm( d_arg_reps[n] ); +} + Node TermDb::getModelBasisTerm( TypeNode tn, int i ){ if( d_model_basis_term.find( tn )==d_model_basis_term.end() ){ Node mbt; @@ -448,14 +593,14 @@ void getSelfSel( const DatatypeConstructor& dc, Node n, TypeNode ntn, std::vecto Node TermDb::mkSkolemizedBody( Node f, Node n, std::vector< TypeNode >& argTypes, std::vector< TNode >& fvs, - std::vector< Node >& sk ) { + std::vector< Node >& sk, Node& sub, std::vector< unsigned >& sub_vars ) { //calculate the variables and substitution std::vector< TNode > ind_vars; std::vector< unsigned > ind_var_indicies; std::vector< TNode > vars; std::vector< unsigned > var_indicies; for( unsigned i=0; i& argTypes Node nret; Node n_str_ind; TypeNode tn = ind_vars[0].getType(); - if( datatypes::DatatypesRewriter::isTypeDatatype(tn) ){ + if( options::dtStcInduction() && datatypes::DatatypesRewriter::isTypeDatatype(tn) ){ Node k = sk[ind_var_indicies[0]]; const Datatype& dt = ((DatatypeType)(tn).toType()).getDatatype(); std::vector< Node > disj; for( unsigned i=0; i selfSel; - getSelfSel( dt[i], k, tn, selfSel ); - std::vector< Node > conj; - conj.push_back( NodeManager::currentNM()->mkNode( APPLY_TESTER, Node::fromExpr( dt[i].getTester() ), k ).negate() ); - for( unsigned j=0; jmkNode( OR, conj ) ); + std::vector< Node > selfSel; + getSelfSel( dt[i], k, tn, selfSel ); + std::vector< Node > conj; + conj.push_back( NodeManager::currentNM()->mkNode( APPLY_TESTER, Node::fromExpr( dt[i].getTester() ), k ).negate() ); + for( unsigned j=0; jmkNode( OR, conj ) ); } Assert( !disj.empty() ); n_str_ind = disj.size()==1 ? disj[0] : NodeManager::currentNM()->mkNode( AND, disj ); @@ -516,12 +661,15 @@ Node TermDb::mkSkolemizedBody( Node f, Node n, std::vector< TypeNode >& argTypes Trace("stc-ind") << "Unknown induction for term : " << ind_vars[0] << ", type = " << tn << std::endl; Assert( false ); } - + std::vector< Node > rem_ind_vars; rem_ind_vars.insert( rem_ind_vars.end(), ind_vars.begin()+1, ind_vars.end() ); if( !rem_ind_vars.empty() ){ Node bvl = NodeManager::currentNM()->mkNode( BOUND_VAR_LIST, rem_ind_vars ); nret = NodeManager::currentNM()->mkNode( FORALL, bvl, nret ); + nret = Rewriter::rewrite( nret ); + sub = nret; + sub_vars.insert( sub_vars.end(), ind_var_indicies.begin()+1, ind_var_indicies.end() ); n_str_ind = NodeManager::currentNM()->mkNode( FORALL, bvl, n_str_ind.negate() ).negate(); } ret = NodeManager::currentNM()->mkNode( OR, nret, n_str_ind ); @@ -535,7 +683,15 @@ Node TermDb::getSkolemizedBody( Node f ){ if( d_skolem_body.find( f )==d_skolem_body.end() ){ std::vector< TypeNode > fvTypes; std::vector< TNode > fvs; - d_skolem_body[ f ] = mkSkolemizedBody( f, f[1], fvTypes, fvs, d_skolem_constants[f] ); + Node sub; + std::vector< unsigned > sub_vars; + d_skolem_body[ f ] = mkSkolemizedBody( f, f[1], fvTypes, fvs, d_skolem_constants[f], sub, sub_vars ); + //store sub quantifier information + if( !sub.isNull() ){ + Assert( sub[0].getNumChildren()==sub_vars.size() ); + d_skolem_sub_quant[f] = sub; + d_skolem_sub_quant_vars[f].insert( d_skolem_sub_quant_vars[f].end(), sub_vars.begin(), sub_vars.end() ); + } Assert( d_skolem_constants[f].size()==f[0].getNumChildren() ); if( options::sortInference() ){ for( unsigned i=0; i& sk, bool expSub ) { + std::map< Node, std::vector< Node > >::iterator it = d_skolem_constants.find( f ); + if( it!=d_skolem_constants.end() ){ + sk.insert( sk.end(), it->second.begin(), it->second.end() ); + if( expSub ){ + std::map< Node, Node >::iterator its = d_skolem_sub_quant.find( f ); + if( its!=d_skolem_sub_quant.end() && !its->second.isNull() ){ + std::vector< Node > ssk; + getSkolemConstants( its->second, ssk, true ); + Assert( ssk.size()==d_skolem_sub_quant_vars[f].size() ); + for( unsigned i=0; i d_data; + std::map< TNode, TermArgTrie > d_data; public: - bool addTerm( QuantifiersEngine* qe, Node n ) { return addTerm2( qe, n, 0 ); } + TNode existsTerm( std::vector< TNode >& reps, int argIndex = 0 ); + bool addTerm( TNode n, std::vector< TNode >& reps, int argIndex = 0 ); void debugPrint( const char * c, Node n, unsigned depth = 0 ); + void clear() { d_data.clear(); } };/* class TermArgTrie */ @@ -103,6 +103,9 @@ private: public: TermDb( context::Context* c, context::UserContext* u, QuantifiersEngine* qe ); ~TermDb(){} + /** boolean terms */ + Node d_true; + Node d_false; /** ground terms */ unsigned getNumGroundTerms( Node f ); /** count number of non-redundant ground terms per operator */ @@ -111,16 +114,32 @@ public: std::map< Node, std::vector< Node > > d_op_map; /** map from APPLY_UF functions to trie */ std::map< Node, TermArgTrie > d_func_map_trie; - /** map from APPLY_UF predicates to trie */ - std::map< Node, TermArgTrie > d_pred_map_trie[2]; + std::map< Node, TermArgTrie > d_func_map_eqc_trie; + /**mapping from UF terms to representatives of their arguments */ + std::map< TNode, std::vector< TNode > > d_arg_reps; /** map from type nodes to terms of that type */ std::map< TypeNode, std::vector< Node > > d_type_map; /** add a term to the database */ void addTerm( Node n, std::set< Node >& added, bool withinQuant = false ); /** reset (calculate which terms are active) */ void reset( Theory::Effort effort ); - /** get operation */ + /** get operator*/ Node getOperator( Node n ); + /** get term arg index */ + TermArgTrie * getTermArgTrie( Node f ); + TermArgTrie * getTermArgTrie( Node eqc, Node f ); + /** exists term */ + TNode existsTerm( Node f, Node n ); + /** compute arg reps */ + void computeArgReps( TNode n ); + /** compute uf eqc terms */ + void computeUfEqcTerms( TNode f ); + /** evaluate a term under a substitution. Return representative in EE if possible. + * subsRep is whether subs contains only representatives + */ + TNode evaluateTerm( TNode n, std::map< TNode, TNode >& subs, bool subsRep ); + /** is entailed (incomplete check) */ + bool isEntailed( TNode n, std::map< TNode, TNode >& subs, bool subsRep, bool pol ); public: /** parent structure (for efficient E-matching): n -> op -> index -> L @@ -204,11 +223,16 @@ private: public: /** map from universal quantifiers to the list of skolem constants */ std::map< Node, std::vector< Node > > d_skolem_constants; + /** for quantified formulas whose skolemization was strengthened by induction */ + std::map< Node, Node > d_skolem_sub_quant; + std::map< Node, std::vector< unsigned > > d_skolem_sub_quant_vars; /** make the skolemized body f[e/x] */ static Node mkSkolemizedBody( Node f, Node n, std::vector< TypeNode >& fvTypes, std::vector< TNode >& fvs, - std::vector< Node >& sk ); + std::vector< Node >& sk, Node& sub, std::vector< unsigned >& sub_vars ); /** get the skolemized body */ Node getSkolemizedBody( Node f); + /** get skolem constants */ + void getSkolemConstants( Node f, std::vector< Node >& sk, bool expSub = false ); //miscellaneous public: @@ -245,11 +269,18 @@ public: int isInstanceOf( Node n1, Node n2 ); /** filter all nodes that have instances */ void filterInstances( std::vector< Node >& nodes ); -public: + +public: //for induction + /** is induction variable */ + static bool isInductionTerm( Node n ); + + +public: //general queries concerning quantified formulas wrt modules /** is quantifier treated as a rewrite rule? */ static bool isRewriteRule( Node q ); /** get the rewrite rule associated with the quanfied formula */ static Node getRewriteRule( Node q ); + };/* class TermDb */ }/* CVC4::theory::quantifiers namespace */ diff --git a/src/theory/quantifiers_engine.cpp b/src/theory/quantifiers_engine.cpp index c55ffa2a6..a4adf8054 100644 --- a/src/theory/quantifiers_engine.cpp +++ b/src/theory/quantifiers_engine.cpp @@ -30,6 +30,7 @@ #include "theory/quantifiers/bounded_integers.h" #include "theory/quantifiers/rewrite_engine.h" #include "theory/quantifiers/quant_conflict_find.h" +#include "theory/quantifiers/conjecture_generator.h" #include "theory/quantifiers/relevant_domain.h" #include "theory/uf/options.h" #include "theory/uf/theory_uf.h" @@ -83,6 +84,12 @@ d_lemmas_produced_c(u){ }else{ d_qcf = NULL; } + if( options::conjectureGen() ){ + d_sg_gen = new quantifiers::ConjectureGenerator( this, c ); + d_modules.push_back( d_sg_gen ); + }else{ + d_sg_gen = NULL; + } if( !options::finiteModelFind() || options::fmfInstEngine() ){ //the instantiation must set incomplete flag unless finite model finding is turned on d_inst_engine = new quantifiers::InstantiationEngine( this, !options::finiteModelFind() ); @@ -167,6 +174,7 @@ void QuantifiersEngine::check( Theory::Effort e ){ } if( needsCheck ){ Trace("quant-engine") << "Quantifiers Engine check, level = " << e << std::endl; + Trace("quant-engine-debug") << " # quantified formulas = " << d_model->getNumAssertedQuantifiers() << std::endl; if( !getMasterEqualityEngine()->consistent() ){ Trace("quant-engine") << "Master equality engine not consistent, return." << std::endl; return; @@ -179,6 +187,7 @@ void QuantifiersEngine::check( Theory::Effort e ){ if( d_rel_dom ){ d_rel_dom->reset(); } + d_model->reset_round(); for( int i=0; i<(int)d_modules.size(); i++ ){ d_modules[i]->reset_round( e ); } @@ -551,9 +560,20 @@ bool QuantifiersEngine::addInstantiation( Node f, std::vector< Node >& terms, bo } } } + //check for entailment + if( options::instNoEntail() ){ + std::map< TNode, TNode > subs; + for( unsigned i=0; iisEntailed( f[1], subs, false, true ) ){ + Trace("inst-add-debug") << " -> Currently entailed." << std::endl; + Trace("inst-add-entail") << " -> instantiation for " << f[1] << " currently entailed." << std::endl; + return false; + } + } //check for duplication - ///* bool alreadyExists = false; if( options::incrementalSolving() ){ Trace("inst-add-debug") << "Adding into context-dependent inst trie, modEq = " << modEq << ", modInst = " << modInst << std::endl; @@ -575,7 +595,7 @@ bool QuantifiersEngine::addInstantiation( Node f, std::vector< Node >& terms, bo ++(d_statistics.d_inst_duplicate_eq); return false; } - //*/ + //add the instantiation bool addedInst = addInstantiation( f, d_term_db->d_vars[f], terms ); diff --git a/src/theory/quantifiers_engine.h b/src/theory/quantifiers_engine.h index 7786e0b70..220fa0b1f 100644 --- a/src/theory/quantifiers_engine.h +++ b/src/theory/quantifiers_engine.h @@ -73,6 +73,7 @@ namespace quantifiers { class QuantConflictFind; class RewriteEngine; class RelevantDomain; + class ConjectureGenerator; }/* CVC4::theory::quantifiers */ namespace inst { @@ -112,6 +113,8 @@ private: quantifiers::QuantConflictFind* d_qcf; /** rewrite rules utility */ quantifiers::RewriteEngine * d_rr_engine; + /** subgoal generator */ + quantifiers::ConjectureGenerator * d_sg_gen; private: /** list of all quantifiers seen */ std::vector< Node > d_quants;