mirror of
https://github.com/Z3Prover/z3
synced 2026-03-17 18:43:45 +00:00
689 lines
24 KiB
C++
689 lines
24 KiB
C++
/*++
|
|
Copyright (c) 2026 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
nseq_zipt.cpp
|
|
|
|
Abstract:
|
|
|
|
Unit tests for theory_nseq ported from the ZIPT test suite.
|
|
Source: https://github.com/CEisenhofer/ZIPT/blob/parikh/Test/Test.cs
|
|
|
|
Naming convention for strings/regexes (matching ZIPT's ParseStr/ParseRegex):
|
|
- Uppercase ASCII letters (A-Z) denote string variables.
|
|
- Lowercase letters and digits denote concrete characters.
|
|
- Regex syntax: * (Kleene star), + (one-or-more), | (union),
|
|
& (intersection), ~ (complement), ( ) (grouping).
|
|
|
|
--*/
|
|
#include "util/util.h"
|
|
#include "ast/reg_decl_plugins.h"
|
|
#include "ast/euf/euf_egraph.h"
|
|
#include "ast/euf/euf_sgraph.h"
|
|
#include "smt/seq/seq_nielsen.h"
|
|
#include "ast/seq_decl_plugin.h"
|
|
#include "ast/ast_pp.h"
|
|
#include <iostream>
|
|
#include <cassert>
|
|
#include <functional>
|
|
#include <chrono>
|
|
|
|
// Trivial solver that always returns sat and ignores all assertions.
|
|
class nseq_zipt_dummy_solver : public seq::simple_solver {
|
|
public:
|
|
void push() override {}
|
|
void pop(unsigned) override {}
|
|
void assert_expr(expr*) override {}
|
|
lbool check() override { return l_true; }
|
|
};
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Trivial simple_solver stub: optimistically assumes integer constraints
|
|
// are always feasible (returns l_true without actually checking).
|
|
// -----------------------------------------------------------------------
|
|
class zipt_dummy_simple_solver : public seq::simple_solver {
|
|
public:
|
|
void push() override {}
|
|
void pop(unsigned) override {}
|
|
void assert_expr(expr*) override {}
|
|
lbool check() override { return l_true; }
|
|
};
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Helper: build a string snode from a notation string.
|
|
// Uppercase = fresh variable, lowercase/digit = concrete character.
|
|
// Variables with the same letter share the same snode (memoised per call).
|
|
// -----------------------------------------------------------------------
|
|
struct str_builder {
|
|
euf::sgraph& sg;
|
|
euf::snode* vars[26] = {}; // vars['A'-'A'] .. vars['Z'-'A']
|
|
|
|
explicit str_builder(euf::sgraph& sg) : sg(sg) {}
|
|
|
|
euf::snode* var(char c) {
|
|
int idx = c - 'A';
|
|
if (!vars[idx])
|
|
vars[idx] = sg.mk_var(symbol(std::string(1, c).c_str()));
|
|
return vars[idx];
|
|
}
|
|
|
|
euf::snode* parse(const char* s) {
|
|
euf::snode* result = nullptr;
|
|
for (const char* p = s; *p; ++p) {
|
|
euf::snode* tok = (*p >= 'A' && *p <= 'Z')
|
|
? var(*p)
|
|
: sg.mk_char((unsigned)(unsigned char)*p);
|
|
result = result ? sg.mk_concat(result, tok) : tok;
|
|
}
|
|
return result ? result : sg.mk_empty();
|
|
}
|
|
};
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Helper: build a regex snode from a notation string.
|
|
// Parses: union (|), intersection (&), concatenation, postfix * and +,
|
|
// prefix complement ~, parentheses, lowercase chars, () for epsilon.
|
|
// -----------------------------------------------------------------------
|
|
struct regex_builder {
|
|
ast_manager& m;
|
|
seq_util& su;
|
|
euf::sgraph& sg;
|
|
sort* re_sort;
|
|
|
|
regex_builder(ast_manager& m, seq_util& su, euf::sgraph& sg)
|
|
: m(m), su(su), sg(sg) {
|
|
re_sort = su.re.mk_re(su.str.mk_string_sort());
|
|
}
|
|
|
|
euf::snode* parse(const char* s) {
|
|
int pos = 0;
|
|
expr_ref e = parse_union(s, pos, (int)strlen(s));
|
|
SASSERT(pos == (int)strlen(s));
|
|
return sg.mk(e.get());
|
|
}
|
|
|
|
private:
|
|
expr_ref mk_char_re(char c) {
|
|
zstring zs(std::string(1, c).c_str());
|
|
return expr_ref(su.re.mk_to_re(su.str.mk_string(zs)), m);
|
|
}
|
|
|
|
expr_ref parse_union(const char* s, int& pos, int len) {
|
|
expr_ref left = parse_inter(s, pos, len);
|
|
while (pos < len && s[pos] == '|') {
|
|
++pos;
|
|
expr_ref right = parse_inter(s, pos, len);
|
|
left = expr_ref(su.re.mk_union(left.get(), right.get()), m);
|
|
}
|
|
return left;
|
|
}
|
|
|
|
expr_ref parse_inter(const char* s, int& pos, int len) {
|
|
expr_ref left = parse_concat(s, pos, len);
|
|
while (pos < len && s[pos] == '&') {
|
|
++pos;
|
|
expr_ref right = parse_concat(s, pos, len);
|
|
left = expr_ref(su.re.mk_inter(left.get(), right.get()), m);
|
|
}
|
|
return left;
|
|
}
|
|
|
|
expr_ref parse_concat(const char* s, int& pos, int len) {
|
|
expr_ref acc(m);
|
|
while (pos < len && s[pos] != ')' && s[pos] != '|' && s[pos] != '&') {
|
|
expr_ref tok = parse_repeat(s, pos, len);
|
|
acc = acc ? expr_ref(su.re.mk_concat(acc.get(), tok.get()), m) : tok;
|
|
}
|
|
return acc ? acc : expr_ref(su.re.mk_to_re(su.str.mk_string(zstring(""))), m);
|
|
}
|
|
|
|
expr_ref parse_repeat(const char* s, int& pos, int len) {
|
|
// collect leading tildes (complement)
|
|
int tildes = 0;
|
|
while (pos < len && s[pos] == '~') { ++tildes; ++pos; }
|
|
expr_ref base = parse_primary(s, pos, len);
|
|
// postfix * and +
|
|
while (pos < len && (s[pos] == '*' || s[pos] == '+')) {
|
|
if (s[pos] == '*')
|
|
base = expr_ref(su.re.mk_star(base.get()), m);
|
|
else
|
|
base = expr_ref(su.re.mk_plus(base.get()), m);
|
|
++pos;
|
|
}
|
|
// apply complements
|
|
for (int i = 0; i < tildes; ++i)
|
|
base = expr_ref(su.re.mk_complement(base.get()), m);
|
|
return base;
|
|
}
|
|
|
|
expr_ref parse_primary(const char* s, int& pos, int len) {
|
|
if (pos >= len)
|
|
return expr_ref(su.re.mk_to_re(su.str.mk_string(zstring(""))), m);
|
|
char c = s[pos];
|
|
if (c == '(') {
|
|
++pos;
|
|
expr_ref inner = parse_union(s, pos, len);
|
|
SASSERT(pos < len && s[pos] == ')');
|
|
++pos;
|
|
return inner;
|
|
}
|
|
++pos;
|
|
return mk_char_re(c);
|
|
}
|
|
};
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Test fixture: shared setup
|
|
// -----------------------------------------------------------------------
|
|
struct nseq_fixture {
|
|
ast_manager m;
|
|
euf::egraph eg;
|
|
euf::sgraph sg;
|
|
zipt_dummy_simple_solver dummy_solver;
|
|
seq::nielsen_graph ng;
|
|
seq_util su;
|
|
str_builder sb;
|
|
regex_builder rb;
|
|
|
|
// Registers plugins on m and returns it so eg can be initialized after plugins are ready.
|
|
static ast_manager& init(ast_manager& m) { reg_decl_plugins(m); return m; }
|
|
|
|
nseq_fixture()
|
|
: eg(init(m)), sg(m, eg), ng(sg, dummy_solver), su(m), sb(sg), rb(m, su, sg)
|
|
{}
|
|
|
|
euf::snode* S(const char* s) { return sb.parse(s); }
|
|
euf::snode* R(const char* s) { return rb.parse(s); }
|
|
};
|
|
|
|
static constexpr int TEST_TIMEOUT_SEC = 2;
|
|
|
|
static void set_timeout(nseq_fixture& f) {
|
|
auto start = std::chrono::steady_clock::now();
|
|
f.ng.set_cancel_fn([start]() {
|
|
auto elapsed = std::chrono::steady_clock::now() - start;
|
|
return std::chrono::duration_cast<std::chrono::seconds>(elapsed).count() >= TEST_TIMEOUT_SEC;
|
|
});
|
|
}
|
|
|
|
static bool eq_sat(const char* lhs, const char* rhs) {
|
|
std::cout << "Checking equation: " << lhs << " = " << rhs << std::endl;
|
|
nseq_fixture f;
|
|
set_timeout(f);
|
|
f.ng.add_str_eq(f.S(lhs), f.S(rhs));
|
|
return f.ng.solve() == seq::nielsen_graph::search_result::sat;
|
|
}
|
|
static bool eq_unsat(const char* lhs, const char* rhs) {
|
|
std::cout << "Checking equation: " << lhs << " = " << rhs << std::endl;
|
|
nseq_fixture f;
|
|
set_timeout(f);
|
|
f.ng.add_str_eq(f.S(lhs), f.S(rhs));
|
|
return f.ng.solve() == seq::nielsen_graph::search_result::unsat;
|
|
}
|
|
static bool mem_sat(std::initializer_list<std::pair<const char*, const char*>> mems) {
|
|
nseq_fixture f;
|
|
set_timeout(f);
|
|
for (auto& [str, re] : mems)
|
|
f.ng.add_str_mem(f.S(str), f.R(re));
|
|
return f.ng.solve() == seq::nielsen_graph::search_result::sat;
|
|
}
|
|
static bool mem_unsat(std::initializer_list<std::pair<const char*, const char*>> mems) {
|
|
nseq_fixture f;
|
|
set_timeout(f);
|
|
for (auto& [str, re] : mems)
|
|
f.ng.add_str_mem(f.S(str), f.R(re));
|
|
return f.ng.solve() == seq::nielsen_graph::search_result::unsat;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// String equation tests (ZIPT: CheckStrEquations)
|
|
// -----------------------------------------------------------------------
|
|
static void test_zipt_str_equations() {
|
|
std::cout << "test_zipt_str_equations:" << std::endl;
|
|
|
|
VERIFY(eq_sat ("abab", "XX")); // abab = XX (X="ab")
|
|
VERIFY(eq_sat ("aX", "YX")); // aX = YX (Y="a")
|
|
VERIFY(eq_sat ("aX", "Xa")); // aX = Xa
|
|
VERIFY(eq_unsat("aX", "Xb")); // aX = Xb — UNSAT
|
|
VERIFY(eq_sat ("abX", "Xba")); // abX = Xba
|
|
VERIFY(eq_sat ("XabY", "YbaX")); // XabY = YbaX
|
|
VERIFY(eq_unsat("abcX", "Xbac")); // abcX = Xbac — UNSAT
|
|
VERIFY(eq_unsat("aaX", "Xa")); // aaX = Xa — UNSAT
|
|
VERIFY(eq_unsat("aa", "XXX")); // aa = XXX — UNSAT
|
|
VERIFY(eq_sat ("aX", "XY")); // aX = XY
|
|
|
|
std::cout << " ok\n";
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Ground regex matching tests (ZIPT: CheckRegexMatching)
|
|
// No string variables — all concrete inputs.
|
|
// -----------------------------------------------------------------------
|
|
static void test_zipt_regex_ground() {
|
|
std::cout << "test_zipt_regex_ground\n";
|
|
|
|
VERIFY(mem_sat ({{"", ""}})); // "" ∈ ε
|
|
VERIFY(mem_unsat({{"a", ""}})); // "a" ∉ ε
|
|
|
|
VERIFY(mem_sat ({{"", "a*"}})); // "" ∈ a*
|
|
VERIFY(mem_sat ({{"aaaa", "a*"}})); // "aaaa" ∈ a*
|
|
VERIFY(mem_unsat({{"b", "a*"}})); // "b" ∉ a*
|
|
VERIFY(mem_sat ({{"abbb", "ab*"}})); // "abbb" ∈ ab*
|
|
|
|
VERIFY(mem_sat ({{"ab", "(ab)+"}})); // "ab" ∈ (ab)+
|
|
VERIFY(mem_sat ({{"ababab", "(ab)+"}})); // "ababab" ∈ (ab)+
|
|
VERIFY(mem_unsat({{"", "(ab)+"}})); // "" ∉ (ab)+
|
|
|
|
VERIFY(mem_sat ({{"", "()"}})); // "" ∈ ()
|
|
VERIFY(mem_sat ({{"", "()*"}})); // "" ∈ ()*
|
|
VERIFY(mem_unsat({{"a", "()*"}})); // "a" ∉ ()*
|
|
|
|
VERIFY(mem_unsat({{"a", "~a"}})); // "a" ∉ ~a
|
|
VERIFY(mem_sat ({{"b", "~a"}})); // "b" ∈ ~a
|
|
VERIFY(mem_sat ({{"a", "~(~a)"}})); // "a" ∈ ~~a
|
|
|
|
VERIFY(mem_unsat({{"a", "a&(~a)"}})); // "a" ∉ a & ~a
|
|
VERIFY(mem_unsat({{"a", "(a|b)&(~a)"}})); // "a" ∉ (a|b) & ~a
|
|
VERIFY(mem_sat ({{"b", "(a|b)&(~a)"}})); // "b" ∈ (a|b) & ~a
|
|
|
|
VERIFY(mem_sat ({{"ab", "ab"}}));
|
|
VERIFY(mem_sat ({{"a", "a|b"}}));
|
|
VERIFY(mem_sat ({{"b", "a|b"}}));
|
|
VERIFY(mem_unsat({{"ab", "a|b"}}));
|
|
|
|
VERIFY(mem_sat ({{"b", "(a|b)|(c|d)"}}));
|
|
VERIFY(mem_sat ({{"c", "(a|b)|(c|d)"}}));
|
|
VERIFY(mem_unsat({{"e", "(a|b)|(c|d)"}}));
|
|
VERIFY(mem_sat ({{"b", "(a|b)&(~a|b)"}}));
|
|
VERIFY(mem_unsat({{"a", "(a|b)&(~a|b)"}}));
|
|
|
|
VERIFY(mem_sat ({{"abababab", "(ab)*"}}));
|
|
VERIFY(mem_sat ({{"abab", "(ab)*"}}));
|
|
VERIFY(mem_unsat({{"aba", "(ab)*"}}));
|
|
|
|
VERIFY(mem_sat ({{"c", "(a|b|c)&(c|d)"}}));
|
|
VERIFY(mem_unsat({{"b", "(a|b|c)&(c|d)"}}));
|
|
|
|
VERIFY(mem_sat ({{"abab", "((ab)|(ba))+"}}));
|
|
VERIFY(mem_unsat({{"a", "((ab)|(ba))+"}}));
|
|
|
|
VERIFY(mem_sat ({{"c", "(~a)&(c|b)"}}));
|
|
|
|
VERIFY(mem_unsat({{"a", "~(a|b)"}}));
|
|
VERIFY(mem_sat ({{"c", "~(a|b)"}}));
|
|
|
|
std::cout << " ok\n";
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// String membership tests (ZIPT: CheckStrMembership)
|
|
// String variables (uppercase) combined with regex constraints.
|
|
// -----------------------------------------------------------------------
|
|
static void test_zipt_str_membership() {
|
|
std::cout << "test_zipt_str_membership\n";
|
|
|
|
// X ∈ (~(ab))*cab
|
|
VERIFY(mem_sat({{"X", "(~(ab))*cab"}}));
|
|
|
|
// X ∈ a* && X ∈ a* && X ∈ b+ → UNSAT
|
|
VERIFY(mem_unsat({{"X","a*"}, {"X","a*"}, {"X","b+"}}));
|
|
|
|
// X ∈ a*b* && Y ∈ a*b* → SAT (independent)
|
|
VERIFY(mem_sat({{"X","a*b*"}, {"Y","a*b*"}}));
|
|
|
|
// X ∈ a* && Y ∈ (ab)+ → SAT (independent)
|
|
VERIFY(mem_sat({{"X","a*"}, {"Y","(ab)+"}}));
|
|
|
|
// X ∈ (ab)+ && X ∈ a* → UNSAT
|
|
VERIFY(mem_unsat({{"X","(ab)+"}, {"X","a*"}}));
|
|
|
|
// XaX ∈ (aa)* → UNSAT
|
|
VERIFY(mem_unsat({{"XaX", "(aa)*"}}));
|
|
|
|
// aX ∈ aa*
|
|
VERIFY(mem_sat({{"aX", "aa*"}}));
|
|
|
|
// X ∈ (aa)*a && X ∈ (aa)* → UNSAT
|
|
VERIFY(mem_unsat({{"X","(aa)*a"}, {"X","(aa)*"}}));
|
|
|
|
// X ∈ (aa)*aa && X ∈ (aa)* → SAT
|
|
VERIFY(mem_sat({{"X","(aa)*aa"}, {"X","(aa)*"}}));
|
|
|
|
// Xa ∈ aa*
|
|
VERIFY(mem_sat({{"Xa", "aa*"}}));
|
|
|
|
// Xa ∈ aa*a
|
|
VERIFY(mem_sat({{"Xa", "aa*a"}}));
|
|
|
|
// bX ∉ a*a
|
|
VERIFY(mem_unsat({{"bX", "a*a"}}));
|
|
|
|
// bX ∉ a*
|
|
VERIFY(mem_unsat({{"bX", "a*"}}));
|
|
|
|
// bX ∉ a*a
|
|
VERIFY(mem_unsat({{"bX", "a*a"}}));
|
|
|
|
// bX ∈ b*a
|
|
VERIFY(mem_sat({{"bX", "b*a"}}));
|
|
|
|
// bXb ∈ b*ab*
|
|
VERIFY(mem_sat({{"bXb", "b*ab*"}}));
|
|
|
|
// bXbb ∈ b*ab*
|
|
VERIFY(mem_sat({{"bXbb", "b*ab*"}}));
|
|
|
|
// XX ∈ aa*
|
|
VERIFY(mem_sat({{"XX", "aa*"}}));
|
|
|
|
// XaX ∈ aaa*
|
|
VERIFY(mem_sat({{"XaX", "aaa*"}}));
|
|
|
|
// XX ∈ aaaa*
|
|
VERIFY(mem_sat({{"XX", "aaaa*"}}));
|
|
|
|
// XbX ∉ a*
|
|
VERIFY(mem_unsat({{"XbX", "a*"}}));
|
|
|
|
// XbX ∈ a*b*
|
|
VERIFY(mem_sat({{"XbX", "a*b*"}}));
|
|
|
|
// XbX ∈ a*b*a*a
|
|
VERIFY(mem_sat({{"XbX", "a*b*a*a"}}));
|
|
|
|
// XabX ∉ (aba)*
|
|
VERIFY(mem_unsat({{"XabX", "(aba)*"}}));
|
|
|
|
// XaX ∉ (ab)*
|
|
VERIFY(mem_unsat({{"XaX", "(ab)*"}}));
|
|
|
|
// X ∈ a|b
|
|
VERIFY(mem_sat({{"X", "a|b"}}));
|
|
|
|
// XX ∉ a|b
|
|
VERIFY(mem_unsat({{"XX", "a|b"}}));
|
|
|
|
// XX ∉ (ab)|(ba)
|
|
VERIFY(mem_unsat({{"XX", "(ab)|(ba)"}}));
|
|
|
|
// XX ∈ (ab|ba)(ba|ab)
|
|
VERIFY(mem_sat({{"XX", "(ab|ba)(ba|ab)"}}));
|
|
|
|
// XX ∉ (ab|ba)(aa|bb)
|
|
VERIFY(mem_unsat({{"XX", "(ab|ba)(aa|bb)"}}));
|
|
|
|
// bXbX ∉ a*b*a*a
|
|
VERIFY(mem_unsat({{"bXbX", "a*b*a*a"}}));
|
|
|
|
// XdX ∈ (a|b)*da(a|c)*
|
|
VERIFY(mem_sat({{"XdX", "(a|b)*da(a|c)*"}}));
|
|
|
|
// XbX ∉ (ab)*
|
|
VERIFY(mem_unsat({{"XbX", "(ab)*"}}));
|
|
|
|
// XabX ∉ (ab)* && XbabX ∉ a(ba)*
|
|
VERIFY(mem_unsat({{"XabX","(ab)*"}, {"XbabX","a(ba)*"}}));
|
|
|
|
// XX ∉ (aba)*a
|
|
VERIFY(mem_unsat({{"XX", "(aba)*a"}}));
|
|
|
|
// XX ∈ (((ab)|(ba)))+aa
|
|
VERIFY(mem_sat({{"XX", "((ab)|(ba))+aa"}}));
|
|
|
|
// XX ∉ (ab)*a
|
|
VERIFY(mem_unsat({{"XX", "(ab)*a"}}));
|
|
|
|
// XX ∉ (a(a|b))*a
|
|
VERIFY(mem_unsat({{"XX", "(a(a|b))*a"}}));
|
|
|
|
// XX ∉ (a(a|(aaa)))*a
|
|
VERIFY(mem_unsat({{"XX", "(a(a|(aaa)))*a"}}));
|
|
|
|
// XX ∈ (((ab)|(ba)))+aa (duplicate from ZIPT)
|
|
VERIFY(mem_sat({{"XX", "((ab)|(ba))+aa"}}));
|
|
|
|
// XX ∉ (((ab)|(ba)))+aaaa
|
|
VERIFY(mem_unsat({{"XX", "((ab)|(ba))+aaaa"}}));
|
|
|
|
// XX ∈ (((ab)|(ba)))*aaaa
|
|
VERIFY(mem_sat({{"XX", "((ab)|(ba))*aaaa"}}));
|
|
|
|
// X ∈ a+ && X ∈ b+ → UNSAT
|
|
VERIFY(mem_unsat({{"X","a+"}, {"X","b+"}}));
|
|
|
|
// X ∈ (a|b) && XX ∈ (a|b) → UNSAT
|
|
VERIFY(mem_unsat({{"X","a|b"}, {"XX","a|b"}}));
|
|
|
|
// X ∈ (ab)+ && XX ∈ a* → UNSAT
|
|
VERIFY(mem_unsat({{"X","(ab)+"}, {"XX","a*"}}));
|
|
|
|
// X ∈ a* && Y ∈ b* && XY ∈ (ab)+ → SAT
|
|
VERIFY(mem_sat({{"X","a*"}, {"Y","b*"}, {"XY","(ab)+"}}));
|
|
|
|
// X ∈ a* && X ∈ ~(a*) → UNSAT
|
|
VERIFY(mem_unsat({{"X","a*"}, {"X","~(a*)"}}));
|
|
|
|
// X ∈ (ab)* && X ∈ (ab)+ → SAT
|
|
VERIFY(mem_sat({{"X","(ab)*"}, {"X","(ab)+"}}));
|
|
|
|
// X ∈ ~(a|b) && X ∈ (c|d) → SAT
|
|
VERIFY(mem_sat({{"X","~(a|b)"}, {"X","c|d"}}));
|
|
|
|
// X ∈ (a|b)* && XX ∈ (ab)+ → SAT
|
|
VERIFY(mem_sat({{"X","(a|b)*"}, {"XX","(ab)+"}}));
|
|
|
|
// X ∈ a+ && Y ∈ b* && XYYX ∈ (ab)*(ba)* → SAT
|
|
VERIFY(mem_sat({{"X","a+"}, {"Y","b*"}, {"XYYX","(ab)*(ba)*"}}));
|
|
|
|
// X ∈ (ab)+ && XXX ∈ (ab)+ → SAT
|
|
VERIFY(mem_sat({{"X","(ab)+"}, {"XXX","(ab)+"}}));
|
|
|
|
// X ∈ (a|b) && X ∈ ~(a|b) → UNSAT
|
|
VERIFY(mem_unsat({{"X","a|b"}, {"X","~(a|b)"}}));
|
|
|
|
// X ∈ a+ && Y ∈ b+ && XY ∈ (ab)+ → SAT
|
|
VERIFY(mem_sat({{"X","a+"}, {"Y","b+"}, {"XY","(ab)+"}}));
|
|
|
|
// XbX ∈ a*b* (note: same snode X shared)
|
|
VERIFY(mem_sat({{"XbX", "a*b*"}}));
|
|
|
|
// X ∈ a+ && XbX ∈ b* → UNSAT
|
|
VERIFY(mem_unsat({{"X","a+"}, {"XbX","b*"}}));
|
|
|
|
// aXb ∈ a(a|b)*b
|
|
VERIFY(mem_sat({{"aXb", "a(a|b)*b"}}));
|
|
|
|
// X ∈ a+ && Y ∈ b+ && XYX ∈ (ab)*(ba)* → SAT
|
|
VERIFY(mem_sat({{"X","a+"}, {"Y","b+"}, {"XYX","(ab)*(ba)*"}}));
|
|
|
|
// XX ∈ (ab|ba)+ && X ∈ (a|b)+ → SAT
|
|
VERIFY(mem_sat({{"XX","(ab|ba)+"}, {"X","(a|b)+"}}));
|
|
|
|
// X ∈ a* && X ∈ a+ → SAT
|
|
VERIFY(mem_sat({{"X","a*"}, {"X","a+"}}));
|
|
|
|
// X ∈ "" && XbX ∈ a*baa* → UNSAT
|
|
VERIFY(mem_unsat({{"X",""}, {"XbX","a*baa*"}}));
|
|
|
|
// XXXX ∈ aaaaa*
|
|
VERIFY(mem_sat({{"XXXX", "aaaaa*"}}));
|
|
|
|
// XXXX ∉ aaa(aa)*
|
|
VERIFY(mem_unsat({{"XXXX", "aaa(aa)*"}}));
|
|
|
|
// XXXX ∉ ab
|
|
VERIFY(mem_unsat({{"XXXX", "ab"}}));
|
|
|
|
// XXXX ∉ abab
|
|
VERIFY(mem_unsat({{"XXXX", "abab"}}));
|
|
|
|
// XXXX ∈ a(ba)*b
|
|
VERIFY(mem_sat({{"XXXX", "a(ba)*b"}}));
|
|
|
|
// XXXX ∉ a(ab)*b
|
|
VERIFY(mem_unsat({{"XXXX", "a(ab)*b"}}));
|
|
|
|
// XYYX ∉ ab
|
|
VERIFY(mem_unsat({{"XYYX", "ab"}}));
|
|
|
|
// XYYX ∉ a(ab)*b
|
|
VERIFY(mem_unsat({{"XYYX", "a(ab)*b"}}));
|
|
|
|
// XYYX ∉ a+b+
|
|
VERIFY(mem_unsat({{"XYYX", "a+b+"}}));
|
|
|
|
// XaX ∈ a(a|b)*a
|
|
VERIFY(mem_sat({{"XaX", "a(a|b)*a"}}));
|
|
|
|
// XbY ∈ a+b* && X ∈ a* && Y ∈ b+
|
|
VERIFY(mem_sat({{"XbY","a+b*"}, {"X","a*"}, {"Y","b+"}}));
|
|
|
|
// X ∈ a+ && Y ∈ b+ && XbY ∉ (ab)+
|
|
VERIFY(mem_unsat({{"X","a+"}, {"Y","b+"}, {"XbY","(ab)+"}}));
|
|
|
|
// X ∈ ((()|a)b)* && Y ∈ (a(()|b))* && XbY ∉ (ab)*
|
|
VERIFY(mem_unsat({{"X","((()|a)b)*"}, {"Y","(a(()|b))*"}, {"XbY","(ab)*"}}));
|
|
|
|
// X ∈ (a(()|b))* && Y ∈ (ab)* && XbY ∈ (ab)*
|
|
VERIFY(mem_sat({{"X","(a(()|b))*"}, {"Y","(ab)*"}, {"XbY","(ab)*"}}));
|
|
|
|
// X ∈ (ab)* && Y ∈ ((()|a)b)* && XbY ∉ (ab)*
|
|
VERIFY(mem_unsat({{"X","(ab)*"}, {"Y","((()|a)b)*"}, {"XbY","(ab)*"}}));
|
|
|
|
// X ∈ (ab)* && Y ∈ (ab)* && XbY ∉ (ab)*
|
|
VERIFY(mem_unsat({{"X","(ab)*"}, {"Y","(ab)*"}, {"XbY","(ab)*"}}));
|
|
|
|
// X ∈ a+ && Y ∈ b+ && Z ∈ c+ && XYZ ∈ (abc)+ → SAT
|
|
VERIFY(mem_sat({{"X","a+"}, {"Y","b+"}, {"Z","c+"}, {"XYZ","(abc)+"}}));
|
|
|
|
// XaYbZ ∈ a*b*c* && X ∈ a* && Y ∈ b* && Z ∈ c* → SAT
|
|
VERIFY(mem_sat({{"XaYbZ","a*b*c*"}, {"X","a*"}, {"Y","b*"}, {"Z","c*"}}));
|
|
|
|
// aXbYc ∈ a(a|b|c)*c
|
|
VERIFY(mem_sat({{"aXbYc", "a(a|b|c)*c"}}));
|
|
|
|
// X ∈ (a|b)* && Y ∈ (b|c)* && Z ∈ (c|a)* && XYZ ∈ (abc)+ → SAT
|
|
VERIFY(mem_sat({{"X","(a|b)*"}, {"Y","(b|c)*"}, {"Z","(c|a)*"}, {"XYZ","(abc)+"}}));
|
|
|
|
std::cout << " ok\n";
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Parikh image tests (ZIPT: CheckParikh)
|
|
// These must be UNSAT via Parikh/letter-count arguments alone.
|
|
// -----------------------------------------------------------------------
|
|
static void test_zipt_parikh() {
|
|
std::cout << "test_zipt_parikh\n";
|
|
|
|
VERIFY(eq_unsat("abcX", "Xbac"));
|
|
VERIFY(eq_unsat("XabcY", "YbacX"));
|
|
VERIFY(eq_unsat("XXabcYY", "YYbacXX"));
|
|
VERIFY(eq_unsat("XXacdYYb", "YYabcdXX"));
|
|
VERIFY(eq_unsat("YaXaaabbbbYX", "XYababababXY"));
|
|
|
|
std::cout << " ok\n";
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Tricky string equation benchmarks (hand-crafted, beyond ZIPT suite).
|
|
//
|
|
// SAT witnesses are noted inline. UNSAT arguments are grouped by type:
|
|
// [first-char] — immediate first-character mismatch
|
|
// [after-cancel] — mismatch exposed after prefix/suffix cancellation
|
|
// [induction] — recursive unrolling forces a = b contradiction
|
|
// [parity] — length parity (odd vs even) rules out all solutions
|
|
// [midpoint] — equal length forced by lengths; midpoint char differs
|
|
// -----------------------------------------------------------------------
|
|
static void test_tricky_str_equations() {
|
|
std::cout << "test_tricky_str_equations\n";
|
|
|
|
// ---------------------------------------------------------------
|
|
// SAT — Conjugacy equations: Xw₂ = w₁X
|
|
// SAT iff w₂ is a rotation of w₁. In that case w₁ = qp, w₂ = pq
|
|
// and X = (qp)^n · q is a family of solutions (n ≥ 0).
|
|
// All of these are UNSAT for X = ε (the ground parts don't match),
|
|
// so the solver must find a non-trivial witness.
|
|
// ---------------------------------------------------------------
|
|
|
|
// "ba" is a rotation of "ab" (p="b", q="a"). X = "a".
|
|
VERIFY(eq_sat("Xba", "abX"));
|
|
|
|
// "cb" is a rotation of "bc" (p="c", q="b"). X = "b".
|
|
VERIFY(eq_sat("Xcb", "bcX"));
|
|
|
|
// "bca" is a rotation of "abc" (p="bc", q="a"). X = "a".
|
|
VERIFY(eq_sat("Xbca", "abcX"));
|
|
|
|
// "cab" is a rotation of "abc" (p="c", q="ab"). X = "ab".
|
|
VERIFY(eq_sat("Xcab", "abcX"));
|
|
|
|
// ---------------------------------------------------------------
|
|
// SAT — Power decomposition (ε NOT a solution)
|
|
// ---------------------------------------------------------------
|
|
|
|
// XX = aa ⇒ X = "a". (ε gives "" ≠ "aa")
|
|
VERIFY(eq_sat("XX", "aa"));
|
|
|
|
// XbX = aba ⇒ 2|X| + 1 = 3 forces |X| = 1; X = "a".
|
|
// (ε gives "b" ≠ "aba")
|
|
VERIFY(eq_sat("XbX", "aba"));
|
|
|
|
// ---------------------------------------------------------------
|
|
// SAT — Multi-variable (ε NOT a solution)
|
|
// ---------------------------------------------------------------
|
|
|
|
// X = "b", Y = "a" gives "baab" = "baab". (ε gives "ab" ≠ "ba")
|
|
VERIFY(eq_sat("XaYb", "bYaX"));
|
|
|
|
// X = "b", Y = "a" gives "abba" = "abba". (ε gives "ab" ≠ "ba")
|
|
VERIFY(eq_sat("abXY", "YXba"));
|
|
|
|
// ---------------------------------------------------------------
|
|
// UNSAT — Non-conjugate rotation
|
|
// Xw₂ = w₁X where w₂ is NOT a rotation of w₁.
|
|
// Heads are variable vs char, so never a trivial first-char clash.
|
|
// GPowerIntr introduces periodicity, then the period boundaries
|
|
// give a character mismatch.
|
|
// ---------------------------------------------------------------
|
|
|
|
// "cba" is the reverse of "abc", NOT a rotation.
|
|
// Rotations of "abc" are: abc, bca, cab.
|
|
VERIFY(eq_unsat("Xcba", "abcX"));
|
|
|
|
// "acb" is a transposition of "abc", NOT a rotation.
|
|
VERIFY(eq_unsat("Xacb", "abcX"));
|
|
|
|
// ---------------------------------------------------------------
|
|
// UNSAT — Induction via GPowerIntr
|
|
// One side starts with a variable that also appears on the other
|
|
// side behind a ground prefix → self-cycle. GPowerIntr forces
|
|
// periodicity; all period branches yield character mismatches.
|
|
// None of these has a trivial first-char or last-char clash.
|
|
// ---------------------------------------------------------------
|
|
|
|
// Xa = bX: LHS head = X. Scan RHS: [b], X → self-cycle, base "b".
|
|
// X = b^n ⇒ b^n·a = b^{n+1} ⇒ last chars a ≠ b ⊥.
|
|
VERIFY(eq_unsat("Xa", "bX"));
|
|
|
|
// acX = Xbc: RHS head = X. Scan LHS: [a,c], X → self-cycle, base "ac".
|
|
// X = (ac)^n ⇒ ac = bc ⊥ (a ≠ b).
|
|
// X = (ac)^n·a ⇒ aca = abc ⊥ (c ≠ b).
|
|
VERIFY(eq_unsat("acX", "Xbc"));
|
|
|
|
// bcX = Xab: RHS head = X. Scan LHS: [b,c], X → self-cycle, base "bc".
|
|
// X = (bc)^n ⇒ bc = ab ⊥ (b ≠ a).
|
|
// X = (bc)^n·b ⇒ bcb = bab ⊥ (c ≠ a).
|
|
VERIFY(eq_unsat("bcX", "Xab"));
|
|
|
|
std::cout << " ok\n";
|
|
}
|
|
|
|
void tst_nseq_zipt() {
|
|
test_zipt_str_equations();
|
|
test_tricky_str_equations();
|
|
test_zipt_regex_ground();
|
|
test_zipt_str_membership();
|
|
test_zipt_parikh();
|
|
std::cout << "nseq_zipt: all tests passed\n";
|
|
}
|