ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AlgebraicGeometry.isNoetherian_iff_of_finite_affine_openCover
File: Mathlib/AlgebraicGeometry/Noetherian.lean

Proof steps:
state_before: X : Scheme
𝒰 : X.OpenCover
inst✝¹ : Finite 𝒰.J
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
⊢ IsNoetherian X ↔ ∀ (i : 𝒰.J), IsNoetherianRing ↑Γ(𝒰.obj i, ⊤)
state_after: case mp
X : Scheme
𝒰 : X.OpenCover
inst✝¹ : Finite 𝒰.J
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
⊢ IsNoetherian X → ∀ (i : 𝒰.J), IsNoetherianRing ↑Γ(𝒰.obj i, ⊤)

case mpr
X : Scheme
𝒰 : X.OpenCover
inst✝¹ : Finite 𝒰.J
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
⊢ (∀ (i : 𝒰.J), IsNoetherianRing ↑Γ(𝒰.obj i, ⊤)) → IsNoetherian X
tactic: constructor
Theorem: Nat.periodic_coprime
File: Mathlib/Data/Nat/Periodic.lean

Proof steps:
state_before: a : ℕ
⊢ Periodic a.Coprime a
state_after: no goals
tactic: simp only [coprime_add_self_right, forall_const, iff_self_iff, eq_iff_iff, Periodic]
Theorem: hasDerivAt_sqrt_mul_log
File: Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean

Proof steps:
state_before: x : ℝ
hx : x ≠ 0
⊢ HasDerivAt (fun x => √x * log x) ((2 + log x) / (2 * √x)) x
state_after: case h.e'_7
x : ℝ
hx : x ≠ 0
⊢ (2 + log x) / (2 * √x) = 1 / (2 * √x) * log x + √x * x⁻¹
tactic: convert (hasDerivAt_sqrt hx).mul (hasDerivAt_log hx) using 1
state_before: case h.e'_7
x : ℝ
hx : x ≠ 0
⊢ (2 + log x) / (2 * √x) = 1 / (2 * √x) * log x + √x * x⁻¹
state_after: no goals
tactic: rw [add_div, div_mul_cancel_left₀ two_ne_zero, ← div_eq_mul_inv, sqrt_div_self', add_comm,
    one_div, one_div, ← div_eq_inv_mul]
Theorem: Set.Ici_add_bij
File: Mathlib/Algebra/Order/Interval/Set/Monoid.lean

Proof steps:
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ BijOn (fun x => x + d) (Ici a) (Ici (a + d))
state_after: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d x✝ : M
h : x✝ ∈ Ici (a + d)
⊢ x✝ ∈ (fun x => x + d) '' Ici a
tactic: refine
    ⟨fun x h => add_le_add_right (mem_Ici.mp h) _, (add_left_injective d).injOn, fun _ h => ?_⟩
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d x✝ : M
h : x✝ ∈ Ici (a + d)
⊢ x✝ ∈ (fun x => x + d) '' Ici a
state_after: case intro
M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c✝ d c : M
h : a + d + c ∈ Ici (a + d)
⊢ a + d + c ∈ (fun x => x + d) '' Ici a
tactic: obtain ⟨c, rfl⟩ := exists_add_of_le (mem_Ici.mp h)
state_before: case intro
M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c✝ d c : M
h : a + d + c ∈ Ici (a + d)
⊢ a + d + c ∈ (fun x => x + d) '' Ici a
state_after: case intro
M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c✝ d c : M
h : a ≤ a + c
⊢ a + d + c ∈ (fun x => x + d) '' Ici a
tactic: rw [mem_Ici, add_right_comm, add_le_add_iff_right] at h
state_before: case intro
M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c✝ d c : M
h : a ≤ a + c
⊢ a + d + c ∈ (fun x => x + d) '' Ici a
state_after: no goals
tactic: exact ⟨a + c, h, by rw [add_right_comm]⟩
Theorem: hasBasis_nhdsSet
File: Mathlib/Topology/NhdsSet.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s✝ t✝ s₁ s₂ t₁ t₂ : Set X
x : X
s t : Set X
⊢ t ∈ 𝓝ˢ s ↔ ∃ i, (IsOpen i ∧ s ⊆ i) ∧ i ⊆ t
state_after: no goals
tactic: simp [mem_nhdsSet_iff_exists, and_assoc]
Theorem: Matroid.dual_dep_iff_forall
File: Mathlib/Data/Matroid/Dual.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
I B X : Set α
⊢ M✶.Dep I ↔ (∀ (B : Set α), M.Base B → (I ∩ B).Nonempty) ∧ I ⊆ M.E
state_after: no goals
tactic: simp_rw [dep_iff, dual_indep_iff_exists', dual_ground, and_congr_left_iff, not_and,
    not_exists, not_and, not_disjoint_iff_nonempty_inter, Classical.imp_iff_right_iff,
    iff_true_intro Or.inl]
Theorem: QuadraticModuleCat.Hom.toIsometry_injective
File: Mathlib/LinearAlgebra/QuadraticForm/QuadraticModuleCat.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
V W : QuadraticModuleCat R
x✝² x✝¹ : V.Hom W
f g : V.form →qᵢ W.form
x✝ : { toIsometry := f }.toIsometry = { toIsometry := g }.toIsometry
⊢ { toIsometry := f } = { toIsometry := g }
state_after: no goals
tactic: congr
Theorem: Field.insepDegree_self
File: Mathlib/FieldTheory/SeparableClosure.lean

Proof steps:
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
⊢ insepDegree F F = 1
state_after: no goals
tactic: rw [insepDegree, Subsingleton.elim (separableClosure F F) ⊤, IntermediateField.rank_top]
Theorem: rpow_neg_one_add_norm_sq_le
File: Mathlib/Analysis/SpecialFunctions/JapaneseBracket.lean

Proof steps:
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
r : ℝ
x : E
hr : 0 < r
⊢ (1 + ‖x‖ ^ 2) ^ (-r / 2) = 2 ^ (r / 2) * ((√2 * √(1 + ‖x‖ ^ 2)) ^ r)⁻¹
state_after: no goals
tactic: rw [rpow_div_two_eq_sqrt, rpow_div_two_eq_sqrt, mul_rpow, mul_inv, rpow_neg,
        mul_inv_cancel_left₀] <;> positivity
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
r : ℝ
x : E
hr : 0 < r
⊢ 2 ^ (r / 2) * ((√2 * √(1 + ‖x‖ ^ 2)) ^ r)⁻¹ ≤ 2 ^ (r / 2) * ((1 + ‖x‖) ^ r)⁻¹
state_after: case h.h.h₁
E : Type u_1
inst✝ : NormedAddCommGroup E
r : ℝ
x : E
hr : 0 < r
⊢ 1 + ‖x‖ ≤ √2 * √(1 + ‖x‖ ^ 2)
tactic: gcongr
state_before: case h.h.h₁
E : Type u_1
inst✝ : NormedAddCommGroup E
r : ℝ
x : E
hr : 0 < r
⊢ 1 + ‖x‖ ≤ √2 * √(1 + ‖x‖ ^ 2)
state_after: no goals
tactic: apply one_add_norm_le_sqrt_two_mul_sqrt
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
r : ℝ
x : E
hr : 0 < r
⊢ 2 ^ (r / 2) * ((1 + ‖x‖) ^ r)⁻¹ = 2 ^ (r / 2) * (1 + ‖x‖) ^ (-r)
state_after: case hx
E : Type u_1
inst✝ : NormedAddCommGroup E
r : ℝ
x : E
hr : 0 < r
⊢ 0 ≤ 1 + ‖x‖
tactic: rw [rpow_neg]
state_before: case hx
E : Type u_1
inst✝ : NormedAddCommGroup E
r : ℝ
x : E
hr : 0 < r
⊢ 0 ≤ 1 + ‖x‖
state_after: no goals
tactic: positivity
Theorem: openEmbedding_sigma_map
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
ι : Type u_5
κ : Type u_6
σ : ι → Type u_7
τ : κ → Type u_8
inst✝² : (i : ι) → TopologicalSpace (σ i)
inst✝¹ : (k : κ) → TopologicalSpace (τ k)
inst✝ : TopologicalSpace X
f₁ : ι → κ
f₂ : (i : ι) → σ i → τ (f₁ i)
h : Injective f₁
⊢ OpenEmbedding (Sigma.map f₁ f₂) ↔ ∀ (i : ι), OpenEmbedding (f₂ i)
state_after: no goals
tactic: simp only [openEmbedding_iff_embedding_open, isOpenMap_sigma_map, embedding_sigma_map h,
    forall_and]
Theorem: Finset.dens_lt_dens
File: Mathlib/Data/Finset/Density.lean

Proof steps:
state_before: 𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝ : Fintype α
s t : Finset α
a b : α
h : s ⊂ t
⊢ 0 < ↑(Fintype.card α)
state_after: case inl
𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝ : Fintype α
s t : Finset α
a b : α
h : s ⊂ t
h✝ : IsEmpty α
⊢ 0 < ↑(Fintype.card α)

case inr
𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝ : Fintype α
s t : Finset α
a b : α
h : s ⊂ t
h✝ : Nonempty α
⊢ 0 < ↑(Fintype.card α)
tactic: cases isEmpty_or_nonempty α
Theorem: MeasureTheory.Measure.addHaar_preimage_linearEquiv
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

Proof steps:
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f : E ≃ₗ[ℝ] E
s : Set E
⊢ μ (⇑f ⁻¹' s) = ENNReal.ofReal |LinearMap.det ↑f.symm| * μ s
state_after: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f : E ≃ₗ[ℝ] E
s : Set E
A : LinearMap.det ↑f ≠ 0
⊢ μ (⇑f ⁻¹' s) = ENNReal.ofReal |LinearMap.det ↑f.symm| * μ s
tactic: have A : LinearMap.det (f : E →ₗ[ℝ] E) ≠ 0 := (LinearEquiv.isUnit_det' f).ne_zero
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f : E ≃ₗ[ℝ] E
s : Set E
A : LinearMap.det ↑f ≠ 0
⊢ μ (⇑f ⁻¹' s) = ENNReal.ofReal |LinearMap.det ↑f.symm| * μ s
state_after: case h.e'_3.h.e'_5.h.e'_1.h.e'_4
E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f : E ≃ₗ[ℝ] E
s : Set E
A : LinearMap.det ↑f ≠ 0
⊢ LinearMap.det ↑f.symm = (LinearMap.det ↑f)⁻¹
tactic: convert addHaar_preimage_linearMap μ A s
state_before: case h.e'_3.h.e'_5.h.e'_1.h.e'_4
E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f : E ≃ₗ[ℝ] E
s : Set E
A : LinearMap.det ↑f ≠ 0
⊢ LinearMap.det ↑f.symm = (LinearMap.det ↑f)⁻¹
state_after: no goals
tactic: simp only [LinearEquiv.det_coe_symm]
Theorem: sq_abs
File: Mathlib/Algebra/Order/Ring/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
n : ℕ
a✝ b c a : α
⊢ |a| ^ 2 = a ^ 2
state_after: no goals
tactic: simpa only [sq] using abs_mul_abs_self a
Theorem: LieModule.antitone_lowerCentralSeries
File: Mathlib/Algebra/Lie/Nilpotent.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
k : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
⊢ Antitone (lowerCentralSeries R L M)
state_after: 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
k✝ : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
l k : ℕ
⊢ l ≤ k → lowerCentralSeries R L M k ≤ lowerCentralSeries R L M l
tactic: intro l k
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
k✝ : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
l k : ℕ
⊢ l ≤ k → lowerCentralSeries R L M k ≤ lowerCentralSeries R L M l
state_after: case zero
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
k : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
l : ℕ
h : l ≤ 0
⊢ lowerCentralSeries R L M 0 ≤ lowerCentralSeries R L M l

case succ
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
k✝ : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
k : ℕ
ih : ∀ ⦃l : ℕ⦄, l ≤ k → lowerCentralSeries R L M k ≤ lowerCentralSeries R L M l
l : ℕ
h : l ≤ k + 1
⊢ lowerCentralSeries R L M (k + 1) ≤ lowerCentralSeries R L M l
tactic: induction' k with k ih generalizing l <;> intro h
Theorem: Order.isMax_iterate_succ_of_eq_of_lt
File: Mathlib/Order/SuccPred/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
n m : ℕ
h_eq : succ^[n] a = succ^[m] a
h_lt : n < m
⊢ IsMax (succ^[n] a)
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
n m : ℕ
h_eq : succ^[n] a = succ^[m] a
h_lt : n < m
⊢ succ (succ^[n] a) ≤ succ^[m] a
tactic: refine max_of_succ_le (le_trans ?_ h_eq.symm.le)
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
n m : ℕ
h_eq : succ^[n] a = succ^[m] a
h_lt : n < m
⊢ succ (succ^[n] a) ≤ succ^[m] a
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
n m : ℕ
h_eq : succ^[n] a = succ^[m] a
h_lt : n < m
this : succ (succ^[n] a) = succ^[n + 1] a
⊢ succ (succ^[n] a) ≤ succ^[m] a
tactic: have : succ (succ^[n] a) = succ^[n + 1] a := by rw [Function.iterate_succ', comp]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
n m : ℕ
h_eq : succ^[n] a = succ^[m] a
h_lt : n < m
this : succ (succ^[n] a) = succ^[n + 1] a
⊢ succ (succ^[n] a) ≤ succ^[m] a
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
n m : ℕ
h_eq : succ^[n] a = succ^[m] a
h_lt : n < m
this : succ (succ^[n] a) = succ^[n + 1] a
⊢ succ^[n + 1] a ≤ succ^[m] a
tactic: rw [this]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
n m : ℕ
h_eq : succ^[n] a = succ^[m] a
h_lt : n < m
this : succ (succ^[n] a) = succ^[n + 1] a
⊢ succ^[n + 1] a ≤ succ^[m] a
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
n m : ℕ
h_eq : succ^[n] a = succ^[m] a
h_lt : n < m
this : succ (succ^[n] a) = succ^[n + 1] a
h_le : n + 1 ≤ m
⊢ succ^[n + 1] a ≤ succ^[m] a
tactic: have h_le : n + 1 ≤ m := Nat.succ_le_of_lt h_lt
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
n m : ℕ
h_eq : succ^[n] a = succ^[m] a
h_lt : n < m
this : succ (succ^[n] a) = succ^[n + 1] a
h_le : n + 1 ≤ m
⊢ succ^[n + 1] a ≤ succ^[m] a
state_after: no goals
tactic: exact Monotone.monotone_iterate_of_le_map succ_mono (le_succ a) h_le
Theorem: intervalIntegral.measure_integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae_right
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
f : ℝ → E
a b : ℝ
c ca cb : E
l l' la la' lb lb' : Filter ℝ
lt : Filter ι
μ : Measure ℝ
u v ua va ub vb : ι → ℝ
inst✝³ : CompleteSpace E
inst✝² : FTCFilter a la la'
inst✝¹ : FTCFilter b lb lb'
inst✝ : IsLocallyFiniteMeasure μ
hab : IntervalIntegrable f μ a b
hmeas : StronglyMeasurableAtFilter f lb' μ
hf : Tendsto f (lb' ⊓ ae μ) (𝓝 c)
hu : Tendsto u lt lb
hv : Tendsto v lt lb
⊢ (fun t => ∫ (x : ℝ) in a..v t, f x ∂μ - ∫ (x : ℝ) in a..u t, f x ∂μ - ∫ (x : ℝ) in u t..v t, c ∂μ) =o[lt] fun t =>
    ∫ (x : ℝ) in u t..v t, 1 ∂μ
state_after: no goals
tactic: simpa using
    measure_integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae hab stronglyMeasurableAt_bot
      hmeas ((tendsto_bot : Tendsto _ ⊥ (𝓝 (0 : E))).mono_left inf_le_left) hf
      (tendsto_const_pure : Tendsto _ _ (pure a)) tendsto_const_pure hu hv
Theorem: List.length_range
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: n : Nat
⊢ (range n).length = n
state_after: no goals
tactic: simp only [range_eq_range', length_range']
Theorem: Filter.mem_inf_principal'
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
f : Filter α
s t : Set α
⊢ s ∈ f ⊓ 𝓟 t ↔ tᶜ ∪ s ∈ f
state_after: no goals
tactic: simp only [← le_principal_iff, (isCompl_principal s).le_left_iff, disjoint_assoc, inf_principal,
    ← (isCompl_principal (t ∩ sᶜ)).le_right_iff, compl_inter, compl_compl]
Theorem: Metric.emetric_ball_nnreal
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x : α
ε : ℝ≥0
⊢ EMetric.ball x ↑ε = ball x ↑ε
state_after: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x : α
ε : ℝ≥0
⊢ EMetric.ball x ↑ε = EMetric.ball x (ENNReal.ofReal ↑ε)
tactic: rw [← Metric.emetric_ball]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x : α
ε : ℝ≥0
⊢ EMetric.ball x ↑ε = EMetric.ball x (ENNReal.ofReal ↑ε)
state_after: no goals
tactic: simp
Theorem: Rel.card_interedges_finpartition
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

Proof steps:
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝³ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝² : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
P : Finpartition s
Q : Finpartition t
⊢ (interedges r s t).card = ∑ ab ∈ P.parts ×ˢ Q.parts, (interedges r ab.1 ab.2).card
state_after: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝³ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝² : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
P : Finpartition s
Q : Finpartition t
⊢ ∑ a ∈ P.parts, (interedges r a t).card = ∑ x ∈ P.parts, ∑ y ∈ Q.parts, (interedges r (x, y).1 (x, y).2).card
tactic: rw [card_interedges_finpartition_left _ P, sum_product]
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝³ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝² : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
P : Finpartition s
Q : Finpartition t
⊢ ∑ a ∈ P.parts, (interedges r a t).card = ∑ x ∈ P.parts, ∑ y ∈ Q.parts, (interedges r (x, y).1 (x, y).2).card
state_after: case e_f
𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝³ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝² : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
P : Finpartition s
Q : Finpartition t
⊢ (fun a => (interedges r a t).card) = fun x => ∑ y ∈ Q.parts, (interedges r (x, y).1 (x, y).2).card
tactic: congr
state_before: case e_f
𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝³ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝² : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
P : Finpartition s
Q : Finpartition t
⊢ (fun a => (interedges r a t).card) = fun x => ∑ y ∈ Q.parts, (interedges r (x, y).1 (x, y).2).card
state_after: case e_f.h
𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝³ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝² : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
P : Finpartition s
Q : Finpartition t
x✝ : Finset α
⊢ (interedges r x✝ t).card = ∑ y ∈ Q.parts, (interedges r (x✝, y).1 (x✝, y).2).card
tactic: ext
state_before: case e_f.h
𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝³ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝² : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
P : Finpartition s
Q : Finpartition t
x✝ : Finset α
⊢ (interedges r x✝ t).card = ∑ y ∈ Q.parts, (interedges r (x✝, y).1 (x✝, y).2).card
state_after: no goals
tactic: rw [card_interedges_finpartition_right]
Theorem: CategoryTheory.Limits.biproduct.isoProduct_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
K : Type u_1
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j : J
⊢ (isoProduct f).inv ≫ π f j = lift (Pi.π f) ≫ π f j
state_after: no goals
tactic: simp [Iso.inv_comp_eq]
Theorem: Asymptotics.isBigOWith_insert
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹⁴ : Norm E
inst✝¹³ : Norm F
inst✝¹² : Norm G
inst✝¹¹ : SeminormedAddCommGroup E'
inst✝¹⁰ : SeminormedAddCommGroup F'
inst✝⁹ : SeminormedAddCommGroup G'
inst✝⁸ : NormedAddCommGroup E''
inst✝⁷ : NormedAddCommGroup F''
inst✝⁶ : NormedAddCommGroup G''
inst✝⁵ : SeminormedRing R
inst✝⁴ : SeminormedAddGroup E'''
inst✝³ : SeminormedRing R'
inst✝² : NormedDivisionRing 𝕜
inst✝¹ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g✝ : α → F
k : α → G
f' : α → E'
g'✝ : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
inst✝ : TopologicalSpace α
x : α
s : Set α
C : ℝ
g : α → E
g' : α → F
h : ‖g x‖ ≤ C * ‖g' x‖
⊢ IsBigOWith C (𝓝[insert x s] x) g g' ↔ IsBigOWith C (𝓝[s] x) g g'
state_after: no goals
tactic: simp_rw [IsBigOWith_def, nhdsWithin_insert, eventually_sup, eventually_pure, h, true_and_iff]
Theorem: completedRiemannZeta₀_one_sub
File: Mathlib/NumberTheory/LSeries/RiemannZeta.lean

Proof steps:
state_before: s : ℂ
⊢ completedRiemannZeta₀ (1 - s) = completedRiemannZeta₀ s
state_after: no goals
tactic: rw [← completedHurwitzZetaEven₀_zero, ← completedCosZeta₀_zero, completedHurwitzZetaEven₀_one_sub]
Theorem: DFinsupp.equivCongrLeft_apply
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
κ : Type u_1
inst✝ : (i : ι) → Zero (β i)
h : ι ≃ κ
f : Π₀ (k : κ), β (h.symm k)
i : ι
⊢ HEq 0 0
state_after: no goals
tactic: rw [Equiv.symm_apply_apply]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
κ : Type u_1
inst✝ : (i : ι) → Zero (β i)
h : ι ≃ κ
f : Π₀ (i : ι), β i
⊢ (fun f => mapRange (fun i => ⇑(Equiv.cast ⋯)) ⋯ (comapDomain' ⇑h ⋯ f)) (comapDomain' ⇑h.symm ⋯ f) = f
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
κ : Type u_1
inst✝ : (i : ι) → Zero (β i)
h : ι ≃ κ
f : Π₀ (i : ι), β i
i : ι
⊢ ((fun f => mapRange (fun i => ⇑(Equiv.cast ⋯)) ⋯ (comapDomain' ⇑h ⋯ f)) (comapDomain' ⇑h.symm ⋯ f)) i = f i
tactic: ext i
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
κ : Type u_1
inst✝ : (i : ι) → Zero (β i)
h : ι ≃ κ
f : Π₀ (i : ι), β i
i : ι
⊢ ((fun f => mapRange (fun i => ⇑(Equiv.cast ⋯)) ⋯ (comapDomain' ⇑h ⋯ f)) (comapDomain' ⇑h.symm ⋯ f)) i = f i
state_after: no goals
tactic: rw [mapRange_apply, comapDomain'_apply, comapDomain'_apply, Equiv.cast_eq_iff_heq,
      h.symm_apply_apply]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
κ : Type u_1
inst✝ : (i : ι) → Zero (β i)
h : ι ≃ κ
f : Π₀ (k : κ), β (h.symm k)
⊢ comapDomain' ⇑h.symm ⋯ ((fun f => mapRange (fun i => ⇑(Equiv.cast ⋯)) ⋯ (comapDomain' ⇑h ⋯ f)) f) = f
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
κ : Type u_1
inst✝ : (i : ι) → Zero (β i)
h : ι ≃ κ
f : Π₀ (k : κ), β (h.symm k)
k : κ
⊢ (comapDomain' ⇑h.symm ⋯ ((fun f => mapRange (fun i => ⇑(Equiv.cast ⋯)) ⋯ (comapDomain' ⇑h ⋯ f)) f)) k = f k
tactic: ext k
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
κ : Type u_1
inst✝ : (i : ι) → Zero (β i)
h : ι ≃ κ
f : Π₀ (k : κ), β (h.symm k)
k : κ
⊢ (comapDomain' ⇑h.symm ⋯ ((fun f => mapRange (fun i => ⇑(Equiv.cast ⋯)) ⋯ (comapDomain' ⇑h ⋯ f)) f)) k = f k
state_after: no goals
tactic: rw [comapDomain'_apply, mapRange_apply, comapDomain'_apply, Equiv.cast_eq_iff_heq,
      h.apply_symm_apply]