mirror of
https://github.com/Z3Prover/z3
synced 2025-04-05 17:14:07 +00:00
Fix some spelling errors (mostly in comments).
This commit is contained in:
Florian Pigorsch
parent
880ce12e2d
commit
326bf401b9
|
|
@ -8,13 +8,13 @@
|
|||
# FIXME: All the commented out defines should be removed once
|
||||
# we are confident it is correct to not set them.
|
||||
set(Z3_MSVC_LEGACY_DEFINES
|
||||
# Don't set `_DEBUG`. The old build sytem sets this but this
|
||||
# Don't set `_DEBUG`. The old build system sets this but this
|
||||
# is wrong. MSVC will set this depending on which runtime is being used.
|
||||
# See https://msdn.microsoft.com/en-us/library/b0084kay.aspx
|
||||
# _DEBUG
|
||||
|
||||
# The old build system only set `UNICODE` and `_UNICODE` for x86_64 release.
|
||||
# That seems completly wrong so set it for all configurations.
|
||||
# That seems completely wrong so set it for all configurations.
|
||||
# According to https://blogs.msdn.microsoft.com/oldnewthing/20040212-00/?p=40643/
|
||||
# `UNICODE` affects Windows headers and `_UNICODE` affects C runtime header files.
|
||||
# There is some discussion of this define at https://msdn.microsoft.com/en-us/library/dybsewaf.aspx
|
||||
|
|
@ -116,7 +116,7 @@ z3_add_cxx_flag("/analyze-" REQUIRED)
|
|||
################################################################################
|
||||
|
||||
# By default CMake enables incremental linking for Debug and RelWithDebInfo
|
||||
# builds. The old build sytem disables it for all builds so try to do the same
|
||||
# builds. The old build system disables it for all builds so try to do the same
|
||||
# by changing all configurations if necessary
|
||||
string(TOUPPER "${available_build_types}" _build_types_as_upper)
|
||||
foreach (_build_type ${_build_types_as_upper})
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ function(z3_expand_dependencies output_var)
|
|||
if (ARGC LESS 2)
|
||||
message(FATAL_ERROR "Invalid number of arguments")
|
||||
endif()
|
||||
# Remaing args should be component names
|
||||
# Remaining args should be component names
|
||||
set(_expanded_deps ${ARGN})
|
||||
set(_old_number_of_deps 0)
|
||||
list(LENGTH _expanded_deps _number_of_deps)
|
||||
|
|
@ -33,7 +33,7 @@ function(z3_add_component_dependencies_to_target target_name)
|
|||
if (NOT (TARGET ${target_name}))
|
||||
message(FATAL_ERROR "Target \"${target_name}\" does not exist")
|
||||
endif()
|
||||
# Remaing args should be component names
|
||||
# Remaining args should be component names
|
||||
set(_expanded_deps ${ARGN})
|
||||
foreach (dependency ${_expanded_deps})
|
||||
# Ensure this component's dependencies are built before this component.
|
||||
|
|
@ -219,7 +219,7 @@ macro(z3_add_component component_name)
|
|||
# Record this component's dependencies
|
||||
foreach (dependency ${Z3_MOD_COMPONENT_DEPENDENCIES})
|
||||
if (NOT (TARGET ${dependency}))
|
||||
message(FATAL_ERROR "Component \"${component_name}\" depends on a non existant component \"${dependency}\"")
|
||||
message(FATAL_ERROR "Component \"${component_name}\" depends on a non existent component \"${dependency}\"")
|
||||
endif()
|
||||
set_property(GLOBAL APPEND PROPERTY Z3_${component_name}_DEPS "${dependency}")
|
||||
endforeach()
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# Continous integration scripts
|
||||
# Continuous integration scripts
|
||||
|
||||
## TravisCI
|
||||
|
||||
|
|
@ -45,7 +45,7 @@ the future.
|
|||
* `Z3_VERBOSE_BUILD_OUTPUT` - Show compile commands in CMake builds (`0` or `1`)
|
||||
* `Z3_STATIC_BUILD` - Build Z3 binaries and libraries statically (`0` or `1`)
|
||||
* `Z3_SYSTEM_TEST_GIT_REVISION` - Git revision of [z3test](https://github.com/Z3Prover/z3test). If empty lastest revision will be used.
|
||||
* `Z3_WARNINGS_AS_ERRORS` - Set the `WARNINGS_AS_ERRORS` CMake option pased to Z3 (`OFF`, `ON`, or `SERIOUS_ONLY`)
|
||||
* `Z3_WARNINGS_AS_ERRORS` - Set the `WARNINGS_AS_ERRORS` CMake option passed to Z3 (`OFF`, `ON`, or `SERIOUS_ONLY`)
|
||||
|
||||
### Linux
|
||||
|
||||
|
|
|
|||
|
|
@ -944,7 +944,7 @@ HTML_STYLESHEET =
|
|||
# user-defined cascading style sheet that is included after the standard
|
||||
# style sheets created by doxygen. Using this option one can overrule
|
||||
# certain style aspects. This is preferred over using HTML_STYLESHEET
|
||||
# since it does not replace the standard style sheet and is therefor more
|
||||
# since it does not replace the standard style sheet and is therefore more
|
||||
# robust against future updates. Doxygen will copy the style sheet file to
|
||||
# the output directory.
|
||||
|
||||
|
|
@ -1711,7 +1711,7 @@ UML_LOOK = NO
|
|||
# the class node. If there are many fields or methods and many nodes the
|
||||
# graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS
|
||||
# threshold limits the number of items for each type to make the size more
|
||||
# managable. Set this to 0 for no limit. Note that the threshold may be
|
||||
# manageable. Set this to 0 for no limit. Note that the threshold may be
|
||||
# exceeded by 50% before the limit is enforced.
|
||||
|
||||
UML_LIMIT_NUM_FIELDS = 10
|
||||
|
|
|
|||
|
|
@ -7,8 +7,8 @@ find_package(Z3
|
|||
REQUIRED
|
||||
CONFIG
|
||||
# `NO_DEFAULT_PATH` is set so that -DZ3_DIR has to be passed to find Z3.
|
||||
# This should prevent us from accidently picking up an installed
|
||||
# copy of Z3. This is here to benefit Z3's build sytem when building
|
||||
# This should prevent us from accidentally picking up an installed
|
||||
# copy of Z3. This is here to benefit Z3's build system when building
|
||||
# this project. When making your own project you probably shouldn't
|
||||
# use this option.
|
||||
NO_DEFAULT_PATH
|
||||
|
|
|
|||
|
|
@ -24,8 +24,8 @@ find_package(Z3
|
|||
REQUIRED
|
||||
CONFIG
|
||||
# `NO_DEFAULT_PATH` is set so that -DZ3_DIR has to be passed to find Z3.
|
||||
# This should prevent us from accidently picking up an installed
|
||||
# copy of Z3. This is here to benefit Z3's build sytem when building
|
||||
# This should prevent us from accidentally picking up an installed
|
||||
# copy of Z3. This is here to benefit Z3's build system when building
|
||||
# this project. When making your own project you probably shouldn't
|
||||
# use this option.
|
||||
NO_DEFAULT_PATH
|
||||
|
|
|
|||
|
|
@ -11,8 +11,8 @@ find_package(Z3
|
|||
REQUIRED
|
||||
CONFIG
|
||||
# `NO_DEFAULT_PATH` is set so that -DZ3_DIR has to be passed to find Z3.
|
||||
# This should prevent us from accidently picking up an installed
|
||||
# copy of Z3. This is here to benefit Z3's build sytem when building
|
||||
# This should prevent us from accidentally picking up an installed
|
||||
# copy of Z3. This is here to benefit Z3's build system when building
|
||||
# this project. When making your own project you probably shouldn't
|
||||
# use this option.
|
||||
NO_DEFAULT_PATH
|
||||
|
|
|
|||
|
|
@ -226,7 +226,7 @@ namespace Microsoft.SolverFoundation.Plugin.Z3
|
|||
}
|
||||
|
||||
/// <summary>
|
||||
/// Adds a MSF variable with the coresponding assertion to the Z3 variables.
|
||||
/// Adds a MSF variable with the corresponding assertion to the Z3 variables.
|
||||
/// </summary>
|
||||
/// <param name="vid">The MSF id of the variable</param>
|
||||
internal void AddVariable(int vid)
|
||||
|
|
|
|||
|
|
@ -7,8 +7,8 @@ find_package(Z3
|
|||
REQUIRED
|
||||
CONFIG
|
||||
# `NO_DEFAULT_PATH` is set so that -DZ3_DIR has to be passed to find Z3.
|
||||
# This should prevent us from accidently picking up an installed
|
||||
# copy of Z3. This is here to benefit Z3's build sytem when building
|
||||
# This should prevent us from accidentally picking up an installed
|
||||
# copy of Z3. This is here to benefit Z3's build system when building
|
||||
# this project. When making your own project you probably shouldn't
|
||||
# use this option.
|
||||
NO_DEFAULT_PATH
|
||||
|
|
|
|||
|
|
@ -233,7 +233,7 @@ class env {
|
|||
|
||||
void check_arity(unsigned num_args, unsigned arity) {
|
||||
if (num_args != arity) {
|
||||
throw failure_ex("arity missmatch");
|
||||
throw failure_ex("arity mismatch");
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -3276,7 +3276,7 @@ class MakeRuleCmd(object):
|
|||
needed commands used in Makefile rules
|
||||
Note that several of the method are meant for use during ``make
|
||||
install`` and ``make uninstall``. These methods correctly use
|
||||
``$(PREFIX)`` and ``$(DESTDIR)`` and therefore are preferrable
|
||||
``$(PREFIX)`` and ``$(DESTDIR)`` and therefore are preferable
|
||||
to writing commands manually which can be error prone.
|
||||
"""
|
||||
@classmethod
|
||||
|
|
|
|||
|
|
@ -276,7 +276,7 @@ struct lackr_model_constructor::imp {
|
|||
SASSERT(a->get_num_args() == 0);
|
||||
func_decl * const fd = a->get_decl();
|
||||
expr * val = m_abstr_model->get_const_interp(fd);
|
||||
if (val == nullptr) { // TODO: avoid model completetion?
|
||||
if (val == nullptr) { // TODO: avoid model completion?
|
||||
sort * s = fd->get_range();
|
||||
val = m_abstr_model->get_some_value(s);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -219,7 +219,7 @@ namespace api {
|
|||
if (m_user_ref_count) {
|
||||
// Corner case bug: n may be in m_last_result, and this is the only reference to n.
|
||||
// When, we execute reset() it is deleted
|
||||
// To avoid this bug, I bump the reference counter before reseting m_last_result
|
||||
// To avoid this bug, I bump the reference counter before resetting m_last_result
|
||||
ast_ref node(n, m());
|
||||
m_last_result.reset();
|
||||
m_last_result.push_back(std::move(node));
|
||||
|
|
|
|||
|
|
@ -210,7 +210,7 @@ extern "C" {
|
|||
if (!out) {
|
||||
return Z3_FALSE;
|
||||
}
|
||||
// must start loggging here, since function uses Z3_get_sort_kind above
|
||||
// must start logging here, since function uses Z3_get_sort_kind above
|
||||
LOG_Z3_get_finite_domain_sort_size(c, s, out);
|
||||
RESET_ERROR_CODE();
|
||||
VERIFY(mk_c(c)->datalog_util().try_get_size(to_sort(s), *out));
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ namespace Microsoft.Z3
|
|||
|
||||
private static ArithExpr MkNum(ArithExpr e, double d) { return (ArithExpr)e.Context.MkNumeral(d.ToString(), e.Context.MkRealSort()); }
|
||||
|
||||
/// <summary> Operator overloading for arithmetical divsion operator (over reals) </summary>
|
||||
/// <summary> Operator overloading for arithmetical division operator (over reals) </summary>
|
||||
public static ArithExpr operator /(ArithExpr a, ArithExpr b) { return a.Context.MkDiv(a, b); }
|
||||
|
||||
/// <summary> Operator overloading for arithmetical operator </summary>
|
||||
|
|
|
|||
|
|
@ -2459,7 +2459,7 @@ namespace Microsoft.Z3
|
|||
|
||||
#endregion
|
||||
|
||||
#region Sequence, string and regular expresions
|
||||
#region Sequence, string and regular expressions
|
||||
|
||||
/// <summary>
|
||||
/// Create the empty sequence.
|
||||
|
|
@ -3131,7 +3131,7 @@ namespace Microsoft.Z3
|
|||
/// <summary>
|
||||
/// Create a bit-vector numeral.
|
||||
/// </summary>
|
||||
/// <param name="bits">An array of bits representing the bit-vector. Least signficant bit is at position 0.</param>
|
||||
/// <param name="bits">An array of bits representing the bit-vector. Least significant bit is at position 0.</param>
|
||||
public BitVecNum MkBV(bool[] bits)
|
||||
{
|
||||
Contract.Ensures(Contract.Result<BitVecNum>() != null);
|
||||
|
|
|
|||
|
|
@ -842,7 +842,7 @@ namespace Microsoft.Z3
|
|||
public string String { get { return Native.Z3_get_string(Context.nCtx, NativeObject); } }
|
||||
|
||||
/// <summary>
|
||||
/// Check whether expression is a concatentation.
|
||||
/// Check whether expression is a concatenation.
|
||||
/// </summary>
|
||||
/// <returns>a Boolean</returns>
|
||||
public bool IsConcat { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SEQ_CONCAT; } }
|
||||
|
|
|
|||
|
|
@ -199,7 +199,7 @@ def prove(claim,assume=None,verbose=0):
|
|||
>>> r,m = prove(True,assume=And(x,Not(x)),verbose=0)
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AssertionError: Assumption is alway False!
|
||||
AssertionError: Assumption is always False!
|
||||
|
||||
>>> r,m = prove(Implies(x,x),assume=y,verbose=2); r,model_str(m,as_str=False)
|
||||
assume:
|
||||
|
|
@ -238,7 +238,7 @@ def prove(claim,assume=None,verbose=0):
|
|||
is_proved,_ = prove(Not(assume))
|
||||
|
||||
def _f():
|
||||
emsg = "Assumption is alway False!"
|
||||
emsg = "Assumption is always False!"
|
||||
if verbose >= 2:
|
||||
emsg = "{}\n{}".format(assume,emsg)
|
||||
return emsg
|
||||
|
|
|
|||
|
|
@ -3772,7 +3772,7 @@ extern "C" {
|
|||
);
|
||||
|
||||
/**
|
||||
\brief Create a lambda expression. It taks an expression \c body that contains bound variables
|
||||
\brief Create a lambda expression. It takes an expression \c body that contains bound variables
|
||||
of the same sorts as the sorts listed in the array \c sorts. The bound variables are de-Bruijn indices created
|
||||
using #Z3_mk_bound. The array \c decl_names contains the names that the quantified formula uses for the
|
||||
bound variables. Z3 applies the convention that the last element in the \c decl_names and \c sorts array
|
||||
|
|
@ -4609,7 +4609,7 @@ extern "C" {
|
|||
Z3_bool Z3_API Z3_is_quantifier_exists(Z3_context c, Z3_ast a);
|
||||
|
||||
/**
|
||||
\brief Determine if ast is a lambda expresion.
|
||||
\brief Determine if ast is a lambda expression.
|
||||
|
||||
\pre Z3_get_ast_kind(a) == Z3_QUANTIFIER_AST
|
||||
|
||||
|
|
@ -5996,7 +5996,7 @@ extern "C" {
|
|||
Z3_solver Z3_API Z3_solver_translate(Z3_context source, Z3_solver s, Z3_context target);
|
||||
|
||||
/**
|
||||
\brief Ad-hoc method for importing model convertion from solver.
|
||||
\brief Ad-hoc method for importing model conversion from solver.
|
||||
|
||||
def_API('Z3_solver_import_model_converter', VOID, (_in(CONTEXT), _in(SOLVER), _in(SOLVER)))
|
||||
*/
|
||||
|
|
@ -6215,7 +6215,7 @@ extern "C" {
|
|||
The third argument is a vector of variables that may be used for cubing.
|
||||
The contents of the vector is only used in the first call. The initial list of variables
|
||||
is used in subsequent calls until it returns the unsatisfiable cube.
|
||||
The vector is modified to contain a set of Autarky variables that occor in clauses that
|
||||
The vector is modified to contain a set of Autarky variables that occur in clauses that
|
||||
are affected by the (last literal in the) cube. These variables could be used by a different
|
||||
cuber (on a different solver object) for further recursive cubing.
|
||||
|
||||
|
|
|
|||
|
|
@ -123,7 +123,7 @@ inline expr_ref mk_or(expr_ref_vector const& args) { return expr_ref(mk_or(args.
|
|||
|
||||
/**
|
||||
Return a if arg = (not a)
|
||||
Retur (not arg) otherwise
|
||||
Return (not arg) otherwise
|
||||
*/
|
||||
expr * mk_not(ast_manager & m, expr * arg);
|
||||
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ fpa2bv_rewriter_cfg::fpa2bv_rewriter_cfg(ast_manager & m, fpa2bv_converter & c,
|
|||
m_bindings(m)
|
||||
{
|
||||
updt_params(p);
|
||||
// We need to make sure that the mananger has the BV plugin loaded.
|
||||
// We need to make sure that the manager has the BV plugin loaded.
|
||||
symbol s_bv("bv");
|
||||
if (!m_manager.has_plugin(s_bv))
|
||||
m_manager.register_plugin(s_bv, alloc(bv_decl_plugin));
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ public:
|
|||
void reset();
|
||||
|
||||
/**
|
||||
\brief Create a dependecy set.
|
||||
\brief Create a dependency set.
|
||||
This set should be populated using #collect_func_decls.
|
||||
After populating the set, it must be used as an argument for the #insert method.
|
||||
|
||||
|
|
|
|||
|
|
@ -263,7 +263,7 @@ bool quasi_macros::find_macros(unsigned n, expr * const * exprs) {
|
|||
m_occurrences.reset();
|
||||
|
||||
|
||||
// Find out how many non-ground appearences for each uninterpreted function there are
|
||||
// Find out how many non-ground appearances for each uninterpreted function there are
|
||||
for (unsigned i = 0 ; i < n ; i++)
|
||||
find_occurrences(exprs[i]);
|
||||
|
||||
|
|
@ -301,7 +301,7 @@ bool quasi_macros::find_macros(unsigned n, justified_expr const * exprs) {
|
|||
m_occurrences.reset();
|
||||
|
||||
|
||||
// Find out how many non-ground appearences for each uninterpreted function there are
|
||||
// Find out how many non-ground appearances for each uninterpreted function there are
|
||||
for ( unsigned i = 0 ; i < n ; i++ )
|
||||
find_occurrences(exprs[i].get_fml());
|
||||
|
||||
|
|
|
|||
|
|
@ -687,7 +687,7 @@ bool pattern_inference_cfg::reduce_quantifier(
|
|||
mk_patterns(result2->get_num_decls(), result2->get_expr(), 0, nullptr, new_patterns);
|
||||
if (!new_patterns.empty()) {
|
||||
if (m_params.m_pi_warnings) {
|
||||
warning_msg("pulled nested quantifier to be able to find an useable pattern (quantifier id: %s)", q->get_qid().str().c_str());
|
||||
warning_msg("pulled nested quantifier to be able to find an usable pattern (quantifier id: %s)", q->get_qid().str().c_str());
|
||||
}
|
||||
new_q = m.update_quantifier(result2, new_patterns.size(), (expr**) new_patterns.c_ptr(), result2->get_expr());
|
||||
if (m.proofs_enabled()) {
|
||||
|
|
|
|||
|
|
@ -2679,7 +2679,7 @@ br_status bv_rewriter::mk_ite_core(expr * c, expr * t, expr * e, expr_ref & resu
|
|||
}
|
||||
|
||||
const unsigned sz = m_util.get_bv_size(rhs);
|
||||
if (sz == 1) { // detect (lhs = N) ? C : D, where N, C, D are 1 bit numberals
|
||||
if (sz == 1) { // detect (lhs = N) ? C : D, where N, C, D are 1 bit numerals
|
||||
numeral rhs_n, e_n, t_n;
|
||||
unsigned rhs_sz, e_sz, t_sz;
|
||||
if (is_numeral(rhs, rhs_n, rhs_sz)
|
||||
|
|
|
|||
|
|
@ -124,7 +124,7 @@ br_status datatype_rewriter::mk_eq_core(expr * lhs, expr * rhs, expr_ref & resul
|
|||
// (= (+ c5 a5) b5) <<< NOT SIMPLIFIED WITH RESPECT TO ARITHMETIC
|
||||
// (= (cons a6 nil) (cons b6 nil))) <<< NOT SIMPLIFIED WITH RESPECT TO DATATYPE theory
|
||||
//
|
||||
// Note that asserted_formulas::reduce() applied the simplier many times.
|
||||
// Note that asserted_formulas::reduce() applied the simplifier many times.
|
||||
// After the first simplification step we had:
|
||||
// (= a1 b1)
|
||||
// (= (cons a2 (cons a3 (cons (+ a4 1) (cons (+ a5 c5) (cons a6 nil))))))
|
||||
|
|
|
|||
|
|
@ -108,7 +108,7 @@ Revision History:
|
|||
apply var_subst using m_map to this child, and store the result in a new children array
|
||||
Create a new OR (new body of the quantifier) using the new children
|
||||
Then, we create a new quantifier using this new body, and use the function elim_unused_vars to
|
||||
eliminate the ununsed variables.
|
||||
eliminate the unused variables.
|
||||
|
||||
Remark: let us implement the new version inside the class der.
|
||||
Use #if 0 ... #endif to comment the old version.
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ struct push_app_ite_cfg : public default_rewriter_cfg {
|
|||
\brief Variation of push_app_ite that applies the transformation on nonground terms only.
|
||||
|
||||
\remark This functor uses the app::is_ground method. This method is not
|
||||
completly precise, for instance, any term containing a quantifier is marked as non ground.
|
||||
completely precise, for instance, any term containing a quantifier is marked as non ground.
|
||||
*/
|
||||
class ng_push_app_ite_cfg : public push_app_ite_cfg {
|
||||
protected:
|
||||
|
|
|
|||
|
|
@ -85,7 +85,7 @@ ATOMIC_CMD(get_user_tactics_cmd, "get-user-tactics", "display tactics defined us
|
|||
void help_tactic(cmd_context & ctx) {
|
||||
std::ostringstream buf;
|
||||
buf << "combinators:\n";
|
||||
buf << "- (and-then <tactic>+) executes the given tactics sequencially.\n";
|
||||
buf << "- (and-then <tactic>+) executes the given tactics sequentially.\n";
|
||||
buf << "- (or-else <tactic>+) tries the given tactics in sequence until one of them succeeds (i.e., the first that doesn't fail).\n";
|
||||
buf << "- (par-or <tactic>+) executes the given tactics in parallel until one of them succeeds (i.e., the first that doesn't fail).\n";
|
||||
buf << "- (par-then <tactic1> <tactic2>) executes tactic1 and then tactic2 to every subgoal produced by tactic1. All subgoals are processed in parallel.\n";
|
||||
|
|
|
|||
|
|
@ -690,7 +690,7 @@ struct euclidean_solver::imp {
|
|||
m().del(eq.m_as[j]);
|
||||
eq.m_as.shrink(new_sz);
|
||||
eq.m_xs.shrink(new_sz);
|
||||
// ajust c
|
||||
// adjust c
|
||||
mpz new_c;
|
||||
decompose(m_next_pos_a, m_next_a, eq.m_c, new_c, eq.m_c);
|
||||
// create auxiliary equation
|
||||
|
|
|
|||
|
|
@ -948,7 +948,7 @@ namespace algebraic_numbers {
|
|||
// zero is a root of p, and r_i is an isolating interval containing zero,
|
||||
// then c is zero
|
||||
reset(c);
|
||||
TRACE("algebraic", tout << "reseting\nresult: "; display_root(tout, c); tout << "\n";);
|
||||
TRACE("algebraic", tout << "resetting\nresult: "; display_root(tout, c); tout << "\n";);
|
||||
return;
|
||||
}
|
||||
int zV = upm().sign_variations_at_zero(seq);
|
||||
|
|
@ -1728,7 +1728,7 @@ namespace algebraic_numbers {
|
|||
COMPARE_INTERVAL();
|
||||
|
||||
// if cell_a and cell_b, contain the same polynomial,
|
||||
// and the intervals are overlaping, then they are
|
||||
// and the intervals are overlapping, then they are
|
||||
// the same root.
|
||||
if (compare_p(cell_a, cell_b)) {
|
||||
m_compare_poly_eq++;
|
||||
|
|
@ -1825,7 +1825,7 @@ namespace algebraic_numbers {
|
|||
|
||||
// Here is an unexplored option for comparing numbers.
|
||||
//
|
||||
// The isolating intervals of a and b are still overlaping
|
||||
// The isolating intervals of a and b are still overlapping
|
||||
// Then we compute
|
||||
// r(x) = Resultant(x - y1 + y2, p1(y1), p2(y2))
|
||||
// where p1(y1) and p2(y2) are the polynomials defining a and b.
|
||||
|
|
|
|||
|
|
@ -4052,7 +4052,7 @@ namespace polynomial {
|
|||
|
||||
// select a new random value in GF(p) that is not in vals, and store it in r
|
||||
void peek_fresh(scoped_numeral_vector const & vals, unsigned p, scoped_numeral & r) {
|
||||
SASSERT(vals.size() < p); // otherwise we cant keep the fresh value
|
||||
SASSERT(vals.size() < p); // otherwise we can't keep the fresh value
|
||||
unsigned sz = vals.size();
|
||||
while (true) {
|
||||
m().set(r, rand() % p);
|
||||
|
|
@ -4149,7 +4149,7 @@ namespace polynomial {
|
|||
TRACE("mgcd_detail", tout << "counter: " << counter << "\nidx: " << idx << "\nq: " << q << "\ndeg_q: " << deg_q << "\nmin_deg_q: " <<
|
||||
min_deg_q << "\nnext_x: x" << vars[idx+1] << "\nmax_var(q): " << q_var << "\n";);
|
||||
if (deg_q < min_deg_q) {
|
||||
TRACE("mgcd_detail", tout << "reseting...\n";);
|
||||
TRACE("mgcd_detail", tout << "resetting...\n";);
|
||||
counter = 0;
|
||||
min_deg_q = deg_q;
|
||||
// start from scratch
|
||||
|
|
|
|||
|
|
@ -131,12 +131,12 @@ namespace polynomial {
|
|||
~factors();
|
||||
|
||||
/**
|
||||
\brief Numer of distinct factors (not counting multiplicities).
|
||||
\brief Number of distinct factors (not counting multiplicities).
|
||||
*/
|
||||
unsigned distinct_factors() const { return m_factors.size(); }
|
||||
|
||||
/**
|
||||
\brief Numer of distinct factors (counting multiplicities).
|
||||
\brief Number of distinct factors (counting multiplicities).
|
||||
*/
|
||||
unsigned total_factors() const { return m_total_factors; }
|
||||
|
||||
|
|
|
|||
|
|
@ -362,7 +362,7 @@ namespace upolynomial {
|
|||
set_size(sz-1, buffer);
|
||||
}
|
||||
|
||||
// Divide coeffients of p by their GCD
|
||||
// Divide coefficients of p by their GCD
|
||||
void core_manager::normalize(unsigned sz, numeral * p) {
|
||||
if (sz == 0)
|
||||
return;
|
||||
|
|
@ -395,7 +395,7 @@ namespace upolynomial {
|
|||
}
|
||||
}
|
||||
|
||||
// Divide coeffients of p by their GCD
|
||||
// Divide coefficients of p by their GCD
|
||||
void core_manager::normalize(numeral_vector & p) {
|
||||
normalize(p.size(), p.c_ptr());
|
||||
}
|
||||
|
|
@ -568,7 +568,7 @@ namespace upolynomial {
|
|||
SASSERT(!is_alias(p1, buffer)); SASSERT(!is_alias(p2, buffer));
|
||||
unsigned d;
|
||||
rem(sz1, p1, sz2, p2, d, buffer);
|
||||
// We don't ned to flip the sign if d is odd and leading coefficient of p2 is negative
|
||||
// We don't need to flip the sign if d is odd and leading coefficient of p2 is negative
|
||||
if (d % 2 == 0 || (sz2 > 0 && m().is_pos(p2[sz2-1])))
|
||||
neg(buffer.size(), buffer.c_ptr());
|
||||
}
|
||||
|
|
@ -2005,7 +2005,7 @@ namespace upolynomial {
|
|||
continue;
|
||||
bool pos_a_n_k = m().is_pos(a_n_k);
|
||||
if (pos_a_n_k == pos_a_n)
|
||||
continue; // must have oposite signs
|
||||
continue; // must have opposite signs
|
||||
unsigned log2_a_n_k = pos_a_n_k ? m().log2(a_n_k) : m().mlog2(a_n_k);
|
||||
if (log2_a_n > log2_a_n_k)
|
||||
continue;
|
||||
|
|
@ -2103,7 +2103,7 @@ namespace upolynomial {
|
|||
frame_stack.pop_back();
|
||||
}
|
||||
|
||||
// Auxiliar method for isolating the roots of p in the interval (0, 1).
|
||||
// Auxiliary method for isolating the roots of p in the interval (0, 1).
|
||||
// The basic idea is to split the interval in: (0, 1/2) and (1/2, 1).
|
||||
// This is accomplished by analyzing the roots in the interval (0, 1) of the following polynomials.
|
||||
// p1(x) := 2^n * p(x/2) where n = sz-1
|
||||
|
|
@ -2574,10 +2574,10 @@ namespace upolynomial {
|
|||
We say an interval (a, b) of a polynomial p is ISOLATING if p has only one root in the
|
||||
interval (a, b).
|
||||
|
||||
We say an isolating interval (a, b) of a square free polynomial p is REFINEABLE if
|
||||
We say an isolating interval (a, b) of a square free polynomial p is REFINABLE if
|
||||
sign(p(a)) = -sign(p(b))
|
||||
|
||||
Not every isolating interval (a, b) of a square free polynomial p is refineable, because
|
||||
Not every isolating interval (a, b) of a square free polynomial p is refinable, because
|
||||
sign(p(a)) or sign(p(b)) may be zero.
|
||||
|
||||
Refinable intervals of square free polynomials are useful, because we can increase precision
|
||||
|
|
|
|||
|
|
@ -256,12 +256,12 @@ namespace upolynomial {
|
|||
void derivative(numeral_vector const & p, numeral_vector & d_p) { derivative(p.size(), p.c_ptr(), d_p); }
|
||||
|
||||
/**
|
||||
\brief Divide coeffients of p by their GCD
|
||||
\brief Divide coefficients of p by their GCD
|
||||
*/
|
||||
void normalize(unsigned sz, numeral * p);
|
||||
|
||||
/**
|
||||
\brief Divide coeffients of p by their GCD
|
||||
\brief Divide coefficients of p by their GCD
|
||||
*/
|
||||
void normalize(numeral_vector & p);
|
||||
|
||||
|
|
|
|||
|
|
@ -195,7 +195,7 @@ namespace upolynomial {
|
|||
|
||||
// the index we are currently trying to fix
|
||||
int current_i = m_current_size - 1;
|
||||
// the value we found as plausable (-1 we didn't find anything)
|
||||
// the value we found as plausible (-1 we didn't find anything)
|
||||
int current_value = -1;
|
||||
|
||||
if (remove_current) {
|
||||
|
|
|
|||
|
|
@ -107,7 +107,7 @@ public:
|
|||
this method will give preference to the row that occurs first.
|
||||
|
||||
\remark The vector r must have at least A.n() capacity
|
||||
The numer of linear independent rows is returned.
|
||||
The number of linear independent rows is returned.
|
||||
|
||||
Store the new matrix in B.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -6,5 +6,5 @@ def_module_params('rcf',
|
|||
('initial_precision', UINT, 24, "a value k that is the initial interval size (as 1/2^k) when creating transcendentals and approximated division"),
|
||||
('inf_precision', UINT, 24, "a value k that is the initial interval size (i.e., (0, 1/2^l)) used as an approximation for infinitesimal values"),
|
||||
('max_precision', UINT, 128, "during sign determination we switch from interval arithmetic to complete methods when the interval size is less than 1/2^k, where k is the max_precision"),
|
||||
('lazy_algebraic_normalization', BOOL, True, "during sturm-seq and square-free polynomial computations, only normalize algebraic polynomial expressions when the definining polynomial is monic")
|
||||
('lazy_algebraic_normalization', BOOL, True, "during sturm-seq and square-free polynomial computations, only normalize algebraic polynomial expressions when the defining polynomial is monic")
|
||||
))
|
||||
|
|
|
|||
|
|
@ -4790,7 +4790,7 @@ namespace realclosure {
|
|||
|
||||
/**
|
||||
\brief Determine the sign of the new rational function value.
|
||||
The idea is to keep refinining the interval until interval of v does not contain 0.
|
||||
The idea is to keep refining the interval until interval of v does not contain 0.
|
||||
After a couple of steps we switch to expensive sign determination procedure.
|
||||
|
||||
Return false if v is actually zero.
|
||||
|
|
@ -5474,7 +5474,7 @@ namespace realclosure {
|
|||
}
|
||||
else {
|
||||
// Let sdt be alpha->sdt();
|
||||
// In pricipal, the signs of the polynomials sdt->qs can be used
|
||||
// In principal, the signs of the polynomials sdt->qs can be used
|
||||
// to discriminate the roots of new_p. The signs of this polynomials
|
||||
// depend only on alpha, and not on the polynomial used to define alpha
|
||||
// So, in principle, we can reuse m_qs and m_sign_conditions.
|
||||
|
|
|
|||
|
|
@ -148,7 +148,7 @@ namespace smt {
|
|||
vector<numeral> m_potentials; // nodes + 1 |-> initial: +/- 1
|
||||
// Duals of flows which are convenient to compute dual solutions
|
||||
// become solutions to Dual simplex.
|
||||
vector<numeral> m_flows; // edges + nodes |-> assignemnt Basic feasible flows
|
||||
vector<numeral> m_flows; // edges + nodes |-> assignment Basic feasible flows
|
||||
svector<edge_state> m_states;
|
||||
unsigned m_step;
|
||||
edge_id m_enter_id;
|
||||
|
|
|
|||
|
|
@ -202,7 +202,7 @@ public:
|
|||
public:
|
||||
node(context_t & s, unsigned id);
|
||||
node(node * parent, unsigned id);
|
||||
// return unique indentifier.
|
||||
// return unique identifier.
|
||||
unsigned id() const { return m_id; }
|
||||
bound_array_manager & bm() const { return m_bm; }
|
||||
bound_array & lowers() { return m_lowers; }
|
||||
|
|
|
|||
|
|
@ -248,7 +248,7 @@ public:
|
|||
|
||||
|
||||
/**
|
||||
\brief Auxiliary static method used to diplay a bound specified by (x, k, lower, open).
|
||||
\brief Auxiliary static method used to display a bound specified by (x, k, lower, open).
|
||||
*/
|
||||
template<typename C>
|
||||
void context_t<C>::display(std::ostream & out, numeral_manager & nm, display_var_proc const & proc, var x, numeral & k, bool lower, bool open) {
|
||||
|
|
|
|||
|
|
@ -615,7 +615,7 @@ namespace datalog {
|
|||
|
||||
void ensure_engine();
|
||||
|
||||
// auxilary functions for SMT2 pretty-printer.
|
||||
// auxiliary functions for SMT2 pretty-printer.
|
||||
void declare_vars(expr_ref_vector& rules, mk_fresh_name& mk_fresh, std::ostream& out);
|
||||
|
||||
//undefined and private copy constructor and operator=
|
||||
|
|
|
|||
|
|
@ -110,7 +110,7 @@ namespace datalog {
|
|||
/**
|
||||
\brief Manager for the \c rule class
|
||||
|
||||
\remark \c rule_manager objects are interchangable as long as they
|
||||
\remark \c rule_manager objects are interchangeable as long as they
|
||||
contain the same \c ast_manager object.
|
||||
*/
|
||||
class rule_manager
|
||||
|
|
|
|||
|
|
@ -97,7 +97,7 @@ namespace datalog {
|
|||
\brief Auxiliary function used to create a tail based on \c pred for a new rule.
|
||||
The variables in \c pred are re-assigned using \c next_idx and \c varidx2var.
|
||||
A variable is considered non-local to the rule if it is in the set \c non_local_vars.
|
||||
Non-local variables are coppied to new_rule_args, and their sorts to \c new_rule_domain.
|
||||
Non-local variables are copied to new_rule_args, and their sorts to \c new_rule_domain.
|
||||
The new predicate is stored in \c new_pred.
|
||||
*/
|
||||
void mk_new_rule_tail(ast_manager & m, app * pred,
|
||||
|
|
|
|||
|
|
@ -143,8 +143,8 @@ def_module_params('fp',
|
|||
('spacer.native_mbp', BOOL, True, "Use native mbp of Z3"),
|
||||
('spacer.eq_prop', BOOL, True, "Enable equality and bound propagation in arithmetic"),
|
||||
('spacer.weak_abs', BOOL, True, "Weak abstraction"),
|
||||
('spacer.restarts', BOOL, False, "Enable reseting obligation queue"),
|
||||
('spacer.restart_initial_threshold', UINT, 10, "Intial threshold for restarts"),
|
||||
('spacer.restarts', BOOL, False, "Enable resetting obligation queue"),
|
||||
('spacer.restart_initial_threshold', UINT, 10, "Initial threshold for restarts"),
|
||||
('spacer.random_seed', UINT, 0, "Random seed to be used by SMT solver"),
|
||||
|
||||
('spacer.mbqi', BOOL, True, 'Enable mbqi'),
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ Copyright (c) 2015 Microsoft Corporation
|
|||
|
||||
Abstract:
|
||||
|
||||
Horn normal form convertion.
|
||||
Horn normal form conversion.
|
||||
|
||||
Author:
|
||||
|
||||
|
|
|
|||
|
|
@ -332,7 +332,7 @@ namespace datalog {
|
|||
|
||||
|
||||
void internalize() {
|
||||
// populate maps (should be bit-sets) of decendants.
|
||||
// populate maps (should be bit-sets) of descendants.
|
||||
if (m_internalized) {
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -120,7 +120,7 @@ public:
|
|||
|
||||
This operation invalidates the line previously retrieved.
|
||||
|
||||
This operatio can be called only if we are not at the end of file.
|
||||
This operation can be called only if we are not at the end of file.
|
||||
|
||||
User is free to modify the content of the returned array until the terminating NULL character.
|
||||
*/
|
||||
|
|
@ -876,7 +876,7 @@ protected:
|
|||
|
||||
/**
|
||||
\brief Parse predicate arguments. If \c f==0, they are arguments of a predicate declaration.
|
||||
If parsing a declaration, argumens names are pushed to the \c arg_names vector.
|
||||
If parsing a declaration, argument names are pushed to the \c arg_names vector.
|
||||
*/
|
||||
dtoken parse_args(dtoken tok, func_decl* f, expr_ref_vector& args, svector<symbol> & arg_names) {
|
||||
if (tok != TK_LP) {
|
||||
|
|
|
|||
|
|
@ -295,7 +295,7 @@ namespace datalog {
|
|||
Precondition: &orig.get_plugin()==this
|
||||
*/
|
||||
virtual base_object * mk_empty(const signature & s, family_id kind) {
|
||||
SASSERT(kind==get_kind()); //if plugin uses multiple kinds, this function needs to be overriden
|
||||
SASSERT(kind==get_kind()); //if plugin uses multiple kinds, this function needs to be overridden
|
||||
return mk_empty(s);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1319,7 +1319,7 @@ namespace datalog {
|
|||
|
||||
if(!m_table_cond_columns.empty()) {
|
||||
//We will keep the table variables that appear in the condition together
|
||||
//with the index column and then iterate throught the tuples, evaluating
|
||||
//with the index column and then iterate through the tuples, evaluating
|
||||
//the rest of the condition on the inner relations.
|
||||
unsigned_vector removed_cols;
|
||||
unsigned table_data_col_cnt = r.m_table_sig.size()-1;
|
||||
|
|
|
|||
|
|
@ -640,7 +640,7 @@ namespace datalog {
|
|||
reg_idx m_src;
|
||||
reg_idx m_tgt;
|
||||
reg_idx m_delta;
|
||||
bool m_widen; //if true, widening is performed intead of an union
|
||||
bool m_widen; //if true, widening is performed instead of an union
|
||||
public:
|
||||
instr_union(reg_idx src, reg_idx tgt, reg_idx delta, bool widen)
|
||||
: m_src(src), m_tgt(tgt), m_delta(delta), m_widen(widen) {}
|
||||
|
|
|
|||
|
|
@ -253,7 +253,7 @@ namespace datalog {
|
|||
\brief Return functor that transforms a table into one that lacks columns listed in
|
||||
\c removed_cols array.
|
||||
|
||||
The \c removed_cols cotains columns of table \c t in strictly ascending order.
|
||||
The \c removed_cols contains columns of table \c t in strictly ascending order.
|
||||
*/
|
||||
relation_transformer_fn * mk_project_fn(const relation_base & t, unsigned col_cnt,
|
||||
const unsigned * removed_cols);
|
||||
|
|
@ -420,7 +420,7 @@ namespace datalog {
|
|||
\brief Return functor that transforms a table into one that lacks columns listed in
|
||||
\c removed_cols array.
|
||||
|
||||
The \c removed_cols cotains columns of table \c t in strictly ascending order.
|
||||
The \c removed_cols contains columns of table \c t in strictly ascending order.
|
||||
|
||||
If a project operation removes a non-functional column, all functional columns become
|
||||
non-functional (so that none of the values in functional columns are lost)
|
||||
|
|
|
|||
|
|
@ -568,7 +568,7 @@ namespace datalog {
|
|||
}
|
||||
|
||||
/**
|
||||
In this function we modify the content of table functional columns without reseting indexes.
|
||||
In this function we modify the content of table functional columns without resetting indexes.
|
||||
This is ok as long as we do not allow indexing on functional columns.
|
||||
*/
|
||||
void sparse_table::ensure_fact(const table_fact & f) {
|
||||
|
|
|
|||
|
|
@ -85,7 +85,7 @@ namespace datalog {
|
|||
/**
|
||||
\brief Restrict the set of used predicates to \c res.
|
||||
|
||||
The function deallocates unsused relations, it does not deal with rules.
|
||||
The function deallocates unused relations, it does not deal with rules.
|
||||
*/
|
||||
void restrict_predicates(func_decl_set const& predicates) override;
|
||||
|
||||
|
|
|
|||
|
|
@ -7,8 +7,8 @@ Module Name:
|
|||
|
||||
Abstract:
|
||||
|
||||
Proviced abstract interface and some inplementations of algorithms
|
||||
for strenghtning lemmas
|
||||
Provides abstract interface and some implementations of algorithms
|
||||
for strenghtening lemmas
|
||||
|
||||
Author:
|
||||
|
||||
|
|
@ -161,7 +161,7 @@ bool farkas_learner::is_pure_expr(func_decl_set const& symbs, expr* e, ast_manag
|
|||
in a clausal version.
|
||||
|
||||
NB: the routine is not interpolating, though an interpolating variant would
|
||||
be preferrable because then we can also use it for model propagation.
|
||||
be preferable because then we can also use it for model propagation.
|
||||
|
||||
We collect the unit derivable nodes from bs.
|
||||
These are the weakenings of bs, besides the
|
||||
|
|
|
|||
|
|
@ -186,7 +186,7 @@ void lemma_quantifier_generalizer::find_candidates(expr *e,
|
|||
|
||||
std::sort(candidates.c_ptr(), candidates.c_ptr() + candidates.size(),
|
||||
index_lt_proc(m));
|
||||
// keep actual select indecies in the order found at the back of
|
||||
// keep actual select indices in the order found at the back of
|
||||
// candidate list. There is no particular reason for this order
|
||||
candidates.append(extra);
|
||||
}
|
||||
|
|
@ -199,24 +199,24 @@ bool lemma_quantifier_generalizer::match_sk_idx(expr *e, app_ref_vector const &z
|
|||
contains_app has_zk(m, zks.get(0));
|
||||
|
||||
if (!contains_selects(e, m)) return false;
|
||||
app_ref_vector indicies(m);
|
||||
get_select_indices(e, indicies);
|
||||
if (indicies.size() > 2) return false;
|
||||
app_ref_vector indices(m);
|
||||
get_select_indices(e, indices);
|
||||
if (indices.size() > 2) return false;
|
||||
|
||||
unsigned i=0;
|
||||
if (indicies.size() == 1) {
|
||||
if (!has_zk(indicies.get(0))) return false;
|
||||
if (indices.size() == 1) {
|
||||
if (!has_zk(indices.get(0))) return false;
|
||||
}
|
||||
else {
|
||||
if (has_zk(indicies.get(0)) && !has_zk(indicies.get(1)))
|
||||
if (has_zk(indices.get(0)) && !has_zk(indices.get(1)))
|
||||
i = 0;
|
||||
else if (!has_zk(indicies.get(0)) && has_zk(indicies.get(1)))
|
||||
else if (!has_zk(indices.get(0)) && has_zk(indices.get(1)))
|
||||
i = 1;
|
||||
else if (!has_zk(indicies.get(0)) && !has_zk(indicies.get(1)))
|
||||
else if (!has_zk(indices.get(0)) && !has_zk(indices.get(1)))
|
||||
return false;
|
||||
}
|
||||
|
||||
idx = indicies.get(i);
|
||||
idx = indices.get(i);
|
||||
sk = zks.get(0);
|
||||
return true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -124,7 +124,7 @@ namespace spacer {
|
|||
* We can rewrite (E2) to rewrite (E1) to
|
||||
* (BP*Fark(BP)) => (neg(A*Fark(A) + BNP*Fark(BNP) + (neg D)*Fark(D))) (E3)
|
||||
* and since we can derive (A*Fark(A) + BNP*Fark(BNP) + (neg D)*Fark(D)) from
|
||||
* A, BNP and D, we also know that it is inconsisent. Therefore
|
||||
* A, BNP and D, we also know that it is inconsistent. Therefore
|
||||
* neg(A*Fark(A) + BNP*Fark(BNP) + (neg D)*Fark(D)) is a solution.
|
||||
*
|
||||
* Finally we also need the following workaround:
|
||||
|
|
|
|||
|
|
@ -1097,7 +1097,7 @@ namespace tb {
|
|||
m_S1.apply(2, delta, expr_offset(src.get_constraint(), 1), tmp2);
|
||||
constraint = m.mk_and(tmp, tmp2);
|
||||
|
||||
// perform trival quantifier-elimination:
|
||||
// perform trivial quantifier-elimination:
|
||||
uint_set index_set;
|
||||
expr_free_vars fv;
|
||||
fv(head);
|
||||
|
|
|
|||
|
|
@ -280,7 +280,7 @@ namespace datalog {
|
|||
}
|
||||
}
|
||||
|
||||
// model convertion: identity function.
|
||||
// model conversion: identity function.
|
||||
|
||||
if (instantiated) {
|
||||
result->inherit_predicates(source);
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ namespace datalog {
|
|||
|
||||
unsigned pt_len = r->get_positive_tail_size();
|
||||
if(pt_len != r->get_uninterpreted_tail_size()) {
|
||||
// we dont' expect rules with negative tails to be total
|
||||
// we don't expect rules with negative tails to be total
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -97,7 +97,7 @@ namespace datalog {
|
|||
void mk_subsumption_checker::scan_for_total_rules(const rule_set & rules) {
|
||||
bool new_discovered;
|
||||
//we cycle through the rules until we keep discovering new total relations
|
||||
//(discovering a total relation migh reveal other total relations)
|
||||
//(discovering a total relation might reveal other total relations)
|
||||
do {
|
||||
new_discovered = false;
|
||||
rule_set::iterator rend = rules.end();
|
||||
|
|
|
|||
|
|
@ -377,7 +377,7 @@ namespace nlsat {
|
|||
}
|
||||
|
||||
/**
|
||||
\brief Return the sign of the polynomial in the current interpration.
|
||||
\brief Return the sign of the polynomial in the current interpretation.
|
||||
|
||||
\pre All variables of p are assigned in the current interpretation.
|
||||
*/
|
||||
|
|
@ -469,7 +469,7 @@ namespace nlsat {
|
|||
}
|
||||
}
|
||||
|
||||
// Evalute the sign of p1^e1*...*pn^en (of atom a) in cell c of table t.
|
||||
// Evaluate the sign of p1^e1*...*pn^en (of atom a) in cell c of table t.
|
||||
int sign_at(ineq_atom * a, sign_table const & t, unsigned c) const {
|
||||
int sign = 1;
|
||||
unsigned num_ps = a->size();
|
||||
|
|
@ -556,7 +556,7 @@ namespace nlsat {
|
|||
result = m_ism.mk(true, true, dummy, true, true, dummy, jst);
|
||||
}
|
||||
else {
|
||||
// save -oo as begining of infeasible interval
|
||||
// save -oo as beginning of infeasible interval
|
||||
prev_open = true;
|
||||
prev_inf = true;
|
||||
prev_root_id = UINT_MAX;
|
||||
|
|
|
|||
|
|
@ -1987,7 +1987,7 @@ namespace smt2 {
|
|||
if (expr_stack().size() == fr->m_expr_spos) {
|
||||
if (!ignore_bad_patterns())
|
||||
throw parser_exception("invalid empty pattern");
|
||||
// ingoring empty pattern
|
||||
// ignoring empty pattern
|
||||
expr_stack().shrink(fr->m_expr_spos);
|
||||
}
|
||||
else {
|
||||
|
|
@ -2698,7 +2698,7 @@ namespace smt2 {
|
|||
next();
|
||||
}
|
||||
unsigned spos = sort_stack().size();
|
||||
parse_sorts("Invalid function name. Expecting sort list startig with '(' to disambiguate function name");
|
||||
parse_sorts("Invalid function name. Expecting sort list starting with '(' to disambiguate function name");
|
||||
unsigned domain_size = sort_stack().size() - spos;
|
||||
parse_sort("Invalid function name");
|
||||
func_decl * d = m_ctx.find_func_decl(id, indices.size(), indices.c_ptr(), domain_size, sort_stack().c_ptr() + spos, sort_stack().back());
|
||||
|
|
|
|||
|
|
@ -316,7 +316,7 @@ namespace qe {
|
|||
void mk_bound_aux(rational const& a, expr* t, rational const& b, expr* s, expr_ref& result) {
|
||||
SASSERT(a.is_neg() == b.is_neg());
|
||||
expr_ref tt(t, m), ss(s, m), e(m);
|
||||
// hack to fix wierd gcc compilation error
|
||||
// hack to fix weird gcc compilation error
|
||||
rational abs_a(a);
|
||||
rational abs_b(b);
|
||||
if (abs_a.is_neg()) abs_a.neg();
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ Copyright (c) 2015 Microsoft Corporation
|
|||
// -> \/_i R_C(t_i) & phi[t_i/x] \/ phi[false, true]
|
||||
//
|
||||
// Justification:
|
||||
// - We will asume that each of t_i, s_j are constructor terms.
|
||||
// - We will assume that each of t_i, s_j are constructor terms.
|
||||
// - We can assume that x \notin t_i, x \notin s_j, or otherwise use simplification.
|
||||
// - We can assume that x occurs only in equalities or disequalities, or the recognizer, since
|
||||
// otherwise, we could simplify equalities, or QE does not apply.
|
||||
|
|
|
|||
|
|
@ -1816,7 +1816,7 @@ namespace fm {
|
|||
}
|
||||
|
||||
// An integer variable x may be eliminated, if
|
||||
// 1- All variables in the contraints it occur are integer.
|
||||
// 1- All variables in the constraints it occur are integer.
|
||||
// 2- The coefficient of x in all lower bounds (or all upper bounds) is unit.
|
||||
bool can_eliminate(var x) const {
|
||||
if (!is_int(x))
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ namespace qe {
|
|||
/**
|
||||
* \brief Utility that works modulo a background state.
|
||||
* - vars
|
||||
* variables to preferrably project onto (other variables would require quantification to fit interpolation signature)
|
||||
* variables to preferably project onto (other variables would require quantification to fit interpolation signature)
|
||||
* - lits
|
||||
* set of literals to check satisfiability with respect to.
|
||||
* - mdl
|
||||
|
|
|
|||
|
|
@ -669,7 +669,7 @@ namespace qe {
|
|||
|
||||
// Here we could also walk equivalence classes that
|
||||
// contain interpreted values by sort and extract
|
||||
// disequalities bewteen non-unique value
|
||||
// disequalities between non-unique value
|
||||
// representatives. these disequalities are implied
|
||||
// and can be mined using other means, such as theory
|
||||
// aware core minimization
|
||||
|
|
|
|||
|
|
@ -2519,7 +2519,7 @@ namespace sat {
|
|||
* ~lit does not occur in clauses
|
||||
* ~lit is only in one constraint use list
|
||||
* lit == C
|
||||
* -> ignore assignemnts to ~lit for C
|
||||
* -> ignore assignments to ~lit for C
|
||||
*
|
||||
* ~lit does not occur in clauses
|
||||
* lit is only in one constraint use list
|
||||
|
|
|
|||
|
|
@ -118,7 +118,7 @@ namespace sat {
|
|||
local_search_config m_config;
|
||||
|
||||
// objective function: maximize
|
||||
svector<ob_term> ob_constraint; // the objective function *constraint*, sorted in decending order
|
||||
svector<ob_term> ob_constraint; // the objective function *constraint*, sorted in descending order
|
||||
|
||||
// information about the variable
|
||||
int_vector coefficient_in_ob_constraint; // var! initialized to be 0
|
||||
|
|
@ -169,8 +169,8 @@ namespace sat {
|
|||
|
||||
// unsat constraint stack
|
||||
bool m_is_unsat;
|
||||
unsigned_vector m_unsat_stack; // store all the unsat constraits
|
||||
unsigned_vector m_index_in_unsat_stack; // which position is a contraint in the unsat_stack
|
||||
unsigned_vector m_unsat_stack; // store all the unsat constraints
|
||||
unsigned_vector m_index_in_unsat_stack; // which position is a constraint in the unsat_stack
|
||||
|
||||
// configuration changed decreasing variables (score>0 and conf_change==true)
|
||||
bool_var_vector m_goodvar_stack;
|
||||
|
|
|
|||
|
|
@ -1220,7 +1220,7 @@ namespace sat {
|
|||
double operator()(literal l) override { return lh.literal_occs(l); }
|
||||
};
|
||||
|
||||
// Ternary clause managagement:
|
||||
// Ternary clause management:
|
||||
|
||||
void lookahead::add_ternary(literal u, literal v, literal w) {
|
||||
SASSERT(u != w && u != v && v != w && ~u != w && ~u != v && ~w != v);
|
||||
|
|
@ -1377,7 +1377,7 @@ namespace sat {
|
|||
}
|
||||
|
||||
|
||||
// new n-ary clause managment
|
||||
// new n-ary clause management
|
||||
|
||||
void lookahead::add_clause(clause const& c) {
|
||||
SASSERT(c.size() > 3);
|
||||
|
|
@ -1636,7 +1636,7 @@ namespace sat {
|
|||
}
|
||||
|
||||
// Sum_{ clause C that contains ~l } 1
|
||||
// FIXME: counts occurences of ~l; misleading
|
||||
// FIXME: counts occurrences of ~l; misleading
|
||||
double lookahead::literal_occs(literal l) {
|
||||
double result = m_binary[l.index()].size();
|
||||
result += literal_big_occs(l);
|
||||
|
|
@ -1644,7 +1644,7 @@ namespace sat {
|
|||
}
|
||||
|
||||
// Sum_{ clause C that contains ~l such that |C| > 2} 1
|
||||
// FIXME: counts occurences of ~l; misleading
|
||||
// FIXME: counts occurrences of ~l; misleading
|
||||
double lookahead::literal_big_occs(literal l) {
|
||||
double result = m_nary_count[(~l).index()];
|
||||
result += m_ternary_count[(~l).index()];
|
||||
|
|
@ -1718,7 +1718,7 @@ namespace sat {
|
|||
}
|
||||
// VERIFY(!missed_propagation());
|
||||
if (unsat) {
|
||||
TRACE("sat", tout << "backtracking and settting " << ~lit << "\n";);
|
||||
TRACE("sat", tout << "backtracking and setting " << ~lit << "\n";);
|
||||
lookahead_backtrack();
|
||||
assign(~lit);
|
||||
propagate();
|
||||
|
|
|
|||
|
|
@ -471,7 +471,7 @@ namespace sat {
|
|||
watch_list& get_wlist(literal l) { return m_watches[l.index()]; }
|
||||
watch_list const& get_wlist(literal l) const { return m_watches[l.index()]; }
|
||||
|
||||
// new clause managment:
|
||||
// new clause management:
|
||||
void add_ternary(literal u, literal v, literal w);
|
||||
void propagate_ternary(literal l);
|
||||
lbool propagate_ternary(literal l1, literal l2);
|
||||
|
|
|
|||
|
|
@ -232,7 +232,7 @@ namespace sat {
|
|||
}
|
||||
if (m_consumer_ready && (m_num_clauses == 0 || (m_num_clauses > s.m_clauses.size()))) {
|
||||
// time to update local search with new clauses.
|
||||
// there could be multiple local search engines runing at the same time.
|
||||
// there could be multiple local search engines running at the same time.
|
||||
IF_VERBOSE(1, verbose_stream() << "(sat-parallel refresh :from " << m_num_clauses << " :to " << s.m_clauses.size() << ")\n";);
|
||||
m_solver_copy = alloc(solver, s.m_params, s.rlimit());
|
||||
m_solver_copy->copy(s);
|
||||
|
|
|
|||
|
|
@ -984,7 +984,7 @@ namespace sat {
|
|||
queue m_queue;
|
||||
|
||||
literal_vector m_covered_clause; // covered clause
|
||||
svector<clause_ante> m_covered_antecedent; // explainations for literals in covered clause
|
||||
svector<clause_ante> m_covered_antecedent; // explanations for literals in covered clause
|
||||
literal_vector m_intersection; // current resolution intersection
|
||||
literal_vector m_tautology; // literals that are used in blocking tautology
|
||||
literal_vector m_new_intersection;
|
||||
|
|
|
|||
|
|
@ -74,7 +74,7 @@ namespace sat {
|
|||
// config
|
||||
bool m_abce; // block clauses using asymmetric added literals
|
||||
bool m_cce; // covered clause elimination
|
||||
bool m_acce; // cce with asymetric literal addition
|
||||
bool m_acce; // cce with asymmetric literal addition
|
||||
bool m_bca; // blocked (binary) clause addition.
|
||||
unsigned m_bce_delay;
|
||||
bool m_bce; // blocked clause elimination
|
||||
|
|
|
|||
|
|
@ -492,7 +492,7 @@ bool arith_eq_solver::solve_integer_equations_omega(
|
|||
return false;
|
||||
}
|
||||
else if (r[index].is_zero()) {
|
||||
// Row is trival
|
||||
// Row is trivial
|
||||
rows_solved.pop_back();
|
||||
continue;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -64,14 +64,14 @@ struct qi_params {
|
|||
Enodes in the input problem have generation 0.
|
||||
|
||||
Some combinations of m_qi_cost and m_qi_new_gen will prevent Z3 from breaking matching loops.
|
||||
For example, the "Weight 0" peformace bug was triggered by the following combination:
|
||||
For example, the "Weight 0" performance bug was triggered by the following combination:
|
||||
- m_qi_cost: (+ weight generation)
|
||||
- m_qi_new_gen: cost
|
||||
If a quantifier has weight 0, then the cost of instantiating it with a term in the input problem has cost 0.
|
||||
The new enodes created during the instantiation will be tagged with generation = const = 0. So, every enode
|
||||
will have generation 0, and consequently every quantifier instantiation will have cost 0.
|
||||
|
||||
Although dangerous, this feature was requested by the Boogie team. In their case, the patterns are carefully constructred,
|
||||
Although dangerous, this feature was requested by the Boogie team. In their case, the patterns are carefully constructed,
|
||||
and there are no matching loops. Moreover, the tag some quantifiers with weight 0 to instruct Z3 to never block their instances.
|
||||
An example is the select-store axiom. They need this feature to be able to analyze code that contains very long execution paths.
|
||||
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ def_module_params(module_name='smt',
|
|||
('ematching', BOOL, True, 'E-Matching based quantifier instantiation'),
|
||||
('phase_selection', UINT, 3, 'phase selection heuristic: 0 - always false, 1 - always true, 2 - phase caching, 3 - phase caching conservative, 4 - phase caching conservative 2, 5 - random, 6 - number of occurrences'),
|
||||
('restart_strategy', UINT, 1, '0 - geometric, 1 - inner-outer-geometric, 2 - luby, 3 - fixed, 4 - arithmetic'),
|
||||
('restart_factor', DOUBLE, 1.1, 'when using geometric (or inner-outer-geometric) progression of restarts, it specifies the constant used to multiply the currect restart threshold'),
|
||||
('restart_factor', DOUBLE, 1.1, 'when using geometric (or inner-outer-geometric) progression of restarts, it specifies the constant used to multiply the current restart threshold'),
|
||||
('case_split', UINT, 1, '0 - case split based on variable activity, 1 - similar to 0, but delay case splits created during the search, 2 - similar to 0, but cache the relevancy, 3 - case split based on relevancy (structural splitting), 4 - case split on relevancy and activity, 5 - case split on relevancy and current goal, 6 - activity-based case split with theory-aware branching activity'),
|
||||
('delay_units', BOOL, False, 'if true then z3 will not restart when a unit clause is learned'),
|
||||
('delay_units_threshold', UINT, 32, 'maximum number of learned unit clauses before restarting, ignored if delay_units is false'),
|
||||
|
|
|
|||
|
|
@ -175,7 +175,7 @@ namespace smt {
|
|||
}
|
||||
}
|
||||
m_new_entries.reset();
|
||||
TRACE("new_entries_bug", tout << "[qi:instatiate]\n";);
|
||||
TRACE("new_entries_bug", tout << "[qi:instantiate]\n";);
|
||||
}
|
||||
|
||||
void qi_queue::display_instance_profile(fingerprint * f, quantifier * q, unsigned num_bindings, enode * const * bindings, unsigned proof_id, unsigned generation) {
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ namespace smt {
|
|||
}
|
||||
|
||||
/**
|
||||
\brief Mark all enodes in a 'proof' tree brach starting at n
|
||||
\brief Mark all enodes in a 'proof' tree branch starting at n
|
||||
n -> ... -> root
|
||||
*/
|
||||
template<bool Set>
|
||||
|
|
|
|||
|
|
@ -518,7 +518,7 @@ namespace smt {
|
|||
// 2. r1 is interpreted but r2 is not.
|
||||
//
|
||||
// The second condition is used to enforce the invariant that if a class contain
|
||||
// an interepreted enode then the root is also interpreted.
|
||||
// an interpreted enode then the root is also interpreted.
|
||||
if ((r1->get_class_size() > r2->get_class_size() && !r2->is_interpreted()) || r1->is_interpreted()) {
|
||||
SASSERT(!r2->is_interpreted());
|
||||
std::swap(n1, n2);
|
||||
|
|
@ -529,7 +529,7 @@ namespace smt {
|
|||
" n1: #" << n1->get_owner_id() << "\n";);
|
||||
|
||||
// It is necessary to propagate relevancy to other elements of
|
||||
// the equivalence class. This is nessary to enforce the invariant
|
||||
// the equivalence class. This is necessary to enforce the invariant
|
||||
// in the field m_parent of the enode class.
|
||||
if (is_relevant(r1)) { // && !m_manager.is_eq(r1->get_owner())) !is_eq HACK
|
||||
// NOTE for !is_eq HACK... the !is_eq HACK does not propagate relevancy when two
|
||||
|
|
@ -4067,7 +4067,7 @@ namespace smt {
|
|||
A literal may have been marked relevant within the scope that gets popped during
|
||||
conflict resolution. In this case, the literal is no longer marked as relevant after
|
||||
the pop. This can cause quantifier instantiation to miss relevant triggers and thereby
|
||||
cause incmpleteness.
|
||||
cause incompleteness.
|
||||
*/
|
||||
void context::record_relevancy(unsigned n, literal const* lits) {
|
||||
m_relevant_conflict_literals.reset();
|
||||
|
|
@ -4281,7 +4281,7 @@ namespace smt {
|
|||
return true;
|
||||
}
|
||||
|
||||
// the variabe is shared if the equivalence class of n
|
||||
// the variable is shared if the equivalence class of n
|
||||
// contains a parent application.
|
||||
|
||||
theory_var_list * l = n->get_th_var_list();
|
||||
|
|
|
|||
|
|
@ -73,7 +73,7 @@ namespace smt {
|
|||
class tmp_enode;
|
||||
|
||||
/**
|
||||
\brief Aditional data-structure for implementing congruence closure,
|
||||
\brief Additional data-structure for implementing congruence closure,
|
||||
equality propagation, and the theory central bus of equalities.
|
||||
*/
|
||||
class enode {
|
||||
|
|
|
|||
|
|
@ -96,7 +96,7 @@ namespace smt {
|
|||
class model_value_dependency {
|
||||
bool m_fresh; //!< True if the dependency is a new fresh value;
|
||||
union {
|
||||
enode * m_enode; //!< When m_fresh == false, contains an enode depedency.
|
||||
enode * m_enode; //!< When m_fresh == false, contains an enode dependency.
|
||||
extra_fresh_value * m_value; //!< When m_fresh == true, contains the sort of the fresh value
|
||||
};
|
||||
public:
|
||||
|
|
|
|||
|
|
@ -203,7 +203,7 @@ namespace smt {
|
|||
|
||||
static void check_no_arithmetic(static_features const & st, char const * logic) {
|
||||
if (st.m_num_arith_ineqs > 0 || st.m_num_arith_terms > 0 || st.m_num_arith_eqs > 0)
|
||||
throw default_exception("Benchmark constains arithmetic, but specified loging does not support it.");
|
||||
throw default_exception("Benchmark constains arithmetic, but specified logic does not support it.");
|
||||
}
|
||||
|
||||
void setup::setup_QF_UF() {
|
||||
|
|
@ -519,7 +519,7 @@ namespace smt {
|
|||
m_params.m_arith_eq2ineq = true;
|
||||
m_params.m_eliminate_term_ite = true;
|
||||
// if (st.m_num_exprs < 5000 && st.m_num_ite_terms < 50) { // safeguard to avoid high memory consumption
|
||||
// TODO: implement analsysis function to decide where lift ite is too expensive.
|
||||
// TODO: implement analysis function to decide where lift ite is too expensive.
|
||||
// m_params.m_lift_ite = LI_FULL;
|
||||
// }
|
||||
}
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ namespace smt {
|
|||
|
||||
public:
|
||||
/**
|
||||
\brief Return ture if the given enode is attached to a
|
||||
\brief Return true if the given enode is attached to a
|
||||
variable of the theory.
|
||||
|
||||
\remark The result is not equivalent to
|
||||
|
|
@ -389,7 +389,7 @@ namespace smt {
|
|||
\brief When an eq atom n is created during the search, the default behavior is
|
||||
to make sure that the n->get_arg(0)->get_id() < n->get_arg(1)->get_id().
|
||||
This may create some redundant atoms, since some theories/families use different
|
||||
convetions in their simplifiers. For example, arithmetic always force a numeral
|
||||
conventions in their simplifiers. For example, arithmetic always force a numeral
|
||||
to be in the right hand side. So, this method should be redefined if the default
|
||||
behavior conflicts with a convention used by the theory/family.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -1073,7 +1073,7 @@ namespace smt {
|
|||
/**
|
||||
\brief: Create an atom that enforces the inequality v > val
|
||||
The arithmetical expression encoding the inequality suffices
|
||||
for the theory of aritmetic.
|
||||
for the theory of arithmetic.
|
||||
*/
|
||||
template<typename Ext>
|
||||
expr_ref theory_arith<Ext>::mk_gt(theory_var v) {
|
||||
|
|
@ -1146,7 +1146,7 @@ namespace smt {
|
|||
template<typename Ext>
|
||||
void theory_arith<Ext>::enable_record_conflict(expr* bound) {
|
||||
m_params.m_arith_bound_prop = BP_NONE;
|
||||
SASSERT(propagation_mode() == BP_NONE); // bound propagtion rules are not (yet) handled.
|
||||
SASSERT(propagation_mode() == BP_NONE); // bound propagation rules are not (yet) handled.
|
||||
if (bound) {
|
||||
context& ctx = get_context();
|
||||
m_bound_watch = ctx.get_bool_var(bound);
|
||||
|
|
|
|||
|
|
@ -3128,7 +3128,7 @@ namespace smt {
|
|||
//
|
||||
// 1) Handling inequalities: (n1, k1) <= (n2, k2)
|
||||
//
|
||||
// The only intersting case is n1 < n2 and k1 > k2.
|
||||
// The only interesting case is n1 < n2 and k1 > k2.
|
||||
// Using the definition of infinitesimal numbers
|
||||
// we have:
|
||||
// n1 + k1 * epsilon <= n2 + k2 - epsilon
|
||||
|
|
@ -3533,7 +3533,7 @@ namespace smt {
|
|||
}
|
||||
|
||||
/**
|
||||
\brief reset and retrieve built-in explanation hints for arithmetic lemmmas.
|
||||
\brief reset and retrieve built-in explanation hints for arithmetic lemmas.
|
||||
*/
|
||||
|
||||
template<typename Ext>
|
||||
|
|
|
|||
|
|
@ -1337,7 +1337,7 @@ namespace smt {
|
|||
}
|
||||
|
||||
/**
|
||||
\brief Diplay a nested form expression
|
||||
\brief Display a nested form expression
|
||||
*/
|
||||
template<typename Ext>
|
||||
void theory_arith<Ext>::display_nested_form(std::ostream & out, expr * p) {
|
||||
|
|
@ -1682,7 +1682,7 @@ namespace smt {
|
|||
if (!get_manager().int_real_coercions() && is_mixed_real_integer(r))
|
||||
return true; // giving up... see comment above
|
||||
|
||||
TRACE("cross_nested", tout << "cheking problematic row...\n";);
|
||||
TRACE("cross_nested", tout << "checking problematic row...\n";);
|
||||
|
||||
rational c = rational::one();
|
||||
if (is_integer(r))
|
||||
|
|
@ -1764,7 +1764,7 @@ namespace smt {
|
|||
updated with the fixed variables in m. A variable is only
|
||||
added to dep if it is not already in already_found.
|
||||
|
||||
Return null if the monomial was simplied to 0.
|
||||
Return null if the monomial was simplified to 0.
|
||||
*/
|
||||
template<typename Ext>
|
||||
grobner::monomial * theory_arith<Ext>::mk_gb_monomial(rational const & _coeff, expr * m, grobner & gb, v_dependency * & dep, var_set & already_found) {
|
||||
|
|
|
|||
|
|
@ -756,7 +756,7 @@ namespace smt {
|
|||
(n_x, k_x) <= (n_y + n_c, k_y + k_c)
|
||||
|
||||
|
||||
The only intersting case is n_x < n_y + n_c and k_x > k_y + k_c.
|
||||
The only interesting case is n_x < n_y + n_c and k_x > k_y + k_c.
|
||||
Using the definition of infinitesimal numbers
|
||||
we have:
|
||||
|
||||
|
|
|
|||
|
|
@ -3225,7 +3225,7 @@ public:
|
|||
theory_var w;
|
||||
if (m_solver->is_term(ti.var())) {
|
||||
//w = m_term_index2theory_var.get(m_solver->adjust_term_index(ti.var()), null_theory_var);
|
||||
//if (w == null_theory_var) // if extracing expressions directly from nested term
|
||||
//if (w == null_theory_var) // if extracting expressions directly from nested term
|
||||
lp::lar_term const& term1 = m_solver->get_term(ti.var());
|
||||
rational coeff2 = coeff * ti.coeff();
|
||||
term2coeffs(term1, coeffs, coeff2, offset);
|
||||
|
|
|
|||
|
|
@ -107,7 +107,7 @@ namespace smt {
|
|||
|
||||
struct ineq {
|
||||
unsynch_mpz_manager& m_mpz; // mpz manager.
|
||||
literal m_lit; // literal repesenting predicate
|
||||
literal m_lit; // literal representing predicate
|
||||
bool m_is_eq; // is this an = or >=.
|
||||
arg_t m_args[2]; // encode args[0]*coeffs[0]+...+args[n-1]*coeffs[n-1] >= k();
|
||||
// Watch the first few positions until the sum satisfies:
|
||||
|
|
@ -192,7 +192,7 @@ namespace smt {
|
|||
// If none are available, then perform unit propagation.
|
||||
//
|
||||
class card {
|
||||
literal m_lit; // literal repesenting predicate
|
||||
literal m_lit; // literal representing predicate
|
||||
literal_vector m_args;
|
||||
unsigned m_bound;
|
||||
unsigned m_num_propagations;
|
||||
|
|
|
|||
|
|
@ -1412,7 +1412,7 @@ bool theory_seq::is_complex(eq const& e) {
|
|||
\brief Decompose ls = rs into Xa = bYc, such that
|
||||
1.
|
||||
- X != Y
|
||||
- |b| <= |X| <= |bY| in currrent model
|
||||
- |b| <= |X| <= |bY| in current model
|
||||
- b is non-empty.
|
||||
2. X != Y
|
||||
- b is empty
|
||||
|
|
|
|||
|
|
@ -5074,7 +5074,7 @@ namespace smt {
|
|||
}
|
||||
} else {
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// subStr doesn't have an eqc contant value
|
||||
// subStr doesn't have an eqc constant value
|
||||
// however, subStr equals to some concat(arg_1, arg_2, ..., arg_n)
|
||||
// if arg_j is a constant and is not a part of the strConst, it's sure that the contains is false
|
||||
// ** This check is needed here because the "strConst" and "strAst" may not be in a same eqc yet
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ Notes:
|
|||
|
||||
The object switches to incremental when:
|
||||
- push is used
|
||||
- assertions are peformed after a check_sat
|
||||
- assertions are performed after a check_sat
|
||||
- parameter ignore_solver1==false
|
||||
*/
|
||||
class combined_solver : public solver {
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@ def_module_params('parallel',
|
|||
('conquer.restart.max', UINT, 5, 'maximal number of restarts during conquer phase'),
|
||||
('conquer.delay', UINT, 10, 'delay of cubes until applying conquer'),
|
||||
('conquer.backtrack_frequency', UINT, 10, 'frequency to apply core minimization during conquer'),
|
||||
('simplify.exp', DOUBLE, 1, 'restart and inprocess max is multipled by simplify.exp ^ depth'),
|
||||
('simplify.exp', DOUBLE, 1, 'restart and inprocess max is multiplied by simplify.exp ^ depth'),
|
||||
('simplify.restart.max', UINT, 5000, 'maximal number of restarts during simplification phase'),
|
||||
('simplify.inprocess.max', UINT, 2, 'maximal number of inprocessing steps during simplification'),
|
||||
))
|
||||
|
|
|
|||
|
|
@ -1231,7 +1231,7 @@ class fm_tactic : public tactic {
|
|||
}
|
||||
|
||||
// An integer variable x may be eliminated, if
|
||||
// 1- All variables in the contraints it occur are integer.
|
||||
// 1- All variables in the constraints it occur are integer.
|
||||
// 2- The coefficient of x in all lower bounds (or all upper bounds) is unit.
|
||||
bool can_eliminate(var x) const {
|
||||
if (!is_int(x))
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ bvarray2uf_rewriter_cfg::bvarray2uf_rewriter_cfg(ast_manager & m, params_ref con
|
|||
m_fmc(nullptr),
|
||||
extra_assertions(m) {
|
||||
updt_params(p);
|
||||
// We need to make sure that the mananger has the BV and array plugins loaded.
|
||||
// We need to make sure that the manager has the BV and array plugins loaded.
|
||||
symbol s_bv("bv");
|
||||
if (!m_manager.has_plugin(s_bv))
|
||||
m_manager.register_plugin(s_bv, alloc(bv_decl_plugin));
|
||||
|
|
|
|||
|
|
@ -197,7 +197,7 @@ struct cofactor_elim_term_ite::imp {
|
|||
switch (arg->get_kind()) {
|
||||
case AST_VAR:
|
||||
case AST_QUANTIFIER:
|
||||
// ingore quantifiers
|
||||
// ignore quantifiers
|
||||
break;
|
||||
case AST_APP:
|
||||
if (to_app(arg)->get_num_args() > 0) {
|
||||
|
|
@ -264,7 +264,7 @@ struct cofactor_elim_term_ite::imp {
|
|||
switch (arg->get_kind()) {
|
||||
case AST_VAR:
|
||||
case AST_QUANTIFIER:
|
||||
// ingore quantifiers
|
||||
// ignore quantifiers
|
||||
break;
|
||||
case AST_APP:
|
||||
if (to_app(arg)->get_num_args() > 0) {
|
||||
|
|
|
|||
|
|
@ -273,8 +273,8 @@ private:
|
|||
}
|
||||
|
||||
/**
|
||||
\brief decompose large sums into smaller sums by intoducing
|
||||
auxilary variables.
|
||||
\brief decompose large sums into smaller sums by introducing
|
||||
auxiliary variables.
|
||||
*/
|
||||
void decompose(goal_ref const& g) {
|
||||
expr_ref fml1(m), fml2(m);
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ Notes:
|
|||
|
||||
This property holds for both eval, that decides on a fixed value
|
||||
for constants that have no interpretation in m and for 'peval'
|
||||
(partial eval) that retuns just the constants that are unfixed.
|
||||
(partial eval) that returns just the constants that are unfixed.
|
||||
(in the model evaluator one can control this behavior using a
|
||||
configuration flag)
|
||||
|
||||
|
|
@ -48,7 +48,7 @@ Notes:
|
|||
mc(G) & F_s is SAT iff G & F is SAT
|
||||
|
||||
For a model converter that is a sequence of definitions and removals
|
||||
of functions we can obtain mc(G) by adding back or expanding definitinos
|
||||
of functions we can obtain mc(G) by adding back or expanding definitions
|
||||
that are required to interpret G fully in the context of F_s.
|
||||
|
||||
--*/
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue