mirror of
https://github.com/Z3Prover/z3
synced 2025-04-08 10:25:18 +00:00
Merge remote-tracking branch 'upstream/master' into release-1.0
This commit is contained in:
commit
9ac0d098ac
|
@ -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);
|
||||
|
|
|
@ -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>
|
||||
|
|
|
@ -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
|
||||
{
|
||||
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();
|
||||
}
|
||||
public static class Handle {
|
||||
|
||||
/**
|
||||
* Print a string representation of the handle.
|
||||
**/
|
||||
@Override
|
||||
public String toString()
|
||||
private final Optimize opt;
|
||||
private final 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);
|
||||
}
|
||||
|
||||
/**
|
||||
* @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.
|
||||
**/
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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.
|
||||
|
|
|
@ -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());
|
||||
}
|
||||
|
||||
|
|
|
@ -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())) {
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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();
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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););
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -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 {
|
||||
|
|
|
@ -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();
|
||||
|
|
Loading…
Reference in a new issue