ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.NatTrans.rightDerived_id
File: Mathlib/CategoryTheory/Abelian/RightDerived.lean

Proof steps:
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u_1
inst✝⁴ : Category.{u_2, u_1} D
inst✝³ : Abelian C
inst✝² : HasInjectiveResolutions C
inst✝¹ : Abelian D
F : C ⥤ D
inst✝ : F.Additive
n : ℕ
⊢ rightDerived (𝟙 F) n = 𝟙 (F.rightDerived n)
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u_1
inst✝⁴ : Category.{u_2, u_1} D
inst✝³ : Abelian C
inst✝² : HasInjectiveResolutions C
inst✝¹ : Abelian D
F : C ⥤ D
inst✝ : F.Additive
n : ℕ
⊢ whiskerRight (rightDerivedToHomotopyCategory (𝟙 F)) (HomotopyCategory.homologyFunctor D (ComplexShape.up ℕ) n) =
    𝟙 (F.rightDerived n)
tactic: dsimp only [rightDerived]
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u_1
inst✝⁴ : Category.{u_2, u_1} D
inst✝³ : Abelian C
inst✝² : HasInjectiveResolutions C
inst✝¹ : Abelian D
F : C ⥤ D
inst✝ : F.Additive
n : ℕ
⊢ whiskerRight (rightDerivedToHomotopyCategory (𝟙 F)) (HomotopyCategory.homologyFunctor D (ComplexShape.up ℕ) n) =
    𝟙 (F.rightDerived n)
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u_1
inst✝⁴ : Category.{u_2, u_1} D
inst✝³ : Abelian C
inst✝² : HasInjectiveResolutions C
inst✝¹ : Abelian D
F : C ⥤ D
inst✝ : F.Additive
n : ℕ
⊢ 𝟙 (F.rightDerivedToHomotopyCategory ⋙ HomotopyCategory.homologyFunctor D (ComplexShape.up ℕ) n) = 𝟙 (F.rightDerived n)
tactic: simp only [rightDerivedToHomotopyCategory_id, whiskerRight_id']
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u_1
inst✝⁴ : Category.{u_2, u_1} D
inst✝³ : Abelian C
inst✝² : HasInjectiveResolutions C
inst✝¹ : Abelian D
F : C ⥤ D
inst✝ : F.Additive
n : ℕ
⊢ 𝟙 (F.rightDerivedToHomotopyCategory ⋙ HomotopyCategory.homologyFunctor D (ComplexShape.up ℕ) n) = 𝟙 (F.rightDerived n)
state_after: no goals
tactic: rfl
Theorem: SchwartzMap.decay_add_le_aux
File: Mathlib/Analysis/Distribution/SchwartzSpace.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
k n : ℕ
f g : 𝓢(E, F)
x : E
⊢ ‖x‖ ^ k * ‖iteratedFDeriv ℝ n (⇑f + ⇑g) x‖ ≤
    ‖x‖ ^ k * ‖iteratedFDeriv ℝ n (⇑f) x‖ + ‖x‖ ^ k * ‖iteratedFDeriv ℝ n (⇑g) x‖
state_after: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
k n : ℕ
f g : 𝓢(E, F)
x : E
⊢ ‖x‖ ^ k * ‖iteratedFDeriv ℝ n (⇑f + ⇑g) x‖ ≤ ‖x‖ ^ k * (‖iteratedFDeriv ℝ n (⇑f) x‖ + ‖iteratedFDeriv ℝ n (⇑g) x‖)
tactic: rw [← mul_add]
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
k n : ℕ
f g : 𝓢(E, F)
x : E
⊢ ‖x‖ ^ k * ‖iteratedFDeriv ℝ n (⇑f + ⇑g) x‖ ≤ ‖x‖ ^ k * (‖iteratedFDeriv ℝ n (⇑f) x‖ + ‖iteratedFDeriv ℝ n (⇑g) x‖)
state_after: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
k n : ℕ
f g : 𝓢(E, F)
x : E
⊢ ‖iteratedFDeriv ℝ n (⇑f + ⇑g) x‖ ≤ ‖iteratedFDeriv ℝ n (⇑f) x‖ + ‖iteratedFDeriv ℝ n (⇑g) x‖
tactic: refine mul_le_mul_of_nonneg_left ?_ (by positivity)
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
k n : ℕ
f g : 𝓢(E, F)
x : E
⊢ ‖iteratedFDeriv ℝ n (⇑f + ⇑g) x‖ ≤ ‖iteratedFDeriv ℝ n (⇑f) x‖ + ‖iteratedFDeriv ℝ n (⇑g) x‖
state_after: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
k n : ℕ
f g : 𝓢(E, F)
x : E
⊢ ‖iteratedFDeriv ℝ n (⇑f) x + iteratedFDeriv ℝ n (⇑g) x‖ ≤ ‖iteratedFDeriv ℝ n (⇑f) x‖ + ‖iteratedFDeriv ℝ n (⇑g) x‖
tactic: rw [iteratedFDeriv_add_apply (f.smooth _) (g.smooth _)]
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
k n : ℕ
f g : 𝓢(E, F)
x : E
⊢ ‖iteratedFDeriv ℝ n (⇑f) x + iteratedFDeriv ℝ n (⇑g) x‖ ≤ ‖iteratedFDeriv ℝ n (⇑f) x‖ + ‖iteratedFDeriv ℝ n (⇑g) x‖
state_after: no goals
tactic: exact norm_add_le _ _
Theorem: TopCat.colimit_isOpen_iff
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCat
U : Set ↑(colimit F)
⊢ IsOpen U ↔ ∀ (j : J), IsOpen (⇑(colimit.ι F j) ⁻¹' U)
state_after: no goals
tactic: exact isOpen_iSup_iff
Theorem: CategoryTheory.Dial.leftUnitor_hom_F
File: Mathlib/CategoryTheory/Dialectica/Monoidal.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X : Dial C
⊢ (tensorUnit.tensorObj X).rel =
    (Subobject.pullback (prod.map (prod.leftUnitor X.src).hom (prod.leftUnitor X.tgt).hom)).obj X.rel
state_after: no goals
tactic: simp [Subobject.pullback_top]
Theorem: isometry_dcomp
File: Mathlib/Topology/MetricSpace/Isometry.lean

Proof steps:
state_before: ι✝ : Type u_1
α✝ : Type u
β✝ : Type v
γ : Type w
inst✝⁵ : PseudoEMetricSpace α✝
inst✝⁴ : PseudoEMetricSpace β✝
inst✝³ : PseudoEMetricSpace γ
f✝ : α✝ → β✝
x✝ y✝ z : α✝
s : Set α✝
ι : Type u_4
inst✝² : Fintype ι
α : ι → Type u_2
β : ι → Type u_3
inst✝¹ : (i : ι) → PseudoEMetricSpace (α i)
inst✝ : (i : ι) → PseudoEMetricSpace (β i)
f : (i : ι) → α i → β i
hf : ∀ (i : ι), Isometry (f i)
x y : (i : ι) → α i
⊢ edist ((fun g i => f i (g i)) x) ((fun g i => f i (g i)) y) = edist x y
state_after: no goals
tactic: simp only [edist_pi_def, (hf _).edist_eq]
Theorem: PNat.card_Icc
File: Mathlib/Data/PNat/Interval.lean

Proof steps:
state_before: a b : ℕ+
⊢ (Icc a b).card = ↑b + 1 - ↑a
state_after: a b : ℕ+
⊢ (Icc a b).card = (Icc ↑a ↑b).card
tactic: rw [← Nat.card_Icc]
state_before: a b : ℕ+
⊢ (Icc a b).card = (Icc ↑a ↑b).card
state_after: a b : ℕ+
⊢ (Icc a b).card = (map (Embedding.subtype fun n => 0 < n) (Icc a b)).card
tactic: erw [← Finset.map_subtype_embedding_Icc _ a b (fun c x _ hx _ hc _ => hc.trans_le hx)]
state_before: a b : ℕ+
⊢ (Icc a b).card = (map (Embedding.subtype fun n => 0 < n) (Icc a b)).card
state_after: no goals
tactic: rw [card_map]
Theorem: Real.continuous_mul_log
File: Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean

Proof steps:
state_before: ⊢ Continuous fun x => x * log x
state_after: ⊢ ∀ (x : ℝ), ContinuousAt (fun x => x * log x) x
tactic: rw [continuous_iff_continuousAt]
state_before: ⊢ ∀ (x : ℝ), ContinuousAt (fun x => x * log x) x
state_after: x : ℝ
⊢ ContinuousAt (fun x => x * log x) x
tactic: intro x
state_before: x : ℝ
⊢ ContinuousAt (fun x => x * log x) x
state_after: case inl
x : ℝ
hx : x ≠ 0
⊢ ContinuousAt (fun x => x * log x) x

case inr

⊢ ContinuousAt (fun x => x * log x) 0
tactic: obtain hx | rfl := ne_or_eq x 0
state_before: case inr

⊢ ContinuousAt (fun x => x * log x) 0
state_after: case inr

⊢ Filter.Tendsto (fun x => x * log x) (𝓝 0) (𝓝 0)
tactic: rw [ContinuousAt, zero_mul]
state_before: case inr

⊢ Filter.Tendsto (fun x => x * log x) (𝓝 0) (𝓝 0)
state_after: case inr

⊢ Filter.Tendsto (fun x => log x * x) (𝓝 0) (𝓝 0)
tactic: simp_rw [mul_comm _ (log _)]
state_before: case inr

⊢ Filter.Tendsto (fun x => log x * x) (𝓝 0) (𝓝 0)
state_after: case inr

⊢ Filter.Tendsto (fun x => log x * x) (𝓝[Set.univ] 0) (𝓝 0)
tactic: nth_rewrite 1 [← nhdsWithin_univ]
state_before: case inr

⊢ Filter.Tendsto (fun x => log x * x) (𝓝[Set.univ] 0) (𝓝 0)
state_after: case inr
this : Set.univ = Set.Iio 0 ∪ Set.Ioi 0 ∪ {0}
⊢ Filter.Tendsto (fun x => log x * x) (𝓝[Set.univ] 0) (𝓝 0)
tactic: have : (Set.univ : Set ℝ) = Set.Iio 0 ∪ Set.Ioi 0 ∪ {0} := by ext; simp [em]
state_before: case inr
this : Set.univ = Set.Iio 0 ∪ Set.Ioi 0 ∪ {0}
⊢ Filter.Tendsto (fun x => log x * x) (𝓝[Set.univ] 0) (𝓝 0)
state_after: case inr
this : Set.univ = Set.Iio 0 ∪ Set.Ioi 0 ∪ {0}
⊢ Filter.Tendsto (fun x => log x * x) (𝓝[<] 0 ⊔ 𝓝[>] 0 ⊔ 𝓝[{0}] 0) (𝓝 0)
tactic: rw [this, nhdsWithin_union, nhdsWithin_union]
state_before: case inr
this : Set.univ = Set.Iio 0 ∪ Set.Ioi 0 ∪ {0}
⊢ Filter.Tendsto (fun x => log x * x) (𝓝[<] 0 ⊔ 𝓝[>] 0 ⊔ 𝓝[{0}] 0) (𝓝 0)
state_after: case inr
this : Set.univ = Set.Iio 0 ∪ Set.Ioi 0 ∪ {0}
⊢ (Filter.Tendsto (fun x => log x * x) (𝓝[<] 0) (𝓝 0) ∧ Filter.Tendsto (fun x => log x * x) (𝓝[>] 0) (𝓝 0)) ∧
    Filter.Tendsto (fun x => log x * x) (pure 0) (𝓝 0)
tactic: simp only [nhdsWithin_singleton, sup_le_iff, Filter.nonpos_iff, Filter.tendsto_sup]
state_before: case inr
this : Set.univ = Set.Iio 0 ∪ Set.Ioi 0 ∪ {0}
⊢ (Filter.Tendsto (fun x => log x * x) (𝓝[<] 0) (𝓝 0) ∧ Filter.Tendsto (fun x => log x * x) (𝓝[>] 0) (𝓝 0)) ∧
    Filter.Tendsto (fun x => log x * x) (pure 0) (𝓝 0)
state_after: case inr.refine_1
this : Set.univ = Set.Iio 0 ∪ Set.Ioi 0 ∪ {0}
⊢ Filter.Tendsto (fun x => log x * x) (𝓝[>] 0) (𝓝 0)

case inr.refine_2
this : Set.univ = Set.Iio 0 ∪ Set.Ioi 0 ∪ {0}
⊢ Filter.Tendsto (fun x => log x * x) (pure 0) (𝓝 0)
tactic: refine ⟨⟨tendsto_log_mul_self_nhds_zero_left, ?_⟩, ?_⟩
Theorem: connectedComponentIn_mono
File: Mathlib/Topology/Connected/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F G : Set α
h : F ⊆ G
⊢ connectedComponentIn F x ⊆ connectedComponentIn G x
state_after: case pos
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F G : Set α
h : F ⊆ G
hx : x ∈ F
⊢ connectedComponentIn F x ⊆ connectedComponentIn G x

case neg
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F G : Set α
h : F ⊆ G
hx : x ∉ F
⊢ connectedComponentIn F x ⊆ connectedComponentIn G x
tactic: by_cases hx : x ∈ F
Theorem: MeasureTheory.eLpNorm_le_of_ae_bound
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.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 : α → F
C : ℝ
hfC : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ C
⊢ eLpNorm f p μ ≤ μ Set.univ ^ p.toReal⁻¹ * ENNReal.ofReal C
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 : α → F
C : ℝ
hfC : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ C
⊢ eLpNorm f p μ ≤ ENNReal.ofReal C * μ Set.univ ^ p.toReal⁻¹
tactic: rw [← mul_comm]
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 : α → F
C : ℝ
hfC : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ C
⊢ eLpNorm f p μ ≤ ENNReal.ofReal C * μ Set.univ ^ p.toReal⁻¹
state_after: no goals
tactic: exact eLpNorm_le_of_ae_nnnorm_bound (hfC.mono fun x hx => hx.trans C.le_coe_toNNReal)
Theorem: Sum.getLeft_eq_iff
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

Proof steps:
state_before: α✝ : Type u_1
a : α✝
β✝ : Type u_2
x : α✝ ⊕ β✝
h : x.isLeft = true
⊢ x.getLeft h = a ↔ x = inl a
state_after: no goals
tactic: cases x <;> simp at h ⊢
Theorem: sdiff_sdiff
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedCoheytingAlgebra α
a✝ b✝ c✝ d✝ a b c d : α
⊢ (a \ b) \ c ≤ d ↔ a \ (b ⊔ c) ≤ d
state_after: no goals
tactic: simp_rw [sdiff_le_iff, sup_assoc]
Theorem: FreeGroup.freeGroupCongr_apply
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α✝ : Type u
L L₁ L₂ L₃ L₄ : List (α✝ × Bool)
β✝ : Type v
f : α✝ → β✝
x✝ y : FreeGroup α✝
α : Type ?u.60273
β : Type ?u.60274
e : α ≃ β
x : FreeGroup α
⊢ (map ⇑e.symm) ((map ⇑e) x) = x
state_after: no goals
tactic: simp [Function.comp, map.comp]
state_before: α✝ : Type u
L L₁ L₂ L₃ L₄ : List (α✝ × Bool)
β✝ : Type v
f : α✝ → β✝
x✝ y : FreeGroup α✝
α : Type ?u.60273
β : Type ?u.60274
e : α ≃ β
x : FreeGroup β
⊢ (map ⇑e) ((map ⇑e.symm) x) = x
state_after: no goals
tactic: simp [Function.comp, map.comp]
Theorem: Rel.image_preimage_subset_inter_codom
File: Mathlib/Data/Rel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
s : Set β
⊢ s ∩ r.codom ⊆ r.image (r.preimage s)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
s : Set β
⊢ s ∩ r.inv.dom ⊆ r.inv.preimage (r.preimage s)
tactic: rw [← dom_inv, ← preimage_inv]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
s : Set β
⊢ s ∩ r.inv.dom ⊆ r.inv.preimage (r.preimage s)
state_after: no goals
tactic: apply inter_dom_subset_preimage_image
Theorem: Set.dual_ordSeparatingSet
File: Mathlib/Order/Interval/Set/OrdConnectedComponent.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrder α
s t : Set α
x y z : α
⊢ (⇑ofDual ⁻¹' s).ordSeparatingSet (⇑ofDual ⁻¹' t) = ⇑ofDual ⁻¹' s.ordSeparatingSet t
state_after: no goals
tactic: simp only [ordSeparatingSet, mem_preimage, ← toDual.surjective.iUnion_comp, ofDual_toDual,
    dual_ordConnectedComponent, ← preimage_compl, preimage_inter, preimage_iUnion]
Theorem: Function.Surjective.rightDistribClass
File: Mathlib/Algebra/Ring/InjSurj.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹³ : Zero β
inst✝¹² : One β
inst✝¹¹ : Add β
inst✝¹⁰ : Mul β
inst✝⁹ : Neg β
inst✝⁸ : Sub β
inst✝⁷ : SMul ℕ β
inst✝⁶ : SMul ℤ β
inst✝⁵ : Pow β ℕ
inst✝⁴ : NatCast β
inst✝³ : IntCast β
f : α → β
hf : Surjective f
inst✝² : Mul α
inst✝¹ : Add α
inst✝ : RightDistribClass α
add : ∀ (x y : α), f (x + y) = f x + f y
mul : ∀ (x y : α), f (x * y) = f x * f y
x y z : α
⊢ (f x + f y) * f z = f x * f z + f y * f z
state_after: no goals
tactic: simp only [← add, ← mul, right_distrib]
Theorem: Option.forall_mem_map
File: Mathlib/Data/Option/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f : α → β
o : Option α
p : β → Prop
⊢ (∀ (y : β), y ∈ Option.map f o → p y) ↔ ∀ (x : α), x ∈ o → p (f x)
state_after: no goals
tactic: simp
Theorem: MeasureTheory.lintegral_sub_le'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : AEMeasurable f μ
⊢ ∫⁻ (x : α), g x ∂μ - ∫⁻ (x : α), f x ∂μ ≤ ∫⁻ (x : α), g x - f x ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : AEMeasurable f μ
⊢ ∫⁻ (x : α), g x ∂μ ≤ ∫⁻ (x : α), g x - f x ∂μ + ∫⁻ (x : α), f x ∂μ
tactic: rw [tsub_le_iff_right]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : AEMeasurable f μ
⊢ ∫⁻ (x : α), g x ∂μ ≤ ∫⁻ (x : α), g x - f x ∂μ + ∫⁻ (x : α), f x ∂μ
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : AEMeasurable f μ
hfi : ∫⁻ (x : α), f x ∂μ = ⊤
⊢ ∫⁻ (x : α), g x ∂μ ≤ ∫⁻ (x : α), g x - f x ∂μ + ∫⁻ (x : α), f x ∂μ

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hf : AEMeasurable f μ
hfi : ¬∫⁻ (x : α), f x ∂μ = ⊤
⊢ ∫⁻ (x : α), g x ∂μ ≤ ∫⁻ (x : α), g x - f x ∂μ + ∫⁻ (x : α), f x ∂μ
tactic: by_cases hfi : ∫⁻ x, f x ∂μ = ∞
Theorem: ContinuousMap.inf_mem_subalgebra_closure
File: Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean

Proof steps:
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
f g : ↥A
⊢ ↑f ⊓ ↑g ∈ A.topologicalClosure
state_after: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
f g : ↥A
⊢ 2⁻¹ • (↑f + ↑g - |↑g - ↑f|) ∈ A.topologicalClosure
tactic: rw [inf_eq_half_smul_add_sub_abs_sub' ℝ]
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
f g : ↥A
⊢ 2⁻¹ • (↑f + ↑g - |↑g - ↑f|) ∈ A.topologicalClosure
state_after: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
f g : ↥A
⊢ |↑g - ↑f| ∈ A.topologicalClosure
tactic: refine
    A.topologicalClosure.smul_mem
      (A.topologicalClosure.sub_mem
        (A.topologicalClosure.add_mem (A.le_topologicalClosure f.property)
          (A.le_topologicalClosure g.property))
        ?_)
      _
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
f g : ↥A
⊢ |↑g - ↑f| ∈ A.topologicalClosure
state_after: no goals
tactic: exact mod_cast abs_mem_subalgebra_closure A _
Theorem: frontier_Ioc
File: Mathlib/Topology/Order/DenselyOrdered.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderTopology α
inst✝¹ : DenselyOrdered α
a✝ b✝ : α
s : Set α
inst✝ : NoMaxOrder α
a b : α
h : a < b
⊢ frontier (Ioc a b) = {a, b}
state_after: no goals
tactic: rw [frontier, closure_Ioc h.ne, interior_Ioc, Icc_diff_Ioo_same h.le]
Theorem: _private.Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass.0.WeierstrassCurve.VariableChange.comp_map
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
A : Type v
inst✝ : CommRing A
φ : R →+* A
C C' : VariableChange R
⊢ map φ (C.comp C') = (map φ C).comp (map φ C')
state_after: R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
A : Type v
inst✝ : CommRing A
φ : R →+* A
C C' : VariableChange R
⊢ { u := (Units.map ↑φ) (C.u * C'.u), r := φ (C.r * ↑C'.u ^ 2 + C'.r), s := φ (↑C'.u * C.s + C'.s),
      t := φ (C.t * ↑C'.u ^ 3 + C.r * C'.s * ↑C'.u ^ 2 + C'.t) } =
    { u := (Units.map ↑φ) C.u * (Units.map ↑φ) C'.u, r := φ C.r * ↑((Units.map ↑φ) C'.u) ^ 2 + φ C'.r,
      s := ↑((Units.map ↑φ) C'.u) * φ C.s + φ C'.s,
      t := φ C.t * ↑((Units.map ↑φ) C'.u) ^ 3 + φ C.r * φ C'.s * ↑((Units.map ↑φ) C'.u) ^ 2 + φ C'.t }
tactic: simp only [comp, map]
state_before: R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
A : Type v
inst✝ : CommRing A
φ : R →+* A
C C' : VariableChange R
⊢ { u := (Units.map ↑φ) (C.u * C'.u), r := φ (C.r * ↑C'.u ^ 2 + C'.r), s := φ (↑C'.u * C.s + C'.s),
      t := φ (C.t * ↑C'.u ^ 3 + C.r * C'.s * ↑C'.u ^ 2 + C'.t) } =
    { u := (Units.map ↑φ) C.u * (Units.map ↑φ) C'.u, r := φ C.r * ↑((Units.map ↑φ) C'.u) ^ 2 + φ C'.r,
      s := ↑((Units.map ↑φ) C'.u) * φ C.s + φ C'.s,
      t := φ C.t * ↑((Units.map ↑φ) C'.u) ^ 3 + φ C.r * φ C'.s * ↑((Units.map ↑φ) C'.u) ^ 2 + φ C'.t }
state_after: no goals
tactic: ext <;> map_simp <;> simp only [Units.coe_map, Units.coe_map_inv, MonoidHom.coe_coe]
Theorem: Matrix.TransvectionStruct.det_toMatrix_prod
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

Proof steps:
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
L : List (TransvectionStruct n 𝕜)
⊢ (List.map toMatrix L).prod.det = 1
state_after: case nil
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
⊢ (List.map toMatrix []).prod.det = 1

case cons
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
t : TransvectionStruct n 𝕜
L : List (TransvectionStruct n 𝕜)
IH : (List.map toMatrix L).prod.det = 1
⊢ (List.map toMatrix (t :: L)).prod.det = 1
tactic: induction' L with t L IH
Theorem: CategoryTheory.ShortComplex.Homotopy.equivSubZero_apply
File: Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.182898, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
⊢ Function.LeftInverse (fun h => ((ofEq ⋯).trans (h.add (refl φ₂))).trans (ofEq ⋯)) fun h =>
    (h.sub (refl φ₂)).trans (ofEq ⋯)
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
inst✝¹ : Category.{?u.182898, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
⊢ Function.RightInverse (fun h => ((ofEq ⋯).trans (h.add (refl φ₂))).trans (ofEq ⋯)) fun h =>
    (h.sub (refl φ₂)).trans (ofEq ⋯)
state_after: no goals
tactic: aesop_cat
Theorem: map_ratCast
File: Mathlib/Data/Rat/Cast/Defs.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝³ : FunLike F α β
inst✝² : DivisionRing α
inst✝¹ : DivisionRing β
inst✝ : RingHomClass F α β
f : F
q : ℚ
⊢ f ↑q = ↑q
state_after: no goals
tactic: rw [cast_def, map_div₀, map_intCast, map_natCast, cast_def]
Theorem: ContinuousMap.continuous_comp_left
File: Mathlib/Topology/CompactOpen.lean

Proof steps:
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace T
K✝ : Set X
U✝ : Set Y
f : C(X, Y)
K : Set X
hK : IsCompact K
U : Set Z
hU : IsOpen U
⊢ IsOpen {x | MapsTo (⇑(x.comp f)) K U}
state_after: no goals
tactic: simpa only [mapsTo_image_iff] using isOpen_setOf_mapsTo (hK.image f.2) hU
Theorem: Multiset.bind_zero
File: Mathlib/Data/Multiset/Bind.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f g : α → Multiset β
⊢ (s.bind fun x => 0) = 0
state_after: no goals
tactic: simp [bind, join, nsmul_zero]
Theorem: Polynomial.ne_zero_of_trailingDegree_lt
File: Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ∞
h : p.trailingDegree < n
h₀ : p = 0
⊢ n ≤ p.trailingDegree
state_after: no goals
tactic: simp [h₀]
Theorem: isAddUnit_of_add_isAddUnit_right
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : CommMonoid M
x y : M
hu : IsUnit (x * y)
⊢ IsUnit (y * x)
state_after: no goals
tactic: rwa [mul_comm]
Theorem: SimplexCategory.mono_iff_injective
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

Proof steps:
state_before: n m : SimplexCategory
f : n ⟶ m
⊢ Mono f ↔ Function.Injective ⇑(Hom.toOrderHom f)
state_after: n m : SimplexCategory
f : n ⟶ m
⊢ Mono (skeletalEquivalence.functor.map f) ↔ Function.Injective ⇑(Hom.toOrderHom f)
tactic: rw [← Functor.mono_map_iff_mono skeletalEquivalence.functor]
state_before: n m : SimplexCategory
f : n ⟶ m
⊢ Mono (skeletalEquivalence.functor.map f) ↔ Function.Injective ⇑(Hom.toOrderHom f)
state_after: n m : SimplexCategory
f : n ⟶ m
⊢ Mono (skeletalFunctor.map f) ↔ Function.Injective ⇑(Hom.toOrderHom f)
tactic: dsimp only [skeletalEquivalence, Functor.asEquivalence_functor]
state_before: n m : SimplexCategory
f : n ⟶ m
⊢ Mono (skeletalFunctor.map f) ↔ Function.Injective ⇑(Hom.toOrderHom f)
state_after: no goals
tactic: simp only [skeletalFunctor_obj, skeletalFunctor_map,
    NonemptyFinLinOrd.mono_iff_injective, NonemptyFinLinOrd.coe_of]
Theorem: IsSelfAdjoint.mul_star_self
File: Mathlib/Algebra/Star/SelfAdjoint.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝¹ : Mul R
inst✝ : StarMul R
x : R
⊢ IsSelfAdjoint (x * star x)
state_after: no goals
tactic: simpa only [star_star] using star_mul_self (star x)
Theorem: Basis.flag_last
File: Mathlib/LinearAlgebra/Basis/Flag.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
n : ℕ
b : Basis (Fin n) R M
⊢ b.flag (Fin.last n) = ⊤
state_after: no goals
tactic: simp [flag, Fin.castSucc_lt_last]