void Tptp::makeApplication(Expr& expr, std::string& name,
std::vector<Expr>& args, bool term) {
if (args.empty()) { // Its a constant
if (isDeclared(name)) { // already appeared
expr = getVariable(name);
} else {
Type t = term ? d_unsorted : getExprManager()->booleanType();
expr = mkVar(name, t, ExprManager::VAR_FLAG_GLOBAL); // levelZero
preemptCommand(new DeclareFunctionCommand(name, expr, t));
}
} else { // Its an application
if (isDeclared(name)) { // already appeared
expr = getVariable(name);
} else {
std::vector<Type> sorts(args.size(), d_unsorted);
Type t = term ? d_unsorted : getExprManager()->booleanType();
t = getExprManager()->mkFunctionType(sorts, t);
expr = mkVar(name, t, ExprManager::VAR_FLAG_GLOBAL); // levelZero
preemptCommand(new DeclareFunctionCommand(name, expr, t));
}
// args might be rationals, in which case we need to create
// distinct constants of the "unsorted" sort to represent them
for (size_t i = 0; i < args.size(); ++i) {
if (args[i].getType().isReal() &&
FunctionType(expr.getType()).getArgTypes()[i] == d_unsorted) {
args[i] = convertRatToUnsorted(args[i]);
}
}
expr = getExprManager()->mkExpr(kind::APPLY_UF, expr, args);
}
}
Expr Tptp::convertRatToUnsorted(Expr expr) {
ExprManager* em = getExprManager();
// Create the conversion function If they doesn't exists
if (d_rtu_op.isNull()) {
Type t;
// Conversion from rational to unsorted
t = em->mkFunctionType(em->realType(), d_unsorted);
d_rtu_op = em->mkVar("$$rtu", t);
preemptCommand(new DeclareFunctionCommand("$$rtu", d_rtu_op, t));
// Conversion from unsorted to rational
t = em->mkFunctionType(d_unsorted, em->realType());
d_utr_op = em->mkVar("$$utr", t);
preemptCommand(new DeclareFunctionCommand("$$utr", d_utr_op, t));
}
// Add the inverse in order to show that over the elements that
// appear in the problem there is a bijection between unsorted and
// rational
Expr ret = em->mkExpr(kind::APPLY_UF, d_rtu_op, expr);
if (d_r_converted.find(expr) == d_r_converted.end()) {
d_r_converted.insert(expr);
Expr eq = em->mkExpr(kind::EQUAL, expr,
em->mkExpr(kind::APPLY_UF, d_utr_op, ret));
preemptCommand(new AssertCommand(eq));
}
return ret;
}
void Tptp::addTheory(Theory theory) {
ExprManager * em = getExprManager();
switch(theory) {
case THEORY_CORE:
//TPTP (CNF and FOF) is unsorted so we define this common type
{
std::string d_unsorted_name = "$$unsorted";
d_unsorted = em->mkSort(d_unsorted_name);
preemptCommand( new DeclareTypeCommand(d_unsorted_name, 0, d_unsorted) );
}
// propositionnal
defineType("Bool", em->booleanType());
defineVar("$true", em->mkConst(true));
defineVar("$false", em->mkConst(false));
addOperator(kind::AND);
addOperator(kind::EQUAL);
addOperator(kind::IMPLIES);
//addOperator(kind::ITE); //only for tff thf
addOperator(kind::NOT);
addOperator(kind::OR);
addOperator(kind::XOR);
addOperator(kind::APPLY_UF);
//Add quantifiers?
break;
default:
std::stringstream ss;
ss << "internal error: Tptp::addTheory(): unhandled theory " << theory;
throw ParserException(ss.str());
}
}
void Smt2::checkThatLogicIsSet() {
if( ! logicIsSet() ) {
if( strictModeEnabled() ) {
parseError("set-logic must appear before this point.");
} else {
warning("No set-logic command was given before this point.");
warning("CVC4 will assume the non-standard ALL_SUPPORTED logic.");
warning("Consider setting a stricter logic for (likely) better performance.");
warning("To suppress this warning in the future use (set-logic ALL_SUPPORTED).");
setLogic("ALL_SUPPORTED");
Command* c = new SetBenchmarkLogicCommand("ALL_SUPPORTED");
c->setMuted(true);
preemptCommand(c);
}
}
}
