# Design for handling recursive functions

Main source of inspiration is [Sutter, Köksal & Kuncak 2011],
as implemented in Leon, but the main
differences is that we should unroll function definitions directly from the
inside of Z3, in a backtracking way. Termination and fairness are ensured by
iterative-deepening on the maximum number of unrollings in a given branch.

## Unfolding

The idea is that every function definition `f(x1…xn) := rhs[x1…xn]` is
compiled into:

- a list of cases `A_f_i[x1…xn] => f(x1…xn) = rhs_i[x1…xn]`.
  When `A_f_i[t1…tn]` becomes true in the model, `f(t1…tn)` is said to be
  *unfolded* and the clause `A_f_i[t1…tn] => f(t1…tn) = rhs_i[t1…tn]`
  is added as an auxiliary clause.
- a list of constraints `Γ_f_i[x1…xn] <=> A_f_i[x1…xn]`
  that states when `A_f_i[x1…xn]` should be true, depending on inputs `x1…xn`.
  For every term `f(t1…tn)` present in congruence closure, we
  immediately add all the `Γ_f_i[t1…tn] <=> A_f_i[t1…tn]` as auxiliary clauses
  (maybe during internalization of `f(t1…tn)`?).

where each `A_f_i[x1…xn]` is a special new predicate representing the
given case of `f`, and `rhs_i` does not contain any `ite`.
We assume pattern matching has been compiled to `ite` beforehand.

For example, `fact(n) := if n<2 then 1 else n * fact(n-1)` is compiled into:

- `A_fact_0[n] => fact(n) = 1`
- `A_fact_1[n] => fact(n) = n * fact(n-1)`
- `A_fact_0[n] <=> n < 2`
- `A_fact_1[n] <=> ¬(n < 2)`

The 2 first clauses are only added when `A_fact_0[t]` is true
(respectively `A_fact_1[t]` is true).
The 2 other clauses are added as soon as `fact(t)` is internalized.

## Termination

To ensure termination, we define variables:

- `unfold_depth: int`
- `current_max_unfold_depth: int`
- `global_max_unfold_depth: int`

and a special literal `[max_depth=$n]` for each `n:int`.
Solving is done under the local assumption
`[max_depth=$current_max_unfold_depth]` (this should be handled in some outer
loop, e.g. in a custom tactic).

Whenever `A_f_i[t1…tn]` becomes true (for any `f`), we increment
`unfold_depth`. If `unfold_depth > current_max_unfold_depth`, then
the conflict clause `[max_depth=$current_max_unfold_depth] => Γ => false`
where `Γ` is the conjunction of all `A_f_i[t1…tn]` true in the trail.

For non-recursive functions, we don't have to increment `unfold_depth`. Some other functions that are known

If the solver answers "SAT", we have a model.
Otherwise, if `[max_depth=$current_max_unfold_depth]` is part of the
unsat-core, then we increase `current_max_unfold_depth`.
If `current_max_unfold_depth == global_max_unfold_depth` then
we report "UNKNOWN" (reached global depth limit), otherwise we can
try to `solve()` again with the new assumption (higher depth limit).

## Tactic

there should be a parametrized tactic `funrec(t, n)` where `t` is the tactic
used to solve (under assumption that depth is limited to `current_max_unfold_depth`)
and `n` is an integer that is assigned to `global_max_unfold_depth`.

This way, to try and find models for a problem with recursive functions + LIA,
one could use something like `(funrec (then simplify dl smt) 100)`.

## Expected benefits

This addition to Z3 would bring many benefits compared to current alternatives (Leon, quantifiers, …)

- should be very fast and lightweight
  (compared to Leon or quantifiers).
  In particular, every function call is very lightweight even compared to Leon (no need for full model building, followed by unsat core extraction)
- possibility of answering "SAT" for any `QF_*` fragment +
  recursive functions
- makes `define-funs-rec` a first-class citizen of the language,  usable to model user-defined theories or to analyze functional
  programs directly

## Optimizations

- maybe `C_f_i` literals should never be decided on
  (they can always be propagated).
  Even stronger: they should not be part of conflicts?
  (i.e. tune conflict resolution to always resolve
   these literals away, disregarding their level)