static void check_propagation(test_bench_t *bench) {
equality_queue_t *queue;
ivector_t expl;
uint32_t i, n;
int32_t x, y;
init_ivector(&expl, 10);
queue = &bench->equeue;
n = queue->top;
for (i=0; i<n; i++) {
x = queue->data[i].lhs;
y = queue->data[i].rhs;
if (x >= 0) {
assert(y >= 0);
offset_manager_explain_equality(&bench->manager, x, y, &expl);
check_equality(bench, x, y, &expl);
if (bench->show_details) {
printf("Explanation for x%"PRId32" == x%"PRId32":\n", x, y);
print_poly_def(bench->ptable, x);
print_poly_def(bench->ptable, y);
print_explanation(bench, &expl);
}
ivector_reset(&expl);
}
}
delete_ivector(&expl);
}
/*
* Flattening of disjuncts and universal quantifiers + optionally ite and iff terms
*/
void flatten_forall_disjuncts(flattener_t *flat, term_t f, bool f_ite, bool f_iff) {
assert(int_queue_is_empty(&flat->queue) && int_hset_is_empty(&flat->cache));
ivector_reset(&flat->resu);
flattener_push_term(flat, f);
flattener_forall_disjuncts(flat, f_ite, f_iff);
}
/*
* Test the period/phase computation
*/
static void test_periods_and_phases(int_constraint_t *cnstr) {
ivector_t v;
rational_t *p, *q;
uint32_t i, n;
int32_t x;
init_ivector(&v, 10);
n = int_constraint_num_terms(cnstr);
for (i=0; i<n; i++) {
ivector_reset(&v);
int_constraint_period_of_var(cnstr, i, &v);
x = int_constraint_get_var(cnstr, i);
p = int_constraint_period(cnstr);
q = int_constraint_phase(cnstr);
printf("Variable %s: period = ", var[x].name);
q_print(stdout, p);
printf(", phase = ");
q_print(stdout, q);
printf("\n");
printf(" antecedents: ");
show_varnames(stdout, v.data, v.size);
check_period_and_phase(cnstr, i, p, q);
}
delete_ivector(&v);
}
/*
* Merge the exists and forall variables of constraint i
* - store the variables in solver->all_vars
* - store their values in solver->all_values
*/
static void ef_build_full_map(ef_solver_t *solver, uint32_t i) {
ef_cnstr_t *cnstr;
ivector_t *v;
uint32_t n;
assert(i < ef_prob_num_constraints(solver->prob));
cnstr = solver->prob->cnstr + i;
// collect all variables of cnstr in solver->all_vars
v = &solver->all_vars;
ivector_reset(v);
n = ef_constraint_num_evars(cnstr);
ivector_add(v, cnstr->evars, n);
n = ef_constraint_num_uvars(cnstr);
ivector_add(v, cnstr->uvars, n);
// project the evalues onto the exists variable of constraint i
// store the results in all_values
v = &solver->all_values;
n = ef_constraint_num_evars(cnstr);
resize_ivector(v, n);
v->size = n;
ef_project_exists_model(solver->prob, solver->evalue, cnstr->evars, v->data, n);
// copy the uvalues for constraint i (from uvalue_aux to v)
n = ef_constraint_num_uvars(cnstr);
assert(n == solver->uvalue_aux.size);
ivector_add(v, solver->uvalue_aux.data, n);
#if EF_VERBOSE
printf("Full map\n");
print_full_map(stdout, solver);
fflush(stdout);
#endif
}
/*
* Flatten array f[0 .... n-1]: universal quantifiers + disjuncts
*/
void flatten_array_forall_disjuncts(flattener_t *flat, uint32_t n, term_t *f, bool f_ite, bool f_iff) {
uint32_t i;
assert(int_queue_is_empty(&flat->queue) && int_hset_is_empty(&flat->cache));
ivector_reset(&flat->resu);
for (i=0; i<n; i++) {
flattener_push_term(flat, f[i]);
}
flattener_forall_disjuncts(flat, f_ite, f_iff);
}
/*
* Reset queue/cache and vector
*/
void reset_flattener(flattener_t *flat) {
int_queue_reset(&flat->queue);
int_hset_reset(&flat->cache);
ivector_reset(&flat->resu);
}
static int build_instance(char *filename, smt_core_t *core) {
int l, n, c_idx, literal, nvars, nclauses;
char *s;
FILE *f;
ivector_t buffer;
f = fopen(filename, "r");
if (f == NULL) {
perror(filename);
return OPEN_ERROR;
}
s = fgets(line, MAX_LINE, f);
l = 1; /* line number */
if (s == NULL) {
fprintf(stderr, "%s: empty file\n", filename);
fclose(f);
return FORMAT_ERROR;
}
/* skip empty and comment lines */
while (*s == 'c' || *s == '\n') {
s = fgets(line, MAX_LINE, f);
l ++;
if (s == NULL) {
fprintf(stderr, "Format error: file %s, line %d\n", filename, l);
fclose(f);
return FORMAT_ERROR;
}
}
/* read problem size */
n = sscanf(s, "p cnf %d %d", &nvars, &nclauses);
if (n != 2 || nvars < 0 || nclauses < 0) {
fprintf(stderr, "Format error: file %s, line %d\n", filename, l);
fclose(f);
return FORMAT_ERROR;
}
/* initialize core for nvars */
init_sat_solver(core, nvars);
/* initialize the clause buffer */
init_ivector(&buffer, 10);
/* now read the clauses and translate them */
c_idx = 0;
while (c_idx < nclauses) {
for (;;) {
literal = read_literal(f, nvars);
if (literal < 0) break;
ivector_push(&buffer, literal);
}
if (literal != END_OF_CLAUSE) {
fprintf(stderr, "Format error: file %s\n", filename);
fclose(f);
return FORMAT_ERROR;
}
add_clause(core, buffer.size, buffer.data);
c_idx ++;
ivector_reset(&buffer);
}
delete_ivector(&buffer);
fclose(f);
return 0;
}
/*
* Option 3: generalize by computing an implicant then
* applying projection.
*/
static term_t ef_generalize3(ef_solver_t *solver, uint32_t i) {
model_t *mdl;
ef_cnstr_t *cnstr;
ivector_t *v, *w;
term_t a[2];
uint32_t n;
int32_t code;
proj_flag_t pflag;
term_t result;
assert(i < ef_prob_num_constraints(solver->prob));
// free the current full model if any
if (solver->full_model != NULL) {
yices_free_model(solver->full_model);
solver->full_model = NULL;
}
// build the full_map and the corresponding model.
ef_build_full_map(solver, i);
n = solver->all_vars.size;
assert(n == solver->all_values.size);
mdl = yices_model_from_map(n, solver->all_vars.data, solver->all_values.data);
if (mdl == NULL) {
// error in the model construction
solver->status = EF_STATUS_MDL_ERROR;
solver->error_code = yices_error_code();
return NULL_TERM;
}
solver->full_model = mdl;
// Constraint
cnstr = solver->prob->cnstr + i;
a[0] = cnstr->assumption; // B(y)
a[1] = opposite_term(cnstr->guarantee); // not C(x, y)
#if EF_VERBOSE
printf("Constraint:\n");
yices_pp_term_array(stdout, 2, a, 120, UINT32_MAX, 0, 0);
printf("(%"PRIu32" literals)\n", 2);
#endif
// Compute the implicant
v = &solver->implicant;
ivector_reset(v);
code = get_implicant(mdl, solver->prob->manager, LIT_COLLECTOR_ALL_OPTIONS, 2, a, v);
if (code < 0) {
solver->status = EF_STATUS_IMPLICANT_ERROR;
solver->error_code = code;
return NULL_TERM;
}
#if EF_VERBOSE
printf("Implicant:\n");
yices_pp_term_array(stdout, v->size, v->data, 120, UINT32_MAX, 0, 0);
printf("(%"PRIu32" literals)\n", v->size);
#endif
// Projection
w = &solver->projection;
ivector_reset(w);
n = ef_constraint_num_uvars(cnstr);
#if EF_VERBOSE
printf("(%"PRIu32" universals)\n", n);
yices_pp_term_array(stdout, n, cnstr->uvars, 120, UINT32_MAX, 0, 0);
#endif
pflag = project_literals(mdl, solver->prob->manager, v->size, v->data, n, cnstr->uvars, w);
if (pflag != PROJ_NO_ERROR) {
solver->status = EF_STATUS_PROJECTION_ERROR;
solver->error_code = pflag;
return NULL_TERM;
}
#if EF_VERBOSE
printf("Projection:\n");
yices_pp_term_array(stdout, w->size, w->data, 120, UINT32_MAX, 0, 0);
printf("(%"PRIu32" literals)\n", w->size);
#endif
switch (w->size) {
case 0:
result = true_term;
break;
case 1:
result = w->data[0];
break;
default:
result = mk_and(solver->prob->manager, w->size, w->data);
break;
}
return opposite_term(result);
}
