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()); } }