def_module_params('fp',
                  description='fixedpoint parameters',
                  export=True,
                  params=(('engine', SYMBOL, 'auto-config',
                           'Select: auto-config, datalog, bmc, spacer'),
                          ('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.timeout', UINT, 0, "Time limit used for saturation"),
                          ('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"),
                          ('generate_proof_trace', BOOL, False, "trace for 'sat' answer as proof object"),
                          ('spacer.push_pob', BOOL, False, "push blocked pobs to higher level"),
                          ('spacer.push_pob_max_depth', UINT, UINT_MAX,
                           'Maximum depth at which push_pob is enabled'),
                          ('validate', BOOL, False,
                           "validate result (by proof checking or model checking)"),
                          ('spacer.simplify_lemmas_pre', BOOL, False,
                           "simplify derived lemmas before inductive propagation"),
                          ('spacer.simplify_lemmas_post', BOOL, False,
                           "simplify derived lemmas after inductive propagation"),
                          ('spacer.use_inductive_generalizer', BOOL, True,
                           "generalize lemmas using induction strengthening"),
                          ('spacer.max_num_contexts', UINT, 500, "maximal number of contexts to create"),
                          ('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_aig', SYMBOL, '',
                           'Dump clauses in AIG text format (AAG) to the given file name'),
                          ('print_statistics',  BOOL, False, 'print statistics'),
                          ('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 squaring"),
                          ('xform.slice', BOOL, True, "simplify clause set using slicing"),
                          ('spacer.use_euf_gen', BOOL, False, 'Generalize lemmas and pobs using implied equalities'),
                          ('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), 2 (random)'),
                          ('spacer.use_lemma_as_cti', BOOL, False, 'SPACER: use a lemma instead of a CTI in flexible_trace'),
                          ('spacer.reset_pob_queue', BOOL, True, 'SPACER: reset pob obligation queue when entering a new level'),
                          ('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"),
                          ('xform.elim_term_ite', BOOL, False, 'Eliminate term-ite expressions'),
                          ('xform.elim_term_ite.inflation', UINT, 3, 'Maximum inflation for non-Boolean ite-terms blasting: 0 (none), k (multiplicative)'),
                          ('spacer.propagate', BOOL, True, 'Enable propagate/pushing phase'),
                          ('spacer.max_level', UINT, UINT_MAX, "Maximum level to explore"),
                          ('spacer.elim_aux', BOOL, True, "Eliminate auxiliary variables in reachability facts"),
                          ('spacer.blast_term_ite_inflation', UINT, 3, 'Maximum inflation for non-Boolean ite-terms expansion: 0 (none), k (multiplicative)'),
                          ('spacer.reach_dnf', BOOL, True, "Restrict reachability facts to DNF"),
                          ('bmc.linear_unrolling_depth', UINT, UINT_MAX, "Maximal level to explore"),
                          ('spacer.iuc.split_farkas_literals', BOOL, False, "Split Farkas literals"),
                          ('spacer.native_mbp', BOOL, True, "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 resetting obligation queue"),
                          ('spacer.restart_initial_threshold', UINT, 10, "Initial threshold for restarts"),
                          ('spacer.random_seed', UINT, 0, "Random seed to be used by SMT solver"),

                          ('spacer.mbqi', BOOL, True, 'Enable mbqi'),
                          ('spacer.keep_proxy', BOOL, True, 'keep proxy variables (internal parameter)'),
                          ('spacer.q3', BOOL, True, 'Allow quantified lemmas in frames'),
                          ('spacer.q3.instantiate', BOOL, True, 'Instantiate quantified lemmas'),
                          ('spacer.q3.use_qgen', BOOL, False, 'use quantified lemma generalizer'),
                          ('spacer.q3.qgen.normalize', BOOL, True, 'normalize cube before quantified generalization'),
                          ('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, 1,
                           '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 (broken), 3 = use additive IUC plugin'),
                          ('spacer.iuc.old_hyp_reducer', BOOL, False, 'use old hyp reducer instead of new implementation, for debugging only'),
                          ('spacer.validate_lemmas', BOOL, False, 'Validate each lemma after generalization'),
                          ('spacer.ground_pobs', BOOL, True, 'Ground pobs by using values from a model'),
                          ('spacer.iuc.print_farkas_stats', BOOL, False, 'prints for each proof how many Farkas lemmas it contains and how many of these participate in the cut (for debugging)'),
                          ('spacer.iuc.debug_proof', BOOL, False, 'prints proof used by unsat-core-learner for debugging purposes (debugging)'),
                          ('spacer.simplify_pob', BOOL, False, 'simplify pobs by removing redundant constraints'),
                          ('spacer.p3.share_lemmas', BOOL, False, 'Share frame lemmas'),
                          ('spacer.p3.share_invariants', BOOL, False, "Share invariants lemmas"),
                          ('spacer.min_level', UINT, 0, 'Minimal level to explore'),
                          ('spacer.print_json', SYMBOL, '', 'Print pobs tree in JSON format to a given file'),
                          ('spacer.trace_file', SYMBOL, '', 'Log file for progress events'),
                          ('spacer.ctp', BOOL, True, 'Enable counterexample-to-pushing'),
                          ('spacer.use_inc_clause', BOOL, True, 'Use incremental clause to represent trans'),
                          ('spacer.dump_benchmarks', BOOL, False, 'Dump SMT queries as benchmarks'),
                          ('spacer.dump_threshold', DOUBLE, 5.0, 'Threshold in seconds on dumping benchmarks'),
                          ('spacer.gpdr', BOOL, False, 'Use GPDR solving strategy for non-linear CHC'),
                          ('spacer.gpdr.bfs', BOOL, True, 'Use BFS exploration strategy for expanding model search'),
                          ('spacer.use_bg_invs', BOOL, False, 'Enable external background invariants'),
                          ('spacer.use_lim_num_gen', BOOL, False, 'Enable limit numbers generalizer to get smaller numbers'),
                          ('spacer.logic', SYMBOL, '', 'SMT-LIB logic to configure internal SMT solvers'),
                          ('spacer.arith.solver', UINT, 2, 'arithmetic solver: 0 - no solver, 1 - bellman-ford based solver (diff. logic only), 2 - simplex based solver, 3 - floyd-warshall based solver (diff. logic only) and no theory combination 4 - utvpi, 5 - infinitary lra, 6 - lra solver'),
                          ))
