max/lean4-htt
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 2
lean4-htt/tests/elab_fail/simp_trace.lean.out.expected
Sebastian Graf 40e8f4c5fb
chore: turn on new do elaborator in Core (#12656) 
This PR turns on the new `do` elaborator in Init, Lean, Std, Lake and
the testsuite.

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
2026-03-09 12:38:33 +00:00

234 lines
7.2 KiB
Text
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

Try this: simp only [f, reduceCtorEq]
[Meta.Tactic.simp.rewrite] unfold f, f (a :: b = []) ==> a :: b = []
[Meta.Tactic.simp.rewrite] eq_self:1000:
False = False
==>
True
Try this: simp only [length, gt_iff_lt]
[Meta.Tactic.simp.rewrite] unfold length, length (a :: b :: as) ==> length (b :: as) + 1
[Meta.Tactic.simp.rewrite] unfold length, length (b :: as) ==> length as + 1
[Meta.Tactic.simp.rewrite] gt_iff_lt:1000:
length as + 1 + 1 > length as
==>
length as < length as + 1 + 1
Try this: simp only [fact, gt_iff_lt, Nat.zero_lt_succ, Nat.mul_pos_iff_of_pos_left]
[Meta.Tactic.simp.rewrite] unfold fact, fact (x + 1) ==> (x + 1) * fact x
[Meta.Tactic.simp.rewrite] gt_iff_lt:1000:
(x + 1) * fact x > 0
==>
0 < (x + 1) * fact x
[Meta.Tactic.simp.rewrite] Nat.zero_lt_succ:1000:
0 < x + 1
==>
True
[Meta.Tactic.simp.rewrite] Nat.mul_pos_iff_of_pos_left:1000:
0 < (x + 1) * fact x
==>
0 < fact x
Try this: simp only [head]
[Meta.Tactic.simp.rewrite] unfold head, head (a :: as) ==> match a :: as with
| [] => default
| a :: tail => a
[Meta.Tactic.simp.rewrite] eq_self:1000:
a = a
==>
True
Try this: simp only [foo]
[Meta.Tactic.simp.rewrite] unfold foo, foo ==> 10
[Meta.Tactic.simp.rewrite] eq_self:1000:
10 + x = 10 + x
==>
True
Try this: simp only [g, pure]
[Meta.Tactic.simp.rewrite] unfold g, g x ==> (have x := x;
pure x).run
Try this: simp (config := { unfoldPartialApp := true }) only [f1, modify, modifyGet, MonadStateOf.modifyGet,
StateT.modifyGet, pure, f2, bind, StateT.bind, get, getThe, MonadStateOf.get, StateT.get, set, StateT.set]
[Meta.Tactic.simp.rewrite] unfold f1, f1 ==> modify fun x => g x
[Meta.Tactic.simp.rewrite] unfold modify, modify fun x => g x ==> modifyGet fun s => (PUnit.unit, (fun x => g x) s)
[Meta.Tactic.simp.rewrite] unfold StateT.modifyGet, StateT.modifyGet fun s =>
(PUnit.unit, (fun x => g x) s) ==> fun s => pure ((fun s => (PUnit.unit, (fun x => g x) s)) s)
[Meta.Tactic.simp.rewrite] unfold f2, f2 ==> do
let s ← get
set (g s)
[Meta.Tactic.simp.rewrite] unfold StateT.bind, StateT.bind get fun s => set (g s) ==> fun s => do
let __x ← get s
match __x with
| (a, s) => (fun s => set (g s)) a s
[Meta.Tactic.simp.rewrite] unfold getThe, getThe Nat s ==> MonadStateOf.get s
[Meta.Tactic.simp.rewrite] unfold StateT.get, StateT.get s ==> pure (s, s)
[Meta.Tactic.simp.rewrite] unfold StateT.set, StateT.set (g s) s ==> pure (PUnit.unit, g s)
[Meta.Tactic.simp.rewrite] eq_self:1000:
(fun s => (PUnit.unit, g s)) = fun s => (PUnit.unit, g s)
==>
True
Try this: simp only [bla, h]
[Meta.Tactic.simp.rewrite] unfold bla, bla x ==> match h x with
| Sum.inl (y, z) => y + z
| Sum.inr val => 0
[Meta.Tactic.simp.rewrite] unfold h, h x ==> Sum.inl (x, x)
[Meta.Tactic.simp.rewrite] eq_self:1000:
x + x = x + x
==>
True
Try this: simp only [h, Nat.sub_add_cancel]
[Meta.Tactic.simp.rewrite] h:1000:
1 ≤ x
==>
True
[Meta.Tactic.simp.rewrite] Nat.sub_add_cancel:1000:
x - 1 + 1
==>
x
[Meta.Tactic.simp.rewrite] eq_self:1000:
x + 2 = x + 2
==>
True
Try this: simp (config := { contextual := true }) only [Nat.sub_add_cancel, dite_eq_ite]
[Meta.Tactic.simp.rewrite] h:1000:
1 ≤ x
==>
True
[Meta.Tactic.simp.rewrite] Nat.sub_add_cancel:1000:
x - 1 + 1
==>
x
[Meta.Tactic.simp.rewrite] dite_eq_ite:1000:
if h : 1 ≤ x then x else 0
==>
if 1 ≤ x then x else 0
[Meta.Tactic.simp.rewrite] dite_eq_ite:1000:
if _h : 1 ≤ x then x else 0
==>
if 1 ≤ x then x else 0
[Meta.Tactic.simp.rewrite] eq_self:1000:
(if 1 ≤ x then x else 0) = if 1 ≤ x then x else 0
==>
True
Try this: simp only [and_self]
[Meta.Tactic.simp.rewrite] and_self:1000:
b ∧ b
==>
b
[Meta.Tactic.simp.rewrite] iff_self:1000:
a ∧ b ↔ a ∧ b
==>
True
Try this: simp only [my_thm]
[Meta.Tactic.simp.rewrite] my_thm:1000:
b ∧ b
==>
b
[Meta.Tactic.simp.rewrite] eq_self:1000:
(a ∧ b) = (a ∧ b)
==>
True
Try this: simp (discharger := sorry) only [Nat.sub_add_cancel]
[Meta.Tactic.simp.rewrite] Nat.sub_add_cancel:1000:
x - 1 + 1
==>
x
[Meta.Tactic.simp.rewrite] eq_self:1000:
x = x
==>
True
simp_trace.lean:86:0-86:7: warning: declaration uses `sorry`
Try this: simp only [bla, h] at *
[Meta.Tactic.simp.rewrite] unfold bla, bla x ==> match h x with
| Sum.inl (y, z) => y + z
| Sum.inr val => 0
[Meta.Tactic.simp.rewrite] unfold h, h x ==> Sum.inl (x, x)
Try this: simp only [bla, h] at h'
[Meta.Tactic.simp.rewrite] unfold bla, bla x ==> match h x with
| Sum.inl (y, z) => y + z
| Sum.inr val => 0
[Meta.Tactic.simp.rewrite] unfold h, h x ==> Sum.inl (x, x)
Try this: simp only [bla, h, List.length_append] at *
simp_trace.lean:103:101-104:40: error: unsolved goals
x y : Nat
α : Type
xs ys : List α
h₁ : x + x = y
h₂ : xs.length + ys.length = y
⊢ x = length xs
[Meta.Tactic.simp.rewrite] unfold bla, bla x ==> match h x with
| Sum.inl (y, z) => y + z
| Sum.inr val => 0
[Meta.Tactic.simp.rewrite] unfold h, h x ==> Sum.inl (x, x)
[Meta.Tactic.simp.rewrite] List.length_append:1000:
(xs ++ ys).length
==>
xs.length + ys.length
Try this: simp only [bla, h, List.length_append] at *
simp_trace.lean:107:101-108:53: error: unsolved goals
x y : Nat
α : Type
xs ys : List α
h₁ : x + x = y
h₂ : xs.length + ys.length = y
⊢ x = length xs
[Meta.Tactic.simp.rewrite] unfold bla, bla x ==> match h x with
| Sum.inl (y, z) => y + z
| Sum.inr val => 0
[Meta.Tactic.simp.rewrite] unfold h, h x ==> Sum.inl (x, x)
[Meta.Tactic.simp.rewrite] List.length_append:1000:
(xs ++ ys).length
==>
xs.length + ys.length
Try this: simp only [bla, h] at *
[Meta.Tactic.simp.rewrite] unfold bla, bla x ==> match h x with
| Sum.inl (y, z) => y + z
| Sum.inr val => 0
[Meta.Tactic.simp.rewrite] unfold h, h x ==> Sum.inl (x, x)
[Meta.Tactic.simp.rewrite] unfold bla, bla y ==> match h y with
| Sum.inl (y, z) => y + z
| Sum.inr val => 0
[Meta.Tactic.simp.rewrite] unfold h, h y ==> Sum.inl (y, y)
Try this: simp only [bla, h] at *
[Meta.Tactic.simp.rewrite] unfold bla, bla x ==> match h x with
| Sum.inl (y, z) => y + z
| Sum.inr val => 0
[Meta.Tactic.simp.rewrite] unfold h, h x ==> Sum.inl (x, x)
[Meta.Tactic.simp.rewrite] unfold bla, bla x ==> match h x with
| Sum.inl (y, z) => y + z
| Sum.inr val => 0
[Meta.Tactic.simp.rewrite] unfold h, h x ==> Sum.inl (x, x)
Try this: simp only [HasProp.toProp]
Try this: simp only [← h]
[Meta.Tactic.simp.rewrite] ← h:1000:
Q
==>
P
Try this: simp only [← my_thm']
[Meta.Tactic.simp.rewrite] ← my_thm':1000:
P ∧ P
==>
P
[Meta.Tactic.simp.rewrite] iff_self:1000:
P ↔ P
==>
True
Try this: simp only [h]
[Meta.Tactic.simp.rewrite] h:1000:
P
==>
True
Try this: simp only [*]
[Meta.Tactic.simp.rewrite] a✝:1000:
P
==>
True
Try this: simp_all only
[Meta.Tactic.simp.rewrite] h₁:1000:
n
==>
m
Try this: simp_all only
[Meta.Tactic.simp.rewrite] h₁:1000:
n
==>
m
[Meta.Tactic.simp.rewrite] h₁:1000:
n
==>
m
Reference in a new issue View git blame Copy permalink