mirror of
https://github.com/Z3Prover/z3
synced 2026-05-17 15:39:27 +00:00
euf_seq_plugin: fix identity elimination after merge, activate loop merging, integrate sgraph improvements (#9414)
* Initial plan * Initial plan * Fix identity elimination after merge and activate loop merging in euf_seq_plugin Agent-Logs-Url: https://github.com/Z3Prover/z3/sessions/053b94e4-645a-4cde-ae5d-cf6d61222f92 Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com> * Apply three ZIPT code review improvements to euf_seq_plugin Agent-Logs-Url: https://github.com/Z3Prover/z3/sessions/da8647c4-ddff-47ce-9364-2eee3810c38d Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com> * Address code review: improve loop-merge defensive code and test variable names Agent-Logs-Url: https://github.com/Z3Prover/z3/sessions/053b94e4-645a-4cde-ae5d-cf6d61222f92 Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com> * Refactor: extract saturating_add helper, simplify hash-check condition Agent-Logs-Url: https://github.com/Z3Prover/z3/sessions/da8647c4-ddff-47ce-9364-2eee3810c38d Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com> --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>
This commit is contained in:
Copilot
GitHub
parent
f461369ab8
commit
42582c6835
3 changed files with 134 additions and 5 deletions
|
|
@ -46,6 +46,11 @@ namespace euf {
|
|||
}
|
||||
}
|
||||
|
||||
// Saturating unsigned addition: returns UINT_MAX instead of wrapping.
|
||||
static unsigned saturating_add(unsigned a, unsigned b) {
|
||||
return (b > UINT_MAX - a) ? UINT_MAX : a + b;
|
||||
}
|
||||
|
||||
unsigned enode_concat_hash::operator()(enode* n) const {
|
||||
snode* sn = sg.find(n->get_expr());
|
||||
if (sn && sn->has_cached_hash())
|
||||
|
|
@ -64,6 +69,15 @@ namespace euf {
|
|||
if (a == b) return true;
|
||||
if (!is_any_concat(a, seq) || !is_any_concat(b, seq))
|
||||
return false;
|
||||
// fast-path: snode length check (O(1), avoids leaf allocation)
|
||||
snode* sa = sg.find(a->get_expr());
|
||||
snode* sb = sg.find(b->get_expr());
|
||||
if (sa && sb && sa->length() != sb->length())
|
||||
return false;
|
||||
// fast-path: cached associativity hash (O(1))
|
||||
bool both_have_hash = sa && sa->has_cached_hash() && sb && sb->has_cached_hash();
|
||||
if (both_have_hash && sa->assoc_hash() != sb->assoc_hash())
|
||||
return false;
|
||||
enode_vector la, lb;
|
||||
collect_enode_leaves(a, seq, la);
|
||||
collect_enode_leaves(b, seq, lb);
|
||||
|
|
@ -82,7 +96,7 @@ namespace euf {
|
|||
m_sg(sg ? *sg : *alloc(sgraph, g.get_manager(), g, false)),
|
||||
m_sg_owned(sg == nullptr),
|
||||
m_concat_hash(m_seq, m_sg),
|
||||
m_concat_eq(m_seq),
|
||||
m_concat_eq(m_seq, m_sg),
|
||||
m_concat_table(DEFAULT_HASHTABLE_INITIAL_CAPACITY, m_concat_hash, m_concat_eq) {
|
||||
}
|
||||
|
||||
|
|
@ -168,6 +182,35 @@ namespace euf {
|
|||
if (is_concat(n))
|
||||
propagate_simplify(n);
|
||||
}
|
||||
|
||||
// Re-apply identity and absorption rules over all tracked concat nodes.
|
||||
// This handles the case where the merge caused a child to become equivalent
|
||||
// to an identity (ε) or absorbing element (∅) that was not known at
|
||||
// registration time (e.g. b ~ "" discovered after concat(x, b) was registered).
|
||||
// Also re-simplifies RE concat nodes when a child's root has become full_seq,
|
||||
// to handle nullable absorption through nested concats:
|
||||
// concat(.*, concat(v, w)) = concat(.*, w) when v is nullable but w is not.
|
||||
for (enode* n : m_concats) {
|
||||
enode *na, *nb;
|
||||
if (is_str_concat(n, na, nb)) {
|
||||
if (is_str_empty(na))
|
||||
push_merge(n, nb);
|
||||
else if (is_str_empty(nb))
|
||||
push_merge(n, na);
|
||||
}
|
||||
if (is_re_concat(n, na, nb)) {
|
||||
if (is_re_epsilon(na))
|
||||
push_merge(n, nb);
|
||||
else if (is_re_epsilon(nb))
|
||||
push_merge(n, na);
|
||||
else if (is_re_empty(na))
|
||||
push_merge(n, na); // absorb: concat(∅, b) = ∅
|
||||
else if (is_re_empty(nb))
|
||||
push_merge(n, nb); // absorb: concat(a, ∅) = ∅
|
||||
else if (is_full_seq(na->get_root()) || is_full_seq(nb->get_root()))
|
||||
propagate_simplify(n);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
|
|
@ -202,6 +245,9 @@ namespace euf {
|
|||
// 2. Nullable absorption: concat(u, .*, v, w) = concat(u, .*, w)
|
||||
// when v is nullable and adjacent to full_seq (.*).
|
||||
//
|
||||
// 3. Loop merging: concat(body{lo1,hi1}, body{lo2,hi2}) = body{lo1+lo2, hi1+hi2}
|
||||
// when both children are loops over congruent bodies.
|
||||
//
|
||||
void seq_plugin::propagate_simplify(enode* n) {
|
||||
enode* a, *b;
|
||||
if (!is_concat(n, a, b))
|
||||
|
|
@ -236,6 +282,20 @@ namespace euf {
|
|||
|
||||
// concat(concat(u, v), .*) = concat(u, .*) when v nullable
|
||||
// handled by associativity + nullable absorption on sub-concats
|
||||
|
||||
// Rule 3: Loop merging
|
||||
// concat(v{l1,h1}, v{l2,h2}) = v{l1+l2,h1+h2}
|
||||
unsigned lo1, hi1, lo2, hi2;
|
||||
if (same_loop_body(a, b, lo1, hi1, lo2, hi2)) {
|
||||
ast_manager& m = g.get_manager();
|
||||
enode* body_n = a->get_arg(0);
|
||||
// saturating add: prevent silent unsigned wrap-around on large bounds
|
||||
unsigned lo_merged = saturating_add(lo1, lo2);
|
||||
unsigned hi_merged = saturating_add(hi1, hi2);
|
||||
expr_ref merged(m_seq.re.mk_loop(body_n->get_expr(), lo_merged, hi_merged), m);
|
||||
enode* merged_n = mk(merged, 1, &body_n);
|
||||
push_merge(n, merged_n);
|
||||
}
|
||||
}
|
||||
|
||||
bool seq_plugin::is_nullable(expr* e) {
|
||||
|
|
|
|||
|
|
@ -63,7 +63,8 @@ namespace euf {
|
|||
// Handles both str.++ (OP_SEQ_CONCAT) and re.++ (OP_RE_CONCAT).
|
||||
struct enode_concat_eq {
|
||||
seq_util const& seq;
|
||||
enode_concat_eq(seq_util const& s) : seq(s) {}
|
||||
sgraph& sg;
|
||||
enode_concat_eq(seq_util const& s, sgraph& sg) : seq(s), sg(sg) {}
|
||||
bool operator()(enode* a, enode* b) const;
|
||||
};
|
||||
|
||||
|
|
@ -120,11 +121,14 @@ namespace euf {
|
|||
bool is_loop(enode* n) const { return m_seq.re.is_loop(n->get_expr()); }
|
||||
|
||||
// string empty: ε for str.++
|
||||
bool is_str_empty(enode* n) const { return m_seq.str.is_empty(n->get_expr()); }
|
||||
// Follows the union-find root so that merges are correctly reflected.
|
||||
bool is_str_empty(enode* n) const { return m_seq.str.is_empty(n->get_root()->get_expr()); }
|
||||
// regex empty set: ∅ for re.++ (absorbing element)
|
||||
bool is_re_empty(enode* n) const { return m_seq.re.is_empty(n->get_expr()); }
|
||||
// Follows the union-find root so that merges are correctly reflected.
|
||||
bool is_re_empty(enode* n) const { return m_seq.re.is_empty(n->get_root()->get_expr()); }
|
||||
// regex epsilon: to_re("") for re.++ (identity element)
|
||||
bool is_re_epsilon(enode* n) const { return m_seq.re.is_epsilon(n->get_expr()); }
|
||||
// Follows the union-find root so that merges are correctly reflected.
|
||||
bool is_re_epsilon(enode* n) const { return m_seq.re.is_epsilon(n->get_root()->get_expr()); }
|
||||
|
||||
bool is_to_re(enode* n) const { return m_seq.re.is_to_re(n->get_expr()); }
|
||||
bool is_full_seq(enode* n) const { return m_seq.re.is_full_seq(n->get_expr()); }
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue