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);
}
}
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());
}
}
Expr Tptp::getAssertionExpr(FormulaRole fr, Expr expr) {
switch (fr) {
case FR_AXIOM:
case FR_HYPOTHESIS:
case FR_DEFINITION:
case FR_ASSUMPTION:
case FR_LEMMA:
case FR_THEOREM:
case FR_NEGATED_CONJECTURE:
case FR_PLAIN:
// it's a usual assert
return expr;
case FR_CONJECTURE:
// it should be negated when asserted
return getExprManager()->mkExpr(kind::NOT, expr);
case FR_UNKNOWN:
case FR_FI_DOMAIN:
case FR_FI_FUNCTORS:
case FR_FI_PREDICATES:
case FR_TYPE:
// it does not correspond to an assertion
return d_nullExpr;
break;
}
assert(false); // unreachable
return d_nullExpr;
}
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;
}
Expr Tptp::convertStrToUnsorted(std::string str) {
Expr& e = d_distinct_objects[str];
if (e.isNull())
{
e = getExprManager()->mkVar(str, d_unsorted);
}
return e;
}
Expr Tptp::getAssertionDistinctConstants()
{
std::vector<Expr> constants;
for (std::pair<const std::string, Expr>& cs : d_distinct_objects)
{
constants.push_back(cs.second);
}
if (constants.size() > 1)
{
return getExprManager()->mkExpr(kind::DISTINCT, constants);
}
return d_nullExpr;
}
void Smt2::addTheory(Theory theory) {
switch(theory) {
case THEORY_ARRAYS:
Parser::addOperator(kind::SELECT);
Parser::addOperator(kind::STORE);
break;
case THEORY_BITVECTORS:
addBitvectorOperators();
break;
case THEORY_CORE:
defineType("Bool", getExprManager()->booleanType());
defineVar("true", getExprManager()->mkConst(true));
defineVar("false", getExprManager()->mkConst(false));
Parser::addOperator(kind::AND);
Parser::addOperator(kind::DISTINCT);
Parser::addOperator(kind::EQUAL);
Parser::addOperator(kind::IFF);
Parser::addOperator(kind::IMPLIES);
Parser::addOperator(kind::ITE);
Parser::addOperator(kind::NOT);
Parser::addOperator(kind::OR);
Parser::addOperator(kind::XOR);
break;
case THEORY_REALS_INTS:
defineType("Real", getExprManager()->realType());
Parser::addOperator(kind::DIVISION);
Parser::addOperator(kind::TO_INTEGER);
Parser::addOperator(kind::IS_INTEGER);
Parser::addOperator(kind::TO_REAL);
// falling through on purpose, to add Ints part of Reals_Ints
case THEORY_INTS:
defineType("Int", getExprManager()->integerType());
addArithmeticOperators();
Parser::addOperator(kind::INTS_DIVISION);
Parser::addOperator(kind::INTS_MODULUS);
Parser::addOperator(kind::ABS);
Parser::addOperator(kind::DIVISIBLE);
break;
case THEORY_REALS:
defineType("Real", getExprManager()->realType());
addArithmeticOperators();
Parser::addOperator(kind::DIVISION);
break;
case THEORY_QUANTIFIERS:
break;
case THEORY_SETS:
addOperator(kind::UNION, "union");
addOperator(kind::INTERSECTION, "intersection");
addOperator(kind::SETMINUS, "setminus");
addOperator(kind::SUBSET, "subset");
addOperator(kind::MEMBER, "member");
addOperator(kind::SINGLETON, "singleton");
addOperator(kind::INSERT, "insert");
break;
case THEORY_DATATYPES:
Parser::addOperator(kind::APPLY_CONSTRUCTOR);
Parser::addOperator(kind::APPLY_TESTER);
Parser::addOperator(kind::APPLY_SELECTOR);
Parser::addOperator(kind::APPLY_SELECTOR_TOTAL);
break;
case THEORY_STRINGS:
defineType("String", getExprManager()->stringType());
addStringOperators();
break;
case THEORY_UF:
Parser::addOperator(kind::APPLY_UF);
break;
default:
std::stringstream ss;
ss << "internal error: unsupported theory " << theory;
throw ParserException(ss.str());
}
}
