/* Adds a rule for a pred entry */ void add_rule_to_pred(pred_table_t *pred_table, int32_t predicate, int32_t current_rule_index) { pred_entry_t *entry = get_pred_entry(pred_table, predicate); int32_t i; /* if alreay exists, return */ for (i = 0; i < entry->num_rules; i++) { if (entry->rules[i] == current_rule_index) { return; } } pred_rule_table_resize(entry); entry->rules[entry->num_rules++] = current_rule_index; }
/* * 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; }
/* Adds a new atom for a pred entry */ void add_atom_to_pred(pred_table_t *pred_table, int32_t predicate, int32_t current_atom_index) { pred_entry_t *entry = get_pred_entry(pred_table, predicate); pred_atom_table_resize(entry); entry->atoms[entry->num_atoms++] = current_atom_index; }