cadical分析01_基本数据结构01

以下代码基于cadical-rel-1.5.3版本，来源于：

	Solver 在cadical.hpp文件中声明求解器类型。其中成员函数比较有趣的是： int val (int lit); // Line 57, 返回文字的值；assert(val(liter)),断言文字liter为非零，即是有效文字； // Get value (-lit=false, lit=true) of valid non-zero literal. bool failed (int lit); // Determine whether the valid non-zero literal is in the core. void copy (Solver & other) const; // Line //=================================================================== 除了函数'val'， 'fixed'， 'failed'和'frozen'外，每当将文字用作参数时， 通常会隐式地添加和初始化变量。但是，库内部保留了一个可查询的最大变量索引函数vars()。 //===================================================================  bign (lit)； sign (lit); //获取文字的符号inline int sign (int lit) { return (lit > 0) - (lit < 0); } vals[idx] = tmp; //tep值为1或-1 举例文字-8,tep = -1,则确保该负文字取值为真赋值vals[8] = -1,vals[-8] = 1 vals[-idx] = -tmp;
	class Solver { public: // ====== BEGIN IPASIR =================================================== // This section implements the corresponding IPASIR functionality. Solver (); ~Solver (); static const char * signature (); // name of this library // Core functionality as in the IPASIR incremental SAT solver interface. // (recall 'READY = CONFIGURING | UNKNOWN | SATISFIED | UNSATISFIED'). // Further note that 'lit' is required to be different from 'INT_MIN' and // different from '0' except for 'add'. // Add valid literal to clause or zero to terminate clause. // // require (VALID) // recall 'VALID = READY | ADDING' // if (lit) ensure (ADDING) // and thus VALID but not READY // if (!lit) ensure (UNKNOWN) // and thus READY // void add (int lit); // Assume valid non zero literal for next call to 'solve'. These // assumptions are reset after the call to 'solve' as well as after // returning from 'simplify' and 'lookahead. // // require (READY) // ensure (UNKNOWN) // void assume (int lit); // Try to solve the current formula. Returns // // 0 = UNSOLVED (limit reached or interrupted through 'terminate') // 10 = SATISFIABLE // 20 = UNSATISFIABLE // // require (READY) // ensure (UNKNOWN | SATISFIED | UNSATISFIED) // // Note, that while in this call the solver actually transitions to state // 'SOLVING', which however is only visible from a different context, // i.e., from a different thread or from a signal handler. Only right // before returning from this call it goes into a 'READY' state. // int solve (); // Get value (-lit=false, lit=true) of valid non-zero literal. // // require (SATISFIED) // ensure (SATISFIED) // int val (int lit); // Determine whether the valid non-zero literal is in the core. // Returns 'true' if the literal is in the core and 'false' otherwise. // Note that the core does not have to be minimal. // // require (UNSATISFIED) // ensure (UNSATISFIED) // bool failed (int lit); // Add call-back which is checked regularly for termination. There can // only be one terminator connected. If a second (non-zero) one is added // the first one is implicitly disconnected. // // require (VALID) // ensure (VALID) // void connect_terminator (Terminator * terminator); void disconnect_terminator (); // Add call-back which allows to export learned clauses. // // require (VALID) // ensure (VALID) // void connect_learner (Learner * learner); void disconnect_learner (); // ====== END IPASIR ===================================================== //------------------------------------------------------------------------ // Adds a literal to the constraint clause. Same functionality as 'add' but // the clause only exists for the next call to solve (same lifetime as // assumptions). Only one constraint may exists at a time. A new constraint // replaces the old. // The main application of this functonality is the model checking algorithm // IC3. See our FMCAD'21 paper [FroleyksBiere-FMCAD'19] for more details. // // Add valid literal to the constraint clause or zero to terminate it. // // require (VALID) // recall 'VALID = READY | ADDING' // if (lit) ensure (ADDING) // and thus VALID but not READY // if (!lit) && !adding_clause ensure (UNKNOWN) // and thus READY // void constrain (int lit); // Determine whether the constraint was used to proof the unsatisfiability. // Note that the formula might still be unsatisfiable without the constraint. // // require (UNSATISFIED) // ensure (UNSATISFIED) // bool constraint_failed (); //------------------------------------------------------------------------ // This function determines a good splitting literal. The result can be // zero if the formula is proven to be satisfiable or unsatisfiable. This // can then be checked by 'state ()'. If the formula is empty and // the function is not able to determine satisfiability also zero is // returned but the state remains unknown. // // require (READY) // ensure (UNKNOWN|SATISFIED|UNSATISFIED) // int lookahead(void); struct CubesWithStatus { int status; std::vector<std::vector<int>> cubes; }; CubesWithStatus generate_cubes(int, int min_depth = 0); void reset_assumptions (); void reset_constraint (); // Return the current state of the solver as defined above. // const State & state () const { return _state; } // Similar to 'state ()' but using the staddard competition exit codes of // '10' for 'SATISFIABLE', '20' for 'UNSATISFIABLE' and '0' otherwise. // int status () const { if (_state == SATISFIED) return 10; else if (_state == UNSATISFIED) return 20; else return 0; } /*----------------------------------------------------------------------*/ static const char * version (); // return version string /*----------------------------------------------------------------------*/ // Copy 'this' into a fresh 'other'. The copy procedure is not a deep // clone, but only copies irredundant clauses and units. It also makes // sure that witness reconstruction works with the copy as with the // original formula such that both solvers have the same models. // Assumptions are not copied. Options however are copied as well as // flags which remember the current state of variables in preprocessing. // // require (READY) // for 'this' // ensure (READY) // for 'this' // // other.require (CONFIGURING) // other.ensure (CONFIGURING | UNKNOWN) // void copy (Solver & other) const; 复制过程不是深度克隆，而是只复制非冗余子句和单元。 它还确保见证重建可以像处理原始公式一样处理副本，以便两个求解器具有相同的模型。 Assumptions不会被复制。然而，选项和标记被复制，这些标记在预处理中记住了变量的当前状态。 166 /*----------------------------------------------------------------------*/ // Variables are usually added and initialized implicitly whenever a // literal is used as an argument except for the functions 'val', 'fixed', // 'failed' and 'frozen'. However, the library internally keeps a maximum // variable index, which can be queried. // // require (VALID | SOLVING) // ensure (VALID | SOLVING) // int vars (); 除了'val'， 'fixed'， 'failed'和'frozen'函数外，变量通常会被隐式地添加和初始化。 但是，库内部保留了一个最大变量索引，可以进行查询。 // Increase the maximum variable index explicitly. This function makes // sure that at least 'min_max_var' variables are initialized. Since it // might need to reallocate tables, it destroys a satisfying assignment // and has the same state transition and conditions as 'assume' etc. // // require (READY) // ensure (UNKNOWN) // void reserve (int min_max_var); #ifndef NTRACING //------------------------------------------------------------------------ // This function can be used to write API calls to a file. The same // format is used which 'mobical' can read, execute and also shrink // through delta debugging. // // Tracing API calls can also be achieved by using the environment // variable 'CADICAL_API_TRACE'. That alternative is useful if you do not // want to change the source code using the solver, e.g., if you only have // a binary with the solver linked in. However, that method only allows // to trace one solver instance, while with the following function API // tracing can be enabled for different solver instances individually. // // The solver will flush the file after every trace API call but does not // close it during deletion. It remains owned by the user of the library. // // require (VALID) // ensure (VALID) // void trace_api_calls (FILE * file); #endif //------------------------------------------------------------------------ // Option handling. // Determine whether 'name' is a valid option name. // static bool is_valid_option (const char * name); // Determine whether 'name' enables a specific preprocessing technique. // static bool is_preprocessing_option (const char * name); // Determine whether 'arg' is a valid long option of the form '--<name>', // '--<name>=<val>' or '--no-<name>' similar to 'set_long_option' below. // Legal values are 'true', 'false', or '[-]<mantissa>[e<exponent>]'. static bool is_valid_long_option (const char * arg); // Get the current value of the option 'name'. If 'name' is invalid then // zero is returned. Here '--...' arguments as invalid options. // int get (const char * name); // Set the default verbose message prefix (default "c "). // void prefix (const char * verbose_message_prefix); // Explicit version of setting an option. If the option '<name>' exists // and '<val>' can be parsed then 'true' is returned. If the option value // is out of range the actual value is computed as the closest (minimum or // maximum) value possible, but still 'true' is returned. // // require (CONFIGURING) // ensure (CONFIGURING) // // Thus options can only bet set right after initialization. // bool set (const char * name, int val); // This function accepts options in command line syntax: // // '--<name>=<val>', '--<name>', or '--no-<name>' // // It actually calls the previous 'set' function after parsing 'arg'. The // same values are expected as for 'is_valid_long_option' above and as // with 'set' any value outside of the range of legal values for a // particular option are set to either the minimum or maximum depending on // which side of the valid interval they lie. // // require (CONFIGURING) // ensure (CONFIGURING) // bool set_long_option (const char * arg); // Determine whether 'name' is a valid configuration. // static bool is_valid_configuration (const char *); // Overwrite (some) options with the forced values of the configuration. // The result is 'true' iff the 'name' is a valid configuration. // // require (CONFIGURING) // ensure (CONFIGURING) // bool configure (const char *); // Increase preprocessing and inprocessing limits by '10^<val>'. Values // below '0' are ignored and values above '9' are reduced to '9'. // // require (READY) // ensure (READY) // void optimize (int val); // Specify search limits, where currently 'name' can be "conflicts", // "decisions", "preprocessing", or "localsearch". The first two limits // are unbounded by default. Thus using a negative limit for conflicts or // decisions switches back to the default of unlimited search (for that // particular limit). The preprocessing limit determines the number of // preprocessing rounds, which is zero by default. Similarly, the local // search limit determines the number of local search rounds (also zero by // default). As with 'set', the return value denotes whether the limit // 'name' is valid. These limits are only valid for the next 'solve' or // 'simplify' call and reset to their default after 'solve' returns (as // well as overwritten and reset during calls to 'simplify' and // 'lookahead'). We actually also have an internal "terminate" limit // which however should only be used for testing and debugging. // // require (READY) // ensure (READY) // bool limit (const char * arg, int val); bool is_valid_limit (const char * arg); //=====================================================================================       指定搜索限制，当前“name”可以是“conflicts”、“decisions”、“pre - processing”或“localsearch”。       默认情况下，前两个限制是无限制的。因此，对于冲突或决策使用负限制将切换回默认的无限搜索(对于特定的限制)。       预处理限制决定预处理轮数，默认为0。       类似地，本地搜索限制决定了本地搜索轮的数量(默认情况下也是零)。与'set'一样，返回值表示是否限制'name'有效。       这些限制仅对下一个“solve”或“simplify”调用有效，并在“solve”返回后重置为默认值(以及在调用“simplify”           和“lookahead”期间重写和重置)。      实际上，我们也有一个内部的“终止”限制，但是只能用于测试和调试。      //======================================================================================= // The number of currently active variables and clauses can be queried by // these functions. Variables become active if a clause is added with it. // They become inactive if they are eliminated or fixed at the root level // Clauses become inactive if they are satisfied, subsumed, eliminated. // Redundant clauses are reduced regularly and thus the 'redundant' // function is less useful. // // require (VALID) // ensure (VALID) // int active () const; // Number of active variables. int64_t redundant () const; // Number of active redundant clauses. int64_t irredundant () const; // Number of active irredundant clauses. //------------------------------------------------------------------------ // This function executes the given number of preprocessing rounds. It is // similar to 'solve' with 'limits ("preprocessing", rounds)' except that // no CDCL nor local search, nor lucky phases are executed. The result // values are also the same: 0=unknown, 10=satisfiable, 20=unsatisfiable. // As 'solve' it resets current assumptions and limits before returning. // The numbers of rounds should not be negative. If the number of rounds // is zero only clauses are restored (if necessary) and top level unit // propagation is performed, which both take some time. // // require (READY) // ensure (UNKNOWN | SATISFIED | UNSATISFIED) // int simplify (int rounds = 3); //------------------------------------------------------------------------ // Force termination of 'solve' asynchronously. // // require (SOLVING | READY) // ensure (UNKNOWN) // actually not immediately (synchronously) // void terminate (); //------------------------------------------------------------------------ // We have the following common reference counting functions, which avoid // to restore clauses but require substantial user guidance. This was the // only way to use inprocessing in incremental SAT solving in Lingeling // (and before in MiniSAT's 'freeze' / 'thaw') and which did not use // automatic clause restoring. In general this is slower than // restoring clauses and should not be used. // // In essence the user freezes variables which potentially are still // needed in clauses added or assumptions used after the next 'solve' // call. As in Lingeling you can freeze a variable multiple times, but // then have to melt it the same number of times again in order to enable // variable eliminating on it etc. The arguments can be literals // (negative indices) but conceptually variables are frozen. // // In the old way of doing things without restore you should not use a // variable incrementally (in 'add' or 'assume'), which was used before // and potentially could have been eliminated in a previous 'solve' call. // This can lead to spurious satisfying assignment. In order to check // this API contract one can use the 'checkfrozen' option. This has the // drawback that restoring clauses implicitly would fail with a fatal // error message even if in principle the solver could just restore // clauses. Thus this option is disabled by default. // // See our SAT'19 paper [FazekasBiereScholl-SAT'19] for more details. // // require (VALID) // ensure (VALID) // bool frozen (int lit) const; void freeze (int lit); void melt (int lit); // Also needs 'require (frozen (lit))'. //------------------------------------------------------------------------ // Root level assigned variables can be queried with this function. // It returns '1' if the literal is implied by the formula, '-1' if its // negation is implied, or '0' if this is unclear at this point. // // require (VALID) // ensure (VALID) // int fixed (int lit) const; 可以使用此函数查询根级别分配的变量。如果字面量由公式暗示，则返回'1'， 如果隐含其否定则返回'-1'，如果此时不清楚则返回'0'。 //------------------------------------------------------------------------ // Force the default decision phase of a variable to a certain value. // void phase (int lit); void unphase (int lit); //------------------------------------------------------------------------ // Enables clausal proof tracing in DRAT format and returns 'true' if // successfully opened for writing. Writing proofs has to be enabled // before calling 'solve', 'add' and 'dimacs', that is in state // 'CONFIGURING'. Otherwise only partial proofs would be written. // // require (CONFIGURING) // ensure (CONFIGURING) // bool trace_proof (FILE * file, const char * name); // Write DRAT proof. bool trace_proof (const char * path); // Open & write proof. // Flush proof trace file. // // require (VALID) // ensure (VALID) // void flush_proof_trace (); // Close proof trace early. // // require (VALID) // ensure (VALID) // void close_proof_trace (); //------------------------------------------------------------------------ static void usage (); // print usage information for long options static void configurations (); // print configuration usage options // require (!DELETING) // ensure (!DELETING) // void statistics (); // print statistics void resources (); // print resource usage (time and memory) // require (VALID) // ensure (VALID) // void options (); // print current option and value list //------------------------------------------------------------------------ // Traverse irredundant clauses or the extension stack in reverse order. // // The return value is false if traversal is aborted early due to one of // the visitor functions returning false. See description of the // iterators below for more details on how to use these functions. // // require (VALID) // ensure (VALID) // bool traverse_clauses (ClauseIterator &) const; bool traverse_witnesses_backward (WitnessIterator &) const; bool traverse_witnesses_forward (WitnessIterator &) const; //------------------------------------------------------------------------ // Files with explicit path argument support compressed input and output // if appropriate helper functions 'gzip' etc. are available. They are // called through opening a pipe to an external command. // // If the 'strict' argument is zero then the number of variables and // clauses specified in the DIMACS headers are ignored, i.e., the header // 'p cnf 0 0' is always legal. If the 'strict' argument is larger '1' // strict formatting of the header is required, i.e., single spaces // everywhere and no trailing white space. // // Returns zero if successful and otherwise an error message. // // require (VALID) // ensure (VALID) // const char * read_dimacs (FILE * file, const char * name, int & vars, int strict = 1); const char * read_dimacs (const char * path, int & vars, int strict = 1); // The following routines work the same way but parse both DIMACS and // INCCNF files (with 'p inccnf' header and 'a <cube>' lines). If the // parser finds and 'p inccnf' header or cubes then '*incremental' is set // to true and the cubes are stored in the given vector (each cube // terminated by a zero). const char * read_dimacs (FILE * file, const char * name, int & vars, int strict, bool & incremental, std::vector<int> & cubes); const char * read_dimacs (const char * path, int & vars, int strict, bool & incremental, std::vector<int> & cubes); //------------------------------------------------------------------------ // Write current irredundant clauses and all derived unit clauses // to a file in DIMACS format. Clauses on the extension stack are // not included, nor any redundant clauses. // // The 'min_max_var' parameter gives a lower bound on the number '<vars>' // of variables used in the DIMACS 'p cnf <vars> ...' header. // // Returns zero if successful and otherwise an error message. // // require (VALID) // ensure (VALID) // const char * write_dimacs (const char * path, int min_max_var = 0); // The extension stack for reconstruction a solution can be written too. // const char * write_extension (const char * path); // Print build configuration to a file with prefix 'c '. If the file // is '<stdout>' or '<stderr>' then terminal color codes might be used. // static void build (FILE * file, const char * prefix = "c "); private: //==== start of state ==================================================== // The solver is in the state ADDING if either the current clause or the // constraint (or both) is not yet terminated. bool adding_clause; bool adding_constraint; State _state; // API states as discussed above. /*----------------------------------------------------------------------*/ // The 'Solver' class is a 'facade' object for 'External'. It exposes the // public API of 'External' but hides everything else (except for the some // private functions). It is supposed to make it easier to understand the // API and use the solver through the API. // This approach has the benefit of decoupling this header file from all // internal data structures, which is particularly useful if the rest of // the source is not available. For instance if only a CaDiCaL library is // installed in a system, then only this header file has to be installed // too, and still allows to compile and link against the library. /*----------------------------------------------------------------------*/ // More precisely the CaDiCaL code is split into three layers: // // Solver: facade object providing the actual API of the solver // External: communication layer between 'Solver' and 'Internal' // Internal: the actual solver code // // The 'External' and 'Internal' layers are declared and implemented in // the corresponding '{external,internal}.{hpp,cpp}' files (as expected), // while the 'Solver' facade class is defined in 'cadical.hpp' (here) but // implemented in 'solver.cpp'. The reason for this naming mismatch is, // that we want to use 'cadical.hpp' for the library header (this header // file) and call the binary of the stand alone SAT also 'cadical', which // is more naturally implemented in 'cadical.cpp'. // // Separating 'External' from 'Internal' also allows us to map external // literals to internal literals, which is useful with many fixed or // eliminated variables (during 'compact' the internal variable range is // reduced and external variables are remapped). Such an approach is also // necessary, if we want to use extended resolution in the future (such as // bounded variable addition). // Internal * internal; // Hidden internal solver. External * external; // Hidden API to internal solver mapping. #ifndef NTRACING // The API calls to the solver can be traced by setting the environment // variable 'CADICAL_API_TRACE' to point to the path of a file to which // API calls are written. The same format is used which 'mobical' can // read, execute and also shrink through delta debugging. // // The environment variable is read in the constructor and the trace is // opened for writing and then closed again in the destructor. // // Alternatively one case use 'trace_api_calls'. Both // bool close_trace_api_file; // Close file if owned by solver it. FILE * trace_api_file; // Also acts as flag that we are tracing. static bool tracing_api_through_environment; //===== end of state ==================================================== void trace_api_call (const char *) const; void trace_api_call (const char *, int) const; void trace_api_call (const char *, const char *, int) const; #endif void transition_to_unknown_state (); //------------------------------------------------------------------------ // Used in the stand alone solver application 'App' and the model based // tester 'Mobical'. So only these two classes need direct access to the // otherwise more application specific functions listed here together with // the internal DIMACS parser. friend class App; friend class Mobical; friend class Parser; // Read solution in competition format for debugging and testing. // // require (VALID) // ensure (VALID) // const char * read_solution (const char * path); // Cross-compilation with 'MinGW' needs some work-around for 'printf' // style printing of 64-bit numbers including warning messages. The // followings lines are copies of similar code in 'inttypes.hpp' but we // want to keep the 'cadical.hpp' header file stand-alone. # ifndef PRINTF_FORMAT # ifdef __MINGW32__ # define __USE_MINGW_ANSI_STDIO 1 # define PRINTF_FORMAT __MINGW_PRINTF_FORMAT # else # define PRINTF_FORMAT printf # endif # endif // This gives warning messages for wrong 'printf' style format string usage. // Apparently (on 'gcc 9' at least) the first argument is 'this' here. // // TODO: support for other compilers (beside 'gcc' and 'clang'). # define CADICAL_ATTRIBUTE_FORMAT(FORMAT_POSITION,VARIADIC_ARGUMENT_POSITION) \ __attribute__ ((format (PRINTF_FORMAT, FORMAT_POSITION, VARIADIC_ARGUMENT_POSITION))) // Messages in a common style. // // require (VALID | DELETING) // ensure (VALID | DELETING) // void section (const char *); // print section header void message (const char *, ...) // ordinary message CADICAL_ATTRIBUTE_FORMAT (2, 3); void message (); // empty line - only prefix void error (const char *, ...) // produce error message CADICAL_ATTRIBUTE_FORMAT (2, 3); // Explicit verbose level ('section' and 'message' use '0'). // // require (VALID | DELETING) // ensure (VALID | DELETING) // void verbose (int level, const char *, ...) CADICAL_ATTRIBUTE_FORMAT (3, 4); // Factoring out common code to both 'read_dimacs' functions above. // // require (VALID) // ensure (VALID) // const char * read_dimacs (File *, int &, int strict, bool * incremental = 0, std::vector<int> * = 0); // Factored out common code for 'solve', 'simplify' and 'lookahead'. // int call_external_solve_and_check_results (bool preprocess_only); //------------------------------------------------------------------------ // Print DIMACS file to '<stdout>' for debugging and testing purposes, // including derived units and assumptions. Since it will print in terms // of internal literals it is otherwise not really useful. To write a // DIMACS formula in terms of external variables use 'write_dimacs'. // // require (!INITIALIZING) // ensure (!INITIALIZING) // void dump_cnf (); friend struct DumpCall; // Mobical calls 'dump_cnf' in 'DumpCall::execute' }; /*========================================================================*/ // Connected terminators are checked for termination regularly. If the // 'terminate' function of the terminator returns true the solver is // terminated synchronously as soon it calls this function. class Terminator { public: virtual ~Terminator () { } virtual bool terminate () = 0; }; // Connected learners which can be used to export learned clauses. // The 'learning' can check the size of the learn clause and only if it // returns true then the individual literals of the learned clause are given // to the learn through 'learn' one by one terminated by a zero literal. class Learner { public: virtual ~Learner () { } virtual bool learning (int size) = 0; virtual void learn (int lit) = 0; }; /*------------------------------------------------------------------------*/ // Allows to traverse all remaining irredundant clauses. Satisfied and // eliminated clauses are not included, nor any derived units unless such // a unit literal is frozen. Falsified literals are skipped. If the solver // is inconsistent only the empty clause is traversed. // // If 'clause' returns false traversal aborts early. class ClauseIterator { public: virtual ~ClauseIterator () { } virtual bool clause (const std::vector<int> &) = 0; };
	Clause 见文件clause.hpp
	struct Clause { #ifdef LOGGING int64_t id; // Only useful for debugging. #endif bool conditioned:1; // Tried for globally blocked clause elimination. bool covered:1; // Already considered for covered clause elimination. bool enqueued:1; // Enqueued on backward queue. bool frozen:1; // Temporarily frozen (in covered clause elimination). bool garbage:1; // can be garbage collected unless it is a 'reason' bool gate:1 ; // Clause part of a gate (function definition). bool hyper:1; // redundant hyper binary or ternary resolved bool instantiated:1;// tried to instantiate bool keep:1; // always keep this clause (if redundant) bool moved:1; // moved during garbage collector ('copy' valid) bool reason:1; // reason / antecedent clause can not be collected bool redundant:1; // aka 'learned' so not 'irredundant' (original) bool transred:1; // already checked for transitive reduction bool subsume:1; // not checked in last subsumption round unsigned used:2; // resolved in conflict analysis since last 'reduce' bool vivified:1; // clause already vivified bool vivify:1; // clause scheduled to be vivified // The glucose level ('LBD' or short 'glue') is a heuristic value for the // expected usefulness of a learned clause, where smaller glue is consider // more useful. During learning the 'glue' is determined as the number of // decisions in the learned clause. Thus the glue of a clause is a strict // upper limit on the smallest number of decisions needed to make it // propagate. For instance a binary clause will propagate if one of its // literals is set to false. Similarly a learned clause with glue 1 can // propagate after one decision, one with glue 2 after 2 decisions etc. // In some sense the glue is an abstraction of the size of the clause. // // See the IJCAI'09 paper by Audemard & Simon for more details. We // switched back and forth between keeping the glue stored in a clause and // using it only initially to determine whether it is kept, that is // survives clause reduction. The latter strategy is not bad but also // does not allow to use glue values for instance in 'reduce'. // // More recently we also update the glue and promote clauses to lower // level tiers during conflict analysis. The idea of using three tiers is // also due to Chanseok Oh and thus used in all recent 'Maple...' solvers. // Tier one are the always kept clauses with low glue at most // 'opts.reducetier1glue' (default '2'). The second tier contains all // clauses with glue larger than 'opts.reducetier1glue' but smaller or // equal than 'opts.reducetier2glue' (default '6'). The third tier // consists of clauses with glue larger than 'opts.reducetier2glue'. // // Clauses in tier one are not deleted in 'reduce'. Clauses in tier // two require to be unused in two consecutive 'reduce' intervals before // being collected while for clauses in tier three not being used since // the last 'reduce' call makes them deletion candidates. Clauses derived // by hyper binary or ternary resolution (even though small and thus with // low glue) are always removed if they remain unused during one interval. // See 'mark_useless_redundant_clauses_as_garbage' in 'reduce.cpp' and // 'bump_clause' in 'analyze.cpp'. // int glue; int size; // Actual size of 'literals' (at least 2). int pos; // Position of last watch replacement [Gent'13]. union { int literals[2]; // Of variadic 'size' (shrunken if strengthened). Clause * copy; // Only valid if 'moved', then that's where to. // // The 'copy' field is only valid for 'moved' clauses in the moving // garbage collector 'copy_non_garbage_clauses' for keeping clauses // compactly in a contiguous memory arena. Otherwise, most of // the time, 'literals' is valid. See 'collect.cpp' for details. };
	Var 见文件var.hpp
	struct Var { // Note that none of these members is valid unless the variable is // assigned. During unassigning a variable we do not reset it. int level; // decision level int trail; // trail height at assignment Clause * reason; // implication graph edge during search };
	Level 见文件level.hpp
	struct Level { int decision; // decision literal of this level int trail; // trail start of this level struct { int count; // how many variables seen during 'analyze' int trail; // smallest trail position seen on this level } seen; void reset () { seen.count = 0; seen.trail = INT_MAX; } Level (int d, int t) : decision (d), trail (t) { reset (); } Level () { } };
	Internal 见文件 Internal.hpp
	重点的成员函数 （1）理解文字、变元量表示、存储与操作 Var & var (int lit)        { return vtab[vidx (lit)]; }  // Line 322 // Unsigned literals (abs) with checks. // int vidx (int lit) const {     int idx;     assert (lit);     assert (lit != INT_MIN);     idx = abs (lit);     assert (idx <= max_var);     return idx; } //============================================================================= ---------- cadical-rel-1.5.3\src\internal.hpp [310] unsigned vlit (int lit) { return (lit < 0) + 2u * (unsigned) vidx (lit); } int u2i (unsigned u) {     assert (u > 1);     int res = u/2;     assert (res <= max_var);     if (u & 1) res = -res;    return res; } 由以上两个函数可知,Cadical对文字的表示是由正负整数来分别表示的;这与minisat系列的表示方式不同.两者之间可以进行转换. internal.hpp文件中 struct Internal类型声明中有数据成员         vector<int> i2e; // maps internal 'idx' to external 'lit'   [322] Var & var (int lit) { return vtab[vidx (lit)]; }  依据文字查询Var类型的元素，vtab中存由位置1-maxv分别对应的Var类型的元素     顺便了解一下各种成员变量，它们都是向量类型，且索引位置序号都是由变元量来对应。 vector<double> stab;　　 　　// table of variable scores [1,max_var] vector<Var> vtab;      　　　　// variable table [1,max_var] vector<Flags> ftab;　　　　 // variable and literal flags vector<int64_t> btab; 　　　　 // enqueue time stamps for queue vector<int64_t> gtab;　　 // time stamp table to recompute glue vector<Occs> otab; 　　 // table of occurrences for all literals vector<int> ptab; 　　 // table for caching probing attempts vector<int64_t> ntab; 　　 // number of one-sided occurrences table vector<Bins> big; 　　 // binary implication graph vector<Watches> wtab; 　　 // table of watches for all literals vector<signed char> marks;　　 // signed marks [1,max_var] vector<unsigned> frozentab; 　　 // frozen counters [1,max_var] Queue queue; // variable move to front decision queue Links links; // table of links for decision queue [323] Link & link (int lit) { return links[vidx (lit)]; } [324] Flags & flags (int lit) { return ftab[vidx (lit)]; } [325] int64_t & bumped (int lit) { return btab[vidx (lit)]; } [327] double & score (int lit) { return stab[vidx (lit)]; } [330] flags (int lit) const { return ftab[vidx (lit)]; } [350] signed char res = marks [ vidx (lit) ]; [356] marks[vidx (lit)] = sign (lit); [361] marks [ vidx (lit) ] = 0; [369] signed char res = marks [ vidx (lit) ] >> 6; [374] signed char & m = marks[vidx (lit)]; [387] signed char & m = marks[vidx (lit)]; [407] return marks[vidx (lit)] & (1<<bit); [412] marks[vidx (lit)] |= (1<<bit); [418] marks[vidx (lit)] &= ~(1<<bit); [425] unsigned res = marks [ vidx (lit) ]; [431] marks[vidx (lit)] |= bign (lit); [1075] const int idx = vidx (lit); [1097] int idx = vidx (lit); [1105] int idx = vidx (lit); [1115] bool frozen (int lit) { return frozentab[vidx (lit)] > 0; } //=============================================================================   （2）理解二值观察-与观察元的建立 // Watch literal 'lit' in clause with blocking literal 'blit'. // Inlined here, since it occurs in the tight inner loop of 'propagate'. // inline void watch_literal (int lit, int blit, Clause * c) { assert (lit != blit); Watches & ws = watches (lit); ws.push_back (Watch (blit, c)); LOG (c, "watch %d blit %d in", lit, blit); } // Add two watches to a clause. This is used initially during allocation // of a clause and during connecting back all watches after preprocessing. // inline void watch_clause (Clause * c) { const int l0 = c->literals[0]; const int l1 = c->literals[1]; watch_literal (l0, l1, c); watch_literal (l1, l0, c); } inline void unwatch_clause (Clause * c) { const int l0 = c->literals[0]; const int l1 = c->literals[1]; remove_watch (watches (l0), c); remove_watch (watches (l1), c); }   (3)与传播文字相关的量存储结构 size_t propagated;          // next trail position to propagate size_t propagated2;        // next binary trail position to propagate size_t best_assigned;     // best maximum assigned ever size_t target_assigned;  // maximum assigned without conflict size_t no_conflict_until;  // largest trail prefix without conflict vector<int> trail;             // currently assigned literals Queue queue;                // variable move to front decision queue Links links;                     // table of links for decision queue   (4)与变元对应指标相关的量 signed char * vals;                           // assignment [-max_var,max_var] vector<signed char> marks;            // signed marks [1,max_var] vector<unsigned> frozentab;           // frozen counters [1,max_var] vector<int> i2e;                                // maps internal 'idx' to external 'lit' vector<double> stab;                      // table of variable scores [1,max_var] vector<Var> vtab;                           // variable table [1,max_var] vector<int> parents;                       // parent literals during probing vector<Flags> ftab;                        // variable and literal flags vector<int64_t> btab;                     // enqueue time stamps for queue vector<int64_t> gtab;                     // time stamp table to recompute glue vector<int> ptab;                            // table for caching probing attempts vector<int64_t> ntab;                     // number of one-sided occurrences table   （） double score_inc;                          // current score increment ScoreSchedule scores;                 // score based decision priority queue vector<Occs> otab;                       // table of occurrences for all literals
	struct Internal { /*----------------------------------------------------------------------*/ // The actual internal state of the solver is set and maintained in this // section. This is currently only used for debugging and testing. enum Mode { BLOCK = (1<<0), CONDITION= (1<<1), COVER = (1<<2), DECOMP = (1<<3), DEDUP = (1<<4), ELIM = (1<<5), LUCKY = (1<<6), PROBE = (1<<7), SEARCH = (1<<8), SIMPLIFY = (1<<9), SUBSUME = (1<<10), TERNARY = (1<<11), TRANSRED = (1<<12), VIVIFY = (1<<13), WALK = (1<<14), }; bool in_mode (Mode m) const { return (mode & m) != 0; } void set_mode (Mode m) { assert (!(mode & m)); mode |= m; } void reset_mode (Mode m) { assert (mode & m); mode &= ~m; } void require_mode (Mode m) const { assert (mode & m), (void) m; } /*----------------------------------------------------------------------*/ int mode; // current internal state bool unsat; // empty clause found or learned bool iterating; // report learned unit ('i' line) bool localsearching; // true during local search bool lookingahead; // true during look ahead bool preprocessing; // true during preprocessing bool protected_reasons; // referenced reasons are protected bool force_saved_phase; // force saved phase in decision bool searching_lucky_phases; // during 'lucky_phases' bool stable; // true during stabilization phase bool reported; // reported in this solving call char rephased; // last type of resetting phases Reluctant reluctant; // restart counter in stable mode size_t vsize; // actually allocated variable data size int max_var; // internal maximum variable index int level; // decision level ('control.size () - 1') Phases phases; // saved, target and best phases signed char * vals; // assignment [-max_var,max_var] vector<signed char> marks; // signed marks [1,max_var] vector<unsigned> frozentab; // frozen counters [1,max_var] vector<int> i2e; // maps internal 'idx' to external 'lit' Queue queue; // variable move to front decision queue Links links; // table of links for decision queue double score_inc; // current score increment ScoreSchedule scores; // score based decision priority queue vector<double> stab; // table of variable scores [1,max_var] vector<Var> vtab; // variable table [1,max_var] vector<int> parents; // parent literals during probing vector<Flags> ftab; // variable and literal flags vector<int64_t> btab; // enqueue time stamps for queue vector<int64_t> gtab; // time stamp table to recompute glue vector<Occs> otab; // table of occurrences for all literals vector<int> ptab; // table for caching probing attempts vector<int64_t> ntab; // number of one-sided occurrences table vector<Bins> big; // binary implication graph vector<Watches> wtab; // table of watches for all literals Clause * conflict; // set in 'propagation', reset in 'analyze' Clause * ignore; // ignored during 'vivify_propagate' size_t propagated; // next trail position to propagate size_t propagated2; // next binary trail position to propagate size_t best_assigned; // best maximum assigned ever size_t target_assigned; // maximum assigned without conflict size_t no_conflict_until; // largest trail prefix without conflict vector<int> trail; // currently assigned literals vector<int> clause; // simplified in parsing & learning vector<int> assumptions; // assumed literals vector<int> constraint; // literals of the constraint bool unsat_constraint; // constraint used for unsatisfiability? bool marked_failed; // are the failed assumptions marked? vector<int> original; // original added literals vector<int> levels; // decision levels in learned clause vector<int> analyzed; // analyzed literals in 'analyze' vector<int> minimized; // removable or poison in 'minimize' vector<int> shrinkable; // removable or poison in 'shrink' Reap reap; // radix heap for shrink vector<int> probes; // remaining scheduled probes vector<Level> control; // 'level + 1 == control.size ()' vector<Clause*> clauses; // ordered collection of all clauses Averages averages; // glue, size, jump moving averages Limit lim; // limits for various phases Last last; // statistics at last occurrence Inc inc; // increments on limits Proof * proof; // clausal proof observers if non zero Checker * checker; // online proof checker observing proof Tracer * tracer; // proof to file tracer observing proof Options opts; // run-time options Stats stats; // statistics #ifndef QUIET Profiles profiles; // time profiles for various functions bool force_phase_messages; // force 'phase (...)' messages #endif Arena arena; // memory arena for moving garbage collector Format error_message; // provide persistent error message string prefix; // verbose messages prefix Internal * internal; // proxy to 'this' in macros External * external; // proxy to 'external' buddy in 'Solver' /*----------------------------------------------------------------------*/ // Asynchronous termination flag written by 'terminate' and read by // 'terminated_asynchronously' (the latter at the end of this header). // volatile bool termination_forced; /*----------------------------------------------------------------------*/ const Range vars; // Provides safe variable iteration. const Sange lits; // Provides safe literal iteration. /*----------------------------------------------------------------------*/ Internal (); ~Internal (); /*----------------------------------------------------------------------*/ // Internal delegates and helpers for corresponding functions in // 'External' and 'Solver'. The 'init_vars' function initializes // variables up to and including the requested variable index. // void init_vars (int new_max_var); void init_enqueue (int idx); void init_queue (int old_max_var, int new_max_var); void init_scores (int old_max_var, int new_max_var); void add_original_lit (int lit); // Enlarge tables. // void enlarge_vals (size_t new_vsize); void enlarge (int new_max_var); // A variable is 'active' if it is not eliminated nor fixed. // bool active (int lit) { return flags(lit).active (); } int active () const { int res = stats.active; #ifndef NDEBUG int tmp = max_var; tmp -= stats.unused; tmp -= stats.now.fixed; tmp -= stats.now.eliminated; tmp -= stats.now.substituted; tmp -= stats.now.pure; assert (tmp >= 0); assert (tmp == res); #endif return res; } void reactivate (int lit); // During 'restore'. // Currently remaining active redundant and irredundant clauses. int64_t redundant () const { return stats.current.redundant; } int64_t irredundant () const { return stats.current.irredundant; } double clause_variable_ratio () const { return relative (irredundant (), active ()); } // Scale values relative to clause variable ratio. // double scale (double v) const; // Unsigned literals (abs) with checks. // int vidx (int lit) const { int idx; assert (lit); assert (lit != INT_MIN); idx = abs (lit); assert (idx <= max_var); return idx; } // Unsigned version with LSB denoting sign. This is used in indexing arrays // by literals. The idea is to keep the elements in such an array for both // the positive and negated version of a literal close together. // unsigned vlit (int lit) { return (lit < 0) + 2u * (unsigned) vidx (lit); } int u2i (unsigned u) { assert (u > 1); int res = u/2; assert (res <= max_var); if (u & 1) res = -res; return res; } // Helper functions to access variable and literal data. // Var & var (int lit) { return vtab[vidx (lit)]; } Link & link (int lit) { return links[vidx (lit)]; } Flags & flags (int lit) { return ftab[vidx (lit)]; } int64_t & bumped (int lit) { return btab[vidx (lit)]; } int & propfixed (int lit) { return ptab[vlit (lit)]; } double & score (int lit) { return stab[vidx (lit)]; } const Flags & flags (int lit) const { return ftab[vidx (lit)]; } bool occurring () const { return !otab.empty (); } bool watching () const { return !wtab.empty (); } Bins & bins (int lit) { return big[vlit (lit)]; } Occs & occs (int lit) { return otab[vlit (lit)]; } int64_t & noccs (int lit) { return ntab[vlit (lit)]; } Watches & watches (int lit) { return wtab[vlit (lit)]; } // Variable bumping through exponential VSIDS (EVSIDS) as in MiniSAT. // bool use_scores () const { return opts.score && stable; } void bump_variable_score (int lit); void bump_variable_score_inc (); void rescale_variable_scores (); // Marking variables with a sign (positive or negative). // signed char marked (int lit) const { signed char res = marks [ vidx (lit) ]; if (lit < 0) res = -res; return res; } void mark (int lit) { assert (!marked (lit)); marks[vidx (lit)] = sign (lit); assert (marked (lit) > 0); assert (marked (-lit) < 0); } void unmark (int lit) { marks [ vidx (lit) ] = 0; assert (!marked (lit)); } // Use only bits 6 and 7 to store the sign or zero. The remaining // bits can be use as additional flags. // signed char marked67 (int lit) const { signed char res = marks [ vidx (lit) ] >> 6; if (lit < 0) res = -res; return res; } void mark67 (int lit) { signed char & m = marks[vidx (lit)]; const signed char mask = 0x3f; #ifndef NDEBUG const signed char bits = m & mask; #endif m = (m & mask) | (sign (lit) << 6); assert (marked (lit) > 0); assert (marked (-lit) < 0); assert ((m & mask) == bits); assert (marked67 (lit) > 0); assert (marked67 (-lit) < 0); } void unmark67 (int lit) { signed char & m = marks[vidx (lit)]; const signed char mask = 0x3f; #ifndef NDEBUG const signed bits = m & mask; #endif m &= mask; assert ((m & mask) == bits); } void unmark (vector<int> & lits) { for (const auto & lit : lits) unmark (lit); } // The other 6 bits of the 'marks' bytes can be used as additional // (unsigned) marking bits. Currently we only use the least significant // bit in 'condition' to mark variables in the conditional part. // bool getbit (int lit, int bit) const { assert (0 <= bit), assert (bit < 6); return marks[vidx (lit)] & (1<<bit); } void setbit (int lit, int bit) { assert (0 <= bit), assert (bit < 6); assert (!getbit (lit, bit)); marks[vidx (lit)] |= (1<<bit); assert (getbit (lit, bit)); } void unsetbit (int lit, int bit) { assert (0 <= bit), assert (bit < 6); assert (getbit (lit, bit)); marks[vidx (lit)] &= ~(1<<bit); assert (!getbit (lit, bit)); } // Marking individual literals. // bool marked2 (int lit) const { unsigned res = marks [ vidx (lit) ]; assert (res <= 3); unsigned bit = bign (lit); return (res & bit) != 0; } void mark2 (int lit) { marks[vidx (lit)] |= bign (lit); assert (marked2 (lit)); } // Marking and unmarking of all literals in a clause. // void mark_clause (); // mark 'this->clause' void mark (Clause *); void mark2 (Clause *); void unmark_clause (); // unmark 'this->clause' void unmark (Clause *); // Watch literal 'lit' in clause with blocking literal 'blit'. // Inlined here, since it occurs in the tight inner loop of 'propagate'. // inline void watch_literal (int lit, int blit, Clause * c) { assert (lit != blit); Watches & ws = watches (lit); ws.push_back (Watch (blit, c)); LOG (c, "watch %d blit %d in", lit, blit); } // Add two watches to a clause. This is used initially during allocation // of a clause and during connecting back all watches after preprocessing. // inline void watch_clause (Clause * c) { const int l0 = c->literals[0]; const int l1 = c->literals[1]; watch_literal (l0, l1, c); watch_literal (l1, l0, c); } inline void unwatch_clause (Clause * c) { const int l0 = c->literals[0]; const int l1 = c->literals[1]; remove_watch (watches (l0), c); remove_watch (watches (l1), c); } // Update queue to point to last potentially still unassigned variable. // All variables after 'queue.unassigned' in bump order are assumed to be // assigned. Then update the 'queue.bumped' field and log it. This is // inlined here since it occurs in several inner loops. // inline void update_queue_unassigned (int idx) { assert (0 < idx); assert (idx <= max_var); queue.unassigned = idx; queue.bumped = btab[idx]; LOG ("queue unassigned now %d bumped %" PRId64 "", idx, btab[idx]); } void bump_queue (int idx); // Mark (active) variables as eliminated, substituted, pure or fixed, // which turns them into inactive variables. // void mark_eliminated (int); void mark_substituted (int); void mark_active (int); void mark_fixed (int); void mark_pure (int); // Managing clauses in 'clause.cpp'. Without explicit 'Clause' argument // these functions work on the global temporary 'clause'. // Clause * new_clause (bool red, int glue = 0); void promote_clause (Clause *, int new_glue); size_t shrink_clause (Clause *, int new_size); void minimize_sort_clause(); void shrink_and_minimize_clause (); void reset_shrinkable(); void mark_shrinkable_as_removable(int, std::vector<int>::size_type); int shrink_literal(int, int, unsigned); unsigned shrunken_block_uip(int, int, std::vector<int>::reverse_iterator &, std::vector<int>::reverse_iterator &, std::vector<int>::size_type, const int); void shrunken_block_no_uip( const std::vector<int>::reverse_iterator&, const std::vector<int>::reverse_iterator&, unsigned&, const int); void push_literals_of_block( const std::vector<int>::reverse_iterator&, const std::vector<int>::reverse_iterator&, int, unsigned); unsigned shrink_next(unsigned&, unsigned&); std::vector<int>::reverse_iterator minimize_and_shrink_block( std::vector<int>::reverse_iterator&, unsigned int&, unsigned int&, const int); unsigned shrink_block( std::vector<int>::reverse_iterator&, std::vector<int>::reverse_iterator&, int, unsigned&, unsigned&, const int, unsigned); unsigned shrink_along_reason(int, int, bool, bool&, unsigned); void deallocate_clause(Clause *); void delete_clause (Clause *); void mark_garbage (Clause *); void assign_original_unit (int); void add_new_original_clause (); Clause * new_learned_redundant_clause (int glue); Clause * new_hyper_binary_resolved_clause (bool red, int glue); Clause * new_clause_as (const Clause * orig); Clause * new_resolved_irredundant_clause (); // Forward reasoning through propagation in 'propagate.cpp'. // int assignment_level (int lit, Clause*); void search_assign (int lit, Clause *); void search_assign_driving (int lit, Clause * reason); void search_assume_decision (int decision); void assign_unit (int lit); bool propagate (); // Undo and restart in 'backtrack.cpp'. // void unassign (int lit); void update_target_and_best (); void backtrack (int target_level = 0); // Minimized learned clauses in 'minimize.cpp'. // bool minimize_literal (int lit, int depth = 0); void minimize_clause (); // Learning from conflicts in 'analyze.cc'. // void learn_empty_clause (); void learn_unit_clause (int lit); void bump_variable (int lit); void bump_variables (); int recompute_glue (Clause *); void bump_clause (Clause *); void clear_analyzed_literals (); void clear_analyzed_levels (); void clear_minimized_literals (); bool bump_also_reason_literal (int lit); void bump_also_reason_literals (int lit, int limit); void bump_also_all_reason_literals (); void analyze_literal (int lit, int & open); void analyze_reason (int lit, Clause *, int & open); Clause * new_driving_clause (const int glue, int & jump); int find_conflict_level (int & forced); int determine_actual_backtrack_level (int jump); void analyze (); void iterate (); // report learned unit clause // Use last learned clause to subsume some more. // void eagerly_subsume_recently_learned_clauses (Clause *); // Restarting policy in 'restart.cc'. // bool stabilizing (); bool restarting (); int reuse_trail (); void restart (); // Functions to set and reset certain 'phases'. // void clear_phases (vector<signed char> &); // reset argument to zero void copy_phases (vector<signed char> &); // copy 'saved' to argument // Resetting the saved phased in 'rephase.cpp'. // bool rephasing (); char rephase_best (); char rephase_flipping (); char rephase_inverted (); char rephase_original (); char rephase_random (); char rephase_walk (); void shuffle_scores (); void shuffle_queue (); void rephase (); // Lucky feasible case checking. // int unlucky (int res); int trivially_false_satisfiable (); int trivially_true_satisfiable (); int forward_false_satisfiable (); int forward_true_satisfiable (); int backward_false_satisfiable (); int backward_true_satisfiable (); int positive_horn_satisfiable (); int negative_horn_satisfiable (); // Asynchronous terminating check. // bool terminated_asynchronously (int factor = 1); bool search_limits_hit (); void terminate () { LOG ("forcing asynchronous termination"); termination_forced = true; } // Reducing means determining useless clauses with 'reduce' in // 'reduce.cpp' as well as root level satisfied clause and then removing // those which are not used as reason anymore with garbage collection. // bool flushing (); bool reducing (); void protect_reasons (); void mark_clauses_to_be_flushed (); void mark_useless_redundant_clauses_as_garbage (); bool propagate_out_of_order_units (); void unprotect_reasons (); void reduce (); // Garbage collection in 'collect.cpp' called from 'reduce' and during // inprocessing and preprocessing. // int clause_contains_fixed_literal (Clause *); void remove_falsified_literals (Clause *); void mark_satisfied_clauses_as_garbage (); void copy_clause (Clause *); void flush_watches (int lit, Watches &); size_t flush_occs (int lit); void flush_all_occs_and_watches (); void update_reason_references (); void copy_non_garbage_clauses (); void delete_garbage_clauses (); void check_clause_stats (); void check_var_stats (); bool arenaing (); void garbage_collection (); // Set-up occurrence list counters and containers. // void init_occs (); void init_bins (); void init_noccs (); void reset_occs (); void reset_bins (); void reset_noccs (); // Operators on watches. // void init_watches (); void connect_watches (bool irredundant_only = false); void sort_watches (); void clear_watches (); void reset_watches (); // Regular forward subsumption checking in 'subsume.cpp'. // bool subsuming (); void strengthen_clause (Clause *, int); void subsume_clause (Clause * subsuming, Clause * subsumed); int subsume_check (Clause * subsuming, Clause * subsumed); int try_to_subsume_clause (Clause *, vector<Clause*> & shrunken); void reset_subsume_bits (); bool subsume_round (); void subsume (bool update_limits = true); // Covered clause elimination of large clauses. // void covered_literal_addition (int lit, Coveror &); void asymmetric_literal_addition (int lit, Coveror &); void cover_push_extension (int lit, Coveror &); bool cover_propagate_asymmetric (int lit, Clause * ignore, Coveror &); bool cover_propagate_covered (int lit, Coveror &); bool cover_clause (Clause * c, Coveror &); int64_t cover_round (); bool cover (); // Strengthening through vivification in 'vivify.cpp'. // void flush_vivification_schedule (Vivifier &); bool consider_to_vivify_clause (Clause * candidate, bool redundant_mode); void vivify_analyze_redundant (Vivifier &, Clause * start, bool &); bool vivify_all_decisions (Clause * candidate, int subsume); void vivify_post_process_analysis (Clause * candidate, int subsume); void vivify_strengthen (Clause * candidate); void vivify_assign (int lit, Clause *); void vivify_assume (int lit); bool vivify_propagate (); void vivify_clause (Vivifier &, Clause * candidate); void vivify_round (bool redundant_mode, int64_t delta); void vivify (); // Compacting (shrinking internal variable tables) in 'compact.cpp' // bool compacting (); void compact (); // Transitive reduction of binary implication graph in 'transred.cpp' // void transred (); // We monitor the maximum size and glue of clauses during 'reduce' and // thus can predict if a redundant extended clause is likely to be kept in // the next 'reduce' phase. These clauses are target of subsumption and // vivification checks, in addition to irredundant clauses. Their // variables are also marked as being 'added'. // bool likely_to_be_kept_clause (Clause * c) { if (!c->redundant) return true; if (c->keep) return true; if (c->glue > lim.keptglue) return false; if (c->size > lim.keptsize) return false; return true; } // We mark variables in added or shrunken clauses as 'subsume' candidates // if the clause is likely to be kept in the next 'reduce' phase (see last // function above). This gives a persistent (across consecutive // interleaved search and inprocessing phases) set of variables which have // to be reconsidered in subsumption checks, i.e., only clauses with // 'subsume' marked variables are checked to be forward subsumed. // A similar technique is used to reduce the effort in hyper ternary // resolution to focus on variables in new ternary clauses. // void mark_subsume (int lit) { Flags & f = flags (lit); if (f.subsume) return; LOG ("marking %d as subsuming literal candidate", abs (lit)); stats.mark.subsume++; f.subsume = true; } void mark_ternary (int lit) { Flags & f = flags (lit); if (f.ternary) return; LOG ("marking %d as ternary resolution literal candidate", abs (lit)); stats.mark.ternary++; f.ternary = true; } void mark_added (int lit, int size, bool redundant); void mark_added (Clause *); bool marked_subsume(int lit) const { return flags(lit).subsume; } // If irredundant clauses are removed or literals in clauses are removed, // then variables in such clauses should be reconsidered to be eliminated // through bounded variable elimination. In contrast to 'subsume' the // 'elim' flag is restricted to 'irredundant' clauses only. For blocked // clause elimination it is better to have a more precise signed version, // which allows to independently mark positive and negative literals. // void mark_elim(int lit) { Flags &f = flags(lit); if (f.elim) return; LOG("marking %d as elimination literal candidate", lit); stats.mark.elim++; f.elim = true; } void mark_block(int lit) { Flags &f = flags(lit); const unsigned bit = bign(lit); if (f.block & bit) return; LOG("marking %d as blocking literal candidate", lit); stats.mark.block++; f.block |= bit; } void mark_removed(int lit) { mark_elim(lit); mark_block(-lit); } void mark_removed(Clause *, int except = 0); // The following two functions are only used for testing & debugging. bool marked_block(int lit) const { const Flags &f = flags(lit); const unsigned bit = bign(lit); return (f.block & bit) != 0; } void unmark_block(int lit) { Flags &f = flags(lit); const unsigned bit = bign(lit); f.block &= ~bit; } // During scheduling literals for blocked clause elimination we skip those // literals which occur negated in a too large clause. // void mark_skip(int lit) { Flags &f = flags(lit); const unsigned bit = bign(lit); if (f.skip & bit) return; LOG("marking %d to be skipped as blocking literal", lit); f.skip |= bit; } bool marked_skip(int lit) { const Flags &f = flags(lit); const unsigned bit = bign(lit); return (f.skip & bit) != 0; } // Blocked Clause elimination in 'block.cpp'. // bool is_blocked_clause(Clause * c, int pivot); void block_schedule(Blocker &); size_t block_candidates(Blocker &, int lit); Clause *block_impossible(Blocker &, int lit); void block_literal_with_at_least_two_negative_occs(Blocker &, int lit); void block_literal_with_one_negative_occ(Blocker &, int lit); void block_pure_literal(Blocker &, int lit); void block_reschedule_clause(Blocker &, int lit, Clause *); void block_reschedule(Blocker &, int lit); void block_literal(Blocker &, int lit); bool block(); // Find gates in 'gates.cpp' for bounded variable substitution. // int second_literal_in_binary_clause(Eliminator &, Clause *, int first); void mark_binary_literals(Eliminator &, int pivot); void find_and_gate(Eliminator &, int pivot); void find_equivalence(Eliminator &, int pivot); bool get_ternary_clause(Clause *, int &, int &, int &); bool match_ternary_clause(Clause *, int, int, int); Clause *find_ternary_clause(int, int, int); bool get_clause(Clause *, vector<int> &); bool is_clause(Clause *, const vector<int> &); Clause *find_clause(const vector<int> &); void find_xor_gate(Eliminator &, int pivot); void find_if_then_else(Eliminator &, int pivot); void find_gate_clauses(Eliminator &, int pivot); void unmark_gate_clauses(Eliminator &); // Bounded variable elimination in 'elim.cpp'. // bool eliminating(); double compute_elim_score(unsigned lit); void mark_redundant_clauses_with_eliminated_variables_as_garbage(); void unmark_binary_literals(Eliminator &); bool resolve_clauses(Eliminator &, Clause *, int pivot, Clause *, bool); void mark_eliminated_clauses_as_garbage(Eliminator &, int pivot); bool elim_resolvents_are_bounded(Eliminator &, int pivot); void elim_update_removed_lit(Eliminator &, int lit); void elim_update_removed_clause(Eliminator &, Clause *, int except = 0); void elim_update_added_clause(Eliminator &, Clause *); void elim_add_resolvents(Eliminator &, int pivot); void elim_backward_clause(Eliminator &, Clause *); void elim_backward_clauses(Eliminator &); void elim_propagate(Eliminator &, int unit); void elim_on_the_fly_self_subsumption(Eliminator &, Clause *, int); void try_to_eliminate_variable(Eliminator &, int pivot); void increase_elimination_bound(); int elim_round(bool &completed); void elim(bool update_limits = true); void inst_assign(int lit); bool inst_propagate(); void collect_instantiation_candidates(Instantiator &); bool instantiate_candidate(int lit, Clause *); void instantiate(Instantiator &); // Hyper ternary resolution. // bool ternary_find_binary_clause(int, int); bool ternary_find_ternary_clause(int, int, int); Clause *new_hyper_ternary_resolved_clause(bool red); bool hyper_ternary_resolve(Clause *, int, Clause *); void ternary_lit(int pivot, int64_t &steps, int64_t &htrs); void ternary_idx(int idx, int64_t &steps, int64_t &htrs); bool ternary_round(int64_t & steps, int64_t & htrs); bool ternary(); // Probing in 'probe.cpp'. // bool probing(); void failed_literal(int lit); void probe_assign_unit(int lit); void probe_assign_decision(int lit); void probe_assign(int lit, int parent); void mark_duplicated_binary_clauses_as_garbage(); int get_parent_reason_literal(int lit); void set_parent_reason_literal(int lit, int reason); int probe_dominator(int a, int b); int hyper_binary_resolve(Clause *); void probe_propagate2(); bool probe_propagate(); bool is_binary_clause(Clause * c, int &, int &); void generate_probes(); void flush_probes(); int next_probe(); bool probe_round(); void probe(bool update_limits = true); // ProbSAT/WalkSAT implementation called initially or from 'rephase'. // void walk_save_minimum(Walker &); Clause *walk_pick_clause(Walker &); unsigned walk_break_value(int lit); int walk_pick_lit(Walker &, Clause *); void walk_flip_lit(Walker &, int lit); int walk_round(int64_t limit, bool prev); void walk(); // Detect strongly connected components in the binary implication graph // (BIG) and equivalent literal substitution (ELS) in 'decompose.cpp'. // bool decompose_round(); void decompose(); void reset_limits(); // Reset after 'solve' call. // Assumption handling. // void assume(int); // New assumption literal. bool failed(int lit); // Literal failed assumption? void reset_assumptions(); // Reset after 'solve' call. void failing(); // Prepare failed assumptions. bool assumed(int lit) { // Marked as assumption. Flags &f = flags(lit); const unsigned bit = bign(lit); return (f.assumed & bit) != 0; } // Add temporary clause as constraint. // void constrain(int); // Add literal to constraint. bool failed_constraint(); // Was constraint used to proof unsatisfiablity? void reset_constraint(); // Reset after 'solve' call. // Forcing decision variables to a certain phase. // void phase(int lit); void unphase(int lit); // Globally blocked clause elimination. // bool is_autarky_literal(int lit) const; bool is_conditional_literal(int lit) const; void mark_as_conditional_literal(int lit); void unmark_as_conditional_literal(int lit); // bool is_in_candidate_clause(int lit) const; void mark_in_candidate_clause(int lit); void unmark_in_candidate_clause(int lit); // void condition_assign(int lit); void condition_unassign(int lit); // bool conditioning(); long condition_round(long unassigned_literal_propagation_limit); void condition(bool update_limits = true); // Part on picking the next decision in 'decide.cpp'. // bool satisfied(); int next_decision_variable_on_queue(); int next_decision_variable_with_best_score(); int next_decision_variable(); int decide_phase(int idx, bool target); int likely_phase(int idx); int decide(); // 0=decision, 20=failed // Internal functions to enable explicit search limits. // void limit_terminate(int); void limit_decisions(int); // Force decision limit. void limit_conflicts(int); // Force conflict limit. void limit_preprocessing(int); // Enable 'n' preprocessing rounds. void limit_local_search(int); // Enable 'n' local search rounds. // External versions can access limits by 'name'. // static bool is_valid_limit(const char *name); bool limit(const char *name, int); // 'true' if 'name' valid // Set all the CDCL search limits and increments for scheduling // inprocessing, restarts, clause database reductions, etc. // void init_report_limits(); void init_preprocessing_limits(); void init_search_limits(); // The computed averages are local to the 'stable' and 'unstable' phase. // Their main use is to be reported in 'report', except for the 'glue' // averages, which are used to schedule (prohibit actually) restarts // during 'unstable' phases ('stable' phases use reluctant doubling). // void init_averages(); void swap_averages(); int try_to_satisfy_formula_by_saved_phases(); void produce_failed_assumptions(); // Main solve & search functions in 'internal.cpp'. // // We have three pre-solving techniques. These consist of preprocessing, // local search and searching for lucky phases, which in full solving // mode except for the last are usually optional and then followed by // the main CDCL search loop with inprocessing. If only preprocessing // is requested from 'External::simplifiy' only preprocessing is called // though. This is all orchestrated by the 'solve' function. // int already_solved(); int restore_clauses(); bool preprocess_round(int round); int preprocess(); int local_search_round(int round); int local_search(); int lucky_phases(); int cdcl_loop_with_inprocessing(); void reset_solving(); int solve(bool preprocess_only = false); // int lookahead(); CubesWithStatus generate_cubes(int, int); int most_occurring_literal(); int lookahead_probing(); int lookahead_next_probe(); void lookahead_flush_probes(); void lookahead_generate_probes(); std::vector<int> lookahead_populate_locc(); int lookahead_locc(const std::vector<int> &); bool terminating_asked(); #ifndef QUIET // Built in profiling in 'profile.cpp' (see also 'profile.hpp'). // void start_profiling (Profile & p, double); void stop_profiling (Profile & p, double); double update_profiles (); // Returns 'time ()'. void print_profile (); #endif // Get the value of an internal literal: -1=false, 0=unassigned, 1=true. // We use a redundant table for both negative and positive literals. This // allows a branch-less check for the value of literal and is considered // substantially faster than negating the result if the argument is // negative. We also avoid taking the absolute value. // signed char val (int lit) const { assert (-max_var <= lit); assert (lit); assert (lit <= max_var); return vals[lit]; } // As 'val' but restricted to the root-level value of a literal. // It is not that time critical and also needs to check the decision level // of the variable anyhow. // int fixed (int lit) { assert (-max_var <= lit); assert (lit); assert (lit <= max_var); const int idx = vidx (lit); int res = vals[idx]; if (res && vtab[idx].level) res = 0; if (lit < 0) res = -res; return res; } // Map back an internal literal to an external. // int externalize (int lit) { assert (lit != INT_MIN); const int idx = abs (lit); assert (idx); assert (idx <= max_var); int res = i2e[idx]; if (lit < 0) res = -res; return res; } // Explicit freezing and melting of variables. // void freeze (int lit) { int idx = vidx (lit); unsigned & ref = frozentab[idx]; if (ref < UINT_MAX) { ref++; LOG ("variable %d frozen %u times", idx, ref); } else LOG ("variable %d remains frozen forever", idx); } void melt (int lit) { int idx = vidx (lit); unsigned & ref = frozentab[idx]; if (ref < UINT_MAX) { if (!--ref) { LOG ("variable %d completely molten", idx); } else LOG ("variable %d melted once but remains frozen %u times", lit, ref); } else LOG ("variable %d remains frozen forever", idx); } bool frozen (int lit) { return frozentab[vidx (lit)] > 0; } // Parsing functions in 'parse.cpp'. // const char * parse_dimacs (FILE *); const char * parse_dimacs (const char *); const char * parse_solution (const char *); // Enable and disable proof logging and checking. // void new_proof_on_demand (); void close_trace (); // Stop proof tracing. void flush_trace (); // Flush proof trace file. void trace (File *); // Start write proof file. void check (); // Enable online proof checking. // Dump to '<stdout>' as DIMACS for debugging. // void dump (Clause *); void dump (); // Export and traverse all irredundant (non-unit) clauses. // bool traverse_clauses (ClauseIterator &); /*----------------------------------------------------------------------*/ double solve_time (); // accumulated time spent in 'solve ()' double process_time (); // since solver was initialized double real_time (); // since solver was initialized double time () { return opts.realtime ? real_time () : process_time (); } // Regularly reports what is going on in 'report.cpp'. // void report (char type, int verbose_level = 0); void report_solving(int); void print_statistics (); void print_resource_usage (); /*----------------------------------------------------------------------*/ #ifndef QUIET void print_prefix (); // Non-verbose messages and warnings, i.e., always printed unless 'quiet' // is set, which disables messages at run-time, or even 'QUIET' is defined // through the configuration option './configure --quiet', which disables // such messages completely at compile-time. // void vmessage (const char *, va_list &); void message (const char *, ...) CADICAL_ATTRIBUTE_FORMAT (2, 3); void message (); // empty line // Verbose messages with explicit verbose 'level' controlled by // 'opts.verbose' (verbose level '0' gives the same as 'message'). // void vverbose (int level, const char * fmt, va_list &); void verbose (int level, const char * fmt, ...) CADICAL_ATTRIBUTE_FORMAT (3, 4); void verbose (int level); // This is for printing section headers in the form // // c ---- [ <title> ] --------------------- // // nicely aligned (and of course is ignored if 'quiet' is set). // void section (const char * title); // Print verbose message about phases if 'opts.verbose > 1' (but not if // 'quiet' is set). Note that setting 'log' or '-l' forces all verbose // output (and also ignores 'quiet' set to true'). The 'phase' argument // is used to print a 'phase' prefix for the message as follows: // // c [<phase>] ... // void phase (const char * phase, const char *, ...) CADICAL_ATTRIBUTE_FORMAT (3, 4); // Same as the last 'phase' above except that the prefix gets a count: // // c [<phase>-<count>] ... // void phase (const char * phase, int64_t count, const char *, ...) CADICAL_ATTRIBUTE_FORMAT (4, 5); #endif // Print error messages which are really always printed (even if 'quiet' // is set). This leads to exit the current process with exit status '1'. // // TODO add possibility to use a call back instead of calling exit. // void error_message_end (); void verror (const char *, va_list &); void error (const char *, ...) CADICAL_ATTRIBUTE_FORMAT (2, 3); void error_message_start (); // Warning messages. // void warning (const char *, ...) CADICAL_ATTRIBUTE_FORMAT (2, 3); };
	Queue 见文件queue.hpp
	struct Queue { // We use integers instead of variable pointers. This is more compact and // also avoids issues due to moving the variable table during 'resize'. int first, last; // anchors (head/tail) for doubly linked list int unassigned; // all variables after this one are assigned int64_t bumped; // see 'Internal.update_queue_unassigned' Queue () : first (0), last (0), unassigned (0), bumped (0) { } // We explicitly provide the mapping of integer indices to links to the // following two (inlined) functions. This avoids including // 'internal.hpp' and breaks a cyclic dependency, so we can keep their // code here in this header file. Otherwise they are just ordinary doubly // linked list 'dequeue' and 'enqueue' operations. inline void dequeue (Links & links, int idx) { Link & l = links[idx]; if (l.prev) links[l.prev].next = l.next; else first = l.next; if (l.next) links[l.next].prev = l.prev; else last = l.prev; } inline void enqueue (Links & links, int idx) { Link & l = links[idx]; if ((l.prev = last)) links[last].next = idx; else first = idx; last = idx; l.next = 0; } };  在queue.cpp文件中，还声明了Link类型 \cadical-rel-1.5.3\src\queue.hpp [6] // Links for double linked decision queue. [15] typedef vector<Link> Links; [37] inline void dequeue (Links & links, int idx) { [43] inline void enqueue (Links & links, int idx) { // Links for double linked decision queue. struct Link { int prev, next; // variable indices // initialized explicitly in 'init_queue' }; typedef vector<Link> Links; // Variable move to front (VMTF) decision queue ordered by 'bumped'. See // our SAT'15 paper for an explanation on how this works.