ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsCyclotomicExtension.Rat.cyclotomicRing_isIntegralClosure_of_prime_pow
File: Mathlib/NumberTheory/Cyclotomic/Rat.lean

Proof steps:
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
⊢ IsIntegralClosure (CyclotomicRing (p ^ k) ℤ ℚ) ℤ (CyclotomicField (p ^ k) ℚ)
state_after: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hζ : IsPrimitiveRoot (zeta (p ^ k) ℚ (CyclotomicField (p ^ k) ℚ)) ↑(p ^ k)
⊢ IsIntegralClosure (CyclotomicRing (p ^ k) ℤ ℚ) ℤ (CyclotomicField (p ^ k) ℚ)
tactic: have hζ := zeta_spec (p ^ k) ℚ (CyclotomicField (p ^ k) ℚ)
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hζ : IsPrimitiveRoot (zeta (p ^ k) ℚ (CyclotomicField (p ^ k) ℚ)) ↑(p ^ k)
⊢ IsIntegralClosure (CyclotomicRing (p ^ k) ℤ ℚ) ℤ (CyclotomicField (p ^ k) ℚ)
state_after: case refine_1
p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hζ : IsPrimitiveRoot (zeta (p ^ k) ℚ (CyclotomicField (p ^ k) ℚ)) ↑(p ^ k)
x : CyclotomicField (p ^ k) ℚ
h : IsIntegral ℤ x
⊢ x ∈ adjoin ℤ {b | b ^ ↑(p ^ k) = 1}

case refine_2
p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hζ : IsPrimitiveRoot (zeta (p ^ k) ℚ (CyclotomicField (p ^ k) ℚ)) ↑(p ^ k)
x : CyclotomicField (p ^ k) ℚ
⊢ (∃ y, (algebraMap (CyclotomicRing (p ^ k) ℤ ℚ) (CyclotomicField (p ^ k) ℚ)) y = x) → IsIntegral ℤ x
tactic: refine ⟨IsFractionRing.injective _ _, @fun x => ⟨fun h => ⟨⟨x, ?_⟩, rfl⟩, ?_⟩⟩
Theorem: norm_div_pos_iff
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : NormedGroup E
inst✝ : NormedGroup F
a b : E
⊢ 0 < ‖a / b‖ ↔ a ≠ b
state_after: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : NormedGroup E
inst✝ : NormedGroup F
a b : E
⊢ ‖a / b‖ ≠ 0 ↔ a ≠ b
tactic: rw [(norm_nonneg' _).lt_iff_ne, ne_comm]
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : NormedGroup E
inst✝ : NormedGroup F
a b : E
⊢ ‖a / b‖ ≠ 0 ↔ a ≠ b
state_after: no goals
tactic: exact norm_div_eq_zero_iff.not
Theorem: LieSubalgebra.to_submodule_injective
File: Mathlib/Algebra/Lie/Subalgebra.lean

Proof steps:
state_before: R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
L' L₁' L₂' : LieSubalgebra R L
h : L₁'.toSubmodule = L₂'.toSubmodule
⊢ L₁' = L₂'
state_after: R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
L' L₁' L₂' : LieSubalgebra R L
h : ↑L₁'.toSubmodule = ↑L₂'.toSubmodule
⊢ L₁' = L₂'
tactic: rw [SetLike.ext'_iff] at h
state_before: R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
L' L₁' L₂' : LieSubalgebra R L
h : ↑L₁'.toSubmodule = ↑L₂'.toSubmodule
⊢ L₁' = L₂'
state_after: R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
L' L₁' L₂' : LieSubalgebra R L
h : ↑L₁'.toSubmodule = ↑L₂'.toSubmodule
⊢ ↑L₁' = ↑L₂'
tactic: rw [← coe_set_eq]
state_before: R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
L' L₁' L₂' : LieSubalgebra R L
h : ↑L₁'.toSubmodule = ↑L₂'.toSubmodule
⊢ ↑L₁' = ↑L₂'
state_after: no goals
tactic: exact h
Theorem: Stream'.Seq.append_assoc
File: Mathlib/Data/Seq/Seq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s t u : Seq α
⊢ (s.append t).append u = s.append (t.append u)
state_after: case bisim
α : Type u
β : Type v
γ : Type w
s t u : Seq α
⊢ IsBisimulation fun s1 s2 => ∃ s t u, s1 = (s.append t).append u ∧ s2 = s.append (t.append u)

case r
α : Type u
β : Type v
γ : Type w
s t u : Seq α
⊢ ∃ s_1 t_1 u_1,
    (s.append t).append u = (s_1.append t_1).append u_1 ∧ s.append (t.append u) = s_1.append (t_1.append u_1)
tactic: apply eq_of_bisim fun s1 s2 => ∃ s t u, s1 = append (append s t) u ∧ s2 = append s (append t u)
Theorem: sub_le_iff_le_add'
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a / b ≤ c ↔ a ≤ b * c
state_after: no goals
tactic: rw [div_le_iff_le_mul, mul_comm]
Theorem: LinearMap.range_coprod
File: Mathlib/LinearAlgebra/Prod.lean

Proof steps:
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommMonoid M₃
inst✝⁴ : AddCommMonoid M₄
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M₄
f : M →ₗ[R] M₃
g : M₂ →ₗ[R] M₃
x : M₃
⊢ x ∈ range (f.coprod g) ↔ x ∈ range f ⊔ range g
state_after: no goals
tactic: simp [mem_sup]
Theorem: CategoryTheory.ShortComplex.HomologyData.right_homologyIso_eq_left_homologyIso_trans_iso
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
h : S.HomologyData
inst✝ : S.HasHomology
⊢ h.right.homologyIso = h.left.homologyIso ≪≫ h.iso
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
h : S.HomologyData
inst✝ : S.HasHomology
⊢ h.iso = h.left.homologyIso.symm ≪≫ h.right.homologyIso
tactic: suffices h.iso = h.left.homologyIso.symm ≪≫ h.right.homologyIso by
    rw [this, Iso.self_symm_id_assoc]
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
h : S.HomologyData
inst✝ : S.HasHomology
⊢ h.iso = h.left.homologyIso.symm ≪≫ h.right.homologyIso
state_after: case w
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
h : S.HomologyData
inst✝ : S.HasHomology
⊢ h.iso.hom = (h.left.homologyIso.symm ≪≫ h.right.homologyIso).hom
tactic: ext
state_before: case w
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
h : S.HomologyData
inst✝ : S.HasHomology
⊢ h.iso.hom = (h.left.homologyIso.symm ≪≫ h.right.homologyIso).hom
state_after: case w
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
h : S.HomologyData
inst✝ : S.HasHomology
⊢ h.iso.hom = h.left.homologyIso.inv ≫ h.right.homologyIso.hom
tactic: dsimp
state_before: case w
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
h : S.HomologyData
inst✝ : S.HasHomology
⊢ h.iso.hom = h.left.homologyIso.inv ≫ h.right.homologyIso.hom
state_after: no goals
tactic: rw [← leftRightHomologyComparison'_fac, leftRightHomologyComparison'_eq]
Theorem: Real.sinh_log
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

Proof steps:
state_before: x✝ y x : ℝ
hx : 0 < x
⊢ sinh (log x) = (x - x⁻¹) / 2
state_after: no goals
tactic: rw [sinh_eq, exp_neg, exp_log hx]
Theorem: Finset.shatterer_mono
File: Mathlib/Combinatorics/SetFamily/Shatter.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s t : Finset α
a : α
n : ℕ
h : 𝒜 ⊆ ℬ
x✝ : Finset α
⊢ x✝ ∈ 𝒜.shatterer → x✝ ∈ ℬ.shatterer
state_after: no goals
tactic: simpa using Shatters.mono_left h
Theorem: Polynomial.monomial_neg
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Ring R
n : ℕ
a : R
⊢ (monomial n) (-a) = -(monomial n) a
state_after: no goals
tactic: rw [eq_neg_iff_add_eq_zero, ← monomial_add, neg_add_self, monomial_zero_right]
Theorem: CategoryTheory.Discrete.natIso_inv_app
File: Mathlib/CategoryTheory/DiscreteCategory.lean

Proof steps:
state_before: α : Type u₁
C : Type u₂
inst✝ : Category.{v₂, u₂} C
I : Type u₁
F G : Discrete I ⥤ C
f : (i : Discrete I) → F.obj i ≅ G.obj i
X✝ Y✝ : Discrete I
x✝ : X✝ ⟶ Y✝
g : X✝.as = Y✝.as
⊢ F.map { down := { down := g } } ≫ (f Y✝).hom = (f X✝).hom ≫ G.map { down := { down := g } }
state_after: case mk.mk.up.up
α : Type u₁
C : Type u₂
inst✝ : Category.{v₂, u₂} C
I : Type u₁
F G : Discrete I ⥤ C
f : (i : Discrete I) → F.obj i ≅ G.obj i
as✝¹ as✝ : I
g down✝ : { as := as✝¹ }.as = { as := as✝ }.as
⊢ F.map { down := { down := g } } ≫ (f { as := as✝ }).hom = (f { as := as✝¹ }).hom ≫ G.map { down := { down := g } }
tactic: discrete_cases
state_before: case mk.mk.up.up
α : Type u₁
C : Type u₂
inst✝ : Category.{v₂, u₂} C
I : Type u₁
F G : Discrete I ⥤ C
f : (i : Discrete I) → F.obj i ≅ G.obj i
as✝¹ as✝ : I
g down✝ : { as := as✝¹ }.as = { as := as✝ }.as
⊢ F.map { down := { down := g } } ≫ (f { as := as✝ }).hom = (f { as := as✝¹ }).hom ≫ G.map { down := { down := g } }
state_after: case mk.mk.up.up.refl
α : Type u₁
C : Type u₂
inst✝ : Category.{v₂, u₂} C
I : Type u₁
F G : Discrete I ⥤ C
f : (i : Discrete I) → F.obj i ≅ G.obj i
as✝ : I
down✝ : { as := as✝ }.as = { as := as✝ }.as
⊢ F.map { down := { down := ⋯ } } ≫ (f { as := as✝ }).hom = (f { as := as✝ }).hom ≫ G.map { down := { down := ⋯ } }
tactic: rcases g
state_before: case mk.mk.up.up.refl
α : Type u₁
C : Type u₂
inst✝ : Category.{v₂, u₂} C
I : Type u₁
F G : Discrete I ⥤ C
f : (i : Discrete I) → F.obj i ≅ G.obj i
as✝ : I
down✝ : { as := as✝ }.as = { as := as✝ }.as
⊢ F.map { down := { down := ⋯ } } ≫ (f { as := as✝ }).hom = (f { as := as✝ }).hom ≫ G.map { down := { down := ⋯ } }
state_after: case mk.mk.up.up.refl
α : Type u₁
C : Type u₂
inst✝ : Category.{v₂, u₂} C
I : Type u₁
F G : Discrete I ⥤ C
f : (i : Discrete I) → F.obj i ≅ G.obj i
as✝ : I
down✝ : { as := as✝ }.as = { as := as✝ }.as
⊢ F.map (𝟙 { as := as✝ }) ≫ (f { as := as✝ }).hom = (f { as := as✝ }).hom ≫ G.map (𝟙 { as := as✝ })
tactic: change F.map (𝟙 _) ≫ _ = _ ≫ G.map (𝟙 _)
state_before: case mk.mk.up.up.refl
α : Type u₁
C : Type u₂
inst✝ : Category.{v₂, u₂} C
I : Type u₁
F G : Discrete I ⥤ C
f : (i : Discrete I) → F.obj i ≅ G.obj i
as✝ : I
down✝ : { as := as✝ }.as = { as := as✝ }.as
⊢ F.map (𝟙 { as := as✝ }) ≫ (f { as := as✝ }).hom = (f { as := as✝ }).hom ≫ G.map (𝟙 { as := as✝ })
state_after: no goals
tactic: simp
Theorem: Real.tendsto_div_pow_mul_exp_add_atTop
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

Proof steps:
state_before: α : Type u_1
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
⊢ Tendsto (fun x => x ^ n / (b * rexp x + c)) atTop (𝓝 0)
state_after: α : Type u_1
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
H : ∀ (d e : ℝ), 0 < d → Tendsto (fun x => x ^ n / (d * rexp x + e)) atTop (𝓝 0)
⊢ Tendsto (fun x => x ^ n / (b * rexp x + c)) atTop (𝓝 0)
tactic: have H : ∀ d e, 0 < d → Tendsto (fun x : ℝ => x ^ n / (d * exp x + e)) atTop (𝓝 0) := by
    intro b' c' h
    convert (tendsto_mul_exp_add_div_pow_atTop b' c' n h).inv_tendsto_atTop using 1
    ext x
    simp
state_before: α : Type u_1
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
H : ∀ (d e : ℝ), 0 < d → Tendsto (fun x => x ^ n / (d * rexp x + e)) atTop (𝓝 0)
⊢ Tendsto (fun x => x ^ n / (b * rexp x + c)) atTop (𝓝 0)
state_after: case inl
α : Type u_1
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
H : ∀ (d e : ℝ), 0 < d → Tendsto (fun x => x ^ n / (d * rexp x + e)) atTop (𝓝 0)
h : 0 < b
⊢ Tendsto (fun x => x ^ n / (b * rexp x + c)) atTop (𝓝 0)

case inr
α : Type u_1
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
H : ∀ (d e : ℝ), 0 < d → Tendsto (fun x => x ^ n / (d * rexp x + e)) atTop (𝓝 0)
h : 0 > b
⊢ Tendsto (fun x => x ^ n / (b * rexp x + c)) atTop (𝓝 0)
tactic: cases' lt_or_gt_of_ne hb with h h
Theorem: CategoryTheory.Mat_.embedding_map
File: Mathlib/CategoryTheory/Preadditive/Mat.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Preadditive C
x✝ : C
⊢ { obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map (𝟙 x✝) =
    𝟙 ({ obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.obj x✝)
state_after: case H.unit
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Preadditive C
x✝ : C
j✝ : ({ obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.obj x✝).ι
⊢ { obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map (𝟙 x✝) PUnit.unit j✝ =
    𝟙 ({ obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.obj x✝) PUnit.unit j✝
tactic: ext ⟨⟩
state_before: case H.unit
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Preadditive C
x✝ : C
j✝ : ({ obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.obj x✝).ι
⊢ { obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map (𝟙 x✝) PUnit.unit j✝ =
    𝟙 ({ obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.obj x✝) PUnit.unit j✝
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Preadditive C
X✝ Y✝ Z✝ : C
x✝¹ : X✝ ⟶ Y✝
x✝ : Y✝ ⟶ Z✝
⊢ { obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map (x✝¹ ≫ x✝) =
    { obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map x✝¹ ≫
      { obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map x✝
state_after: case H.unit
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Preadditive C
X✝ Y✝ Z✝ : C
x✝¹ : X✝ ⟶ Y✝
x✝ : Y✝ ⟶ Z✝
j✝ : ({ obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.obj Z✝).ι
⊢ { obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map (x✝¹ ≫ x✝) PUnit.unit j✝ =
    ({ obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map x✝¹ ≫
        { obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map x✝)
      PUnit.unit j✝
tactic: ext ⟨⟩
state_before: case H.unit
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Preadditive C
X✝ Y✝ Z✝ : C
x✝¹ : X✝ ⟶ Y✝
x✝ : Y✝ ⟶ Z✝
j✝ : ({ obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.obj Z✝).ι
⊢ { obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map (x✝¹ ≫ x✝) PUnit.unit j✝ =
    ({ obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map x✝¹ ≫
        { obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map x✝)
      PUnit.unit j✝
state_after: no goals
tactic: simp
Theorem: PNat.card_fintype_Ico
File: Mathlib/Data/PNat/Interval.lean

Proof steps:
state_before: a b : ℕ+
⊢ Fintype.card ↑(Set.Ico a b) = ↑b - ↑a
state_after: no goals
tactic: rw [← card_Ico, Fintype.card_ofFinset]
Theorem: le_inv
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
hb : 0 < b
⊢ a ≤ b⁻¹ ↔ b ≤ a⁻¹
state_after: no goals
tactic: rw [← inv_le_inv (inv_pos (α := α) |>.2 hb) ha, inv_inv]
Theorem: CategoryTheory.cokernel_zero_of_nonzero_to_simple
File: Mathlib/CategoryTheory/Simple.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
X Y : C
inst✝ : Simple Y
f : X ⟶ Y
w : f ≠ 0
⊢ cokernel.π f = 0
state_after: no goals
tactic: classical
    by_contra h
    haveI := isIso_of_epi_of_nonzero h
    exact w (eq_zero_of_mono_cokernel f)
Theorem: HurwitzZeta.hasSum_int_evenKernel
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a t : ℝ
ht : 0 < t
⊢ HasSum (fun n => rexp (-π * (↑n + a) ^ 2 * t)) (evenKernel (↑a) t)
state_after: a t : ℝ
ht : 0 < t
⊢ HasSum (fun x => ↑(rexp (-π * (↑x + a) ^ 2 * t))) (cexp (-↑π * ↑a ^ 2 * ↑t) * jacobiTheta₂ (↑a * I * ↑t) (I * ↑t))
tactic: rw [← hasSum_ofReal, evenKernel_def]
state_before: a t : ℝ
ht : 0 < t
⊢ HasSum (fun x => ↑(rexp (-π * (↑x + a) ^ 2 * t))) (cexp (-↑π * ↑a ^ 2 * ↑t) * jacobiTheta₂ (↑a * I * ↑t) (I * ↑t))
state_after: a t : ℝ
ht : 0 < t
this :
  ∀ (n : ℤ), ↑(rexp (-π * (↑n + a) ^ 2 * t)) = cexp (-↑π * ↑a ^ 2 * ↑t) * jacobiTheta₂_term n (↑a * I * ↑t) (I * ↑t)
⊢ HasSum (fun x => ↑(rexp (-π * (↑x + a) ^ 2 * t))) (cexp (-↑π * ↑a ^ 2 * ↑t) * jacobiTheta₂ (↑a * I * ↑t) (I * ↑t))
tactic: have (n : ℤ) : ↑(rexp (-π * (↑n + a) ^ 2 * t)) =
      cexp (-↑π * ↑a ^ 2 * ↑t) * jacobiTheta₂_term n (↑a * I * ↑t) (I * ↑t) := by
    rw [jacobiTheta₂_term, ← Complex.exp_add]
    push_cast
    congr
    ring_nf
    simp only [I_sq, mul_neg, neg_mul, mul_one]
state_before: a t : ℝ
ht : 0 < t
this :
  ∀ (n : ℤ), ↑(rexp (-π * (↑n + a) ^ 2 * t)) = cexp (-↑π * ↑a ^ 2 * ↑t) * jacobiTheta₂_term n (↑a * I * ↑t) (I * ↑t)
⊢ HasSum (fun x => ↑(rexp (-π * (↑x + a) ^ 2 * t))) (cexp (-↑π * ↑a ^ 2 * ↑t) * jacobiTheta₂ (↑a * I * ↑t) (I * ↑t))
state_after: a t : ℝ
ht : 0 < t
this :
  ∀ (n : ℤ), ↑(rexp (-π * (↑n + a) ^ 2 * t)) = cexp (-↑π * ↑a ^ 2 * ↑t) * jacobiTheta₂_term n (↑a * I * ↑t) (I * ↑t)
⊢ HasSum (fun x => cexp (-↑π * ↑a ^ 2 * ↑t) * jacobiTheta₂_term x (↑a * I * ↑t) (I * ↑t))
    (cexp (-↑π * ↑a ^ 2 * ↑t) * jacobiTheta₂ (↑a * I * ↑t) (I * ↑t))
tactic: simp only [this]
state_before: a t : ℝ
ht : 0 < t
this :
  ∀ (n : ℤ), ↑(rexp (-π * (↑n + a) ^ 2 * t)) = cexp (-↑π * ↑a ^ 2 * ↑t) * jacobiTheta₂_term n (↑a * I * ↑t) (I * ↑t)
⊢ HasSum (fun x => cexp (-↑π * ↑a ^ 2 * ↑t) * jacobiTheta₂_term x (↑a * I * ↑t) (I * ↑t))
    (cexp (-↑π * ↑a ^ 2 * ↑t) * jacobiTheta₂ (↑a * I * ↑t) (I * ↑t))
state_after: no goals
tactic: apply (hasSum_jacobiTheta₂_term _ (by rwa [I_mul_im, ofReal_re])).mul_left
Theorem: MeasureTheory.Measure.rnDeriv_smul_right_of_ne_top'
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ ν μ : Measure α
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
r : ℝ≥0∞
hr : r ≠ 0
hr_ne_top : r ≠ ⊤
⊢ ν.rnDeriv (r • μ) =ᶠ[ae μ] r⁻¹ • ν.rnDeriv μ
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ ν μ : Measure α
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
r : ℝ≥0∞
hr : r ≠ 0
hr_ne_top : r ≠ ⊤
h : ν.rnDeriv (r.toNNReal • μ) =ᶠ[ae μ] r.toNNReal⁻¹ • ν.rnDeriv μ
⊢ ν.rnDeriv (r • μ) =ᶠ[ae μ] r⁻¹ • ν.rnDeriv μ
tactic: have h : ν.rnDeriv (r.toNNReal • μ) =ᵐ[μ] r.toNNReal⁻¹ • ν.rnDeriv μ := by
    refine rnDeriv_smul_right' ν μ ?_
    rw [ne_eq, ENNReal.toNNReal_eq_zero_iff]
    simp [hr, hr_ne_top]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ ν μ : Measure α
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
r : ℝ≥0∞
hr : r ≠ 0
hr_ne_top : r ≠ ⊤
h : ν.rnDeriv (r.toNNReal • μ) =ᶠ[ae μ] r.toNNReal⁻¹ • ν.rnDeriv μ
⊢ ν.rnDeriv (r • μ) =ᶠ[ae μ] r⁻¹ • ν.rnDeriv μ
state_after: no goals
tactic: rwa [ENNReal.smul_def, ENNReal.coe_toNNReal hr_ne_top,
    ← ENNReal.toNNReal_inv, ENNReal.smul_def, ENNReal.coe_toNNReal (ENNReal.inv_ne_top.mpr hr)] at h
Theorem: abs_pos
File: Mathlib/Algebra/Order/Group/Unbundled/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Group α
inst✝¹ : LinearOrder α
a✝ b✝ : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ 1 < mabs a ↔ a ≠ 1
state_after: case inl
α : Type u_1
inst✝² : Group α
inst✝¹ : LinearOrder α
a✝ b✝ : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
ha : a < 1
⊢ 1 < mabs a ↔ a ≠ 1

case inr.inl
α : Type u_1
inst✝² : Group α
inst✝¹ : LinearOrder α
a b✝ : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
b c : α
⊢ 1 < mabs 1 ↔ 1 ≠ 1

case inr.inr
α : Type u_1
inst✝² : Group α
inst✝¹ : LinearOrder α
a✝ b✝ : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
ha : 1 < a
⊢ 1 < mabs a ↔ a ≠ 1
tactic: obtain ha | rfl | ha := lt_trichotomy a 1
Theorem: closedEmbedding_of_spaced_out
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

Proof steps:
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝⁵ : UniformSpace α✝
inst✝⁴ : UniformSpace β
inst✝³ : UniformSpace γ
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : DiscreteTopology α
inst✝ : T0Space β
f : α → β
s : Set (β × β)
hs : s ∈ 𝓤 β
hf : Pairwise fun x y => (f x, f y) ∉ s
⊢ ClosedEmbedding f
state_after: α✝ : Type u
β : Type v
γ : Type w
inst✝⁴ : UniformSpace α✝
inst✝³ : UniformSpace β
inst✝² : UniformSpace γ
α : Type u_1
inst✝¹ : T0Space β
f : α → β
s : Set (β × β)
hs : s ∈ 𝓤 β
hf : Pairwise fun x y => (f x, f y) ∉ s
inst✝ : DiscreteTopology α
⊢ ClosedEmbedding f
tactic: rcases @DiscreteTopology.eq_bot α _ _ with rfl
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝⁴ : UniformSpace α✝
inst✝³ : UniformSpace β
inst✝² : UniformSpace γ
α : Type u_1
inst✝¹ : T0Space β
f : α → β
s : Set (β × β)
hs : s ∈ 𝓤 β
hf : Pairwise fun x y => (f x, f y) ∉ s
inst✝ : DiscreteTopology α
⊢ ClosedEmbedding f
state_after: α✝ : Type u
β : Type v
γ : Type w
inst✝⁴ : UniformSpace α✝
inst✝³ : UniformSpace β
inst✝² : UniformSpace γ
α : Type u_1
inst✝¹ : T0Space β
f : α → β
s : Set (β × β)
hs : s ∈ 𝓤 β
hf : Pairwise fun x y => (f x, f y) ∉ s
inst✝ : DiscreteTopology α
x✝ : UniformSpace α := ⊥
⊢ ClosedEmbedding f
tactic: let _ : UniformSpace α := ⊥
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝⁴ : UniformSpace α✝
inst✝³ : UniformSpace β
inst✝² : UniformSpace γ
α : Type u_1
inst✝¹ : T0Space β
f : α → β
s : Set (β × β)
hs : s ∈ 𝓤 β
hf : Pairwise fun x y => (f x, f y) ∉ s
inst✝ : DiscreteTopology α
x✝ : UniformSpace α := ⊥
⊢ ClosedEmbedding f
state_after: no goals
tactic: exact
    { (uniformEmbedding_of_spaced_out hs hf).embedding with
      isClosed_range := isClosed_range_of_spaced_out hs hf }
Theorem: Complex.conj_eq_iff_real
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
x✝ : ∃ r, z = ↑r
h : ℝ
e : z = ↑h
⊢ (starRingEnd ℂ) z = z
state_after: no goals
tactic: rw [e, conj_ofReal]
Theorem: Filter.HasBasis.inf_principal
File: Mathlib/Order/Filter/Bases.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s'✝ : ι' → Set α
i' : ι'
hl : l.HasBasis p s
s' t : Set α
⊢ t ∈ l ⊓ 𝓟 s' ↔ ∃ i, p i ∧ s i ∩ s' ⊆ t
state_after: no goals
tactic: simp only [mem_inf_principal, hl.mem_iff, subset_def, mem_setOf_eq, mem_inter_iff, and_imp]
Theorem: Finsupp.support_indicator_subset
File: Mathlib/Data/Finsupp/Indicator.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i : ι
⊢ ↑(indicator s f).support ⊆ ↑s
state_after: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i✝ i : ι
hi : i ∈ ↑(indicator s f).support
⊢ i ∈ ↑s
tactic: intro i hi
state_before: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i✝ i : ι
hi : i ∈ ↑(indicator s f).support
⊢ i ∈ ↑s
state_after: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i✝ i : ι
hi : (indicator s f) i ≠ 0
⊢ i ∈ ↑s
tactic: rw [mem_coe, mem_support_iff] at hi
state_before: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i✝ i : ι
hi : (indicator s f) i ≠ 0
⊢ i ∈ ↑s
state_after: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i✝ i : ι
hi : (indicator s f) i ≠ 0
h : i ∉ ↑s
⊢ False
tactic: by_contra h
state_before: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i✝ i : ι
hi : (indicator s f) i ≠ 0
h : i ∉ ↑s
⊢ False
state_after: no goals
tactic: exact hi (indicator_of_not_mem h _)