long ClauseSetUnfoldAllEqDefs(ClauseSet_p set, ClauseSet_p passive,
ClauseSet_p archive,
int min_arity, int eqdef_incrlimit)
{
ClausePos_p demod;
long res = false;
Clause_p start = NULL;
while((demod = ClauseSetFindEqDefinition(set, min_arity, start)))
{
start = demod->clause->succ;
if((TermStandardWeight(ClausePosGetOtherSide(demod))-
TermStandardWeight(ClausePosGetSide(demod)))<=eqdef_incrlimit)
{
ClauseSetExtractEntry(demod->clause);
ClauseSetUnfoldEqDef(set, demod);
if(passive)
{
ClauseSetUnfoldEqDef(passive, demod);
}
if(BuildProofObject)
{
ClauseSetInsert(archive, demod->clause);
}
else
{
ClauseFree(demod->clause);
}
res++;
}
ClausePosCellFree(demod);
}
return res;
}
static long pos_tree_compute_size_constraint(PTree_p tree)
{
ClausePos_p entry;
PTree_p trav;
PStack_p trav_stack;
long res = LONG_MAX;
trav_stack = PTreeTraverseInit(tree);
while((trav = PTreeTraverseNext(trav_stack)))
{
entry = trav->key;
res = MIN(res, TermStandardWeight(ClausePosGetSide(entry)));
}
PTreeTraverseExit(trav_stack);
/* This is a leaf node, size is fixed! */
return res;
}
static Term_p term_top_unfold_def(TB_p bank, Term_p term, ClausePos_p demod)
{
Term_p lside, rside, res;
Subst_p subst;
bool tmp;
assert(bank&&term&&demod);
lside = ClausePosGetSide(demod);
assert(!TermIsVar(lside));
if(lside->f_code != term->f_code)
{
return term;
}
subst = SubstAlloc();
tmp = SubstComputeMatch(lside, term, subst, TBTermEqual);
assert(tmp); /* Match must exist because demod is demod! */
rside = ClausePosGetOtherSide(demod);
res = TBInsertInstantiated(bank, rside);
SubstDelete(subst);
return res;
}
void PDTreeInsert(PDTree_p tree, ClausePos_p demod_side)
{
Term_p term, curr;
PDTNode_p node, *next;
bool res;
long tmp;
assert(tree);
assert(tree->tree);
assert(demod_side);
term = ClausePosGetSide(demod_side);
TermLRTraverseInit(tree->term_stack, term);
node = tree->tree;
tmp = TermStandardWeight(term);
if(!SysDateIsInvalid(node->age_constr))
{
node->age_constr = SysDateMaximum(demod_side->clause->date,
node->age_constr);
}
/* We need no guard here, since invalid = -1 will win out in either
case. */
node->size_constr = MIN(tmp, node->size_constr);
node->ref_count++;
curr = TermLRTraverseNext(tree->term_stack);
while(curr)
{
next = pdt_select_alt_ref(tree, node, curr);
if(!(*next))
{
*next = PDTNodeAlloc();
tree->arr_storage_est+= (IntMapStorage((*next)->f_alternatives)+
PDArrayStorage((*next)->v_alternatives));
(*next)->parent = node;
tree->node_count++;
if(TermIsVar(curr))
{
(*next)->variable = curr;
node->max_var = MAX(node->max_var, -curr->f_code);
}
}
node = *next;
tmp = TermStandardWeight(term);
node->size_constr = MIN(tmp, node->size_constr);
if(!SysDateIsInvalid(node->age_constr))
{
node->age_constr = SysDateMaximum(demod_side->clause->date,
node->age_constr);
}
node->ref_count++;
curr = TermLRTraverseNext(tree->term_stack);
}
assert(node);
res = PTreeStore(&(node->entries), demod_side);
tree->clause_count++;
(void)res; assert(res);
//printf("ISizeConstr %p: %ld\n", tree, pdt_verify_size_constraint(tree->tree));
//printf("IDateConstr %p: %ld\n", tree, pdt_verify_age_constraint(tree->tree));
}
