ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Finset.prod_disjiUnion
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
s : Finset ι
t : ι → Finset α
h : (↑s).PairwiseDisjoint t
⊢ ∏ x ∈ s.disjiUnion t h, f x = ∏ i ∈ s, ∏ x ∈ t i, f x
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
s : Finset ι
t : ι → Finset α
h : (↑s).PairwiseDisjoint t
⊢ ∏ x ∈ s.disjiUnion t h, f x =
    fold (fun x x_1 => x * x_1) (fold (fun x x_1 => x * x_1) 1 (fun i => 1) s) (fun x => f x) (s.disjiUnion t h)
tactic: refine Eq.trans ?_ (fold_disjiUnion h)
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
s : Finset ι
t : ι → Finset α
h : (↑s).PairwiseDisjoint t
⊢ ∏ x ∈ s.disjiUnion t h, f x =
    fold (fun x x_1 => x * x_1) (fold (fun x x_1 => x * x_1) 1 (fun i => 1) s) (fun x => f x) (s.disjiUnion t h)
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
s : Finset ι
t : ι → Finset α
h : (↑s).PairwiseDisjoint t
⊢ Multiset.foldr (fun x x_1 => x * x_1) ⋯ 1 (Multiset.map (fun x => f x) (s.val.bind fun a => (t a).val)) =
    Multiset.foldr (fun x x_1 => x * x_1) ⋯
      (Multiset.foldr (fun x x_1 => x * x_1) ⋯ 1 (Multiset.map (fun i => 1) s.val))
      (Multiset.map (fun x => f x) (s.val.bind fun a => (t a).val))
tactic: dsimp [Finset.prod, Multiset.prod, Multiset.fold, Finset.disjUnion, Finset.fold]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
s : Finset ι
t : ι → Finset α
h : (↑s).PairwiseDisjoint t
⊢ Multiset.foldr (fun x x_1 => x * x_1) ⋯ 1 (Multiset.map (fun x => f x) (s.val.bind fun a => (t a).val)) =
    Multiset.foldr (fun x x_1 => x * x_1) ⋯
      (Multiset.foldr (fun x x_1 => x * x_1) ⋯ 1 (Multiset.map (fun i => 1) s.val))
      (Multiset.map (fun x => f x) (s.val.bind fun a => (t a).val))
state_after: case e_b
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
s : Finset ι
t : ι → Finset α
h : (↑s).PairwiseDisjoint t
⊢ 1 = Multiset.foldr (fun x x_1 => x * x_1) ⋯ 1 (Multiset.map (fun i => 1) s.val)
tactic: congr
state_before: case e_b
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
s : Finset ι
t : ι → Finset α
h : (↑s).PairwiseDisjoint t
⊢ 1 = Multiset.foldr (fun x x_1 => x * x_1) ⋯ 1 (Multiset.map (fun i => 1) s.val)
state_after: no goals
tactic: exact prod_const_one.symm
Theorem: CategoryTheory.Idempotents.karoubiUniversal₁_functor
File: Mathlib/CategoryTheory/Idempotents/FunctorExtension.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.58582, u_1} C
inst✝¹ : Category.{?u.58586, u_2} D
inst✝ : Category.{?u.58590, u_3} E
F : C ⥤ Karoubi D
⊢ (functorExtension₁ C D).map ((functorExtension₁CompWhiskeringLeftToKaroubiIso C D).symm.hom.app F) ≫
      (KaroubiUniversal₁.counitIso C D).hom.app ((functorExtension₁ C D).obj F) =
    𝟙 ((functorExtension₁ C D).obj F)
state_after: case w.h.h
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.58582, u_1} C
inst✝¹ : Category.{?u.58586, u_2} D
inst✝ : Category.{?u.58590, u_3} E
F : C ⥤ Karoubi D
P : Karoubi C
⊢ (((functorExtension₁ C D).map ((functorExtension₁CompWhiskeringLeftToKaroubiIso C D).symm.hom.app F) ≫
            (KaroubiUniversal₁.counitIso C D).hom.app ((functorExtension₁ C D).obj F)).app
        P).f =
    ((𝟙 ((functorExtension₁ C D).obj F)).app P).f
tactic: ext P
state_before: case w.h.h
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.58582, u_1} C
inst✝¹ : Category.{?u.58586, u_2} D
inst✝ : Category.{?u.58590, u_3} E
F : C ⥤ Karoubi D
P : Karoubi C
⊢ (((functorExtension₁ C D).map ((functorExtension₁CompWhiskeringLeftToKaroubiIso C D).symm.hom.app F) ≫
            (KaroubiUniversal₁.counitIso C D).hom.app ((functorExtension₁ C D).obj F)).app
        P).f =
    ((𝟙 ((functorExtension₁ C D).obj F)).app P).f
state_after: case w.h.h
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.58582, u_1} C
inst✝¹ : Category.{?u.58586, u_2} D
inst✝ : Category.{?u.58590, u_3} E
F : C ⥤ Karoubi D
P : Karoubi C
⊢ ((F.map P.p).f ≫ (F.obj P.X).p) ≫ (F.map P.p).f = (F.map P.p).f
tactic: dsimp
state_before: case w.h.h
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.58582, u_1} C
inst✝¹ : Category.{?u.58586, u_2} D
inst✝ : Category.{?u.58590, u_3} E
F : C ⥤ Karoubi D
P : Karoubi C
⊢ ((F.map P.p).f ≫ (F.obj P.X).p) ≫ (F.map P.p).f = (F.map P.p).f
state_after: no goals
tactic: rw [comp_p, ← comp_f, ← F.map_comp, P.idem]
Theorem: FormalMultilinearSeries.nnnorm_changeOriginSeries_apply_le_tsum
File: Mathlib/Analysis/Analytic/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
x✝ y : E
r R : ℝ≥0
k l : ℕ
x : E
⊢ ‖(p.changeOriginSeries k l) fun x_1 => x‖₊ ≤ ∑' (x_1 : { s // s.card = l }), ‖p (k + l)‖₊ * ‖x‖₊ ^ l
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
x✝ y : E
r R : ℝ≥0
k l : ℕ
x : E
⊢ ‖(p.changeOriginSeries k l) fun x_1 => x‖₊ ≤ (∑' (x : { s // s.card = l }), ‖p (k + l)‖₊) * ∏ _i : Fin l, ‖x‖₊
tactic: rw [NNReal.tsum_mul_right, ← Fin.prod_const]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
x✝ y : E
r R : ℝ≥0
k l : ℕ
x : E
⊢ ‖(p.changeOriginSeries k l) fun x_1 => x‖₊ ≤ (∑' (x : { s // s.card = l }), ‖p (k + l)‖₊) * ∏ _i : Fin l, ‖x‖₊
state_after: no goals
tactic: exact (p.changeOriginSeries k l).le_of_opNNNorm_le _ (p.nnnorm_changeOriginSeries_le_tsum _ _)
Theorem: MeasureTheory.Measure.rnDeriv_restrict
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝¹ : μ.HaveLebesgueDecomposition ν
inst✝ : SigmaFinite ν
s : Set α
hs : MeasurableSet s
⊢ (μ.restrict s).rnDeriv ν =ᶠ[ae ν] s.indicator (μ.rnDeriv ν)
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝¹ : μ.HaveLebesgueDecomposition ν
inst✝ : SigmaFinite ν
s : Set α
hs : MeasurableSet s
⊢ μ.restrict s = (μ.restrict s).singularPart ν + ν.withDensity (s.indicator (μ.rnDeriv ν))
tactic: refine (eq_rnDeriv (s := (μ.restrict s).singularPart ν)
    ((measurable_rnDeriv _ _).indicator hs) (mutuallySingular_singularPart _ _) ?_).symm
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝¹ : μ.HaveLebesgueDecomposition ν
inst✝ : SigmaFinite ν
s : Set α
hs : MeasurableSet s
⊢ μ.restrict s = (μ.restrict s).singularPart ν + ν.withDensity (s.indicator (μ.rnDeriv ν))
state_after: no goals
tactic: rw [singularPart_restrict _ _ hs, withDensity_indicator hs, ← restrict_withDensity hs,
    ← Measure.restrict_add, ← μ.haveLebesgueDecomposition_add ν]
Theorem: MeasureTheory.IsSetSemiring.diffFinset_subset
File: Mathlib/MeasureTheory/SetSemiring.lean

Proof steps:
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
hC : IsSetSemiring C
hs : s ∈ C
ht : t ∈ C
⊢ ↑(hC.diffFinset hs ht) ⊆ C
state_after: no goals
tactic: classical
  simp only [diffFinset, coe_sdiff, coe_singleton, diff_singleton_subset_iff]
  exact (hC.diff_eq_sUnion' s hs t ht).choose_spec.1.trans (Set.subset_insert _ _)
Theorem: WeierstrassCurve.Jacobian.eval_polynomialY
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
⊢ (eval P) W'.polynomialY = 2 * P y + W'.a₁ * P x * P z + W'.a₃ * P z ^ 3
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
⊢ (eval P) (C 2 * X y + C W'.a₁ * X x * X z + C W'.a₃ * X z ^ 3) = 2 * P y + W'.a₁ * P x * P z + W'.a₃ * P z ^ 3
tactic: rw [polynomialY_eq]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
⊢ (eval P) (C 2 * X y + C W'.a₁ * X x * X z + C W'.a₃ * X z ^ 3) = 2 * P y + W'.a₁ * P x * P z + W'.a₃ * P z ^ 3
state_after: no goals
tactic: eval_simp
Theorem: IsPGroup.card_eq_or_dvd
File: Mathlib/GroupTheory/PGroup.lean

Proof steps:
state_before: p : ℕ
G : Type u_1
inst✝ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
⊢ Nat.card G = 1 ∨ p ∣ Nat.card G
state_after: case inl
p : ℕ
G : Type u_1
inst✝ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
h✝ : Finite G
⊢ Nat.card G = 1 ∨ p ∣ Nat.card G

case inr
p : ℕ
G : Type u_1
inst✝ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
h✝ : Infinite G
⊢ Nat.card G = 1 ∨ p ∣ Nat.card G
tactic: cases finite_or_infinite G
Theorem: Filter.iSup_ultrafilter_le_eq
File: Mathlib/Order/Filter/Ultrafilter.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type u_1
f✝ : Filter α
s : Set α
a : α
f f' : Filter α
⊢ ⨆ g, ⨆ (_ : ↑g ≤ f), ↑g ≤ f' ↔ f ≤ f'
state_after: no goals
tactic: simp only [iSup_le_iff, ← le_iff_ultrafilter]
Theorem: MulAction.pow_mod_period_smul
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type v
G : Type u
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u
inst✝¹ : Monoid M
inst✝ : MulAction M α
n : ℕ
m : M
a : α
⊢ m ^ (n % period m a) • a = m ^ n • a
state_after: no goals
tactic: conv_rhs => rw [← Nat.mod_add_div n (period m a), pow_add, mul_smul,
    pow_smul_eq_iff_period_dvd.mpr (dvd_mul_right _ _)]
Theorem: norm_fderiv_le_of_lipschitzOn
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s✝ t : Set E
L L₁ L₂ : Filter E
f : E → F
x₀ : E
s : Set E
hs : s ∈ 𝓝 x₀
C : ℝ≥0
hlip : LipschitzOnWith C f s
⊢ ‖fderiv 𝕜 f x₀‖ ≤ ↑C
state_after: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s✝ t : Set E
L L₁ L₂ : Filter E
f : E → F
x₀ : E
s : Set E
hs : s ∈ 𝓝 x₀
C : ℝ≥0
hlip : LipschitzOnWith C f s
⊢ ∀ᶠ (x : E) in 𝓝 x₀, ‖f x - f x₀‖ ≤ ↑C * ‖x - x₀‖
tactic: refine norm_fderiv_le_of_lip' 𝕜 C.coe_nonneg ?_
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s✝ t : Set E
L L₁ L₂ : Filter E
f : E → F
x₀ : E
s : Set E
hs : s ∈ 𝓝 x₀
C : ℝ≥0
hlip : LipschitzOnWith C f s
⊢ ∀ᶠ (x : E) in 𝓝 x₀, ‖f x - f x₀‖ ≤ ↑C * ‖x - x₀‖
state_after: no goals
tactic: filter_upwards [hs] with x hx using hlip.norm_sub_le hx (mem_of_mem_nhds hs)
Theorem: CategoryTheory.FunctorToTypes.prod.lift_app
File: Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
F G F₁ F₂ : C ⥤ Type w
τ₁ : F ⟶ F₁
τ₂ : F ⟶ F₂
x✝² x✝¹ : C
x✝ : x✝² ⟶ x✝¹
⊢ F.map x✝ ≫ (fun x y => (τ₁.app x y, τ₂.app x y)) x✝¹ = (fun x y => (τ₁.app x y, τ₂.app x y)) x✝² ≫ (prod F₁ F₂).map x✝
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
F G F₁ F₂ : C ⥤ Type w
τ₁ : F ⟶ F₁
τ₂ : F ⟶ F₂
x✝² x✝¹ : C
x✝ : x✝² ⟶ x✝¹
a : F.obj x✝²
⊢ (F.map x✝ ≫ (fun x y => (τ₁.app x y, τ₂.app x y)) x✝¹) a =
    ((fun x y => (τ₁.app x y, τ₂.app x y)) x✝² ≫ (prod F₁ F₂).map x✝) a
tactic: ext a
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
F G F₁ F₂ : C ⥤ Type w
τ₁ : F ⟶ F₁
τ₂ : F ⟶ F₂
x✝² x✝¹ : C
x✝ : x✝² ⟶ x✝¹
a : F.obj x✝²
⊢ (F.map x✝ ≫ (fun x y => (τ₁.app x y, τ₂.app x y)) x✝¹) a =
    ((fun x y => (τ₁.app x y, τ₂.app x y)) x✝² ≫ (prod F₁ F₂).map x✝) a
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
F G F₁ F₂ : C ⥤ Type w
τ₁ : F ⟶ F₁
τ₂ : F ⟶ F₂
x✝² x✝¹ : C
x✝ : x✝² ⟶ x✝¹
a : F.obj x✝²
⊢ (F₁.map x✝ (τ₁.app x✝² a), F₂.map x✝ (τ₂.app x✝² a)) = (prod F₁ F₂).map x✝ (τ₁.app x✝² a, τ₂.app x✝² a)
tactic: simp only [types_comp_apply, FunctorToTypes.naturality]
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
F G F₁ F₂ : C ⥤ Type w
τ₁ : F ⟶ F₁
τ₂ : F ⟶ F₂
x✝² x✝¹ : C
x✝ : x✝² ⟶ x✝¹
a : F.obj x✝²
⊢ (F₁.map x✝ (τ₁.app x✝² a), F₂.map x✝ (τ₂.app x✝² a)) = (prod F₁ F₂).map x✝ (τ₁.app x✝² a, τ₂.app x✝² a)
state_after: no goals
tactic: aesop
Theorem: Urysohns.CU.lim_of_nmem_U
File: Mathlib/Topology/UrysohnsLemma.lean

Proof steps:
state_before: X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
c : CU P
x : X
h : x ∉ c.U
⊢ c.lim x = 1
state_after: no goals
tactic: simp only [CU.lim, approx_of_nmem_U c _ h, ciSup_const]
Theorem: Specializes.not_disjoint
File: Mathlib/Topology/Inseparable.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f g : X → Y
h : x ⤳ y
hd : _root_.Disjoint (𝓝 x) (𝓝 y)
⊢ ¬_root_.Disjoint (𝓝 x) (𝓝 x)
state_after: no goals
tactic: simp [NeBot.ne']
Theorem: TopologicalSpace.Opens.inclusion_map_eq_top
File: Mathlib/Topology/Category/TopCat/Opens.lean

Proof steps:
state_before: X : TopCat
U : Opens ↑X
⊢ (map U.inclusion).obj U = ⊤
state_after: case h
X : TopCat
U : Opens ↑X
⊢ ↑((map U.inclusion).obj U) = ↑⊤
tactic: ext1
state_before: case h
X : TopCat
U : Opens ↑X
⊢ ↑((map U.inclusion).obj U) = ↑⊤
state_after: no goals
tactic: exact Subtype.coe_preimage_self _
Theorem: SetTheory.PGame.Subsequent.moveRight_mk_right
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
xL : xl → PGame
i : xr
xR : xr → PGame
j : (xR i).RightMoves
⊢ ((xR i).moveRight j).Subsequent (mk xl xr xL xR)
state_after: no goals
tactic: pgame_wf_tac
Theorem: integral_exp
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

Proof steps:
state_before: a b : ℝ
n : ℕ
⊢ ∫ (x : ℝ) in a..b, rexp x = rexp b - rexp a
state_after: case hderiv
a b : ℝ
n : ℕ
⊢ deriv rexp = rexp

case hdiff
a b : ℝ
n : ℕ
⊢ ∀ x ∈ [[a, b]], DifferentiableAt ℝ rexp x

case hcont
a b : ℝ
n : ℕ
⊢ ContinuousOn rexp [[a, b]]
tactic: rw [integral_deriv_eq_sub']
Theorem: SignType.castHom_apply
File: Mathlib/Data/Sign.lean

Proof steps:
state_before: α : Type ?u.51176
inst✝¹ : MulZeroOneClass α
inst✝ : HasDistribNeg α
x y : SignType
⊢ { toFun := cast, map_zero' := ⋯ }.toFun (x * y) =
    { toFun := cast, map_zero' := ⋯ }.toFun x * { toFun := cast, map_zero' := ⋯ }.toFun y
state_after: no goals
tactic: cases x <;> cases y <;> simp [zero_eq_zero, pos_eq_one, neg_eq_neg_one]
Theorem: Set.eq_of_mem_uIoc_of_mem_uIoc
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ a ∈ Ι b c → b ∈ Ι a c → a = b
state_after: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ b < a ∧ a ≤ c ∨ c < a ∧ a ≤ b → a < b ∧ b ≤ c ∨ c < b ∧ b ≤ a → a = b
tactic: simp_rw [mem_uIoc]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ b < a ∧ a ≤ c ∨ c < a ∧ a ≤ b → a < b ∧ b ≤ c ∨ c < b ∧ b ≤ a → a = b
state_after: no goals
tactic: rintro (⟨_, _⟩ | ⟨_, _⟩) (⟨_, _⟩ | ⟨_, _⟩) <;> apply le_antisymm <;>
    first |assumption|exact le_of_lt ‹_›|exact le_trans ‹_› (le_of_lt ‹_›)
Theorem: Ideal.IsHomogeneous.radical
File: Mathlib/RingTheory/GradedAlgebra/Radical.lean

Proof steps:
state_before: ι : Type u_1
σ : Type u_2
A : Type u_3
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
h : IsHomogeneous 𝒜 I
⊢ IsHomogeneous 𝒜 I.radical
state_after: ι : Type u_1
σ : Type u_2
A : Type u_3
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
h : IsHomogeneous 𝒜 I
⊢ IsHomogeneous 𝒜 (InfSet.sInf {J | IsHomogeneous 𝒜 J ∧ I ≤ J ∧ J.IsPrime})
tactic: rw [h.radical_eq]
state_before: ι : Type u_1
σ : Type u_2
A : Type u_3
inst✝⁴ : CommRing A
inst✝³ : LinearOrderedCancelAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
h : IsHomogeneous 𝒜 I
⊢ IsHomogeneous 𝒜 (InfSet.sInf {J | IsHomogeneous 𝒜 J ∧ I ≤ J ∧ J.IsPrime})
state_after: no goals
tactic: exact Ideal.IsHomogeneous.sInf fun _ => And.left
Theorem: AddCommGrp.epi_iff_surjective
File: Mathlib/Algebra/Category/Grp/EpiMono.lean

Proof steps:
state_before: A B : CommGrp
f : A ⟶ B
⊢ Epi f ↔ Function.Surjective ⇑f
state_after: no goals
tactic: rw [epi_iff_range_eq_top, MonoidHom.range_top_iff_surjective]
Theorem: AddMonoidHom.coe_addMonoidHom_mkRingHomOfMulSelfOfTwoNeZero
File: Mathlib/Algebra/Ring/Hom/Defs.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommRing α
inst✝¹ : IsDomain α
inst✝ : CommRing β
f : β →+ α
h : ∀ (x : β), f (x * x) = f x * f x
h_two : 2 ≠ 0
h_one : f 1 = 1
⊢ ↑(f.mkRingHomOfMulSelfOfTwoNeZero h h_two h_one) = f
state_after: case h
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommRing α
inst✝¹ : IsDomain α
inst✝ : CommRing β
f : β →+ α
h : ∀ (x : β), f (x * x) = f x * f x
h_two : 2 ≠ 0
h_one : f 1 = 1
x✝ : β
⊢ ↑(f.mkRingHomOfMulSelfOfTwoNeZero h h_two h_one) x✝ = f x✝
tactic: ext
state_before: case h
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommRing α
inst✝¹ : IsDomain α
inst✝ : CommRing β
f : β →+ α
h : ∀ (x : β), f (x * x) = f x * f x
h_two : 2 ≠ 0
h_one : f 1 = 1
x✝ : β
⊢ ↑(f.mkRingHomOfMulSelfOfTwoNeZero h h_two h_one) x✝ = f x✝
state_after: no goals
tactic: rfl
Theorem: CliffordAlgebraComplex.reverse_apply
File: Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean

Proof steps:
state_before: x : CliffordAlgebra Q
⊢ reverse x = x
state_after: no goals
tactic: induction x using CliffordAlgebra.induction with
  | algebraMap r => exact reverse.commutes _
  | ι x => rw [reverse_ι]
  | mul x₁ x₂ hx₁ hx₂ => rw [reverse.map_mul, mul_comm, hx₁, hx₂]
  | add x₁ x₂ hx₁ hx₂ => rw [reverse.map_add, hx₁, hx₂]
Theorem: tendsto_mulIndicator_thickening_mulIndicator_closure
File: Mathlib/Topology/MetricSpace/ThickenedIndicator.lean

Proof steps:
state_before: α : Type u_1
inst✝² : PseudoEMetricSpace α
β : Type u_2
inst✝¹ : One β
inst✝ : TopologicalSpace β
f : α → β
E : Set α
⊢ Tendsto (fun δ => (thickening δ E).mulIndicator f) (𝓝[>] 0) (𝓝 ((closure E).mulIndicator f))
state_after: α : Type u_1
inst✝² : PseudoEMetricSpace α
β : Type u_2
inst✝¹ : One β
inst✝ : TopologicalSpace β
f : α → β
E : Set α
⊢ ∀ (x : α), Tendsto (fun i => (thickening i E).mulIndicator f x) (𝓝[>] 0) (𝓝 ((closure E).mulIndicator f x))
tactic: rw [tendsto_pi_nhds]
state_before: α : Type u_1
inst✝² : PseudoEMetricSpace α
β : Type u_2
inst✝¹ : One β
inst✝ : TopologicalSpace β
f : α → β
E : Set α
⊢ ∀ (x : α), Tendsto (fun i => (thickening i E).mulIndicator f x) (𝓝[>] 0) (𝓝 ((closure E).mulIndicator f x))
state_after: α : Type u_1
inst✝² : PseudoEMetricSpace α
β : Type u_2
inst✝¹ : One β
inst✝ : TopologicalSpace β
f : α → β
E : Set α
x : α
⊢ Tendsto (fun i => (thickening i E).mulIndicator f x) (𝓝[>] 0) (𝓝 ((closure E).mulIndicator f x))
tactic: intro x
state_before: α : Type u_1
inst✝² : PseudoEMetricSpace α
β : Type u_2
inst✝¹ : One β
inst✝ : TopologicalSpace β
f : α → β
E : Set α
x : α
⊢ Tendsto (fun i => (thickening i E).mulIndicator f x) (𝓝[>] 0) (𝓝 ((closure E).mulIndicator f x))
state_after: α : Type u_1
inst✝² : PseudoEMetricSpace α
β : Type u_2
inst✝¹ : One β
inst✝ : TopologicalSpace β
f : α → β
E : Set α
x : α
⊢ Tendsto (fun x_1 => (closure E).mulIndicator f x) (𝓝[>] 0) (𝓝 ((closure E).mulIndicator f x))
tactic: rw [tendsto_congr' (mulIndicator_thickening_eventually_eq_mulIndicator_closure f E x)]
state_before: α : Type u_1
inst✝² : PseudoEMetricSpace α
β : Type u_2
inst✝¹ : One β
inst✝ : TopologicalSpace β
f : α → β
E : Set α
x : α
⊢ Tendsto (fun x_1 => (closure E).mulIndicator f x) (𝓝[>] 0) (𝓝 ((closure E).mulIndicator f x))
state_after: no goals
tactic: apply tendsto_const_nhds
Theorem: LinearMapClass.map_smul
File: Mathlib/Algebra/Module/LinearMap/Defs.lean

Proof steps:
state_before: R✝ : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
k : Type u_5
S : Type u_6
S₃ : Type u_7
T : Type u_8
M✝ : Type u_9
M₁ : Type u_10
M₂✝ : Type u_11
M₃ : Type u_12
N₁ : Type u_13
N₂ : Type u_14
N₃ : Type u_15
ι : Type u_16
R : outParam (Type u_17)
M : outParam (Type u_18)
M₂ : outParam (Type u_19)
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M
inst✝² : Module R M₂
F : Type u_20
inst✝¹ : FunLike F M M₂
inst✝ : LinearMapClass F R M M₂
f : F
r : R
x : M
⊢ f (r • x) = r • f x
state_after: no goals
tactic: rw [_root_.map_smul]
Theorem: CategoryTheory.Center.associator_inv_f
File: Mathlib/CategoryTheory/Monoidal/Center.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y Z : Center C
⊢ (α_ X Y Z).inv.f = (α_ X.fst Y.fst Z.fst).inv
state_after: case hom_inv_id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y Z : Center C
⊢ (α_ X.fst Y.fst Z.fst).hom ≫ (α_ X Y Z).inv.f = 𝟙 ((X ⊗ Y) ⊗ Z).fst
tactic: apply Iso.inv_ext'
state_before: case hom_inv_id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y Z : Center C
⊢ (α_ X.fst Y.fst Z.fst).hom ≫ (α_ X Y Z).inv.f = 𝟙 ((X ⊗ Y) ⊗ Z).fst
state_after: case hom_inv_id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y Z : Center C
⊢ (𝟙 ((X ⊗ Y) ⊗ Z)).f = 𝟙 ((X ⊗ Y) ⊗ Z).fst
tactic: rw [← associator_hom_f, ← comp_f, Iso.hom_inv_id]
state_before: case hom_inv_id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y Z : Center C
⊢ (𝟙 ((X ⊗ Y) ⊗ Z)).f = 𝟙 ((X ⊗ Y) ⊗ Z).fst
state_after: no goals
tactic: rfl
Theorem: Nat.binCast_eq
File: Mathlib/Data/Nat/Cast/Defs.lean

Proof steps:
state_before: R : Type u_1
inst✝ : AddMonoidWithOne R
n : ℕ
⊢ n.binCast = ↑n
state_after: R : Type u_1
inst✝ : AddMonoidWithOne R
n : ℕ
⊢ ∀ (n : ℕ), (∀ (m : ℕ), m < n → m.binCast = ↑m) → n.binCast = ↑n
tactic: apply Nat.strongInductionOn n
state_before: R : Type u_1
inst✝ : AddMonoidWithOne R
n : ℕ
⊢ ∀ (n : ℕ), (∀ (m : ℕ), m < n → m.binCast = ↑m) → n.binCast = ↑n
state_after: R : Type u_1
inst✝ : AddMonoidWithOne R
n k : ℕ
hk : ∀ (m : ℕ), m < k → m.binCast = ↑m
⊢ k.binCast = ↑k
tactic: intros k hk
Theorem: Ordering.ite_eq_lt_distrib
File: Mathlib/Data/Ordering/Lemmas.lean

Proof steps:
state_before: c : Prop
inst✝ : Decidable c
a b : Ordering
⊢ ((if c then a else b) = lt) = if c then a = lt else b = lt
state_after: no goals
tactic: by_cases c <;> simp [*]