/*
* Pushes a clause to a list depending on its evaluation
*
* If it is fixed to be satisfied, push to sat_clauses
* If it is satisfied, push to the corresponding watched list
* If it is unsatisified, push to unsat_clauses
*/
void insert_live_clause(samp_clause_t *clause, samp_table_t *table) {
rule_inst_table_t *rule_inst_table = &table->rule_inst_table;
atom_table_t *atom_table = &table->atom_table;
int32_t i, fixable;
samp_literal_t lit;
/* See if the clause is fixed-unit propagating */
fixable = get_fixable_literal(atom_table->assignment,
rule_inst_table->assignment, clause);
if (fixable == -2) {
/* fixed unsat */
mcsat_err("There is a fixed unsat clause, no model exists.");
return;
}
else if (fixable == -1) { /* more than one unfixed lits */
i = get_true_literal(atom_table->assignment,
rule_inst_table->assignment, clause);
if (i < 0) {
/* currently unsat, put back to the unsat list */
clause_list_insert_head(clause,
&rule_inst_table->unsat_clauses);
} else if (i == clause->num_lits) {
/* currently sat, put to the rule_watched list */
clause_list_insert_head(clause,
&rule_inst_table->rule_watched[clause->rule_index]);
} else {
/* currently sat, put to the watched list */
clause_list_insert_head(clause,
&rule_inst_table->watched[clause->disjunct[i]]);
}
} else {
/* fix a soft rule to unsat, because one of its clauses is fixed unsat */
if (fixable == clause->num_lits) {
rule_inst_t *rinst = rule_inst_table->rule_insts[clause->rule_index];
if (assigned_true(rule_inst_table->assignment[clause->rule_index])) {
rule_inst_table->unsat_weight += rinst->weight;
} else {
rule_inst_table->sat_weight += rinst->weight;
}
if (get_verbosity_level() >= 3) {
printf("[insert_live_clause] Fix rule %d: \n", clause->rule_index);
print_rule_instance(rinst, table);
printf(" to false\n");
}
rule_inst_table->assignment[clause->rule_index] = v_up_false;
} else {
/* fixed sat if we fix the 'fixable' literal */
lit = clause->disjunct[fixable];
if (unfixed_tval(atom_table->assignment[var_of(lit)])) {
/* unit propagation */
fix_lit_true(table, lit);
} else {
// already fixed sat
}
assert(assigned_fixed_true_lit(atom_table->assignment, lit));
}
clause_list_insert_head(clause, &rule_inst_table->sat_clauses);
}
}
tactic_report::tactic_report(char const * id, goal const & g) {
if (get_verbosity_level() >= TACTIC_VERBOSITY_LVL)
m_imp = alloc(imp, id, g);
else
m_imp = 0;
}
unsigned spacer_matrix::perform_gaussian_elimination()
{
unsigned i=0;
unsigned j=0;
while(i < m_matrix.size() && j < m_matrix[0].size())
{
// find maximal element in column with row index bigger or equal i
rational max = m_matrix[i][j];
unsigned max_index = i;
for (unsigned k=i+1; k < m_matrix.size(); ++k)
{
if (max < m_matrix[k][j])
{
max = m_matrix[k][j];
max_index = k;
}
}
if (max.is_zero()) // skip this column
{
++j;
}
else
{
// reorder rows if necessary
vector<rational> tmp = m_matrix[i];
m_matrix[i] = m_matrix[max_index];
m_matrix[max_index] = m_matrix[i];
// normalize row
rational pivot = m_matrix[i][j];
if (!pivot.is_one())
{
for (unsigned k=0; k < m_matrix[i].size(); ++k)
{
m_matrix[i][k] = m_matrix[i][k] / pivot;
}
}
// subtract row from all other rows
for (unsigned k=1; k < m_matrix.size(); ++k)
{
if (k != i)
{
rational factor = m_matrix[k][j];
for (unsigned l=0; l < m_matrix[k].size(); ++l)
{
m_matrix[k][l] = m_matrix[k][l] - (factor * m_matrix[i][l]);
}
}
}
++i;
++j;
}
}
if (get_verbosity_level() >= 1)
{
SASSERT(m_matrix.size() > 0);
}
return i; //i points to the row after the last row which is non-zero
}
/* MaxWalkSAT */
void mw_sat(samp_table_t *table, int32_t num_trials, double rvar_probability,
int32_t max_flips, uint32_t timeout) {
rule_inst_table_t *rule_inst_table = &table->rule_inst_table;
atom_table_t *atom_table = &table->atom_table;
int32_t i, j;
time_t fintime;
if (timeout != 0) {
fintime = time(NULL) + timeout;
}
double best_cost = DBL_MAX;
for (i = 0; i < num_trials; i++) {
init_random_assignment(table);
//scan_rule_instances(table);
for (j = 0; j < rule_inst_table->num_rule_insts; j++) {
if (rule_inst_table->rule_insts[j]->weight == DBL_MAX)
rule_inst_table->assignment[j] = v_up_true;
else
rule_inst_table->assignment[j] = v_true;
}
init_live_clauses(table);
scan_live_clauses(table);
if (get_verbosity_level() >= 3) {
printf("\n[mw_sat] Trial %d: \n", i);
print_live_clauses(table);
}
for (j = 0; j < max_flips; j++) {
if (timeout != 0 && time(NULL) >= fintime) {
printf("Timeout after %"PRIu32" samples\n", i);
break;
}
if (rule_inst_table->unsat_clauses.length == 0
&& rule_inst_table->unsat_soft_rules.nelems == 0) {
return;
}
int32_t c = genrand_uint(rule_inst_table->unsat_clauses.length
+ rule_inst_table->unsat_soft_rules.nelems);
if (c < rule_inst_table->unsat_clauses.length) { /* picked a hard clause */
samp_clause_t *clause = choose_random_clause(&rule_inst_table->unsat_clauses);
int32_t litidx = choose_clause_var(table, clause, rvar_probability);
if (litidx == clause->num_lits) {
if (get_verbosity_level() >= 3) {
printf("[flip_rule_to_unsat] Rule %d: ", clause->rule_index);
print_rule_instance(rule_inst_table->rule_insts[clause->rule_index], table);
printf("\n");
}
/* picked the rule auxiliary variable, i.e., rinst T -> F */
hmap_get(&rule_inst_table->unsat_soft_rules, clause->rule_index);
rule_inst_table->assignment[clause->rule_index] = v_false;
rule_inst_t *rinst = rule_inst_table->rule_insts[clause->rule_index];
rule_inst_table->unsat_weight += rinst->weight;
/* Is this really going to do the right thing?? */
rule_inst_table->sat_weight -= rinst->weight;
/* move unsat_clauses to live_clause_list and rescan */
clause_list_concat(&rule_inst_table->unsat_clauses,
&rule_inst_table->live_clauses);
scan_live_clauses(table);
} else {
flip_unfixed_variable(table, var_of(clause->disjunct[litidx]));
}
} else {
/* picked a soft rule auxiliary variable, i.e., rinst F -> T */
int32_t rule_index = hmap_remove_random(&rule_inst_table->unsat_soft_rules);
rule_inst_table->assignment[rule_index] = v_true;
rule_inst_t *rinst = rule_inst_table->rule_insts[rule_index];
rule_inst_table->unsat_weight -= rinst->weight;
rule_inst_table->sat_weight += rinst->weight;
if (get_verbosity_level() >= 3) {
printf("[flip_rule_to_sat] Rule %d: ", rule_index);
print_rule_instance(rinst, table);
printf("\n");
}
/* move watch[~r] to live_clause_list and rescan */
clause_list_concat(&rule_inst_table->rule_watched[rule_index],
&rule_inst_table->live_clauses);
scan_live_clauses(table);
}
if (get_verbosity_level() >= 1) {
printf("[mw_sat] Flip %d: # unsat hard = %d, # unsat soft = %d, "
"weight of unsat soft = %f; weight of sat soft = %f\n", j,
rule_inst_table->unsat_clauses.length,
rule_inst_table->unsat_soft_rules.nelems,
rule_inst_table->unsat_weight,
rule_inst_table->sat_weight
);
}
if (get_verbosity_level() >= 3) {
print_live_clauses(table);
}
if (best_cost > rule_inst_table->unsat_weight) {
best_cost = rule_inst_table->unsat_weight;
copy_assignment_array(atom_table);
}
}
}
restore_assignment_array(atom_table);
}
as_st_report::as_st_report(char const * id, assertion_set & s) {
if (get_verbosity_level() >= ST_VERBOSITY_LVL)
m_imp = alloc(imp, id, s);
else
m_imp = 0;
}
