void clause_list_insert(samp_clause_t *clause, samp_clause_list_t *list,
samp_clause_t *ptr) {
assert(valid_clause_list(list));
clause->link = ptr->link;
ptr->link = clause;
if (list->tail == ptr) { /* insert at the end */
list->tail = clause;
}
list->length++;
assert(valid_clause_list(list));
}
samp_clause_t *clause_list_pop(samp_clause_list_t *list, samp_clause_t *ptr) {
assert(valid_clause_list(list));
assert(ptr != list->tail); /* pointer cannot be the tail */
samp_clause_t *clause = ptr->link;
if (list->tail == clause) {
list->tail = ptr;
}
ptr->link = clause->link;
clause->link = NULL;
list->length--;
assert(valid_clause_list(list));
return clause;
}
void clause_list_concat(samp_clause_list_t *list_src, samp_clause_list_t *list_dst) {
assert(valid_clause_list(list_src));
assert(valid_clause_list(list_dst));
list_dst->tail->link = list_src->head->link;
if (!is_empty_clause_list(list_src)) {
list_dst->tail = list_src->tail;
}
list_dst->length += list_src->length;
list_src->head->link = NULL;
list_src->tail = list_src->head;
list_src->length = 0;
assert(valid_clause_list(list_src));
assert(valid_clause_list(list_dst));
}
void init_clause_list(samp_clause_list_t *list) {
/* sentinel */
list->head = (samp_clause_t *) safe_malloc(sizeof(samp_clause_t));
list->head->link = NULL;
list->tail = list->head;
list->length = 0;
assert(valid_clause_list(list));
}
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;
}
/*
* Validate all the lists in the clause table
*/
bool valid_rule_inst_table(rule_inst_table_t *rule_inst_table, atom_table_t *atom_table){
samp_clause_t *ptr;
samp_clause_t *cls;
int32_t lit, i;
assert(rule_inst_table->size >= 0);
assert(rule_inst_table->num_rule_insts >= 0);
assert(rule_inst_table->num_rule_insts <= rule_inst_table->size);
if (rule_inst_table->size < 0) return false;
if (rule_inst_table->num_rule_insts < 0
|| rule_inst_table->num_rule_insts > rule_inst_table->size)
return false;
/* check that every clause in the unsat list is unsat */
valid_clause_list(&rule_inst_table->unsat_clauses);
for (ptr = rule_inst_table->unsat_clauses.head;
ptr != rule_inst_table->unsat_clauses.tail;
ptr = next_clause_ptr(ptr)) {
cls = ptr->link;
assert(eval_clause(atom_table->assignment, cls) == -1);
if (eval_clause(atom_table->assignment, cls) != -1)
return false;
}
///* check negative_or_unit_clauses */
//valid_clause_list(&rule_inst_table->negative_or_unit_clauses);
//for (ptr = rule_inst_table->negative_or_unit_clauses.head;
// ptr != rule_inst_table->negative_or_unit_clauses.tail;
// ptr = next_clause_ptr(ptr)) {
// cls = ptr->link;
// assert(cls->weight < 0 || cls->numlits == 1);
// if (cls->weight >= 0 && cls->numlits != 1)
// return false;
//}
///* check dead_negative_or_unit_clauses */
//valid_clause_list(&rule_inst_table->dead_negative_or_unit_clauses);
//for (ptr = rule_inst_table->dead_negative_or_unit_clauses.head;
// ptr != rule_inst_table->dead_negative_or_unit_clauses.tail;
// ptr = next_clause_ptr(ptr)) {
// cls = ptr->link;
// assert(cls->weight < 0 || cls->numlits == 1);
// if (cls->weight >= 0 && cls->numlits != 1)
// return false;
//}
/* check that every watched clause is satisfied */
for (i = 0; i < atom_table->num_vars; i++) {
lit = pos_lit(i);
valid_watched_lit(rule_inst_table, lit, atom_table);
lit = neg_lit(i);
valid_watched_lit(rule_inst_table, lit, atom_table);
}
/* check the sat_clauses to see if the first disjunct is fixed true */
valid_clause_list(&rule_inst_table->sat_clauses);
for (ptr = rule_inst_table->sat_clauses.head;
ptr != rule_inst_table->sat_clauses.tail;
ptr = next_clause_ptr(ptr)) {
cls = ptr->link;
assert(clause_contains_fixed_true_lit(cls, atom_table->assignment));
if (!clause_contains_fixed_true_lit(cls, atom_table->assignment))
return false;
}
/* check the live_clauses */
valid_clause_list(&rule_inst_table->sat_clauses);
/* check all the clauses to see if they are properly indexed */
rule_inst_t *rinst;
for (i = 0; i < rule_inst_table->num_rule_insts; i++){
rinst = rule_inst_table->rule_insts[i];
assert(rinst->num_clauses >= 0);
if (rinst->num_clauses < 0)
return false;
//for (j = 0; j < clause->numlits; j++){
// assert(var_of(clause->disjunct[j]) >= 0);
// assert(var_of(clause->disjunct[j]) < atom_table->num_vars);
// if (var_of(clause->disjunct[j]) < 0 ||
// var_of(clause->disjunct[j]) >= atom_table->num_vars)
// return false;
//}
}
return true;
}