ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: least_descending_central_series_length_eq_nilpotencyClass
File: Mathlib/GroupTheory/Nilpotent.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
hG : Group.IsNilpotent G
⊢ Nat.find ⋯ = Group.nilpotencyClass G
state_after: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
hG : Group.IsNilpotent G
⊢ Nat.find ⋯ = Nat.find ⋯
tactic: rw [← least_ascending_central_series_length_eq_nilpotencyClass]
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
hG : Group.IsNilpotent G
⊢ Nat.find ⋯ = Nat.find ⋯
state_after: case refine_1
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
hG : Group.IsNilpotent G
⊢ ∀ (n : ℕ), (∃ H, IsAscendingCentralSeries H ∧ H n = ⊤) → ∃ H, IsDescendingCentralSeries H ∧ H n = ⊥

case refine_2
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
hG : Group.IsNilpotent G
⊢ ∀ (n : ℕ), (∃ H, IsDescendingCentralSeries H ∧ H n = ⊥) → ∃ H, IsAscendingCentralSeries H ∧ H n = ⊤
tactic: refine le_antisymm (Nat.find_mono ?_) (Nat.find_mono ?_)
Theorem: PowerSeries.order_monomial
File: Mathlib/RingTheory/PowerSeries/Order.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : Semiring R
φ : R⟦X⟧
n : ℕ
a : R
inst✝ : Decidable (a = 0)
⊢ ((monomial R n) a).order = if a = 0 then ⊤ else ↑n
state_after: case pos
R : Type u_1
inst✝¹ : Semiring R
φ : R⟦X⟧
n : ℕ
a : R
inst✝ : Decidable (a = 0)
h : a = 0
⊢ ((monomial R n) a).order = ⊤

case neg
R : Type u_1
inst✝¹ : Semiring R
φ : R⟦X⟧
n : ℕ
a : R
inst✝ : Decidable (a = 0)
h : ¬a = 0
⊢ ((monomial R n) a).order = ↑n
tactic: split_ifs with h
Theorem: Pell.Solution₁.x_ne_zero
File: Mathlib/NumberTheory/Pell.lean

Proof steps:
state_before: d : ℤ
h₀ : 0 ≤ d
a : Solution₁ d
⊢ a.x ≠ 0
state_after: d : ℤ
h₀ : 0 ≤ d
a : Solution₁ d
hx : a.x = 0
⊢ False
tactic: intro hx
state_before: d : ℤ
h₀ : 0 ≤ d
a : Solution₁ d
hx : a.x = 0
⊢ False
state_after: d : ℤ
h₀ : 0 ≤ d
a : Solution₁ d
hx : a.x = 0
h : 0 ≤ d * a.y ^ 2
⊢ False
tactic: have h : 0 ≤ d * a.y ^ 2 := mul_nonneg h₀ (sq_nonneg _)
state_before: d : ℤ
h₀ : 0 ≤ d
a : Solution₁ d
hx : a.x = 0
h : 0 ≤ d * a.y ^ 2
⊢ False
state_after: d : ℤ
h₀ : 0 ≤ d
a : Solution₁ d
hx : a.x = 0
h : 0 ≤ -1
⊢ False
tactic: rw [a.prop_y, hx, sq, zero_mul, zero_sub] at h
state_before: d : ℤ
h₀ : 0 ≤ d
a : Solution₁ d
hx : a.x = 0
h : 0 ≤ -1
⊢ False
state_after: no goals
tactic: exact not_le.mpr (neg_one_lt_zero : (-1 : ℤ) < 0) h
Theorem: Profinite.epi_iff_surjective
File: Mathlib/Topology/Category/Profinite/Basic.lean

Proof steps:
state_before: X Y : Profinite
f : X ⟶ Y
⊢ Epi f ↔ Function.Surjective ⇑f
state_after: case mp
X Y : Profinite
f : X ⟶ Y
⊢ Epi f → Function.Surjective ⇑f

case mpr
X Y : Profinite
f : X ⟶ Y
⊢ Function.Surjective ⇑f → Epi f
tactic: constructor
Theorem: CategoryTheory.Monad.comparison_obj_a
File: Mathlib/CategoryTheory/Monad/Adjunction.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X : D
⊢ h.toMonad.μ.app (R.obj X) ≫ R.map (h.counit.app X) = h.toMonad.map (R.map (h.counit.app X)) ≫ R.map (h.counit.app X)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X : D
⊢ R.map (h.counit.app (L.obj (R.obj X))) ≫ R.map (h.counit.app X) =
    R.map (L.map (R.map (h.counit.app X))) ≫ R.map (h.counit.app X)
tactic: dsimp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X : D
⊢ R.map (h.counit.app (L.obj (R.obj X))) ≫ R.map (h.counit.app X) =
    R.map (L.map (R.map (h.counit.app X))) ≫ R.map (h.counit.app X)
state_after: no goals
tactic: rw [← R.map_comp, ← Adjunction.counit_naturality, R.map_comp]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X✝ Y✝ : D
f : X✝ ⟶ Y✝
⊢ h.toMonad.map (R.map f) ≫ ((fun X => { A := R.obj X, a := R.map (h.counit.app X), unit := ⋯, assoc := ⋯ }) Y✝).a =
    ((fun X => { A := R.obj X, a := R.map (h.counit.app X), unit := ⋯, assoc := ⋯ }) X✝).a ≫ R.map f
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X✝ Y✝ : D
f : X✝ ⟶ Y✝
⊢ R.map (L.map (R.map f)) ≫ R.map (h.counit.app Y✝) = R.map (h.counit.app X✝) ≫ R.map f
tactic: dsimp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
X✝ Y✝ : D
f : X✝ ⟶ Y✝
⊢ R.map (L.map (R.map f)) ≫ R.map (h.counit.app Y✝) = R.map (h.counit.app X✝) ≫ R.map f
state_after: no goals
tactic: rw [← R.map_comp, Adjunction.counit_naturality, R.map_comp]
Theorem: CategoryTheory.GrothendieckTopology.isIso_toSheafify
File: Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
⊢ IsIso (J.toSheafify P)
state_after: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
⊢ IsIso (J.toPlus P ≫ J.plusMap (J.toPlus P))
tactic: dsimp [toSheafify]
state_before: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
⊢ IsIso (J.toPlus P ≫ J.plusMap (J.toPlus P))
state_after: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
this : IsIso (J.toPlus P)
⊢ IsIso (J.toPlus P ≫ J.plusMap (J.toPlus P))
tactic: haveI := isIso_toPlus_of_isSheaf J P hP
state_before: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
this : IsIso (J.toPlus P)
⊢ IsIso (J.toPlus P ≫ J.plusMap (J.toPlus P))
state_after: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
this : IsIso (J.toPlus P)
⊢ IsIso (J.toPlus P ≫ (J.plusFunctor D).map (J.toPlus P))
tactic: change (IsIso (toPlus J P ≫ (J.plusFunctor D).map (toPlus J P)))
state_before: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
this : IsIso (J.toPlus P)
⊢ IsIso (J.toPlus P ≫ (J.plusFunctor D).map (J.toPlus P))
state_after: no goals
tactic: infer_instance
Theorem: topCatToLightCondSet_obj
File: Mathlib/Condensed/Light/TopComparison.lean

Proof steps:
state_before: X✝ Y✝ : TopCat
f : X✝ ⟶ Y✝
⊢ ∀ ⦃X Y : LightProfiniteᵒᵖ⦄ (f_1 : X ⟶ Y),
    ((fun X => X.toLightCondSet) X✝).val.map f_1 ≫ (fun x g => comp f g) Y =
      (fun x g => comp f g) X ≫ ((fun X => X.toLightCondSet) Y✝).val.map f_1
state_after: no goals
tactic: aesop
Theorem: FreeAbelianGroup.map_comp
File: Mathlib/GroupTheory/FreeAbelianGroup.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
x✝ : α
⊢ ((map g).comp (map f)) (of x✝) = (map (g ∘ f)) (of x✝)
state_after: no goals
tactic: simp [map]
Theorem: integral_inv
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

Proof steps:
state_before: a b : ℝ
n : ℕ
h : 0 ∉ [[a, b]]
⊢ ∫ (x : ℝ) in a..b, x⁻¹ = Real.log (b / a)
state_after: a b : ℝ
n : ℕ
h : 0 ∉ [[a, b]]
h' : ∀ x ∈ [[a, b]], x ≠ 0
⊢ ∫ (x : ℝ) in a..b, x⁻¹ = Real.log (b / a)
tactic: have h' := fun x (hx : x ∈ [[a, b]]) => ne_of_mem_of_not_mem hx h
state_before: a b : ℝ
n : ℕ
h : 0 ∉ [[a, b]]
h' : ∀ x ∈ [[a, b]], x ≠ 0
⊢ ∫ (x : ℝ) in a..b, x⁻¹ = Real.log (b / a)
state_after: no goals
tactic: rw [integral_deriv_eq_sub' _ deriv_log' (fun x hx => differentiableAt_log (h' x hx))
      (continuousOn_inv₀.mono <| subset_compl_singleton_iff.mpr h),
    log_div (h' b right_mem_uIcc) (h' a left_mem_uIcc)]
Theorem: CategoryTheory.ShortComplex.homologyι_comp_fromOpcycles
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝ : S.HasHomology
⊢ S.homologyι ≫ S.fromOpcycles = 0
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝ : S.HasHomology
⊢ (S.rightHomologyIso.inv ≫ S.rightHomologyι) ≫ S.fromOpcycles = 0
tactic: dsimp only [homologyι]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝ : S.HasHomology
⊢ (S.rightHomologyIso.inv ≫ S.rightHomologyι) ≫ S.fromOpcycles = 0
state_after: no goals
tactic: simp only [assoc, rightHomologyι_comp_fromOpcycles, comp_zero]
Theorem: nhds_def'
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x✝ : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
x : X
⊢ 𝓝 x = ⨅ s, ⨅ (_ : IsOpen s), ⨅ (_ : x ∈ s), 𝓟 s
state_after: no goals
tactic: simp only [nhds_def, mem_setOf_eq, @and_comm (x ∈ _), iInf_and]
Theorem: Algebra.TensorProduct.includeLeftRingHom_apply
File: Mathlib/RingTheory/TensorProduct/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
⊢ (↑{ toFun := fun a => a ⊗ₜ[R] 1, map_one' := ⋯, map_mul' := ⋯ }).toFun 0 = 0
state_after: no goals
tactic: simp
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
⊢ ∀ (x y : A),
    (↑{ toFun := fun a => a ⊗ₜ[R] 1, map_one' := ⋯, map_mul' := ⋯ }).toFun (x + y) =
      (↑{ toFun := fun a => a ⊗ₜ[R] 1, map_one' := ⋯, map_mul' := ⋯ }).toFun x +
        (↑{ toFun := fun a => a ⊗ₜ[R] 1, map_one' := ⋯, map_mul' := ⋯ }).toFun y
state_after: no goals
tactic: simp [add_tmul]
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
⊢ ∀ (x y : A),
    { toFun := fun a => a ⊗ₜ[R] 1, map_one' := ⋯ }.toFun (x * y) =
      { toFun := fun a => a ⊗ₜ[R] 1, map_one' := ⋯ }.toFun x * { toFun := fun a => a ⊗ₜ[R] 1, map_one' := ⋯ }.toFun y
state_after: no goals
tactic: simp
Theorem: LinearPMap.closure_def'
File: Mathlib/Topology/Algebra/Module/LinearPMap.lean

Proof steps:
state_before: R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : ¬f.IsClosable
⊢ f.closure = f
state_after: no goals
tactic: simp [closure, hf]
Theorem: nilpotencyClass_quotient_center
File: Mathlib/GroupTheory/Nilpotent.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
hH : Group.IsNilpotent G
⊢ Group.nilpotencyClass (G ⧸ center G) = Group.nilpotencyClass G - 1
state_after: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
hH : Group.IsNilpotent G
n : ℕ
hn : Group.nilpotencyClass G = n
⊢ Group.nilpotencyClass (G ⧸ center G) = n - 1
tactic: generalize hn : Group.nilpotencyClass G = n
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
hH : Group.IsNilpotent G
n : ℕ
hn : Group.nilpotencyClass G = n
⊢ Group.nilpotencyClass (G ⧸ center G) = n - 1
state_after: case zero
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
hH : Group.IsNilpotent G
hn : Group.nilpotencyClass G = 0
⊢ Group.nilpotencyClass (G ⧸ center G) = 0 - 1

case succ
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
hH : Group.IsNilpotent G
n : ℕ
hn : Group.nilpotencyClass G = n + 1
⊢ Group.nilpotencyClass (G ⧸ center G) = n + 1 - 1
tactic: rcases n with (rfl | n)
Theorem: Tropical.add_eq_iff
File: Mathlib/Algebra/Tropical/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : LinearOrder R
x y z : Tropical R
⊢ x + y = z ↔ x = z ∧ x ≤ y ∨ y = z ∧ y ≤ x
state_after: R : Type u
inst✝ : LinearOrder R
x y z : Tropical R
⊢ min (untrop x) (untrop y) = untrop z ↔ x = z ∧ x ≤ y ∨ y = z ∧ y ≤ x
tactic: rw [trop_add_def, trop_eq_iff_eq_untrop]
state_before: R : Type u
inst✝ : LinearOrder R
x y z : Tropical R
⊢ min (untrop x) (untrop y) = untrop z ↔ x = z ∧ x ≤ y ∨ y = z ∧ y ≤ x
state_after: no goals
tactic: simp [min_eq_iff]
Theorem: Set.forall_subtype_range_iff
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : ι → α
s t : Set α
p : ↑(range f) → Prop
H : ∀ (i : ι), p ⟨f i, ⋯⟩
x✝ : ↑(range f)
y : α
i : ι
hi : f i = y
⊢ p ⟨y, ⋯⟩
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : ι → α
s t : Set α
p : ↑(range f) → Prop
H : ∀ (i : ι), p ⟨f i, ⋯⟩
x✝ : ↑(range f)
i : ι
⊢ p ⟨f i, ⋯⟩
tactic: subst hi
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : ι → α
s t : Set α
p : ↑(range f) → Prop
H : ∀ (i : ι), p ⟨f i, ⋯⟩
x✝ : ↑(range f)
i : ι
⊢ p ⟨f i, ⋯⟩
state_after: no goals
tactic: apply H
Theorem: Euclidean.nhds_basis_ball
File: Mathlib/Analysis/InnerProductSpace/EuclideanDist.lean

Proof steps:
state_before: E : Type u_1
inst✝⁶ : AddCommGroup E
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : T2Space E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
⊢ (𝓝 x).HasBasis (fun r => 0 < r) (ball x)
state_after: E : Type u_1
inst✝⁶ : AddCommGroup E
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : T2Space E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
⊢ (Filter.comap (⇑toEuclidean.toHomeomorph) (𝓝 (toEuclidean.toHomeomorph x))).HasBasis (fun r => 0 < r) (ball x)
tactic: rw [toEuclidean.toHomeomorph.nhds_eq_comap x]
state_before: E : Type u_1
inst✝⁶ : AddCommGroup E
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : T2Space E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
⊢ (Filter.comap (⇑toEuclidean.toHomeomorph) (𝓝 (toEuclidean.toHomeomorph x))).HasBasis (fun r => 0 < r) (ball x)
state_after: no goals
tactic: exact Metric.nhds_basis_ball.comap _
Theorem: AffineBasis.exists_affineBasis_of_finiteDimensional
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

Proof steps:
state_before: ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : DivisionRing k
inst✝² : Module k V
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional k V
h : Fintype.card ι = FiniteDimensional.finrank k V + 1
⊢ Nonempty (AffineBasis ι k P)
state_after: case intro.intro
ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : DivisionRing k
inst✝² : Module k V
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional k V
h : Fintype.card ι = FiniteDimensional.finrank k V + 1
s : Set P
b : AffineBasis (↑s) k P
hb : ⇑b = Subtype.val
⊢ Nonempty (AffineBasis ι k P)
tactic: obtain ⟨s, b, hb⟩ := AffineBasis.exists_affineBasis k V P
state_before: case intro.intro
ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : DivisionRing k
inst✝² : Module k V
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional k V
h : Fintype.card ι = FiniteDimensional.finrank k V + 1
s : Set P
b : AffineBasis (↑s) k P
hb : ⇑b = Subtype.val
⊢ Nonempty (AffineBasis ι k P)
state_after: case intro.intro.intro
ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : DivisionRing k
inst✝² : Module k V
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional k V
h : Fintype.card ι = FiniteDimensional.finrank k V + 1
s : Finset P
b : AffineBasis (↑↑s) k P
hb : ⇑b = Subtype.val
⊢ Nonempty (AffineBasis ι k P)
tactic: lift s to Finset P using b.finite_set
state_before: case intro.intro.intro
ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : DivisionRing k
inst✝² : Module k V
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional k V
h : Fintype.card ι = FiniteDimensional.finrank k V + 1
s : Finset P
b : AffineBasis (↑↑s) k P
hb : ⇑b = Subtype.val
⊢ Nonempty (AffineBasis ι k P)
state_after: case intro.intro.intro
ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : DivisionRing k
inst✝² : Module k V
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional k V
h : Fintype.card ι = FiniteDimensional.finrank k V + 1
s : Finset P
b : AffineBasis (↑↑s) k P
hb : ⇑b = Subtype.val
⊢ Fintype.card ↑↑s = Fintype.card ι
tactic: refine ⟨b.reindex <| Fintype.equivOfCardEq ?_⟩
state_before: case intro.intro.intro
ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : DivisionRing k
inst✝² : Module k V
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional k V
h : Fintype.card ι = FiniteDimensional.finrank k V + 1
s : Finset P
b : AffineBasis (↑↑s) k P
hb : ⇑b = Subtype.val
⊢ Fintype.card ↑↑s = Fintype.card ι
state_after: no goals
tactic: rw [h, ← b.card_eq_finrank_add_one]
Theorem: Polynomial.IsSplittingField.of_algEquiv
File: Mathlib/FieldTheory/SplittingField/IsSplittingField.lean

Proof steps:
state_before: F : Type u
K : Type v
L : Type w
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Field F
inst✝² : Algebra K L
inst✝¹ : Algebra K F
p : K[X]
f : F ≃ₐ[K] L
inst✝ : IsSplittingField K F p
⊢ IsSplittingField K L p
state_after: case splits'
F : Type u
K : Type v
L : Type w
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Field F
inst✝² : Algebra K L
inst✝¹ : Algebra K F
p : K[X]
f : F ≃ₐ[K] L
inst✝ : IsSplittingField K F p
⊢ Splits (algebraMap K L) p

case adjoin_rootSet'
F : Type u
K : Type v
L : Type w
inst✝⁵ : Field K
inst✝⁴ : Field L
inst✝³ : Field F
inst✝² : Algebra K L
inst✝¹ : Algebra K F
p : K[X]
f : F ≃ₐ[K] L
inst✝ : IsSplittingField K F p
⊢ Algebra.adjoin K (p.rootSet L) = ⊤
tactic: constructor
Theorem: Finset.sigma_eq_biUnion
File: Mathlib/Data/Finset/Sigma.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
β : Type u_3
s✝ s₁ s₂ : Finset ι
t✝ t₁ t₂ : (i : ι) → Finset (α i)
inst✝ : DecidableEq ((i : ι) × α i)
s : Finset ι
t : (i : ι) → Finset (α i)
⊢ s.sigma t = s.biUnion fun i => map (Embedding.sigmaMk i) (t i)
state_after: case a.mk
ι : Type u_1
α : ι → Type u_2
β : Type u_3
s✝ s₁ s₂ : Finset ι
t✝ t₁ t₂ : (i : ι) → Finset (α i)
inst✝ : DecidableEq ((i : ι) × α i)
s : Finset ι
t : (i : ι) → Finset (α i)
x : ι
y : α x
⊢ ⟨x, y⟩ ∈ s.sigma t ↔ ⟨x, y⟩ ∈ s.biUnion fun i => map (Embedding.sigmaMk i) (t i)
tactic: ext ⟨x, y⟩
state_before: case a.mk
ι : Type u_1
α : ι → Type u_2
β : Type u_3
s✝ s₁ s₂ : Finset ι
t✝ t₁ t₂ : (i : ι) → Finset (α i)
inst✝ : DecidableEq ((i : ι) × α i)
s : Finset ι
t : (i : ι) → Finset (α i)
x : ι
y : α x
⊢ ⟨x, y⟩ ∈ s.sigma t ↔ ⟨x, y⟩ ∈ s.biUnion fun i => map (Embedding.sigmaMk i) (t i)
state_after: no goals
tactic: simp [and_left_comm]
Theorem: List.length_mapIdx
File: Mathlib/Data/List/Indexes.lean

Proof steps:
state_before: α : Type u
β : Type v
l : List α
f : ℕ → α → β
⊢ (mapIdx f l).length = l.length
state_after: case nil
α : Type u
β : Type v
f : ℕ → α → β
⊢ (mapIdx f []).length = [].length

case cons
α : Type u
β : Type v
hd : α
tl : List α
IH : ∀ (f : ℕ → α → β), (mapIdx f tl).length = tl.length
f : ℕ → α → β
⊢ (mapIdx f (hd :: tl)).length = (hd :: tl).length
tactic: induction' l with hd tl IH generalizing f
Theorem: Subsemigroup.prod_top
File: Mathlib/Algebra/Group/Subsemigroup/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
σ : Type u_4
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S s : Subsemigroup M
x : M × N
⊢ x ∈ s.prod ⊤ ↔ x ∈ comap (MulHom.fst M N) s
state_after: no goals
tactic: simp [mem_prod, MulHom.coe_fst]
Theorem: MvPolynomial.renameSymmetricSubalgebra_apply_coe
File: Mathlib/RingTheory/MvPolynomial/Symmetric.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
τ : Type u_3
S : Type u_4
inst✝ : CommSemiring R
e : σ ≃ τ
p : ↥(symmetricSubalgebra τ R)
⊢ ↑(((((rename ⇑e).comp (symmetricSubalgebra σ R).val).codRestrict (symmetricSubalgebra τ R) ⋯).comp
          (((rename ⇑e.symm).comp (symmetricSubalgebra τ R).val).codRestrict (symmetricSubalgebra σ R) ⋯))
        p) =
    ↑((AlgHom.id R ↥(symmetricSubalgebra τ R)) p)
state_after: no goals
tactic: simp
state_before: σ : Type u_1
R : Type u_2
τ : Type u_3
S : Type u_4
inst✝ : CommSemiring R
e : σ ≃ τ
p : ↥(symmetricSubalgebra σ R)
⊢ ↑(((((rename ⇑e.symm).comp (symmetricSubalgebra τ R).val).codRestrict (symmetricSubalgebra σ R) ⋯).comp
          (((rename ⇑e).comp (symmetricSubalgebra σ R).val).codRestrict (symmetricSubalgebra τ R) ⋯))
        p) =
    ↑((AlgHom.id R ↥(symmetricSubalgebra σ R)) p)
state_after: no goals
tactic: simp
Theorem: Ideal.associatesEquivIsPrincipal_map_zero
File: Mathlib/RingTheory/Ideal/IsPrincipal.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ ↑((associatesEquivIsPrincipal R) 0) = 0
state_after: no goals
tactic: rw [← mk_zero, associatesEquivIsPrincipal_apply, Submodule.zero_eq_bot, span_singleton_eq_bot]