ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CharP.char_ne_one
File: Mathlib/Algebra/CharP/Defs.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : NonAssocSemiring R
inst✝ : Nontrivial R
p : ℕ
hc : CharP R p
hp : p = 1
⊢ 1 = 0
state_after: no goals
tactic: simpa using (cast_eq_zero_iff R p 1).mpr (hp ▸ dvd_refl p)
Theorem: Function.Exact.inr_fst
File: Mathlib/Algebra/Exact.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
⊢ Exact ⇑(LinearMap.inr R M N) ⇑(LinearMap.fst R M N)
state_after: case mk
R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
x : M
y : N
⊢ (LinearMap.fst R M N) (x, y) = 0 ↔ (x, y) ∈ Set.range ⇑(LinearMap.inr R M N)
tactic: rintro ⟨x, y⟩
state_before: case mk
R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
x : M
y : N
⊢ (LinearMap.fst R M N) (x, y) = 0 ↔ (x, y) ∈ Set.range ⇑(LinearMap.inr R M N)
state_after: no goals
tactic: simp only [LinearMap.fst_apply, @eq_comm _ x, LinearMap.coe_inr, Set.mem_range, Prod.mk.injEq,
    exists_eq_right]
Theorem: CategoryTheory.Limits.IsTerminal.hom_ext
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
t : IsTerminal X
f g : Y ⟶ X
⊢ ∀ (j : Discrete PEmpty.{1}), f ≫ (asEmptyCone X).π.app j = g ≫ (asEmptyCone X).π.app j
state_after: no goals
tactic: aesop_cat
Theorem: Complex.log_im_le_pi
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

Proof steps:
state_before: x : ℂ
⊢ (log x).im ≤ π
state_after: no goals
tactic: simp only [log_im, arg_le_pi]
Theorem: MeasureTheory.OuterMeasure.map_iSup
File: Mathlib/MeasureTheory/OuterMeasure/Operations.lean

Proof steps:
state_before: α : Type u_1
β✝ : Type u_2
m✝ : OuterMeasure α
β : Type u_3
ι : Sort u_4
f : α → β
m : ι → OuterMeasure α
s : Set β
⊢ ((map f) (⨆ i, m i)) s = (⨆ i, (map f) (m i)) s
state_after: no goals
tactic: simp only [map_apply, iSup_apply]
Theorem: MeasureTheory.Measure.measure_eq_right_of_subset_of_measure_add_eq
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t : Set α
h : (μ + ν) t ≠ ⊤
h' : s ⊆ t
h'' : (μ + ν) s = (μ + ν) t
⊢ ν s = ν t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t : Set α
h : (ν + μ) t ≠ ⊤
h' : s ⊆ t
h'' : (ν + μ) s = (ν + μ) t
⊢ ν s = ν t
tactic: rw [add_comm] at h'' h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t : Set α
h : (ν + μ) t ≠ ⊤
h' : s ⊆ t
h'' : (ν + μ) s = (ν + μ) t
⊢ ν s = ν t
state_after: no goals
tactic: exact measure_eq_left_of_subset_of_measure_add_eq h h' h''
Theorem: CategoryTheory.CategoryOfElements.CreatesLimitsAux.map_π_liftedConeElement
File: Mathlib/CategoryTheory/Limits/Elements.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
A : C ⥤ Type w
I : Type u₁
inst✝³ : Category.{v₁, u₁} I
inst✝² : Small.{w, u₁} I
F : I ⥤ A.Elements
inst✝¹ : HasLimitsOfShape I C
inst✝ : PreservesLimitsOfShape I A
i : I
⊢ A.map (limit.π (F ⋙ π A) i) (liftedConeElement F) = (F.obj i).snd
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
A : C ⥤ Type w
I : Type u₁
inst✝³ : Category.{v₁, u₁} I
inst✝² : Small.{w, u₁} I
F : I ⥤ A.Elements
inst✝¹ : HasLimitsOfShape I C
inst✝ : PreservesLimitsOfShape I A
i : I
this :
  ((preservesLimitIso A (F ⋙ π A)).inv ≫ A.map (limit.π (F ⋙ π A) i)) (liftedConeElement' F) =
    limit.π ((F ⋙ π A) ⋙ A) i (liftedConeElement' F)
⊢ A.map (limit.π (F ⋙ π A) i) (liftedConeElement F) = (F.obj i).snd
tactic: have := congrFun
    (preservesLimitsIso_inv_π A (F ⋙ π A) i) (liftedConeElement' F)
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
A : C ⥤ Type w
I : Type u₁
inst✝³ : Category.{v₁, u₁} I
inst✝² : Small.{w, u₁} I
F : I ⥤ A.Elements
inst✝¹ : HasLimitsOfShape I C
inst✝ : PreservesLimitsOfShape I A
i : I
this :
  ((preservesLimitIso A (F ⋙ π A)).inv ≫ A.map (limit.π (F ⋙ π A) i)) (liftedConeElement' F) =
    limit.π ((F ⋙ π A) ⋙ A) i (liftedConeElement' F)
⊢ A.map (limit.π (F ⋙ π A) i) (liftedConeElement F) = (F.obj i).snd
state_after: no goals
tactic: simp_all [liftedConeElement]
Theorem: ZMod.cast_sub_one
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n✝ : ℕ
R : Type u_1
inst✝ : Ring R
n : ℕ
k : ZMod n
⊢ (k - 1).cast = (if k = 0 then ↑n else k.cast) - 1
state_after: case pos
m n✝ : ℕ
R : Type u_1
inst✝ : Ring R
n : ℕ
k : ZMod n
hk : k = 0
⊢ (k - 1).cast = ↑n - 1

case neg
m n✝ : ℕ
R : Type u_1
inst✝ : Ring R
n : ℕ
k : ZMod n
hk : ¬k = 0
⊢ (k - 1).cast = k.cast - 1
tactic: split_ifs with hk
Theorem: CategoryTheory.Functor.Monoidal.tensorHom_app_snd
File: Mathlib/CategoryTheory/ChosenFiniteProducts/FunctorCategory.lean

Proof steps:
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{u_3, u_1} J
inst✝¹ : Category.{u_4, u_2} C
inst✝ : ChosenFiniteProducts C
F₁ F₁' F₂ F₂' : J ⥤ C
f : F₁ ⟶ F₁'
g : F₂ ⟶ F₂'
j : J
⊢ (f ⊗ g).app j ≫ snd (F₁'.obj j) (F₂'.obj j) = snd (F₁.obj j) (F₂.obj j) ≫ g.app j
state_after: J : Type u_1
C : Type u_2
inst✝² : Category.{u_3, u_1} J
inst✝¹ : Category.{u_4, u_2} C
inst✝ : ChosenFiniteProducts C
F₁ F₁' F₂ F₂' : J ⥤ C
f : F₁ ⟶ F₁'
g : F₂ ⟶ F₂'
j : J
⊢ (f ⊗ g).app j ≫ (snd F₁' F₂').app j = snd (F₁.obj j) (F₂.obj j) ≫ g.app j
tactic: change (f ⊗ g).app j ≫ (snd F₁' F₂').app j = _
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{u_3, u_1} J
inst✝¹ : Category.{u_4, u_2} C
inst✝ : ChosenFiniteProducts C
F₁ F₁' F₂ F₂' : J ⥤ C
f : F₁ ⟶ F₁'
g : F₂ ⟶ F₂'
j : J
⊢ (f ⊗ g).app j ≫ (snd F₁' F₂').app j = snd (F₁.obj j) (F₂.obj j) ≫ g.app j
state_after: J : Type u_1
C : Type u_2
inst✝² : Category.{u_3, u_1} J
inst✝¹ : Category.{u_4, u_2} C
inst✝ : ChosenFiniteProducts C
F₁ F₁' F₂ F₂' : J ⥤ C
f : F₁ ⟶ F₁'
g : F₂ ⟶ F₂'
j : J
⊢ (snd F₁ F₂).app j ≫ g.app j = snd (F₁.obj j) (F₂.obj j) ≫ g.app j
tactic: rw [← NatTrans.comp_app, tensorHom_snd, NatTrans.comp_app]
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{u_3, u_1} J
inst✝¹ : Category.{u_4, u_2} C
inst✝ : ChosenFiniteProducts C
F₁ F₁' F₂ F₂' : J ⥤ C
f : F₁ ⟶ F₁'
g : F₂ ⟶ F₂'
j : J
⊢ (snd F₁ F₂).app j ≫ g.app j = snd (F₁.obj j) (F₂.obj j) ≫ g.app j
state_after: no goals
tactic: rfl
Theorem: SimpleGraph.ConnectedComponent.iso_image_comp_eq_map_iff_eq_comp
File: Mathlib/Combinatorics/SimpleGraph/Path.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
φ : G ≃g G'
v : V
v' : V'
C : G.ConnectedComponent
⊢ G'.connectedComponentMk (φ v) = map (RelIso.toRelEmbedding φ).toRelHom C ↔ G.connectedComponentMk v = C
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
φ : G ≃g G'
v : V
v' : V'
C : G.ConnectedComponent
u : V
⊢ G'.connectedComponentMk (φ v) = map (RelIso.toRelEmbedding φ).toRelHom (G.connectedComponentMk u) ↔
    G.connectedComponentMk v = G.connectedComponentMk u
tactic: refine C.ind fun u => ?_
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
φ : G ≃g G'
v : V
v' : V'
C : G.ConnectedComponent
u : V
⊢ G'.connectedComponentMk (φ v) = map (RelIso.toRelEmbedding φ).toRelHom (G.connectedComponentMk u) ↔
    G.connectedComponentMk v = G.connectedComponentMk u
state_after: no goals
tactic: simp only [Iso.reachable_iff, ConnectedComponent.map_mk, RelEmbedding.coe_toRelHom,
    RelIso.coe_toRelEmbedding, ConnectedComponent.eq]
Theorem: CategoryTheory.LocalizerMorphism.isEquivalence
File: Mathlib/CategoryTheory/Localization/LocalizerMorphism.lean

Proof steps:
state_before: C₁ : Type u₁
C₂ : Type u₂
C₃ : Type u₃
D₁ : Type u₄
D₂ : Type u₅
D₃ : Type u₆
inst✝⁸ : Category.{v₁, u₁} C₁
inst✝⁷ : Category.{v₂, u₂} C₂
inst✝⁶ : Category.{v₃, u₃} C₃
inst✝⁵ : Category.{v₄, u₄} D₁
inst✝⁴ : Category.{v₅, u₅} D₂
inst✝³ : Category.{v₆, u₆} D₃
W₁ : MorphismProperty C₁
W₂ : MorphismProperty C₂
W₃ : MorphismProperty C₃
Φ : LocalizerMorphism W₁ W₂
L₁ : C₁ ⥤ D₁
inst✝² : L₁.IsLocalization W₁
L₂ : C₂ ⥤ D₂
inst✝¹ : L₂.IsLocalization W₂
G : D₁ ⥤ D₂
h : Φ.IsLocalizedEquivalence
inst✝ : CatCommSq Φ.functor L₁ L₂ G
⊢ G.IsEquivalence
state_after: C₁ : Type u₁
C₂ : Type u₂
C₃ : Type u₃
D₁ : Type u₄
D₂ : Type u₅
D₃ : Type u₆
inst✝⁸ : Category.{v₁, u₁} C₁
inst✝⁷ : Category.{v₂, u₂} C₂
inst✝⁶ : Category.{v₃, u₃} C₃
inst✝⁵ : Category.{v₄, u₄} D₁
inst✝⁴ : Category.{v₅, u₅} D₂
inst✝³ : Category.{v₆, u₆} D₃
W₁ : MorphismProperty C₁
W₂ : MorphismProperty C₂
W₃ : MorphismProperty C₃
Φ : LocalizerMorphism W₁ W₂
L₁ : C₁ ⥤ D₁
inst✝² : L₁.IsLocalization W₁
L₂ : C₂ ⥤ D₂
inst✝¹ : L₂.IsLocalization W₂
G : D₁ ⥤ D₂
h : Φ.IsLocalizedEquivalence
inst✝ : CatCommSq Φ.functor L₁ L₂ G
⊢ (Φ.localizedFunctor W₁.Q W₂.Q).IsEquivalence
tactic: rw [Φ.isEquivalence_iff L₁ L₂ G W₁.Q W₂.Q (Φ.localizedFunctor W₁.Q W₂.Q)]
state_before: C₁ : Type u₁
C₂ : Type u₂
C₃ : Type u₃
D₁ : Type u₄
D₂ : Type u₅
D₃ : Type u₆
inst✝⁸ : Category.{v₁, u₁} C₁
inst✝⁷ : Category.{v₂, u₂} C₂
inst✝⁶ : Category.{v₃, u₃} C₃
inst✝⁵ : Category.{v₄, u₄} D₁
inst✝⁴ : Category.{v₅, u₅} D₂
inst✝³ : Category.{v₆, u₆} D₃
W₁ : MorphismProperty C₁
W₂ : MorphismProperty C₂
W₃ : MorphismProperty C₃
Φ : LocalizerMorphism W₁ W₂
L₁ : C₁ ⥤ D₁
inst✝² : L₁.IsLocalization W₁
L₂ : C₂ ⥤ D₂
inst✝¹ : L₂.IsLocalization W₂
G : D₁ ⥤ D₂
h : Φ.IsLocalizedEquivalence
inst✝ : CatCommSq Φ.functor L₁ L₂ G
⊢ (Φ.localizedFunctor W₁.Q W₂.Q).IsEquivalence
state_after: no goals
tactic: exact h.isEquivalence
Theorem: CategoryTheory.ShortComplex.exact_iff_mono_cokernel_desc
File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : Category.{?u.54716, u_2} D
inst✝³ : Preadditive C
inst✝² : Preadditive D
S : ShortComplex C
inst✝¹ : S.HasHomology
inst✝ : HasCokernel S.f
⊢ S.Exact ↔ Mono (cokernel.desc S.f S.g ⋯)
state_after: C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : Category.{?u.54716, u_2} D
inst✝³ : Preadditive C
inst✝² : Preadditive D
S : ShortComplex C
inst✝¹ : S.HasHomology
inst✝ : HasCokernel S.f
⊢ Mono S.fromOpcycles ↔ Mono (cokernel.desc S.f S.g ⋯)
tactic: rw [exact_iff_mono_fromOpcycles]
state_before: C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : Category.{?u.54716, u_2} D
inst✝³ : Preadditive C
inst✝² : Preadditive D
S : ShortComplex C
inst✝¹ : S.HasHomology
inst✝ : HasCokernel S.f
⊢ Mono S.fromOpcycles ↔ Mono (cokernel.desc S.f S.g ⋯)
state_after: C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : Category.{?u.54716, u_2} D
inst✝³ : Preadditive C
inst✝² : Preadditive D
S : ShortComplex C
inst✝¹ : S.HasHomology
inst✝ : HasCokernel S.f
⊢ Arrow.mk (cokernel.desc S.f S.g ⋯) ≅ Arrow.mk S.fromOpcycles
tactic: refine (MorphismProperty.monomorphisms C).arrow_mk_iso_iff (Iso.symm ?_)
state_before: C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : Category.{?u.54716, u_2} D
inst✝³ : Preadditive C
inst✝² : Preadditive D
S : ShortComplex C
inst✝¹ : S.HasHomology
inst✝ : HasCokernel S.f
⊢ Arrow.mk (cokernel.desc S.f S.g ⋯) ≅ Arrow.mk S.fromOpcycles
state_after: no goals
tactic: exact Arrow.isoMk S.opcyclesIsoCokernel.symm (Iso.refl _) (by aesop_cat)
Theorem: StarConvex.add_smul_mem
File: Mathlib/Analysis/Convex/Star.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
s t✝ : Set E
hs : StarConvex 𝕜 x s
hy : x + y ∈ s
t : 𝕜
ht₀ : 0 ≤ t
ht₁ : t ≤ 1
⊢ x + t • y ∈ s
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
s t✝ : Set E
hs : StarConvex 𝕜 x s
hy : x + y ∈ s
t : 𝕜
ht₀ : 0 ≤ t
ht₁ : t ≤ 1
h : x + t • y = (1 - t) • x + t • (x + y)
⊢ x + t • y ∈ s
tactic: have h : x + t • y = (1 - t) • x + t • (x + y) := by
    rw [smul_add, ← add_assoc, ← add_smul, sub_add_cancel, one_smul]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
s t✝ : Set E
hs : StarConvex 𝕜 x s
hy : x + y ∈ s
t : 𝕜
ht₀ : 0 ≤ t
ht₁ : t ≤ 1
h : x + t • y = (1 - t) • x + t • (x + y)
⊢ x + t • y ∈ s
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
s t✝ : Set E
hs : StarConvex 𝕜 x s
hy : x + y ∈ s
t : 𝕜
ht₀ : 0 ≤ t
ht₁ : t ≤ 1
h : x + t • y = (1 - t) • x + t • (x + y)
⊢ (1 - t) • x + t • (x + y) ∈ s
tactic: rw [h]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
s t✝ : Set E
hs : StarConvex 𝕜 x s
hy : x + y ∈ s
t : 𝕜
ht₀ : 0 ≤ t
ht₁ : t ≤ 1
h : x + t • y = (1 - t) • x + t • (x + y)
⊢ (1 - t) • x + t • (x + y) ∈ s
state_after: no goals
tactic: exact hs hy (sub_nonneg_of_le ht₁) ht₀ (sub_add_cancel _ _)
Theorem: Finset.product_image_snd
File: Mathlib/Data/Finset/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s s' : Finset α
t t' : Finset β
a : α
b : β
inst✝ : DecidableEq β
ht : s.Nonempty
⊢ image Prod.snd (s ×ˢ t) = t
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s s' : Finset α
t t' : Finset β
a : α
b : β
inst✝ : DecidableEq β
ht : s.Nonempty
i : β
⊢ i ∈ image Prod.snd (s ×ˢ t) ↔ i ∈ t
tactic: ext i
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s s' : Finset α
t t' : Finset β
a : α
b : β
inst✝ : DecidableEq β
ht : s.Nonempty
i : β
⊢ i ∈ image Prod.snd (s ×ˢ t) ↔ i ∈ t
state_after: no goals
tactic: simp [mem_image, ht.exists_mem]
Theorem: Multiset.prod_add
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 : ι → α
s t : Multiset α
l₁ l₂ : List α
⊢ (⟦l₁⟧ + ⟦l₂⟧).prod = prod ⟦l₁⟧ * prod ⟦l₂⟧
state_after: no goals
tactic: simp
Theorem: Finset.map_some_eraseNone
File: Mathlib/Data/Finset/Option.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq (Option α)
s : Finset (Option α)
⊢ map Embedding.some (eraseNone s) = s.erase none
state_after: no goals
tactic: rw [map_eq_image, Embedding.some_apply, image_some_eraseNone]
Theorem: LinearOrderedField.smul_Ico
File: Mathlib/Algebra/Order/Pointwise.lean

Proof steps:
state_before: α : Type u_1
K : Type u_2
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
⊢ r • Ico a b = Ico (r • a) (r • b)
state_after: case h
α : Type u_1
K : Type u_2
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ x ∈ r • Ico a b ↔ x ∈ Ico (r • a) (r • b)
tactic: ext x
state_before: case h
α : Type u_1
K : Type u_2
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ x ∈ r • Ico a b ↔ x ∈ Ico (r • a) (r • b)
state_after: case h
α : Type u_1
K : Type u_2
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ (∃ y, (a ≤ y ∧ y < b) ∧ r * y = x) ↔ r * a ≤ x ∧ x < r * b
tactic: simp only [mem_smul_set, smul_eq_mul, mem_Ico]
state_before: case h
α : Type u_1
K : Type u_2
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ (∃ y, (a ≤ y ∧ y < b) ∧ r * y = x) ↔ r * a ≤ x ∧ x < r * b
state_after: case h.mp
α : Type u_1
K : Type u_2
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ (∃ y, (a ≤ y ∧ y < b) ∧ r * y = x) → r * a ≤ x ∧ x < r * b

case h.mpr
α : Type u_1
K : Type u_2
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ r * a ≤ x ∧ x < r * b → ∃ y, (a ≤ y ∧ y < b) ∧ r * y = x
tactic: constructor
Theorem: Matrix.trace_diagonal
File: Mathlib/LinearAlgebra/Matrix/Trace.lean

Proof steps:
state_before: ι : Type u_1
m : Type u_2
n : Type u_3
p : Type u_4
α : Type u_5
R : Type u_6
S : Type u_7
inst✝⁵ : Fintype m
inst✝⁴ : Fintype n
inst✝³ : Fintype p
inst✝² : AddCommMonoid R
o : Type u_8
inst✝¹ : Fintype o
inst✝ : DecidableEq o
d : o → R
⊢ (diagonal d).trace = ∑ i : o, d i
state_after: no goals
tactic: simp only [trace, diag_apply, diagonal_apply_eq]
Theorem: RatFunc.denom_dvd
File: Mathlib/FieldTheory/RatFunc/Basic.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
x : RatFunc K
q : K[X]
hq : q ≠ 0
⊢ x.denom ∣ q ↔ ∃ p, x = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q
state_after: case mp
K : Type u
inst✝ : Field K
x : RatFunc K
q : K[X]
hq : q ≠ 0
⊢ x.denom ∣ q → ∃ p, x = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q

case mpr
K : Type u
inst✝ : Field K
x : RatFunc K
q : K[X]
hq : q ≠ 0
⊢ (∃ p, x = (algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q) → x.denom ∣ q
tactic: constructor
Theorem: Polynomial.linearIndependent_powers_iff_aeval
File: Mathlib/RingTheory/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
S : Type u_1
σ : Type v
M : Type w
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : M →ₗ[R] M
v : M
⊢ (LinearIndependent R fun n => (f ^ n) v) ↔ ∀ (p : R[X]), ((aeval f) p) v = 0 → p = 0
state_after: R : Type u
S : Type u_1
σ : Type v
M : Type w
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : M →ₗ[R] M
v : M
⊢ (∀ (l : ℕ →₀ R), (Finsupp.total ℕ M R fun n => (f ^ n) v) l = 0 → l = 0) ↔ ∀ (p : R[X]), ((aeval f) p) v = 0 → p = 0
tactic: rw [linearIndependent_iff]
state_before: R : Type u
S : Type u_1
σ : Type v
M : Type w
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : M →ₗ[R] M
v : M
⊢ (∀ (l : ℕ →₀ R), (Finsupp.total ℕ M R fun n => (f ^ n) v) l = 0 → l = 0) ↔ ∀ (p : R[X]), ((aeval f) p) v = 0 → p = 0
state_after: R : Type u
S : Type u_1
σ : Type v
M : Type w
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : M →ₗ[R] M
v : M
⊢ (∀ (l : ℕ →₀ R), (l.sum fun i a => a • (f ^ i) v) = 0 → l = 0) ↔
    ∀ (q : AddMonoidAlgebra R ℕ), ({ toFinsupp := q }.sum fun n b => b • (f ^ n) v) = 0 → q = 0
tactic: simp only [Finsupp.total_apply, aeval_endomorphism, forall_iff_forall_finsupp, Sum, support,
    coeff, ofFinsupp_eq_zero]
state_before: R : Type u
S : Type u_1
σ : Type v
M : Type w
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : M →ₗ[R] M
v : M
⊢ (∀ (l : ℕ →₀ R), (l.sum fun i a => a • (f ^ i) v) = 0 → l = 0) ↔
    ∀ (q : AddMonoidAlgebra R ℕ), ({ toFinsupp := q }.sum fun n b => b • (f ^ n) v) = 0 → q = 0
state_after: no goals
tactic: exact Iff.rfl
Theorem: monotoneOn_of_deriv_nonneg
File: Mathlib/Analysis/Calculus/MeanValue.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : DifferentiableOn ℝ f (interior D)
hf'_nonneg : ∀ x ∈ interior D, 0 ≤ deriv f x
x : ℝ
hx : x ∈ D
y : ℝ
hy : y ∈ D
hxy : x ≤ y
⊢ f x ≤ f y
state_after: no goals
tactic: simpa only [zero_mul, sub_nonneg] using
    hD.mul_sub_le_image_sub_of_le_deriv hf hf' hf'_nonneg x hx y hy hxy
Theorem: Function.periodicOrbit_length
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
⊢ (periodicOrbit f x).length = minimalPeriod f x
state_after: no goals
tactic: rw [periodicOrbit, Cycle.length_coe, List.length_map, List.length_range]
Theorem: jacobiSym.neg
File: Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean

Proof steps:
state_before: a : ℤ
b : ℕ
hb : Odd b
⊢ J(-a | b) = χ₄ ↑b * J(a | b)
state_after: no goals
tactic: rw [neg_eq_neg_one_mul, mul_left, at_neg_one hb]
Theorem: finprod_mem_eq_toFinset_prod
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f : α → M
s : Set α
inst✝ : Fintype ↑s
⊢ s ∩ mulSupport f = ↑s.toFinset ∩ mulSupport f
state_after: no goals
tactic: simp_rw [coe_toFinset s]
Theorem: Complex.inv_Gammaℝ_one_sub
File: Mathlib/Analysis/SpecialFunctions/Gamma/Deligne.lean

Proof steps:
state_before: s : ℂ
hs : ∀ (n : ℕ), s ≠ -↑n
⊢ (1 - s).Gammaℝ⁻¹ = s.Gammaℂ * cos (↑π * s / 2) * s.Gammaℝ⁻¹
state_after: s : ℂ
hs : ∀ (n : ℕ), s ≠ -↑n
h1 : s.Gammaℝ ≠ 0
⊢ (1 - s).Gammaℝ⁻¹ = s.Gammaℂ * cos (↑π * s / 2) * s.Gammaℝ⁻¹
tactic: have h1 : Gammaℝ s ≠ 0 := by
    rw [Ne, Gammaℝ_eq_zero_iff, not_exists]
    intro n h
    specialize hs (2 * n)
    simp_all
state_before: s : ℂ
hs : ∀ (n : ℕ), s ≠ -↑n
h1 : s.Gammaℝ ≠ 0
⊢ (1 - s).Gammaℝ⁻¹ = s.Gammaℂ * cos (↑π * s / 2) * s.Gammaℝ⁻¹
state_after: s : ℂ
hs : ∀ (n : ℕ), s ≠ -↑n
h1 : s.Gammaℝ ≠ 0
h2 : ∀ (n : ℕ), s ≠ -(2 * ↑n + 1)
⊢ (1 - s).Gammaℝ⁻¹ = s.Gammaℂ * cos (↑π * s / 2) * s.Gammaℝ⁻¹
tactic: have h2 : ∀ (n : ℕ), s ≠ -(2 * ↑n + 1) := by
    intro n h
    specialize hs (2 * n + 1)
    simp_all
state_before: s : ℂ
hs : ∀ (n : ℕ), s ≠ -↑n
h1 : s.Gammaℝ ≠ 0
h2 : ∀ (n : ℕ), s ≠ -(2 * ↑n + 1)
⊢ (1 - s).Gammaℝ⁻¹ = s.Gammaℂ * cos (↑π * s / 2) * s.Gammaℝ⁻¹
state_after: no goals
tactic: rw [← Gammaℝ_div_Gammaℝ_one_sub h2, ← div_eq_mul_inv, div_right_comm, div_self h1, one_div]
Theorem: Projectivization.Subspace.mem_span
File: Mathlib/LinearAlgebra/Projectivization/Subspace.lean

Proof steps:
state_before: K : Type u_1
V : Type u_2
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
S : Set (ℙ K V)
u : ℙ K V
⊢ u ∈ span S ↔ ∀ (W : Subspace K V), S ⊆ ↑W → u ∈ W
state_after: K : Type u_1
V : Type u_2
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
S : Set (ℙ K V)
u : ℙ K V
⊢ u ∈ span S ↔ ∀ (W : Subspace K V), span S ≤ W → u ∈ W
tactic: simp_rw [← span_le_subspace_iff]
state_before: K : Type u_1
V : Type u_2
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
S : Set (ℙ K V)
u : ℙ K V
⊢ u ∈ span S ↔ ∀ (W : Subspace K V), span S ≤ W → u ∈ W
state_after: no goals
tactic: exact ⟨fun hu W hW => hW hu, fun W => W (span S) (le_refl _)⟩