d975e4302e
This is part of #3983. Fine-grained equational lemmas are useful even for non-recursive functions, so this adds them. The new option `eqns.nonrecursive` can be set to `false` to have the old behavior. ### Breaking channge This is a breaking change: Previously, `rw [Option.map]` would rewrite `Option.map f o` to `match o with … `. Now this rewrite will fail because the equational lemmas require constructors here (like they do for, say, `List.map`). Remedies: * Split on `o` before rewriting. * Use `rw [Option.map.eq_def]`, which rewrites any (saturated) application of `Option.map` * Use `set_option eqns.nonrecursive false` when *defining* the function in question. ### Interaction with simp The `simp` tactic so far had a special provision for non-recursive functions so that `simp [f]` will try to use the equational lemmas, but will also unfold `f` else, so less breakage here (but maybe performance improvements with functions with many cases when applied to a constructor, as the simplifier will no longer unfold to a large `match`-statement and then collapse it right away). For projection functions and functions marked `[reducible]`, `simp [f]` won’t use the equational theorems, and will only use its internal unfolding machinery. ### Implementation notes It uses the same `mkEqnTypes` function as for recursive functions, so we are close to a consistency here. There is still the wrinkle that for recursive functions we don't split matches without an interesting recursive call inside. Unifying that is future work.
102 lines
2.1 KiB
Text
102 lines
2.1 KiB
Text
import Lean.Elab.Command
|
||
|
||
variable (P : Bool → Prop)
|
||
variable (o : Option Nat)
|
||
|
||
/-!
|
||
This test checks that `simp [foo]` where `foo` is `reducible` uses the unfolding machinery,
|
||
not the equations machinery.
|
||
-/
|
||
|
||
@[reducible] def red : Option α → Bool
|
||
| .some _ => true
|
||
| .none => false
|
||
|
||
-- check that simp rewrites even without constants
|
||
|
||
/--
|
||
error: tactic 'fail' failed
|
||
P : Bool → Prop
|
||
o : Option Nat
|
||
⊢ P
|
||
(match o with
|
||
| some val => true
|
||
| none => false)
|
||
-/
|
||
#guard_msgs in
|
||
theorem ex1 : P (red o) := by simp [red]; fail
|
||
|
||
-- check that the equational theorems have not been generated
|
||
|
||
/-- info: false -/
|
||
#guard_msgs in
|
||
run_meta Lean.logInfo m!"{← Lean.hasConst `red.eq_1}"
|
||
|
||
-- Again, the same for the `simp` attribute
|
||
|
||
attribute [simp] red
|
||
|
||
/-- info: false -/
|
||
#guard_msgs in
|
||
run_meta Lean.logInfo m!"{← Lean.hasConst `red.eq_1}"
|
||
|
||
/--
|
||
error: tactic 'fail' failed
|
||
P : Bool → Prop
|
||
o : Option Nat
|
||
⊢ P
|
||
(match o with
|
||
| some val => true
|
||
| none => false)
|
||
-/
|
||
#guard_msgs in
|
||
theorem ex1' : P (red o) := by simp; fail
|
||
|
||
-- For comparison, the behavior for a semi-reducible function
|
||
|
||
def semired : Option α → Bool
|
||
| .some _ => true
|
||
| .none => false
|
||
|
||
-- At least for now, non-recursive functions are also unfolded by simp (as per
|
||
-- `SimpTheorems.unfoldEvenWithEqns`), in addition to applying their rewrite rules:
|
||
|
||
/--
|
||
error: tactic 'fail' failed
|
||
P : Bool → Prop
|
||
o : Option Nat
|
||
⊢ P
|
||
(match o with
|
||
| some val => true
|
||
| none => false)
|
||
-/
|
||
#guard_msgs in
|
||
theorem ex2 : P (semired o) := by simp [semired]; fail
|
||
|
||
-- check that the equational theorems have been generated
|
||
|
||
/-- info: true -/
|
||
#guard_msgs in
|
||
run_meta Lean.logInfo m!"{← Lean.hasConst `semired.eq_1}"
|
||
|
||
def semired2 : Option α → Bool
|
||
| .some _ => true
|
||
| .none => false
|
||
|
||
attribute [simp] semired2
|
||
|
||
/-- info: true -/
|
||
#guard_msgs in
|
||
run_meta Lean.logInfo m!"{← Lean.hasConst `semired2.eq_1}"
|
||
|
||
/--
|
||
error: tactic 'fail' failed
|
||
P : Bool → Prop
|
||
o : Option Nat
|
||
⊢ P
|
||
(match o with
|
||
| some val => true
|
||
| none => false)
|
||
-/
|
||
#guard_msgs in
|
||
theorem ex2' : P (semired2 o) := by simp; fail
|