unsigned compute_degree(ExprManager& exprManager, const Expr& term) {
unsigned n = term.getNumChildren();
unsigned degree = 0;
// boolean stuff
if (term.getType() == exprManager.booleanType()) {
for (unsigned i = 0; i < n; ++ i) {
degree = std::max(degree, compute_degree(exprManager, term[i]));
}
return degree;
}
// terms
if (n == 0) {
if (term.getKind() == kind::CONST_RATIONAL) {
return 0;
} else {
return 1;
}
} else {
unsigned degree = 0;
if (term.getKind() == kind::MULT) {
for (unsigned i = 0; i < n; ++ i) {
degree += std::max(degree, compute_degree(exprManager, term[i]));
}
} else {
for (unsigned i = 0; i < n; ++ i) {
degree = std::max(degree, compute_degree(exprManager, term[i]));
}
}
return degree;
}
}
void PortfolioLemmaOutputChannel::notifyNewLemma(Expr lemma) {
if(int(lemma.getNumChildren()) > Options::currentGetSharingFilterByLength()) {
return;
}
++cnt;
Trace("sharing") << d_tag << ": " << lemma << std::endl;
expr::pickle::Pickle pkl;
try {
d_pickler.toPickle(lemma, pkl);
d_sharedChannel->push(pkl);
if(Trace.isOn("showSharing") && Options::currentGetThreadId() == 0) {
(*(Options::currentGetOut()))
<< "thread #0: notifyNewLemma: " << lemma << std::endl;
}
} catch(expr::pickle::PicklingException& p){
Trace("sharing::blocked") << lemma << std::endl;
}
}
Expr collectSortsExpr(Expr e)
{
if(substitutions.find(e) != substitutions.end()) {
return substitutions[e];
}
++depth;
Expr old_e = e;
for(unsigned i = 0; i < e.getNumChildren(); ++i) {
collectSortsExpr(e[i]);
}
e = e.substitute(substitutions);
// cout << "[debug] " << e << " " << e.getKind() << " " << theory::kindToTheoryId(e.getKind()) << endl;
if(theory::kindToTheoryId(e.getKind()) == theory::THEORY_SETS) {
SetType t = SetType(e.getType().isBoolean() ? e[1].getType() : e.getType());
substitutions[e] = add(t, e);
e = e.substitute(substitutions);
}
substitutions[old_e] = e;
// cout << ";"; for(int i = 0; i < depth; ++i) cout << " "; cout << old_e << " => " << e << endl;
--depth;
return e;
}
void translate_to_redlog(const map<Expr, unsigned>& variables, const Expr& assertion) {
bool first;
unsigned n = assertion.getNumChildren();
if (n == 0) {
if (assertion.isConst()) {
if (assertion.getConst<bool>()) {
cout << "(1 > 0)";
} else {
cout << "(1 < 0)";
}
} else {
assert(false);
}
} else {
std::string op;
bool binary = false;
bool theory = false;
switch (assertion.getKind()) {
case kind::NOT:
cout << "(not ";
translate_to_redlog(variables, assertion[0]);
cout << ")";
break;
case kind::OR:
first = true;
cout << "(";
for (unsigned i = 0; i < n; ++ i) {
if (!first) {
cout << " or ";
}
first = false;
translate_to_redlog(variables, assertion[i]);
}
cout << ")";
break;
case kind::AND:
first = true;
cout << "(";
for (unsigned i = 0; i < n; ++ i) {
if (!first) {
cout << " and ";
}
first = false;
translate_to_redlog(variables, assertion[i]);
}
cout << ")";
break;
case kind::IMPLIES:
cout << "(";
translate_to_redlog(variables, assertion[0]);
cout << " impl ";
translate_to_redlog(variables, assertion[1]);
cout << ")";
break;
case kind::IFF:
cout << "(";
translate_to_redlog(variables, assertion[0]);
cout << " equiv ";
translate_to_redlog(variables, assertion[1]);
cout << ")";
break;
case kind::EQUAL:
op = "=";
theory = true;
break;
case kind::LT:
op = "<";
theory = true;
break;
case kind::LEQ:
op = "<=";
theory = true;
break;
case kind::GT:
op = ">";
theory = true;
break;
case kind::GEQ:
op = ">=";
theory = true;
break;
default:
assert(false);
break;
}
if (binary) {
cout << "(";
translate_to_redlog(variables, assertion[0]);
cout << " " << op << " ";
translate_to_redlog(variables, assertion[1]);
cout << ")";
}
if (theory) {
cout << "(";
translate_to_redlog_term(variables, assertion[0]);
cout << " " << op << " ";
translate_to_redlog_term(variables, assertion[1]);
cout << ")";
}
}
}
void translate_to_redlog_term(const map<Expr, unsigned>& variables, const Expr& term) {
bool first;
unsigned n = term.getNumChildren();
if (n == 0) {
if (term.getKind() == kind::CONST_RATIONAL) {
cout << term.getConst<Rational>();
} else {
assert(variables.find(term) != variables.end());
cout << "x" << variables.find(term)->second;
}
} else {
switch (term.getKind()) {
case kind::PLUS:
cout << "(";
first = true;
for (unsigned i = 0; i < n; ++ i) {
if (!first) {
cout << " + ";
}
first = false;
translate_to_redlog_term(variables, term[i]);
}
cout << ")";
break;
case kind::MULT:
cout << "(";
first = true;
for (unsigned i = 0; i < n; ++ i) {
if (!first) {
cout << " * ";
}
first = false;
translate_to_redlog_term(variables, term[i]);
}
cout << ")";
break;
case kind::MINUS:
cout << "(";
translate_to_redlog_term(variables, term[0]);
cout << " - ";
translate_to_redlog_term(variables, term[1]);
cout << ")";
break;
case kind::DIVISION:
cout << "(";
translate_to_redlog_term(variables, term[0]);
cout << " / ";
translate_to_redlog_term(variables, term[1]);
cout << ")";
break;
case kind::UMINUS:
cout << "(-(";
translate_to_redlog_term(variables, term[0]);
cout << "))";
break;
default:
assert(false);
break;
}
}
}
void translate_to_mathematica(const map<Expr, unsigned>& variables, const Expr& assertion) {
bool first;
unsigned n = assertion.getNumChildren();
if (n == 0) {
assert(false);
} else {
std::string op;
bool binary = false;
bool theory = false;
switch (assertion.getKind()) {
case kind::NOT:
cout << "!";
translate_to_mathematica(variables, assertion[0]);
break;
case kind::OR:
first = true;
cout << "(";
for (unsigned i = 0; i < n; ++ i) {
if (!first) {
cout << " || ";
}
first = false;
translate_to_mathematica(variables, assertion[i]);
}
cout << ")";
break;
case kind::AND:
first = true;
cout << "(";
for (unsigned i = 0; i < n; ++ i) {
if (!first) {
cout << " && ";
}
first = false;
translate_to_mathematica(variables, assertion[i]);
}
cout << ")";
break;
case kind::IMPLIES:
cout << "Implies[";
translate_to_mathematica(variables, assertion[0]);
cout << ",";
translate_to_mathematica(variables, assertion[1]);
cout << "]";
break;
case kind::IFF:
cout << "Equivalent[";
translate_to_mathematica(variables, assertion[0]);
cout << ",";
translate_to_mathematica(variables, assertion[1]);
cout << "]";
break;
case kind::EQUAL:
op = "==";
theory = true;
break;
case kind::LT:
op = "<";
theory = true;
break;
case kind::LEQ:
op = "<=";
theory = true;
break;
case kind::GT:
op = ">";
theory = true;
break;
case kind::GEQ:
op = ">=";
theory = true;
break;
default:
assert(false);
break;
}
if (binary) {
cout << "(";
translate_to_mathematica(variables, assertion[0]);
cout << " " << op << " ";
translate_to_mathematica(variables, assertion[1]);
cout << ")";
}
if (theory) {
cout << "(";
translate_to_mathematica_term(variables, assertion[0]);
cout << " " << op << " ";
translate_to_mathematica_term(variables, assertion[1]);
cout << ")";
}
}
}
