/*
* Returns: the index of a satisfied literal of a clause, or -1 if none exists.
*/
static int32_t get_true_literal(
samp_truth_value_t *atom_assignment,
samp_truth_value_t *rule_assignment,
samp_clause_t *clause) {
int32_t i;
for (i = 0; i < clause->num_lits; i++) {
if (assigned_true_lit(atom_assignment, clause->disjunct[i]))
return i;
}
if (assigned_false(rule_assignment[clause->rule_index]))
return clause->num_lits;
return -1;
}
static bool valid_watched_lit(rule_inst_table_t *rule_inst_table, samp_literal_t lit,
atom_table_t *atom_table) {
valid_clause_list(&rule_inst_table->watched[lit]);
bool lit_true = (is_pos(lit) && assigned_true(atom_table->assignment[var_of(lit)]))
|| (is_neg(lit) && assigned_false(atom_table->assignment[var_of(lit)]));
assert(is_empty_clause_list(&rule_inst_table->watched[lit]) || lit_true);
if (!is_empty_clause_list(&rule_inst_table->watched[lit]) && !lit_true) {
return false;
}
samp_clause_t *ptr;
samp_clause_t *cls;
for (ptr = rule_inst_table->watched[lit].head;
ptr != rule_inst_table->watched[lit].tail;
ptr = next_clause_ptr(ptr)) {
cls = ptr->link;
assert(clause_contains_lit(cls, lit));
if (!clause_contains_lit(cls, lit))
return false;
}
return true;
}
/*
* Try to set the value of an atom.
*
* If the atom has a non-fixed value and is set to a fixed value, run
* unit_propagation...;
* If the atom has a non-fixed value and is set to the opposite non-fixed value,
* just change the value (and change the state of the relavent clauses?)
*/
static int32_t update_atom_tval(int32_t var, samp_truth_value_t tval, samp_table_t *table) {
pred_table_t *pred_table = &table->pred_table;
atom_table_t *atom_table = &table->atom_table;
samp_atom_t *atom = atom_table->atom[var];
pred_entry_t *pred_entry = get_pred_entry(pred_table, atom->pred);
/*
* Case 0: If the atom has been fixed, check if consistent: if it is
* assigned to the opposite value, return inconsistency; otherwise do
* nothing;
*/
samp_truth_value_t old_tval = atom_table->assignment[var];
if (!unfixed_tval(old_tval)) {
if ((assigned_true(old_tval) && assigned_false(tval))
|| (assigned_false(old_tval) && assigned_true(tval))) {
mcsat_err("[update_atom_tval] Assigning a conflict truth value. No model exists.\n");
return -1;
} else {
return 0;
}
}
#if USE_PTHREADS
/* Internally, this is now theoretically protected with a
mutex, but do we really want a multithreaded mcmc to be
waiting for mutexes? */
#else
/* Something's still bad here. For now, we ignore this code
block if we are compiled for pthreads */
char *var_str = var_string(var, table);
cprintf(3, "[update_atom_tval] Setting the value of %s to %s\n",
var_str, samp_truth_value_string(tval));
free(var_str);
#endif
/* Not case 0: update the value */
atom_table->assignment[var] = tval;
if (fixed_tval(tval)) {
/* If fixed, this can break a later assertion that there are
no fixed vars. Why? */
atom_table->num_unfixed_vars--;
}
/* Case 1: If the value just gets fixed but not changed, we are done. */
if (old_tval == unfix_tval(tval)) {
return 0;
}
/* Case 2: the value has changed */
if (assigned_true(tval)) {
link_propagate(table, neg_lit(var));
} else {
link_propagate(table, pos_lit(var));
}
//assert(valid_table(table));
/* If the atom is inactive AND the value is non-default, activate the atom. */
if (lazy_mcsat() && !atom_table->active[var]
&& assigned_false(tval) == pred_default_value(pred_entry)) {
activate_atom(table, var);
}
//assert(valid_table(table));
samp_truth_value_t new_tval = atom_table->assignment[var];
assert(new_tval == tval || (fixed_tval(new_tval)
&& tval == unfix_tval(negate_tval(new_tval))));
/*
* WARNING: in lazy mcsat, when we activate a new clause, it may force the
* value of the atom being activated to be the nagation of the value we
* intend to assign. E.g., when we want to set p(A) to v_true, and
* activated (and kept alive of) the clause ~p(A) or q(B), where q(B) is
* fixed to false (either by database or unit propagation), then p(A) has
* to change back to v_fixed_false.
*/
if (new_tval != tval)
return -1;
return 0;
}
