mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-24 09:35:32 +00:00
Code Activity

saved params work

Browse source 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
This commit is contained in:
Leonardo de Moura 2012-11-29 17:19:12 -08:00
parent c3055207ed
commit cf28cbab0a
130 changed files with 1469 additions and 948 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/tactic/aig/aig_tactic.cpp
View file

@ -62,14 +62,14 @@ public:
}
virtual void updt_params(params_ref const & p) {
m_max_memory = megabytes_to_bytes(p.get_uint(":max-memory", UINT_MAX));
m_aig_gate_encoding = p.get_bool(":aig-default-gate-encoding", true);
m_aig_per_assertion = p.get_bool(":aig-per-assertion", true);
m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX));
m_aig_gate_encoding = p.get_bool("aig_default_gate_encoding", true);
m_aig_per_assertion = p.get_bool("aig_per_assertion", true);
}
virtual void collect_param_descrs(param_descrs & r) {
insert_max_memory(r);
r.insert(":aig-per-assertion", CPK_BOOL, "(default: true) process one assertion at a time.");
r.insert("aig_per_assertion", CPK_BOOL, "(default: true) process one assertion at a time.");
}
void operator()(goal_ref const & g) {

8
src/tactic/arith/add_bounds_tactic.cpp
View file

@ -70,8 +70,8 @@ class add_bounds_tactic : public tactic {
}
void updt_params(params_ref const & p) {
m_lower = p.get_rat(":add-bound-lower", rational(-2));
m_upper = p.get_rat(":add-bound-upper", rational(2));
m_lower = p.get_rat("add_bound_lower", rational(-2));
m_upper = p.get_rat("add_bound_upper", rational(2));
}
void set_cancel(bool f) {
@ -159,8 +159,8 @@ public:
}
virtual void collect_param_descrs(param_descrs & r) {
r.insert(":add-bound-lower", CPK_NUMERAL, "(default: -2) lower bound to be added to unbounded variables.");
r.insert(":add-bound-upper", CPK_NUMERAL, "(default: 2) upper bound to be added to unbounded variables.");
r.insert("add_bound_lower", CPK_NUMERAL, "(default: -2) lower bound to be added to unbounded variables.");
r.insert("add_bound_upper", CPK_NUMERAL, "(default: 2) upper bound to be added to unbounded variables.");
}
virtual void operator()(goal_ref const & g,

12
src/tactic/arith/bound_propagator.cpp
View file

@ -116,15 +116,15 @@ void bound_propagator::del_constraint(constraint & c) {
}
void bound_propagator::updt_params(params_ref const & p) {
m_max_refinements = p.get_uint(":bound-max-refinements", 16);
m_threshold = p.get_double(":bound-threshold", 0.05);
m_small_interval = p.get_double(":bound-small-interval", 128);
m_strict2double = p.get_double(":strict2double", 0.00001);
m_max_refinements = p.get_uint("bound_max_refinements", 16);
m_threshold = p.get_double("bound_threshold", 0.05);
m_small_interval = p.get_double("bound_small_interval", 128);
m_strict2double = p.get_double("strict2double", 0.00001);
}
void bound_propagator::get_param_descrs(param_descrs & r) {
r.insert(":bound-max-refinements", CPK_UINT, "(default: 16) maximum number of bound refinements (per round) for unbounded variables.");
r.insert(":bound-threshold", CPK_DOUBLE, "(default: 0.05) bound propagation improvement threshold ratio.");
r.insert("bound_max_refinements", CPK_UINT, "(default: 16) maximum number of bound refinements (per round) for unbounded variables.");
r.insert("bound_threshold", CPK_DOUBLE, "(default: 0.05) bound propagation improvement threshold ratio.");
}
void bound_propagator::collect_statistics(statistics & st) const {

2
src/tactic/arith/bv2int_rewriter.cpp
View file

@ -21,7 +21,7 @@ Notes:
#include "ast_pp.h"
void bv2int_rewriter_ctx::update_params(params_ref const& p) {
m_max_size = p.get_uint(":max-bv-size", UINT_MAX);
m_max_size = p.get_uint("max_bv_size", UINT_MAX);
}
struct lt_rational {

4
src/tactic/arith/diff_neq_tactic.cpp
View file

@ -62,7 +62,7 @@ class diff_neq_tactic : public tactic {
}
void updt_params(params_ref const & p) {
m_max_k = rational(p.get_uint(":diff-neq-max-k", 1024));
m_max_k = rational(p.get_uint("diff_neq_max_k", 1024));
m_max_neg_k = -m_max_k;
if (m_max_k >= rational(INT_MAX/2))
m_max_k = rational(INT_MAX/2);
@ -374,7 +374,7 @@ public:
}
virtual void collect_param_descrs(param_descrs & r) {
r.insert(":diff-neq-max-k", CPK_UINT, "(default: 1024) maximum variable upper bound for diff neq solver.");
r.insert("diff_neq_max_k", CPK_UINT, "(default: 1024) maximum variable upper bound for diff neq solver.");
}
virtual void collect_statistics(statistics & st) const {

4
src/tactic/arith/factor_tactic.cpp
View file

@ -40,7 +40,7 @@ class factor_tactic : public tactic {
}
void updt_params(params_ref const & p) {
m_split_factors = p.get_bool(":split-factors", true);
m_split_factors = p.get_bool("split_factors", true);
m_fparams.updt_params(p);
}
@ -311,7 +311,7 @@ public:
}
virtual void collect_param_descrs(param_descrs & r) {
r.insert(":split-factors", CPK_BOOL,
r.insert("split_factors", CPK_BOOL,
"(default: true) apply simplifications such as (= (* p1 p2) 0) --> (or (= p1 0) (= p2 0)).");
polynomial::factor_params::get_param_descrs(r);
}

32
src/tactic/arith/fm_tactic.cpp
View file

@ -792,13 +792,13 @@ class fm_tactic : public tactic {
}
void updt_params(params_ref const & p) {
m_max_memory = megabytes_to_bytes(p.get_uint(":max-memory", UINT_MAX));
m_fm_real_only = p.get_bool(":fm-real-only", true);
m_fm_limit = p.get_uint(":fm-limit", 5000000);
m_fm_cutoff1 = p.get_uint(":fm-cutoff1", 8);
m_fm_cutoff2 = p.get_uint(":fm-cutoff2", 256);
m_fm_extra = p.get_uint(":fm-extra", 0);
m_fm_occ = p.get_bool(":fm-occ", false);
m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX));
m_fm_real_only = p.get_bool("fm_real_only", true);
m_fm_limit = p.get_uint("fm_limit", 5000000);
m_fm_cutoff1 = p.get_uint("fm_cutoff1", 8);
m_fm_cutoff2 = p.get_uint("fm_cutoff2", 256);
m_fm_extra = p.get_uint("fm_extra", 0);
m_fm_occ = p.get_bool("fm_occ", false);
}
void set_cancel(bool f) {
@ -1668,12 +1668,12 @@ public:
virtual void collect_param_descrs(param_descrs & r) {
insert_produce_models(r);
insert_max_memory(r);
r.insert(":fm-real-only", CPK_BOOL, "(default: true) consider only real variables for fourier-motzkin elimination.");
r.insert(":fm-occ", CPK_BOOL, "(default: false) consider inequalities occurring in clauses for FM.");
r.insert(":fm-limit", CPK_UINT, "(default: 5000000) maximum number of constraints, monomials, clauses visited during FM.");
r.insert(":fm-cutoff1", CPK_UINT, "(default: 8) first cutoff for FM based on maximum number of lower/upper occurrences.");
r.insert(":fm-cutoff2", CPK_UINT, "(default: 256) second cutoff for FM based on num_lower * num_upper occurrences.");
r.insert(":fm-extra", CPK_UINT, "(default: 0) max. increase on the number of inequalities for each FM variable elimination step.");
r.insert("fm_real_only", CPK_BOOL, "(default: true) consider only real variables for fourier-motzkin elimination.");
r.insert("fm_occ", CPK_BOOL, "(default: false) consider inequalities occurring in clauses for FM.");
r.insert("fm_limit", CPK_UINT, "(default: 5000000) maximum number of constraints, monomials, clauses visited during FM.");
r.insert("fm_cutoff1", CPK_UINT, "(default: 8) first cutoff for FM based on maximum number of lower/upper occurrences.");
r.insert("fm_cutoff2", CPK_UINT, "(default: 256) second cutoff for FM based on num_lower * num_upper occurrences.");
r.insert("fm_extra", CPK_UINT, "(default: 0) max. increase on the number of inequalities for each FM variable elimination step.");
}
virtual void set_cancel(bool f) {
@ -1707,9 +1707,9 @@ public:
tactic * mk_fm_tactic(ast_manager & m, params_ref const & p) {
params_ref s_p = p;
s_p.set_bool(":arith-lhs", true);
s_p.set_bool(":elim-and", true);
s_p.set_bool(":som", true);
s_p.set_bool("arith_lhs", true);
s_p.set_bool("elim_and", true);
s_p.set_bool("som", true);
return and_then(using_params(mk_simplify_tactic(m, s_p), s_p),
clean(alloc(fm_tactic, m, p)));
}

12
src/tactic/arith/lia2pb_tactic.cpp
View file

@ -50,9 +50,9 @@ class lia2pb_tactic : public tactic {
}
void updt_params_core(params_ref const & p) {
m_partial_lia2pb = p.get_bool(":lia2pb-partial", false);
m_max_bits = p.get_uint(":lia2pb-max-bits", 32);
m_total_bits = p.get_uint(":lia2pb-total-bits", 2048);
m_partial_lia2pb = p.get_bool("lia2pb_partial", false);
m_max_bits = p.get_uint("lia2pb_max_bits", 32);
m_total_bits = p.get_uint("lia2pb_total_bits", 2048);
}
void updt_params(params_ref const & p) {
@ -325,9 +325,9 @@ public:
}
virtual void collect_param_descrs(param_descrs & r) {
r.insert(":lia2pb-partial", CPK_BOOL, "(default: false) partial lia2pb conversion.");
r.insert(":lia2pb-max-bits", CPK_UINT, "(default: 32) maximum number of bits to be used (per variable) in lia2pb.");
r.insert(":lia2pb-total-bits", CPK_UINT, "(default: 2048) total number of bits to be used (per problem) in lia2pb.");
r.insert("lia2pb_partial", CPK_BOOL, "(default: false) partial lia2pb conversion.");
r.insert("lia2pb_max_bits", CPK_UINT, "(default: 32) maximum number of bits to be used (per variable) in lia2pb.");
r.insert("lia2pb_total_bits", CPK_UINT, "(default: 2048) total number of bits to be used (per problem) in lia2pb.");
}
virtual void operator()(goal_ref const & in,

12
src/tactic/arith/nla2bv_tactic.cpp
View file

@ -68,7 +68,7 @@ class nla2bv_tactic : public tactic {
m_is_sat_preserving(true),
m_arith(m),
m_bv(m),
m_bv2real(m, rational(p.get_uint(":nla2bv-root",2)), rational(p.get_uint(":nla2bv-divisor",2)), p.get_uint(":nla2bv-max-bv-size", UINT_MAX)),
m_bv2real(m, rational(p.get_uint("nla2bv_root",2)), rational(p.get_uint("nla2bv_divisor",2)), p.get_uint("nla2bv_max_bv_size", UINT_MAX)),
m_bv2int_ctx(m, p),
m_bounds(m),
m_subst(m),
@ -76,7 +76,7 @@ class nla2bv_tactic : public tactic {
m_defs(m),
m_trail(m),
m_fmc(0) {
m_default_bv_size = m_num_bits = p.get_uint(":nla2bv-bv-size", 4);
m_default_bv_size = m_num_bits = p.get_uint("nla2bv_bv_size", 4);
}
~imp() {}
@ -436,10 +436,10 @@ public:
}
virtual void collect_param_descrs(param_descrs & r) {
r.insert(":nla2bv-max-bv-size", CPK_UINT, "(default: inf) maximum bit-vector size used by nla2bv tactic");
r.insert(":nla2bv-bv-size", CPK_UINT, "(default: 4) default bit-vector size used by nla2bv tactic.");
r.insert(":nla2bv-root", CPK_UINT, "(default: 2) nla2bv tactic encodes reals into bit-vectors using expressions of the form a+b*sqrt(c), this parameter sets the value of c used in the encoding.");
r.insert(":nla2bv-divisor", CPK_UINT, "(default: 2) nla2bv tactic parameter.");
r.insert("nla2bv_max_bv_size", CPK_UINT, "(default: inf) maximum bit-vector size used by nla2bv tactic");
r.insert("nla2bv_bv_size", CPK_UINT, "(default: 4) default bit-vector size used by nla2bv tactic.");
r.insert("nla2bv_root", CPK_UINT, "(default: 2) nla2bv tactic encodes reals into bit-vectors using expressions of the form a+b*sqrt(c), this parameter sets the value of c used in the encoding.");
r.insert("nla2bv_divisor", CPK_UINT, "(default: 2) nla2bv tactic parameter.");
}
/**

4
src/tactic/arith/normalize_bounds_tactic.cpp
View file

@ -44,7 +44,7 @@ class normalize_bounds_tactic : public tactic {
}
void updt_params_core(params_ref const & p) {
m_normalize_int_only = p.get_bool(":norm-int-only", true);
m_normalize_int_only = p.get_bool("norm_int_only", true);
}
void updt_params(params_ref const & p) {
@ -173,7 +173,7 @@ public:
virtual void collect_param_descrs(param_descrs & r) {
insert_produce_models(r);
r.insert(":norm-int-only", CPK_BOOL, "(default: true) normalize only the bounds of integer constants.");
r.insert("norm_int_only", CPK_BOOL, "(default: true) normalize only the bounds of integer constants.");
}
virtual void operator()(goal_ref const & in,

10
src/tactic/arith/pb2bv_tactic.cpp
View file

@ -863,15 +863,15 @@ private:
}
void updt_params(params_ref const & p) {
m_max_memory = megabytes_to_bytes(p.get_uint(":max-memory", UINT_MAX));
m_all_clauses_limit = p.get_uint(":pb2bv-all-clauses-limit", 8);
m_cardinality_limit = p.get_uint(":pb2bv-cardinality-limit", UINT_MAX);
m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX));
m_all_clauses_limit = p.get_uint("pb2bv_all_clauses_limit", 8);
m_cardinality_limit = p.get_uint("pb2bv_cardinality_limit", UINT_MAX);
}
void collect_param_descrs(param_descrs & r) {
insert_max_memory(r);
r.insert(":pb2bv-all-clauses-limit", CPK_UINT, "(default: 8) maximum number of literals for using equivalent CNF encoding of PB constraint.");
r.insert(":pb2bv-cardinality-limit", CPK_UINT, "(default: inf) limit for using arc-consistent cardinality constraint encoding.");
r.insert("pb2bv_all_clauses_limit", CPK_UINT, "(default: 8) maximum number of literals for using equivalent CNF encoding of PB constraint.");
r.insert("pb2bv_cardinality_limit", CPK_UINT, "(default: inf) limit for using arc-consistent cardinality constraint encoding.");
}
void set_cancel(bool f) {

16
src/tactic/arith/purify_arith_tactic.cpp
View file

@ -856,11 +856,11 @@ public:
}
virtual void collect_param_descrs(param_descrs & r) {
r.insert(":complete", CPK_BOOL,
r.insert("complete", CPK_BOOL,
"(default: true) add constraints to make sure that any interpretation of a underspecified arithmetic operators is a functio. The result will include additional uninterpreted functions/constants: /0, div0, mod0, 0^0, neg-root");
r.insert(":elim-root-objects", CPK_BOOL,
r.insert("elim_root_objects", CPK_BOOL,
"(default: true) eliminate root objects.");
r.insert(":elim-inverses", CPK_BOOL,
r.insert("elim_inverses", CPK_BOOL,
"(default: true) eliminate inverse trigonometric functions (asin, acos, atan).");
th_rewriter::get_param_descrs(r);
}
@ -876,9 +876,9 @@ public:
tactic_report report("purify-arith", *g);
bool produce_proofs = g->proofs_enabled();
bool produce_models = g->models_enabled();
bool elim_root_objs = m_params.get_bool(":elim-root-objects", true);
bool elim_inverses = m_params.get_bool(":elim-inverses", true);
bool complete = m_params.get_bool(":complete", true);
bool elim_root_objs = m_params.get_bool("elim_root_objects", true);
bool elim_inverses = m_params.get_bool("elim_inverses", true);
bool complete = m_params.get_bool("complete", true);
purify_arith_proc proc(m_util, m_aux_decls, produce_proofs, elim_root_objs, elim_inverses, complete);
proc(*(g.get()), mc, produce_models);
@ -902,10 +902,10 @@ public:
tactic * mk_purify_arith_tactic(ast_manager & m, params_ref const & p) {
params_ref elim_rem_p = p;
elim_rem_p.set_bool(":elim-rem", true);
elim_rem_p.set_bool("elim-rem", true);
params_ref skolemize_p;
skolemize_p.set_bool(":skolemize", false);
skolemize_p.set_bool("skolemize", false);
return and_then(using_params(mk_snf_tactic(m, skolemize_p), skolemize_p),
using_params(mk_simplify_tactic(m, elim_rem_p), elim_rem_p),

4
src/tactic/arith/recover_01_tactic.cpp
View file

@ -58,7 +58,7 @@ class recover_01_tactic : public tactic {
}
void updt_params_core(params_ref const & p) {
m_cls_max_size = p.get_uint(":recover-01-max-bits", 10);
m_cls_max_size = p.get_uint("recover_01_max_bits", 10);
}
void updt_params(params_ref const & p) {
@ -408,7 +408,7 @@ public:
virtual void collect_param_descrs(param_descrs & r) {
th_rewriter::get_param_descrs(r);
r.insert(":recover-01-max-bits", CPK_UINT, "(default: 10) maximum number of bits to consider in a clause.");
r.insert("recover_01_max_bits", CPK_UINT, "(default: 10) maximum number of bits to consider in a clause.");
}
void operator()(goal_ref const & g,

10
src/tactic/bv/bit_blaster_tactic.cpp
View file

@ -36,7 +36,7 @@ class bit_blaster_tactic : public tactic {
}
void updt_params_core(params_ref const & p) {
m_blast_quant = p.get_bool(":blast-quant", false);
m_blast_quant = p.get_bool("blast_quant", false);
}
void updt_params(params_ref const & p) {
@ -120,10 +120,10 @@ public:
virtual void collect_param_descrs(param_descrs & r) {
insert_max_memory(r);
insert_max_steps(r);
r.insert(":blast-mul", CPK_BOOL, "(default: true) bit-blast multipliers (and dividers, remainders).");
r.insert(":blast-add", CPK_BOOL, "(default: true) bit-blast adders.");
r.insert(":blast-quant", CPK_BOOL, "(default: false) bit-blast quantified variables.");
r.insert(":blast-full", CPK_BOOL, "(default: false) bit-blast any term with bit-vector sort, this option will make E-matching ineffective in any pattern containing bit-vector terms.");
r.insert("blast_mul", CPK_BOOL, "(default: true) bit-blast multipliers (and dividers, remainders).");
r.insert("blast_add", CPK_BOOL, "(default: true) bit-blast adders.");
r.insert("blast_quant", CPK_BOOL, "(default: false) bit-blast quantified variables.");
r.insert("blast_full", CPK_BOOL, "(default: false) bit-blast any term with bit-vector sort, this option will make E-matching ineffective in any pattern containing bit-vector terms.");
}
virtual void operator()(goal_ref const & g,

6
src/tactic/bv/bv1_blaster_tactic.cpp
View file

@ -63,9 +63,9 @@ class bv1_blaster_tactic : public tactic {
}
void updt_params(params_ref const & p) {
m_max_memory = megabytes_to_bytes(p.get_uint(":max-memory", UINT_MAX));
m_max_steps = p.get_uint(":max-steps", UINT_MAX);
m_produce_models = p.get_bool(":produce-models", false);
m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX));
m_max_steps = p.get_uint("max_steps", UINT_MAX);
m_produce_models = p.get_bool("produce_models", false);
}
bool rewrite_patterns() const { UNREACHABLE(); return false; }

8
src/tactic/bv/max_bv_sharing_tactic.cpp
View file

@ -55,9 +55,9 @@ class max_bv_sharing_tactic : public tactic {
}
void updt_params(params_ref const & p) {
m_max_memory = megabytes_to_bytes(p.get_uint(":max-memory", UINT_MAX));
m_max_steps = p.get_uint(":max-steps", UINT_MAX);
m_max_args = p.get_uint(":max-args", 128);
m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX));
m_max_steps = p.get_uint("max_steps", UINT_MAX);
m_max_args = p.get_uint("max_args", 128);
}
bool max_steps_exceeded(unsigned num_steps) const {
@ -298,7 +298,7 @@ public:
virtual void collect_param_descrs(param_descrs & r) {
insert_max_memory(r);
insert_max_steps(r);
r.insert(":max-args", CPK_UINT,
r.insert("max_args", CPK_UINT,
"(default: 128) maximum number of arguments (per application) that will be considered by the greedy (quadratic) heuristic.");
}

2
src/tactic/core/cofactor_elim_term_ite.cpp
View file

@ -304,7 +304,7 @@ struct cofactor_elim_term_ite::imp {
}
void updt_params(params_ref const & p) {
m_max_memory = megabytes_to_bytes(p.get_uint(":max-memory", UINT_MAX));
m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX));
}
void set_cancel(bool f) {

10
src/tactic/core/ctx_simplify_tactic.cpp
View file

@ -90,10 +90,10 @@ struct ctx_simplify_tactic::imp {
}
void updt_params(params_ref const & p) {
m_max_memory = megabytes_to_bytes(p.get_uint(":max-memory", UINT_MAX));
m_max_steps = p.get_uint(":max-steps", UINT_MAX);
m_max_depth = p.get_uint(":max-depth", 1024);
m_bail_on_blowup = p.get_bool(":bail-on-blowup", false);
m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX));
m_max_steps = p.get_uint("max_steps", UINT_MAX);
m_max_depth = p.get_uint("max_depth", 1024);
m_bail_on_blowup = p.get_bool("bail_on_blowup", false);
}
void checkpoint() {
@ -519,7 +519,7 @@ void ctx_simplify_tactic::updt_params(params_ref const & p) {
void ctx_simplify_tactic::get_param_descrs(param_descrs & r) {
insert_max_memory(r);
insert_max_steps(r);
r.insert(":max-depth", CPK_UINT, "(default: 1024) maximum term depth.");
r.insert("max_depth", CPK_UINT, "(default: 1024) maximum term depth.");
}
void ctx_simplify_tactic::operator()(goal_ref const & in,

4
src/tactic/core/elim_term_ite_tactic.cpp
View file

@ -72,7 +72,7 @@ class elim_term_ite_tactic : public tactic {
}
void updt_params(params_ref const & p) {
m_max_memory = megabytes_to_bytes(p.get_uint(":max-memory", UINT_MAX));
m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX));
}
};
@ -160,7 +160,7 @@ public:
virtual void collect_param_descrs(param_descrs & r) {
insert_max_memory(r);
insert_max_steps(r);
r.insert(":max-args", CPK_UINT,
r.insert("max_args", CPK_UINT,
"(default: 128) maximum number of arguments (per application) that will be considered by the greedy (quadratic) heuristic.");
}

4
src/tactic/core/elim_uncnstr_tactic.cpp
View file

@ -881,8 +881,8 @@ class elim_uncnstr_tactic : public tactic {
}
void updt_params(params_ref const & p) {
m_max_memory = megabytes_to_bytes(p.get_uint(":max-memory", UINT_MAX));
m_max_steps = p.get_uint(":max-steps", UINT_MAX);
m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX));
m_max_steps = p.get_uint("max_steps", UINT_MAX);
}
ast_manager & m() { return m_manager; }

2
src/tactic/core/nnf_tactic.cpp
View file

@ -120,7 +120,7 @@ tactic * mk_snf_tactic(ast_manager & m, params_ref const & p) {
tactic * mk_nnf_tactic(ast_manager & m, params_ref const & p) {
params_ref new_p(p);
new_p.set_sym(":nnf-mode", symbol("full"));
new_p.set_sym("nnf_mode", symbol("full"));
TRACE("nnf", tout << "mk_nnf: " << new_p << "\n";);
return using_params(mk_snf_tactic(m, p), new_p);
}

4
src/tactic/core/propagate_values_tactic.cpp
View file

@ -44,7 +44,7 @@ class propagate_values_tactic : public tactic {
}
void updt_params_core(params_ref const & p) {
m_max_rounds = p.get_uint(":max-rounds", 4);
m_max_rounds = p.get_uint("max_rounds", 4);
}
void updt_params(params_ref const & p) {
@ -237,7 +237,7 @@ public:
virtual void collect_param_descrs(param_descrs & r) {
th_rewriter::get_param_descrs(r);
r.insert(":max-rounds", CPK_UINT, "(default: 2) maximum number of rounds.");
r.insert("max_rounds", CPK_UINT, "(default: 2) maximum number of rounds.");
}
virtual void operator()(goal_ref const & in,

2
src/tactic/core/simplify_tactic.cpp
View file

@ -138,7 +138,7 @@ tactic * mk_simplify_tactic(ast_manager & m, params_ref const & p) {
tactic * mk_elim_and_tactic(ast_manager & m, params_ref const & p) {
params_ref xp = p;
xp.set_bool(":elim-and", true);
xp.set_bool("elim_and", true);
return using_params(mk_simplify_tactic(m, xp), xp);
}

12
src/tactic/core/solve_eqs_tactic.cpp
View file

@ -71,9 +71,9 @@ class solve_eqs_tactic : public tactic {
ast_manager & m() const { return m_manager; }
void updt_params(params_ref const & p) {
m_ite_solver = p.get_bool(":ite-solver", true);
m_theory_solver = p.get_bool(":theory-solver", true);
m_max_occs = p.get_uint(":solve-eqs-max-occs", UINT_MAX);
m_ite_solver = p.get_bool("ite_solver", true);
m_theory_solver = p.get_bool("theory_solver", true);
m_max_occs = p.get_uint("solve_eqs_max_occs", UINT_MAX);
}
void set_cancel(bool f) {
@ -732,9 +732,9 @@ public:
}
virtual void collect_param_descrs(param_descrs & r) {
r.insert(":solve-eqs-max-occs", CPK_UINT, "(default: infty) maximum number of occurrences for considering a variable for gaussian eliminations.");
r.insert(":theory-solver", CPK_BOOL, "(default: true) use theory solvers.");
r.insert(":ite-solver", CPK_BOOL, "(default: true) use if-then-else solver.");
r.insert("solve_eqs_max_occs", CPK_UINT, "(default: infty) maximum number of occurrences for considering a variable for gaussian eliminations.");
r.insert("theory_solver", CPK_BOOL, "(default: true) use theory solvers.");
r.insert("ite_solver", CPK_BOOL, "(default: true) use if-then-else solver.");
}
virtual void operator()(goal_ref const & in,

4
src/tactic/core/split_clause_tactic.cpp
View file

@ -96,11 +96,11 @@ public:
}
virtual void updt_params(params_ref const & p) {
m_largest_clause = p.get_bool(":split-largest-clause", false);
m_largest_clause = p.get_bool("split_largest_clause", false);
}
virtual void collect_param_descrs(param_descrs & r) {
r.insert(":split-largest-clause", CPK_BOOL, "(default: false) split the largest clause in the goal.");
r.insert("split_largest_clause", CPK_BOOL, "(default: false) split the largest clause in the goal.");
}
virtual void operator()(goal_ref const & in,

26
src/tactic/core/tseitin_cnf_tactic.cpp
View file

@ -122,12 +122,12 @@ class tseitin_cnf_tactic : public tactic {
}
void updt_params(params_ref const & p) {
m_common_patterns = p.get_bool(":common-patterns", true);
m_distributivity = p.get_bool(":distributivity", true);
m_distributivity_blowup = p.get_uint(":distributivity-blowup", 32);
m_ite_chains = p.get_bool(":ite-chains", true);
m_ite_extra = p.get_bool(":ite-extra", true);
m_max_memory = megabytes_to_bytes(p.get_uint(":max-memory", UINT_MAX));
m_common_patterns = p.get_bool("common_patterns", true);
m_distributivity = p.get_bool("distributivity", true);
m_distributivity_blowup = p.get_uint("distributivity_blowup", 32);
m_ite_chains = p.get_bool("ite_chains", true);
m_ite_extra = p.get_bool("ite_extra", true);
m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX));
}
void push_frame(app * n) { m_frame_stack.push_back(frame(n)); }
@ -881,11 +881,11 @@ public:
virtual void collect_param_descrs(param_descrs & r) {
insert_max_memory(r);
r.insert(":common-patterns", CPK_BOOL, "(default: true) minimize the number of auxiliary variables during CNF encoding by identifing commonly used patterns");
r.insert(":distributivity", CPK_BOOL, "(default: true) minimize the number of auxiliary variables during CNF encoding by applying distributivity over unshared subformulas");
r.insert(":distributivity-blowup", CPK_UINT, "(default: 32) maximum overhead for applying distributivity during CNF encoding");
r.insert("ite-chaing", CPK_BOOL, "(default: true) minimize the number of auxiliary variables during CNF encoding by identifing if-then-else chains");
r.insert(":ite-extra", CPK_BOOL, "(default: true) add redundant clauses (that improve unit propagation) when encoding if-then-else formulas");
r.insert("common_patterns", CPK_BOOL, "(default: true) minimize the number of auxiliary variables during CNF encoding by identifing commonly used patterns");
r.insert("distributivity", CPK_BOOL, "(default: true) minimize the number of auxiliary variables during CNF encoding by applying distributivity over unshared subformulas");
r.insert("distributivity_blowup", CPK_UINT, "(default: 32) maximum overhead for applying distributivity during CNF encoding");
r.insert("ite_chaing", CPK_BOOL, "(default: true) minimize the number of auxiliary variables during CNF encoding by identifing if-then-else chains");
r.insert("ite_extra", CPK_BOOL, "(default: true) add redundant clauses (that improve unit propagation) when encoding if-then-else formulas");
}
virtual void operator()(goal_ref const & in,
@ -934,8 +934,8 @@ tactic * mk_tseitin_cnf_core_tactic(ast_manager & m, params_ref const & p) {
tactic * mk_tseitin_cnf_tactic(ast_manager & m, params_ref const & p) {
params_ref simp_p = p;
simp_p.set_bool(":elim-and", true);
simp_p.set_bool(":blast-distinct", true);
simp_p.set_bool("elim_and", true);
simp_p.set_bool("blast_distinct", true);
return or_else(mk_tseitin_cnf_core_tactic(m, p),
and_then(using_params(mk_simplify_tactic(m, p), simp_p),
mk_tseitin_cnf_core_tactic(m, p)));

4
src/tactic/fpa/fpa2bv_rewriter.h
View file

@ -54,8 +54,8 @@ struct fpa2bv_rewriter_cfg : public default_rewriter_cfg {
}
void updt_params(params_ref const & p) {
m_max_memory = megabytes_to_bytes(p.get_uint(":max-memory", UINT_MAX));
m_max_steps = p.get_uint(":max-steps", UINT_MAX);
m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX));
m_max_steps = p.get_uint("max_steps", UINT_MAX);
}
bool max_steps_exceeded(unsigned num_steps) const {

2
src/tactic/fpa/qffpa_tactic.cpp
View file

@ -26,7 +26,7 @@ Notes:
tactic * mk_qffpa_tactic(ast_manager & m, params_ref const & p) {
params_ref sat_simp_p = p;
sat_simp_p .set_bool(":elim-and", true);
sat_simp_p .set_bool("elim_and", true);
return and_then(mk_simplify_tactic(m, p),
mk_fpa2bv_tactic(m, p),

48
src/tactic/sls/sls_tactic.cpp
View file

@ -1363,16 +1363,16 @@ class sls_tactic : public tactic {
static void collect_param_descrs(param_descrs & r) {
insert_produce_models(r);
r.insert(":sls-restarts", CPK_UINT, "(default: infty) # of SLS restarts.");
r.insert(":random-seed", CPK_UINT, "(default: 0) random seed.");
r.insert(":plateau-limit", CPK_UINT, "(default: 100) SLS plateau limit.");
r.insert("sls_restarts", CPK_UINT, "(default: infty) # of SLS restarts.");
r.insert("random_seed", CPK_UINT, "(default: 0) random seed.");
r.insert("plateau_limit", CPK_UINT, "(default: 100) SLS plateau limit.");
}
void updt_params(params_ref const & p) {
m_produce_models = p.get_bool(":produce-models", false);
m_max_restarts = p.get_uint(":sls-restarts", -1);
m_tracker.set_random_seed(p.get_uint(":random-seed", 0));
m_plateau_limit = p.get_uint(":plateau-limit", 100);
m_produce_models = p.get_bool("produce_models", false);
m_max_restarts = p.get_uint("sls_restarts", -1);
m_tracker.set_random_seed(p.get_uint("random_seed", 0));
m_plateau_limit = p.get_uint("plateau_limit", 100);
}
void checkpoint() {
@ -1854,28 +1854,28 @@ tactic * mk_sls_tactic(ast_manager & m, params_ref const & p) {
tactic * mk_preamble(ast_manager & m, params_ref const & p) {
params_ref main_p;
main_p.set_bool(":elim-and", true);
// main_p.set_bool(":pull-cheap-ite", true);
main_p.set_bool(":push-ite-bv", true);
main_p.set_bool(":blast-distinct", true);
// main_p.set_bool(":udiv2mul", true);
main_p.set_bool(":hi-div0", true);
main_p.set_bool("elim_and", true);
// main_p.set_bool("pull-cheap_ite", true);
main_p.set_bool("push_ite_bv", true);
main_p.set_bool("blast_distinct", true);
// main_p.set_bool("udiv2mul", true);
main_p.set_bool("hi_div0", true);
params_ref simp2_p = p;
simp2_p.set_bool(":som", true);
simp2_p.set_bool(":pull-cheap-ite", true);
simp2_p.set_bool(":push-ite-bv", false);
simp2_p.set_bool(":local-ctx", true);
simp2_p.set_uint(":local-ctx-limit", 10000000);
simp2_p.set_bool("som", true);
simp2_p.set_bool("pull_cheap_ite", true);
simp2_p.set_bool("push_ite_bv", false);
simp2_p.set_bool("local_ctx", true);
simp2_p.set_uint("local_ctx_limit", 10000000);
params_ref hoist_p;
hoist_p.set_bool(":hoist-mul", true);
// hoist_p.set_bool(":hoist-cmul", true);
hoist_p.set_bool(":som", false);
hoist_p.set_bool("hoist_mul", true);
// hoist_p.set_bool("hoist_cmul", true);
hoist_p.set_bool("som", false);
params_ref gaussian_p;
// conservative gaussian elimination.
gaussian_p.set_uint(":gaussian-max-occs", 2);
gaussian_p.set_uint("gaussian_max_occs", 2);
return and_then(and_then(mk_simplify_tactic(m),
mk_propagate_values_tactic(m),
@ -1890,8 +1890,8 @@ tactic * mk_preamble(ast_manager & m, params_ref const & p) {
tactic * mk_qfbv_sls_tactic(ast_manager & m, params_ref const & p) {
params_ref sls_p(p);
sls_p.set_uint(":sls-restarts", 10000);
sls_p.set_uint(":plateau-limit", 100);
sls_p.set_uint("sls_restarts", 10000);
sls_p.set_uint("plateau_limit", 100);
tactic * t = and_then(mk_preamble(m, p),
using_params(mk_sls_tactic(m, p), sls_p));

2
src/tactic/smtlogics/qfnra_tactic.cpp
View file

@ -25,7 +25,7 @@ Notes:
static tactic * mk_qfnra_sat_solver(ast_manager& m, params_ref const& p, unsigned bv_size) {
params_ref nra2sat_p = p;
nra2sat_p.set_uint(":nla2bv-max-bv-size", p.get_uint(":nla2bv-max-bv-size", bv_size));
nra2sat_p.set_uint(":nla2bv-max-bv-size", p.get_uint("nla2bv_max_bv_size", bv_size));
return and_then(mk_nla2bv_tactic(m, nra2sat_p),
mk_smt_tactic(),

2
src/tactic/smtlogics/quant_tactics.cpp
View file

@ -72,7 +72,7 @@ tactic * mk_uflra_tactic(ast_manager & m, params_ref const & p) {
tactic * mk_auflia_tactic(ast_manager & m, params_ref const & p) {
params_ref qi_p;
qi_p.set_str(":qi-cost", "0");
TRACE("qi_cost", qi_p.display(tout); tout << "\n" << qi_p.get_str(":qi-cost", "<null>") << "\n";);
TRACE("qi_cost", qi_p.display(tout); tout << "\n" << qi_p.get_str("qi_cost", "<null>") << "\n";);
tactic * st = and_then(mk_no_solve_eq_preprocessor(m),
or_else(and_then(fail_if(mk_gt(mk_num_exprs_probe(), mk_const_probe(static_cast<double>(128)))),
using_params(mk_smt_tactic(), qi_p),

4
src/tactic/ufbv/macro_finder_tactic.cpp
View file

@ -102,7 +102,7 @@ class macro_finder_tactic : public tactic {
}
void updt_params(params_ref const & p) {
m_elim_and = p.get_bool(":elim-and", false);
m_elim_and = p.get_bool("elim_and", false);
}
};
@ -131,7 +131,7 @@ public:
insert_max_memory(r);
insert_produce_models(r);
insert_produce_proofs(r);
r.insert(":elim-and", CPK_BOOL, "(default: false) eliminate conjunctions during (internal) calls to the simplifier.");
r.insert("elim_and", CPK_BOOL, "(default: false) eliminate conjunctions during (internal) calls to the simplifier.");
}
virtual void operator()(goal_ref const & in,