mirror of
https://github.com/Z3Prover/z3
synced 2025-04-15 21:38:44 +00:00
201 lines
17 KiB
Plaintext
201 lines
17 KiB
Plaintext
def_module_params('fixedpoint',
|
|
description='fixedpoint parameters',
|
|
export=True,
|
|
params=(('timeout', UINT, UINT_MAX, 'set timeout'),
|
|
('engine', SYMBOL, 'auto-config',
|
|
'Select: auto-config, datalog, spacer, pdr, bmc'),
|
|
('datalog.default_table', SYMBOL, 'sparse',
|
|
'default table implementation: sparse, hashtable, bitvector, interval'),
|
|
('datalog.default_relation', SYMBOL, 'pentagon',
|
|
'default relation implementation: external_relation, pentagon'),
|
|
('datalog.generate_explanations', BOOL, False,
|
|
'produce explanations for produced facts when using the datalog engine'),
|
|
('datalog.use_map_names', BOOL, True,
|
|
"use names from map files when displaying tuples"),
|
|
('datalog.magic_sets_for_queries', BOOL, False,
|
|
"magic set transformation will be used for queries"),
|
|
('datalog.explanations_on_relation_level', BOOL, False,
|
|
'if true, explanations are generated as history of each relation, ' +
|
|
'rather than per fact (generate_explanations must be set to true for ' +
|
|
'this option to have any effect)'),
|
|
('datalog.unbound_compressor', BOOL, True,
|
|
"auxiliary relations will be introduced to avoid unbound variables " +
|
|
"in rule heads"),
|
|
('datalog.similarity_compressor', BOOL, True,
|
|
"rules that differ only in values of constants will be merged into " +
|
|
"a single rule"),
|
|
('datalog.similarity_compressor_threshold', UINT, 11,
|
|
"if similarity_compressor is on, this value determines how many " +
|
|
"similar rules there must be in order for them to be merged"),
|
|
('datalog.all_or_nothing_deltas', BOOL, False,
|
|
"compile rules so that it is enough for the delta relation in " +
|
|
"union and widening operations to determine only whether the " +
|
|
"updated relation was modified or not"),
|
|
('datalog.compile_with_widening', BOOL, False,
|
|
"widening will be used to compile recursive rules"),
|
|
('datalog.default_table_checked', BOOL, False, "if true, the default " +
|
|
'table will be default_table inside a wrapper that checks that its results ' +
|
|
'are the same as of default_table_checker table'),
|
|
('datalog.default_table_checker', SYMBOL, 'null', "see default_table_checked"),
|
|
('datalog.check_relation',SYMBOL,'null', "name of default relation to check. " +
|
|
"operations on the default relation will be verified using SMT solving"),
|
|
('datalog.initial_restart_timeout', UINT, 0,
|
|
"length of saturation run before the first restart (in ms), " +
|
|
"zero means no restarts"),
|
|
('datalog.output_profile', BOOL, False,
|
|
"determines whether profile information should be " +
|
|
"output when outputting Datalog rules or instructions"),
|
|
('datalog.print.tuples', BOOL, True,
|
|
"determines whether tuples for output predicates should be output"),
|
|
('datalog.profile_timeout_milliseconds', UINT, 0,
|
|
"instructions and rules that took less than the threshold " +
|
|
"will not be printed when printed the instruction/rule list"),
|
|
('datalog.dbg_fpr_nonempty_relation_signature', BOOL, False,
|
|
"if true, finite_product_relation will attempt to avoid creating " +
|
|
"inner relation with empty signature by putting in half of the " +
|
|
"table columns, if it would have been empty otherwise"),
|
|
('datalog.subsumption', BOOL, True,
|
|
"if true, removes/filters predicates with total transitions"),
|
|
('pdr.bfs_model_search', BOOL, True,
|
|
"use BFS strategy for expanding model search"),
|
|
('pdr.farkas', BOOL, True,
|
|
"use lemma generator based on Farkas (for linear real arithmetic)"),
|
|
('generate_proof_trace', BOOL, False, "trace for 'sat' answer as proof object"),
|
|
('pdr.flexible_trace', BOOL, False,
|
|
"allow PDR generate long counter-examples " +
|
|
"by extending candidate trace within search area"),
|
|
('pdr.flexible_trace_depth', UINT, UINT_MAX,
|
|
'Controls the depth (below the current level) at which flexible trace can be applied'),
|
|
('pdr.use_model_generalizer', BOOL, False,
|
|
"use model for backwards propagation (instead of symbolic simulation)"),
|
|
('pdr.validate_result', BOOL, False,
|
|
"validate result (by proof checking or model checking)"),
|
|
('pdr.simplify_formulas_pre', BOOL, False,
|
|
"simplify derived formulas before inductive propagation"),
|
|
('pdr.simplify_formulas_post', BOOL, False,
|
|
"simplify derived formulas after inductive propagation"),
|
|
('pdr.use_multicore_generalizer', BOOL, False,
|
|
"extract multiple cores for blocking states"),
|
|
('pdr.use_inductive_generalizer', BOOL, True,
|
|
"generalize lemmas using induction strengthening"),
|
|
('pdr.use_arith_inductive_generalizer', BOOL, False,
|
|
"generalize lemmas using arithmetic heuristics for induction strengthening"),
|
|
('pdr.use_convex_closure_generalizer', BOOL, False,
|
|
"generalize using convex closures of lemmas"),
|
|
('pdr.use_convex_interior_generalizer', BOOL, False,
|
|
"generalize using convex interiors of lemmas"),
|
|
('pdr.cache_mode', UINT, 0, "use no (0), symbolic (1) or explicit " +
|
|
"cache (2) for model search"),
|
|
('pdr.inductive_reachability_check', BOOL, False,
|
|
"assume negation of the cube on the previous level when " +
|
|
"checking for reachability (not only during cube weakening)"),
|
|
('pdr.max_num_contexts', UINT, 500, "maximal number of contexts to create"),
|
|
('pdr.try_minimize_core', BOOL, False,
|
|
"try to reduce core size (before inductive minimization)"),
|
|
('pdr.utvpi', BOOL, True, 'Enable UTVPI strategy'),
|
|
('print_fixedpoint_extensions', BOOL, True,
|
|
"use SMT-LIB2 fixedpoint extensions, instead of pure SMT2, " +
|
|
"when printing rules"),
|
|
('print_low_level_smt2', BOOL, False,
|
|
"use (faster) low-level SMT2 printer (the printer is scalable " +
|
|
"but the result may not be as readable)"),
|
|
('print_with_variable_declarations', BOOL, True,
|
|
"use variable declarations when displaying rules " +
|
|
"(instead of attempting to use original names)"),
|
|
('print_answer', BOOL, False, 'print answer instance(s) to query'),
|
|
('print_certificate', BOOL, False,
|
|
'print certificate for reachability or non-reachability'),
|
|
('print_boogie_certificate', BOOL, False,
|
|
'print certificate for reachability or non-reachability using a ' +
|
|
'format understood by Boogie'),
|
|
('print_statistics', BOOL, False, 'print statistics'),
|
|
('print_aig', SYMBOL, '',
|
|
'Dump clauses in AIG text format (AAG) to the given file name'),
|
|
('tab.selection', SYMBOL, 'weight',
|
|
'selection method for tabular strategy: weight (default), first, var-use'),
|
|
('xform.bit_blast', BOOL, False,
|
|
'bit-blast bit-vectors'),
|
|
('xform.magic', BOOL, False,
|
|
"perform symbolic magic set transformation"),
|
|
('xform.scale', BOOL, False,
|
|
"add scaling variable to linear real arithmetic clauses"),
|
|
('xform.inline_linear', BOOL, True, "try linear inlining method"),
|
|
('xform.inline_eager', BOOL, True, "try eager inlining of rules"),
|
|
('xform.inline_linear_branch', BOOL, False,
|
|
"try linear inlining method with potential expansion"),
|
|
('xform.compress_unbound', BOOL, True, "compress tails with unbound variables"),
|
|
('xform.fix_unbound_vars', BOOL, False, "fix unbound variables in tail"),
|
|
('xform.unfold_rules', UINT, 0,
|
|
"unfold rules statically using iterative squarring"),
|
|
('xform.slice', BOOL, True, "simplify clause set using slicing"),
|
|
('xform.karr', BOOL, False,
|
|
"Add linear invariants to clauses using Karr's method"),
|
|
('spacer.use_eqclass', BOOL, False, "Generalizes equalities to equivalence classes"),
|
|
('xform.transform_arrays', BOOL, False,
|
|
"Rewrites arrays equalities and applies select over store"),
|
|
('xform.instantiate_arrays', BOOL, False,
|
|
"Transforms P(a) into P(i, a[i] a)"),
|
|
('xform.instantiate_arrays.enforce', BOOL, False,
|
|
"Transforms P(a) into P(i, a[i]), discards a from predicate"),
|
|
('xform.instantiate_arrays.nb_quantifier', UINT, 1,
|
|
"Gives the number of quantifiers per array"),
|
|
('xform.instantiate_arrays.slice_technique', SYMBOL, "no-slicing",
|
|
"<no-slicing>=> GetId(i) = i, <smash> => GetId(i) = true"),
|
|
('xform.quantify_arrays', BOOL, False,
|
|
"create quantified Horn clauses from clauses with arrays"),
|
|
('xform.instantiate_quantifiers', BOOL, False,
|
|
"instantiate quantified Horn clauses using E-matching heuristic"),
|
|
('xform.coalesce_rules', BOOL, False, "coalesce rules"),
|
|
('xform.tail_simplifier_pve', BOOL, True, "propagate_variable_equivalences"),
|
|
('xform.subsumption_checker', BOOL, True, "Enable subsumption checker (no support for model conversion)"),
|
|
('xform.coi', BOOL, True, "use cone of influence simplification"),
|
|
('spacer.order_children', UINT, 0, 'SPACER: order of enqueuing children in non-linear rules : 0 (original), 1 (reverse)'),
|
|
('spacer.eager_reach_check', BOOL, True, 'SPACER: eagerly check if a query is reachable using reachability facts of predecessors'),
|
|
('spacer.use_lemma_as_cti', BOOL, False, 'SPACER: use a lemma instead of a CTI in flexible_trace'),
|
|
('spacer.reset_obligation_queue', BOOL, True, 'SPACER: reset obligation queue when entering a new level'),
|
|
('spacer.init_reach_facts', BOOL, True, 'SPACER: initialize reachability facts with false'),
|
|
('spacer.use_array_eq_generalizer', BOOL, True, 'SPACER: attempt to generalize lemmas with array equalities'),
|
|
('spacer.use_derivations', BOOL, True, 'SPACER: using derivation mechanism to cache intermediate results for non-linear rules'),
|
|
('xform.array_blast', BOOL, False, "try to eliminate local array terms using Ackermannization -- some array terms may remain"),
|
|
('xform.array_blast_full', BOOL, False, "eliminate all local array variables by QE"),
|
|
('spacer.skip_propagate', BOOL, False, "Skip propagate/pushing phase. Turns PDR into a BMC that returns either reachable or unknown"),
|
|
('spacer.max_level', UINT, UINT_MAX, "Maximum level to explore"),
|
|
('spacer.elim_aux', BOOL, True, "Eliminate auxiliary variables in reachability facts"),
|
|
('spacer.reach_as_init', BOOL, True, "Extend initial rules with computed reachability facts"),
|
|
('spacer.blast_term_ite', BOOL, True, "Expand non-Boolean ite-terms"),
|
|
('spacer.nondet_tie_break', BOOL, False, "Break ties in obligation queue non-deterministically"),
|
|
('spacer.reach_dnf', BOOL, True, "Restrict reachability facts to DNF"),
|
|
('bmc.linear_unrolling_depth', UINT, UINT_MAX, "Maximal level to explore"),
|
|
('spacer.split_farkas_literals', BOOL, False, "Split Farkas literals"),
|
|
('spacer.native_mbp', BOOL, False, "Use native mbp of Z3"),
|
|
('spacer.eq_prop', BOOL, True, "Enable equality and bound propagation in arithmetic"),
|
|
('spacer.weak_abs', BOOL, True, "Weak abstraction"),
|
|
('spacer.restarts', BOOL, False, "Enable reseting obligation queue"),
|
|
('spacer.restart_initial_threshold', UINT, 10, "Intial threshold for restarts"),
|
|
('spacer.random_seed', UINT, 0, "Random seed to be used by SMT solver"),
|
|
('spacer.ground_cti', BOOL, True, "Require CTI to be ground"),
|
|
('spacer.vs.dump_benchmarks', BOOL, False, 'dump benchmarks in virtual solver'),
|
|
('spacer.vs.dump_min_time', DOUBLE, 5.0, 'min time to dump benchmark'),
|
|
('spacer.vs.recheck', BOOL, False, 're-check locally during benchmark dumping'),
|
|
('spacer.mbqi', BOOL, True, 'use model-based quantifier instantiation'),
|
|
('spacer.keep_proxy', BOOL, True, 'keep proxy variables (internal parameter)'),
|
|
('spacer.instantiate', BOOL, True, 'instantiate quantified lemmas'),
|
|
('spacer.qlemmas', BOOL, True, 'allow quantified lemmas in frames'),
|
|
('spacer.iuc', UINT, 1, '0 = use old implementation of unsat-core-generation, 1 = use new implementation of IUC generation, 2 = use new implementation of IUC + min-cut optimization'),
|
|
('spacer.iuc.arith', UINT, 2, '0 = use simple Farkas plugin, 1 = use simple Farkas plugin with constant from other partition (like old unsat-core-generation), 2 = use Gaussian elimination optimization, 3 = use additive IUC plugin'),
|
|
('spacer.lemma_sanity_check', BOOL, False, 'check during generalization whether lemma is actually correct'),
|
|
('spacer.reuse_pobs', BOOL, True, 'reuse POBs'),
|
|
('spacer.print_farkas_stats', BOOL, False, 'prints for each proof how many Farkas lemmas it contains and how many of these participate in the cut'),
|
|
('spacer.iuc.debug_proof', BOOL, False, 'prints proof used by unsat-core-learner for debugging purposes'),
|
|
('spacer.simplify_pob', BOOL, False, 'simplify POBs by removing redundant constraints'),
|
|
('spacer.use_quant_generalizer', BOOL, False, 'use quantified lemma generalizer'),
|
|
('spacer.quic_gen_normalize', BOOL, True, 'normalize cube before quantified generalization'),
|
|
('spacer.share_lemmas', BOOL, False, "Share frame lemmas"),
|
|
('spacer.share_invariants', BOOL, False, "Share invariants lemmas"),
|
|
('spacer.from_level', UINT, 0, 'starting level to explore'),
|
|
('spacer.print_json', SYMBOL, '', 'print pobs tree in JSON format to a given file')
|
|
))
|
|
|
|
|
|
|