def_module_params('sat', 
                  export=True,
                  description='propositional SAT solver',
                  params=(max_memory_param(),
                          ('phase', SYMBOL, 'caching', 'phase selection strategy: always_false, always_true, caching, random'),
                          ('phase.caching.on', UINT, 400, 'phase caching on period (in number of conflicts)'),
                          ('phase.caching.off', UINT, 100, 'phase caching off period (in number of conflicts)'),
                          ('phase.sticky', BOOL, False, 'use sticky phase caching for local search'),
                          ('propagate.prefetch', BOOL, True, 'prefetch watch lists for assigned literals'),
                          ('restart', SYMBOL, 'luby', 'restart strategy: luby or geometric'),
                          ('restart.initial', UINT, 100, 'initial restart (number of conflicts)'),
                          ('restart.max', UINT, UINT_MAX, 'maximal number of restarts.'),
                          ('restart.fast', BOOL, False, 'use fast restart strategy.'),
                          ('restart.factor', DOUBLE, 1.5, 'restart increment factor for geometric strategy'),
                          ('variable_decay', UINT, 110, 'multiplier (divided by 100) for the VSIDS activity increement'), 
                          ('inprocess.max', UINT, UINT_MAX, 'maximal number of inprocessing passes'),
                          ('branching.heuristic', SYMBOL, 'vsids', 'branching heuristic vsids, lrb or chb'),
                          ('branching.anti_exploration', BOOL, False, 'apply anti-exploration heuristic for branch selection'),
                          ('random_freq', DOUBLE, 0.01, 'frequency of random case splits'),
                          ('random_seed', UINT, 0, 'random seed'),
                          ('burst_search', UINT, 100, 'number of conflicts before first global simplification'),
                          ('max_conflicts', UINT, UINT_MAX, 'maximum number of conflicts'),
                          ('gc', SYMBOL, 'glue_psm', 'garbage collection strategy: psm, glue, glue_psm, dyn_psm'),
                          ('gc.initial', UINT, 20000, 'learned clauses garbage collection frequency'),
                          ('gc.increment', UINT, 500, 'increment to the garbage collection threshold'),
                          ('gc.small_lbd', UINT, 3, 'learned clauses with small LBD are never deleted (only used in dyn_psm)'),
                          ('gc.k', UINT, 7, 'learned clauses that are inactive for k gc rounds are permanently deleted (only used in dyn_psm)'),
                          ('gc.burst', BOOL, True, 'perform eager garbage collection during initialization'),
                          ('gc.defrag', BOOL, True, 'defragment clauses when garbage collecting'),
                          ('simplify.delay', UINT, 0, 'set initial delay of simplification by a conflict count'),
                          ('minimize_lemmas', BOOL, True, 'minimize learned clauses'),
                          ('dyn_sub_res', BOOL, True, 'dynamic subsumption resolution for minimizing learned clauses'),
                          ('core.minimize', BOOL, False, 'minimize computed core'),
                          ('core.minimize_partial', BOOL, False, 'apply partial (cheap) core minimization'),
                          ('threads', UINT, 1, 'number of parallel threads to use'),
                          ('dimacs.core', BOOL, False, 'extract core from DIMACS benchmarks'),
                          ('drat.file', SYMBOL, '', 'file to dump DRAT proofs'),
                          ('drat.check_unsat', BOOL, False, 'build up internal proof and check'),
                          ('drat.check_sat', BOOL, False, 'build up internal trace, check satisfying model'),
                          ('cardinality.solver', BOOL, True, 'use cardinality solver'),
                          ('pb.solver', SYMBOL, 'solver', 'method for handling Pseudo-Boolean constraints: circuit (arithmetical circuit), sorting (sorting circuit), totalizer (use totalizer encoding), solver (use native solver)'),
                          ('xor.solver', BOOL, False, 'use xor solver'),
                          ('atmost1_encoding', SYMBOL, 'grouped', 'encoding used for at-most-1 constraints grouped, bimander, ordered'),
                          ('local_search', BOOL, False, 'use local search instead of CDCL'),
                          ('local_search_threads', UINT, 0, 'number of local search threads to find satisfiable solution'),
                          ('local_search_mode', SYMBOL, 'wsat', 'local search algorithm, either default wsat or qsat'),
	                  ('unit_walk', BOOL, False, 'use unit-walk search instead of CDCL'),
                          ('unit_walk_threads', UINT, 0, 'number of unit-walk search threads to find satisfiable solution'),
                          ('lookahead.cube.cutoff', SYMBOL, 'depth', 'cutoff type used to create lookahead cubes: depth, freevars, psat, adaptive_freevars, adaptive_psat'),
                          ('lookahead.cube.fraction', DOUBLE, 0.4, 'adaptive fraction to create lookahead cubes. Used when lookahead.cube.cutoff is adaptive_freevars or adaptive_psat'),
                          ('lookahead.cube.depth', UINT, 1, 'cut-off depth to create cubes. Used when lookahead.cube.cutoff is depth.'),
                          ('lookahead.cube.freevars', DOUBLE, 0.8, 'cube free fariable fraction. Used when lookahead.cube.cutoff is freevars'),
                          ('lookahead.cube.psat.var_exp', DOUBLE, 1, 'free variable exponent for PSAT cutoff'),
                          ('lookahead.cube.psat.clause_base', DOUBLE, 2, 'clause base for PSAT cutoff'),
                          ('lookahead.cube.psat.trigger', DOUBLE, 5, 'trigger value to create lookahead cubes for PSAT cutoff. Used when lookahead.cube.cutoff is psat'),
                          ('lookahead_search', BOOL, False, 'use lookahead solver'),
                          ('lookahead.preselect', BOOL, False, 'use pre-selection of subset of variables for branching'),
                          ('lookahead_simplify', BOOL, False, 'use lookahead solver during simplification'),
                          ('lookahead.use_learned', BOOL, False, 'use learned clauses when selecting lookahead literal'),
                          ('lookahead_simplify.bca', BOOL, True, 'add learned binary clauses as part of lookahead simplification'),
                          ('lookahead.global_autarky', BOOL, False, 'prefer to branch on variables that occur in clauses that are reduced'),
                          ('lookahead.reward', SYMBOL, 'march_cu', 'select lookahead heuristic: ternary, heule_schur (Heule Schur), heuleu (Heule Unit), unit, or march_cu')))

