5cd90f5826
until around 7fe6881 the way to define well-founded recursions was to
specify a `WellFoundedRelation` on the argument explicitly. This was
rather low-level, for example one had to predict the packing of multiple
arguments into `PProd`s, the packing of mutual functions into `PSum`s,
and the cliques that were calculated.
Then the current `termination_by` syntax was introduced, where you
specify the termination argument at a higher level (one clause per
functions, unpacked arguments), and the `WellFoundedRelation` is found
using type class resolution.
The old syntax was kept around as `termination_by'`. This is not used
anywhere in the lean, std, mathlib or the theorem-proving-in-lean
repositories,
and three occurrences I found in the wild can do without
In particular, it should be possible to express anything that the old
syntax
supported also with the new one, possibly requiring a helper type with a
suitable instance, or the following generic wrapper that now lives in
std
```
def wrap {α : Sort u} {r : α → α → Prop} (h : WellFounded r) (x : α) : {x : α // Acc r x}
```
Since the old syntax is unused, has an unhelpful name and relies on
internals, this removes the support. Now is a good time before the
refactoring that's planned in #2921.
The test suite was updated without particular surprises.
The parametric `terminationHint` parser is gone, which means we can
match on syntax more easily now, in `expandDecreasingBy?`.
44 lines
745 B
Text
44 lines
745 B
Text
namespace Ex1
|
|
mutual
|
|
def f : Nat → Bool → Nat
|
|
| n, true => 2 * f n false
|
|
| 0, false => 1
|
|
| n, false => n + g n
|
|
|
|
def g (n : Nat) : Nat :=
|
|
if h : n ≠ 0 then
|
|
f (n-1) true
|
|
else
|
|
n
|
|
end
|
|
termination_by
|
|
f n b => (n, if b then 2 else 1)
|
|
g n => (n, 0)
|
|
decreasing_by
|
|
simp_wf
|
|
first
|
|
| apply Prod.Lex.left
|
|
apply Nat.pred_lt
|
|
| apply Prod.Lex.right
|
|
decide
|
|
done -- should fail
|
|
end Ex1
|
|
|
|
|
|
namespace Ex2
|
|
mutual
|
|
def f : Nat → Bool → Nat
|
|
| n, true => 2 * f n false
|
|
| 0, false => 1
|
|
| n, false => n + g (n+1) -- Error
|
|
|
|
def g (n : Nat) : Nat :=
|
|
if h : n ≠ 0 then
|
|
f (n-1) true
|
|
else
|
|
n
|
|
end
|
|
termination_by
|
|
f n b => (n, if b then 2 else 1)
|
|
g n => (n, 0)
|
|
end Ex2
|