Term* UniversalInstantiator::instantiate_term(Term* t,
map<int, Term*> &sub_map)
{
if(t->get_term_type() == CONSTANT_TERM)
return t;
if(t->get_term_type() == VARIABLE_TERM){
VariableTerm *vt = (VariableTerm*)t;
if(sub_map.count(vt->get_var_id()) == 0)
return vt;
return sub_map[vt->get_var_id()];
}
if(t->get_term_type() == ARITHMETIC_TERM) {
ArithmeticTerm* at = (ArithmeticTerm*)t;
bool changed = false;
map<Term*, long int> new_elems;
map<Term*, long int>::const_iterator it = at->get_elems().begin();
for(; it!= at->get_elems().end(); it++) {
Term* new_t = instantiate_term(it->first, sub_map);
if(new_t != t) changed = true;
new_elems[new_t] = it->second;
}
if(!changed) return at;
return ArithmeticTerm::make(new_elems, at->get_constant());
}
FunctionTerm *ft = (FunctionTerm*)t;
vector<Term*> new_args;
for(unsigned int i=0; i < ft->get_args().size(); i++)
{
Term* cur = instantiate_term(ft->get_args()[i], sub_map);
new_args.push_back(cur);
}
return FunctionTerm::make(ft->get_id(), new_args, ft->is_invertible());
}
Term* Term::substitute(Term* (*sub_func)(Term* t, void* data), void* my_data)
{
Term* new_t = (*sub_func)(this, my_data);
if(new_t != this) {
return new_t;
}
Term* res = NULL;
switch (get_term_type()) {
case CONSTANT_TERM:
case VARIABLE_TERM: {
res= this;
break;
}
case FUNCTION_TERM: {
FunctionTerm* ft = (FunctionTerm*) this;
const vector<Term*>& args = ft->get_args();
vector<Term*> new_args;
bool changed = false;
for (unsigned int i = 0; i < args.size(); i++) {
Term* new_arg = args[i]->substitute(sub_func, my_data);
if (new_arg != args[i])
changed = true;
new_args.push_back(new_arg);
}
if (!changed) {
res = this;
break;
}
res= FunctionTerm::make(ft->get_id(), new_args, ft->is_invertible());
break;
}
case ARITHMETIC_TERM: {
ArithmeticTerm* at = (ArithmeticTerm*) this;
bool changed = false;
map<Term*, long int> new_elems;
map<Term*, long int>::const_iterator it = at->get_elems().begin();
for (; it != at->get_elems().end(); it++) {
Term* new_t = it->first->substitute(sub_func, my_data);
if (new_t != it->first)
changed = true;
new_elems[new_t]+= it->second;
}
if (!changed) {
res = at;
break;
}
res = ArithmeticTerm::make(new_elems, at->get_constant());
break;
}
default:
assert(false);
}
return res;
}
Term* Term::evalute_term(map<Term*, SatValue>& assignments)
{
switch(this->get_term_type())
{
case CONSTANT_TERM:
return this;
case VARIABLE_TERM:
{
if(assignments.count(this) > 0){
return ConstantTerm::make(assignments[this].value.to_int());
}
return this;
}
case FUNCTION_TERM:
{
if(assignments.count(this) > 0){
return ConstantTerm::make(assignments[this].value.to_int());
}
vector<Term*> new_args;
FunctionTerm* ft = (FunctionTerm*) this;
for(unsigned int i = 0; i < ft->get_args().size(); i++)
{
Term* arg = ft->get_args()[i];
arg = arg->evalute_term(assignments);
new_args.push_back(arg);
}
Term* new_t =
FunctionTerm::make(ft->get_id(), new_args, ft->is_invertible());
if(assignments.count(new_t) > 0)
return ConstantTerm::make(assignments[new_t].value.to_int());
return new_t;
}
case ARITHMETIC_TERM:
{
ArithmeticTerm* at = (ArithmeticTerm*) this;
Term* res = ConstantTerm::make(at->get_constant());
const map<Term*, long int>& elems = at->get_elems();
map<Term*, long int>::const_iterator it = elems.begin();
for(; it!=elems.end(); it++)
{
Term* t = it->first;
Term* val = t->evalute_term(assignments);
res = res->add(val->multiply(it->second));
}
if(assignments.count(res) > 0)
return ConstantTerm::make(assignments[res].value.to_int());
return res;
}
default:
assert(false);
}
}
Term* Term::replace_argument(int fun_id, int arg_num, Term* replacement)
{
switch(this->get_term_type())
{
case CONSTANT_TERM:
case VARIABLE_TERM:
return this;
case FUNCTION_TERM:
{
FunctionTerm* ft = (FunctionTerm*)this;
const vector<Term*>& args = ft->get_args();
bool changed = false;
vector<Term*> new_args;
for(unsigned int i=0; i < args.size(); i++)
{
Term* cur = args[i];
Term* new_cur = cur->replace_argument(fun_id, arg_num, replacement);
if(cur != new_cur) {
changed = true;
}
new_args.push_back(new_cur);
}
if(ft->get_id() == fun_id )
{
changed = true;
new_args[arg_num] = replacement;
}
if(!changed) return this;
return FunctionTerm::make(ft->get_id(), new_args, ft->is_invertible());
}
case ARITHMETIC_TERM:
{
ArithmeticTerm* at = (ArithmeticTerm*) this;
const map<Term*, long int>& elems = at->get_elems();
map<Term*, long int>::const_iterator it = elems.begin();
bool changed = false;
map<Term*, long int> new_elems;
for(; it!=elems.end(); it++)
{
Term* t = it->first;
long int c = it->second;
Term* new_t = t->replace_argument(fun_id, arg_num, replacement);
new_elems[new_t] = c;
if(t!= new_t) changed = true;
}
if(!changed) return this;
return ArithmeticTerm::make(new_elems, at->get_constant());
}
default:
assert(false);
}
}
Term* Term::rename_variables(map<int, int>& replacements)
{
switch (get_term_type()) {
case CONSTANT_TERM:
return this;
case VARIABLE_TERM: {
VariableTerm* vt = (VariableTerm*) this;
int var_id = vt->get_var_id();
if (replacements.count(var_id)==0)
return this;
Term* res= VariableTerm::make(replacements[var_id]);
return res;
}
case FUNCTION_TERM: {
FunctionTerm* ft = (FunctionTerm*) this;
const vector<Term*>& args = ft->get_args();
vector<Term*> new_args;
bool changed = false;
for (unsigned int i = 0; i < args.size(); i++) {
Term* new_arg = args[i]->rename_variables(replacements);
if (new_arg != args[i])
changed = true;
new_args.push_back(new_arg);
}
if (!changed)
return this;
Term* res= FunctionTerm::make(ft->get_id(), new_args,
ft->is_invertible());
return res;
}
case ARITHMETIC_TERM: {
ArithmeticTerm* at = (ArithmeticTerm*) this;
bool changed = false;
map<Term*, long int> new_elems;
map<Term*, long int>::const_iterator it = at->get_elems().begin();
for (; it != at->get_elems().end(); it++) {
Term* new_t = it->first->rename_variables(replacements);
if (new_t != it->first)
changed = true;
new_elems[new_t] += it->second;
}
if (!changed)
return at;
Term* res= ArithmeticTerm::make(new_elems, at->get_constant());
return res;
}
default:
assert(false);
}
}
/*
* Substitutes variables if there are any
* active subtituitons & byuilds the fun_arg_universal
* and reverse_fun_arg universal maps. This is
* recursive since we need to cdr down
* nested function terms.
*/
Term* UniversalInstantiator::process_term(Term* t, map<int,int> & var_subs,
int fun_id, int arg_num, QuantifiedLeaf* ql)
{
if(t->get_term_type() == CONSTANT_TERM) return t;
if(t->get_term_type() == VARIABLE_TERM){
VariableTerm* vt = (VariableTerm*)t;
int var_id = vt->get_var_id();
if(var_subs.count(var_id)>0){
Term* new_vt = VariableTerm::make(var_subs[var_id]);
return new_vt;
}
else if(fun_id != -1 && ql!= NULL &&
ql->get_quantified_vars().count(var_id) >0)
{
assert(arg_num != -1);
qvar qv;
//qv.orig_id = ql->get_orig_id();
qv.id = (long int) ql;
qv.var_id = var_id;
map<int, int> *fun_map = NULL;
if(fun_arg_universal.count(qv)>0) {
fun_map = fun_arg_universal[qv];
}
else
{
fun_map = new map<int, int>();
fun_arg_universal[qv] = fun_map;
}
if(fun_map->count(fun_id) == 0){
(*fun_map)[fun_id] = arg_num;
pair<int, int> key(fun_id, arg_num);
set<qvar>* val = reverse_fun_arg_universal[key];
if(val == NULL){
val = new set<qvar>();
reverse_fun_arg_universal[key] = val;
}
val->insert(qv);
}
else {
if((*fun_map)[fun_id] != arg_num)
return NULL;
}
}
return t;
}
if(t->get_term_type() == FUNCTION_TERM)
{
FunctionTerm* ft = (FunctionTerm*)t;
vector<Term*> new_args;
for(unsigned int i=0; i < ft->get_args().size(); i++)
{
Term* cur_arg = process_term(ft->get_args()[i], var_subs,
ft->get_id(), i, ql);
if(cur_arg == NULL){
return NULL;
}
new_args.push_back(cur_arg);
}
Term* new_ft = FunctionTerm::make(ft->get_id(), new_args,
ft->is_invertible());
return new_ft;
}
else {
assert(t->get_term_type() == ARITHMETIC_TERM);
ArithmeticTerm* at = (ArithmeticTerm*) t;
bool changed = false;
map<Term*, long int> new_elems;
map<Term*, long int>::const_iterator it = at->get_elems().begin();
for(; it!= at->get_elems().end(); it++){
Term* new_t = process_term(it->first, var_subs, -1, -1, ql);
if(new_t == NULL) return NULL;
new_elems[new_t] = it->second;
}
if(!changed) return at;
Term* new_at = ArithmeticTerm::make(new_elems, at->get_constant());
return new_at;
}
}