Merge remote-tracking branch 'upstream/master' into release-1.0

src/api/api_opt.cpp

@@ -218,6 +218,34 @@ extern "C" {
         Z3_CATCH_RETURN(0);
     }
 
+    // get lower value or current approximation
+    Z3_ast_vector Z3_API Z3_optimize_get_lower_as_vector(Z3_context c, Z3_optimize o, unsigned idx) {
+        Z3_TRY;
+        LOG_Z3_optimize_get_lower_as_vector(c, o, idx);
+        RESET_ERROR_CODE();
+        expr_ref_vector es(mk_c(c)->m());
+        to_optimize_ptr(o)->get_lower(idx, es);
+        Z3_ast_vector_ref * v = alloc(Z3_ast_vector_ref, *mk_c(c), mk_c(c)->m());
+        mk_c(c)->save_object(v);
+        v->m_ast_vector.append(es.size(), (ast*const*)es.c_ptr());
+        RETURN_Z3(of_ast_vector(v));
+        Z3_CATCH_RETURN(0);
+    }
+
+    // get upper or current approximation
+    Z3_ast_vector Z3_API Z3_optimize_get_upper_as_vector(Z3_context c, Z3_optimize o, unsigned idx) {
+        Z3_TRY;
+        LOG_Z3_optimize_get_upper_as_vector(c, o, idx);
+        RESET_ERROR_CODE();
+        expr_ref_vector es(mk_c(c)->m());
+        to_optimize_ptr(o)->get_upper(idx, es);
+        Z3_ast_vector_ref * v = alloc(Z3_ast_vector_ref, *mk_c(c), mk_c(c)->m());
+        mk_c(c)->save_object(v);
+        v->m_ast_vector.append(es.size(), (ast*const*)es.c_ptr());
+        RETURN_Z3(of_ast_vector(v));
+        Z3_CATCH_RETURN(0);
+    }
+
     Z3_string Z3_API Z3_optimize_to_string(Z3_context c, Z3_optimize o) {
         Z3_TRY;
         LOG_Z3_optimize_to_string(c, o);

src/api/dotnet/Optimize.cs

@@ -144,6 +144,23 @@ namespace Microsoft.Z3
             {
                 get { return Lower; }
             }
+
+            /// <summary>
+            /// Retrieve a lower bound for the objective handle.
+            /// </summary>        	   	
+            public ArithExpr[] LowerAsVector
+            {
+                get { return opt.GetLowerAsVector(handle); }
+            }
+
+            /// <summary>
+            /// Retrieve an upper bound for the objective handle.
+            /// </summary>        	   	
+            public ArithExpr[] UpperAsVector
+            {
+                get { return opt.GetUpperAsVector(handle); }
+            }
+
         }
 
         /// <summary>
@@ -255,6 +272,25 @@ namespace Microsoft.Z3
             return (ArithExpr)Expr.Create(Context, Native.Z3_optimize_get_upper(Context.nCtx, NativeObject, index));
         }
 
+        /// <summary>
+        /// Retrieve a lower bound for the objective handle.
+        /// </summary>        	
+        private ArithExpr[] GetLowerAsVector(uint index)
+        {
+            ASTVector v = new ASTVector(Context, Native.Z3_optimize_get_lower_as_vector(Context.nCtx, NativeObject, index));
+            return v.ToArithExprArray();
+        }
+
+
+        /// <summary>
+        /// Retrieve an upper bound for the objective handle.
+        /// </summary>        	
+        private ArithExpr[] GetUpperAsVector(uint index)
+        {
+            ASTVector v = new ASTVector(Context, Native.Z3_optimize_get_upper_as_vector(Context.nCtx, NativeObject, index));
+            return v.ToArithExprArray();
+        }
+
 	/// <summary>
 	/// Return a string the describes why the last to check returned unknown
 	/// </summary>	

src/api/java/Optimize.java

@@ -14,7 +14,6 @@ Author:
     Nikolaj Bjorner (nbjorner) 2015-07-16
 
 Notes:
-    
 **/
 
 package com.microsoft.z3;
@@ -23,10 +22,10 @@ import com.microsoft.z3.enumerations.Z3_lbool;
 
 
 /**
- * Object for managing optimizization context
+ * Object for managing optimization context
  **/
-public class Optimize extends Z3Object
+public class Optimize extends Z3Object {
-{
+
     /**
      * A string that describes all available optimize solver parameters.
      **/
@@ -55,7 +54,7 @@ public class Optimize extends Z3Object
 
     /**
      * Assert a constraint (or multiple) into the optimize solver.
-     **/        
+     **/
     public void Assert(BoolExpr ... constraints)
     {
         getContext().checkContextMatch(constraints);
@@ -67,80 +66,101 @@ public class Optimize extends Z3Object
 
     /**
      * Alias for Assert.
-     **/        
+     **/
     public void Add(BoolExpr ... constraints)
     {
-	Assert(constraints);
+        Assert(constraints);
     }
-    
+
     /**
      * Handle to objectives returned by objective functions.
      **/
-    public class Handle
+    public static class Handle {
-    {
-	Optimize opt;
-	int handle;
-	Handle(Optimize opt, int h)
-	{
-	    this.opt = opt;
-	    this.handle = h;
-	}
-	
-	/**
-	 * Retrieve a lower bound for the objective handle.
-	 **/        	   	
-	public ArithExpr getLower()
-	{
-	    return opt.GetLower(handle); 
-	}
-	
-	/**            
-	 * Retrieve an upper bound for the objective handle.
-	 **/        	   	
-	public ArithExpr getUpper()
-	{
-	    return opt.GetUpper(handle); 
-	}
-	
-	/**
-	 * Retrieve the value of an objective.
-	 **/        	   	
-	public ArithExpr getValue()
-	{
-	    return getLower(); 
-	}
 
-	/**
+        private final Optimize opt;
-	 * Print a string representation of the handle.
+        private final int handle;
-	 **/
+
-    @Override
+        Handle(Optimize opt, int h)
-    public String toString()
+        {
+            this.opt = opt;
+            this.handle = h;
+        }
+
+        /**
+         * Retrieve a lower bound for the objective handle.
+         **/
+        public ArithExpr getLower()
+        {
+            return opt.GetLower(handle);
+        }
+
+        /**
+         * Retrieve an upper bound for the objective handle.
+         **/
+        public ArithExpr getUpper()
+        {
+            return opt.GetUpper(handle);
+        }
+
+        /**
+         * @return a triple representing the upper bound of the objective handle.
+         *
+         * The triple contains values {@code inf, value, eps},
+         * where the objective value is unbounded iff {@code inf} is non-zero,
+         * and otherwise is represented by the expression {@code value + eps * EPSILON},
+         * where {@code EPSILON} is an arbitrarily small real number.
+         */
+        public ArithExpr[] getUpperAsVector()
+        {
+            return opt.GetUpperAsVector(handle);
+        }
+
+        /**
+         * @return a triple representing the upper bound of the objective handle.
+         *
+         * <p>See {@link #getUpperAsVector()} for triple semantics.
+         */
+        public ArithExpr[] getLowerAsVector()
+        {
+            return opt.GetLowerAsVector(handle);
+        }
+
+        /**
+         * Retrieve the value of an objective.
+         **/
+        public ArithExpr getValue()
+        {
+            return getLower();
+        }
+
+        /**
+         * Print a string representation of the handle.
+         **/
+        @Override
+        public String toString()
         {
             return getValue().toString();
         }
     }
 
-    /**        
+    /**
      * Assert soft constraint
      *
      * Return an objective which associates with the group of constraints.
      *
-     **/        
+     **/
-
     public Handle AssertSoft(BoolExpr constraint, int weight, String group)
     {
         getContext().checkContextMatch(constraint);
         Symbol s = getContext().mkSymbol(group);
         return new Handle(this, Native.optimizeAssertSoft(getContext().nCtx(), getNativeObject(), constraint.getNativeObject(), Integer.toString(weight), s.getNativeObject()));
     }
-    
 
-    /**        
+    /**
      * Check satisfiability of asserted constraints.
      * Produce a model that (when the objectives are bounded and 
      * don't use strict inequalities) meets the objectives.
      **/
-
     public Status Check()
     {
         Z3_lbool r = Z3_lbool.fromInt(Native.optimizeCheck(getContext().nCtx(), getNativeObject()));
@@ -153,7 +173,7 @@ public class Optimize extends Z3Object
                 return Status.UNKNOWN;
         }
     }
-    
+
     /**
      * Creates a backtracking point.
      **/
@@ -162,13 +182,11 @@ public class Optimize extends Z3Object
         Native.optimizePush(getContext().nCtx(), getNativeObject());
     }
 
-
+    /**
-    /** 
      * Backtrack one backtracking point.
      *
      * Note that an exception is thrown if Pop is called without a corresponding Push.
      **/
-     
     public void Pop()
     {
         Native.optimizePop(getContext().nCtx(), getNativeObject());
@@ -191,7 +209,7 @@ public class Optimize extends Z3Object
         }
     }
 
-    /** 
+    /**
      *  Declare an arithmetical maximization objective.
      *  Return a handle to the objective. The handle is used as
      *  to retrieve the values of objectives after calling Check.
@@ -200,11 +218,11 @@ public class Optimize extends Z3Object
     {
         return new Handle(this, Native.optimizeMaximize(getContext().nCtx(), getNativeObject(), e.getNativeObject()));
     }
-    
+
     /**
      *  Declare an arithmetical minimization objective. 
      *  Similar to MkMaximize.
-     **/        	
+     **/
     public Handle MkMinimize(ArithExpr e)
     {
         return new Handle(this, Native.optimizeMinimize(getContext().nCtx(), getNativeObject(), e.getNativeObject()));
@@ -212,21 +230,56 @@ public class Optimize extends Z3Object
     
     /**
      *  Retrieve a lower bound for the objective handle.
-     **/        	
+     **/
     private ArithExpr GetLower(int index)
     {
         return (ArithExpr)Expr.create(getContext(), Native.optimizeGetLower(getContext().nCtx(), getNativeObject(), index));
     }
-    
+
-    
     /**
      *  Retrieve an upper bound for the objective handle.
-     **/        	
+     **/
     private ArithExpr GetUpper(int index)
     {
         return (ArithExpr)Expr.create(getContext(), Native.optimizeGetUpper(getContext().nCtx(), getNativeObject(), index));
     }
 
+    /**
+     * @return Triple representing the upper bound for the objective handle.
+     *
+     * <p>See {@link Handle#getUpperAsVector}.
+     */
+    private ArithExpr[] GetUpperAsVector(int index) {
+        return unpackObjectiveValueVector(
+                Native.optimizeGetUpperAsVector(
+                        getContext().nCtx(), getNativeObject(), index
+                )
+        );
+    }
+
+    /**
+     * @return Triple representing the upper bound for the objective handle.
+     *
+     * <p>See {@link Handle#getLowerAsVector}.
+     */
+    private ArithExpr[] GetLowerAsVector(int index) {
+        return unpackObjectiveValueVector(
+                Native.optimizeGetLowerAsVector(
+                        getContext().nCtx(), getNativeObject(), index
+                )
+        );
+    }
+
+    private ArithExpr[] unpackObjectiveValueVector(long nativeVec) {
+        ASTVector vec = new ASTVector(
+                getContext(), nativeVec
+        );
+        return new ArithExpr[] {
+                (ArithExpr) vec.get(0), (ArithExpr) vec.get(1), (ArithExpr) vec.get(2)
+        };
+
+    }
+
     /**
      * Return a string the describes why the last to check returned unknown
      **/
@@ -235,8 +288,7 @@ public class Optimize extends Z3Object
         return Native.optimizeGetReasonUnknown(getContext().nCtx(),
                 getNativeObject());	
     }
-    
+
-    
     /**
      *  Print the context to a String (SMT-LIB parseable benchmark).
      **/
@@ -245,7 +297,7 @@ public class Optimize extends Z3Object
     {
         return Native.optimizeToString(getContext().nCtx(), getNativeObject());
     }
-    
+
     /**
      *  Optimize statistics.
      **/

src/api/python/z3/z3.py

@@ -6719,12 +6719,24 @@ class OptimizeObjective:
         opt = self._opt
         return _to_expr_ref(Z3_optimize_get_upper(opt.ctx.ref(), opt.optimize, self._value), opt.ctx)
 
+    def lower_values(self):
+        opt = self._opt
+        return AstVector(Z3_optimize_get_lower_as_vector(opt.ctx.ref(), opt.optimize, self._value), opt.ctx)
+
+    def upper_values(self):
+        opt = self._opt
+        return AstVector(Z3_optimize_get_upper_as_vector(opt.ctx.ref(), opt.optimize, self._value), opt.ctx)
+
     def value(self):
         if self._is_max:
             return self.upper()
         else:
             return self.lower()
 
+    def __str__(self):
+        return "%s:%s" % (self._value, self._is_max)
+
+
 class Optimize(Z3PPObject):
     """Optimize API provides methods for solving using objective functions and weighted soft constraints"""
 
@@ -6829,6 +6841,16 @@ class Optimize(Z3PPObject):
             raise Z3Exception("Expecting objective handle returned by maximize/minimize")
         return obj.upper()
 
+    def lower_values(self, obj):
+        if not isinstance(obj, OptimizeObjective):
+            raise Z3Exception("Expecting objective handle returned by maximize/minimize")
+        return obj.lower_values()
+
+    def upper_values(self, obj):
+        if not isinstance(obj, OptimizeObjective):
+            raise Z3Exception("Expecting objective handle returned by maximize/minimize")
+        return obj.upper_values()
+
     def from_file(self, filename):
         """Parse assertions and objectives from a file"""
         Z3_optimize_from_file(self.ctx.ref(), self.optimize, filename)

src/api/z3_optimization.h

@@ -186,6 +186,33 @@ extern "C" {
     */
     Z3_ast Z3_API Z3_optimize_get_upper(Z3_context c, Z3_optimize o, unsigned idx);
 
+
+    /**
+       \brief Retrieve lower bound value or approximation for the i'th optimization objective.
+              The returned vector is of length 3. It always contains numerals.
+              The three numerals are coefficients a, b, c and encode the result of \c Z3_optimize_get_lower
+              a * infinity + b + c * epsilon.
+              
+       \param c - context
+       \param o - optimization context
+       \param idx - index of optimization objective
+
+       def_API('Z3_optimize_get_lower_as_vector', AST_VECTOR, (_in(CONTEXT), _in(OPTIMIZE), _in(UINT)))
+    */
+    Z3_ast_vector Z3_API Z3_optimize_get_lower_as_vector(Z3_context c, Z3_optimize o, unsigned idx);
+
+    /**
+       \brief Retrieve upper bound value or approximation for the i'th optimization objective.
+
+       \param c - context
+       \param o - optimization context
+       \param idx - index of optimization objective
+
+       def_API('Z3_optimize_get_upper_as_vector', AST_VECTOR, (_in(CONTEXT), _in(OPTIMIZE), _in(UINT)))
+    */
+    Z3_ast_vector Z3_API Z3_optimize_get_upper_as_vector(Z3_context c, Z3_optimize o, unsigned idx);
+
+
     /**
        \brief Print the current context as a string.
        \param c - context.

src/ast/rewriter/enum2bv_rewriter.cpp

@@ -85,7 +85,7 @@ struct enum2bv_rewriter::imp {
 
         void throw_non_fd(expr* e) {
             std::stringstream strm;
-            strm << "unabled nested data-type expression " << mk_pp(e, m);
+            strm << "unable to handle nested data-type expression " << mk_pp(e, m);
             throw rewriter_exception(strm.str().c_str());
         }
 

src/ast/seq_decl_plugin.cpp

@@ -473,6 +473,7 @@ void seq_decl_plugin::init() {
     sort* str2TintT[3] = { strT, strT, intT };
     sort* seqAintT[2] = { seqA, intT };
     sort* seq3A[3] = { seqA, seqA, seqA };
+    sort* reTintT[2] = { reT, intT };
     m_sigs.resize(LAST_SEQ_OP);
     // TBD: have (par ..) construct and load parameterized signature from premable.
     m_sigs[OP_SEQ_UNIT]      = alloc(psig, m, "seq.unit",     1, 1, &A, seqA);
@@ -516,6 +517,7 @@ void seq_decl_plugin::init() {
     m_sigs[_OP_REGEXP_EMPTY]      = alloc(psig, m, "re.nostr", 0, 0, 0, reT);
     m_sigs[_OP_REGEXP_FULL]       = alloc(psig, m, "re.allchar", 0, 0, 0, reT);
     m_sigs[_OP_STRING_SUBSTR]     = alloc(psig, m, "str.substr", 0, 3, strTint2T, strT);
+    m_sigs[_OP_RE_UNROLL]         = alloc(psig, m, "_re.unroll", 0, 2, reTintT, strT);
 }
 
 void seq_decl_plugin::set_manager(ast_manager* m, family_id id) {
@@ -672,6 +674,9 @@ func_decl * seq_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters,
             m.raise_exception("Incorrect number of arguments passed to loop. Expected 1 regular expression and two integer parameters");
         }
         
+    case _OP_RE_UNROLL:
+        match(*m_sigs[k], arity, domain, range, rng);
+        return m.mk_func_decl(m_sigs[k]->m_name, arity, domain, rng, func_decl_info(m_family_id, k));
 
     case OP_STRING_CONST:
         if (!(num_parameters == 1 && arity == 0 && parameters[0].is_symbol())) {

src/ast/seq_decl_plugin.h

@@ -79,6 +79,7 @@ enum seq_op_kind {
     _OP_REGEXP_EMPTY,
     _OP_REGEXP_FULL,
     _OP_SEQ_SKOLEM,
+    _OP_RE_UNROLL,
     LAST_SEQ_OP
 };
 
@@ -334,6 +335,7 @@ public:
         MATCH_UNARY(is_opt);
         bool is_loop(expr const* n, expr*& body, unsigned& lo, unsigned& hi);
         bool is_loop(expr const* n, expr*& body, unsigned& lo);
+        bool is_unroll(expr const* n) const { return is_app_of(n, m_fid, _OP_RE_UNROLL); }
     };
     str str;
     re  re;

src/cmd_context/tactic_cmds.cpp

@@ -223,7 +223,7 @@ public:
                 cmd_context::scoped_watch sw(ctx);
                 lbool r = l_undef;
                 try {
-                    r = check_sat(t, g, md, result->labels, pr, core, reason_unknown);
+                    r = check_sat(t, g, md, result->labels, pr, core, reason_unknown);                    
                     ctx.display_sat_result(r);
                     result->set_status(r);
                     if (r == l_undef) {

src/opt/opt_context.cpp

@@ -1290,6 +1290,15 @@ namespace opt {
         return to_expr(get_upper_as_num(idx));
     }
 
+    void context::to_exprs(inf_eps const& n, expr_ref_vector& es) {
+        rational inf = n.get_infinity();
+        rational r   = n.get_rational();
+        rational eps = n.get_infinitesimal();
+        es.push_back(m_arith.mk_numeral(inf, inf.is_int()));
+        es.push_back(m_arith.mk_numeral(r, r.is_int()));
+        es.push_back(m_arith.mk_numeral(eps, eps.is_int()));
+    }
+
     expr_ref context::to_expr(inf_eps const& n) {
         rational inf = n.get_infinity();
         rational r   = n.get_rational();
@@ -1455,9 +1464,10 @@ namespace opt {
 
     void context::validate_maxsat(symbol const& id) {
         maxsmt& ms = *m_maxsmts.find(id);
+        TRACE("opt", tout << "Validate: " << id << "\n";);
         for (unsigned i = 0; i < m_objectives.size(); ++i) {
             objective const& obj = m_objectives[i];
-            if (obj.m_id == id) {
+            if (obj.m_id == id && obj.m_type == O_MAXSMT) {        
                 SASSERT(obj.m_type == O_MAXSMT);
                 rational value(0);
                 expr_ref val(m);

src/opt/opt_context.h

@@ -207,6 +207,9 @@ namespace opt {
         expr_ref get_lower(unsigned idx);
         expr_ref get_upper(unsigned idx);
 
+        void get_lower(unsigned idx, expr_ref_vector& es) { to_exprs(get_lower_as_num(idx), es); }
+        void get_upper(unsigned idx, expr_ref_vector& es) { to_exprs(get_upper_as_num(idx), es); }
+
         std::string to_string() const;
 
 
@@ -238,6 +241,7 @@ namespace opt {
         lbool adjust_unknown(lbool r);
         bool scoped_lex();
         expr_ref to_expr(inf_eps const& n);
+        void to_exprs(inf_eps const& n, expr_ref_vector& es);
 
         void reset_maxsmts();
         void import_scoped_state();

src/smt/tactic/smt_tactic.cpp

@@ -25,6 +25,9 @@ Notes:
 #include"filter_model_converter.h"
 #include"ast_util.h"
 #include"solver2tactic.h"
+#include"smt_solver.h"
+#include"solver.h"
+#include"mus.h"
 
 typedef obj_map<expr, expr *> expr2expr_map;
 
@@ -159,6 +162,8 @@ public:
             ref<filter_model_converter> fmc;
             if (in->unsat_core_enabled()) {
                 extract_clauses_and_dependencies(in, clauses, assumptions, bool2dep, fmc);
+                TRACE("mus", in->display_with_dependencies(tout);
+                      tout << clauses << "\n";);
                 if (in->proofs_enabled() && !assumptions.empty())
                     throw tactic_exception("smt tactic does not support simultaneous generation of proofs and unsat cores");
                 for (unsigned i = 0; i < clauses.size(); ++i) {

src/solver/mus.cpp

@@ -89,6 +89,7 @@ struct mus::imp {
     lbool get_mus1(expr_ref_vector& mus) {
         ptr_vector<expr> unknown(m_lit2expr.size(), m_lit2expr.c_ptr());
         ptr_vector<expr> core_exprs;
+        TRACE("mus", m_solver.display(tout););
         while (!unknown.empty()) { 
             IF_VERBOSE(12, verbose_stream() << "(mus reducing core: " << unknown.size() << " new core: " << mus.size() << ")\n";);
             TRACE("mus", display_vec(tout << "core:  ", unknown); display_vec(tout << "mus:   ", mus););

src/solver/tactic2solver.cpp

@@ -290,3 +290,5 @@ solver_factory * mk_tactic2solver_factory(tactic * t) {
 solver_factory * mk_tactic_factory2solver_factory(tactic_factory * f) {
     return alloc(tactic_factory2solver_factory, f);
 }
+
+

src/tactic/bv/dt2bv_tactic.cpp

@@ -64,7 +64,10 @@ class dt2bv_tactic : public tactic {
                 return;
             }
 
-            if (m_t.is_fd(a)) {
+            if (m_t.is_fd(a) && a->get_num_args() > 0) {
+                m_t.m_non_fd_sorts.insert(get_sort(a));
+            }
+            else if (m_t.is_fd(a)) {
                 m_t.m_fd_sorts.insert(get_sort(a));
             }
             else {

src/tactic/tactic.cpp

@@ -23,7 +23,6 @@ Notes:
 #include"model_v2_pp.h"
 
 
-
 struct tactic_report::imp {
     char const *    m_id;
     goal const &    m_goal;
@@ -175,6 +174,7 @@ void exec(tactic & t, goal_ref const & in, goal_ref_buffer & result, model_conve
     }
 }
 
+
 lbool check_sat(tactic & t, goal_ref & g, model_ref & md, labels_vec & labels, proof_ref & pr, expr_dependency_ref & core, std::string & reason_unknown) {
     bool models_enabled = g->models_enabled();
     bool proofs_enabled = g->proofs_enabled();