mirror of
https://github.com/Z3Prover/z3
synced 2025-10-10 09:48:05 +00:00
150 lines
4 KiB
C++
150 lines
4 KiB
C++
/*++
|
|
Copyright (c) 2022 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
dependent_expr_state.cpp
|
|
|
|
Author:
|
|
|
|
Nikolaj Bjorner (nbjorner) 2022-11-2.
|
|
|
|
--*/
|
|
|
|
#include "ast/simplifiers/dependent_expr_state.h"
|
|
#include "ast/recfun_decl_plugin.h"
|
|
#include "ast/for_each_ast.h"
|
|
|
|
unsigned dependent_expr_state::num_exprs() {
|
|
expr_fast_mark1 visited;
|
|
unsigned r = 0;
|
|
for (unsigned i = 0; i < qtail(); i++)
|
|
r += get_num_exprs((*this)[i].fml(), visited);
|
|
return r;
|
|
}
|
|
|
|
void dependent_expr_state::freeze(func_decl* f) {
|
|
if (m_frozen.is_marked(f) || !is_uninterp(f))
|
|
return;
|
|
m_frozen_trail.push_back(f);
|
|
m_frozen.mark(f, true);
|
|
}
|
|
|
|
void dependent_expr_state::freeze(expr* term) {
|
|
if (is_app(term) && to_app(term)->get_num_args() == 0)
|
|
freeze(to_app(term)->get_decl());
|
|
else {
|
|
ast_mark visited;
|
|
freeze_terms(term, false, visited);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Freeze functions appearing as sub-expressions of 'e'.
|
|
* The only_as_array flag indicates whether to only freeze occurrences of as-array
|
|
* from elimination.
|
|
*/
|
|
void dependent_expr_state::freeze_terms(expr* e, bool only_as_array, ast_mark& visited) {
|
|
auto& m = m_frozen_trail.get_manager();
|
|
struct proc {
|
|
bool only_as_array;
|
|
array_util a;
|
|
dependent_expr_state& st;
|
|
proc(ast_manager& m, bool o, dependent_expr_state& d) :
|
|
only_as_array(o), a(m), st(d) {}
|
|
void operator()(func_decl* f) {
|
|
if (!only_as_array)
|
|
st.freeze(f);
|
|
if (a.is_as_array(f, f) && is_uninterp(f))
|
|
st.freeze(f);
|
|
}
|
|
void operator()(ast* s) {}
|
|
};
|
|
proc proc(m, only_as_array, *this);
|
|
for_each_ast(proc, visited, e);
|
|
}
|
|
|
|
/**
|
|
* Freeze all functions used in recursive definitions
|
|
*/
|
|
|
|
void dependent_expr_state::freeze_recfun() {
|
|
auto& m = m_frozen_trail.get_manager();
|
|
recfun::util rec(m);
|
|
if (!rec.has_rec_defs())
|
|
return;
|
|
unsigned sz = rec.get_rec_funs().size();
|
|
if (m_num_recfun >= sz)
|
|
return;
|
|
|
|
ast_mark visited;
|
|
for (func_decl* f : rec.get_rec_funs()) {
|
|
auto& d = rec.get_def(f);
|
|
if (!d.is_macro() && d.get_rhs())
|
|
freeze_terms(d.get_rhs(), false, visited);
|
|
}
|
|
m_trail.push(value_trail(m_num_recfun));
|
|
m_num_recfun = sz;
|
|
}
|
|
|
|
/**
|
|
* Freeze all functions used in lambda defined declarations
|
|
*/
|
|
void dependent_expr_state::freeze_lambda() {
|
|
auto& m = m_frozen_trail.get_manager();
|
|
unsigned sz = m.lambda_defs().size();
|
|
if (m_num_lambdas >= sz)
|
|
return;
|
|
|
|
ast_mark visited;
|
|
for (auto const& [f, body] : m.lambda_defs())
|
|
freeze_terms(body, false, visited);
|
|
m_trail.push(value_trail(m_num_lambdas));
|
|
m_num_lambdas = sz;
|
|
}
|
|
|
|
|
|
/**
|
|
* The current qhead is to be updated to qtail.
|
|
* Before this update, freeze all functions appearing in formulas.
|
|
*/
|
|
void dependent_expr_state::freeze_prefix() {
|
|
ast_mark visited;
|
|
for (unsigned i = qhead(); i < qtail(); ++i)
|
|
freeze_terms((*this)[i].fml(), false, visited);
|
|
}
|
|
|
|
/**
|
|
* Freeze functions in the unprocessed suffix that appear in dependencies and in as-array.
|
|
*/
|
|
void dependent_expr_state::freeze_suffix() {
|
|
if (m_suffix_frozen)
|
|
return;
|
|
m_suffix_frozen = true;
|
|
freeze_recfun();
|
|
freeze_lambda();
|
|
auto& m = m_frozen_trail.get_manager();
|
|
ast_mark visited;
|
|
ptr_vector<expr> es;
|
|
for (unsigned i = qhead(); i < qtail(); ++i) {
|
|
auto d = (*this)[i];
|
|
if (d.dep()) {
|
|
es.reset();
|
|
m.linearize(d.dep(), es);
|
|
for (expr* e : es)
|
|
freeze_terms(e, false, visited);
|
|
}
|
|
freeze_terms(d.fml(), true, visited);
|
|
}
|
|
}
|
|
|
|
bool dependent_expr_state::has_quantifiers() {
|
|
if (m_has_quantifiers != l_undef)
|
|
return m_has_quantifiers == l_true;
|
|
bool found = false;
|
|
for (unsigned i = qhead(); i < qtail(); ++i)
|
|
found |= ::has_quantifiers((*this)[i].fml());
|
|
m_has_quantifiers = found ? l_true : l_false;
|
|
return m_has_quantifiers == l_true;
|
|
}
|