ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.SmallObject.ιFunctorObj_πFunctorObj
File: Mathlib/CategoryTheory/SmallObject/Construction.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
I : Type w
A B : I → C
f : (i : I) → A i ⟶ B i
S X Y Z : C
πX : X ⟶ S
πY : Y ⟶ S
φ : X ⟶ Y
inst✝² : HasColimitsOfShape (Discrete (FunctorObjIndex f πX)) C
inst✝¹ : HasColimitsOfShape (Discrete (FunctorObjIndex f πY)) C
inst✝ : HasPushout (functorObjTop f πX) (functorObjLeft f πX)
⊢ ιFunctorObj f πX ≫ πFunctorObj f πX = πX
state_after: no goals
tactic: simp [ιFunctorObj, πFunctorObj]
Theorem: Set.zero_mul_subset
File: Mathlib/Data/Set/Pointwise/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : MulZeroClass α
s✝ t s : Set α
⊢ 0 * s ⊆ 0
state_after: no goals
tactic: simp [subset_def, mem_mul]
Theorem: Array.size_zipWith
File: .lake/packages/batteries/Batteries/Data/Array/Lemmas.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
as : Array α
bs : Array β
f : α → β → γ
⊢ (as.zipWith bs f).size = min as.size bs.size
state_after: no goals
tactic: rw [size_eq_length_data, zipWith_eq_zipWith_data, List.length_zipWith]
Theorem: Part.Dom.bind
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
h : o.Dom
f : α → Part β
⊢ o.bind f = f (o.get h)
state_after: case H
α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
h : o.Dom
f : α → Part β
b : β
⊢ b ∈ o.bind f ↔ b ∈ f (o.get h)
tactic: ext b
state_before: case H
α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
h : o.Dom
f : α → Part β
b : β
⊢ b ∈ o.bind f ↔ b ∈ f (o.get h)
state_after: case H
α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
h : o.Dom
f : α → Part β
b : β
⊢ (∃ a ∈ o, b ∈ f a) ↔ b ∈ f (o.get h)
tactic: simp only [Part.mem_bind_iff, exists_prop]
state_before: case H
α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
h : o.Dom
f : α → Part β
b : β
⊢ (∃ a ∈ o, b ∈ f a) ↔ b ∈ f (o.get h)
state_after: case H
α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
h : o.Dom
f : α → Part β
b : β
⊢ (∃ a ∈ o, b ∈ f a) → b ∈ f (o.get h)
tactic: refine ⟨?_, fun hb => ⟨o.get h, Part.get_mem _, hb⟩⟩
state_before: case H
α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
h : o.Dom
f : α → Part β
b : β
⊢ (∃ a ∈ o, b ∈ f a) → b ∈ f (o.get h)
state_after: case H.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
h : o.Dom
f : α → Part β
b : β
a : α
ha : a ∈ o
hb : b ∈ f a
⊢ b ∈ f (o.get h)
tactic: rintro ⟨a, ha, hb⟩
state_before: case H.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
o : Part α
h : o.Dom
f : α → Part β
b : β
a : α
ha : a ∈ o
hb : b ∈ f a
⊢ b ∈ f (o.get h)
state_after: no goals
tactic: rwa [Part.get_eq_of_mem ha]
Theorem: DifferentiableOn.sub_iff_right
File: Mathlib/Analysis/Calculus/FDeriv/Add.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
hg : DifferentiableOn 𝕜 f s
⊢ DifferentiableOn 𝕜 (fun y => f y - g y) s ↔ DifferentiableOn 𝕜 g s
state_after: no goals
tactic: simp only [sub_eq_add_neg, differentiableOn_neg_iff, hg, add_iff_right]
Theorem: cfcₙ_neg_id
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹² : CommRing R
inst✝¹¹ : Nontrivial R
inst✝¹⁰ : StarRing R
inst✝⁹ : MetricSpace R
inst✝⁸ : TopologicalRing R
inst✝⁷ : ContinuousStar R
inst✝⁶ : TopologicalSpace A
inst✝⁵ : NonUnitalRing A
inst✝⁴ : StarRing A
inst✝³ : Module R A
inst✝² : IsScalarTower R A A
inst✝¹ : SMulCommClass R A A
inst✝ : NonUnitalContinuousFunctionalCalculus R p
f g : R → R
a : A
hf : autoParam (ContinuousOn f (σₙ R a)) _auto✝
hf0 : autoParam (f 0 = 0) _auto✝
hg : autoParam (ContinuousOn g (σₙ R a)) _auto✝
hg0 : autoParam (g 0 = 0) _auto✝
ha : autoParam (p a) _auto✝
⊢ cfcₙ (fun x => -x) a = -a
state_after: no goals
tactic: rw [cfcₙ_neg .., cfcₙ_id' R a]
Theorem: Subgroup.noncommPiCoprod_range
File: Mathlib/GroupTheory/NoncommPiCoprod.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
ι : Type u_2
hdec : DecidableEq ι
hfin : Fintype ι
H : ι → Subgroup G
f g : (i : ι) → ↥(H i)
hcomm : Pairwise fun i j => ∀ (x y : G), x ∈ H i → y ∈ H j → Commute x y
⊢ (noncommPiCoprod hcomm).range = ⨆ i, H i
state_after: no goals
tactic: simp [noncommPiCoprod, MonoidHom.noncommPiCoprod_range]
Theorem: Nat.ModEq.mul_right_cancel'
File: Mathlib/Data/Nat/ModEq.lean

Proof steps:
state_before: m✝ n a✝ b✝ c✝ d a b c m : ℕ
hc : c ≠ 0
⊢ a * c ≡ b * c [MOD m * c] → a ≡ b [MOD m]
state_after: no goals
tactic: simp [modEq_iff_dvd, ← sub_mul, mul_dvd_mul_iff_right (by simp [hc] : (c : ℤ) ≠ 0)]
Theorem: CategoryTheory.GrothendieckTopology.toSheafify_comp_sheafifyCompIso_inv
File: Mathlib/CategoryTheory/Sites/CompatibleSheafification.lean

Proof steps:
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
inst✝ : (X : C) → (W : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P : Cᵒᵖ ⥤ D
⊢ J.toSheafify (P ⋙ F) ≫ (J.sheafifyCompIso F P).inv = whiskerRight (J.toSheafify P) F
state_after: C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
inst✝ : (X : C) → (W : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P : Cᵒᵖ ⥤ D
⊢ J.toSheafify (P ⋙ F) = whiskerRight (J.toSheafify P) F ≫ (J.sheafifyCompIso F P).hom
tactic: rw [Iso.comp_inv_eq]
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ F
inst✝ : (X : C) → (W : J.Cover X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (W.index P).multicospan F
P : Cᵒᵖ ⥤ D
⊢ J.toSheafify (P ⋙ F) = whiskerRight (J.toSheafify P) F ≫ (J.sheafifyCompIso F P).hom
state_after: no goals
tactic: simp
Theorem: AkraBazziRecurrence.growsPolynomially_deriv_rpow_p_mul_one_add_smoothingFn
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
p : ℝ
⊢ GrowsPolynomially fun x => ‖deriv (fun z => z ^ p * (1 + ε z)) x‖
state_after: no goals
tactic: cases eq_or_ne p 0 with
  | inl hp => -- p = 0
    have h₁ : (fun x => ‖deriv (fun z => z ^ p * (1 + ε z)) x‖)
        =ᶠ[atTop] fun z => z⁻¹ / (log z ^ 2) := by
      filter_upwards [eventually_deriv_one_add_smoothingFn, eventually_gt_atTop 1] with x hx hx_pos
      have : 0 ≤ x⁻¹ / (log x ^ 2) := by
        have hlog : 0 < log x := Real.log_pos hx_pos
        positivity
      simp only [neg_div, norm_neg, hp, Real.rpow_zero,
        one_mul, differentiableAt_const, hx, Real.norm_of_nonneg this]
    refine GrowsPolynomially.congr_of_eventuallyEq h₁ ?_
    refine GrowsPolynomially.div (GrowsPolynomially.inv growsPolynomially_id)
      (GrowsPolynomially.pow 2 growsPolynomially_log ?_)
    filter_upwards [eventually_ge_atTop 1] with x hx
    exact log_nonneg hx
  | inr hp => -- p ≠ 0
    refine GrowsPolynomially.of_isTheta (growsPolynomially_rpow (p-1))
      (isTheta_deriv_rpow_p_mul_one_add_smoothingFn hp) ?_
    filter_upwards [eventually_gt_atTop 0] with _ _
    positivity
Theorem: DiscreteQuotient.map_id
File: Mathlib/Topology/DiscreteQuotient.lean

Proof steps:
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S : DiscreteQuotient X
f : C(X, Y)
A A' : DiscreteQuotient X
B B' : DiscreteQuotient Y
g : C(Y, Z)
C : DiscreteQuotient Z
⊢ map (ContinuousMap.id X) ⋯ = id
state_after: case h.mk
α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S : DiscreteQuotient X
f : C(X, Y)
A A' : DiscreteQuotient X
B B' : DiscreteQuotient Y
g : C(Y, Z)
C : DiscreteQuotient Z
x✝ : Quotient A.toSetoid
a✝ : X
⊢ map (ContinuousMap.id X) ⋯ (Quot.mk Setoid.r a✝) = id (Quot.mk Setoid.r a✝)
tactic: ext ⟨⟩
state_before: case h.mk
α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S : DiscreteQuotient X
f : C(X, Y)
A A' : DiscreteQuotient X
B B' : DiscreteQuotient Y
g : C(Y, Z)
C : DiscreteQuotient Z
x✝ : Quotient A.toSetoid
a✝ : X
⊢ map (ContinuousMap.id X) ⋯ (Quot.mk Setoid.r a✝) = id (Quot.mk Setoid.r a✝)
state_after: no goals
tactic: rfl
Theorem: finrank_eq_one_iff_of_nonzero
File: Mathlib/LinearAlgebra/FiniteDimensional/Defs.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
nz : v ≠ 0
h : finrank K V = 1
⊢ span K {v} = ⊤
state_after: no goals
tactic: simpa using (basisSingleton Unit h v nz).span_eq
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
nz : v ≠ 0
s : span K {v} = ⊤
⊢ ⊤ ≤ span K (Set.range fun x => ↑x)
state_after: case h.e'_4.h.e'_6
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
nz : v ≠ 0
s : span K {v} = ⊤
⊢ (Set.range fun x => ↑x) = {v}
tactic: convert s.ge
state_before: case h.e'_4.h.e'_6
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
nz : v ≠ 0
s : span K {v} = ⊤
⊢ (Set.range fun x => ↑x) = {v}
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Pi.evalCompEqToEquivalenceFunctor_inv
File: Mathlib/CategoryTheory/Pi/Basic.lean

Proof steps:
state_before: I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝ : (i : I) → Category.{v₁, u₁} (C i)
i j : I
h : i = j
⊢ eval C i ⋙ (eqToEquivalence C h).functor = eval C j
state_after: I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝ : (i : I) → Category.{v₁, u₁} (C i)
i : I
⊢ eval C i ⋙ (eqToEquivalence C ⋯).functor = eval C i
tactic: subst h
state_before: I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝ : (i : I) → Category.{v₁, u₁} (C i)
i : I
⊢ eval C i ⋙ (eqToEquivalence C ⋯).functor = eval C i
state_after: no goals
tactic: rfl
Theorem: Real.coe_sqrt
File: Mathlib/Data/Real/Sqrt.lean

Proof steps:
state_before: x✝ y : ℝ
x : ℝ≥0
⊢ ↑(NNReal.sqrt x) = √↑x
state_after: no goals
tactic: rw [Real.sqrt, Real.toNNReal_coe]
Theorem: MeasureTheory.Measure.integral_compProd
File: Mathlib/Probability/Kernel/MeasureCompProd.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
κ η : Kernel α β
inst✝³ : SFinite μ
inst✝² : IsSFiniteKernel κ
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : α × β → E
hf : Integrable f (μ ⊗ₘ κ)
⊢ ∫ (x : α × β), f x ∂μ ⊗ₘ κ = ∫ (a : α), ∫ (b : β), f (a, b) ∂κ a ∂μ
state_after: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
κ η : Kernel α β
inst✝³ : SFinite μ
inst✝² : IsSFiniteKernel κ
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : α × β → E
hf : Integrable f (μ ⊗ₘ κ)
⊢ ∫ (x : α), ∫ (y : β), f (x, y) ∂(Kernel.prodMkLeft Unit κ) ((), x) ∂(Kernel.const Unit μ) () =
    ∫ (a : α), ∫ (b : β), f (a, b) ∂κ a ∂μ
tactic: rw [compProd, ProbabilityTheory.integral_compProd hf]
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
κ η : Kernel α β
inst✝³ : SFinite μ
inst✝² : IsSFiniteKernel κ
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : α × β → E
hf : Integrable f (μ ⊗ₘ κ)
⊢ ∫ (x : α), ∫ (y : β), f (x, y) ∂(Kernel.prodMkLeft Unit κ) ((), x) ∂(Kernel.const Unit μ) () =
    ∫ (a : α), ∫ (b : β), f (a, b) ∂κ a ∂μ
state_after: no goals
tactic: simp
Theorem: Set.image_congr
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t : Set α
f g : α → β
s : Set α
h : ∀ a ∈ s, f a = g a
⊢ f '' s = g '' s
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t : Set α
f g : α → β
s : Set α
h : ∀ a ∈ s, f a = g a
x : β
⊢ x ∈ f '' s ↔ x ∈ g '' s
tactic: ext x
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t : Set α
f g : α → β
s : Set α
h : ∀ a ∈ s, f a = g a
x : β
⊢ x ∈ f '' s ↔ x ∈ g '' s
state_after: no goals
tactic: exact exists_congr fun a ↦ and_congr_right fun ha ↦ by rw [h a ha]
Theorem: Equiv.some_removeNone_iff
File: Mathlib/Logic/Equiv/Option.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
⊢ some (e.removeNone x) = e none ↔ e.symm none = some x
state_after: case none
α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
h : e (some x) = none
⊢ some (e.removeNone x) = e none ↔ e.symm none = some x

case some
α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
a : β
h : e (some x) = some a
⊢ some (e.removeNone x) = e none ↔ e.symm none = some x
tactic: cases' h : e (some x) with a
Theorem: Finset.sigma_nonempty
File: Mathlib/Data/Finset/Sigma.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
β : Type u_3
s s₁ s₂ : Finset ι
t t₁ t₂ : (i : ι) → Finset (α i)
⊢ (s.sigma t).Nonempty ↔ ∃ i ∈ s, (t i).Nonempty
state_after: no goals
tactic: simp [Finset.Nonempty]
Theorem: MeasureTheory.SimpleFunc.eLpNorm'_eq
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
μ✝ : Measure α
p✝ : ℝ≥0∞
p : ℝ
f : α →ₛ F
μ : Measure α
⊢ eLpNorm' (↑f) p μ = (∑ y ∈ f.range, ↑‖y‖₊ ^ p * μ (↑f ⁻¹' {y})) ^ (1 / p)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
μ✝ : Measure α
p✝ : ℝ≥0∞
p : ℝ
f : α →ₛ F
μ : Measure α
h_map : (fun a => ↑‖↑f a‖₊ ^ p) = ↑(map (fun a => ↑‖a‖₊ ^ p) f)
⊢ eLpNorm' (↑f) p μ = (∑ y ∈ f.range, ↑‖y‖₊ ^ p * μ (↑f ⁻¹' {y})) ^ (1 / p)
tactic: have h_map : (fun a => (‖f a‖₊ : ℝ≥0∞) ^ p) = f.map fun a : F => (‖a‖₊ : ℝ≥0∞) ^ p := by
    simp; rfl
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
μ✝ : Measure α
p✝ : ℝ≥0∞
p : ℝ
f : α →ₛ F
μ : Measure α
h_map : (fun a => ↑‖↑f a‖₊ ^ p) = ↑(map (fun a => ↑‖a‖₊ ^ p) f)
⊢ eLpNorm' (↑f) p μ = (∑ y ∈ f.range, ↑‖y‖₊ ^ p * μ (↑f ⁻¹' {y})) ^ (1 / p)
state_after: no goals
tactic: rw [eLpNorm', h_map, lintegral_eq_lintegral, map_lintegral]
Theorem: MvPolynomial.constantCoeff_X
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
i : σ
⊢ constantCoeff (X i) = 0
state_after: no goals
tactic: simp [constantCoeff_eq]
Theorem: uniformInducing_of_compose
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
g : β → γ
hf : UniformContinuous f
hg : UniformContinuous g
hgf : UniformInducing (g ∘ f)
⊢ UniformInducing f
state_after: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
g : β → γ
hf : UniformContinuous f
hg : UniformContinuous g
hgf : UniformInducing (g ∘ f)
⊢ comap (fun x => (f x.1, f x.2)) (𝓤 β) ≤ 𝓤 α
tactic: refine ⟨le_antisymm ?_ hf.le_comap⟩
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
g : β → γ
hf : UniformContinuous f
hg : UniformContinuous g
hgf : UniformInducing (g ∘ f)
⊢ comap (fun x => (f x.1, f x.2)) (𝓤 β) ≤ 𝓤 α
state_after: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
g : β → γ
hf : UniformContinuous f
hg : UniformContinuous g
hgf : UniformInducing (g ∘ f)
⊢ comap (Prod.map f f) (𝓤 β) ≤ comap (Prod.map f f) (comap (Prod.map g g) (𝓤 γ))
tactic: rw [← hgf.1, ← Prod.map_def, ← Prod.map_def, ← Prod.map_comp_map f f g g, ← comap_comap]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
g : β → γ
hf : UniformContinuous f
hg : UniformContinuous g
hgf : UniformInducing (g ∘ f)
⊢ comap (Prod.map f f) (𝓤 β) ≤ comap (Prod.map f f) (comap (Prod.map g g) (𝓤 γ))
state_after: no goals
tactic: exact comap_mono hg.le_comap
Theorem: minpoly.IsIntegrallyClosed.degree_le_of_ne_zero
File: Mathlib/FieldTheory/Minpoly/IsIntegrallyClosed.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain R
inst✝³ : Algebra R S
inst✝² : IsDomain S
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : IsIntegrallyClosed R
s : S
hs : IsIntegral R s
p : R[X]
hp0 : p ≠ 0
hp : (Polynomial.aeval s) p = 0
⊢ (minpoly R s).degree ≤ p.degree
state_after: R : Type u_1
S : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain R
inst✝³ : Algebra R S
inst✝² : IsDomain S
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : IsIntegrallyClosed R
s : S
hs : IsIntegral R s
p : R[X]
hp0 : p ≠ 0
hp : (Polynomial.aeval s) p = 0
⊢ ↑(minpoly R s).natDegree ≤ ↑p.natDegree
tactic: rw [degree_eq_natDegree (minpoly.ne_zero hs), degree_eq_natDegree hp0]
state_before: R : Type u_1
S : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain R
inst✝³ : Algebra R S
inst✝² : IsDomain S
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : IsIntegrallyClosed R
s : S
hs : IsIntegral R s
p : R[X]
hp0 : p ≠ 0
hp : (Polynomial.aeval s) p = 0
⊢ ↑(minpoly R s).natDegree ≤ ↑p.natDegree
state_after: R : Type u_1
S : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain R
inst✝³ : Algebra R S
inst✝² : IsDomain S
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : IsIntegrallyClosed R
s : S
hs : IsIntegral R s
p : R[X]
hp0 : p ≠ 0
hp : (Polynomial.aeval s) p = 0
⊢ (minpoly R s).natDegree ≤ p.natDegree
tactic: norm_cast
state_before: R : Type u_1
S : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain R
inst✝³ : Algebra R S
inst✝² : IsDomain S
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : IsIntegrallyClosed R
s : S
hs : IsIntegral R s
p : R[X]
hp0 : p ≠ 0
hp : (Polynomial.aeval s) p = 0
⊢ (minpoly R s).natDegree ≤ p.natDegree
state_after: no goals
tactic: exact natDegree_le_of_dvd ((isIntegrallyClosed_dvd_iff hs _).mp hp) hp0
Theorem: Complex.sin_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: ⊢ sin (↑π / 2) = ↑(Real.sin (π / 2))
state_after: ⊢ sin (↑π / 2) = sin ↑(π / 2)
tactic: rw [ofReal_sin]
state_before: ⊢ sin (↑π / 2) = sin ↑(π / 2)
state_after: no goals
tactic: simp
state_before: ⊢ ↑(Real.sin (π / 2)) = 1
state_after: no goals
tactic: simp
Theorem: ProbabilityTheory.Kernel.borelMarkovFromReal_apply
File: Mathlib/Probability/Kernel/Disintegration/StandardBorel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
Ω✝ : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝⁶ : CountablyGenerated γ
inst✝⁵ : MeasurableSpace Ω✝
inst✝⁴ : StandardBorelSpace Ω✝
inst✝³ : Nonempty Ω✝
Ω : Type u_5
inst✝² : Nonempty Ω
inst✝¹ : MeasurableSpace Ω
inst✝ : StandardBorelSpace Ω
η : Kernel α ℝ
a : α
⊢ (borelMarkovFromReal Ω η) a =
    if (η a) (range (embeddingReal Ω))ᶜ = 0 then Measure.comap (embeddingReal Ω) (η a)
    else Measure.comap (embeddingReal Ω) (Measure.dirac (Exists.choose ⋯))
state_after: no goals
tactic: classical
  rw [borelMarkovFromReal, comapRight_apply, piecewise_apply, deterministic_apply]
  simp only [mem_preimage, mem_singleton_iff]
  split_ifs <;> rfl
Theorem: NNRat.cast_natCast
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✝ : DivisionSemiring α
q r : ℚ≥0
n : ℕ
⊢ ↑↑n = ↑n
state_after: no goals
tactic: simp [cast_def]
Theorem: le_of_inf_le_sup_le
File: Mathlib/Order/Lattice.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : DistribLattice α
x y z : α
h₁ : x ⊓ z ≤ y ⊓ z
h₂ : x ⊔ z ≤ y ⊔ z
⊢ y ⊓ z ⊔ x = (y ⊔ x) ⊓ (x ⊔ z)
state_after: no goals
tactic: rw [sup_inf_right, sup_comm x]
state_before: α : Type u
β : Type v
inst✝ : DistribLattice α
x y z : α
h₁ : x ⊓ z ≤ y ⊓ z
h₂ : x ⊔ z ≤ y ⊔ z
⊢ (y ⊔ x) ⊓ (y ⊔ z) = y ⊔ x ⊓ z
state_after: no goals
tactic: rw [← sup_inf_left]
Theorem: Matrix.lieConj_apply
File: Mathlib/Algebra/Lie/Matrix.lean

Proof steps:
state_before: R : Type u
inst✝² : CommRing R
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
P A : Matrix n n R
h : Invertible P
⊢ (P.lieConj h) A = P * A * P⁻¹
state_after: no goals
tactic: simp [LinearEquiv.conj_apply, Matrix.lieConj, LinearMap.toMatrix'_comp,
    LinearMap.toMatrix'_toLin']
Theorem: MvPolynomial.supported_eq_range_rename
File: Mathlib/Algebra/MvPolynomial/Supported.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u
S : Type v
r : R
e : ℕ
n m : σ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : Set σ
⊢ supported R s = (rename Subtype.val).range
state_after: σ : Type u_1
τ : Type u_2
R : Type u
S : Type v
r : R
e : ℕ
n m : σ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : Set σ
⊢ (aeval fun x => X ↑x).range = (aeval (X ∘ Subtype.val)).range
tactic: rw [supported, Set.image_eq_range, adjoin_range_eq_range_aeval, rename]
state_before: σ : Type u_1
τ : Type u_2
R : Type u
S : Type v
r : R
e : ℕ
n m : σ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : Set σ
⊢ (aeval fun x => X ↑x).range = (aeval (X ∘ Subtype.val)).range
state_after: no goals
tactic: congr
Theorem: QuadraticMap.Isometry.fst_apply
File: Mathlib/LinearAlgebra/QuadraticForm/Prod.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
M₁ : Type u_3
M₂ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
P : Type u_7
Mᵢ : ι → Type u_8
Nᵢ : ι → Type u_9
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M₁
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid N₁
inst✝⁶ : AddCommMonoid N₂
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
inst✝² : Module R N₁
inst✝¹ : Module R N₂
inst✝ : Module R P
Q₁ : QuadraticMap R M₁ P
m₁ : M₁ × M₂
⊢ Q₁ ((LinearMap.fst R M₁ M₂).toFun m₁) = (Q₁.prod 0) m₁
state_after: no goals
tactic: simp