working on smt2 and api

src/api/api_ast.cpp

@@ -208,6 +208,7 @@ extern "C" {
     MK_BINARY(Z3_mk_xor, mk_c(c)->get_basic_fid(), OP_XOR, SKIP);
     MK_NARY(Z3_mk_and, mk_c(c)->get_basic_fid(), OP_AND, SKIP);
     MK_NARY(Z3_mk_or, mk_c(c)->get_basic_fid(), OP_OR, SKIP);
+    MK_UNARY(Z3_mk_interp, mk_c(c)->get_basic_fid(), OP_INTERP, SKIP);
 
     Z3_ast mk_ite_core(Z3_context c, Z3_ast t1, Z3_ast t2, Z3_ast t3) {
         expr * result = mk_c(c)->m().mk_ite(to_expr(t1), to_expr(t2), to_expr(t3));
@@ -927,6 +928,7 @@ extern "C" {
             case OP_NOT:      return Z3_OP_NOT;
             case OP_IMPLIES:  return Z3_OP_IMPLIES;
             case OP_OEQ:      return Z3_OP_OEQ;
+            case OP_INTERP:   return Z3_OP_INTERP;
 
             case PR_UNDEF:    return Z3_OP_PR_UNDEF;
             case PR_TRUE:     return Z3_OP_PR_TRUE;

src/api/api_interp.cpp

@@ -16,6 +16,7 @@ Revision History:
 
 --*/
 #include<iostream>
+#include<sstream>
 #include"z3.h"
 #include"api_log_macros.h"
 #include"api_context.h"
@@ -34,6 +35,8 @@ Revision History:
 #include"iz3interp.h"
 #include"iz3profiling.h"
 #include"iz3hash.h"
+#include"iz3pp.h"
+#include"iz3checker.h"
 
 #ifndef WIN32
 using namespace stl_ext;
@@ -47,8 +50,8 @@ extern "C" {
     if(!cfg) cfg = Z3_mk_config();
     Z3_set_param_value(cfg, "PROOF", "true");
     Z3_set_param_value(cfg, "MODEL", "true");
-    Z3_set_param_value(cfg, "PRE_SIMPLIFIER","false");
-    Z3_set_param_value(cfg, "SIMPLIFY_CLAUSES","false");
+    // Z3_set_param_value(cfg, "PRE_SIMPLIFIER","false");
+    // Z3_set_param_value(cfg, "SIMPLIFY_CLAUSES","false");
     
     Z3_context ctx = Z3_mk_context(cfg);
     Z3_del_config(cfg);
@@ -191,6 +194,64 @@ extern "C" {
 
   }
   
+  static std::ostringstream itp_err;
+
+  int Z3_check_interpolant(Z3_context ctx, 
+			    int num, 
+			    Z3_ast *cnsts, 
+			    int *parents,
+			    Z3_ast *itp,
+			    const char **error,
+			    int num_theory,
+			    Z3_ast *theory){
+
+    ast_manager &_m = mk_c(ctx)->m();
+    itp_err.clear();
+    
+    // need a solver -- make one here, but how?
+    params_ref p = params_ref::get_empty(); //FIXME
+    scoped_ptr<solver_factory> sf(mk_smt_solver_factory());
+    scoped_ptr<solver> sp((*(sf))(_m, p, false, true, false, symbol("AUFLIA")));
+    
+    ptr_vector<ast> cnsts_vec(num);  // get constraints in a vector
+    for(int i = 0; i < num; i++){
+      ast *a = to_ast(cnsts[i]);
+      cnsts_vec[i] = a;
+    }
+    
+    ptr_vector<ast> itp_vec(num);  // get interpolants in a vector
+    for(int i = 0; i < num-1; i++){
+      ast *a = to_ast(itp[i]);
+      itp_vec[i] = a;
+    }
+
+    ::vector<int> parents_vec;  // get parents in a vector
+    if(parents){
+      parents_vec.resize(num);
+      for(int i = 0; i < num; i++)
+	parents_vec[i] = parents[i];
+    }
+    
+    ptr_vector<ast> theory_vec; // get background theory in a vector
+    if(theory){
+      theory_vec.resize(num_theory);
+      for(int i = 0; i < num_theory; i++)
+	theory_vec[i] = to_ast(theory[i]);
+    }
+    
+    bool res = iz3check(_m,
+			sp.get(),
+			itp_err,
+			cnsts_vec,
+			parents_vec,
+			itp_vec,
+			theory_vec);
+
+    *error = res ? 0 : itp_err.str().c_str();
+    return res;
+  }
+
+
   static std::string Z3_profile_string;
   
   Z3_string Z3_interpolation_profile(Z3_context ctx){
@@ -258,6 +319,7 @@ static void get_file_params(const char *filename, hash_map<std::string,std::stri
 
 extern "C" {
 
+#if 0
   static void iZ3_write_seq(Z3_context ctx, int num, Z3_ast *cnsts, const char *filename, int num_theory, Z3_ast *theory){
     int num_fmlas = num+num_theory;
     std::vector<Z3_ast> fmlas(num_fmlas);
@@ -298,6 +360,89 @@ extern "C" {
     }
     iZ3_write_seq(ctx,num,&tcnsts[0],filename,num_theory,theory);
   }
+#else
+
+
+  static Z3_ast and_vec(Z3_context ctx,std::vector<Z3_ast> &c){
+    return (c.size() > 1) ? Z3_mk_and(ctx,c.size(),&c[0]) : c[0];
+  }
+  
+  static Z3_ast parents_vector_to_tree(Z3_context ctx, int num, Z3_ast *cnsts, int *parents){
+    Z3_ast res;
+    if(!parents){
+      res = Z3_mk_interp(ctx,cnsts[0]);
+      for(int i = 1; i < num-1; i++){
+	Z3_ast bar[2] = {res,cnsts[i]};
+	res = Z3_mk_interp(ctx,Z3_mk_and(ctx,2,bar));
+      }
+      if(num > 1){
+	Z3_ast bar[2] = {res,cnsts[num-1]};
+	res = Z3_mk_and(ctx,2,bar);
+      }
+    }
+    else {
+      std::vector<std::vector<Z3_ast> > chs(num);
+      for(int i = 0; i < num-1; i++){
+	std::vector<Z3_ast> &c = chs[i];
+	c.push_back(cnsts[i]);
+	Z3_ast foo = Z3_mk_interp(ctx,and_vec(ctx,c));
+	chs[parents[i]].push_back(foo);
+      }
+      {
+	std::vector<Z3_ast> &c = chs[num-1];
+	c.push_back(cnsts[num-1]);
+	res = and_vec(ctx,c);
+      }
+    }
+    Z3_inc_ref(ctx,res);
+    return res;
+  }
+
+  void Z3_write_interpolation_problem(Z3_context ctx, int num, Z3_ast *cnsts, int *parents, const char *filename, int num_theory, Z3_ast *theory){
+    std::ofstream f(filename);
+    if(num >  0){
+      ptr_vector<expr> cnsts_vec(num);  // get constraints in a vector
+      for(int i = 0; i < num; i++){
+	expr *a = to_expr(cnsts[i]);
+	cnsts_vec[i] = a;
+      }
+      Z3_ast tree = parents_vector_to_tree(ctx,num,cnsts,parents);
+      iz3pp(mk_c(ctx)->m(),cnsts_vec,to_expr(tree),f);
+      Z3_dec_ref(ctx,tree);
+    }
+    f.close();
+
+#if 0    
+
+    
+    if(!parents){
+      iZ3_write_seq(ctx,num,cnsts,filename,num_theory,theory);
+      return;
+    }
+    std::vector<Z3_ast> tcnsts(num);
+    hash_map<int,Z3_ast> syms;
+    for(int j = 0; j < num - 1; j++){
+      std::ostringstream oss;
+      oss << "$P" << j;
+      std::string name = oss.str();
+      Z3_symbol s = Z3_mk_string_symbol(ctx, name.c_str());
+      Z3_ast symbol = Z3_mk_const(ctx, s, Z3_mk_bool_sort(ctx));
+      syms[j] = symbol;
+      tcnsts[j] = Z3_mk_implies(ctx,cnsts[j],symbol);
+    }
+    tcnsts[num-1] = Z3_mk_implies(ctx,cnsts[num-1],Z3_mk_false(ctx));
+    for(int j = num-2; j >= 0; j--){
+      int parent = parents[j];
+      // assert(parent >= 0 && parent < num);
+      tcnsts[parent] = Z3_mk_implies(ctx,syms[j],tcnsts[parent]);
+    }
+    iZ3_write_seq(ctx,num,&tcnsts[0],filename,num_theory,theory);
+#endif
+
+  }
+
+
+#endif
 
   static std::vector<Z3_ast> read_cnsts;
   static std::vector<int> read_parents;
@@ -309,7 +454,7 @@ extern "C" {
     read_error.clear();
     try {
       std::string foo(filename);
-      if(!foo.empty() && foo[foo.size()-1] == '2'){
+      if(foo.size() >= 5 && foo.substr(foo.size()-5) == ".smt2"){
 	Z3_ast ass = Z3_parse_smtlib2_file(ctx, filename, 0, 0, 0, 0, 0, 0);
 	Z3_app app = Z3_to_app(ctx,ass);
 	int nconjs = Z3_get_app_num_args(ctx,app);

src/api/z3_api.h

@@ -249,6 +249,8 @@ typedef enum
    - Z3_OP_OEQ Binary equivalence modulo namings. This binary predicate is used in proof terms.
         It captures equisatisfiability and equivalence modulo renamings.
 
+   - Z3_OP_INTERP Marks a sub-formula for interpolation.
+
    - Z3_OP_ANUM Arithmetic numeral.
 
    - Z3_OP_AGNUM Arithmetic algebraic numeral. Algebraic numbers are used to represent irrational numbers in Z3.
@@ -890,6 +892,7 @@ typedef enum {
     Z3_OP_NOT,
     Z3_OP_IMPLIES,
     Z3_OP_OEQ,
+    Z3_OP_INTERP,
 
     // Arithmetic
     Z3_OP_ANUM = 0x200,
@@ -2102,6 +2105,16 @@ END_MLAPI_EXCLUDE
     */
     Z3_ast Z3_API Z3_mk_not(__in Z3_context c, __in Z3_ast a);
     
+    /**
+        \brief \mlh mk_interp c a \endmlh 
+        Create an AST node marking a formula position for interpolation.
+        
+        The node \c a must have Boolean sort.
+
+        def_API('Z3_mk_interp', AST, (_in(CONTEXT), _in(AST)))
+    */
+    Z3_ast Z3_API Z3_mk_interp(__in Z3_context c, __in Z3_ast a);
+    
     /**
        \brief \mlh mk_ite c t1 t2 t2 \endmlh 
        Create an AST node representing an if-then-else: <tt>ite(t1, t2,
@@ -7807,6 +7820,7 @@ END_MLAPI_EXCLUDE
      valuation of the vertices that makes all the implications true
      where each value is represented using the common symbols between
      the formulas in the subtree and the remainder of the formulas.
+
   */
   
 
@@ -7822,6 +7836,51 @@ END_MLAPI_EXCLUDE
 
 
 
+  /** Check the correctness of an interpolant. The Z3 context must
+      have no constraints asserted when this call is made. That means
+      that after interpolating, you must first fully pop the Z3
+      context before calling this. See Z3_interpolate for meaning of parameters.
+
+      \param ctx The Z3 context. Must be generated by Z3_mk_interpolation_context
+      \param num The number of constraints in the sequence
+      \param cnsts Array of constraints (AST's in context ctx)
+      \param parents The parents vector (or NULL for sequence)
+      \param interps The interpolant to check
+      \param error Returns an error message if interpolant incorrect (do not free the string)
+
+      Return value is Z3_L_TRUE if interpolant is verified, Z3_L_FALSE if
+      incorrect, and Z3_L_UNDEF if unknown.
+
+  */
+  
+  int Z3_API
+  Z3_check_interpolant(Z3_context ctx, int num, Z3_ast *cnsts, int *parents, Z3_ast *interps, const char **error,
+                                       int num_theory, Z3_ast *theory);
+
+  /** Write an interpolation problem to file suitable for reading with
+      Z3_read_interpolation_problem. The output file is a sequence
+      of SMT-LIB2 format commands, suitable for reading with command-line Z3
+      or other interpolating solvers.
+
+      \param ctx The Z3 context. Must be generated by z3_mk_interpolation_context
+      \param num The number of constraints in the sequence
+      \param cnsts Array of constraints
+      \param parents The parents vector (or NULL for sequence)
+      \param filename The file name to write
+
+  */
+
+  void Z3_API
+  Z3_write_interpolation_problem(Z3_context ctx,
+				 int num, 
+				 Z3_ast *cnsts, 
+				 int *parents,
+				 const char *filename,
+                                 int num_theory,
+				 Z3_ast *theory);
+
+
+
 #endif