mirror of
https://github.com/Z3Prover/z3
synced 2025-08-12 06:00:53 +00:00
564830ab31
This allows using z3 for limited E-saturation simplification.
The tactic rewrites all assertions using the E-graph induced by the equalities and instantiated equality axioms.
It does allow solving with conditionals, although this is a first inefficient cut.
The following is a sample use case that rewrites to false.
```
(declare-fun prime () Int)
(declare-fun add (Int Int) Int)
(declare-fun mul (Int Int) Int)
(declare-fun ^ (Int Int) Int)
(declare-fun sub (Int Int) Int)
(declare-fun i () Int)
(declare-fun j () Int)
(declare-fun base () Int)
(declare-fun S () (Seq Int))
(declare-fun hash ((Seq Int) Int Int Int Int) Int)
(assert (let ((a!1 (mul (seq.nth S i) (^ base (sub (sub j i) 1)))))
(let ((a!2 (mod (add (hash S base prime (add i 1) j) a!1) prime)))
(not (= (hash S base prime i j) a!2)))))
(assert (forall ((x Int))
(! (= (mod (mod x prime) prime) (mod x prime))
:pattern ((mod (mod x prime) prime)))))
(assert (forall ((x Int) (y Int))
(! (= (mod (mul x y) prime) (mod (mul (mod x prime) y) prime))
:pattern ((mod (mul x y) prime))
:pattern ((mod (mul (mod x prime) y) prime)))))
(assert (forall ((x Int) (y Int))
(! (= (mod (mul x y) prime) (mod (mul x (mod y prime)) prime))
:pattern ((mod (mul x y) prime))
:pattern ((mod (mul x (mod y prime)) prime)))))
(assert (forall ((x Int) (y Int))
(! (= (mod (add x y) prime) (mod (add x (mod y prime)) prime))
:pattern ((mod (add x y) prime))
:pattern ((mod (add x (mod y prime)) prime)))))
(assert (forall ((x Int) (y Int))
(! (= (mod (add x y) prime) (mod (add (mod x prime) y) prime))
:pattern ((mod (add x y) prime))
:pattern ((mod (add (mod x prime) y) prime)))))
(assert (forall ((x Int) (y Int))
(! (= (mul x (^ x y)) (^ x (add y 1))) :pattern ((mul x (^ x y))))))
(assert (forall ((x Int) (y Int)) (! (= (mul x y) (mul y x)) :pattern ((mul x y)))))
(assert (forall ((x Int) (y Int)) (! (= (add x y) (add y x)) :pattern ((add x y)))))
(assert (forall ((x Int) (y Int)) (! (= (mul x y) (mul y x)) :pattern ((mul x y)))))
(assert (forall ((x Int) (y Int) (z Int))
(! (= (add x (add y z)) (add (add x y) z))
:pattern ((add x (add y z)))
:pattern ((add (add x y) z)))))
(assert (forall ((x Int) (y Int) (z Int))
(! (= (mul x (mul y z)) (mul (mul x y) z))
:pattern ((mul x (mul y z)))
:pattern ((mul (mul x y) z)))))
(assert (forall ((x Int) (y Int) (z Int))
(! (= (sub (sub x y) z) (sub (sub x z) y)) :pattern ((sub (sub x y) z)))))
(assert (forall ((x Int) (y Int) (z Int))
(! (= (mul x (add y z)) (add (mul x y) (mul x z)))
:pattern ((mul x (add y z))))))
(assert (forall ((x Int)) (! (= (sub (add x 1) 1) x) :pattern ((add x 1)))))
(assert (forall ((x Int)) (! (= (add (sub x 1) 1) x) :pattern ((sub x 1)))))
(assert (let ((a!1 (^ base (sub (sub (sub j 1) i) 1))))
(let ((a!2 (mod (add (hash S base prime (add i 1) (sub j 1))
(mul (seq.nth S i) a!1))
prime)))
(= (hash S base prime i (sub j 1)) a!2))))
(assert (let ((a!1 (add (seq.nth S (- j 1)) (mul base (hash S base prime i (sub j 1))))))
(= (hash S base prime i j) (mod a!1 prime))))
(assert (let ((a!1 (add (seq.nth S (- j 1))
(mul base (hash S base prime (add i 1) (sub j 1))))))
(= (hash S base prime (add i 1) j) (mod a!1 prime))))
(apply euf-completion)
```
To use conditional rewriting you can
```
(assert (not (= 0 prime)))
```
and update axioms using modulus with prime to be of the form:
```
(=> (not (= 0 prime)) <original-body of quantifier>)
```
|
||
|---|---|---|
| .. | ||
| blast_term_ite_tactic.cpp | ||
| blast_term_ite_tactic.h | ||
| CMakeLists.txt | ||
| cofactor_elim_term_ite.cpp | ||
| cofactor_elim_term_ite.h | ||
| cofactor_term_ite_tactic.cpp | ||
| cofactor_term_ite_tactic.h | ||
| collect_occs.cpp | ||
| collect_occs.h | ||
| collect_statistics_tactic.cpp | ||
| collect_statistics_tactic.h | ||
| ctx_simplify_tactic.cpp | ||
| ctx_simplify_tactic.h | ||
| demodulator_tactic.h | ||
| der_tactic.cpp | ||
| der_tactic.h | ||
| distribute_forall_tactic.h | ||
| dom_simplify_tactic.h | ||
| elim_term_ite_tactic.cpp | ||
| elim_term_ite_tactic.h | ||
| elim_uncnstr2_tactic.h | ||
| elim_uncnstr_tactic.cpp | ||
| elim_uncnstr_tactic.h | ||
| eliminate_predicates_tactic.h | ||
| injectivity_tactic.cpp | ||
| injectivity_tactic.h | ||
| nnf_tactic.cpp | ||
| nnf_tactic.h | ||
| occf_tactic.cpp | ||
| occf_tactic.h | ||
| pb_preprocess_tactic.cpp | ||
| pb_preprocess_tactic.h | ||
| propagate_values2_tactic.h | ||
| propagate_values_tactic.cpp | ||
| propagate_values_tactic.h | ||
| reduce_args_tactic.cpp | ||
| reduce_args_tactic.h | ||
| simplify_tactic.cpp | ||
| simplify_tactic.h | ||
| solve_eqs_tactic.h | ||
| special_relations_tactic.cpp | ||
| special_relations_tactic.h | ||
| split_clause_tactic.cpp | ||
| split_clause_tactic.h | ||
| symmetry_reduce_tactic.cpp | ||
| symmetry_reduce_tactic.h | ||
| tseitin_cnf_tactic.cpp | ||
| tseitin_cnf_tactic.h | ||