merge

Signed-off-by: Miguel Angelo Da Terra Neves <t-mineve@microsoft.com>

src/api/api_goal.cpp

@@ -21,6 +21,7 @@ Revision History:
 #include "api/api_context.h"
 #include "api/api_goal.h"
 #include "ast/ast_translation.h"
+#include "api/api_model.h"
 
 extern "C" {
 
@@ -151,6 +152,20 @@ extern "C" {
         Z3_CATCH_RETURN(Z3_FALSE);
     }
 
+    Z3_model Z3_API Z3_goal_convert_model(Z3_context c, Z3_goal g, Z3_model m) {
+        Z3_TRY;
+        LOG_Z3_goal_convert_model(c, g, m);
+        RESET_ERROR_CODE();
+        model_ref new_m;
+        Z3_model_ref * m_ref = alloc(Z3_model_ref, *mk_c(c)); 
+        mk_c(c)->save_object(m_ref);
+        if (m) m_ref->m_model = to_model_ref(m)->copy(); 
+        if (to_goal_ref(g)->mc()) 
+            (*to_goal_ref(g)->mc())(m_ref->m_model);
+        RETURN_Z3(of_model(m_ref));
+        Z3_CATCH_RETURN(0);
+    }    
+
     Z3_goal Z3_API Z3_goal_translate(Z3_context c, Z3_goal g, Z3_context target) {
         Z3_TRY;
         LOG_Z3_goal_translate(c, g, target);

src/api/api_opt.cpp

@@ -16,6 +16,9 @@ Revision History:
 
 --*/
 #include<iostream>
+#include "util/cancel_eh.h"
+#include "util/scoped_timer.h"
+#include "util/file_path.h"
 #include "api/z3.h"
 #include "api/api_log_macros.h"
 #include "api/api_stats.h"
@@ -24,11 +27,11 @@ Revision History:
 #include "api/api_model.h"
 #include "opt/opt_context.h"
 #include "opt/opt_cmds.h"
-#include "util/cancel_eh.h"
-#include "util/scoped_timer.h"
+#include "opt/opt_parse.h"
 #include "parsers/smt2/smt2parser.h"
 #include "api/api_ast_vector.h"
 
+
 extern "C" {
 
     struct Z3_optimize_ref : public api::object {
@@ -286,8 +289,19 @@ extern "C" {
     static void Z3_optimize_from_stream(
         Z3_context    c,
         Z3_optimize opt,
-        std::istream& s) {
-        ast_manager& m = mk_c(c)->m();
+        std::istream& s, 
+        char const* ext) {
+        ast_manager& m = mk_c(c)->m();        
+        if (ext && std::string("opb") == ext) {
+            unsigned_vector h;
+            parse_opb(*to_optimize_ptr(opt), s, h);
+            return;
+        }
+        if (ext && std::string("wcnf") == ext) {
+            unsigned_vector h;
+            parse_wcnf(*to_optimize_ptr(opt), s, h);
+            return;
+        }
         scoped_ptr<cmd_context> ctx = alloc(cmd_context, false, &m);
         install_opt_cmds(*ctx.get(), to_optimize_ptr(opt));
         ctx->set_ignore_check(true);
@@ -311,7 +325,7 @@ extern "C" {
         //LOG_Z3_optimize_from_string(c, d, s);
         std::string str(s);
         std::istringstream is(str);
-        Z3_optimize_from_stream(c, d, is);
+        Z3_optimize_from_stream(c, d, is, nullptr);
         Z3_CATCH;
     }
 
@@ -327,7 +341,7 @@ extern "C" {
             strm << "Could not open file " << s;
             throw default_exception(strm.str());
         }
-        Z3_optimize_from_stream(c, d, is);
+        Z3_optimize_from_stream(c, d, is, get_extension(s));
         Z3_CATCH;
     }
 

src/api/api_solver.cpp

@@ -29,12 +29,16 @@ Revision History:
 #include "util/scoped_ctrl_c.h"
 #include "util/cancel_eh.h"
 #include "util/scoped_timer.h"
+#include "util/file_path.h"
 #include "tactic/portfolio/smt_strategic_solver.h"
 #include "smt/smt_solver.h"
 #include "smt/smt_implied_equalities.h"
 #include "solver/smt_logics.h"
 #include "cmd_context/cmd_context.h"
 #include "parsers/smt2/smt2parser.h"
+#include "sat/dimacs.h"
+#include "sat/sat_solver.h"
+#include "sat/tactic/goal2sat.h"
 
 
 extern "C" {
@@ -127,13 +131,30 @@ extern "C" {
     void Z3_API Z3_solver_from_file(Z3_context c, Z3_solver s, Z3_string file_name) {
         Z3_TRY;
         LOG_Z3_solver_from_file(c, s, file_name);
-        scoped_ptr<cmd_context> ctx = alloc(cmd_context, false, &(mk_c(c)->m()));
-        ctx->set_ignore_check(true);
+        char const* ext = get_extension(file_name);
         std::ifstream is(file_name);
         if (!is) {
             SET_ERROR_CODE(Z3_FILE_ACCESS_ERROR);
             return;
         }
+        if (ext && std::string("dimacs") == ext) {
+            ast_manager& m = to_solver_ref(s)->get_manager();
+            sat::solver solver(to_solver_ref(s)->get_params(), m.limit());
+            parse_dimacs(is, solver);
+            sat2goal s2g;
+            model_converter_ref mc;
+            atom2bool_var a2b(m);
+            goal g(m);            
+            s2g(solver, a2b, to_solver_ref(s)->get_params(), g, mc);
+            for (unsigned i = 0; i < g.size(); ++i) {
+                to_solver_ref(s)->assert_expr(g.form(i));
+            }
+            return;
+        }
+
+        scoped_ptr<cmd_context> ctx = alloc(cmd_context, false, &(mk_c(c)->m()));
+        ctx->set_ignore_check(true);
+
         if (!parse_smt2_commands(*ctx.get(), is)) {
             ctx = nullptr;
             SET_ERROR_CODE(Z3_PARSER_ERROR);

src/api/api_tactic.cpp

@@ -25,25 +25,25 @@ Revision History:
 #include "util/cancel_eh.h"
 #include "util/scoped_timer.h"
 
-Z3_apply_result_ref::Z3_apply_result_ref(api::context& c, ast_manager & m): api::object(c), m_core(m) {
+Z3_apply_result_ref::Z3_apply_result_ref(api::context& c, ast_manager & m): api::object(c) {
 }
 
 extern "C" {
 
-#define RETURN_TACTIC(_t_) {                            \
+#define RETURN_TACTIC(_t_) {                                    \
         Z3_tactic_ref * _ref_ = alloc(Z3_tactic_ref, *mk_c(c)); \
-    _ref_->m_tactic   = _t_;                            \
-    mk_c(c)->save_object(_ref_);                        \
-    Z3_tactic _result_  = of_tactic(_ref_);             \
-    RETURN_Z3(_result_);                                \
+        _ref_->m_tactic   = _t_;                                \
+        mk_c(c)->save_object(_ref_);                            \
+        Z3_tactic _result_  = of_tactic(_ref_);                 \
+        RETURN_Z3(_result_);                                    \
 }
 
-#define RETURN_PROBE(_t_) {                     \
+#define RETURN_PROBE(_t_) {                                     \
         Z3_probe_ref * _ref_ = alloc(Z3_probe_ref, *mk_c(c));   \
-    _ref_->m_probe   = _t_;                     \
-    mk_c(c)->save_object(_ref_);                \
-    Z3_probe _result_  = of_probe(_ref_);       \
-    RETURN_Z3(_result_);                        \
+        _ref_->m_probe   = _t_;                                 \
+        mk_c(c)->save_object(_ref_);                            \
+        Z3_probe _result_  = of_probe(_ref_);                   \
+        RETURN_Z3(_result_);                                    \
 }
 
     Z3_tactic Z3_API Z3_mk_tactic(Z3_context c, Z3_string name) {
@@ -418,7 +418,9 @@ extern "C" {
             scoped_ctrl_c ctrlc(eh, false, use_ctrl_c);
             scoped_timer timer(timeout, &eh);
             try {
-                exec(*to_tactic_ref(t), new_goal, ref->m_subgoals, ref->m_mc, ref->m_pc, ref->m_core);
+                exec(*to_tactic_ref(t), new_goal, ref->m_subgoals);
+                ref->m_pc = new_goal->pc();
+                ref->m_mc = new_goal->mc();
                 return of_apply_result(ref);
             }
             catch (z3_exception & ex) {
@@ -513,22 +515,4 @@ extern "C" {
         Z3_CATCH_RETURN(0);
     }
     
-    Z3_model Z3_API Z3_apply_result_convert_model(Z3_context c, Z3_apply_result r, unsigned i, Z3_model m) {
-        Z3_TRY;
-        LOG_Z3_apply_result_convert_model(c, r, i, m);
-        RESET_ERROR_CODE();
-        if (i > to_apply_result(r)->m_subgoals.size()) {
-            SET_ERROR_CODE(Z3_IOB);
-            RETURN_Z3(0);
-        }
-        model_ref new_m = to_model_ref(m)->copy();
-        if (to_apply_result(r)->m_mc)
-            to_apply_result(r)->m_mc->operator()(new_m, i);
-        Z3_model_ref * m_ref = alloc(Z3_model_ref, *mk_c(c)); 
-        m_ref->m_model = new_m;
-        mk_c(c)->save_object(m_ref);
-        RETURN_Z3(of_model(m_ref));
-        Z3_CATCH_RETURN(0);
-    }
-
 };

src/api/api_tactic.h

@@ -50,7 +50,6 @@ struct Z3_apply_result_ref : public api::object {
     goal_ref_buffer      m_subgoals;
     model_converter_ref  m_mc;
     proof_converter_ref  m_pc;
-    expr_dependency_ref  m_core;
     Z3_apply_result_ref(api::context& c, ast_manager & m);
     virtual ~Z3_apply_result_ref() {}
 };

src/api/c++/z3++.h

@@ -2104,6 +2104,17 @@ namespace z3 {
         unsigned num_exprs() const { return Z3_goal_num_exprs(ctx(), m_goal); }
         bool is_decided_sat() const { return Z3_goal_is_decided_sat(ctx(), m_goal) != 0; }
         bool is_decided_unsat() const { return Z3_goal_is_decided_unsat(ctx(), m_goal) != 0; }
+        model convert_model(model const & m) const {
+            check_context(*this, m);
+            Z3_model new_m = Z3_goal_convert_model(ctx(), m_goal, m);
+            check_error();
+            return model(ctx(), new_m);
+        }
+        model get_model() const {
+            Z3_model new_m = Z3_goal_convert_model(ctx(), m_goal, 0);
+            check_error();
+            return model(ctx(), new_m);
+        }
         expr as_expr() const {
             unsigned n = size();
             if (n == 0)
@@ -2142,12 +2153,6 @@ namespace z3 {
         }
         unsigned size() const { return Z3_apply_result_get_num_subgoals(ctx(), m_apply_result); }
         goal operator[](int i) const { assert(0 <= i); Z3_goal r = Z3_apply_result_get_subgoal(ctx(), m_apply_result, i); check_error(); return goal(ctx(), r); }
-        model convert_model(model const & m, unsigned i = 0) const {
-            check_context(*this, m);
-            Z3_model new_m = Z3_apply_result_convert_model(ctx(), m_apply_result, i, m);
-            check_error();
-            return model(ctx(), new_m);
-        }
         friend std::ostream & operator<<(std::ostream & out, apply_result const & r);
     };
     inline std::ostream & operator<<(std::ostream & out, apply_result const & r) { out << Z3_apply_result_to_string(r.ctx(), r); return out; }

src/api/dotnet/ApplyResult.cs

@@ -55,19 +55,6 @@ namespace Microsoft.Z3
             }
         }
 
-        /// <summary>
-        /// Convert a model for the subgoal <paramref name="i"/> into a model for the original 
-        /// goal <c>g</c>, that the ApplyResult was obtained from. 
-        /// </summary>
-        /// <returns>A model for <c>g</c></returns>
-        public Model ConvertModel(uint i, Model m)
-        {
-            Contract.Requires(m != null);
-            Contract.Ensures(Contract.Result<Model>() != null);
-
-            return new Model(Context, Native.Z3_apply_result_convert_model(Context.nCtx, NativeObject, i, m.NativeObject));
-        }
-
         /// <summary>
         /// A string representation of the ApplyResult.
         /// </summary>

src/api/dotnet/Goal.cs

@@ -174,6 +174,21 @@ namespace Microsoft.Z3
             get { return Native.Z3_goal_is_decided_unsat(Context.nCtx, NativeObject) != 0; }
         }
 
+	/// <summary>
+	/// Convert a model for the goal into a model of the
+        /// original goal from which this goal was derived.
+        /// </summary>
+        /// <returns>A model for <c>g</c></returns>
+        public Model ConvertModel(Model m)
+        {
+            Contract.Ensures(Contract.Result<Model>() != null);
+            if (m != null)
+               return new Model(Context, Native.Z3_goal_convert_model(Context.nCtx, NativeObject, m.NativeObject));
+            else
+               return new Model(Context, Native.Z3_goal_convert_model(Context.nCtx, NativeObject, IntPtr.Zero));
+        }
+
+
         /// <summary>
         /// Translates (copies) the Goal to the target Context <paramref name="ctx"/>.
         /// </summary>

src/api/java/ApplyResult.java

@@ -46,19 +46,6 @@ public class ApplyResult extends Z3Object {
         return res;
     }
 
-    /**
-     * Convert a model for the subgoal {@code i} into a model for the
-     * original goal {@code g}, that the ApplyResult was obtained from.
-     * 
-     * @return A model for {@code g}
-     * @throws Z3Exception
-     **/
-    public Model convertModel(int i, Model m)
-    {
-        return new Model(getContext(), 
-            Native.applyResultConvertModel(getContext().nCtx(), getNativeObject(), i, m.getNativeObject()));
-    }
-
     /**
      * A string representation of the ApplyResult.
      **/

src/api/java/Goal.java

@@ -240,6 +240,21 @@ public class Goal extends Z3Object {
             (unsatCores), (proofs)));
     }
 
+    /**
+     * Convert a model for the goal into a model of the
+     * original goal from which this goal was derived.
+     * 
+     * @return A model for {@code g}
+     * @throws Z3Exception
+     **/
+    public Model convertModel(Model m)
+    {
+        return new Model(getContext(), 
+            Native.goalConvertModel(getContext().nCtx(), getNativeObject(), m.getNativeObject()));
+    }
+
+
+
     @Override
     void incRef() {
         Native.goalIncRef(getContext().nCtx(), getNativeObject());

src/api/python/z3/z3.py

@@ -4964,6 +4964,35 @@ class Goal(Z3PPObject):
         """
         self.assert_exprs(*args)
 
+    def convert_model(self, model):
+        """Retrieve model from a satisfiable goal
+        >>> a, b = Ints('a b')
+        >>> g = Goal()
+        >>> g.add(Or(a == 0, a == 1), Or(b == 0, b == 1), a > b)
+        >>> t = Then(Tactic('split-clause'), Tactic('solve-eqs'))
+        >>> r = t(g)
+        >>> r[0]
+        [Or(b == 0, b == 1), Not(0 <= b)]
+        >>> r[1]
+        [Or(b == 0, b == 1), Not(1 <= b)]
+        >>> # Remark: the subgoal r[0] is unsatisfiable
+        >>> # Creating a solver for solving the second subgoal
+        >>> s = Solver()
+        >>> s.add(r[1])
+        >>> s.check()
+        sat
+        >>> s.model()
+        [b = 0]
+        >>> # Model s.model() does not assign a value to `a`
+        >>> # It is a model for subgoal `r[1]`, but not for goal `g`
+        >>> # The method convert_model creates a model for `g` from a model for `r[1]`.
+        >>> r[1].convert_model(s.model())
+        [b = 0, a = 1]
+        """
+        if __debug__:
+            _z3_assert(isinstance(model, ModelRef), "Z3 Model expected")
+        return ModelRef(Z3_goal_convert_model(self.ctx.ref(), self.goal, model.model), self.ctx)
+
     def __repr__(self):
         return obj_to_string(self)
 
@@ -7072,36 +7101,6 @@ class ApplyResult(Z3PPObject):
         """Return a textual representation of the s-expression representing the set of subgoals in `self`."""
         return Z3_apply_result_to_string(self.ctx.ref(), self.result)
 
-    def convert_model(self, model, idx=0):
-        """Convert a model for a subgoal into a model for the original goal.
-
-        >>> a, b = Ints('a b')
-        >>> g = Goal()
-        >>> g.add(Or(a == 0, a == 1), Or(b == 0, b == 1), a > b)
-        >>> t = Then(Tactic('split-clause'), Tactic('solve-eqs'))
-        >>> r = t(g)
-        >>> r[0]
-        [Or(b == 0, b == 1), Not(0 <= b)]
-        >>> r[1]
-        [Or(b == 0, b == 1), Not(1 <= b)]
-        >>> # Remark: the subgoal r[0] is unsatisfiable
-        >>> # Creating a solver for solving the second subgoal
-        >>> s = Solver()
-        >>> s.add(r[1])
-        >>> s.check()
-        sat
-        >>> s.model()
-        [b = 0]
-        >>> # Model s.model() does not assign a value to `a`
-        >>> # It is a model for subgoal `r[1]`, but not for goal `g`
-        >>> # The method convert_model creates a model for `g` from a model for `r[1]`.
-        >>> r.convert_model(s.model(), 1)
-        [b = 0, a = 1]
-        """
-        if __debug__:
-            _z3_assert(idx < len(self), "index out of bounds")
-            _z3_assert(isinstance(model, ModelRef), "Z3 Model expected")
-        return ModelRef(Z3_apply_result_convert_model(self.ctx.ref(), self.result, idx, model.model), self.ctx)
 
     def as_expr(self):
         """Return a Z3 expression consisting of all subgoals.
@@ -8057,13 +8056,13 @@ def parse_smt2_string(s, sorts={}, decls={}, ctx=None):
     the symbol table used for the SMT 2.0 parser.
 
     >>> parse_smt2_string('(declare-const x Int) (assert (> x 0)) (assert (< x 10))')
-    And(x > 0, x < 10)
+    [x > 0, x < 10]
     >>> x, y = Ints('x y')
     >>> f = Function('f', IntSort(), IntSort())
     >>> parse_smt2_string('(assert (> (+ foo (g bar)) 0))', decls={ 'foo' : x, 'bar' : y, 'g' : f})
-    x + f(y) > 0
+    [x + f(y) > 0]
     >>> parse_smt2_string('(declare-const a U) (assert (> a 0))', sorts={ 'U' : IntSort() })
-    a > 0
+    [a > 0]
     """
     ctx = _get_ctx(ctx)
     ssz, snames, ssorts = _dict2sarray(sorts, ctx)

src/api/z3_api.h

@@ -5561,6 +5561,15 @@ extern "C" {
     */
     Z3_goal Z3_API Z3_goal_translate(Z3_context source, Z3_goal g, Z3_context target);
 
+    /**
+       \brief Convert a model of the formulas of a goal to a model of an original goal.
+       The model may be null, in which case the returned model is valid if the goal was
+       established satisfiable.
+
+       def_API('Z3_goal_convert_model', MODEL, (_in(CONTEXT), _in(GOAL), _in(MODEL)))
+    */
+    Z3_model Z3_API Z3_goal_convert_model(Z3_context c, Z3_goal g, Z3_model m);
+
     /**
        \brief Convert a goal into a string.
 
@@ -5927,14 +5936,6 @@ extern "C" {
     */
     Z3_goal Z3_API Z3_apply_result_get_subgoal(Z3_context c, Z3_apply_result r, unsigned i);
 
-    /**
-       \brief Convert a model for the subgoal \c Z3_apply_result_get_subgoal(c, r, i) into a model for the original goal \c g.
-       Where \c g is the goal used to create \c r using \c Z3_tactic_apply(c, t, g).
-
-       def_API('Z3_apply_result_convert_model', MODEL, (_in(CONTEXT), _in(APPLY_RESULT), _in(UINT), _in(MODEL)))
-    */
-    Z3_model Z3_API Z3_apply_result_convert_model(Z3_context c, Z3_apply_result r, unsigned i, Z3_model m);
-
     /*@}*/
 
     /** @name Solvers*/