- AC completion which is exposed as an option to the new congruence closure core used roots of E-Graph which gets ordering of monomials out of sync.
- Added injective function handling to AC completion
- Move to model where all equations, also unit to unit are in completion
- throw in first level bound bodies into the E-graph to enable canonization on them.
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>)
```
- add sat.smt option to enable the new incremental core (it is not ready for mainstream consumption as cloning and other features are not implemented and it hasn't been tested in any detail yet).
- move "name" into attribute on simplifier so it can be reused for diagnostics by the seq-simplifier.
simplifiers layer is a common substrate for global non-incremental and incremental processing.
The first two layers are new, but others are to be ported form tactics.
- bv::slice - rewrites equations to cut-dice-slice bit-vector extractions until they align. It creates opportunities for rewriting portions of bit-vectors to common sub-expressions, including values.
- euf::completion - generalizes the KB simplifcation from asserted formulas to use the E-graph to establish a global and order-independent canonization.
The interface dependent_expr_simplifier is amenable to forming tactics. Plugins for asserted-formulas is also possible but not yet realized.
