mirror of
https://github.com/Z3Prover/z3
synced 2025-04-07 18:05:21 +00:00
Current version before integration ...
This commit is contained in:
parent
f88b034b8b
commit
42702c8d8a
|
@ -36,17 +36,21 @@ Notes:
|
|||
// do we use dirty unit propagation to get rid of nested top level assertions?
|
||||
#define _DIRTY_UP_ 0
|
||||
|
||||
// shall we use additive weighting scheme?
|
||||
#define _PAWS_ 5
|
||||
#define _PAWS_INIT_ 40
|
||||
|
||||
// do we use restarts?
|
||||
// 0 = no, 1 = use #moves, 2 = use #plateaus, 3 = use time
|
||||
#define _RESTARTS_ 3
|
||||
#define _RESTARTS_ 1
|
||||
// limit of moves/plateaus/seconds until first restart occurs
|
||||
#define _RESTART_LIMIT_ 10
|
||||
#define _RESTART_LIMIT_ 100
|
||||
// 0 = initialize with all zero, 1 initialize with random value
|
||||
#define _RESTART_INIT_ 0
|
||||
// 0 = even intervals, 1 = pseudo luby, 2 = real luby, 3 = armin, 4 = rapid
|
||||
// 0 = even intervals, 1 = pseudo luby, 2 = real luby, 3 = armin, 4 = rapid, 5 = minisat
|
||||
#define _RESTART_SCHEME_ 1
|
||||
// base value c for armin restart scheme using c^inner - only applies for _RESTART_SCHEME_ 3
|
||||
#define _RESTART_CONST_ARMIN_ 3.0
|
||||
#define _RESTART_CONST_ARMIN_ 2.0
|
||||
|
||||
// timelimit
|
||||
#define _TIMELIMIT_ 3600
|
||||
|
@ -61,6 +65,21 @@ Notes:
|
|||
// 0 = no, 1 = only consider flipping bits if no better score can be obtained otherwise, 2 = only consider flipping bits until a better score can be obtained
|
||||
#define _VNS_ 0
|
||||
|
||||
// shall we check 2-bit flips in plateaus using Monte Carlo?
|
||||
#define _VNS_MC_ 0
|
||||
|
||||
// how many 2-bit flips shall we try per bit?
|
||||
#define _VNS_MC_TRIES_ 1
|
||||
|
||||
// shall we check another assertion if no improving step was found in the first one?
|
||||
#define _VNS_REPICK_ 0
|
||||
|
||||
// what is the probability of doing so (percentage)?
|
||||
#define _VNS_PERC_ 100
|
||||
|
||||
// do a decreasing move with percentage ...
|
||||
#define _INSIST_PERC_ 0
|
||||
|
||||
// do we reduce the score of unsatisfied literals?
|
||||
// 0 = no
|
||||
// 1 = yes, by multiplying it with some factor
|
||||
|
@ -70,7 +89,7 @@ Notes:
|
|||
#define _WEIGHT_DIST_ 1
|
||||
|
||||
// the factor used for _WEIGHT_DIST_ = 1
|
||||
#define _WEIGHT_DIST_FACTOR_ 0.25
|
||||
#define _WEIGHT_DIST_FACTOR_ 0.5
|
||||
|
||||
// shall we toggle the weight after each restart?
|
||||
#define _WEIGHT_TOGGLE_ 0
|
||||
|
@ -82,14 +101,15 @@ Notes:
|
|||
// what is the percentage of random moves in plateaus (instead of full randomization)?
|
||||
#define _PERC_PLATEAU_MOVES_ 0
|
||||
|
||||
// shall we repick clause when randomizing in a plateau or use the current one?
|
||||
// shall we repick assertion when randomizing in a plateau or use the current one?
|
||||
// 0 = use old one, 1 = repick according to usual scheme, 2 = repick randomly and force different one
|
||||
#define _REPICK_ 1
|
||||
|
||||
// do we use some UCT-like scheme for assertion-selection? overrides _BFS_
|
||||
#define _UCT_ 1
|
||||
|
||||
// how much diversification is used in the UCT-scheme?
|
||||
#define _UCT_CONSTANT_ 10.0
|
||||
#define _UCT_CONSTANT_ 20.0
|
||||
|
||||
// is uct clause selection probabilistic similar to variable selection in sparrow?
|
||||
// 0 = no, 1 = yes, use uct-value, 2 = yes, use score-value (_UCT_CONSTANT_ = 0.0) with squared score
|
||||
|
@ -103,7 +123,11 @@ Notes:
|
|||
|
||||
// how shall we initialize the _UCT_ total touched counter?
|
||||
// 0 = initialize with one, 1 = initialize with number of assertions
|
||||
#define _UCT_INIT_ 1
|
||||
#define _UCT_INIT_ 0
|
||||
|
||||
// do we gradually reduce the touched values of _UCT_?
|
||||
#define _UCT_FORGET_ 0
|
||||
#define _UCT_FORGET_FACTOR_ 0.9
|
||||
|
||||
// shall we use addition/subtraction?
|
||||
#define _USE_ADDSUB_ 1
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -22,7 +22,6 @@ Notes:
|
|||
#include"stopwatch.h"
|
||||
#include"lbool.h"
|
||||
#include"model_converter.h"
|
||||
#include"goal.h"
|
||||
|
||||
#include"sls_compilation_settings.h"
|
||||
#include"sls_tracker.h"
|
||||
|
@ -72,7 +71,6 @@ protected:
|
|||
bv_util m_bv_util;
|
||||
sls_tracker m_tracker;
|
||||
sls_evaluator m_evaluator;
|
||||
ptr_vector<expr> m_assertions;
|
||||
|
||||
unsigned m_restart_limit;
|
||||
unsigned m_max_restarts;
|
||||
|
@ -94,12 +92,11 @@ public:
|
|||
|
||||
void updt_params(params_ref const & _p);
|
||||
|
||||
void assert_expr(expr * e) { m_assertions.push_back(e); }
|
||||
|
||||
stats const & get_stats(void) { return m_stats; }
|
||||
void reset_statistics(void) { m_stats.reset(); }
|
||||
|
||||
bool full_eval(model & mdl);
|
||||
bool full_eval(goal_ref const & g, model & mdl);
|
||||
|
||||
|
||||
void mk_add(unsigned bv_sz, const mpz & old_value, mpz & add_value, mpz & result);
|
||||
void mk_mul2(unsigned bv_sz, const mpz & old_value, mpz & result);
|
||||
|
@ -107,48 +104,66 @@ public:
|
|||
void mk_inc(unsigned bv_sz, const mpz & old_value, mpz & incremented);
|
||||
void mk_dec(unsigned bv_sz, const mpz & old_value, mpz & decremented);
|
||||
void mk_inv(unsigned bv_sz, const mpz & old_value, mpz & inverted);
|
||||
void mk_flip(sort * s, const mpz & old_value, unsigned bit, mpz & flipped);
|
||||
void mk_flip(sort * s, const mpz & old_value, unsigned bit, mpz & flipped);
|
||||
|
||||
void init_tracker(void);
|
||||
double find_best_move(goal_ref const & g, ptr_vector<func_decl> & to_evaluate, double score,
|
||||
unsigned & best_const, mpz & best_value, unsigned & new_bit, move_type & move);
|
||||
|
||||
lbool search(void);
|
||||
double find_best_move_lsb(goal_ref const & g, ptr_vector<func_decl> & to_evaluate, double score,
|
||||
unsigned & best_const, mpz & best_value, unsigned & new_bit, move_type & move);
|
||||
|
||||
double find_best_move_mc(goal_ref const & g, ptr_vector<func_decl> & to_evaluate, double score,
|
||||
unsigned & best_const, mpz & best_value);
|
||||
|
||||
double find_best_move_local(expr * e, ptr_vector<func_decl> & to_evaluate,
|
||||
unsigned & best_const, mpz & best_value, unsigned & new_bit, move_type & move);
|
||||
|
||||
|
||||
|
||||
bool what_if(goal_ref const & g, expr * e, func_decl * fd, const mpz & temp,
|
||||
double & best_score, mpz & best_value, unsigned i);
|
||||
|
||||
double find_best_move_local(goal_ref const & g, expr * e, func_decl * fd, mpz & best_value, unsigned i);
|
||||
|
||||
|
||||
lbool search(goal_ref const & g);
|
||||
|
||||
lbool operator()();
|
||||
void operator()(goal_ref const & g, model_converter_ref & mc);
|
||||
|
||||
protected:
|
||||
void checkpoint();
|
||||
lbool search_old(goal_ref const & g);
|
||||
double get_restart_armin(unsigned cnt_restarts);
|
||||
|
||||
bool what_if(func_decl * fd, const unsigned & fd_inx, const mpz & temp,
|
||||
bool what_if(goal_ref const & g, func_decl * fd, const unsigned & fd_inx, const mpz & temp,
|
||||
double & best_score, unsigned & best_const, mpz & best_value);
|
||||
bool what_if(expr * e, func_decl * fd, const mpz & temp,
|
||||
double & best_score, mpz & best_value, unsigned i);
|
||||
|
||||
bool what_if_new(goal_ref const & g, func_decl * fd, const unsigned & fd_inx, const mpz & temp,
|
||||
double & best_score, unsigned & best_const, mpz & best_value);
|
||||
double incremental_score_prune_new(goal_ref const & g, func_decl * fd, const mpz & new_value);
|
||||
|
||||
bool what_if_local(expr * e, func_decl * fd, const unsigned & fd_inx, const mpz & temp,
|
||||
double & best_score, unsigned & best_const, mpz & best_value);
|
||||
|
||||
double top_score();
|
||||
double rescore();
|
||||
double serious_score(func_decl * fd, const mpz & new_value);
|
||||
double incremental_score(func_decl * fd, const mpz & new_value);
|
||||
double top_score(goal_ref const & g);
|
||||
double rescore(goal_ref const & g);
|
||||
double serious_score(goal_ref const & g, func_decl * fd, const mpz & new_value);
|
||||
double incremental_score(goal_ref const & g, func_decl * fd, const mpz & new_value);
|
||||
|
||||
#if _EARLY_PRUNE_
|
||||
double incremental_score_prune(func_decl * fd, const mpz & new_value);
|
||||
double incremental_score_prune(goal_ref const & g, func_decl * fd, const mpz & new_value);
|
||||
#endif
|
||||
double find_best_move(ptr_vector<func_decl> & to_evaluate, double score,
|
||||
unsigned & best_const, mpz & best_value, unsigned & new_bit, move_type & move);
|
||||
double find_best_move_local(expr * e, func_decl * fd, mpz & best_value, unsigned i);
|
||||
double find_best_move_local(expr * e, ptr_vector<func_decl> & to_evaluate,
|
||||
unsigned & best_const, mpz & best_value, unsigned & new_bit, move_type & move);
|
||||
double find_best_move_vns(ptr_vector<func_decl> & to_evaluate, double score,
|
||||
unsigned & best_const, mpz & best_value, unsigned & new_bit, move_type & move);
|
||||
void mk_random_move(ptr_vector<func_decl> & unsat_constants);
|
||||
void mk_random_move();
|
||||
|
||||
bool handle_plateau(void);
|
||||
bool handle_plateau(double old_score);
|
||||
double find_best_move_vns(goal_ref const & g, ptr_vector<func_decl> & to_evaluate, double score,
|
||||
unsigned & best_const, mpz & best_value, unsigned & new_bit, move_type & move);
|
||||
|
||||
void mk_random_move(ptr_vector<func_decl> & unsat_constants);
|
||||
void mk_random_move(goal_ref const & g);
|
||||
|
||||
bool handle_plateau(goal_ref const & g);
|
||||
bool handle_plateau(goal_ref const & g, double old_score);
|
||||
|
||||
inline unsigned check_restart(unsigned curr_value);
|
||||
};
|
||||
|
||||
#endif
|
||||
#endif
|
|
@ -575,7 +575,7 @@ public:
|
|||
#if _CACHE_TOP_SCORE_
|
||||
//if (!m_tracker.has_uplinks(cur))
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(new_score, m_tracker.get_score(cur));
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
#endif
|
||||
m_tracker.set_score(cur, new_score);
|
||||
m_tracker.set_score_prune(cur, new_score);
|
||||
|
@ -584,12 +584,13 @@ public:
|
|||
new_score = m_tracker.score(cur);
|
||||
//if (!m_tracker.has_uplinks(cur))
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(new_score, m_tracker.get_score(cur));
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
m_tracker.set_score(cur, new_score);
|
||||
#else
|
||||
m_tracker.set_score(cur, m_tracker.score(cur));
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if (m_tracker.has_uplinks(cur)) {
|
||||
ptr_vector<expr> & ups = m_tracker.get_uplinks(cur);
|
||||
for (unsigned j = 0; j < ups.size(); j++) {
|
||||
|
@ -634,7 +635,7 @@ public:
|
|||
#if _CACHE_TOP_SCORE_
|
||||
//if (!m_tracker.has_uplinks(cur))
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(new_score, m_tracker.get_score(cur));
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
#endif
|
||||
m_tracker.set_score(cur, new_score);
|
||||
m_tracker.set_score_prune(cur, new_score);
|
||||
|
@ -643,12 +644,12 @@ public:
|
|||
new_score = m_tracker.score(cur);
|
||||
//if (!m_tracker.has_uplinks(cur))
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(new_score, m_tracker.get_score(cur));
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
m_tracker.set_score(cur, new_score);
|
||||
#else
|
||||
m_tracker.set_score(cur, m_tracker.score(cur));
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
if (m_tracker.has_uplinks(cur)) {
|
||||
ptr_vector<expr> & ups = m_tracker.get_uplinks(cur);
|
||||
for (unsigned j = 0; j < ups.size(); j++) {
|
||||
|
@ -683,7 +684,7 @@ public:
|
|||
m_traversal_stack[cur_depth].push_back(ep);
|
||||
if (cur_depth > max_depth) max_depth = cur_depth;
|
||||
}
|
||||
#if _REAL_RS_ || _REAL_PBFS_
|
||||
#if _REAL_RS_ || _REAL_PBFS_ || _PAWS_
|
||||
run_serious_update(max_depth);
|
||||
#else
|
||||
run_update(max_depth);
|
||||
|
@ -729,14 +730,16 @@ public:
|
|||
#if _CACHE_TOP_SCORE_
|
||||
//if (!m_tracker.has_uplinks(cur))
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(new_score, m_tracker.get_score(cur));
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
#endif
|
||||
prune_score = m_tracker.get_score_prune(cur);
|
||||
m_tracker.set_score(cur, new_score);
|
||||
|
||||
if ((new_score > prune_score) && (m_tracker.has_pos_occ(cur)))
|
||||
//if ((new_score >= prune_score) && (m_tracker.has_pos_occ(cur)))
|
||||
pot_benefits = 1;
|
||||
if ((new_score <= prune_score) && (m_tracker.has_neg_occ(cur)))
|
||||
//if ((new_score < prune_score) && (m_tracker.has_neg_occ(cur)))
|
||||
pot_benefits = 1;
|
||||
|
||||
if (m_tracker.has_uplinks(cur)) {
|
||||
|
@ -771,7 +774,7 @@ public:
|
|||
new_score = m_tracker.score(cur);
|
||||
//if (!m_tracker.has_uplinks(cur))
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(new_score, m_tracker.get_score(cur));
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
m_tracker.set_score(cur, new_score);
|
||||
#else
|
||||
m_tracker.set_score(cur, m_tracker.score(cur));
|
||||
|
@ -858,6 +861,104 @@ public:
|
|||
}
|
||||
#endif
|
||||
|
||||
unsigned run_update_bool_prune_new(unsigned cur_depth) {
|
||||
expr_fast_mark1 visited;
|
||||
|
||||
double prune_score, new_score;
|
||||
unsigned pot_benefits = 0;
|
||||
SASSERT(cur_depth < m_traversal_stack_bool.size());
|
||||
|
||||
ptr_vector<expr> & cur_depth_exprs = m_traversal_stack_bool[cur_depth];
|
||||
|
||||
for (unsigned i = 0; i < cur_depth_exprs.size(); i++) {
|
||||
expr * cur = cur_depth_exprs[i];
|
||||
|
||||
new_score = m_tracker.score(cur);
|
||||
//if (!m_tracker.has_uplinks(cur))
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
prune_score = m_tracker.get_score_prune(cur);
|
||||
m_tracker.set_score(cur, new_score);
|
||||
|
||||
if ((new_score >= prune_score) && (m_tracker.has_pos_occ(cur)))
|
||||
pot_benefits = 1;
|
||||
if ((new_score < prune_score) && (m_tracker.has_neg_occ(cur)))
|
||||
pot_benefits = 1;
|
||||
|
||||
if (m_tracker.has_uplinks(cur)) {
|
||||
ptr_vector<expr> & ups = m_tracker.get_uplinks(cur);
|
||||
for (unsigned j = 0; j < ups.size(); j++) {
|
||||
expr * next = ups[j];
|
||||
unsigned next_d = m_tracker.get_distance(next);
|
||||
SASSERT(next_d < cur_depth);
|
||||
if (!visited.is_marked(next)) {
|
||||
m_traversal_stack_bool[next_d].push_back(next);
|
||||
visited.mark(next);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
cur_depth_exprs.reset();
|
||||
cur_depth--;
|
||||
|
||||
while (cur_depth != static_cast<unsigned>(-1)) {
|
||||
ptr_vector<expr> & cur_depth_exprs = m_traversal_stack_bool[cur_depth];
|
||||
if (pot_benefits)
|
||||
{
|
||||
unsigned cur_size = cur_depth_exprs.size();
|
||||
for (unsigned i = 0; i < cur_size; i++) {
|
||||
expr * cur = cur_depth_exprs[i];
|
||||
|
||||
new_score = m_tracker.score(cur);
|
||||
//if (!m_tracker.has_uplinks(cur))
|
||||
if (m_tracker.is_top_expr(cur))
|
||||
m_tracker.adapt_top_sum(cur, new_score, m_tracker.get_score(cur));
|
||||
m_tracker.set_score(cur, new_score);
|
||||
if (m_tracker.has_uplinks(cur)) {
|
||||
ptr_vector<expr> & ups = m_tracker.get_uplinks(cur);
|
||||
for (unsigned j = 0; j < ups.size(); j++) {
|
||||
expr * next = ups[j];
|
||||
unsigned next_d = m_tracker.get_distance(next);
|
||||
SASSERT(next_d < cur_depth);
|
||||
if (!visited.is_marked(next)) {
|
||||
m_traversal_stack_bool[next_d].push_back(next);
|
||||
visited.mark(next);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
cur_depth_exprs.reset();
|
||||
cur_depth--;
|
||||
}
|
||||
|
||||
return pot_benefits;
|
||||
}
|
||||
|
||||
unsigned update_prune_new(func_decl * fd, const mpz & new_value) {
|
||||
m_tracker.set_value(fd, new_value);
|
||||
expr * ep = m_tracker.get_entry_point(fd);
|
||||
unsigned cur_depth = m_tracker.get_distance(ep);
|
||||
|
||||
if (m_traversal_stack_bool.size() <= cur_depth)
|
||||
m_traversal_stack_bool.resize(cur_depth+1);
|
||||
if (m_traversal_stack.size() <= cur_depth)
|
||||
m_traversal_stack.resize(cur_depth+1);
|
||||
|
||||
if (m_manager.is_bool(ep))
|
||||
m_traversal_stack_bool[cur_depth].push_back(ep);
|
||||
else
|
||||
{
|
||||
m_traversal_stack[cur_depth].push_back(ep);
|
||||
run_update_prune(cur_depth);
|
||||
}
|
||||
return run_update_bool_prune_new(cur_depth);
|
||||
}
|
||||
|
||||
void randomize_local(ptr_vector<func_decl> & unsat_constants) {
|
||||
// Randomize _all_ candidates:
|
||||
|
||||
|
@ -901,7 +1002,7 @@ public:
|
|||
mpz temp = m_tracker.get_random(fd->get_range());
|
||||
#endif
|
||||
|
||||
#if _REAL_RS_ || _REAL_PBFS_
|
||||
#if _REAL_RS_ || _REAL_PBFS_ || _PAWS_
|
||||
serious_update(fd, temp);
|
||||
#else
|
||||
update(fd, temp);
|
||||
|
@ -922,9 +1023,36 @@ public:
|
|||
randomize_local(m_tracker.get_constants(e));
|
||||
}
|
||||
|
||||
void randomize_local(ptr_vector<expr> const & as, unsigned int flip) {
|
||||
randomize_local(m_tracker.get_unsat_constants(as, flip));
|
||||
void randomize_local(goal_ref const & g, unsigned int flip) {
|
||||
randomize_local(m_tracker.get_unsat_constants(g, flip));
|
||||
}
|
||||
|
||||
void randomize_local_n(goal_ref const & g, ptr_vector<func_decl> & unsat_constants) {
|
||||
unsigned r = m_tracker.get_random_uint(16) % unsat_constants.size();
|
||||
func_decl * fd = unsat_constants[r];
|
||||
sort * srt = fd->get_range();
|
||||
unsigned bv_sz = m_manager.is_bool(srt) ? 1 : m_bv_util.get_bv_size(srt);
|
||||
mpz max_val = m_tracker.get_random(srt);
|
||||
update(fd, max_val);
|
||||
double max_score = m_tracker.get_top_sum() / g->size();
|
||||
mpz temp_val;
|
||||
double temp_score;
|
||||
for (unsigned i = 1; i < 2; i++)
|
||||
//for (unsigned i = 1; i < bv_sz; i++)
|
||||
{
|
||||
m_mpz_manager.set(temp_val, m_tracker.get_random(srt));
|
||||
update(fd, temp_val);
|
||||
temp_score = m_tracker.get_top_sum() / g->size();
|
||||
if (temp_score > max_score)
|
||||
{
|
||||
m_mpz_manager.set(max_val, temp_val);
|
||||
max_score = temp_score;
|
||||
}
|
||||
}
|
||||
update(fd, max_val);
|
||||
m_mpz_manager.del(temp_val);
|
||||
m_mpz_manager.del(max_val);
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
|
@ -1509,14 +1509,14 @@ tactic * mk_preamble(ast_manager & m, params_ref const & p) {
|
|||
mk_max_bv_sharing_tactic(m),
|
||||
// Andreas: It would be cool to get rid of shared top level assertions but which simplification is doing this?
|
||||
//mk_ctx_simplify_tactic(m, ctx_p),
|
||||
// Andreas: This one at least eliminates top level duplicates ...
|
||||
// Andreas: This one at least eliminates top level duplicates ... but has very bad effects on performance!
|
||||
//mk_simplify_tactic(m),
|
||||
// Andreas: How does a NNF actually look like? Can it contain ITE operators?
|
||||
mk_nnf_tactic(m, p));
|
||||
}
|
||||
|
||||
tactic * mk_qfbv_sls_tactic(ast_manager & m, params_ref const & p) {
|
||||
tactic * t = and_then(mk_preamble(m, p), mk_sls_tactic(m));
|
||||
// tactic * t = and_then(mk_simplify_tactic(m), mk_nnf_tactic(m, p), mk_sls_tactic(m));
|
||||
t->updt_params(p);
|
||||
return t;
|
||||
}
|
||||
|
|
|
@ -20,9 +20,7 @@ Notes:
|
|||
#ifndef _SLS_TRACKER_H_
|
||||
#define _SLS_TRACKER_H_
|
||||
|
||||
#include"for_each_expr.h"
|
||||
#include"ast_smt2_pp.h"
|
||||
#include"bv_decl_plugin.h"
|
||||
#include"goal.h"
|
||||
#include"model.h"
|
||||
|
||||
#include"sls_compilation_settings.h"
|
||||
|
@ -88,12 +86,17 @@ private:
|
|||
obj_map<expr, unsigned> m_where_false;
|
||||
expr** m_list_false;
|
||||
#endif
|
||||
#if _PAWS_
|
||||
obj_map<expr, unsigned> m_weights;
|
||||
//obj_map<expr, double> m_weights;
|
||||
#endif
|
||||
#if _CACHE_TOP_SCORE_
|
||||
double m_top_sum;
|
||||
#endif
|
||||
#if _WEIGHT_DIST_ == 4 || _WEIGHT_TOGGLE_
|
||||
double m_weight_dist_factor;
|
||||
#endif
|
||||
unsigned m_equal_scores;
|
||||
|
||||
public:
|
||||
sls_tracker(ast_manager & m, bv_util & bvu, unsynch_mpz_manager & mm, powers & p) :
|
||||
|
@ -113,15 +116,52 @@ public:
|
|||
m_mpz_manager.del(m_two);
|
||||
}
|
||||
|
||||
unsigned get_formula_size() {
|
||||
return m_scores.size();
|
||||
}
|
||||
|
||||
double get_avg_bw(goal_ref const & g) {
|
||||
double sum = 0.0;
|
||||
unsigned count = 0;
|
||||
|
||||
for (unsigned i = 0; i < g->size(); i++)
|
||||
{
|
||||
m_temp_constants.reset();
|
||||
ptr_vector<func_decl> const & this_decls = m_constants_occ.find(g->form(i));
|
||||
unsigned sz = this_decls.size();
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
func_decl * fd = this_decls[i];
|
||||
m_temp_constants.push_back(fd);
|
||||
sort * srt = fd->get_range();
|
||||
sum += (m_manager.is_bool(srt)) ? 1 : m_bv_util.get_bv_size(srt);
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
||||
return sum / count;
|
||||
}
|
||||
|
||||
#if _WEIGHT_DIST_ == 4 || _WEIGHT_TOGGLE_
|
||||
inline void set_weight_dist_factor(double val) {
|
||||
m_weight_dist_factor = val;
|
||||
}
|
||||
#endif
|
||||
|
||||
void reset_equal_scores() {
|
||||
m_equal_scores = 1;
|
||||
}
|
||||
|
||||
unsigned inc_equal_scores() {
|
||||
return ++m_equal_scores;
|
||||
}
|
||||
|
||||
#if _CACHE_TOP_SCORE_
|
||||
inline void adapt_top_sum(double add, double sub) {
|
||||
inline void adapt_top_sum(expr * e, double add, double sub) {
|
||||
#if _PAWS_
|
||||
m_top_sum += m_weights.find(e) * (add - sub);
|
||||
#else
|
||||
m_top_sum += add - sub;
|
||||
#endif
|
||||
}
|
||||
|
||||
inline void set_top_sum(double new_score) {
|
||||
|
@ -278,19 +318,21 @@ public:
|
|||
}
|
||||
#endif
|
||||
|
||||
void uct_forget(ptr_vector<expr> & as) {
|
||||
#if _UCT_
|
||||
void uct_forget(goal_ref const & g) {
|
||||
expr * e;
|
||||
unsigned touched_old, touched_new;
|
||||
|
||||
for (unsigned i = 0; i < as.size(); i++)
|
||||
for (unsigned i = 0; i < g->size(); i++)
|
||||
{
|
||||
e = as[i];
|
||||
e = g->form(i);
|
||||
touched_old = m_scores.find(e).touched;
|
||||
touched_new = (unsigned)((touched_old - 1) * _UCT_FORGET_FACTOR_ + 1);
|
||||
m_scores.find(e).touched = touched_new;
|
||||
m_touched += touched_new - touched_old;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
void initialize(app * n) {
|
||||
// Build score table
|
||||
|
@ -367,12 +409,12 @@ public:
|
|||
}
|
||||
};
|
||||
|
||||
void calculate_expr_distances(ptr_vector<expr> const & as) {
|
||||
void calculate_expr_distances(goal_ref const & g) {
|
||||
// precondition: m_scores is set up.
|
||||
unsigned sz = as.size();
|
||||
unsigned sz = g->size();
|
||||
ptr_vector<app> stack;
|
||||
for (unsigned i = 0; i < sz; i++)
|
||||
stack.push_back(to_app(as[i]));
|
||||
stack.push_back(to_app(g->form(i)));
|
||||
while (!stack.empty()) {
|
||||
app * cur = stack.back();
|
||||
stack.pop_back();
|
||||
|
@ -420,12 +462,12 @@ public:
|
|||
quick_for_each_expr(ffd_proc, visited, e);
|
||||
}
|
||||
|
||||
void initialize(ptr_vector<expr> const & as) {
|
||||
void initialize(goal_ref const & g) {
|
||||
init_proc proc(m_manager, *this);
|
||||
expr_mark visited;
|
||||
unsigned sz = as.size();
|
||||
unsigned sz = g->size();
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
expr * e = as[i];
|
||||
expr * e = g->form(i);
|
||||
if (!m_top_expr.contains(e))
|
||||
m_top_expr.insert(e);
|
||||
else
|
||||
|
@ -440,7 +482,7 @@ public:
|
|||
visited.reset();
|
||||
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
expr * e = as[i];
|
||||
expr * e = g->form(i);
|
||||
// Andreas: Maybe not fully correct.
|
||||
#if _FOCUS_ == 2 || _INTENSIFICATION_
|
||||
initialize_recursive(e);
|
||||
|
@ -452,7 +494,7 @@ public:
|
|||
quick_for_each_expr(ffd_proc, visited, e);
|
||||
}
|
||||
|
||||
calculate_expr_distances(as);
|
||||
calculate_expr_distances(g);
|
||||
|
||||
TRACE("sls", tout << "Initial model:" << std::endl; show_model(tout); );
|
||||
|
||||
|
@ -465,16 +507,49 @@ public:
|
|||
//}
|
||||
#endif
|
||||
|
||||
#if _PAWS_
|
||||
for (unsigned i = 0; i < sz; i++)
|
||||
{
|
||||
expr * e = g->form(i);
|
||||
if (!m_weights.contains(e))
|
||||
m_weights.insert(e, _PAWS_INIT_);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if _EARLY_PRUNE_
|
||||
for (unsigned i = 0; i < sz; i++)
|
||||
setup_occs(as[i]);
|
||||
setup_occs(g->form(i));
|
||||
#endif
|
||||
|
||||
#if _UCT_
|
||||
m_touched = _UCT_INIT_ ? as.size() : 1;
|
||||
m_touched = _UCT_INIT_ ? g->size() : 1;
|
||||
#endif
|
||||
}
|
||||
|
||||
#if _PAWS_
|
||||
void increase_weight(expr * e)
|
||||
{
|
||||
//printf("Increasing %d to", m_weights.find(e));
|
||||
m_weights.find(e)++;
|
||||
//m_weights.find(e) *= 1.1;
|
||||
//printf(" %d\n", m_weights.find(e));
|
||||
}
|
||||
|
||||
void decrease_weight(expr * e)
|
||||
{
|
||||
unsigned old_weight = m_weights.find(e);
|
||||
m_weights.find(e) = old_weight > _PAWS_INIT_ ? old_weight - 1 : _PAWS_INIT_;
|
||||
//m_weights.find(e) = old_weight > 1.1 ? old_weight / 1.1 : 1;
|
||||
//printf("Decreasing %d to %d\n", old_weight, m_weights.find(e));
|
||||
}
|
||||
|
||||
unsigned get_weight(expr * e)
|
||||
//double get_weight(expr * e)
|
||||
{
|
||||
return m_weights.find(e);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if _REAL_RS_ || _REAL_PBFS_
|
||||
void make_assertion(expr * e)
|
||||
{
|
||||
|
@ -608,7 +683,7 @@ public:
|
|||
NOT_IMPLEMENTED_YET(); // This only works for bit-vectors for now.
|
||||
}
|
||||
|
||||
void randomize(ptr_vector<expr> const & as) {
|
||||
void randomize(goal_ref const & g) {
|
||||
TRACE("sls", tout << "Abandoned model:" << std::endl; show_model(tout); );
|
||||
|
||||
for (entry_point_type::iterator it = m_entry_points.begin(); it != m_entry_points.end(); it++) {
|
||||
|
@ -622,13 +697,13 @@ public:
|
|||
TRACE("sls", tout << "Randomized model:" << std::endl; show_model(tout); );
|
||||
|
||||
#if _UCT_RESET_
|
||||
m_touched = _UCT_INIT_ ? as.size() : 1;
|
||||
for (unsigned i = 0; i < as.size(); i++)
|
||||
m_scores.find(as[i]).touched = 1;
|
||||
m_touched = _UCT_INIT_ ? g->size() : 1;
|
||||
for (unsigned i = 0; i < g->size(); i++)
|
||||
m_scores.find(g->form(i)).touched = 1;
|
||||
#endif
|
||||
}
|
||||
|
||||
void reset(ptr_vector<expr> const & as) {
|
||||
void reset(goal_ref const & g) {
|
||||
TRACE("sls", tout << "Abandoned model:" << std::endl; show_model(tout); );
|
||||
|
||||
for (entry_point_type::iterator it = m_entry_points.begin(); it != m_entry_points.end(); it++) {
|
||||
|
@ -638,9 +713,9 @@ public:
|
|||
}
|
||||
|
||||
#if _UCT_RESET_
|
||||
m_touched = _UCT_INIT_ ? as.size() : 1;
|
||||
for (unsigned i = 0; i < as.size(); i++)
|
||||
m_scores.find(as[i]).touched = 1;
|
||||
m_touched = _UCT_INIT_ ? g->size() : 1;
|
||||
for (unsigned i = 0; i < g->size(); i++)
|
||||
m_scores.find(g->form(i)).touched = 1;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -765,6 +840,7 @@ public:
|
|||
const mpz & v1 = get_value(arg1);
|
||||
|
||||
if (negated) {
|
||||
//res = (m_mpz_manager.eq(v0, v1)) ? 0.5 * (m_bv_util.get_bv_size(arg0) - 1.0) / m_bv_util.get_bv_size(arg0) : 1.0;
|
||||
res = (m_mpz_manager.eq(v0, v1)) ? 0.0 : 1.0;
|
||||
TRACE("sls_score", tout << "V0 = " << m_mpz_manager.to_string(v0) << " ; V1 = " <<
|
||||
m_mpz_manager.to_string(v1) << std::endl; );
|
||||
|
@ -811,40 +887,209 @@ public:
|
|||
SASSERT(a->get_num_args() == 2);
|
||||
const mpz & x = get_value(a->get_arg(0));
|
||||
const mpz & y = get_value(a->get_arg(1));
|
||||
unsigned bv_sz = m_bv_util.get_bv_size(a->get_decl()->get_domain()[0]);
|
||||
int bv_sz = m_bv_util.get_bv_size(a->get_decl()->get_domain()[0]);
|
||||
|
||||
if (negated) {
|
||||
if (m_mpz_manager.gt(x, y))
|
||||
{
|
||||
/*mpz diff;
|
||||
m_mpz_manager.sub(x, y, diff);
|
||||
m_mpz_manager.inc(diff);
|
||||
rational n(diff);
|
||||
n /= rational(m_powers(bv_sz));
|
||||
double dbl = n.get_double();
|
||||
// In extreme cases, n is 0.9999 but to_double returns something > 1.0
|
||||
m_mpz_manager.del(diff);
|
||||
res = 1.0 + 0.5 * dbl;*/
|
||||
res = 1.0;
|
||||
}
|
||||
else {
|
||||
//res = (bv_sz - 1.0) / bv_sz;
|
||||
/* mpz x_copy, y_copy;
|
||||
m_mpz_manager.set(x_copy, x);
|
||||
m_mpz_manager.set(y_copy, y);
|
||||
unsigned lower_gt = 0;
|
||||
unsigned curr_gt = 0;
|
||||
int last_pos = -1;
|
||||
for (int i = 0; i < bv_sz; i++)
|
||||
{
|
||||
if (m_mpz_manager.is_odd(x_copy) && m_mpz_manager.is_even(y_copy))
|
||||
{
|
||||
lower_gt = curr_gt;
|
||||
curr_gt = 1;
|
||||
last_pos = i;
|
||||
}
|
||||
else if (m_mpz_manager.is_even(x_copy) && m_mpz_manager.is_odd(y_copy))
|
||||
{
|
||||
lower_gt = curr_gt;
|
||||
curr_gt = 0;
|
||||
last_pos = i;
|
||||
}
|
||||
|
||||
m_mpz_manager.machine_div(x_copy, m_two, x_copy);
|
||||
m_mpz_manager.machine_div(y_copy, m_two, y_copy);
|
||||
}
|
||||
|
||||
res = (double)(bv_sz - last_pos - 1 + 2 * lower_gt) / (double)(bv_sz + 2);
|
||||
m_mpz_manager.del(x_copy);
|
||||
m_mpz_manager.del(y_copy);*/
|
||||
#if 1
|
||||
mpz diff;
|
||||
m_mpz_manager.sub(y, x, diff);
|
||||
m_mpz_manager.inc(diff);
|
||||
rational n(diff);
|
||||
n /= rational(m_powers(bv_sz));
|
||||
double dbl = 1.0 - n.get_double();
|
||||
// In extreme cases, n is 0.9999 but to_double returns something > 1.0
|
||||
res = (dbl > 1.0) ? 1.0 : (dbl < 0.0) ? 0.0 : dbl;
|
||||
//res = (dbl > 1.0) ? 0.0 : (dbl < 0.0) ? 1.0 : 1.0 - dbl;
|
||||
m_mpz_manager.del(diff);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (m_mpz_manager.le(x, y))
|
||||
{
|
||||
/*mpz diff;
|
||||
m_mpz_manager.sub(y, x, diff);
|
||||
m_mpz_manager.inc(diff);
|
||||
rational n(diff);
|
||||
n /= rational(m_powers(bv_sz));
|
||||
double dbl = n.get_double();
|
||||
// In extreme cases, n is 0.9999 but to_double returns something > 1.0
|
||||
res = (dbl > 1.0) ? 0.0 : (dbl < 0.0) ? 1.0 : 1.0 - dbl;
|
||||
m_mpz_manager.del(diff);
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (m_mpz_manager.le(x, y))
|
||||
res = 1.0 + 0.5 * dbl;*/
|
||||
res = 1.0;
|
||||
}
|
||||
else {
|
||||
//res = (bv_sz - 1.0) / bv_sz;
|
||||
/* mpz x_copy, y_copy;
|
||||
m_mpz_manager.set(x_copy, x);
|
||||
m_mpz_manager.set(y_copy, y);
|
||||
unsigned lower_le = 1;
|
||||
unsigned curr_le = 1;
|
||||
int last_pos = -1;
|
||||
for (int i = 0; i < bv_sz; i++)
|
||||
{
|
||||
if (m_mpz_manager.is_odd(x_copy) && m_mpz_manager.is_even(y_copy))
|
||||
{
|
||||
lower_le = curr_le;
|
||||
curr_le = 0;
|
||||
last_pos = i;
|
||||
}
|
||||
else if (m_mpz_manager.is_even(x_copy) && m_mpz_manager.is_odd(y_copy))
|
||||
{
|
||||
lower_le = curr_le;
|
||||
curr_le = 1;
|
||||
last_pos = i;
|
||||
}
|
||||
|
||||
m_mpz_manager.machine_div(x_copy, m_two, x_copy);
|
||||
m_mpz_manager.machine_div(y_copy, m_two, y_copy);
|
||||
}
|
||||
|
||||
res = (double)(bv_sz - last_pos - 1 + 2 * lower_le) / (double)(bv_sz + 2);*/
|
||||
#if 1
|
||||
mpz diff;
|
||||
m_mpz_manager.sub(x, y, diff);
|
||||
rational n(diff);
|
||||
n /= rational(m_powers(bv_sz));
|
||||
double dbl = n.get_double();
|
||||
double dbl = 1.0 - n.get_double();
|
||||
res = (dbl > 1.0) ? 1.0 : (dbl < 0.0) ? 0.0 : dbl;
|
||||
m_mpz_manager.del(diff);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
TRACE("sls_score", tout << "x = " << m_mpz_manager.to_string(x) << " ; y = " <<
|
||||
m_mpz_manager.to_string(y) << " ; SZ = " << bv_sz << std::endl; );
|
||||
}
|
||||
else if (m_bv_util.is_bv_sle(n)) { // x <= y
|
||||
/* else if (m_bv_util.is_bv_sle(n)) { // x <= y
|
||||
app * a = to_app(n);
|
||||
SASSERT(a->get_num_args() == 2);
|
||||
const mpz & x = get_value(a->get_arg(0));
|
||||
const mpz & y = get_value(a->get_arg(1));
|
||||
int bv_sz = m_bv_util.get_bv_size(a->get_decl()->get_domain()[0]);
|
||||
|
||||
mpz x_unsigned;
|
||||
mpz y_unsigned;
|
||||
const mpz & p = m_powers(bv_sz);
|
||||
const mpz & p_half = m_powers(bv_sz-1);
|
||||
if (x >= p_half) { m_mpz_manager.sub(x, p, x_unsigned); }
|
||||
if (y >= p_half) { m_mpz_manager.sub(y, p, y_unsigned); }
|
||||
|
||||
if (negated) {
|
||||
if (x_unsigned > y_unsigned)
|
||||
res = 1.0;
|
||||
else {
|
||||
mpz x_copy, y_copy;
|
||||
m_mpz_manager.set(x_copy, x);
|
||||
m_mpz_manager.set(y_copy, y);
|
||||
unsigned lower_gt = 0;
|
||||
unsigned curr_gt = 0;
|
||||
int last_pos = -1;
|
||||
for (int i = 0; i < bv_sz; i++)
|
||||
{
|
||||
if (m_mpz_manager.is_odd(x_copy) && m_mpz_manager.is_even(y_copy))
|
||||
{
|
||||
lower_gt = curr_gt;
|
||||
curr_gt = 1;
|
||||
last_pos = i;
|
||||
}
|
||||
else if (m_mpz_manager.is_even(x_copy) && m_mpz_manager.is_odd(y_copy))
|
||||
{
|
||||
lower_gt = curr_gt;
|
||||
curr_gt = 0;
|
||||
last_pos = i;
|
||||
}
|
||||
|
||||
m_mpz_manager.machine_div(x_copy, m_two, x_copy);
|
||||
m_mpz_manager.machine_div(y_copy, m_two, y_copy);
|
||||
}
|
||||
|
||||
res = (double)(bv_sz - last_pos - 1 + 2 * lower_gt) / (double)(bv_sz + 2);
|
||||
m_mpz_manager.del(x_copy);
|
||||
m_mpz_manager.del(y_copy);
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (x_unsigned <= y_unsigned)
|
||||
res = 1.0;
|
||||
else {
|
||||
mpz x_copy, y_copy;
|
||||
m_mpz_manager.set(x_copy, x);
|
||||
m_mpz_manager.set(y_copy, y);
|
||||
unsigned lower_le = 1;
|
||||
unsigned curr_le = 1;
|
||||
int last_pos = -1;
|
||||
for (int i = 0; i < bv_sz; i++)
|
||||
{
|
||||
if (m_mpz_manager.is_odd(x_copy) && m_mpz_manager.is_even(y_copy))
|
||||
{
|
||||
lower_le = curr_le;
|
||||
curr_le = 0;
|
||||
last_pos = i;
|
||||
}
|
||||
else if (m_mpz_manager.is_even(x_copy) && m_mpz_manager.is_odd(y_copy))
|
||||
{
|
||||
lower_le = curr_le;
|
||||
curr_le = 1;
|
||||
last_pos = i;
|
||||
}
|
||||
|
||||
m_mpz_manager.machine_div(x_copy, m_two, x_copy);
|
||||
m_mpz_manager.machine_div(y_copy, m_two, y_copy);
|
||||
}
|
||||
|
||||
res = (double)(bv_sz - last_pos - 1 + 2 * lower_le) / (double)(bv_sz + 2);
|
||||
}
|
||||
}
|
||||
TRACE("sls_score", tout << "x = " << m_mpz_manager.to_string(x) << " ; y = " <<
|
||||
m_mpz_manager.to_string(y) << " ; SZ = " << bv_sz << std::endl; );
|
||||
|
||||
m_mpz_manager.del(x_unsigned);
|
||||
m_mpz_manager.del(y_unsigned);
|
||||
}*/
|
||||
else if (m_bv_util.is_bv_sle(n)) { // x <= y
|
||||
app * a = to_app(n);
|
||||
SASSERT(a->get_num_args() == 2);
|
||||
mpz x; m_mpz_manager.set(x, get_value(a->get_arg(0)));
|
||||
|
@ -857,31 +1102,61 @@ public:
|
|||
|
||||
if (negated) {
|
||||
if (x > y)
|
||||
res = 1.0;
|
||||
{
|
||||
/*mpz diff;
|
||||
m_mpz_manager.sub(x, y, diff);
|
||||
m_mpz_manager.inc(diff);
|
||||
rational n(diff);
|
||||
n /= rational(m_powers(bv_sz));
|
||||
double dbl = n.get_double();
|
||||
// In extreme cases, n is 0.9999 but to_double returns something > 1.0
|
||||
m_mpz_manager.del(diff);
|
||||
res = 1.0 + 0.5 * dbl;*/
|
||||
res = 1.0;
|
||||
}
|
||||
else {
|
||||
//res = (bv_sz - 1.0) / bv_sz;
|
||||
#if 1
|
||||
mpz diff;
|
||||
m_mpz_manager.sub(y, x, diff);
|
||||
m_mpz_manager.inc(diff);
|
||||
rational n(diff);
|
||||
n /= p;
|
||||
double dbl = n.get_double();
|
||||
res = (dbl > 1.0) ? 0.0 : (dbl < 0.0) ? 1.0 : 1.0 - dbl;
|
||||
double dbl = 1.0 - n.get_double();
|
||||
//res = (dbl > 1.0) ? 0.0 : (dbl < 0.0) ? 1.0 : 1.0 - dbl;
|
||||
res = (dbl > 1.0) ? 1.0 : (dbl < 0.0) ? 0.0 : dbl;
|
||||
m_mpz_manager.del(diff);
|
||||
#endif
|
||||
}
|
||||
TRACE("sls_score", tout << "x = " << m_mpz_manager.to_string(x) << " ; y = " <<
|
||||
m_mpz_manager.to_string(y) << " ; SZ = " << bv_sz << std::endl; );
|
||||
}
|
||||
else {
|
||||
if (x <= y)
|
||||
res = 1.0;
|
||||
{
|
||||
/*mpz diff;
|
||||
m_mpz_manager.sub(y, x, diff);
|
||||
m_mpz_manager.inc(diff);
|
||||
rational n(diff);
|
||||
n /= rational(m_powers(bv_sz));
|
||||
double dbl = n.get_double();
|
||||
// In extreme cases, n is 0.9999 but to_double returns something > 1.0
|
||||
m_mpz_manager.del(diff);
|
||||
res = 1.0 + 0.5 * dbl;*/
|
||||
res = 1.0;
|
||||
}
|
||||
else {
|
||||
//res = (bv_sz - 1.0) / bv_sz;
|
||||
#if 1
|
||||
mpz diff;
|
||||
m_mpz_manager.sub(x, y, diff);
|
||||
SASSERT(!m_mpz_manager.is_neg(diff));
|
||||
rational n(diff);
|
||||
n /= p;
|
||||
double dbl = n.get_double();
|
||||
double dbl = 1.0 - n.get_double();
|
||||
res = (dbl > 1.0) ? 1.0 : (dbl < 0.0) ? 0.0 : dbl;
|
||||
m_mpz_manager.del(diff);
|
||||
#endif
|
||||
}
|
||||
TRACE("sls_score", tout << "x = " << m_mpz_manager.to_string(x) << " ; y = " <<
|
||||
m_mpz_manager.to_string(y) << " ; SZ = " << bv_sz << std::endl; );
|
||||
|
@ -1031,13 +1306,13 @@ public:
|
|||
return m_temp_constants;
|
||||
}
|
||||
|
||||
ptr_vector<func_decl> & get_unsat_constants_gsat(ptr_vector<expr> const & as, unsigned sz) {
|
||||
ptr_vector<func_decl> & get_unsat_constants_gsat(goal_ref const & g, unsigned sz) {
|
||||
if (sz == 1)
|
||||
return get_constants();
|
||||
m_temp_constants.reset();
|
||||
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
expr * q = as[i];
|
||||
expr * q = g->form(i);
|
||||
if (m_mpz_manager.eq(get_value(q), m_one))
|
||||
continue;
|
||||
ptr_vector<func_decl> const & this_decls = m_constants_occ.find(q);
|
||||
|
@ -1051,22 +1326,22 @@ public:
|
|||
return m_temp_constants;
|
||||
}
|
||||
|
||||
expr * get_unsat_assertion(ptr_vector<expr> const & as, unsigned sz, unsigned int pos) {
|
||||
expr * get_unsat_assertion(goal_ref const & g, unsigned sz, unsigned int pos) {
|
||||
for (unsigned i = pos; i < sz; i++) {
|
||||
expr * q = as[i];
|
||||
expr * q = g->form(i);
|
||||
if (m_mpz_manager.neq(get_value(q), m_one))
|
||||
return q;
|
||||
}
|
||||
for (unsigned i = 0; i < pos; i++) {
|
||||
expr * q = as[i];
|
||||
expr * q = g->form(i);
|
||||
if (m_mpz_manager.neq(get_value(q), m_one))
|
||||
return q;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
ptr_vector<func_decl> & get_unsat_constants_walksat(ptr_vector<expr> const & as, unsigned sz, unsigned int pos) {
|
||||
expr * q = get_unsat_assertion(as, sz, pos);
|
||||
ptr_vector<func_decl> & get_unsat_constants_walksat(goal_ref const & g, unsigned sz, unsigned int pos) {
|
||||
expr * q = get_unsat_assertion(g, sz, pos);
|
||||
// Andreas: I should probably fix this. If this is the case then the formula is SAT anyway but this is not checked in the first iteration.
|
||||
if (!q)
|
||||
return m_temp_constants;
|
||||
|
@ -1143,20 +1418,66 @@ public:
|
|||
return m_temp_constants;
|
||||
}
|
||||
|
||||
ptr_vector<func_decl> & get_unsat_constants_crsat(ptr_vector<expr> const & as, unsigned sz, unsigned int pos) {
|
||||
expr * q = get_unsat_assertion(as, sz, pos);
|
||||
ptr_vector<func_decl> & get_unsat_constants_crsat(goal_ref const & g, unsigned sz, unsigned int pos) {
|
||||
expr * q = get_unsat_assertion(g, sz, pos);
|
||||
if (!q)
|
||||
return m_temp_constants;
|
||||
|
||||
return go_deeper(q);
|
||||
}
|
||||
|
||||
ptr_vector<func_decl> & get_unsat_constants(ptr_vector<expr> const & as, unsigned int flip) {
|
||||
unsigned sz = as.size();
|
||||
void go_deeper_only(expr * e) {
|
||||
//if (m_manager.is_bool(e)) {
|
||||
if (m_manager.is_and(e)) {
|
||||
app * a = to_app(e);
|
||||
expr * const * args = a->get_args();
|
||||
unsigned int sz = a->get_num_args();
|
||||
unsigned cnt_unsat = 0, pos = -1;
|
||||
for (unsigned int i = 0; i < sz; i++) {
|
||||
expr * q = args[i];
|
||||
if (m_mpz_manager.neq(get_value(q), m_one) && (get_random_uint(16) % ++cnt_unsat == 0)) pos = i;
|
||||
//if (m_mpz_manager.neq(get_value(q), m_one)) go_deeper(q);
|
||||
}
|
||||
go_deeper(args[pos]);
|
||||
}
|
||||
else if (m_manager.is_or(e)) {
|
||||
app * a = to_app(e);
|
||||
expr * const * args = a->get_args();
|
||||
unsigned int sz = a->get_num_args();
|
||||
for (unsigned int i = 0; i < sz; i++) {
|
||||
expr * q = args[i];
|
||||
go_deeper(q);
|
||||
}
|
||||
}
|
||||
//}
|
||||
else
|
||||
{
|
||||
ptr_vector<func_decl> const & this_decls = m_constants_occ.find(e);
|
||||
unsigned sz2 = this_decls.size();
|
||||
for (unsigned j = 0; j < sz2; j++) {
|
||||
func_decl * fd = this_decls[j];
|
||||
if (!m_temp_constants.contains(fd))
|
||||
m_temp_constants.push_back(fd);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ptr_vector<func_decl> & get_unsat_constants_only(expr * e) {
|
||||
if (e && !m_temp_constants.size())
|
||||
go_deeper_only(e);
|
||||
|
||||
return m_temp_constants;
|
||||
}
|
||||
|
||||
ptr_vector<func_decl> & get_unsat_constants(goal_ref const & g, unsigned int flip) {
|
||||
unsigned sz = g->size();
|
||||
|
||||
if (sz == 1) {
|
||||
if (m_mpz_manager.eq(get_value(as[0]), m_one))
|
||||
if (m_mpz_manager.eq(get_value(g->form(0)), m_one))
|
||||
{
|
||||
m_temp_constants.reset();
|
||||
return m_temp_constants;
|
||||
}
|
||||
else
|
||||
return get_constants();
|
||||
}
|
||||
|
@ -1169,11 +1490,12 @@ public:
|
|||
#if _PROBABILISTIC_UCT_
|
||||
double sum_score = 0.0;
|
||||
unsigned start_index = get_random_uint(16) % sz;
|
||||
|
||||
|
||||
for (unsigned i = start_index; i < sz; i++)
|
||||
{
|
||||
expr * e = g->form(i);
|
||||
vscore = m_scores.find(e);
|
||||
|
||||
#if _PROBABILISTIC_UCT_ == 2
|
||||
double q = vscore.score * vscore.score;
|
||||
#else
|
||||
|
@ -1203,7 +1525,7 @@ public:
|
|||
#else
|
||||
double max = -1.0;
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
expr * e = as[i];
|
||||
expr * e = g->form(i);
|
||||
// for (unsigned i = 0; i < m_where_false.size(); i++) {
|
||||
// expr * e = m_list_false[i];
|
||||
vscore = m_scores.find(e);
|
||||
|
@ -1221,12 +1543,12 @@ public:
|
|||
return m_temp_constants;
|
||||
|
||||
#if _UCT_ == 1 || _UCT_ == 3
|
||||
m_scores.find(as[pos]).touched++;
|
||||
m_scores.find(g->form(pos)).touched++;
|
||||
m_touched++;
|
||||
#elif _UCT_ == 2
|
||||
m_scores.find(as[pos]).touched = flip;
|
||||
m_scores.find(g->form(pos)).touched = flip;
|
||||
#endif
|
||||
expr * e = as[pos];
|
||||
expr * e = g->form(pos);
|
||||
// expr * e = m_list_false[pos];
|
||||
|
||||
#elif _BFS_ == 3
|
||||
|
@ -1304,12 +1626,15 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
expr * get_unsat_assertion(goal_ref const & g, unsigned int flip) {
|
||||
unsigned sz = g->size();
|
||||
|
||||
expr * get_unsat_assertion(ptr_vector<expr> const & as, unsigned int flip) {
|
||||
unsigned sz = as.size();
|
||||
|
||||
if (sz == 1)
|
||||
return as[0];
|
||||
if (sz == 1) {
|
||||
if (m_mpz_manager.eq(get_value(g->form(0)), m_zero))
|
||||
return g->form(0);
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
m_temp_constants.reset();
|
||||
#if _FOCUS_ == 1
|
||||
|
@ -1353,12 +1678,12 @@ public:
|
|||
#else
|
||||
double max = -1.0;
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
expr * e = as[i];
|
||||
expr * e = g->form(i);
|
||||
// for (unsigned i = 0; i < m_where_false.size(); i++) {
|
||||
// expr * e = m_list_false[i];
|
||||
vscore = m_scores.find(e);
|
||||
#if _UCT_ == 1
|
||||
double q = vscore.score + _UCT_CONSTANT_ * sqrt(log((double)m_touched) / vscore.touched);
|
||||
double q = vscore.score + _UCT_CONSTANT_ * sqrt(log((double)m_touched) / vscore.touched);
|
||||
#elif _UCT_ == 2
|
||||
double q = vscore.score + (_UCT_CONSTANT_ * (flip - vscore.touched)) / sz;
|
||||
#elif _UCT_ == 3
|
||||
|
@ -1371,13 +1696,13 @@ public:
|
|||
return 0;
|
||||
|
||||
#if _UCT_ == 1 || _UCT_ == 3
|
||||
m_scores.find(as[pos]).touched++;
|
||||
m_scores.find(g->form(pos)).touched++;
|
||||
m_touched++;
|
||||
#elif _UCT_ == 2
|
||||
m_scores.find(g->form(pos)).touched = flip;
|
||||
#endif
|
||||
// return m_list_false[pos];
|
||||
return as[pos];
|
||||
return g->form(pos);
|
||||
|
||||
#elif _BFS_ == 3
|
||||
unsigned int pos = -1;
|
||||
|
@ -1431,7 +1756,7 @@ public:
|
|||
unsigned int pos = get_random_uint(16) % sz;
|
||||
return get_unsat_assertion(g, sz, pos);
|
||||
#endif
|
||||
return as[pos];
|
||||
return g->form(pos);
|
||||
#elif _FOCUS_ == 2
|
||||
#if _BFS_
|
||||
unsigned int pos = flip % sz;
|
||||
|
@ -1441,6 +1766,23 @@ public:
|
|||
return get_unsat_constants_crsat(g, sz, pos);
|
||||
#endif
|
||||
}
|
||||
|
||||
expr * get_new_unsat_assertion(goal_ref const & g, expr * e) {
|
||||
unsigned sz = g->size();
|
||||
|
||||
if (sz == 1)
|
||||
return 0;
|
||||
|
||||
m_temp_constants.reset();
|
||||
|
||||
unsigned cnt_unsat = 0, pos = -1;
|
||||
for (unsigned i = 0; i < sz; i++)
|
||||
if (m_mpz_manager.neq(get_value(g->form(i)), m_one) && (get_random_uint(16) % ++cnt_unsat == 0) && (g->form(i) != e)) pos = i;
|
||||
|
||||
if (pos == static_cast<unsigned>(-1))
|
||||
return 0;
|
||||
return g->form(pos);
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
|
@ -28,6 +28,8 @@ Notes:
|
|||
#include"bv_size_reduction_tactic.h"
|
||||
#include"aig_tactic.h"
|
||||
#include"sat_tactic.h"
|
||||
//#include"nnf_tactic.h"
|
||||
//#include"sls_tactic.h"
|
||||
|
||||
#define MEMLIMIT 300
|
||||
|
||||
|
@ -93,6 +95,32 @@ tactic * mk_qfbv_tactic(ast_manager & m, params_ref const & p) {
|
|||
mk_sat_tactic(m));
|
||||
#endif
|
||||
|
||||
/* use full sls
|
||||
tactic * st = using_params(and_then(preamble_st,
|
||||
cond(mk_is_qfbv_probe(),
|
||||
cond(mk_is_qfbv_eq_probe(),
|
||||
and_then(mk_bv1_blaster_tactic(m),
|
||||
using_params(mk_smt_tactic(), solver_p)),
|
||||
and_then(mk_nnf_tactic(m, p), mk_sls_tactic(m))),
|
||||
mk_smt_tactic())),
|
||||
main_p);*/
|
||||
|
||||
/* use pure dpll
|
||||
tactic * st = using_params(and_then(mk_simplify_tactic(m),
|
||||
cond(mk_is_qfbv_probe(),
|
||||
and_then(mk_bit_blaster_tactic(m),
|
||||
when(mk_lt(mk_memory_probe(), mk_const_probe(MEMLIMIT)),
|
||||
and_then(using_params(and_then(mk_simplify_tactic(m),
|
||||
mk_solve_eqs_tactic(m)),
|
||||
local_ctx_p),
|
||||
if_no_proofs(cond(mk_produce_unsat_cores_probe(),
|
||||
mk_aig_tactic(),
|
||||
using_params(mk_aig_tactic(),
|
||||
big_aig_p))))),
|
||||
new_sat),
|
||||
mk_smt_tactic())),
|
||||
main_p);*/
|
||||
|
||||
tactic * st = using_params(and_then(preamble_st,
|
||||
// If the user sets HI_DIV0=false, then the formula may contain uninterpreted function
|
||||
// symbols. In this case, we should not use
|
||||
|
|
Loading…
Reference in a new issue