void VariableEliminator::get_function_terms_in_clause(Clause& cl,
map<int, set<FunctionTerm*> >& functions_in_clause)
{
set<EqLeaf*>::iterator it = cl.pos_eq.begin();
for(; it!= cl.pos_eq.end(); it++) {
set<Term*> terms;
EqLeaf* eq = *it;
eq->get_lhs()->get_nested_terms(terms);
eq->get_rhs()->get_nested_terms(terms);
set<Term*>::iterator it2 = terms.begin();
for(; it2 != terms.end(); it2++) {
Term* t = *it2;
if(t->get_term_type() != FUNCTION_TERM) continue;
FunctionTerm* ft = (FunctionTerm*) t;
functions_in_clause[ft->get_id()].insert(ft);
}
}
it = cl.neg_eq.begin();
for(; it!= cl.neg_eq.end(); it++) {
set<Term*> terms;
EqLeaf* eq = *it;
if(eq->get_lhs() == NULL) {
cout << eq->get_type() << endl;
cout << "EQ: " << eq->to_string() << endl;
}
eq->get_lhs()->get_nested_terms(terms);
eq->get_rhs()->get_nested_terms(terms);
set<Term*>::iterator it2 = terms.begin();
for(; it2 != terms.end(); it2++) {
Term* t = *it2;
if(t->get_term_type() != FUNCTION_TERM) continue;
FunctionTerm* ft = (FunctionTerm*) t;
functions_in_clause[ft->get_id()].insert(ft);
}
}
if(DEBUG)
{
cout << " --- FUNCTIONS IN CLAUSE ---- " << endl;
map<int, set<FunctionTerm*> >::iterator it = functions_in_clause.begin();
for(; it != functions_in_clause.end(); it++) {
cout << "Function: " << CNode::get_varmap().get_name(it->first) << endl;
set<FunctionTerm*>::iterator it2 = it->second.begin();
for(; it2!= it->second.end(); it2++) {
cout << "\t " << (*it2)->to_string() << endl;
}
}
}
}
Term* ArithmeticTerm::canonicalize(ArithmeticTerm* at)
{
if(at->get_elems().size() == 0) {
long int constant = at->get_constant();
delete at;
return ConstantTerm::make(constant);
}
if(at->get_constant() == 0 && at->get_elems().size() == 1 &&
(at->get_elems().begin())->second ==1)
{
Term* t = at->get_elems().begin()->first;
switch(t->get_term_type())
{
case VARIABLE_TERM:
case FUNCTION_TERM:
{
delete at;
return t;
}
default:
assert(false);
}
}
return Term::get_term(at);
}
bool UniversalInstantiator::process_eq_leaf_in_index_guard(EqLeaf* eq,
set<int> &qvars, QuantifiedLeaf* ql)
{
Term* lhs = eq->get_lhs();
Term* rhs = eq->get_rhs();
if(lhs->get_term_type() == FUNCTION_TERM ||
rhs->get_term_type() == FUNCTION_TERM) return false;
if(lhs->get_term_type() == CONSTANT_TERM && rhs->get_term_type()
== CONSTANT_TERM) return true;
if(lhs->get_term_type() != VARIABLE_TERM ||
qvars.count(((VariableTerm*)lhs)->get_var_id())==0) {
Term* temp = rhs;
rhs = lhs;
lhs = temp;
}
assert(lhs->get_term_type() == VARIABLE_TERM);
VariableTerm* vt = (VariableTerm*) lhs;
if(qvars.count(vt->get_var_id()) == 0){
return true;
}
qvar qv;
//qv.orig_id = ql->get_orig_id();
qv.id = (long int) ql;
qv.var_id = vt->get_var_id();
if(rhs->get_term_type() == CONSTANT_TERM){
add_to_index_set(qv, rhs);
{
return true;
}
}
assert(rhs->get_term_type() == VARIABLE_TERM);
VariableTerm* vt_rhs = (VariableTerm*) rhs;
if(qvars.count(vt_rhs->get_var_id()) > 0){
return true;
}
add_to_index_set(qv, vt_rhs);
return true;
}
