mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-06 17:44:08 +00:00
Code Activity

cave in to supporting proofs (partially) in simplifiers, updated doc

Browse source
This commit is contained in:
Nikolaj Bjorner 2022-12-06 17:02:04 -08:00
parent aaabbfb594
commit 80033e8744
36 changed files with 157 additions and 108 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
doc/mk_tactic_doc.py
View file

@ -21,16 +21,14 @@ is_tac_name = re.compile("## Tactic (.*)")
def extract_params(ous, tac):
z3_exe = BUILD_DIR + "/z3"
out = subprocess.Popen([z3_exe, f"-tactics:{tac}"], stdout=subprocess.PIPE).communicate()[0]
out = subprocess.Popen([z3_exe, f"-tacticsmd:{tac}"], stdout=subprocess.PIPE).communicate()[0]
if not out:
return
out = out.decode(sys.stdout.encoding)
ous.write("#### Parameters\n")
ous.write("```\n")
ous.write("### Parameters\n\n")
for line in out:
ous.write(line.replace("\r",""))
ous.write("\n")
ous.write("```\n")
def generate_tactic_doc(ous, f, ins):
tac_name = None

4
src/ast/simplifiers/bit2int.h
View file

@ -35,8 +35,10 @@ public:
for (unsigned idx : indices()) {
auto const& d = m_fmls[idx];
m_rewriter(d.fml(), r, pr);
m_fmls.update(idx, dependent_expr(m, r, d.dep()));
m_fmls.update(idx, dependent_expr(m, r, mp(d.pr(), pr), d.dep()));
}
}
bool supports_proofs() const override { return true; }
};

4
src/ast/simplifiers/bit_blaster.cpp
View file

@ -38,13 +38,13 @@ void bit_blaster::reduce() {
proof_ref new_pr(m);
bool change = false;
for (unsigned idx : indices()) {
auto [curr, d] = m_fmls[idx]();
auto [curr, p, d] = m_fmls[idx]();
m_rewriter(curr, new_curr, new_pr);
if (curr != new_curr) {
m_num_steps += m_rewriter.get_num_steps();
change = true;
TRACE("bit_blaster", tout << mk_pp(curr, m) << " -> " << new_curr << "\n";);
m_fmls.update(idx, dependent_expr(m, new_curr, d));
m_fmls.update(idx, dependent_expr(m, new_curr, mp(p, new_pr), d));
}
}

2
src/ast/simplifiers/bv_elim.h
View file

@ -36,7 +36,7 @@ public:
if (!has_quantifiers(d.fml()))
continue;
m_rewriter(d.fml(), r);
m_fmls.update(idx, dependent_expr(m, r, d.dep()));
m_fmls.update(idx, dependent_expr(m, r, nullptr, d.dep()));
}
}
};

6
src/ast/simplifiers/bv_slice.cpp
View file

@ -28,7 +28,7 @@ namespace bv {
void slice::process_eqs() {
for (unsigned i : indices()) {
auto const [f, d] = m_fmls[i]();
auto const [f, p, d] = m_fmls[i]();
process_eq(f);
}
}
@ -137,7 +137,7 @@ namespace bv {
ptr_vector<expr> todo, args;
expr* c;
for (unsigned i : indices()) {
auto const [f, d] = m_fmls[i]();
auto const [f, p, d] = m_fmls[i]();
todo.push_back(f);
pin.push_back(f);
while (!todo.empty()) {
@ -191,7 +191,7 @@ namespace bv {
}
c = cache.get(f->get_id());
if (c != f)
m_fmls.update(i, dependent_expr(m, c, d));
m_fmls.update(i, dependent_expr(m, c, nullptr, d));
}
}

6
src/ast/simplifiers/card2bv.cpp
View file

@ -30,12 +30,12 @@ void card2bv::reduce() {
expr_ref new_f1(m), new_f2(m);
proof_ref new_pr(m);
for (unsigned idx : indices()) {
auto [f, d] = m_fmls[idx]();
auto [f, p, d] = m_fmls[idx]();
rw1(f, new_f1);
rw2(false, new_f1, new_f2, new_pr);
if (new_f2 != f) {
TRACE("card2bv", tout << "Rewriting " << new_f1 << "\n" << new_f2 << "\n");
m_fmls.update(idx, dependent_expr(m, new_f2, d));
m_fmls.update(idx, dependent_expr(m, new_f2, mp(p, new_pr), d));
++m_stats.m_num_rewrites;
}
}
@ -43,7 +43,7 @@ void card2bv::reduce() {
expr_ref_vector fmls(m);
rw2.flush_side_constraints(fmls);
for (expr* e : fmls)
m_fmls.add(dependent_expr(m, e, nullptr));
m_fmls.add(dependent_expr(m, e, nullptr, nullptr));
func_decl_ref_vector const& fns = rw2.fresh_constants();
for (func_decl* f : fns)

5
src/ast/simplifiers/cnf_nnf.h
View file

@ -48,12 +48,13 @@ public:
push_todo.reset();
push_todo_prs.reset();
apply_nnf(d.fml(), push_todo, push_todo_prs, r, pr);
m_fmls.update(i, dependent_expr(m, r, d.dep()));
m_fmls.update(i, dependent_expr(m, r, mp(d.pr(), pr), d.dep()));
for (expr* f : push_todo) {
if (!m.inc())
break;
m_rewriter(f, r, pr);
m_fmls.add(dependent_expr(m, r, d.dep()));
if (f != r)
m_fmls.add(dependent_expr(m, r, pr, d.dep()));
}
}
}

2
src/ast/simplifiers/demodulator_simplifier.cpp
View file

@ -108,7 +108,7 @@ void demodulator_simplifier::rewrite(unsigned i) {
expr_dependency_ref d(dep(i), m);
for (unsigned j : m_dependencies)
d = m.mk_join(d, dep(j));
m_fmls.update(i, dependent_expr(m, r, d));
m_fmls.update(i, dependent_expr(m, r, nullptr, d));
}
bool demodulator_simplifier::rewrite1(func_decl* f, expr_ref_vector const& args, expr_ref& np) {

24
src/ast/simplifiers/dependent_expr.h
View file

@ -24,21 +24,26 @@ Author:
class dependent_expr {
ast_manager& m;
expr* m_fml;
proof* m_proof;
expr_dependency* m_dep;
public:
dependent_expr(ast_manager& m, expr* fml, expr_dependency* d):
dependent_expr(ast_manager& m, expr* fml, proof* p, expr_dependency* d):
m(m),
m_fml(fml),
m_proof(p),
m_dep(d) {
SASSERT(fml);
m.inc_ref(fml);
m.inc_ref(d);
m.inc_ref(p);
}
dependent_expr(ast_translation& tr, dependent_expr const& src) :
m(tr.to()) {
m_fml = tr(src.fml());
m.inc_ref(m_fml);
m_proof = tr(src.pr());
m.inc_ref(m_proof);
expr_dependency_translation dtr(tr);
m_dep = dtr(src.dep());
m.inc_ref(m_dep);
@ -49,10 +54,13 @@ public:
if (this != &other) {
m.inc_ref(other.m_fml);
m.inc_ref(other.m_dep);
m.inc_ref(other.m_proof);
m.dec_ref(m_fml);
m.dec_ref(m_dep);
m.dec_ref(m_proof);
m_fml = other.m_fml;
m_dep = other.m_dep;
m_proof = other.m_proof;
}
return *this;
}
@ -60,24 +68,30 @@ public:
dependent_expr(dependent_expr const& other):
m(other.m),
m_fml(other.m_fml),
m_proof(other.m_proof),
m_dep(other.m_dep) {
m.inc_ref(m_fml);
m.inc_ref(m_proof);
m.inc_ref(m_dep);
}
dependent_expr(dependent_expr && other) noexcept :
m(other.m),
m_fml(nullptr),
m_proof(nullptr),
m_dep(nullptr) {
std::swap(m_fml, other.m_fml);
std::swap(m_proof, other.m_proof);
std::swap(m_dep, other.m_dep);
}
~dependent_expr() {
m.dec_ref(m_fml);
m.dec_ref(m_dep);
m.dec_ref(m_proof);
m_fml = nullptr;
m_dep = nullptr;
m_proof = nullptr;
}
ast_manager& get_manager() const { return m; }
@ -86,8 +100,10 @@ public:
expr_dependency* dep() const { return m_dep; }
std::tuple<expr*, expr_dependency*> operator()() const {
return { m_fml, m_dep };
proof* pr() const { return m_proof; }
std::tuple<expr*, proof*, expr_dependency*> operator()() const {
return { m_fml, m_proof, m_dep };
}
std::ostream& display(std::ostream& out) const {
@ -99,6 +115,8 @@ public:
for (expr* arg : deps)
out << mk_pp(arg, m) << " ";
}
if (m_proof)
out << "\n:- " << mk_pp(m_proof, m);
return out;
}
};

3
src/ast/simplifiers/dependent_expr_state.h
View file

@ -135,6 +135,8 @@ protected:
index_set indices() { return index_set(*this); }
proof* mp(proof* a, proof* b) { return (a && b) ? m.mk_modus_ponens(a, b) : nullptr; }
public:
dependent_expr_simplifier(ast_manager& m, dependent_expr_state& s) : m(m), m_fmls(s), m_trail(s.m_trail) {}
virtual ~dependent_expr_simplifier() {}
@ -146,6 +148,7 @@ public:
virtual void reset_statistics() {}
virtual void updt_params(params_ref const& p) {}
virtual void collect_param_descrs(param_descrs& r) {}
virtual bool supports_proofs() const { return false; }
ast_manager& get_manager() { return m; }
dependent_expr_state& get_fmls() { return m_fmls; }
};

2
src/ast/simplifiers/distribute_forall.h
View file

@ -38,7 +38,7 @@ public:
if (!has_quantifiers(d.fml()))
continue;
m_dist(d.fml(), r);
m_fmls.update(idx, dependent_expr(m, r, d.dep()));
m_fmls.update(idx, dependent_expr(m, r, nullptr, d.dep()));
}
}
};

2
src/ast/simplifiers/elim_bounds.h
View file

@ -38,7 +38,7 @@ public:
if (!has_quantifiers(d.fml()))
continue;
m_rewriter(d.fml(), r);
m_fmls.update(idx, dependent_expr(m, r, d.dep()));
m_fmls.update(idx, dependent_expr(m, r, nullptr, d.dep()));
}
}
};

8
src/ast/simplifiers/elim_term_ite.h
View file

@ -33,13 +33,17 @@ public:
void reduce() override {
expr_ref r(m);
proof_ref pr(m);
for (unsigned idx : indices()) {
auto const& d = m_fmls[idx];
m_rewriter(d.fml(), r);
m_fmls.update(idx, dependent_expr(m, r, d.dep()));
m_rewriter(d.fml(), r, pr);
if (d.fml() != r)
m_fmls.update(idx, dependent_expr(m, r, mp(d.pr(), pr), d.dep()));
}
}
bool supports_proofs() const override { return true; }
void push() override { dependent_expr_simplifier::push(); m_df.push(); m_rewriter.push(); }
void pop(unsigned n) override { m_rewriter.pop(n); m_df.pop(n); dependent_expr_simplifier::pop(n); }

4
src/ast/simplifiers/elim_unconstrained.cpp
View file

@ -258,13 +258,13 @@ void elim_unconstrained::reconstruct_terms() {
void elim_unconstrained::assert_normalized(vector<dependent_expr>& old_fmls) {
for (unsigned i : indices()) {
auto [f, d] = m_fmls[i]();
auto [f, p, d] = m_fmls[i]();
node& n = get_node(f);
expr* g = n.m_term;
if (f == g)
continue;
old_fmls.push_back(m_fmls[i]);
m_fmls.update(i, dependent_expr(m, g, d));
m_fmls.update(i, dependent_expr(m, g, nullptr, d));
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");
}

10
src/ast/simplifiers/eliminate_predicates.cpp
View file

@ -536,7 +536,7 @@ void eliminate_predicates::reduce_definitions() {
macro_expander.insert(v->m_head, v->m_def, v->m_dep);
for (unsigned i : indices()) {
auto [f, d] = m_fmls[i]();
auto [f, p, d] = m_fmls[i]();
expr_ref fml(f, m), new_fml(m);
expr_dependency_ref dep(d, m);
while (true) {
@ -546,7 +546,7 @@ void eliminate_predicates::reduce_definitions() {
rewrite(new_fml);
fml = new_fml;
}
m_fmls.update(i, dependent_expr(m, fml, dep));
m_fmls.update(i, dependent_expr(m, fml, nullptr, dep));
}
reset();
init_clauses();
@ -770,7 +770,7 @@ void eliminate_predicates::process_to_exclude(ast_mark& exclude_set) {
eliminate_predicates::clause* eliminate_predicates::init_clause(unsigned i) {
auto [f, d] = m_fmls[i]();
auto [f, p, d] = m_fmls[i]();
return init_clause(f, d, i);
}
@ -821,12 +821,12 @@ void eliminate_predicates::decompile() {
if (cl->m_fml_index != UINT_MAX) {
if (cl->m_alive)
continue;
dependent_expr de(m, m.mk_true(), nullptr);
dependent_expr de(m, m.mk_true(), nullptr, nullptr);
m_fmls.update(cl->m_fml_index, de);
}
else if (cl->m_alive) {
expr_ref new_cl = cl->m_fml;
dependent_expr de(m, new_cl, cl->m_dep);
dependent_expr de(m, new_cl, nullptr, cl->m_dep);
m_fmls.add(de);
}
}

8
src/ast/simplifiers/euf_completion.cpp
View file

@ -82,7 +82,7 @@ namespace euf {
for (unsigned i = qhead(); i < sz; ++i) {
expr* x, * y;
auto [f, d] = m_fmls[i]();
auto [f, p, d] = m_fmls[i]();
if (m.is_eq(f, x, y)) {
enode* a = mk_enode(x);
enode* b = mk_enode(y);
@ -108,19 +108,19 @@ namespace euf {
if (m_egraph.inconsistent()) {
auto* d = explain_conflict();
dependent_expr de(m, m.mk_false(), d);
dependent_expr de(m, m.mk_false(), nullptr, d);
m_fmls.update(0, de);
return;
}
unsigned sz = qtail();
for (unsigned i = qhead(); i < sz; ++i) {
auto [f, d] = m_fmls[i]();
auto [f, p, d] = m_fmls[i]();
expr_dependency_ref dep(d, m);
expr_ref g = canonize_fml(f, dep);
if (g != f) {
m_fmls.update(i, dependent_expr(m, g, dep));
m_fmls.update(i, dependent_expr(m, g, nullptr, dep));
m_stats.m_num_rewrites++;
IF_VERBOSE(11, verbose_stream() << mk_bounded_pp(f, m, 3) << " -> " << mk_bounded_pp(g, m, 3) << "\n");
update_has_new_eq(g);

4
src/ast/simplifiers/extract_eqs.cpp
View file

@ -39,7 +39,7 @@ namespace euf {
}
void get_eqs(dependent_expr const& e, dep_eq_vector& eqs) override {
auto [f, d] = e();
auto [f, p, d] = e();
expr* x, * y;
if (m.is_eq(f, x, y)) {
if (x == y)
@ -246,7 +246,7 @@ namespace euf {
void get_eqs(dependent_expr const& e, dep_eq_vector& eqs) override {
if (!m_enabled)
return;
auto [f, d] = e();
auto [f, p, d] = e();
expr* x, * y;
if (m.is_eq(f, x, y) && a.is_int_real(x)) {
solve_eq(f, x, y, d, eqs);

20
src/ast/simplifiers/flatten_clauses.h
View file

@ -67,8 +67,8 @@ public:
decomposed = true;
if (decomposed) {
for (expr* arg : *to_app(b))
m_fmls.add(dependent_expr(m, m.mk_or(a, mk_not(m, arg)), de.dep()));
m_fmls.update(idx, dependent_expr(m, m.mk_true(), nullptr));
m_fmls.add(dependent_expr(m, nullptr, m.mk_or(a, mk_not(m, arg)), de.dep()));
m_fmls.update(idx, dependent_expr(m, nullptr, m.mk_true(), nullptr));
++m_num_flat;
continue;
}
@ -79,8 +79,8 @@ public:
decomposed = true;
if (decomposed) {
for (expr * arg : *to_app(b))
m_fmls.add(dependent_expr(m, m.mk_or(a, arg), de.dep()));
m_fmls.update(idx, dependent_expr(m, m.mk_true(), nullptr));
m_fmls.add(dependent_expr(m, nullptr, m.mk_or(a, arg), de.dep()));
m_fmls.update(idx, dependent_expr(m, nullptr, m.mk_true(), nullptr));
++m_num_flat;
continue;
}
@ -92,20 +92,20 @@ public:
if (decomposed) {
expr* na = mk_not(m, a);
for (expr* arg : *to_app(b))
m_fmls.add(dependent_expr(m, m.mk_or(na, arg), de.dep()));
m_fmls.update(idx, dependent_expr(m, m.mk_true(), nullptr));
m_fmls.add(dependent_expr(m, m.mk_or(na, arg), nullptr, de.dep()));
m_fmls.update(idx, dependent_expr(m, m.mk_true(), nullptr, nullptr));
++m_num_flat;
continue;
}
if (m.is_implies(f, a, b)) {
m_fmls.update(idx, dependent_expr(m, m.mk_or(mk_not(m, a), b), de.dep()));
m_fmls.update(idx, dependent_expr(m, m.mk_or(mk_not(m, a), b), nullptr, de.dep()));
++m_num_flat;
continue;
}
if (m.is_ite(f, a, b, c)) {
m_fmls.add(dependent_expr(m, m.mk_or(mk_not(m, a), b), de.dep()));
m_fmls.add(dependent_expr(m, m.mk_or(a, c), de.dep()));
m_fmls.update(idx, dependent_expr(m, m.mk_true(), nullptr));
m_fmls.add(dependent_expr(m, m.mk_or(mk_not(m, a), b), nullptr, de.dep()));
m_fmls.add(dependent_expr(m, m.mk_or(a, c), nullptr, de.dep()));
m_fmls.update(idx, dependent_expr(m, m.mk_true(), nullptr, nullptr));
++m_num_flat;
continue;
}

5
src/ast/simplifiers/max_bv_sharing.cpp
View file

@ -48,12 +48,11 @@ public:
expr_ref new_curr(m);
proof_ref new_pr(m);
for (unsigned idx : indices()) {
auto [curr, d] = m_fmls[idx]();
auto [curr, p, d] = m_fmls[idx]();
m_rewriter(curr, new_curr, new_pr);
// Proof reconstruction: new_pr = m.mk_modus_ponens(old_pr, new_pr);
if (new_curr != curr) {
m_num_steps += m_rewriter.get_num_steps();
m_fmls.update(idx, dependent_expr(m, new_curr, d));
m_fmls.update(idx, dependent_expr(m, new_curr, mp(p, new_pr), d));
}
}
}

11
src/ast/simplifiers/model_reconstruction_trail.cpp
View file

@ -61,16 +61,17 @@ void model_reconstruction_trail::replay(unsigned qhead, dependent_expr_state& st
args.push_back(m.mk_var(i, d->get_domain(i)));
head = m.mk_app(d, args);
mrp.insert(head, t->m_def, t->m_dep);
dependent_expr de(m, t->m_def, t->m_dep);
dependent_expr de(m, t->m_def, nullptr, t->m_dep);
add_vars(de, free_vars);
for (unsigned i = qhead; i < st.qtail(); ++i) {
auto [f, dep1] = st[i]();
auto [f, p, dep1] = st[i]();
expr_ref g(m);
expr_dependency_ref dep2(m);
mrp(f, dep1, g, dep2);
CTRACE("simplifier", f != g, tout << "updated " << mk_pp(g, m) << "\n");
st.update(i, dependent_expr(m, g, dep2));
if (f != g)
st.update(i, dependent_expr(m, g, nullptr, dep2));
}
continue;
}
@ -81,7 +82,7 @@ void model_reconstruction_trail::replay(unsigned qhead, dependent_expr_state& st
ptr_vector<expr> dep_exprs;
expr_ref_vector trail(m);
for (unsigned i = qhead; i < st.qtail(); ++i) {
auto [f, dep1] = st[i]();
auto [f, p, dep1] = st[i]();
auto [g, dep2] = rp->replace_with_dep(f);
if (dep1) {
dep_exprs.reset();
@ -98,7 +99,7 @@ void model_reconstruction_trail::replay(unsigned qhead, dependent_expr_state& st
if (!trail.empty())
dep1 = m.mk_join(dep_exprs.size(), dep_exprs.data());
}
dependent_expr d(m, g, m.mk_join(dep1, dep2));
dependent_expr d(m, g, nullptr, m.mk_join(dep1, dep2));
CTRACE("simplifier", f != g, tout << "updated " << mk_pp(g, m) << "\n");
add_vars(d, free_vars);
st.update(i, d);

6
src/ast/simplifiers/propagate_values.cpp
View file

@ -35,13 +35,13 @@ propagate_values::propagate_values(ast_manager& m, params_ref const& p, dependen
void propagate_values::process_fml(unsigned i) {
if (!m_subst.empty()) {
auto [f, dep] = m_fmls[i]();
auto [f, p, dep] = m_fmls[i]();
expr_ref fml(m);
proof_ref pr(m);
m_rewriter(f, fml, pr);
if (fml != f) {
dep = m.mk_join(dep, m_rewriter.get_used_dependencies());
m_fmls.update(i, dependent_expr(m, fml, dep));
m_fmls.update(i, dependent_expr(m, fml, mp(p, pr), dep));
++m_stats.m_num_rewrites;
}
m_rewriter.reset_used_dependencies();
@ -51,7 +51,7 @@ void propagate_values::process_fml(unsigned i) {
void propagate_values::add_sub(dependent_expr const& de) {
expr* x, * y;
auto const& [f, dep] = de();
auto const& [f, p, dep] = de();
if (m.is_not(f, x) && m_shared.is_shared(x))
m_subst.insert(x, m.mk_false(), dep);
if (m_shared.is_shared(f))

4
src/ast/simplifiers/pull_nested_quantifiers.h
View file

@ -40,7 +40,9 @@ public:
for (unsigned idx : indices()) {
auto d = m_fmls[idx];
m_pull(d.fml(), new_curr, new_pr);
m_fmls.update(idx, dependent_expr(m, new_curr, d.dep()));
m_fmls.update(idx, dependent_expr(m, new_curr, mp(d.pr(), new_pr), d.dep()));
}
}
bool supports_proofs() const override { return true; }
};

5
src/ast/simplifiers/push_ite.h
View file

@ -35,7 +35,8 @@ public:
for (unsigned idx : indices()) {
auto const& d = m_fmls[idx];
m_push(d.fml(), r);
m_fmls.update(idx, dependent_expr(m, r, d.dep()));
if (r != d.fml())
m_fmls.update(idx, dependent_expr(m, r, nullptr, d.dep()));
}
}
};
@ -58,7 +59,7 @@ public:
for (unsigned idx : indices()) {
auto const& d = m_fmls[idx];
m_push(d.fml(), r);
m_fmls.update(idx, dependent_expr(m, r, d.dep()));
m_fmls.update(idx, dependent_expr(m, r, nullptr, d.dep()));
}
}
};

2
src/ast/simplifiers/refine_inj_axiom.h
View file

@ -38,7 +38,7 @@ public:
for (unsigned idx : indices()) {
expr* f = m_fmls[idx].fml();
if (is_quantifier(f) && simplify_inj_axiom(m, to_quantifier(f), r))
m_fmls.update(idx, dependent_expr(m, r, m_fmls[idx].dep()));
m_fmls.update(idx, dependent_expr(m, r, nullptr, m_fmls[idx].dep()));
}
}
};

3
src/ast/simplifiers/rewriter_simplifier.h
View file

@ -44,9 +44,10 @@ public:
auto d = m_fmls[idx];
m_rewriter(d.fml(), new_curr, new_pr);
m_num_steps += m_rewriter.get_num_steps();
m_fmls.update(idx, dependent_expr(m, new_curr, d.dep()));
m_fmls.update(idx, dependent_expr(m, new_curr, mp(d.pr(), new_pr), d.dep()));
}
}
bool supports_proofs() const override { return true; }
void collect_statistics(statistics& st) const override { st.update("simplifier-steps", m_num_steps); }
void reset_statistics() override { m_num_steps = 0; }
void updt_params(params_ref const& p) override { m_params.append(p); m_rewriter.updt_params(m_params); }

2
src/ast/simplifiers/solve_context_eqs.cpp
View file

@ -282,7 +282,7 @@ namespace euf {
else if (!s && 1 <= depth) {
for (extract_eq* ex : m_solve_eqs.m_extract_plugins) {
ex->set_allow_booleans(false);
ex->get_eqs(dependent_expr(m, f, df.dep()), eqs);
ex->get_eqs(dependent_expr(m, f, nullptr, df.dep()), eqs);
ex->set_allow_booleans(true);
}
}

7
src/ast/simplifiers/solve_eqs.cpp
View file

@ -191,14 +191,15 @@ namespace euf {
rp->set_substitution(m_subst.get());
for (unsigned i : indices()) {
auto [f, d] = m_fmls[i]();
auto [f, p, d] = m_fmls[i]();
auto [new_f, new_dep] = rp->replace_with_dep(f);
m_rewriter(new_f);
proof_ref new_pr(m);
m_rewriter(new_f, new_f, new_pr);
if (new_f == f)
continue;
new_dep = m.mk_join(d, new_dep);
old_fmls.push_back(m_fmls[i]);
m_fmls.update(i, dependent_expr(m, new_f, new_dep));
m_fmls.update(i, dependent_expr(m, new_f, mp(p, new_pr), new_dep));
}
}

5
src/qe/lite/qe_lite.cpp
View file

@ -2431,12 +2431,13 @@ namespace {
proof_ref new_pr(m);
expr_ref new_f(m);
for (unsigned i : indices()) {
expr* f = m_fmls[i].fml();
auto [f, p, d] = m_fmls[i]();
if (!has_quantifiers(f))
continue;
new_f = f;
m_qe(new_f, new_pr);
m_fmls.update(i, dependent_expr(m, new_f, m_fmls[i].dep()));
if (f != new_f)
m_fmls.update(i, dependent_expr(m, new_f, mp(p, new_pr), d));
}
}
};

8
src/sat/sat_solver/sat_smt_solver.cpp
View file

@ -86,7 +86,7 @@ class sat_smt_solver : public solver {
if (s.m.is_and(f)) {
auto* d = s.m_fmls[i].dep();
for (expr* arg : *to_app(f))
s.m_fmls.push_back(dependent_expr(s.m, arg, d));
s.m_fmls.push_back(dependent_expr(s.m, arg, nullptr, d));
continue;
}
if (i != j)
@ -349,18 +349,18 @@ public:
return a;
expr* new_dep = m.mk_fresh_const("dep", m.mk_bool_sort());
expr* fml = m.mk_iff(new_dep, a);
m_fmls.push_back(dependent_expr(m, fml, nullptr));
m_fmls.push_back(dependent_expr(m, fml, nullptr, nullptr));
m_dep.insert(a, new_dep);
return new_dep;
}
void assert_expr_core2(expr * t, expr * a) override {
a = ensure_literal(a);
m_fmls.push_back(dependent_expr(m, t, m.mk_leaf(a)));
m_fmls.push_back(dependent_expr(m, t, nullptr, m.mk_leaf(a)));
}
void assert_expr_core(expr * t) override {
m_fmls.push_back(dependent_expr(m, t, nullptr));
m_fmls.push_back(dependent_expr(m, t, nullptr, nullptr));
}
ast_manager& get_manager() const override { return m; }

7
src/shell/main.cpp
View file

@ -293,11 +293,12 @@ static void parse_cmd_line_args(std::string& input_file, int argc, char ** argv)
if (!opt_arg)
help_tactics();
else
help_tactic(opt_arg);
help_tactic(opt_arg, false);
}
else if (strcmp(opt_name, "probes") == 0) {
else if (strcmp(opt_name, "tacticsmd") == 0 && opt_arg)
help_tactic(opt_arg, true);
else if (strcmp(opt_name, "probes") == 0)
help_probes();
}
else {
std::cerr << "Error: invalid command line option: " << arg << "\n";
std::cerr << "For usage information: z3 -h\n";

5
src/shell/smtlib_frontend.cpp
View file

@ -88,13 +88,16 @@ void help_tactics() {
std::cout << "- " << cmd->get_name() << " " << cmd->get_descr() << "\n";
}
void help_tactic(char const* name) {
void help_tactic(char const* name, bool markdown) {
cmd_context ctx;
for (auto cmd : ctx.tactics()) {
if (cmd->get_name() == name) {
tactic_ref t = cmd->mk(ctx.m());
param_descrs descrs;
t->collect_param_descrs(descrs);
if (markdown)
descrs.display_markdown(std::cout);
else
descrs.display(std::cout, 4);
}
}

2
src/shell/smtlib_frontend.h
View file

@ -22,6 +22,6 @@ unsigned read_smtlib_file(char const * benchmark_file);
unsigned read_smtlib2_commands(char const * command_file);
void help_tactics();
void help_probes();
void help_tactic(char const* name);
void help_tactic(char const* name, bool markdown);

15
src/tactic/core/injectivity_tactic.cpp
View file

@ -5,19 +5,11 @@ Module Name:
injectivity_tactic.cpp
Abstract:
Injectivity tactics
- Discover axioms of the form `forall x. (= (g (f x)) x`
Mark `f` as injective
- Rewrite (sub)terms of the form `(= (f x) (f y))` to `(= x y)` whenever `f` is injective.
Author:
Nicolas Braud-Santoni (t-nibrau) 2017-08-10
Notes:
--*/
#include <algorithm>
#include <utility>
@ -164,8 +156,6 @@ class injectivity_tactic : public tactic {
struct rewriter_eq_cfg : public default_rewriter_cfg {
ast_manager & m_manager;
InjHelper & inj_map;
// expr_ref_vector m_out;
// sort_ref_vector m_bindings;
ast_manager & m() const { return m_manager; }
@ -176,14 +166,13 @@ class injectivity_tactic : public tactic {
}
void cleanup_buffers() {
// m_out.finalize();
}
void reset() {
}
br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) {
if(num != 2)
if (num != 2)
return BR_FAILED;
if (!m().is_eq(f))
@ -230,8 +219,6 @@ class injectivity_tactic : public tactic {
finder * m_finder;
rewriter_eq * m_eq;
InjHelper * m_map;
// rewriter_inverse * m_inverse;
params_ref m_params;
ast_manager & m_manager;

28
src/tactic/core/injectivity_tactic.h
View file

@ -13,7 +13,33 @@ Author:
Nicolas Braud-Santoni (t-nibrau) 2017-08-10
Notes:
Tactic Documentation:
## Tactic injectivity
### Short Description:
- Discover axioms of the form `forall x. (= (g (f x)) x`
Mark `f` as injective
- Rewrite (sub)terms of the form `(= (f x) (f y))` to `(= x y)` whenever `f` is injective.
### Example
```z3
(declare-fun f (Int) Int)
(declare-fun g (Int) Int)
(declare-const x Int)
(declare-const y Int)
(assert (forall ((x Int)) (= (g (f x)) x)))
(assert (not (= (f x) (f (f y)))))
(apply injectivity)
```
### Notes
* does not support cores nor proofs
--*/
#pragma once

14
src/tactic/core/reduce_args_tactic.h
View file

@ -23,15 +23,15 @@ Reduce the number of arguments of function applications, when for all occurrence
### Long Description
Example, suppose we have a function `f` with `2` arguments.
There are 1000 applications of this function, but the first argument is always "a", "b" or "c".
Thus, we replace the `f(t1, t2)` with
Example, suppose we have a function $f$ with 2 arguments.
There are 1000 applications of this function, but the first argument is always $a$, $b$ or $c$.
Thus, we replace the $f(t_1, t_2)$ with
* `f_a(t2)` if `t1 = a`
* `f_b(t2)` if `t2 = b`
* `f_c(t2)` if `t2 = c`
* $f_a(t_2)$ if $t_1 = a$
* $f_b(t_2)$ if $t_2 = b$
* $f_c(t_2)$ if $t_2 = c$
Since `f_a`, `f_b`, `f_c` are new symbols, satisfiability is preserved.
Since $f_a$, $f_b$, $f_c$ are new symbols, satisfiability is preserved.
This transformation is very similar in spirit to the Ackermman's reduction.

14
src/tactic/dependent_expr_state_tactic.h
View file

@ -49,7 +49,7 @@ public:
m(m),
m_params(p),
m_factory(f),
m_dep(m, m.mk_true(), nullptr)
m_dep(m, m.mk_true(), nullptr, nullptr)
{}
/**
@ -58,22 +58,22 @@ public:
unsigned qtail() const override { return m_goal->size(); }
dependent_expr const& operator[](unsigned i) override {
m_dep = dependent_expr(m, m_goal->form(i), m_goal->dep(i));
m_dep = dependent_expr(m, m_goal->form(i), m_goal->pr(i), m_goal->dep(i));
return m_dep;
}
void update(unsigned i, dependent_expr const& j) override {
if (inconsistent())
return;
auto [f, d] = j();
m_goal->update(i, f, nullptr, d);
auto [f, p, d] = j();
m_goal->update(i, f, p, d);
}
void add(dependent_expr const& j) override {
if (inconsistent())
return;
auto [f, d] = j();
m_goal->assert_expr(f, nullptr, d);
auto [f, p, d] = j();
m_goal->assert_expr(f, p, d);
}
bool inconsistent() override {
@ -108,7 +108,7 @@ public:
tactic_report report(name(), *in);
m_goal = in.get();
try {
if (!in->proofs_enabled())
if (!in->proofs_enabled() || m_simp->supports_proofs())
m_simp->reduce();
if (m.inc())
advance_qhead();