ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: HurwitzZeta.isBigO_atTop_sinKernel
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

Proof steps:
state_before: a : UnitAddCircle
⊢ ∃ p, 0 < p ∧ sinKernel a =O[atTop] fun x => rexp (-p * x)
state_after: case H
a : ℝ
⊢ ∃ p, 0 < p ∧ sinKernel ↑a =O[atTop] fun x => rexp (-p * x)
tactic: induction' a using QuotientAddGroup.induction_on with a
state_before: case H
a : ℝ
⊢ ∃ p, 0 < p ∧ sinKernel ↑a =O[atTop] fun x => rexp (-p * x)
state_after: case H.intro.intro
a p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_nat 1 0 =O[atTop] fun t => rexp (-p * t)
⊢ ∃ p, 0 < p ∧ sinKernel ↑a =O[atTop] fun x => rexp (-p * x)
tactic: obtain ⟨p, hp, hp'⟩ := HurwitzKernelBounds.isBigO_atTop_F_nat_one (le_refl 0)
state_before: case H.intro.intro
a p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_nat 1 0 =O[atTop] fun t => rexp (-p * t)
⊢ ∃ p, 0 < p ∧ sinKernel ↑a =O[atTop] fun x => rexp (-p * x)
state_after: case H.intro.intro
a p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_nat 1 0 =O[atTop] fun t => rexp (-p * t)
⊢ ∀ᶠ (x : ℝ) in atTop, ‖sinKernel (↑a) x‖ ≤ 2 * HurwitzKernelBounds.F_nat 1 0 x
tactic: refine ⟨p, hp, (Eventually.isBigO ?_).trans (hp'.const_mul_left 2)⟩
state_before: case H.intro.intro
a p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_nat 1 0 =O[atTop] fun t => rexp (-p * t)
⊢ ∀ᶠ (x : ℝ) in atTop, ‖sinKernel (↑a) x‖ ≤ 2 * HurwitzKernelBounds.F_nat 1 0 x
state_after: case h
a p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_nat 1 0 =O[atTop] fun t => rexp (-p * t)
t : ℝ
ht : 0 < t
⊢ ‖sinKernel (↑a) t‖ ≤ 2 * HurwitzKernelBounds.F_nat 1 0 t
tactic: filter_upwards [eventually_gt_atTop 0] with t ht
state_before: case h
a p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_nat 1 0 =O[atTop] fun t => rexp (-p * t)
t : ℝ
ht : 0 < t
⊢ ‖sinKernel (↑a) t‖ ≤ 2 * HurwitzKernelBounds.F_nat 1 0 t
state_after: case h
a p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_nat 1 0 =O[atTop] fun t => rexp (-p * t)
t : ℝ
ht : 0 < t
⊢ ‖∑' (b : ℕ), 2 * ↑b * Real.sin (2 * π * a * ↑b) * rexp (-π * ↑b ^ 2 * t)‖ ≤
    2 * ∑' (n : ℕ), HurwitzKernelBounds.f_nat 1 0 t n
tactic: rw [HurwitzKernelBounds.F_nat, ← (hasSum_nat_sinKernel a ht).tsum_eq]
state_before: case h
a p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_nat 1 0 =O[atTop] fun t => rexp (-p * t)
t : ℝ
ht : 0 < t
⊢ ‖∑' (b : ℕ), 2 * ↑b * Real.sin (2 * π * a * ↑b) * rexp (-π * ↑b ^ 2 * t)‖ ≤
    2 * ∑' (n : ℕ), HurwitzKernelBounds.f_nat 1 0 t n
state_after: case h.hg
a p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_nat 1 0 =O[atTop] fun t => rexp (-p * t)
t : ℝ
ht : 0 < t
⊢ HasSum (fun n => 2 * HurwitzKernelBounds.f_nat 1 0 t n) (2 * ∑' (n : ℕ), HurwitzKernelBounds.f_nat 1 0 t n)

case h.h
a p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_nat 1 0 =O[atTop] fun t => rexp (-p * t)
t : ℝ
ht : 0 < t
⊢ ∀ (i : ℕ), ‖2 * ↑i * Real.sin (2 * π * a * ↑i) * rexp (-π * ↑i ^ 2 * t)‖ ≤ 2 * HurwitzKernelBounds.f_nat 1 0 t i
tactic: apply tsum_of_norm_bounded (g := fun n ↦ 2 * HurwitzKernelBounds.f_nat 1 0 t n)
Theorem: Subtype.restrict_apply
File: Mathlib/Data/Subtype.lean

Proof steps:
state_before: α✝ : Sort u_1
β✝ : Sort u_2
γ : Sort u_3
p✝ q : α✝ → Prop
α : Sort u_5
β : α → Type u_4
f : (x : α) → β x
p : α → Prop
x : Subtype p
⊢ restrict p f x = f ↑x
state_after: no goals
tactic: rfl
Theorem: AlgebraicGeometry.universally_isLocalAtTarget
File: Mathlib/AlgebraicGeometry/Morphisms/Constructors.lean

Proof steps:
state_before: P : MorphismProperty Scheme
hP₂ : ∀ {X Y : Scheme} (f : X ⟶ Y) {ι : Type u} (U : ι → Y.Opens), iSup U = ⊤ → (∀ (i : ι), P (f ∣_ U i)) → P f
⊢ IsLocalAtTarget P.universally
state_after: case restrict
P : MorphismProperty Scheme
hP₂ : ∀ {X Y : Scheme} (f : X ⟶ Y) {ι : Type u} (U : ι → Y.Opens), iSup U = ⊤ → (∀ (i : ι), P (f ∣_ U i)) → P f
⊢ ∀ {X Y : Scheme} (f : X ⟶ Y) (U : Y.Opens), P.universally f → P.universally (f ∣_ U)

case of_sSup_eq_top
P : MorphismProperty Scheme
hP₂ : ∀ {X Y : Scheme} (f : X ⟶ Y) {ι : Type u} (U : ι → Y.Opens), iSup U = ⊤ → (∀ (i : ι), P (f ∣_ U i)) → P f
⊢ ∀ {X Y : Scheme} (f : X ⟶ Y) {ι : Type u} (U : ι → Y.Opens),
    iSup U = ⊤ → (∀ (i : ι), P.universally (f ∣_ U i)) → P.universally f
tactic: apply IsLocalAtTarget.mk'
Theorem: List.suffix_iff_eq_append
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 : ℕ
⊢ l₁ <:+ l₂ → take (l₂.length - l₁.length) l₂ ++ l₁ = l₂
state_after: case intro
α : Type u_1
β : Type u_2
l l₁ l₃ : List α
a b : α
m n : ℕ
r : List α
⊢ take ((r ++ l₁).length - l₁.length) (r ++ l₁) ++ l₁ = r ++ l₁
tactic: rintro ⟨r, rfl⟩
state_before: case intro
α : Type u_1
β : Type u_2
l l₁ l₃ : List α
a b : α
m n : ℕ
r : List α
⊢ take ((r ++ l₁).length - l₁.length) (r ++ l₁) ++ l₁ = r ++ l₁
state_after: no goals
tactic: simp only [length_append, Nat.add_sub_cancel_right, take_left]
Theorem: ite_and
File: Mathlib/Logic/Basic.lean

Proof steps:
state_before: α : Sort u_1
σ : α → Sort u_2
P Q R : Prop
inst✝¹ : Decidable P
inst✝ : Decidable Q
a b c : α
A : P → α
B : ¬P → α
⊢ (if P ∧ Q then a else b) = if P then if Q then a else b else b
state_after: no goals
tactic: by_cases hp : P <;> by_cases hq : Q <;> simp [hp, hq]
Theorem: Finset.disjUnion_eq_union
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a✝ b : α
s t : Finset α
h : _root_.Disjoint s t
a : α
⊢ a ∈ s.disjUnion t h ↔ a ∈ s ∪ t
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_hom_comp
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

Proof steps:
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
F G : J ⥤ C
s : Cone F
t : Cone G
P : IsLimit s
Q : IsLimit t
w : F ≅ G
j : J
⊢ (P.conePointsIsoOfNatIso Q w).hom ≫ t.π.app j = s.π.app j ≫ w.hom.app j
state_after: no goals
tactic: simp
Theorem: intrinsicInterior_empty
File: Mathlib/Analysis/Convex/Intrinsic.lean

Proof steps:
state_before: 𝕜 : Type u_1
V : Type u_2
W : Type u_3
Q : Type u_4
P : Type u_5
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup V
inst✝² : Module 𝕜 V
inst✝¹ : TopologicalSpace P
inst✝ : AddTorsor V P
s t : Set P
x : P
⊢ intrinsicInterior 𝕜 ∅ = ∅
state_after: no goals
tactic: simp [intrinsicInterior]
Theorem: Set.MapsTo.restrict_inj
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
h : MapsTo f s t
⊢ Injective (restrict f s t h) ↔ InjOn f s
state_after: no goals
tactic: rw [h.restrict_eq_codRestrict, injective_codRestrict, injOn_iff_injective]
Theorem: CategoryTheory.MonoidalCategory.prodMonoidal_leftUnitor_inv_snd
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₁
C₂ : Type u₂
inst✝¹ : Category.{v₂, u₂} C₂
inst✝ : MonoidalCategory C₂
X : C₁ × C₂
⊢ (λ_ X).inv.2 = (λ_ X.2).inv
state_after: case mk
C : Type u
𝒞 : Category.{v, u} C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category.{v₁, u₁} C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category.{v₂, u₂} C₂
inst✝ : MonoidalCategory C₂
fst✝ : C₁
snd✝ : C₂
⊢ (λ_ (fst✝, snd✝)).inv.2 = (λ_ (fst✝, snd✝).2).inv
tactic: cases X
state_before: case mk
C : Type u
𝒞 : Category.{v, u} C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category.{v₁, u₁} C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category.{v₂, u₂} C₂
inst✝ : MonoidalCategory C₂
fst✝ : C₁
snd✝ : C₂
⊢ (λ_ (fst✝, snd✝)).inv.2 = (λ_ (fst✝, snd✝).2).inv
state_after: no goals
tactic: rfl
Theorem: OrthogonalFamily.summable_of_lp
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 : (i : ι) → G i →ₗᵢ[𝕜] E
hV : OrthogonalFamily 𝕜 G V
f : ↥(lp G 2)
⊢ Summable fun i => (V i) (↑f i)
state_after: ι : 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 : (i : ι) → G i →ₗᵢ[𝕜] E
hV : OrthogonalFamily 𝕜 G V
f : ↥(lp G 2)
⊢ Summable fun i => ‖↑f i‖ ^ 2
tactic: rw [hV.summable_iff_norm_sq_summable]
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 : (i : ι) → G i →ₗᵢ[𝕜] E
hV : OrthogonalFamily 𝕜 G V
f : ↥(lp G 2)
⊢ Summable fun i => ‖↑f i‖ ^ 2
state_after: case h.e'_5.h
ι : 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 : (i : ι) → G i →ₗᵢ[𝕜] E
hV : OrthogonalFamily 𝕜 G V
f : ↥(lp G 2)
x✝ : ι
⊢ ‖↑f x✝‖ ^ 2 = ‖↑f x✝‖ ^ ENNReal.toReal 2

ι : 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 : (i : ι) → G i →ₗᵢ[𝕜] E
hV : OrthogonalFamily 𝕜 G V
f : ↥(lp G 2)
⊢ 0 < ENNReal.toReal 2
tactic: convert (lp.memℓp f).summable _
Theorem: ENNReal.openEmbedding_coe
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ IsOpen (range ofNNReal)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ IsOpen (Iio ⊤)
tactic: rw [range_coe']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ IsOpen (Iio ⊤)
state_after: no goals
tactic: exact isOpen_Iio
Theorem: gramSchmidtOrthonormalBasis_inv_triangular
File: Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁷ : RCLike 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
ι : Type u_3
inst✝⁴ : LinearOrder ι
inst✝³ : LocallyFiniteOrderBot ι
inst✝² : IsWellOrder ι fun x x_1 => x < x_1
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional 𝕜 E
h : finrank 𝕜 E = Fintype.card ι
f : ι → E
i j : ι
hij : i < j
⊢ ⟪(gramSchmidtOrthonormalBasis h f) j, f i⟫_𝕜 = 0
state_after: case pos
𝕜 : Type u_1
E : Type u_2
inst✝⁷ : RCLike 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
ι : Type u_3
inst✝⁴ : LinearOrder ι
inst✝³ : LocallyFiniteOrderBot ι
inst✝² : IsWellOrder ι fun x x_1 => x < x_1
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional 𝕜 E
h : finrank 𝕜 E = Fintype.card ι
f : ι → E
i j : ι
hij : i < j
hi : gramSchmidtNormed 𝕜 f j = 0
⊢ ⟪(gramSchmidtOrthonormalBasis h f) j, f i⟫_𝕜 = 0

case neg
𝕜 : Type u_1
E : Type u_2
inst✝⁷ : RCLike 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
ι : Type u_3
inst✝⁴ : LinearOrder ι
inst✝³ : LocallyFiniteOrderBot ι
inst✝² : IsWellOrder ι fun x x_1 => x < x_1
inst✝¹ : Fintype ι
inst✝ : FiniteDimensional 𝕜 E
h : finrank 𝕜 E = Fintype.card ι
f : ι → E
i j : ι
hij : i < j
hi : ¬gramSchmidtNormed 𝕜 f j = 0
⊢ ⟪(gramSchmidtOrthonormalBasis h f) j, f i⟫_𝕜 = 0
tactic: by_cases hi : gramSchmidtNormed 𝕜 f j = 0
Theorem: Profinite.NobelingProof.GoodProducts.good_lt_maxProducts
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

Proof steps:
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
q : ↑(GoodProducts (π C fun x => ord I x < o))
l : ↑(MaxProducts C ho)
⊢ List.Lex (fun x x_1 => x < x_1) ↑↑q ↑↑l
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
q : ↑(GoodProducts (π C fun x => ord I x < o))
l : ↑(MaxProducts C ho)
this : Inhabited I
⊢ List.Lex (fun x x_1 => x < x_1) ↑↑q ↑↑l
tactic: have : Inhabited I := ⟨term I ho⟩
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
q : ↑(GoodProducts (π C fun x => ord I x < o))
l : ↑(MaxProducts C ho)
this : Inhabited I
⊢ List.Lex (fun x x_1 => x < x_1) ↑↑q ↑↑l
state_after: case pos
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
q : ↑(GoodProducts (π C fun x => ord I x < o))
l : ↑(MaxProducts C ho)
this : Inhabited I
h : ↑↑q = []
⊢ List.Lex (fun x x_1 => x < x_1) ↑↑q ↑↑l

case neg
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
q : ↑(GoodProducts (π C fun x => ord I x < o))
l : ↑(MaxProducts C ho)
this : Inhabited I
h : ¬↑↑q = []
⊢ List.Lex (fun x x_1 => x < x_1) ↑↑q ↑↑l
tactic: by_cases h : q.val.val = []
Theorem: LieSubmodule.toEnd_restrict_eq_toEnd
File: Mathlib/Algebra/Lie/OfAssociative.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
x : L
h : optParam (∀ (m : M) (hm : m ∈ ↑N), ((toEnd R L M) x ∘ₗ (↑N).subtype) ⟨m, hm⟩ ∈ ↑N) ⋯
⊢ LinearMap.restrict ((toEnd R L M) x) h = (toEnd R L ↥↑N) x
state_after: case h.a
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
x : L
h : optParam (∀ (m : M) (hm : m ∈ ↑N), ((toEnd R L M) x ∘ₗ (↑N).subtype) ⟨m, hm⟩ ∈ ↑N) ⋯
x✝ : ↥↑N
⊢ ↑((LinearMap.restrict ((toEnd R L M) x) h) x✝) = ↑(((toEnd R L ↥↑N) x) x✝)
tactic: ext
state_before: case h.a
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
x : L
h : optParam (∀ (m : M) (hm : m ∈ ↑N), ((toEnd R L M) x ∘ₗ (↑N).subtype) ⟨m, hm⟩ ∈ ↑N) ⋯
x✝ : ↥↑N
⊢ ↑((LinearMap.restrict ((toEnd R L M) x) h) x✝) = ↑(((toEnd R L ↥↑N) x) x✝)
state_after: no goals
tactic: simp [LinearMap.restrict_apply]
Theorem: Polynomial.IsPrimitive.ne_zero
File: Mathlib/RingTheory/Polynomial/Content.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Nontrivial R
p : R[X]
hp : p.IsPrimitive
⊢ p ≠ 0
state_after: R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Nontrivial R
hp : IsPrimitive 0
⊢ False
tactic: rintro rfl
state_before: R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Nontrivial R
hp : IsPrimitive 0
⊢ False
state_after: no goals
tactic: exact (hp 0 (dvd_zero (C 0))).ne_zero rfl
Theorem: MeasureTheory.Lp.nnnorm_eq_zero_iff
File: Mathlib/MeasureTheory/Function/LpSpace.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : ↥(Lp E p μ)
hp : 0 < p
⊢ ‖f‖₊ = 0 ↔ f = 0
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : ↥(Lp E p μ)
hp : 0 < p
hf : ‖f‖₊ = 0
⊢ f = 0
tactic: refine ⟨fun hf => ?_, fun hf => by simp [hf]⟩
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : ↥(Lp E p μ)
hp : 0 < p
hf : ‖f‖₊ = 0
⊢ f = 0
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : ↥(Lp E p μ)
hp : 0 < p
hf : eLpNorm (↑↑f) p μ = 0 ∨ eLpNorm (↑↑f) p μ = ⊤
⊢ f = 0
tactic: rw [nnnorm_def, ENNReal.toNNReal_eq_zero_iff] at hf
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : ↥(Lp E p μ)
hp : 0 < p
hf : eLpNorm (↑↑f) p μ = 0 ∨ eLpNorm (↑↑f) p μ = ⊤
⊢ f = 0
state_after: no goals
tactic: cases hf with
  | inl hf =>
    rw [eLpNorm_eq_zero_iff (Lp.aestronglyMeasurable f) hp.ne.symm] at hf
    exact Subtype.eq (AEEqFun.ext (hf.trans AEEqFun.coeFn_zero.symm))
  | inr hf =>
    exact absurd hf (eLpNorm_ne_top f)
Theorem: le_himp_comm
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
⊢ a ≤ b ⇨ c ↔ b ≤ a ⇨ c
state_after: no goals
tactic: rw [le_himp_iff, le_himp_iff']
Theorem: CategoryTheory.IsFiltered.of_exists_of_isFiltered_of_fullyFaithful
File: Mathlib/CategoryTheory/Filtered/Final.lean

Proof steps:
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsFiltered D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (d ⟶ F.obj c)
⊢ Nonempty C
state_after: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsFiltered D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (d ⟶ F.obj c)
this : Nonempty D
⊢ Nonempty C
tactic: have : Nonempty D := IsFiltered.nonempty
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsFiltered D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (d ⟶ F.obj c)
this : Nonempty D
⊢ Nonempty C
state_after: case intro
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsFiltered D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (d ⟶ F.obj c)
this : Nonempty D
c : C
⊢ Nonempty C
tactic: obtain ⟨c, -⟩ := h (Classical.arbitrary D)
state_before: case intro
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsFiltered D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (d ⟶ F.obj c)
this : Nonempty D
c : C
⊢ Nonempty C
state_after: no goals
tactic: exact ⟨c⟩
Theorem: RCLike.ofReal_lt_ofReal
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w : K
x y : ℝ
⊢ ↑x < ↑y ↔ x < y
state_after: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w : K
x y : ℝ
⊢ re ↑x < re ↑y ∧ im ↑x = im ↑y ↔ x < y
tactic: rw [lt_iff_re_im]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w : K
x y : ℝ
⊢ re ↑x < re ↑y ∧ im ↑x = im ↑y ↔ x < y
state_after: no goals
tactic: simp
Theorem: Set.mulIndicator_mul_eq_left
File: Mathlib/Algebra/Group/Indicator.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s t : Set α
f✝ g✝ : α → M
a : α
f g : α → M
h : Disjoint (mulSupport f) (mulSupport g)
⊢ (mulSupport f).mulIndicator (f * g) = f
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s t : Set α
f✝ g✝ : α → M
a : α
f g : α → M
h : Disjoint (mulSupport f) (mulSupport g)
x : α
hx : x ∈ mulSupport f
⊢ (f * g) x = f x
tactic: refine (mulIndicator_congr fun x hx => ?_).trans mulIndicator_mulSupport
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s t : Set α
f✝ g✝ : α → M
a : α
f g : α → M
h : Disjoint (mulSupport f) (mulSupport g)
x : α
hx : x ∈ mulSupport f
⊢ (f * g) x = f x
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s t : Set α
f✝ g✝ : α → M
a : α
f g : α → M
h : Disjoint (mulSupport f) (mulSupport g)
x : α
hx : x ∈ mulSupport f
this : g x = 1
⊢ (f * g) x = f x
tactic: have : g x = 1 := nmem_mulSupport.1 (disjoint_left.1 h hx)
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s t : Set α
f✝ g✝ : α → M
a : α
f g : α → M
h : Disjoint (mulSupport f) (mulSupport g)
x : α
hx : x ∈ mulSupport f
this : g x = 1
⊢ (f * g) x = f x
state_after: no goals
tactic: rw [Pi.mul_apply, this, mul_one]
Theorem: RelSeries.last_smash
File: Mathlib/Order/RelSeries.lean

Proof steps:
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
⊢ (p.smash q h).last = q.last
state_after: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
⊢ { length := p.length + q.length,
          toFun := fun i => if H : ↑i < p.length then p.toFun ⟨↑i, ⋯⟩ else q.toFun ⟨↑i - p.length, ⋯⟩, step := ⋯ }.toFun
      (Fin.last
        { length := p.length + q.length,
            toFun := fun i => if H : ↑i < p.length then p.toFun ⟨↑i, ⋯⟩ else q.toFun ⟨↑i - p.length, ⋯⟩,
            step := ⋯ }.length) =
    q.toFun (Fin.last q.length)
tactic: delta smash last
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
⊢ { length := p.length + q.length,
          toFun := fun i => if H : ↑i < p.length then p.toFun ⟨↑i, ⋯⟩ else q.toFun ⟨↑i - p.length, ⋯⟩, step := ⋯ }.toFun
      (Fin.last
        { length := p.length + q.length,
            toFun := fun i => if H : ↑i < p.length then p.toFun ⟨↑i, ⋯⟩ else q.toFun ⟨↑i - p.length, ⋯⟩,
            step := ⋯ }.length) =
    q.toFun (Fin.last q.length)
state_after: no goals
tactic: aesop
Theorem: Nat.gcd_fib_add_mul_self
File: Mathlib/Data/Nat/Fib/Basic.lean

Proof steps:
state_before: m n : ℕ
⊢ (fib m).gcd (fib (n + 0 * m)) = (fib m).gcd (fib n)
state_after: no goals
tactic: simp
state_before: m n k : ℕ
⊢ (fib m).gcd (fib (n + (k + 1) * m)) = (fib m).gcd (fib n)
state_after: no goals
tactic: rw [← gcd_fib_add_mul_self m n k, add_mul, ← add_assoc, one_mul, gcd_fib_add_self _ _]
Theorem: CategoryTheory.CategoryOfElements.structuredArrowEquivalence_functor_map
File: Mathlib/CategoryTheory/Elements.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
F : C ⥤ Type w
X : F.Elements
⊢ (𝟭 F.Elements).obj X = (toStructuredArrow F ⋙ fromStructuredArrow F).obj X
state_after: no goals
tactic: aesop_cat
Theorem: RatFunc.algebraMap_apply
File: Mathlib/FieldTheory/RatFunc/Basic.lean

Proof steps:
state_before: K : Type u
inst✝³ : CommRing K
inst✝² : IsDomain K
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Algebra R K[X]
x : R
⊢ (algebraMap R (RatFunc K)) x = (algebraMap K[X] (RatFunc K)) ((algebraMap R K[X]) x) / (algebraMap K[X] (RatFunc K)) 1
state_after: K : Type u
inst✝³ : CommRing K
inst✝² : IsDomain K
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Algebra R K[X]
x : R
⊢ (algebraMap R (RatFunc K)) x = RatFunc.mk ((algebraMap R K[X]) x) 1
tactic: rw [← mk_eq_div]
state_before: K : Type u
inst✝³ : CommRing K
inst✝² : IsDomain K
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Algebra R K[X]
x : R
⊢ (algebraMap R (RatFunc K)) x = RatFunc.mk ((algebraMap R K[X]) x) 1
state_after: no goals
tactic: rfl