mirror of
https://github.com/Z3Prover/z3
synced 2025-06-29 01:18:45 +00:00
Sls (#7439)
* reorg sls * sls * na * split into base and plugin * move sat_params to params directory, add op_def repair options * move sat_ddfw to sls, initiate sls-bv-plugin * porting bv-sls * adding basic plugin * na Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * add sls-sms solver * bv updates * updated dependencies Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * updated dependencies Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * use portable ptr-initializer Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * move definitions to cpp Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * use template<> syntax Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fix compiler errors for gcc Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * Bump docker/build-push-action from 6.0.0 to 6.1.0 (#7265) Bumps [docker/build-push-action](https://github.com/docker/build-push-action) from 6.0.0 to 6.1.0. - [Release notes](https://github.com/docker/build-push-action/releases) - [Commits](https://github.com/docker/build-push-action/compare/v6.0.0...v6.1.0) --- updated-dependencies: - dependency-name: docker/build-push-action dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> * set clean shutdown for local search and re-enable local search when it parallelizes with PB solver Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * Bump docker/build-push-action from 6.1.0 to 6.2.0 (#7269) Bumps [docker/build-push-action](https://github.com/docker/build-push-action) from 6.1.0 to 6.2.0. - [Release notes](https://github.com/docker/build-push-action/releases) - [Commits](https://github.com/docker/build-push-action/compare/v6.1.0...v6.2.0) --- updated-dependencies: - dependency-name: docker/build-push-action dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> * Fix a comment for Z3_solver_from_string (#7271) Z3_solver_from_string accepts a string buffer with solver assertions, not a string buffer with filename. * trigger the build with a comment change Signed-off-by: Lev Nachmanson <levnach@hotmail.com> * remove macro distinction #7270 * fix #7268 * kludge to address #7232, probably superseeded by planned revision to setup/pypi Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * add new ema invariant (#7288) * Bump docker/build-push-action from 6.2.0 to 6.3.0 (#7280) Bumps [docker/build-push-action](https://github.com/docker/build-push-action) from 6.2.0 to 6.3.0. - [Release notes](https://github.com/docker/build-push-action/releases) - [Commits](https://github.com/docker/build-push-action/compare/v6.2.0...v6.3.0) --- updated-dependencies: - dependency-name: docker/build-push-action dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> * merge Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fix unit test build Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * remove shared attribute Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * remove stale files Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fix build of unit test Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fixes and rename sls-cc to sls-euf-plugin Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * na Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * testing / debugging arithmetic * updates to repair logic, mainly arithmetic * fixes to sls * evolve sls arith * bugfixes in sls-arith * fix typo Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * bug fixes * Update sls_test.cpp * fixes * fixes Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fix build Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * refactor basic plugin and clause generation Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fixes to ite and other Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * updates * update Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fix division by 0 Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * disable fail restart Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * disable tabu when using reset moves Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * update sls_test Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * add factoring Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fixes to semantics Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * re-add tabu override Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * generalize factoring Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fix bug Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * remove restart Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * disable tabu in fallback modes Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * localize impact of factoring Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * delay factoring Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * flatten products Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * perform lookahead update + nested mul Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * disable nested mul Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * disable nested mul, use non-lookahead Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * make reset updates recursive Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * include linear moves Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * include 5% reset probability Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * separate linear update Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * separate linear update remove 20% threshold Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * remove linear opt Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * enable multiplier expansion, enable linear move Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * use unit coefficients for muls Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * disable non-tabu version of find_nl_moves Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * remove coefficient from multiplication definition Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * reorg monomials Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * add smt params to path Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * avoid negative reward Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * use reward as proxy for score Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * use reward as proxy for score Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * use exponential decay with breaks Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * use std::pow Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fixes to bv Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fixes to fixed Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fixup repairs Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * reserve for multiplication Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fixing repair Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * include bounds checks in set random * na * fixes to mul Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fix mul inverse Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fixes to handling signed operators Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * logging and fixes Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * gcm Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * peli Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * Add .env to gitignore to prevent environment files from being tracked * Add m_num_pelis counter to stats in sls_context * Remove m_num_pelis member from stats struct in sls_context * Enhance bv_sls_eval with improved repair and logging, refine is_bv_predicate in sls_bv_plugin * Remove verbose logging in register_term function of sls_basic_plugin and fix formatting in sls_context * Rename source files for consistency in `src/ast/sls` directory * Refactor bv_sls files to sls_bv with namespace and class name adjustments * Remove typename from member declarations in bv_fixed class * fixing conca Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * Add initial implementation of bit-vector SLS evaluation module in bv_sls_eval.cpp * Remove bv_sls_eval.cpp as part of code cleanup and refactoring * Refactor alignment of member variables in bv_plugin of sls namespace * Rename SLS engine related files to reflect their specific use for bit-vectors * Refactor SLS engine and evaluator components for bit-vector specifics and adjust memory manager alignment * Enhance bv_eval with use_current, lookahead strategies, and randomization improvements in SLS module * Refactor verbose logging and fix logic in range adjustment functions in sls bv modules * Remove commented verbose output in sls_bv_plugin.cpp during repair process * Add early return after setting fixed subterms in sls_bv_fixed.cpp * Remove redundant return statement in sls_bv_fixed.cpp * fixes to new value propagation Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * Refactor sls bv evaluation and fix logic checks for bit operations * Add array plugin support and update bv_eval in ast_sls module * Add array, model value, and user sort plugins to SLS module with enhancements in array propagation logic * Refactor array_plugin in sls to improve handling of select expressions with multiple arguments * Enhance array plugin with early termination and propagation verification, and improve euf and user sort plugins with propagation adjustments and debugging enhancements * Add support for handling 'distinct' expressions in SLS context and user sort plugin * Remove model value and user sort plugins from SLS theory * replace user plugin by euf plugin Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * remove extra file Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * Refactor handling of term registration and enhance distinct handling in sls_euf_plugin * Add TODO list for enhancements in sls_euf_plugin.cpp * add incremental mode * updated package * fix sls build Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * break sls build Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fix build * break build again * fix build Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fixes Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fixing incremental Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * avoid units Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fixup handling of disequality propagation Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fx Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * recover shift-weight loop Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * alternate Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * throttle save model Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * allow for alternating Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fix test for new signature of flip Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * bug fixes Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * restore use of value_hash Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fixes Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * adding dt plugin Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * adt Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * dt updates Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * added cycle detection Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * updated sls-datatype Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * Refactor context management, improve datatype handling, and enhance logging in sls plugins. * axiomatize dt Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * add missing factory plugins to model Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fixup finite domain search Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fixup finite domain search Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fixes Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * redo dfs Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fixing model construction for underspecified operators Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fixes to occurs check Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fixup interpretation building Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * saturate worklist Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * delay distinct axiom Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * adding model-based sls for datatatypes * update the interface in sls_solver to transfer phase between SAT and SLS * add value transfer option Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * rename aux functions * Track shared variables using a unit set * debugging parallel integration * fix dirty flag setting * update log level * add plugin to smt_context, factor out sls_smt_plugin functionality. * bug fixes * fixes * use common infrastructure for sls-smt * fix build Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fix build Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * remove declaration of context Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * add virtual destructor Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * build warnings Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * reorder inclusion order to define smt_context before theory_sls Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * change namespace for single threaded Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * check delayed eqs before nla Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * use independent completion flag for sls to avoid conflating with genuine cancelation * validate sls-arith lemmas Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * bugfixes Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * add intblast to legacy SMT solver * fixup model generation for theory_intblast Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * na Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * mk_value needs to accept more cases where integer expression doesn't evalate Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * use th-axioms to track origins of assertions Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * add missing operator handling for bitwise operators Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * add missing operator handling for bitwise operators Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * normalizing inequality Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * add virtual destructor Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * rework elim_unconstrained * fix non-termination Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * use glue as computed without adjustment * update model generation to fix model bug Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fixes to model construction * remove package and package lock Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * fix build warning Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> * use original gai Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> --------- Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com> Signed-off-by: dependabot[bot] <support@github.com> Signed-off-by: Lev Nachmanson <levnach@hotmail.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Sergey Bronnikov <estetus@gmail.com> Co-authored-by: Lev Nachmanson <levnach@hotmail.com> Co-authored-by: LiviaSun <33578456+ChuyueSun@users.noreply.github.com>
This commit is contained in:
Nikolaj Bjorner
GitHub
parent
ecdfab81a6
commit
91dc02d862
120 changed files with 11172 additions and 4148 deletions
|
|
@ -42,6 +42,73 @@ proof production is work in progress.
|
|||
reconstruct_term should assign proof objects with nodes by applying
|
||||
monotonicity or reflexivity rules.
|
||||
|
||||
Maintain term nodes.
|
||||
Each term node has a root. The root of the root is itself.
|
||||
The root of a term node can be updated.
|
||||
The parents of terms with same roots are combined.
|
||||
The depth of a parent is always greater than the depth of a child.
|
||||
The effective term of a node is reconstructed by taking the root and canonizing the children based on roots.
|
||||
The reference count of a term is the number of parents it has.
|
||||
|
||||
node: term -> node
|
||||
dirty: node -> bool
|
||||
root: node -> node
|
||||
top: node -> bool
|
||||
term: node -> term
|
||||
|
||||
invariant:
|
||||
- root(root(n)) = root(n)
|
||||
- term(node(t)) = t
|
||||
|
||||
parents: node -> node*
|
||||
parents(root(node)) = union of parents of n : root(n) = root(node).
|
||||
is_child(n, p) = term(root(n)) in args(term(root(p)))
|
||||
|
||||
set_root: node -> node -> void
|
||||
set_root(n, r) =
|
||||
r = root(r)
|
||||
n = root(n)
|
||||
if r = n then return
|
||||
parents(r) = parents(r) union parents(n)
|
||||
root(n) := r,
|
||||
top(r) := top(r) or top(n)
|
||||
set all parents of class(r) to dirty, recursively
|
||||
|
||||
reconstruct_term: node -> term
|
||||
reconstruct_term(n) =
|
||||
r = root(n)
|
||||
if dirty(r) then
|
||||
args = [reconstruct_term(c) | c in args(term(r))]
|
||||
term(r) := term(r).f(args)
|
||||
dirty(r) := false
|
||||
return term(r)
|
||||
|
||||
live : term -> bool
|
||||
live(t) =
|
||||
n = node(t)
|
||||
is_root(n) & (top(n) or p in parents(n) : live(p))
|
||||
|
||||
Only live nodes require updates.
|
||||
|
||||
eliminate:
|
||||
while heap is not empty:
|
||||
v = heap.erase_min()
|
||||
n = node(v)
|
||||
if n.parents.size() > 1 then
|
||||
return
|
||||
if !is_root(n) or !live(n) or n.parents.size() != 1 then
|
||||
continue
|
||||
p = n.parents[0]
|
||||
if !is_child(n, p) or !is_root(p) then
|
||||
continue
|
||||
t = p.term
|
||||
args = [reconstruct_term(node(arg)) | arg in t]
|
||||
r = inverter(t.f, args)
|
||||
if r then
|
||||
set_root(n, r)
|
||||
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
|
||||
|
|
@ -54,15 +121,17 @@ monotonicity or reflexivity rules.
|
|||
elim_unconstrained::elim_unconstrained(ast_manager& m, dependent_expr_state& fmls) :
|
||||
dependent_expr_simplifier(m, fmls), m_inverter(m), m_lt(*this), m_heap(1024, m_lt), m_trail(m), m_args(m) {
|
||||
std::function<bool(expr*)> is_var = [&](expr* e) {
|
||||
return is_uninterp_const(e) && !m_fmls.frozen(e) && is_node(e) && get_node(e).m_refcount <= 1;
|
||||
return is_uninterp_const(e) && !m_fmls.frozen(e) && get_node(e).is_root() && get_node(e).num_parents() <= 1;
|
||||
};
|
||||
m_inverter.set_is_var(is_var);
|
||||
}
|
||||
|
||||
bool elim_unconstrained::is_var_lt(int v1, int v2) const {
|
||||
node const& n1 = get_node(v1);
|
||||
node const& n2 = get_node(v2);
|
||||
return n1.m_refcount < n2.m_refcount;
|
||||
elim_unconstrained::~elim_unconstrained() {
|
||||
reset_nodes();
|
||||
}
|
||||
|
||||
bool elim_unconstrained::is_var_lt(int v1, int v2) const {
|
||||
return get_node(v1).num_parents() < get_node(v2).num_parents();
|
||||
}
|
||||
|
||||
void elim_unconstrained::eliminate() {
|
||||
|
|
@ -70,30 +139,29 @@ void elim_unconstrained::eliminate() {
|
|||
expr_ref r(m);
|
||||
int v = m_heap.erase_min();
|
||||
node& n = get_node(v);
|
||||
if (n.m_refcount == 0)
|
||||
if (!n.is_root() || n.is_top())
|
||||
continue;
|
||||
if (n.m_refcount > 1)
|
||||
unsigned num_parents = n.num_parents();
|
||||
if (num_parents == 0)
|
||||
continue;
|
||||
if (num_parents > 1)
|
||||
return;
|
||||
|
||||
if (n.m_parents.empty()) {
|
||||
n.m_refcount = 0;
|
||||
node& p = n.parent();
|
||||
if (!is_child(n, p) || !p.is_root())
|
||||
continue;
|
||||
}
|
||||
expr* e = get_parent(v);
|
||||
TRACE("elim_unconstrained", for (expr* p : n.m_parents) tout << "parent " << mk_bounded_pp(p, m) << " @ " << get_node(p).m_refcount << "\n";);
|
||||
if (!e || !is_app(e) || !is_ground(e)) {
|
||||
n.m_refcount = 0;
|
||||
expr* e = p.term();
|
||||
if (!e || !is_app(e) || !is_ground(e))
|
||||
continue;
|
||||
}
|
||||
if (m_heap.contains(root(e))) {
|
||||
TRACE("elim_unconstrained", tout << "already in heap " << mk_bounded_pp(e, m) << "\n");
|
||||
continue;
|
||||
}
|
||||
|
||||
SASSERT(!m_heap.contains(p.term()->get_id()));
|
||||
|
||||
app* t = to_app(e);
|
||||
TRACE("elim_unconstrained", tout << "eliminating " << mk_pp(t, m) << "\n";);
|
||||
TRACE("elim_unconstrained", tout << "eliminating " << mk_bounded_pp(t, m) << "\n";);
|
||||
unsigned sz = m_args.size();
|
||||
for (expr* arg : *to_app(t))
|
||||
m_args.push_back(reconstruct_term(get_node(arg)));
|
||||
m_args.push_back(reconstruct_term(root(arg)));
|
||||
expr_ref rr(m.mk_app(t->get_decl(), t->get_num_args(), m_args.data() + sz), m);
|
||||
bool inverted = m_inverter(t->get_decl(), t->get_num_args(), m_args.data() + sz, r);
|
||||
proof_ref pr(m);
|
||||
if (inverted && m_enable_proofs) {
|
||||
|
|
@ -103,67 +171,91 @@ void elim_unconstrained::eliminate() {
|
|||
proof * pr = m.mk_apply_def(s, r, pr1);
|
||||
m_trail.push_back(pr);
|
||||
}
|
||||
expr_ref rr(m.mk_app(t->get_decl(), t->get_num_args(), m_args.data() + sz), m);
|
||||
n.m_refcount = 0;
|
||||
m_args.shrink(sz);
|
||||
if (!inverted) {
|
||||
TRACE("elim_unconstrained", tout << "not inverted " << mk_bounded_pp(e, m) << "\n");
|
||||
if (!inverted)
|
||||
continue;
|
||||
}
|
||||
|
||||
IF_VERBOSE(11, verbose_stream() << "replace " << mk_pp(t, m) << " / " << rr << " -> " << r << "\n");
|
||||
IF_VERBOSE(4, verbose_stream() << "replace " << mk_bounded_pp(t, m) << " / " << mk_bounded_pp(rr, m) << " -> " << mk_bounded_pp(r, m) << "\n");
|
||||
|
||||
|
||||
TRACE("elim_unconstrained", tout << mk_pp(t, m) << " / " << rr << " -> " << r << "\n");
|
||||
TRACE("elim_unconstrained", tout << mk_bounded_pp(t, m) << " / " << mk_bounded_pp(rr, m) << " -> " << mk_bounded_pp(r, m) << "\n");
|
||||
SASSERT(r->get_sort() == t->get_sort());
|
||||
m_stats.m_num_eliminated++;
|
||||
m_trail.push_back(r);
|
||||
SASSERT(r);
|
||||
gc(e);
|
||||
invalidate_parents(e);
|
||||
freeze_rec(r);
|
||||
|
||||
m_root.setx(r->get_id(), e->get_id(), UINT_MAX);
|
||||
get_node(e).m_term = r;
|
||||
get_node(e).m_proof = pr;
|
||||
get_node(e).m_refcount++;
|
||||
get_node(e).m_dirty = false;
|
||||
IF_VERBOSE(11, verbose_stream() << "set " << &get_node(e) << " " << root(e) << " " << mk_bounded_pp(e, m) << " := " << mk_bounded_pp(r, m) << "\n");
|
||||
SASSERT(!m_heap.contains(root(e)));
|
||||
if (is_uninterp_const(r))
|
||||
m_heap.insert(root(e));
|
||||
node& rn = root(r);
|
||||
set_root(p, rn);
|
||||
expr* rt = rn.term();
|
||||
SASSERT(!m_heap.contains(rt->get_id()));
|
||||
if (is_uninterp_const(rt))
|
||||
m_heap.insert(rt->get_id());
|
||||
else
|
||||
m_created_compound = true;
|
||||
|
||||
IF_VERBOSE(11, verbose_stream() << mk_bounded_pp(get_node(v).m_orig, m) << " " << mk_bounded_pp(t, m) << " -> " << r << " " << get_node(e).m_refcount << "\n";);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
expr* elim_unconstrained::get_parent(unsigned n) const {
|
||||
for (expr* p : get_node(n).m_parents)
|
||||
if (get_node(p).m_refcount > 0 && get_node(p).m_term == get_node(p).m_orig)
|
||||
return p;
|
||||
return nullptr;
|
||||
void elim_unconstrained::set_root(node& n, node& r) {
|
||||
SASSERT(n.is_root());
|
||||
SASSERT(r.is_root());
|
||||
if (&n == &r)
|
||||
return;
|
||||
r.add_parents(n.parents());
|
||||
n.set_root(r);
|
||||
for (auto p : n.parents())
|
||||
invalidate_parents(*p);
|
||||
}
|
||||
|
||||
void elim_unconstrained::invalidate_parents(expr* e) {
|
||||
ptr_buffer<expr> todo;
|
||||
void elim_unconstrained::invalidate_parents(node& n) {
|
||||
ptr_buffer<node> todo;
|
||||
node* np = &n;
|
||||
do {
|
||||
node& n = get_node(e);
|
||||
if (!n.m_dirty && e == n.m_term) {
|
||||
n.m_dirty = true;
|
||||
for (expr* e : n.m_parents)
|
||||
todo.push_back(e);
|
||||
node& n = *np;
|
||||
if (!n.is_dirty()) {
|
||||
n.set_dirty();
|
||||
for (auto* p : n.parents())
|
||||
todo.push_back(p);
|
||||
}
|
||||
e = nullptr;
|
||||
np = nullptr;
|
||||
if (!todo.empty()) {
|
||||
e = todo.back();
|
||||
np = todo.back();
|
||||
todo.pop_back();
|
||||
}
|
||||
}
|
||||
while (e);
|
||||
while (np);
|
||||
}
|
||||
|
||||
bool elim_unconstrained::is_child(node const& ch, node const& p) {
|
||||
SASSERT(ch.is_root());
|
||||
return is_app(p.term()) && any_of(*to_app(p.term()), [&](expr* arg) { return &root(arg) == &ch; });
|
||||
}
|
||||
|
||||
elim_unconstrained::node& elim_unconstrained::get_node(expr* t) {
|
||||
unsigned id = t->get_id();
|
||||
if (m_nodes.size() <= id)
|
||||
m_nodes.resize(id + 1, nullptr);
|
||||
node* n = m_nodes[id];
|
||||
if (!n) {
|
||||
n = alloc(node, m, t);
|
||||
m_nodes[id] = n;
|
||||
if (is_app(t)) {
|
||||
for (auto arg : *to_app(t)) {
|
||||
node& ch = get_node(arg);
|
||||
SASSERT(ch.is_root());
|
||||
ch.add_parent(*n);
|
||||
}
|
||||
}
|
||||
else if (is_quantifier(t)) {
|
||||
node& ch = get_node(to_quantifier(t)->get_expr());
|
||||
SASSERT(ch.is_root());
|
||||
ch.add_parent(*n);
|
||||
}
|
||||
}
|
||||
return *n;
|
||||
}
|
||||
|
||||
void elim_unconstrained::reset_nodes() {
|
||||
for (node* n : m_nodes)
|
||||
dealloc(n);
|
||||
m_nodes.reset();
|
||||
}
|
||||
|
||||
/**
|
||||
* initialize node structure
|
||||
|
|
@ -182,201 +274,95 @@ void elim_unconstrained::init_nodes() {
|
|||
m_enable_proofs = true;
|
||||
}
|
||||
|
||||
m_trail.append(terms);
|
||||
m_heap.reset();
|
||||
m_root.reset();
|
||||
m_nodes.reset();
|
||||
reset_nodes();
|
||||
|
||||
// initialize nodes for terms in the original goal
|
||||
init_terms(terms);
|
||||
|
||||
// top-level terms have reference count > 0
|
||||
for (expr* e : terms)
|
||||
inc_ref(e);
|
||||
|
||||
m_inverter.set_produce_proofs(m_enable_proofs);
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Create nodes for all terms in the goal
|
||||
*/
|
||||
void elim_unconstrained::init_terms(expr_ref_vector const& terms) {
|
||||
unsigned max_id = 0;
|
||||
for (expr* e : subterms::all(terms))
|
||||
max_id = std::max(max_id, e->get_id());
|
||||
|
||||
m_nodes.reserve(max_id + 1);
|
||||
m_heap.reserve(max_id + 1);
|
||||
m_root.reserve(max_id + 1, UINT_MAX);
|
||||
|
||||
for (expr* e : subterms_postorder::all(terms)) {
|
||||
m_root.setx(e->get_id(), e->get_id(), UINT_MAX);
|
||||
node& n = get_node(e);
|
||||
if (n.m_term)
|
||||
continue;
|
||||
n.m_orig = e;
|
||||
n.m_term = e;
|
||||
n.m_refcount = 0;
|
||||
|
||||
SASSERT(n.is_root());
|
||||
if (is_uninterp_const(e))
|
||||
m_heap.insert(root(e));
|
||||
if (is_quantifier(e)) {
|
||||
expr* body = to_quantifier(e)->get_expr();
|
||||
get_node(body).m_parents.push_back(e);
|
||||
inc_ref(body);
|
||||
}
|
||||
else if (is_app(e)) {
|
||||
for (expr* arg : *to_app(e)) {
|
||||
get_node(arg).m_parents.push_back(e);
|
||||
inc_ref(arg);
|
||||
}
|
||||
}
|
||||
m_heap.insert(e->get_id());
|
||||
}
|
||||
}
|
||||
|
||||
void elim_unconstrained::freeze_rec(expr* r) {
|
||||
expr_ref_vector children(m);
|
||||
if (is_quantifier(r))
|
||||
children.push_back(to_quantifier(r)->get_expr());
|
||||
else if (is_app(r))
|
||||
children.append(to_app(r)->get_num_args(), to_app(r)->get_args());
|
||||
else
|
||||
return;
|
||||
if (children.empty())
|
||||
return;
|
||||
for (expr* t : subterms::all(children))
|
||||
freeze(t);
|
||||
}
|
||||
// mark top level terms
|
||||
for (expr* e : terms)
|
||||
get_node(e).set_top();
|
||||
|
||||
void elim_unconstrained::freeze(expr* t) {
|
||||
if (!is_uninterp_const(t))
|
||||
return;
|
||||
if (m_nodes.size() <= t->get_id())
|
||||
return;
|
||||
if (m_nodes.size() <= root(t))
|
||||
return;
|
||||
node& n = get_node(t);
|
||||
if (!n.m_term)
|
||||
return;
|
||||
if (m_heap.contains(root(t))) {
|
||||
n.m_refcount = UINT_MAX / 2;
|
||||
m_heap.increased(root(t));
|
||||
}
|
||||
}
|
||||
|
||||
void elim_unconstrained::gc(expr* t) {
|
||||
ptr_vector<expr> todo;
|
||||
todo.push_back(t);
|
||||
while (!todo.empty()) {
|
||||
t = todo.back();
|
||||
todo.pop_back();
|
||||
m_inverter.set_produce_proofs(m_enable_proofs);
|
||||
|
||||
node& n = get_node(t);
|
||||
if (n.m_refcount == 0)
|
||||
continue;
|
||||
if (n.m_term && !is_node(n.m_term))
|
||||
continue;
|
||||
|
||||
dec_ref(t);
|
||||
if (n.m_refcount != 0)
|
||||
continue;
|
||||
if (n.m_term)
|
||||
t = n.m_term;
|
||||
if (is_app(t)) {
|
||||
for (expr* arg : *to_app(t))
|
||||
todo.push_back(arg);
|
||||
}
|
||||
else if (is_quantifier(t))
|
||||
todo.push_back(to_quantifier(t)->get_expr());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
expr_ref elim_unconstrained::reconstruct_term(node& n0) {
|
||||
expr* t = n0.m_term;
|
||||
if (!n0.m_dirty)
|
||||
return expr_ref(t, m);
|
||||
if (!is_node(t))
|
||||
return expr_ref(t, m);
|
||||
ptr_buffer<expr> todo;
|
||||
todo.push_back(t);
|
||||
expr* elim_unconstrained::reconstruct_term(node& n) {
|
||||
SASSERT(n.is_root());
|
||||
if (!n.is_dirty())
|
||||
return n.term();
|
||||
ptr_buffer<node> todo;
|
||||
todo.push_back(&n);
|
||||
expr_ref new_t(m);
|
||||
while (!todo.empty()) {
|
||||
t = todo.back();
|
||||
if (!is_node(t)) {
|
||||
UNREACHABLE();
|
||||
node* np = todo.back();
|
||||
if (!np->is_dirty()) {
|
||||
todo.pop_back();
|
||||
continue;
|
||||
}
|
||||
node& n = get_node(t);
|
||||
SASSERT(np->is_root());
|
||||
auto t = np->term();
|
||||
unsigned sz0 = todo.size();
|
||||
if (is_app(t)) {
|
||||
if (n.m_term != t) {
|
||||
n.m_dirty = false;
|
||||
todo.pop_back();
|
||||
continue;
|
||||
if (is_app(t)) {
|
||||
for (expr* arg : *to_app(t)) {
|
||||
node& r = root(arg);
|
||||
if (r.is_dirty())
|
||||
todo.push_back(&r);
|
||||
}
|
||||
for (expr* arg : *to_app(t))
|
||||
if (get_node(arg).m_dirty || !get_node(arg).m_term)
|
||||
todo.push_back(arg);
|
||||
if (todo.size() != sz0)
|
||||
continue;
|
||||
|
||||
unsigned sz = m_args.size();
|
||||
for (expr* arg : *to_app(t))
|
||||
m_args.push_back(get_node(arg).m_term);
|
||||
n.m_term = m.mk_app(to_app(t)->get_decl(), to_app(t)->get_num_args(), m_args.data() + sz);
|
||||
for (expr* arg : *to_app(t))
|
||||
m_args.push_back(root(arg).term());
|
||||
new_t = m.mk_app(to_app(t)->get_decl(), to_app(t)->get_num_args(), m_args.data() + sz);
|
||||
m_args.shrink(sz);
|
||||
}
|
||||
else if (is_quantifier(t)) {
|
||||
expr* body = to_quantifier(t)->get_expr();
|
||||
node& n2 = get_node(body);
|
||||
if (n2.m_dirty || !n2.m_term) {
|
||||
todo.push_back(body);
|
||||
node& n2 = root(body);
|
||||
if (n2.is_dirty()) {
|
||||
todo.push_back(&n2);
|
||||
continue;
|
||||
}
|
||||
n.m_term = m.update_quantifier(to_quantifier(t), n2.m_term);
|
||||
new_t = m.update_quantifier(to_quantifier(t), n2.term());
|
||||
}
|
||||
m_trail.push_back(n.m_term);
|
||||
m_root.setx(n.m_term->get_id(), n.m_term->get_id(), UINT_MAX);
|
||||
else
|
||||
new_t = t;
|
||||
node& new_n = get_node(new_t);
|
||||
set_root(*np, new_n);
|
||||
np->set_clean();
|
||||
todo.pop_back();
|
||||
n.m_dirty = false;
|
||||
}
|
||||
return expr_ref(n0.m_term, m);
|
||||
return n.root().term();
|
||||
}
|
||||
|
||||
/**
|
||||
* walk nodes starting from lowest depth and reconstruct their normalized forms.
|
||||
*/
|
||||
void elim_unconstrained::reconstruct_terms() {
|
||||
expr_ref_vector terms(m);
|
||||
for (unsigned i : indices())
|
||||
terms.push_back(m_fmls[i].fml());
|
||||
ptr_vector<node> nodes;
|
||||
for (node* n : m_nodes)
|
||||
if (n && n->is_root())
|
||||
nodes.push_back(n);
|
||||
|
||||
for (expr* e : subterms_postorder::all(terms)) {
|
||||
node& n = get_node(e);
|
||||
expr* t = n.m_term;
|
||||
if (t != n.m_orig)
|
||||
continue;
|
||||
if (is_app(t)) {
|
||||
bool change = false;
|
||||
m_args.reset();
|
||||
for (expr* arg : *to_app(t)) {
|
||||
node& n2 = get_node(arg);
|
||||
m_args.push_back(n2.m_term);
|
||||
change |= n2.m_term != n2.m_orig;
|
||||
}
|
||||
if (change) {
|
||||
n.m_term = m.mk_app(to_app(t)->get_decl(), m_args);
|
||||
m_trail.push_back(n.m_term);
|
||||
}
|
||||
}
|
||||
else if (is_quantifier(t)) {
|
||||
node& n2 = get_node(to_quantifier(t)->get_expr());
|
||||
if (n2.m_term != n2.m_orig) {
|
||||
n.m_term = m.update_quantifier(to_quantifier(t), n2.m_term);
|
||||
m_trail.push_back(n.m_term);
|
||||
}
|
||||
}
|
||||
}
|
||||
std::stable_sort(nodes.begin(), nodes.end(), [&](node* a, node* b) { return get_depth(a->term()) < get_depth(b->term()); });
|
||||
|
||||
for (node* n : nodes)
|
||||
reconstruct_term(*n);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -384,12 +370,11 @@ void elim_unconstrained::assert_normalized(vector<dependent_expr>& old_fmls) {
|
|||
|
||||
for (unsigned i : indices()) {
|
||||
auto [f, p, d] = m_fmls[i]();
|
||||
node& n = get_node(f);
|
||||
expr* g = n.m_term;
|
||||
node& n = root(f);
|
||||
expr* g = n.term();
|
||||
if (f == g)
|
||||
continue;
|
||||
old_fmls.push_back(m_fmls[i]);
|
||||
IF_VERBOSE(11, verbose_stream() << mk_bounded_pp(f, m, 3) << " -> " << mk_bounded_pp(g, m, 3) << "\n");
|
||||
TRACE("elim_unconstrained", tout << mk_bounded_pp(f, m) << " -> " << mk_bounded_pp(g, m) << "\n");
|
||||
m_fmls.update(i, dependent_expr(m, g, nullptr, d));
|
||||
}
|
||||
|
|
@ -441,6 +426,6 @@ void elim_unconstrained::reduce() {
|
|||
vector<dependent_expr> old_fmls;
|
||||
assert_normalized(old_fmls);
|
||||
update_model_trail(*mc, old_fmls);
|
||||
mc->reset();
|
||||
mc->reset();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue