Exemple #1
0
/*
 * 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);
	}
}
Exemple #2
0
/* 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
		}
	}
}
Exemple #3
0
/*
 * 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;
}