mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2026-02-20 07:24:40 +00:00
Code Activity

adding proof hint output

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2025-10-18 19:26:19 +02:00
parent eb10ab1633
commit 6485808b49
6 changed files with 191 additions and 137 deletions
Download patch file Download diff file Expand all files Collapse all files

237
src/ast/rewriter/finite_set_axioms.cpp
View file

@ -24,6 +24,11 @@ Revision History:
#include "ast/array_decl_plugin.h"
#include "ast/rewriter/finite_set_axioms.h"
std::ostream& operator<<(std::ostream& out, theory_axiom const& ax) {
return out << "axiom";
}
// a ~ set.empty => not (x in a)
// x is an element, generate axiom that x is not in any empty set of x's type
void finite_set_axioms::in_empty_axiom(expr *x) {
@ -33,9 +38,9 @@ void finite_set_axioms::in_empty_axiom(expr *x) {
expr_ref empty_set(u.mk_empty(elem_sort), m);
expr_ref x_in_empty(u.mk_in(x, empty_set), m);
expr_ref_vector clause(m);
clause.push_back(m.mk_not(x_in_empty));
m_add_clause(clause);
theory_axiom ax(m, "finite-set", "in-empty");
ax.clause.push_back(m.mk_not(x_in_empty));
m_add_clause(ax);
}
// a := set.union(b, c)
@ -44,30 +49,29 @@ void finite_set_axioms::in_union_axiom(expr *x, expr *a) {
expr* b = nullptr, *c = nullptr;
if (!u.is_union(a, b, c))
return;
expr_ref_vector clause(m);
theory_axiom ax(m, "finite-set", "in-union");
expr_ref x_in_a(u.mk_in(x, a), m);
expr_ref x_in_b(u.mk_in(x, b), m);
expr_ref x_in_c(u.mk_in(x, c), m);
// (x in a) => (x in b) or (x in c)
expr_ref_vector clause1(m);
clause1.push_back(m.mk_not(x_in_a));
clause1.push_back(x_in_b);
clause1.push_back(x_in_c);
m_add_clause(clause1);
ax.clause.push_back(m.mk_not(x_in_a));
ax.clause.push_back(x_in_b);
ax.clause.push_back(x_in_c);
m_add_clause(ax);
// (x in b) => (x in a)
expr_ref_vector clause2(m);
clause2.push_back(m.mk_not(x_in_b));
clause2.push_back(x_in_a);
m_add_clause(clause2);
theory_axiom ax2(m, "finite-set", "in-union");
ax2.clause.push_back(m.mk_not(x_in_b));
ax2.clause.push_back(x_in_a);
m_add_clause(ax2);
// (x in c) => (x in a)
expr_ref_vector clause3(m);
clause3.push_back(m.mk_not(x_in_c));
clause3.push_back(x_in_a);
m_add_clause(clause3);
theory_axiom ax3(m, "finite-set", "in-union");
ax3.clause.push_back(m.mk_not(x_in_c));
ax3.clause.push_back(x_in_a);
m_add_clause(ax3);
}
// a := set.intersect(b, c)
@ -82,23 +86,23 @@ void finite_set_axioms::in_intersect_axiom(expr *x, expr *a) {
expr_ref x_in_c(u.mk_in(x, c), m);
// (x in a) => (x in b)
expr_ref_vector clause1(m);
clause1.push_back(m.mk_not(x_in_a));
clause1.push_back(x_in_b);
m_add_clause(clause1);
theory_axiom ax1(m, "finite-set", "in-intersect");
ax1.clause.push_back(m.mk_not(x_in_a));
ax1.clause.push_back(x_in_b);
m_add_clause(ax1);
// (x in a) => (x in c)
expr_ref_vector clause2(m);
clause2.push_back(m.mk_not(x_in_a));
clause2.push_back(x_in_c);
m_add_clause(clause2);
theory_axiom ax2(m, "finite-set", "in-intersect");
ax2.clause.push_back(m.mk_not(x_in_a));
ax2.clause.push_back(x_in_c);
m_add_clause(ax2);
// (x in b) and (x in c) => (x in a)
expr_ref_vector clause3(m);
clause3.push_back(m.mk_not(x_in_b));
clause3.push_back(m.mk_not(x_in_c));
clause3.push_back(x_in_a);
m_add_clause(clause3);
theory_axiom ax3(m, "finite-set", "in-intersect");
ax3.clause.push_back(m.mk_not(x_in_b));
ax3.clause.push_back(m.mk_not(x_in_c));
ax3.clause.push_back(x_in_a);
m_add_clause(ax3);
}
// a := set.difference(b, c)
@ -113,23 +117,23 @@ void finite_set_axioms::in_difference_axiom(expr *x, expr *a) {
expr_ref x_in_c(u.mk_in(x, c), m);
// (x in a) => (x in b)
expr_ref_vector clause1(m);
clause1.push_back(m.mk_not(x_in_a));
clause1.push_back(x_in_b);
m_add_clause(clause1);
theory_axiom ax1(m, "finite-set", "in-difference");
ax1.clause.push_back(m.mk_not(x_in_a));
ax1.clause.push_back(x_in_b);
m_add_clause(ax1);
// (x in a) => not (x in c)
expr_ref_vector clause2(m);
clause2.push_back(m.mk_not(x_in_a));
clause2.push_back(m.mk_not(x_in_c));
m_add_clause(clause2);
theory_axiom ax2(m, "finite-set", "in-difference");
ax2.clause.push_back(m.mk_not(x_in_a));
ax2.clause.push_back(m.mk_not(x_in_c));
m_add_clause(ax2);
// (x in b) and not (x in c) => (x in a)
expr_ref_vector clause3(m);
clause3.push_back(m.mk_not(x_in_b));
clause3.push_back(x_in_c);
clause3.push_back(x_in_a);
m_add_clause(clause3);
theory_axiom ax3(m, "finite-set", "in-difference");
ax3.clause.push_back(m.mk_not(x_in_b));
ax3.clause.push_back(x_in_c);
ax3.clause.push_back(x_in_a);
m_add_clause(ax3);
}
// a := set.singleton(b)
@ -141,27 +145,27 @@ void finite_set_axioms::in_singleton_axiom(expr *x, expr *a) {
expr_ref x_in_a(u.mk_in(x, a), m);
theory_axiom ax(m, "finite-set", "in-singleton");
if (x == b) {
// If x and b are syntactically identical, then (x in a) is always true
expr_ref_vector clause(m);
clause.push_back(x_in_a);
m_add_clause(clause);
ax.clause.push_back(x_in_a);
m_add_clause(ax);
return;
}
expr_ref x_eq_b(m.mk_eq(x, b), m);
// (x in a) => (x == b)
expr_ref_vector clause1(m);
clause1.push_back(m.mk_not(x_in_a));
clause1.push_back(x_eq_b);
m_add_clause(clause1);
ax.clause.push_back(m.mk_not(x_in_a));
ax.clause.push_back(x_eq_b);
m_add_clause(ax);
ax.clause.reset();
// (x == b) => (x in a)
expr_ref_vector clause2(m);
clause2.push_back(m.mk_not(x_eq_b));
clause2.push_back(x_in_a);
m_add_clause(clause2);
ax.clause.push_back(m.mk_not(x_eq_b));
ax.clause.push_back(x_in_a);
m_add_clause(ax);
}
// a := set.range(lo, hi)
@ -177,23 +181,23 @@ void finite_set_axioms::in_range_axiom(expr *x, expr *a) {
expr_ref x_le_hi(arith.mk_le(x, hi), m);
// (x in a) => (lo <= x)
expr_ref_vector clause1(m);
clause1.push_back(m.mk_not(x_in_a));
clause1.push_back(lo_le_x);
m_add_clause(clause1);
theory_axiom ax1(m, "finite-set", "in-range");
ax1.clause.push_back(m.mk_not(x_in_a));
ax1.clause.push_back(lo_le_x);
m_add_clause(ax1);
// (x in a) => (x <= hi)
expr_ref_vector clause2(m);
clause2.push_back(m.mk_not(x_in_a));
clause2.push_back(x_le_hi);
m_add_clause(clause2);
theory_axiom ax2(m, "finite-set", "in-range");
ax2.clause.push_back(m.mk_not(x_in_a));
ax2.clause.push_back(x_le_hi);
m_add_clause(ax2);
// (lo <= x) and (x <= hi) => (x in a)
expr_ref_vector clause3(m);
clause3.push_back(m.mk_not(lo_le_x));
clause3.push_back(m.mk_not(x_le_hi));
clause3.push_back(x_in_a);
m_add_clause(clause3);
theory_axiom ax3(m, "finite-set", "in-range");
ax3.clause.push_back(m.mk_not(lo_le_x));
ax3.clause.push_back(m.mk_not(x_le_hi));
ax3.clause.push_back(x_in_a);
m_add_clause(ax3);
}
// a := set.map(f, b)
@ -224,10 +228,10 @@ void finite_set_axioms::in_map_image_axiom(expr *x, expr *a) {
expr_ref fx_in_a(u.mk_in(fx, a), m);
// (x in b) => f(x) in a
expr_ref_vector clause(m);
clause.push_back(m.mk_not(x_in_b));
clause.push_back(fx_in_a);
m_add_clause(clause);
theory_axiom ax(m, "finite-set", "in-map-image");
ax.clause.push_back(m.mk_not(x_in_b));
ax.clause.push_back(fx_in_a);
m_add_clause(ax);
}
// a := set.filter(p, b)
@ -245,23 +249,23 @@ void finite_set_axioms::in_filter_axiom(expr *x, expr *a) {
expr_ref px(autil.mk_select(p, x), m);
// (x in a) => (x in b)
expr_ref_vector clause1(m);
clause1.push_back(m.mk_not(x_in_a));
clause1.push_back(x_in_b);
m_add_clause(clause1);
theory_axiom ax1(m, "finite-set", "in-filter");
ax1.clause.push_back(m.mk_not(x_in_a));
ax1.clause.push_back(x_in_b);
m_add_clause(ax1);
// (x in a) => p(x)
expr_ref_vector clause2(m);
clause2.push_back(m.mk_not(x_in_a));
clause2.push_back(px);
m_add_clause(clause2);
theory_axiom ax2(m, "finite-set", "in-filter");
ax2.clause.push_back(m.mk_not(x_in_a));
ax2.clause.push_back(px);
m_add_clause(ax2);
// (x in b) and p(x) => (x in a)
expr_ref_vector clause3(m);
clause3.push_back(m.mk_not(x_in_b));
clause3.push_back(m.mk_not(px));
clause3.push_back(x_in_a);
m_add_clause(clause3);
theory_axiom ax3(m, "finite-set", "in-filter");
ax3.clause.push_back(m.mk_not(x_in_b));
ax3.clause.push_back(m.mk_not(px));
ax3.clause.push_back(x_in_a);
m_add_clause(ax3);
}
// a := set.singleton(b)
@ -275,10 +279,10 @@ void finite_set_axioms::size_singleton_axiom(expr *a) {
expr_ref size_a(u.mk_size(a), m);
expr_ref one(arith.mk_int(1), m);
expr_ref eq(m.mk_eq(size_a, one), m);
expr_ref_vector clause(m);
clause.push_back(eq);
m_add_clause(clause);
theory_axiom ax(m, "finite-set", "size-singleton");
ax.clause.push_back(eq);
m_add_clause(ax);
}
void finite_set_axioms::subset_axiom(expr* a) {
@ -288,16 +292,16 @@ void finite_set_axioms::subset_axiom(expr* a) {
expr_ref intersect_bc(u.mk_intersect(b, c), m);
expr_ref eq(m.mk_eq(intersect_bc, b), m);
expr_ref_vector clause1(m);
clause1.push_back(m.mk_not(a));
clause1.push_back(eq);
m_add_clause(clause1);
expr_ref_vector clause2(m);
clause2.push_back(a);
clause2.push_back(m.mk_not(eq));
m_add_clause(clause2);
theory_axiom ax1(m, "finite-set", "subset");
ax1.clause.push_back(m.mk_not(a));
ax1.clause.push_back(eq);
m_add_clause(ax1);
theory_axiom ax2(m, "finite-set", "subset");
ax2.clause.push_back(a);
ax2.clause.push_back(m.mk_not(eq));
m_add_clause(ax2);
}
void finite_set_axioms::extensionality_axiom(expr *a, expr* b) {
@ -309,8 +313,15 @@ void finite_set_axioms::extensionality_axiom(expr *a, expr* b) {
expr_ref diff_in_b(u.mk_in(diff_ab, b), m);
// (a != b) => (x in diff_ab != x in diff_ba)
expr_ref_vector clause(m);
clause.push_back(a_eq_b);
clause.push_back(m.mk_not(m.mk_iff(diff_in_a, diff_in_b)));
m_add_clause(clause);
theory_axiom ax(m, "finite-set", "extensionality");
ax.clause.push_back(a_eq_b);
ax.clause.push_back(m.mk_not(diff_in_a));
ax.clause.push_back(m.mk_not(diff_in_b));
m_add_clause(ax);
theory_axiom ax2(m, "finite-set", "extensionality");
ax2.clause.push_back(m.mk_not(a_eq_b));
ax2.clause.push_back(diff_in_a);
ax2.clause.push_back(diff_in_b);
m_add_clause(ax2);
}

26
src/ast/rewriter/finite_set_axioms.h
View file

@ -12,17 +12,39 @@ Abstract:
--*/
struct theory_axiom {
expr_ref_vector clause;
vector<parameter> params;
unsigned weight = 0; // can be used to prioritize instantiation of axioms
theory_axiom(ast_manager& m, symbol const& th): clause(m) {
params.push_back(parameter(th));
}
theory_axiom(ast_manager &m, symbol const &th, symbol const& rule) : clause(m) {
params.push_back(parameter(th));
params.push_back(parameter(rule));
}
theory_axiom(ast_manager &m, char const *th, char const *rule) : clause(m) {
params.push_back(parameter(symbol(th)));
params.push_back(parameter(symbol(rule)));
}
theory_axiom(ast_manager &m) : clause(m) {
}
};
std::ostream &operator<<(std::ostream &out, theory_axiom const &ax);
class finite_set_axioms {
ast_manager& m;
finite_set_util u;
std::function<void(expr_ref_vector const &)> m_add_clause;
std::function<void(theory_axiom const &)> m_add_clause;
public:
finite_set_axioms(ast_manager &m) : m(m), u(m) {}
void set_add_clause(std::function<void(expr_ref_vector const &)> &ac) {
void set_add_clause(std::function<void(theory_axiom const &)> &ac) {
m_add_clause = ac;
}