ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Orientation.oangle_eq_zero_or_eq_pi_iff_right_eq_smul
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
⊢ o.oangle x y = 0 ∨ o.oangle x y = ↑π ↔ x = 0 ∨ ∃ r, y = r • x
state_after: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
⊢ SameRay ℝ x y ∨ x ≠ 0 ∧ y ≠ 0 ∧ SameRay ℝ x (-y) ↔ x = 0 ∨ ∃ r, y = r • x
tactic: rw [oangle_eq_zero_iff_sameRay, oangle_eq_pi_iff_sameRay_neg]
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
⊢ SameRay ℝ x y ∨ x ≠ 0 ∧ y ≠ 0 ∧ SameRay ℝ x (-y) ↔ x = 0 ∨ ∃ r, y = r • x
state_after: case refine_1
V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : SameRay ℝ x y ∨ x ≠ 0 ∧ y ≠ 0 ∧ SameRay ℝ x (-y)
⊢ x = 0 ∨ ∃ r, y = r • x

case refine_2
V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : x = 0 ∨ ∃ r, y = r • x
⊢ SameRay ℝ x y ∨ x ≠ 0 ∧ y ≠ 0 ∧ SameRay ℝ x (-y)
tactic: refine ⟨fun h => ?_, fun h => ?_⟩
Theorem: zero_zpow
File: Mathlib/Algebra/GroupWithZero/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a b c : G₀
n : ℕ
h : ↑n ≠ 0
⊢ 0 ^ ↑n = 0
state_after: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a b c : G₀
n : ℕ
h : ↑n ≠ 0
⊢ n ≠ 0
tactic: rw [zpow_natCast, zero_pow]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a b c : G₀
n : ℕ
h : ↑n ≠ 0
⊢ n ≠ 0
state_after: no goals
tactic: simpa [Int.natCast_eq_zero] using h
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a b c : G₀
n : ℕ
x✝ : Int.negSucc n ≠ 0
⊢ 0 ^ Int.negSucc n = 0
state_after: no goals
tactic: simp
Theorem: upperBounds_insert
File: Mathlib/Order/Bounds/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
s✝ t : Set α
a✝ b a : α
s : Set α
⊢ upperBounds (insert a s) = Ici a ∩ upperBounds s
state_after: no goals
tactic: rw [insert_eq, upperBounds_union, upperBounds_singleton]
Theorem: HilbertBasis.coe_mk
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : RCLike 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
v : ι → E
hv : Orthonormal 𝕜 v
hsp : ⊤ ≤ (span 𝕜 (Set.range v)).topologicalClosure
⊢ (fun i => (HilbertBasis.mk hv hsp).repr.symm (lp.single 2 i 1)) = v
state_after: no goals
tactic: apply funext <| Orthonormal.linearIsometryEquiv_symm_apply_single_one hv hsp
Theorem: List.Subperm.filter
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
p : α → Bool
l l' : List α
h : l <+~ l'
⊢ List.filter p l <+~ List.filter p l'
state_after: α : Type u_1
p : α → Bool
l l' : List α
h✝ : l <+~ l'
xs : List α
hp : xs ~ l
h : xs <+ l'
⊢ List.filter p l <+~ List.filter p l'
tactic: let ⟨xs, hp, h⟩ := h
state_before: α : Type u_1
p : α → Bool
l l' : List α
h✝ : l <+~ l'
xs : List α
hp : xs ~ l
h : xs <+ l'
⊢ List.filter p l <+~ List.filter p l'
state_after: no goals
tactic: exact ⟨_, hp.filter p, h.filter p⟩
Theorem: closedBall_zero_add_singleton
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ closedBall 1 δ * {x} = closedBall x δ
state_after: no goals
tactic: simp
Theorem: Nat.findGreatest_eq
File: Mathlib/Data/Nat/Find.lean

Proof steps:
state_before: a b c d m n✝¹ k : ℕ
p q P Q : ℕ → Prop
inst✝ : DecidablePred P
n✝ n : ℕ
h : P (n + 1)
⊢ findGreatest P (n + 1) = n + 1
state_after: no goals
tactic: simp [Nat.findGreatest, h]
Theorem: Stream'.iterate_eq
File: Mathlib/Data/Stream/Init.lean

Proof steps:
state_before: α : Type u
β : Type v
δ : Type w
f : α → α
a : α
⊢ iterate f a = a :: iterate f (f a)
state_after: α : Type u
β : Type v
δ : Type w
f : α → α
a : α
⊢ (iterate f a).head :: (iterate f a).tail = a :: iterate f (f a)
tactic: rw [← Stream'.eta (iterate f a)]
state_before: α : Type u
β : Type v
δ : Type w
f : α → α
a : α
⊢ (iterate f a).head :: (iterate f a).tail = a :: iterate f (f a)
state_after: α : Type u
β : Type v
δ : Type w
f : α → α
a : α
⊢ (iterate f a).head :: iterate f (f a) = a :: iterate f (f a)
tactic: rw [tail_iterate]
state_before: α : Type u
β : Type v
δ : Type w
f : α → α
a : α
⊢ (iterate f a).head :: iterate f (f a) = a :: iterate f (f a)
state_after: no goals
tactic: rfl
Theorem: Multiset.sum_singleton
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s t : Multiset α
a✝ : α
m : Multiset ι
f g : ι → α
a : α
⊢ {a}.prod = a
state_after: no goals
tactic: simp only [mul_one, prod_cons, ← cons_zero, eq_self_iff_true, prod_zero]
Theorem: Doset.mem_doset
File: Mathlib/GroupTheory/DoubleCoset.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : Group G
α : Type u_2
inst✝ : Mul α
J : Subgroup G
g : G
s t : Set α
a b : α
⊢ b ∈ doset a s t ↔ ∃ x ∈ s, ∃ y ∈ t, b = x * a * y
state_after: no goals
tactic: simp only [doset_eq_image2, Set.mem_image2, eq_comm]
Theorem: Multiset.product_add
File: Mathlib/Data/Multiset/Bind.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a✝ : α
b : β
s✝¹ : Multiset α
t✝ : Multiset β
s✝ : Multiset α
a : α
s : Multiset α
IH : ∀ (t u : Multiset β), s ×ˢ (t + u) = s ×ˢ t + s ×ˢ u
t u : Multiset β
⊢ (a ::ₘ s) ×ˢ (t + u) = (a ::ₘ s) ×ˢ t + (a ::ₘ s) ×ˢ u
state_after: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a✝ : α
b : β
s✝¹ : Multiset α
t✝ : Multiset β
s✝ : Multiset α
a : α
s : Multiset α
IH : ∀ (t u : Multiset β), s ×ˢ (t + u) = s ×ˢ t + s ×ˢ u
t u : Multiset β
⊢ map (Prod.mk a) (t + u) + (s ×ˢ t + s ×ˢ u) = (a ::ₘ s) ×ˢ t + (a ::ₘ s) ×ˢ u
tactic: rw [cons_product, IH]
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a✝ : α
b : β
s✝¹ : Multiset α
t✝ : Multiset β
s✝ : Multiset α
a : α
s : Multiset α
IH : ∀ (t u : Multiset β), s ×ˢ (t + u) = s ×ˢ t + s ×ˢ u
t u : Multiset β
⊢ map (Prod.mk a) (t + u) + (s ×ˢ t + s ×ˢ u) = (a ::ₘ s) ×ˢ t + (a ::ₘ s) ×ˢ u
state_after: no goals
tactic: simp [add_comm, add_left_comm, add_assoc]
Theorem: Zsqrtd.norm_eq_one_iff'
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

Proof steps:
state_before: d✝ d : ℤ
hd : d ≤ 0
z : ℤ√d
⊢ z.norm = 1 ↔ IsUnit z
state_after: no goals
tactic: rw [← norm_eq_one_iff, ← Int.natCast_inj, Int.natAbs_of_nonneg (norm_nonneg hd z), Int.ofNat_one]
Theorem: CategoryTheory.MorphismProperty.FunctorsInverting.ext
File: Mathlib/CategoryTheory/MorphismProperty/IsInvertedBy.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
W : MorphismProperty C
F₁ F₂ : W.FunctorsInverting D
h : F₁.obj = F₂.obj
⊢ F₁ = F₂
state_after: case mk
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
W : MorphismProperty C
F₂ : W.FunctorsInverting D
obj✝ : C ⥤ D
property✝ : W.IsInvertedBy obj✝
h : { obj := obj✝, property := property✝ }.obj = F₂.obj
⊢ { obj := obj✝, property := property✝ } = F₂
tactic: cases F₁
state_before: case mk
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
W : MorphismProperty C
F₂ : W.FunctorsInverting D
obj✝ : C ⥤ D
property✝ : W.IsInvertedBy obj✝
h : { obj := obj✝, property := property✝ }.obj = F₂.obj
⊢ { obj := obj✝, property := property✝ } = F₂
state_after: case mk.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
W : MorphismProperty C
obj✝¹ : C ⥤ D
property✝¹ : W.IsInvertedBy obj✝¹
obj✝ : C ⥤ D
property✝ : W.IsInvertedBy obj✝
h : { obj := obj✝¹, property := property✝¹ }.obj = { obj := obj✝, property := property✝ }.obj
⊢ { obj := obj✝¹, property := property✝¹ } = { obj := obj✝, property := property✝ }
tactic: cases F₂
state_before: case mk.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
W : MorphismProperty C
obj✝¹ : C ⥤ D
property✝¹ : W.IsInvertedBy obj✝¹
obj✝ : C ⥤ D
property✝ : W.IsInvertedBy obj✝
h : { obj := obj✝¹, property := property✝¹ }.obj = { obj := obj✝, property := property✝ }.obj
⊢ { obj := obj✝¹, property := property✝¹ } = { obj := obj✝, property := property✝ }
state_after: case mk.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
W : MorphismProperty C
obj✝ : C ⥤ D
property✝¹ : W.IsInvertedBy obj✝
property✝ : W.IsInvertedBy { obj := obj✝, property := property✝¹ }.obj
⊢ { obj := obj✝, property := property✝¹ } =
    { obj := { obj := obj✝, property := property✝¹ }.obj, property := property✝ }
tactic: subst h
state_before: case mk.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
W : MorphismProperty C
obj✝ : C ⥤ D
property✝¹ : W.IsInvertedBy obj✝
property✝ : W.IsInvertedBy { obj := obj✝, property := property✝¹ }.obj
⊢ { obj := obj✝, property := property✝¹ } =
    { obj := { obj := obj✝, property := property✝¹ }.obj, property := property✝ }
state_after: no goals
tactic: rfl
Theorem: Polynomial.derivative_intCast_mul
File: Mathlib/Algebra/Polynomial/Derivative.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : Ring R
n : ℤ
f : R[X]
⊢ derivative (↑n * f) = ↑n * derivative f
state_after: no goals
tactic: simp
Theorem: CategoryTheory.MonoidalCategory.tensor_hom_inv_id'
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝³ : MonoidalCategory C✝
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : MonoidalCategory C
U V✝ W✝ X✝ Y✝ Z✝ V W X Y Z : C
f : V ⟶ W
inst✝ : IsIso f
g : X ⟶ Y
h : Y ⟶ Z
⊢ (g ⊗ f) ≫ (h ⊗ inv f) = (g ⊗ 𝟙 V) ≫ (h ⊗ 𝟙 V)
state_after: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝³ : MonoidalCategory C✝
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : MonoidalCategory C
U V✝ W✝ X✝ Y✝ Z✝ V W X Y Z : C
f : V ⟶ W
inst✝ : IsIso f
g : X ⟶ Y
h : Y ⟶ Z
⊢ g ≫ h ⊗ 𝟙 V = (g ⊗ 𝟙 V) ≫ (h ⊗ 𝟙 V)
tactic: rw [← tensor_comp, IsIso.hom_inv_id]
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝³ : MonoidalCategory C✝
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : MonoidalCategory C
U V✝ W✝ X✝ Y✝ Z✝ V W X Y Z : C
f : V ⟶ W
inst✝ : IsIso f
g : X ⟶ Y
h : Y ⟶ Z
⊢ g ≫ h ⊗ 𝟙 V = (g ⊗ 𝟙 V) ≫ (h ⊗ 𝟙 V)
state_after: no goals
tactic: simp [tensorHom_id]
Theorem: CategoryTheory.SimplicialCategory.sHomWhiskerRight_comp
File: Mathlib/AlgebraicTopology/SimplicialCategory/Basic.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : SimplicialCategory C
K K' K'' : C
f : K ⟶ K'
f' : K' ⟶ K''
L : C
⊢ sHomWhiskerRight (f ≫ f') L = sHomWhiskerRight f' L ≫ sHomWhiskerRight f L
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : SimplicialCategory C
K K' K'' : C
f : K ⟶ K'
f' : K' ⟶ K''
L : C
⊢ (λ_ (sHom K'' L)).inv ≫ (homEquiv K K'') (f ≫ f') ▷ sHom K'' L ≫ sHomComp K K'' L =
    ((λ_ (sHom K'' L)).inv ≫ (homEquiv K' K'') f' ▷ sHom K'' L ≫ sHomComp K' K'' L) ≫
      (λ_ (sHom K' L)).inv ≫ (homEquiv K K') f ▷ sHom K' L ≫ sHomComp K K' L
tactic: dsimp [sHomWhiskerRight]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : SimplicialCategory C
K K' K'' : C
f : K ⟶ K'
f' : K' ⟶ K''
L : C
⊢ (λ_ (sHom K'' L)).inv ≫ (homEquiv K K'') (f ≫ f') ▷ sHom K'' L ≫ sHomComp K K'' L =
    ((λ_ (sHom K'' L)).inv ≫ (homEquiv K' K'') f' ▷ sHom K'' L ≫ sHomComp K' K'' L) ≫
      (λ_ (sHom K' L)).inv ≫ (homEquiv K K') f ▷ sHom K' L ≫ sHomComp K K' L
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : SimplicialCategory C
K K' K'' : C
f : K ⟶ K'
f' : K' ⟶ K''
L : C
⊢ (λ_ (sHom K'' L)).inv ≫
      (λ_ (𝟙_ SSet ⊗ sHom K'' L)).inv ≫
        (α_ (𝟙_ SSet) (𝟙_ SSet) (sHom K'' L)).inv ≫
          ((homEquiv K K') f ⊗ (homEquiv K' K'') f') ▷ sHom K'' L ≫
            (α_ (EnrichedCategory.Hom K K') (EnrichedCategory.Hom K' K'') (EnrichedCategory.Hom K'' L)).hom ≫
              EnrichedCategory.Hom K K' ◁ eComp SSet K' K'' L ≫ eComp SSet K K' L =
    (λ_ (sHom K'' L)).inv ≫
      (homEquiv K' K'') f' ▷ sHom K'' L ≫
        sHomComp K' K'' L ≫ (λ_ (sHom K' L)).inv ≫ (homEquiv K K') f ▷ sHom K' L ≫ sHomComp K K' L
tactic: simp only [assoc, homEquiv_comp, comp_whiskerRight, leftUnitor_inv_whiskerRight, ← e_assoc']
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : SimplicialCategory C
K K' K'' : C
f : K ⟶ K'
f' : K' ⟶ K''
L : C
⊢ (λ_ (sHom K'' L)).inv ≫
      (λ_ (𝟙_ SSet ⊗ sHom K'' L)).inv ≫
        (α_ (𝟙_ SSet) (𝟙_ SSet) (sHom K'' L)).inv ≫
          ((homEquiv K K') f ⊗ (homEquiv K' K'') f') ▷ sHom K'' L ≫
            (α_ (EnrichedCategory.Hom K K') (EnrichedCategory.Hom K' K'') (EnrichedCategory.Hom K'' L)).hom ≫
              EnrichedCategory.Hom K K' ◁ eComp SSet K' K'' L ≫ eComp SSet K K' L =
    (λ_ (sHom K'' L)).inv ≫
      (homEquiv K' K'') f' ▷ sHom K'' L ≫
        sHomComp K' K'' L ≫ (λ_ (sHom K' L)).inv ≫ (homEquiv K K') f ▷ sHom K' L ≫ sHomComp K K' L
state_after: no goals
tactic: rfl
Theorem: ZFSet.singleton_injective
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: x y : ZFSet
H : {x} = {y}
⊢ x = y
state_after: x y : ZFSet
H : {x} = {y}
this : ⋃₀ {x} = ⋃₀ {y} := congr_arg sUnion H
⊢ x = y
tactic: let this := congr_arg sUnion H
state_before: x y : ZFSet
H : {x} = {y}
this : ⋃₀ {x} = ⋃₀ {y} := congr_arg sUnion H
⊢ x = y
state_after: no goals
tactic: rwa [sUnion_singleton, sUnion_singleton] at this
Theorem: surjOn_Icc_of_monotone_surjective
File: Mathlib/Order/Interval/Set/SurjOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b : α
hab : a ≤ b
⊢ SurjOn f (Icc a b) (Icc (f a) (f b))
state_after: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b : α
hab : a ≤ b
p : β
hp : p ∈ Icc (f a) (f b)
⊢ p ∈ f '' Icc a b
tactic: intro p hp
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b : α
hab : a ≤ b
p : β
hp : p ∈ Icc (f a) (f b)
⊢ p ∈ f '' Icc a b
state_after: case inl
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b : α
hab : a ≤ b
hp : f a ∈ Icc (f a) (f b)
⊢ f a ∈ f '' Icc a b

case inr.inl
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b : α
hab : a ≤ b
hp : f b ∈ Icc (f a) (f b)
⊢ f b ∈ f '' Icc a b

case inr.inr
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b : α
hab : a ≤ b
p : β
hp : p ∈ Icc (f a) (f b)
hp' : p ∈ Ioo (f a) (f b)
⊢ p ∈ f '' Icc a b
tactic: rcases eq_endpoints_or_mem_Ioo_of_mem_Icc hp with (rfl | rfl | hp')
Theorem: String.Iterator.ValidFor.pos_eq_endPos
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ it.i = it.s.endPos ↔ r = []
state_after: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ utf8Len l = utf8Len l + utf8Len r ↔ r = []
tactic: simp only [h.pos, h.toString, endPos_eq, utf8Len_reverseAux, Pos.ext_iff]
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ utf8Len l = utf8Len l + utf8Len r ↔ r = []
state_after: no goals
tactic: exact (Nat.add_left_cancel_iff (m := 0)).trans <| eq_comm.trans utf8Len_eq_zero
Theorem: SimpleGraph.Walk.nil_iff_eq_nil
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
⊢ nil.Nil ↔ nil = nil
state_after: no goals
tactic: simp
Theorem: List.mem_inits
File: Mathlib/Data/List/Infix.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
s : List α
this : s = [] ↔ s <+: []
⊢ s ∈ [].inits ↔ s <+: []
state_after: no goals
tactic: simpa only [inits, mem_singleton]
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
s : List α
a : α
t : List α
this : (s = [] ∨ ∃ l, l ∈ t.inits ∧ a :: l = s) ↔ s <+: a :: t
⊢ s ∈ (a :: t).inits ↔ s <+: a :: t
state_after: no goals
tactic: simpa
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
s✝ : List α
a : α
t : List α
o : s✝ = [] ∨ ∃ l, l ∈ t.inits ∧ a :: l = s✝
s r : List α
hr : r ∈ t.inits
hs : a :: r = s
⊢ s <+: a :: t
state_after: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
s✝¹ : List α
a : α
t : List α
o : s✝¹ = [] ∨ ∃ l, l ∈ t.inits ∧ a :: l = s✝¹
s✝ r : List α
hr : r ∈ t.inits
hs : a :: r = s✝
s : List α
ht : r ++ s = t
⊢ s✝ <+: a :: t
tactic: let ⟨s, ht⟩ := (mem_inits _ _).1 hr
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
s✝¹ : List α
a : α
t : List α
o : s✝¹ = [] ∨ ∃ l, l ∈ t.inits ∧ a :: l = s✝¹
s✝ r : List α
hr : r ∈ t.inits
hs : a :: r = s✝
s : List α
ht : r ++ s = t
⊢ s✝ <+: a :: t
state_after: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
s✝¹ : List α
a : α
t : List α
o : s✝¹ = [] ∨ ∃ l, l ∈ t.inits ∧ a :: l = s✝¹
s✝ r : List α
hr : r ∈ t.inits
hs : a :: r = s✝
s : List α
ht : r ++ s = t
⊢ a :: r <+: a :: (r ++ s)
tactic: rw [← hs, ← ht]
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
s✝¹ : List α
a : α
t : List α
o : s✝¹ = [] ∨ ∃ l, l ∈ t.inits ∧ a :: l = s✝¹
s✝ r : List α
hr : r ∈ t.inits
hs : a :: r = s✝
s : List α
ht : r ++ s = t
⊢ a :: r <+: a :: (r ++ s)
state_after: no goals
tactic: exact ⟨s, rfl⟩
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a✝ b✝ : α
m n : ℕ
s✝ : List α
a : α
t : List α
mi : s✝ <+: a :: t
b : α
s r : List α
hr : b :: s ++ r = a :: t
ba : b = a
st : s ++ r = t
⊢ ∃ l, l ∈ t.inits ∧ a :: l = b :: s
state_after: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a✝ b✝ : α
m n : ℕ
s✝ : List α
a : α
t : List α
mi : s✝ <+: a :: t
b : α
s r : List α
hr : b :: s ++ r = a :: t
ba : b = a
st : s ++ r = t
⊢ ∃ l, l ∈ t.inits ∧ a :: l = a :: s
tactic: rw [ba]
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a✝ b✝ : α
m n : ℕ
s✝ : List α
a : α
t : List α
mi : s✝ <+: a :: t
b : α
s r : List α
hr : b :: s ++ r = a :: t
ba : b = a
st : s ++ r = t
⊢ ∃ l, l ∈ t.inits ∧ a :: l = a :: s
state_after: no goals
tactic: exact ⟨_, (mem_inits _ _).2 ⟨_, st⟩, rfl⟩
Theorem: Real.one_lt_rpow_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x y z : ℝ
n : ℕ
hx : 0 ≤ x
⊢ 1 < x ^ y ↔ 1 < x ∧ 0 < y ∨ 0 < x ∧ x < 1 ∧ y < 0
state_after: case inl
y z : ℝ
n : ℕ
hx : 0 ≤ 0
⊢ 1 < 0 ^ y ↔ 1 < 0 ∧ 0 < y ∨ 0 < 0 ∧ 0 < 1 ∧ y < 0

case inr
x y z : ℝ
n : ℕ
hx✝ : 0 ≤ x
hx : 0 < x
⊢ 1 < x ^ y ↔ 1 < x ∧ 0 < y ∨ 0 < x ∧ x < 1 ∧ y < 0
tactic: rcases hx.eq_or_lt with (rfl | hx)
Theorem: Monotone.continuous_of_denseRange
File: Mathlib/Topology/Order/MonotoneContinuity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁶ : LinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : LinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderTopology β
inst✝ : DenselyOrdered β
f : α → β
h_mono : Monotone f
h_dense : DenseRange f
a : α
⊢ closure (f '' univ) ∈ 𝓝 (f a)
state_after: no goals
tactic: simp only [image_univ, h_dense.closure_eq, univ_mem]
Theorem: Equiv.Perm.decomposeOption_symm_of_none_apply
File: Mathlib/GroupTheory/Perm/Option.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
e : Perm α
i : Option α
⊢ (decomposeOption.symm (none, e)) i = Option.map (⇑e) i
state_after: no goals
tactic: simp
Theorem: Matroid.Indep.not_mem_closure_iff_of_not_mem
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
heI : e ∉ I
he : autoParam (e ∈ M.E) _auto✝
⊢ e ∉ M.closure I ↔ M.Indep (insert e I)
state_after: no goals
tactic: rw [hI.not_mem_closure_iff, and_iff_left heI]
Theorem: WeierstrassCurve.Jacobian.nonsingularLift_negMap
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : PointClass F
hP : W.NonsingularLift P
⊢ W.NonsingularLift (W.negMap P)
state_after: case mk
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : PointClass F
a✝ : Fin 3 → F
hP : W.NonsingularLift (Quot.mk Setoid.r a✝)
⊢ W.NonsingularLift (W.negMap (Quot.mk Setoid.r a✝))
tactic: rcases P with ⟨_⟩
state_before: case mk
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : PointClass F
a✝ : Fin 3 → F
hP : W.NonsingularLift (Quot.mk Setoid.r a✝)
⊢ W.NonsingularLift (W.negMap (Quot.mk Setoid.r a✝))
state_after: no goals
tactic: exact nonsingular_neg hP
Theorem: closedBall_add_ball
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
hε : 0 ≤ ε
hδ : 0 < δ
a b : E
⊢ Metric.closedBall a ε + Metric.ball b δ = Metric.ball (a + b) (ε + δ)
state_after: no goals
tactic: rw [add_comm, ball_add_closedBall hδ hε b, add_comm, add_comm δ]
Theorem: List.sum_hom_rel
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝¹ l₁ l₂ : List M
a✝ : M
l✝ : List ι
r : M → N → Prop
f : ι → M
g : ι → N
h₁ : r 1 1
h₂ : ∀ ⦃i : ι⦄ ⦃a : M⦄ ⦃b : N⦄, r a b → r (f i * a) (g i * b)
a : ι
l : List ι
hl : r (map f l).prod (map g l).prod
⊢ r (map f (a :: l)).prod (map g (a :: l)).prod
state_after: no goals
tactic: simp only [map_cons, prod_cons, h₂ hl]
Theorem: Sym.count_coe_fill_of_ne
File: Mathlib/Data/Sym/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n n' m : ℕ
s✝ : Sym α n
a✝ b : α
inst✝ : DecidableEq α
a x : α
i : Fin (n + 1)
s : Sym α (n - ↑i)
hx : x ≠ a
⊢ count x ↑(fill a i s) = count x ↑s
state_after: α : Type u_1
β : Type u_2
n n' m : ℕ
s✝ : Sym α n
a✝ b : α
inst✝ : DecidableEq α
a x : α
i : Fin (n + 1)
s : Sym α (n - ↑i)
hx : x ≠ a
⊢ x ∉ Multiset.replicate (↑i) a
tactic: suffices x ∉ Multiset.replicate i a by simp [coe_fill, coe_replicate, this]
state_before: α : Type u_1
β : Type u_2
n n' m : ℕ
s✝ : Sym α n
a✝ b : α
inst✝ : DecidableEq α
a x : α
i : Fin (n + 1)
s : Sym α (n - ↑i)
hx : x ≠ a
⊢ x ∉ Multiset.replicate (↑i) a
state_after: no goals
tactic: simp [Multiset.mem_replicate, hx]