mirror of
https://github.com/Z3Prover/z3
synced 2025-08-19 01:32:17 +00:00
002d166f72
* Added function to select the next variable to split on * Fixed typo * Small fixes * uint -> int * Fixed missing assignment for binary clauses * Memory leak in .NET user-propagator The user-propagator object has to be manually disposed (IDisposable), otherwise it stays in memory forever, as it cannot be garbage collected automatically * Throw an exception if variable passed to decide is already assigned instead of running in an assertion violation * Update (not compiling yet) * #6429 * remove ternary clause optimization Removing ternary clause optimization from sat_solver simplifies special case handling of ternary clauses throughout the sat solver and dependent solvers (pb_solver). Benchmarking on QF_BV suggests the ternary clause optimization does not have any effect. While removing ternary clause optimization two bugs in unit propagation were also uncovered: it missed propagations when the only a single undef literal remained in the non-watched literals and it did not update blocked literals in cases where it could in the watch list. These performance bugs were for general clauses, ternary clause propagation did not miss propagations (and don't use blocked literals), but fixing these issues for general clauses appear to have made ternary clause optimization irrelevant based on what was measured. * Update: Missing data-structures (still not compiling) * Nearly compiling * Some missing arguments * Polishing * Only conflicts/propagations/justifications are missing for making it compile * Added propagation (justifications for them are still missing) * Use the right deallocation * Use Z3's memory allocation system * Ported "seen" * Polishing * Added 64-bit "1" counting * More polishing * minor fixes - ensure mk_extract performs simplification to distribute over extract and removing extract if the range is the entire bit-vector - ensure bool_rewriter simplifeis disjunctions when applicable. * adding simplifiers layer simplifiers layer is a common substrate for global non-incremental and incremental processing. The first two layers are new, but others are to be ported form tactics. - bv::slice - rewrites equations to cut-dice-slice bit-vector extractions until they align. It creates opportunities for rewriting portions of bit-vectors to common sub-expressions, including values. - euf::completion - generalizes the KB simplifcation from asserted formulas to use the E-graph to establish a global and order-independent canonization. The interface dependent_expr_simplifier is amenable to forming tactics. Plugins for asserted-formulas is also possible but not yet realized. * Create bv_slice_tactic.cpp missing file * adding virtual destructor Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * Added 64-bit "1" counting (#6434) * Memory leak in .NET user-propagator The user-propagator object has to be manually disposed (IDisposable), otherwise it stays in memory forever, as it cannot be garbage collected automatically * Throw an exception if variable passed to decide is already assigned instead of running in an assertion violation * Added 64-bit "1" counting * remove incorrect assertion Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * Added limit to "visit" to allow detecting multiple visits (#6435) * Memory leak in .NET user-propagator The user-propagator object has to be manually disposed (IDisposable), otherwise it stays in memory forever, as it cannot be garbage collected automatically * Throw an exception if variable passed to decide is already assigned instead of running in an assertion violation * Added limit to "visit" to allow detecting multiple visits * Putting visit in a separate class (Reason: We will probably need two of them in the sat::solver) * Bugfix * init solve_eqs * working on solve_eqs * Update .gitignore * wip - converting the equation solver as a simplifier * make visited_helper independent of literals re-introduce shorthands in sat::solver for visited and have them convert literals to unsigned. * build fix * move model and proof converters to self-contained module * Create solve_eqs2_tactic.h * add converters module to python build * move tactic_params to params * move more converters * move horn_subsume_model_converter to ast/converters * add initial stubs for model reconstruction trail * fixing build Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fixes #6439 #6436 * It's compiling (However, two important functions are commented out) Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> Co-authored-by: Nikolaj Bjorner <nbjorner@microsoft.com>
148 lines
15 KiB
Text
148 lines
15 KiB
Text
def_module_params('sat',
|
|
export=True,
|
|
description='propositional SAT solver',
|
|
params=(max_memory_param(),
|
|
('phase', SYMBOL, 'caching', 'phase selection strategy: always_false, always_true, basic_caching, random, caching'),
|
|
('phase.sticky', BOOL, True, 'use sticky phase caching'),
|
|
('search.unsat.conflicts', UINT, 400, 'period for solving for unsat (in number of conflicts)'),
|
|
('search.sat.conflicts', UINT, 400, 'period for solving for sat (in number of conflicts)'),
|
|
('rephase.base', UINT, 1000, 'number of conflicts per rephase '),
|
|
('reorder.base', UINT, UINT_MAX, 'number of conflicts per random reorder '),
|
|
('reorder.itau', DOUBLE, 4.0, 'inverse temperature for softmax'),
|
|
('reorder.activity_scale', UINT, 100, 'scaling factor for activity update'),
|
|
('propagate.prefetch', BOOL, True, 'prefetch watch lists for assigned literals'),
|
|
('restart', SYMBOL, 'ema', 'restart strategy: static, luby, ema or geometric'),
|
|
('restart.initial', UINT, 2, 'initial restart (number of conflicts)'),
|
|
('restart.max', UINT, UINT_MAX, 'maximal number of restarts.'),
|
|
('restart.fast', BOOL, True, 'use fast restart approach only removing less active literals.'),
|
|
('restart.factor', DOUBLE, 1.5, 'restart increment factor for geometric strategy'),
|
|
('restart.margin', DOUBLE, 1.1, 'margin between fast and slow restart factors. For ema'),
|
|
('restart.emafastglue', DOUBLE, 3e-2, 'ema alpha factor for fast moving average'),
|
|
('restart.emaslowglue', DOUBLE, 1e-5, 'ema alpha factor for slow moving average'),
|
|
('variable_decay', UINT, 110, 'multiplier (divided by 100) for the VSIDS activity increment'),
|
|
('inprocess.max', UINT, UINT_MAX, 'maximal number of inprocessing passes'),
|
|
('inprocess.out', SYMBOL, '', 'file to dump result of the first inprocessing step and exit'),
|
|
('branching.heuristic', SYMBOL, 'vsids', 'branching heuristic vsids, 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'),
|
|
('enable_pre_simplify', BOOL, False, 'enable pre simplifications before the bounded search'),
|
|
('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, False, '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'),
|
|
('force_cleanup', BOOL, False, 'force cleanup to remove tautologies and simplify clauses'),
|
|
('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'),
|
|
('backtrack.scopes', UINT, 100, 'number of scopes to enable chronological backtracking'),
|
|
('backtrack.conflicts', UINT, 4000, 'number of conflicts before enabling chronological backtracking'),
|
|
('threads', UINT, 1, 'number of parallel threads to use'),
|
|
('dimacs.core', BOOL, False, 'extract core from DIMACS benchmarks'),
|
|
('drat.disable', BOOL, False, 'override anything that enables DRAT'),
|
|
('smt.proof', SYMBOL, '', 'add SMT proof to file'),
|
|
('smt.proof.check', BOOL, False, 'check SMT proof while it is created'),
|
|
('smt.proof.check_rup', BOOL, True, 'apply forward RUP proof checking'),
|
|
('drat.file', SYMBOL, '', 'file to dump DRAT proofs'),
|
|
('drat.binary', BOOL, False, 'use Binary DRAT output format'),
|
|
('drat.check_unsat', BOOL, False, 'build up internal proof and check'),
|
|
('drat.check_sat', BOOL, False, 'build up internal trace, check satisfying model'),
|
|
('drat.activity', BOOL, False, 'dump variable activities'),
|
|
('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), binary_merge, segmented, solver (use native solver)'),
|
|
('pb.min_arity', UINT, 9, 'minimal arity to compile pb/cardinality constraints to CNF'),
|
|
('cardinality.encoding', SYMBOL, 'grouped', 'encoding used for at-most-k constraints: grouped, bimander, ordered, unate, circuit'),
|
|
('pb.resolve', SYMBOL, 'cardinality', 'resolution strategy for boolean algebra solver: cardinality, rounding'),
|
|
('pb.lemma_format', SYMBOL, 'cardinality', 'generate either cardinality or pb lemmas'),
|
|
('euf', BOOL, False, 'enable euf solver (this feature is preliminary and not ready for general consumption)'),
|
|
('ddfw_search', BOOL, False, 'use ddfw local search instead of CDCL'),
|
|
('ddfw.init_clause_weight', UINT, 8, 'initial clause weight for DDFW local search'),
|
|
('ddfw.use_reward_pct', UINT, 15, 'percentage to pick highest reward variable when it has reward 0'),
|
|
('ddfw.restart_base', UINT, 100000, 'number of flips used a starting point for hessitant restart backoff'),
|
|
('ddfw.reinit_base', UINT, 10000, 'increment basis for geometric backoff scheme of re-initialization of weights'),
|
|
('ddfw.threads', UINT, 0, 'number of ddfw threads to run in parallel with sat solver'),
|
|
('prob_search', BOOL, False, 'use probsat local search instead of CDCL'),
|
|
('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'),
|
|
('local_search_dbg_flips', BOOL, False, 'write debug information for number of flips'),
|
|
('binspr', BOOL, False, 'enable SPR inferences of binary propagation redundant clauses. This inprocessing step eliminates models'),
|
|
('anf', BOOL, False, 'enable ANF based simplification in-processing'),
|
|
('anf.delay', UINT, 2, 'delay ANF simplification by in-processing round'),
|
|
('anf.exlin', BOOL, False, 'enable extended linear simplification'),
|
|
('cut', BOOL, False, 'enable AIG based simplification in-processing'),
|
|
('cut.delay', UINT, 2, 'delay cut simplification by in-processing round'),
|
|
('cut.aig', BOOL, False, 'extract aigs (and ites) from cluases for cut simplification'),
|
|
('cut.lut', BOOL, False, 'extract luts from clauses for cut simplification'),
|
|
('cut.xor', BOOL, False, 'extract xors from clauses for cut simplification'),
|
|
('cut.npn3', BOOL, False, 'extract 3 input functions from clauses for cut simplification'),
|
|
('cut.dont_cares', BOOL, True, 'integrate dont cares with cuts'),
|
|
('cut.redundancies', BOOL, True, 'integrate redundancy checking of cuts'),
|
|
('cut.force', BOOL, False, 'force redoing cut-enumeration until a fixed-point'),
|
|
('lookahead.cube.cutoff', SYMBOL, 'depth', 'cutoff type used to create lookahead cubes: depth, freevars, psat, adaptive_freevars, adaptive_psat'),
|
|
# - depth: the maximal cutoff is fixed to the value of lookahead.cube.depth.
|
|
# So if the value is 10, at most 1024 cubes will be generated of length 10.
|
|
# - freevars: cutoff based on a variable fraction of lookahead.cube.freevars.
|
|
# Cut if the number of current unassigned variables drops below a fraction of number of initial variables.
|
|
# - psat: Let psat_heur := (Sum_{clause C} (psat.clause_base ^ {-|C|+1})) / |freevars|^psat.var_exp
|
|
# Cut if the value of psat_heur exceeds psat.trigger
|
|
# - adaptive_freevars: Cut if the number of current unassigned variables drops below a fraction of free variables
|
|
# at the time of the last conflict. The fraction is increased every time the cutoff is created.
|
|
# - adative_psat: Cut based on psat_heur in an adaptive way.
|
|
|
|
('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 variable 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.preselect', BOOL, False, 'use pre-selection of subset of variables for branching'),
|
|
('lookahead_simplify', BOOL, False, 'use lookahead solver during simplification'),
|
|
('lookahead_scores', BOOL, False, 'extract lookahead scores. A utility that can only be used from the DIMACS front-end'),
|
|
('lookahead.double', BOOL, True, 'enable doubld lookahead'),
|
|
('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.delta_fraction', DOUBLE, 1.0, 'number between 0 and 1, the smaller the more literals are selected for double lookahead'),
|
|
('lookahead.reward', SYMBOL, 'march_cu', 'select lookahead heuristic: ternary, heule_schur (Heule Schur), heuleu (Heule Unit), unit, or march_cu'),
|
|
# reward function used to determine which literal to cube on.
|
|
# - ternary: reward function useful for random 3-SAT instances. Used by Heule and Knuth in March.
|
|
# - heule_schur: reward function based on "Schur Number 5", Heule, AAAI 2018
|
|
# The score of a literal lit is:
|
|
# Sum_{C in Clauses | lit in C} 2 ^ (- |C|+1)
|
|
# * Sum_{lit' in C | lit' != lit} lit_occs(~lit')
|
|
# / | C |
|
|
# where lit_occs(lit) is the number of clauses containing lit.
|
|
# - heuleu: The score of a literal lit is: Sum_{C in Clauses | lit in C} 2 ^ (-|C| + 1)
|
|
# - unit: heule_schur + also counts number of unit clauses.
|
|
# - march_cu: default reward function used in a version of March
|
|
# Each reward function also comes with its own variant of "mix_diff", which
|
|
# is the function for combining reward metrics for the positive and negative variant of a literal.
|
|
# Xor parameters
|
|
('xor.enable', BOOL, False, 'enable xor solver plugin in combination with pure SAT solving'),
|
|
|
|
# Pull in other xor parameters as they are determined to be relevant
|
|
# ('xor.max_to_find', UINT, 'tbd'),
|
|
# ('xor.max_to_find_slow', UINT, 'tbd'),
|
|
# ('xor.max_xor_matrix, UINT64, 'tbd'),
|
|
# ('xor.allow_elim_vars', BOOL, 'tbd'),
|
|
# ('xor.var_per_cut', UINT, 'tbd'),
|
|
# ('xor.force_preserve_xors', BOOL, 'tbd'),
|
|
('xor.gauss.max_matrix_columns', UINT, 1000, 'tbd'),
|
|
('xor.gauss.max_matrix_rows', UINT, 2000, 'The maximum matrix size -- no. of rows'),
|
|
('xor.gauss.min_matrix_rows', UINT, 3, 'The minimum matrix size -- no. of rows'),
|
|
('xor.gauss.max_num_matrices', UINT, 5, 'Maximum number of matrices'),
|
|
('xor.gauss.force_use_all_matrices', BOOL, True, 'tbd'),
|
|
# ('xor.gauss.autodisable', BOOL, False, 'tbd'),
|
|
('xor.gauss.min_usefulness_cutoff', DOUBLE, 0.2, 'tbd'),
|
|
# ('xor.gauss.do_matrix_find', BOOL, True, 'tbd'),
|
|
# ('xor.gauss.min_xor_clauses', UINT, 2, 'tbd'),
|
|
# ('xor.gauss.max_xor_clauses, UINT, 500000, 'tbd')
|
|
))
|