/*
* 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);
}
}
/* TODO what does this do */
void retract_source(char *source, samp_table_t *table) {
rule_inst_table_t *rule_inst_table = &table->rule_inst_table;
source_table_t *source_table = &table->source_table;
source_entry_t *source_entry;
int32_t i, j, srcidx, sidx, rinst_idx;
rule_inst_t *rinst;
double wt;
for (srcidx = 0; srcidx < source_table->num_entries; srcidx++) {
if (strcmp(source, source_table->entry[srcidx]->name) == 0) {
break;
}
}
if (srcidx == source_table->num_entries) {
mcsat_err("\nSource %s unknown\n", source);
return;
}
source_entry = source_table->entry[srcidx];
if (source_entry->assertion != NULL) {
// Not sure what to do here
}
if (source_entry->rule_insts != NULL) {
for (i = 0; source_entry->rule_insts[i] != -1; i++) {
rinst_idx = source_entry->rule_insts[i];
rinst = rule_inst_table->rule_insts[rinst_idx];
if (source_entry->weight[i] == DBL_MAX) {
// Need to go through all other sources and add them up
wt = 0.0;
for (sidx = 0; sidx < source_table->num_entries; sidx++) {
if (sidx != srcidx && source_table->entry[sidx]->rule_insts != NULL) {
for (j = 0; source_table->entry[sidx]->rule_insts[j] != -1; j++) {
if (source_table->entry[sidx]->rule_insts[j] == rinst_idx) {
wt += source_table->entry[sidx]->weight[j];
// Assume clause occurs only once for given source,
// as we can simply sum up all such occurrences.
break;
}
}
}
}
rinst->weight = wt;
} else if (rinst->weight != DBL_MAX) {
// Subtract the weight of this source from the clause
rinst->weight -= source_entry->weight[i];
} // Nothing to do if current weight is DBL_MAX
}
}
}
/*
* 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;
}
