ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Unitization.norm_splitMul_snd_sq
theorem Unitization.norm_splitMul_snd_sq (x : Unitization 𝕜 E) :
    ‖(Unitization.splitMul 𝕜 E x).snd‖ ^ 2 ≤ ‖(Unitization.splitMul 𝕜 E (star x * x)).snd‖ 
Arguments: (𝕜 : Type u_1) {E : Type u_2} [DenselyNormedField 𝕜] [NonUnitalNormedRing E] [StarRing E] [CstarRing E] [NormedSpace 𝕜 E] [IsScalarTower 𝕜 E E] [SMulCommClass 𝕜 E E] [StarRing 𝕜] [StarModule 𝕜 E] (x : Unitization 𝕜 E)
Goal: ‖((Unitization.splitMul 𝕜 E) x).2‖ ^ 2 ≤ ‖((Unitization.splitMul 𝕜 E) (x⋆ * x)).2‖
-- Ideal.toCharacterSpace_apply_eq_zero_of_mem
theorem Ideal.toCharacterSpace_apply_eq_zero_of_mem {a : A} (ha : a ∈ I) :
    I.toCharacterSpace a = 0 
Arguments: {A : Type u_1} [NormedCommRing A] [NormedAlgebra ℂ A] [CompleteSpace A] (I : Ideal A) [I.IsMaximal] {a : A} (ha : a ∈ I)
Goal: I.toCharacterSpace a = 0
-- WeakDual.CharacterSpace.exists_apply_eq_zero
theorem WeakDual.CharacterSpace.exists_apply_eq_zero {a : A} (ha : ¬IsUnit a) :
    ∃ f : characterSpace ℂ A, f a = 0 
Arguments: {A : Type u_1} [NormedCommRing A] [NormedAlgebra ℂ A] [CompleteSpace A] {a : A} (ha : ¬IsUnit a)
Goal: ∃ f, f a = 0
-- WeakDual.CharacterSpace.mem_spectrum_iff_exists
theorem WeakDual.CharacterSpace.mem_spectrum_iff_exists {a : A} {z : ℂ} :
    z ∈ spectrum ℂ a ↔ ∃ f : characterSpace ℂ A, f a = z 
Arguments: {A : Type u_1} [NormedCommRing A] [NormedAlgebra ℂ A] [CompleteSpace A] {a : A} {z : ℂ}
Goal: z ∈ spectrum ℂ a ↔ ∃ f, f a = z
-- spectrum.gelfandTransform_eq
theorem spectrum.gelfandTransform_eq (a : A) :
    spectrum ℂ (gelfandTransform ℂ A a) = spectrum ℂ a 
Arguments: {A : Type u_1} [NormedCommRing A] [NormedAlgebra ℂ A] [CompleteSpace A] (a : A)
Goal: spectrum ℂ ((WeakDual.gelfandTransform ℂ A) a) = spectrum ℂ a
-- gelfandTransform_map_star
theorem gelfandTransform_map_star (a : A) :
    gelfandTransform ℂ A (star a) = star (gelfandTransform ℂ A a) 
Arguments: {A : Type u_1} [NormedCommRing A] [NormedAlgebra ℂ A] [CompleteSpace A] [StarRing A] [CstarRing A] [StarModule ℂ A] (a : A)
Goal: (WeakDual.gelfandTransform ℂ A) (star a) = star ((WeakDual.gelfandTransform ℂ A) a)
-- gelfandTransform_isometry
theorem gelfandTransform_isometry : Isometry (gelfandTransform ℂ A) 
Arguments: (A : Type u_1) [NormedCommRing A] [NormedAlgebra ℂ A] [CompleteSpace A] [StarRing A] [CstarRing A] [StarModule ℂ A]
Goal: Isometry ⇑(WeakDual.gelfandTransform ℂ A)
-- gelfandTransform_bijective
theorem gelfandTransform_bijective : Function.Bijective (gelfandTransform ℂ A) 
Arguments: (A : Type u_1) [NormedCommRing A] [NormedAlgebra ℂ A] [CompleteSpace A] [StarRing A] [CstarRing A] [StarModule ℂ A]
Goal: Function.Bijective ⇑(WeakDual.gelfandTransform ℂ A)
-- gelfandStarTransform_symm_apply
@[simps!]
noncomputable def gelfandStarTransform : A ≃⋆ₐ[ℂ] C(characterSpace ℂ A, ℂ) 
Arguments: (A : Type u_1) [NormedCommRing A] [NormedAlgebra ℂ A] [CompleteSpace A] [StarRing A] [CstarRing A] [StarModule ℂ A]
Goal: ∀ (a : C(↑(WeakDual.characterSpace ℂ A), ℂ)),
  (gelfandStarTransform A).symm a =
    (↑(RingEquiv.ofBijective { toAlgHom := WeakDual.gelfandTransform ℂ A, map_star' := ⋯ } ⋯)).symm a
-- gelfandStarTransform_apply_apply
@[simps!]
noncomputable def gelfandStarTransform : A ≃⋆ₐ[ℂ] C(characterSpace ℂ A, ℂ) 
Arguments: (A : Type u_1) [NormedCommRing A] [NormedAlgebra ℂ A] [CompleteSpace A] [StarRing A] [CstarRing A] [StarModule ℂ A] (a : A) (φ : ↑(WeakDual.characterSpace ℂ A))
Goal: ((gelfandStarTransform A) a) φ = φ a
-- WeakDual.CharacterSpace.compContinuousMap_apply
@[simps]
noncomputable def compContinuousMap (ψ : A →⋆ₐ[𝕜] B) :
    C(characterSpace 𝕜 B, characterSpace 𝕜 A) 
Arguments: {A : Type u_1} {B : Type u_2} {𝕜 : Type u_4} [NontriviallyNormedField 𝕜] [NormedRing A] [NormedAlgebra 𝕜 A] [CompleteSpace A] [StarRing A] [NormedRing B] [NormedAlgebra 𝕜 B] [CompleteSpace B] [StarRing B] (ψ : A →⋆ₐ[𝕜] B) (φ : ↑(WeakDual.characterSpace 𝕜 B))
Goal: (WeakDual.CharacterSpace.compContinuousMap ψ) φ =
  WeakDual.CharacterSpace.equivAlgHom.symm ((WeakDual.CharacterSpace.equivAlgHom φ).comp ψ.toAlgHom)
-- WeakDual.CharacterSpace.compContinuousMap_id
@[simp]
theorem compContinuousMap_id :
    compContinuousMap (StarAlgHom.id 𝕜 A) = ContinuousMap.id (characterSpace 𝕜 A) 
Arguments: (A : Type u_1) {𝕜 : Type u_4} [NontriviallyNormedField 𝕜] [NormedRing A] [NormedAlgebra 𝕜 A] [CompleteSpace A] [StarRing A]
Goal: WeakDual.CharacterSpace.compContinuousMap (StarAlgHom.id 𝕜 A) = ContinuousMap.id ↑(WeakDual.characterSpace 𝕜 A)
-- WeakDual.CharacterSpace.compContinuousMap_comp
@[simp]
theorem compContinuousMap_comp (ψ₂ : B →⋆ₐ[𝕜] C) (ψ₁ : A →⋆ₐ[𝕜] B) :
    compContinuousMap (ψ₂.comp ψ₁) = (compContinuousMap ψ₁).comp (compContinuousMap ψ₂) 
Arguments: {A : Type u_1} {B : Type u_2} {C : Type u_3} {𝕜 : Type u_4} [NontriviallyNormedField 𝕜] [NormedRing A] [NormedAlgebra 𝕜 A] [CompleteSpace A] [StarRing A] [NormedRing B] [NormedAlgebra 𝕜 B] [CompleteSpace B] [StarRing B] [NormedRing C] [NormedAlgebra 𝕜 C] [CompleteSpace C] [StarRing C] (ψ₂ : B →⋆ₐ[𝕜] C) (ψ₁ : A →⋆ₐ[𝕜] B)
Goal: WeakDual.CharacterSpace.compContinuousMap (ψ₂.comp ψ₁) =
  (WeakDual.CharacterSpace.compContinuousMap ψ₁).comp (WeakDual.CharacterSpace.compContinuousMap ψ₂)
-- gelfandStarTransform_naturality
theorem gelfandStarTransform_naturality {A B : Type*} [NormedCommRing A] [NormedAlgebra ℂ A]
    [CompleteSpace A] [StarRing A] [CstarRing A] [StarModule ℂ A] [NormedCommRing B]
    [NormedAlgebra ℂ B] [CompleteSpace B] [StarRing B] [CstarRing B] [StarModule ℂ B]
    (φ : A →⋆ₐ[ℂ] B) :
    (gelfandStarTransform B : _ →⋆ₐ[ℂ] _).comp φ =
      (compContinuousMap φ |>.compStarAlgHom' ℂ ℂ).comp (gelfandStarTransform A : _ →⋆ₐ[ℂ] _) 
Arguments: {A : Type u_1} {B : Type u_2} [NormedCommRing A] [NormedAlgebra ℂ A] [CompleteSpace A] [StarRing A] [CstarRing A] [StarModule ℂ A] [NormedCommRing B] [NormedAlgebra ℂ B] [CompleteSpace B] [StarRing B] [CstarRing B] [StarModule ℂ B] (φ : A →⋆ₐ[ℂ] B)
Goal: (↑(gelfandStarTransform B)).comp φ =
  (ContinuousMap.compStarAlgHom' ℂ ℂ (WeakDual.CharacterSpace.compContinuousMap φ)).comp ↑(gelfandStarTransform A)
-- WeakDual.CharacterSpace.homeoEval_naturality
lemma WeakDual.CharacterSpace.homeoEval_naturality {X Y 𝕜 : Type*} [RCLike 𝕜] [TopologicalSpace X]
    [CompactSpace X] [T2Space X] [TopologicalSpace Y] [CompactSpace Y] [T2Space Y] (f : C(X, Y)) :
    (homeoEval Y 𝕜 : C(_, _)).comp f =
      (f.compStarAlgHom' 𝕜 𝕜 |> compContinuousMap).comp (homeoEval X 𝕜 : C(_, _)) 
Arguments: {X : Type u_1} {Y : Type u_2} {𝕜 : Type u_3} [RCLike 𝕜] [TopologicalSpace X] [CompactSpace X] [T2Space X] [TopologicalSpace Y] [CompactSpace Y] [T2Space Y] (f : C(X, Y))
Goal: (WeakDual.CharacterSpace.homeoEval Y 𝕜).toContinuousMap.comp f =
  (WeakDual.CharacterSpace.compContinuousMap (ContinuousMap.compStarAlgHom' 𝕜 𝕜 f)).comp
    (WeakDual.CharacterSpace.homeoEval X 𝕜).toContinuousMap
-- NNReal.strictConcaveOn_rpow
lemma strictConcaveOn_rpow {p : ℝ} (hp₀ : 0 < p) (hp₁ : p < 1) :
    StrictConcaveOn ℝ≥0 univ fun x : ℝ≥0 ↦ x ^ p 
Arguments: {p : ℝ} (hp₀ : 0 < p) (hp₁ : p < 1)
Goal: StrictConcaveOn NNReal Set.univ fun x => x ^ p
-- NNReal.concaveOn_rpow
lemma concaveOn_rpow {p : ℝ} (hp₀ : 0 ≤ p) (hp₁ : p ≤ 1) :
    ConcaveOn ℝ≥0 univ fun x : ℝ≥0 ↦ x ^ p 
Arguments: {p : ℝ} (hp₀ : 0 ≤ p) (hp₁ : p ≤ 1)
Goal: ConcaveOn NNReal Set.univ fun x => x ^ p
-- NNReal.strictConcaveOn_sqrt
lemma strictConcaveOn_sqrt : StrictConcaveOn ℝ≥0 univ NNReal.sqrt 
Goal: StrictConcaveOn NNReal Set.univ ⇑NNReal.sqrt
-- Real.strictConcaveOn_rpow
lemma strictConcaveOn_rpow {p : ℝ} (hp₀ : 0 < p) (hp₁ : p < 1) :
    StrictConcaveOn ℝ (Set.Ici 0) fun x : ℝ ↦ x ^ p 
Arguments: {p : ℝ} (hp₀ : 0 < p) (hp₁ : p < 1)
Goal: StrictConcaveOn ℝ (Set.Ici 0) fun x => x ^ p
-- Real.concaveOn_rpow
lemma concaveOn_rpow {p : ℝ} (hp₀ : 0 ≤ p) (hp₁ : p ≤ 1) :
    ConcaveOn ℝ (Set.Ici 0) fun x : ℝ ↦ x ^ p 
Arguments: {p : ℝ} (hp₀ : 0 ≤ p) (hp₁ : p ≤ 1)
Goal: ConcaveOn ℝ (Set.Ici 0) fun x => x ^ p
-- Real.strictConcaveOn_sqrt
lemma strictConcaveOn_sqrt : StrictConcaveOn ℝ (Set.Ici 0) (√· : ℝ → ℝ) 
Goal: StrictConcaveOn ℝ (Set.Ici 0) fun x => √x
-- strictConvexOn_pow
theorem strictConvexOn_pow {n : ℕ} (hn : 2 ≤ n) : StrictConvexOn ℝ (Ici 0) fun x : ℝ => x ^ n 
Arguments: {n : ℕ} (hn : 2 ≤ n)
Goal: StrictConvexOn ℝ (Set.Ici 0) fun x => x ^ n
-- Even.strictConvexOn_pow
theorem Even.strictConvexOn_pow {n : ℕ} (hn : Even n) (h : n ≠ 0) :
    StrictConvexOn ℝ Set.univ fun x : ℝ => x ^ n 
Arguments: {n : ℕ} (hn : Even n) (h : n ≠ 0)
Goal: StrictConvexOn ℝ Set.univ fun x => x ^ n
-- Finset.prod_nonneg_of_card_nonpos_even
theorem Finset.prod_nonneg_of_card_nonpos_even {α β : Type*} [LinearOrderedCommRing β] {f : α → β}
    [DecidablePred fun x => f x ≤ 0] {s : Finset α} (h0 : Even (s.filter fun x => f x ≤ 0).card) :
    0 ≤ ∏ x ∈ s, f x 
Arguments: {α : Type u_1} {β : Type u_2} [LinearOrderedCommRing β] {f : α → β} [DecidablePred fun x => f x ≤ 0] {s : Finset α} (h0 : Even (Finset.filter (fun x => f x ≤ 0) s).card)
Goal: 0 ≤ ∏ x ∈ s, f x
-- int_prod_range_nonneg
theorem int_prod_range_nonneg (m : ℤ) (n : ℕ) (hn : Even n) :
    0 ≤ ∏ k ∈ Finset.range n, (m - k) 
Arguments: (m : ℤ) (n : ℕ) (hn : Even n)
Goal: 0 ≤ ∏ k ∈ Finset.range n, (m - ↑k)
-- int_prod_range_pos
theorem int_prod_range_pos {m : ℤ} {n : ℕ} (hn : Even n) (hm : m ∉ Ico (0 : ℤ) n) :
    0 < ∏ k ∈ Finset.range n, (m - k) 
Arguments: {m : ℤ} {n : ℕ} (hn : Even n) (hm : m ∉ Set.Ico 0 ↑n)
Goal: 0 < ∏ k ∈ Finset.range n, (m - ↑k)
-- strictConvexOn_zpow
theorem strictConvexOn_zpow {m : ℤ} (hm₀ : m ≠ 0) (hm₁ : m ≠ 1) :
    StrictConvexOn ℝ (Ioi 0) fun x : ℝ => x ^ m 
Arguments: {m : ℤ} (hm₀ : m ≠ 0) (hm₁ : m ≠ 1)
Goal: StrictConvexOn ℝ (Set.Ioi 0) fun x => x ^ m
-- hasDerivAt_sqrt_mul_log
theorem hasDerivAt_sqrt_mul_log {x : ℝ} (hx : x ≠ 0) :
    HasDerivAt (fun x => √x * log x) ((2 + log x) / (2 * √x)) x 
Arguments: {x : ℝ} (hx : x ≠ 0)
Goal: HasDerivAt (fun x => √x * Real.log x) ((2 + Real.log x) / (2 * √x)) x
-- deriv_sqrt_mul_log
theorem deriv_sqrt_mul_log (x : ℝ) :
    deriv (fun x => √x * log x) x = (2 + log x) / (2 * √x) 
Arguments: (x : ℝ)
Goal: deriv (fun x => √x * Real.log x) x = (2 + Real.log x) / (2 * √x)
-- deriv_sqrt_mul_log'
theorem deriv_sqrt_mul_log' :
    (deriv fun x => √x * log x) = fun x => (2 + log x) / (2 * √x) 
Goal: (deriv fun x => √x * Real.log x) = fun x => (2 + Real.log x) / (2 * √x)
-- deriv2_sqrt_mul_log
theorem deriv2_sqrt_mul_log (x : ℝ) :
    deriv^[2] (fun x => √x * log x) x = -log x / (4 * √x ^ 3) 
Arguments: (x : ℝ)
Goal: deriv^[2] (fun x => √x * Real.log x) x = -Real.log x / (4 * √x ^ 3)
-- strictConcaveOn_sqrt_mul_log_Ioi
theorem strictConcaveOn_sqrt_mul_log_Ioi :
    StrictConcaveOn ℝ (Set.Ioi 1) fun x => √x * log x 
Goal: StrictConcaveOn ℝ (Set.Ioi 1) fun x => √x * Real.log x
-- strictConcaveOn_sin_Icc
theorem strictConcaveOn_sin_Icc : StrictConcaveOn ℝ (Icc 0 π) sin 
Goal: StrictConcaveOn ℝ (Set.Icc 0 π) Real.sin
-- strictConcaveOn_cos_Icc
theorem strictConcaveOn_cos_Icc : StrictConcaveOn ℝ (Icc (-(π / 2)) (π / 2)) cos 
Goal: StrictConcaveOn ℝ (Set.Icc (-(π / 2)) (π / 2)) Real.cos
-- BoxIntegral.hasIntegralIndicatorConst
theorem hasIntegralIndicatorConst (l : IntegrationParams) (hl : l.bRiemann = false)
    {s : Set (ι → ℝ)} (hs : MeasurableSet s) (I : Box ι) (y : E) (μ : Measure (ι → ℝ))
    [IsLocallyFiniteMeasure μ] :
    HasIntegral.{u, v, v} I l (s.indicator fun _ => y) μ.toBoxAdditive.toSMul
      ((μ (s ∩ I)).toReal • y) 
Arguments: {ι : Type u} {E : Type v} [Fintype ι] [NormedAddCommGroup E] [NormedSpace ℝ E] (l : BoxIntegral.IntegrationParams) (hl : l.bRiemann = false) {s : Set (ι → ℝ)} (hs : MeasurableSet s) (I : BoxIntegral.Box ι) (y : E) (μ : MeasureTheory.Measure (ι → ℝ)) [MeasureTheory.IsLocallyFiniteMeasure μ]
Goal: BoxIntegral.HasIntegral I l (s.indicator fun x => y) μ.toBoxAdditive.toSMul ((μ (s ∩ ↑I)).toReal • y)
-- BoxIntegral.HasIntegral.of_aeEq_zero
theorem HasIntegral.of_aeEq_zero {l : IntegrationParams} {I : Box ι} {f : (ι → ℝ) → E}
    {μ : Measure (ι → ℝ)} [IsLocallyFiniteMeasure μ] (hf : f =ᵐ[μ.restrict I] 0)
    (hl : l.bRiemann = false) : HasIntegral.{u, v, v} I l f μ.toBoxAdditive.toSMul 0 
Arguments: {ι : Type u} {E : Type v} [Fintype ι] [NormedAddCommGroup E] [NormedSpace ℝ E] {l : BoxIntegral.IntegrationParams} {I : BoxIntegral.Box ι} {f : (ι → ℝ) → E} {μ : MeasureTheory.Measure (ι → ℝ)} [MeasureTheory.IsLocallyFiniteMeasure μ] (hf : f =ᵐ[μ.restrict ↑I] 0) (hl : l.bRiemann = false)
Goal: BoxIntegral.HasIntegral I l f μ.toBoxAdditive.toSMul 0
-- BoxIntegral.HasIntegral.congr_ae
theorem HasIntegral.congr_ae {l : IntegrationParams} {I : Box ι} {y : E} {f g : (ι → ℝ) → E}
    {μ : Measure (ι → ℝ)} [IsLocallyFiniteMeasure μ]
    (hf : HasIntegral.{u, v, v} I l f μ.toBoxAdditive.toSMul y) (hfg : f =ᵐ[μ.restrict I] g)
    (hl : l.bRiemann = false) : HasIntegral.{u, v, v} I l g μ.toBoxAdditive.toSMul y 
Arguments: {ι : Type u} {E : Type v} [Fintype ι] [NormedAddCommGroup E] [NormedSpace ℝ E] {l : BoxIntegral.IntegrationParams} {I : BoxIntegral.Box ι} {y : E} {f g : (ι → ℝ) → E} {μ : MeasureTheory.Measure (ι → ℝ)} [MeasureTheory.IsLocallyFiniteMeasure μ] (hf : BoxIntegral.HasIntegral I l f μ.toBoxAdditive.toSMul y) (hfg : f =ᵐ[μ.restrict ↑I] g) (hl : l.bRiemann = false)
Goal: BoxIntegral.HasIntegral I l g μ.toBoxAdditive.toSMul y
-- MeasureTheory.SimpleFunc.hasBoxIntegral
theorem hasBoxIntegral (f : SimpleFunc (ι → ℝ) E) (μ : Measure (ι → ℝ)) [IsLocallyFiniteMeasure μ]
    (I : Box ι) (l : IntegrationParams) (hl : l.bRiemann = false) :
    HasIntegral.{u, v, v} I l f μ.toBoxAdditive.toSMul (f.integral (μ.restrict I)) 
Arguments: {ι : Type u} {E : Type v} [Fintype ι] [NormedAddCommGroup E] [NormedSpace ℝ E] (f : MeasureTheory.SimpleFunc (ι → ℝ) E) (μ : MeasureTheory.Measure (ι → ℝ)) [MeasureTheory.IsLocallyFiniteMeasure μ] (I : BoxIntegral.Box ι) (l : BoxIntegral.IntegrationParams) (hl : l.bRiemann = false)
Goal: BoxIntegral.HasIntegral I l (↑f) μ.toBoxAdditive.toSMul (MeasureTheory.SimpleFunc.integral (μ.restrict ↑I) f)
-- MeasureTheory.SimpleFunc.box_integral_eq_integral
theorem box_integral_eq_integral (f : SimpleFunc (ι → ℝ) E) (μ : Measure (ι → ℝ))
    [IsLocallyFiniteMeasure μ] (I : Box ι) (l : IntegrationParams) (hl : l.bRiemann = false) :
    BoxIntegral.integral.{u, v, v} I l f μ.toBoxAdditive.toSMul = f.integral (μ.restrict I) 
Arguments: {ι : Type u} {E : Type v} [Fintype ι] [NormedAddCommGroup E] [NormedSpace ℝ E] (f : MeasureTheory.SimpleFunc (ι → ℝ) E) (μ : MeasureTheory.Measure (ι → ℝ)) [MeasureTheory.IsLocallyFiniteMeasure μ] (I : BoxIntegral.Box ι) (l : BoxIntegral.IntegrationParams) (hl : l.bRiemann = false)
Goal: BoxIntegral.integral I l (↑f) μ.toBoxAdditive.toSMul = MeasureTheory.SimpleFunc.integral (μ.restrict ↑I) f
-- MeasureTheory.IntegrableOn.hasBoxIntegral
theorem IntegrableOn.hasBoxIntegral [CompleteSpace E] {f : (ι → ℝ) → E} {μ : Measure (ι → ℝ)}
    [IsLocallyFiniteMeasure μ] {I : Box ι} (hf : IntegrableOn f I μ) (l : IntegrationParams)
    (hl : l.bRiemann = false) :
    HasIntegral.{u, v, v} I l f μ.toBoxAdditive.toSMul (∫ x in I, f x ∂μ) 
Arguments: {ι : Type u} {E : Type v} [Fintype ι] [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] {f : (ι → ℝ) → E} {μ : MeasureTheory.Measure (ι → ℝ)} [MeasureTheory.IsLocallyFiniteMeasure μ] {I : BoxIntegral.Box ι} (hf : MeasureTheory.IntegrableOn f (↑I) μ) (l : BoxIntegral.IntegrationParams) (hl : l.bRiemann = false)
Goal: BoxIntegral.HasIntegral I l f μ.toBoxAdditive.toSMul (∫ (x : ι → ℝ) in ↑I, f x ∂μ)
-- MeasureTheory.ContinuousOn.hasBoxIntegral
theorem ContinuousOn.hasBoxIntegral [CompleteSpace E] {f : (ι → ℝ) → E} (μ : Measure (ι → ℝ))
    [IsLocallyFiniteMeasure μ] {I : Box ι} (hc : ContinuousOn f (Box.Icc I))
    (l : IntegrationParams) :
    HasIntegral.{u, v, v} I l f μ.toBoxAdditive.toSMul (∫ x in I, f x ∂μ) 
Arguments: {ι : Type u} {E : Type v} [Fintype ι] [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] {f : (ι → ℝ) → E} (μ : MeasureTheory.Measure (ι → ℝ)) [MeasureTheory.IsLocallyFiniteMeasure μ] {I : BoxIntegral.Box ι} (hc : ContinuousOn f (BoxIntegral.Box.Icc I)) (l : BoxIntegral.IntegrationParams)
Goal: BoxIntegral.HasIntegral I l f μ.toBoxAdditive.toSMul (∫ (x : ι → ℝ) in ↑I, f x ∂μ)
-- MeasureTheory.AEContinuous.hasBoxIntegral
theorem AEContinuous.hasBoxIntegral [CompleteSpace E] {f : (ι → ℝ) → E} (μ : Measure (ι → ℝ))
    [IsLocallyFiniteMeasure μ] {I : Box ι} (hb : ∃ C : ℝ, ∀ x ∈ Box.Icc I, ‖f x‖ ≤ C)
    (hc : ∀ᵐ x ∂μ, ContinuousAt f x) (l : IntegrationParams) :
    HasIntegral.{u, v, v} I l f μ.toBoxAdditive.toSMul (∫ x in I, f x ∂μ) 
Arguments: {ι : Type u} {E : Type v} [Fintype ι] [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] {f : (ι → ℝ) → E} (μ : MeasureTheory.Measure (ι → ℝ)) [MeasureTheory.IsLocallyFiniteMeasure μ] {I : BoxIntegral.Box ι} (hb : ∃ C, ∀ x ∈ BoxIntegral.Box.Icc I, ‖f x‖ ≤ C) (hc : ∀ᵐ (x : ι → ℝ) ∂μ, ContinuousAt f x) (l : BoxIntegral.IntegrationParams)
Goal: BoxIntegral.HasIntegral I l f μ.toBoxAdditive.toSMul (∫ (x : ι → ℝ) in ↑I, f x ∂μ)
-- strictConvexOn_exp
theorem strictConvexOn_exp : StrictConvexOn ℝ univ exp 
Goal: StrictConvexOn ℝ Set.univ rexp
-- convexOn_exp
theorem convexOn_exp : ConvexOn ℝ univ exp 
Goal: ConvexOn ℝ Set.univ rexp
-- strictConcaveOn_log_Ioi
theorem strictConcaveOn_log_Ioi : StrictConcaveOn ℝ (Ioi 0) log 
Goal: StrictConcaveOn ℝ (Set.Ioi 0) Real.log
-- one_add_mul_self_lt_rpow_one_add
theorem one_add_mul_self_lt_rpow_one_add {s : ℝ} (hs : -1 ≤ s) (hs' : s ≠ 0) {p : ℝ} (hp : 1 < p) :
    1 + p * s < (1 + s) ^ p 
Arguments: {s : ℝ} (hs : -1 ≤ s) (hs' : s ≠ 0) {p : ℝ} (hp : 1 < p)
Goal: 1 + p * s < (1 + s) ^ p
-- one_add_mul_self_le_rpow_one_add
theorem one_add_mul_self_le_rpow_one_add {s : ℝ} (hs : -1 ≤ s) {p : ℝ} (hp : 1 ≤ p) :
    1 + p * s ≤ (1 + s) ^ p 
Arguments: {s : ℝ} (hs : -1 ≤ s) {p : ℝ} (hp : 1 ≤ p)
Goal: 1 + p * s ≤ (1 + s) ^ p
-- rpow_one_add_lt_one_add_mul_self
theorem rpow_one_add_lt_one_add_mul_self {s : ℝ} (hs : -1 ≤ s) (hs' : s ≠ 0) {p : ℝ} (hp1 : 0 < p)
    (hp2 : p < 1) : (1 + s) ^ p < 1 + p * s 
Arguments: {s : ℝ} (hs : -1 ≤ s) (hs' : s ≠ 0) {p : ℝ} (hp1 : 0 < p) (hp2 : p < 1)
Goal: (1 + s) ^ p < 1 + p * s
-- rpow_one_add_le_one_add_mul_self
theorem rpow_one_add_le_one_add_mul_self {s : ℝ} (hs : -1 ≤ s) {p : ℝ} (hp1 : 0 ≤ p) (hp2 : p ≤ 1) :
    (1 + s) ^ p ≤ 1 + p * s 
Arguments: {s : ℝ} (hs : -1 ≤ s) {p : ℝ} (hp1 : 0 ≤ p) (hp2 : p ≤ 1)
Goal: (1 + s) ^ p ≤ 1 + p * s
-- strictConvexOn_rpow
theorem strictConvexOn_rpow {p : ℝ} (hp : 1 < p) : StrictConvexOn ℝ (Ici 0) fun x : ℝ ↦ x ^ p 
Arguments: {p : ℝ} (hp : 1 < p)
Goal: StrictConvexOn ℝ (Set.Ici 0) fun x => x ^ p
-- convexOn_rpow
theorem convexOn_rpow {p : ℝ} (hp : 1 ≤ p) : ConvexOn ℝ (Ici 0) fun x : ℝ ↦ x ^ p 
Arguments: {p : ℝ} (hp : 1 ≤ p)
Goal: ConvexOn ℝ (Set.Ici 0) fun x => x ^ p
-- strictConcaveOn_log_Iio
theorem strictConcaveOn_log_Iio : StrictConcaveOn ℝ (Iio 0) log 
Goal: StrictConcaveOn ℝ (Set.Iio 0) Real.log
-- Real.exp_mul_le_cosh_add_mul_sinh
lemma exp_mul_le_cosh_add_mul_sinh {t : ℝ} (ht : |t| ≤ 1) (x : ℝ) :
    exp (t * x) ≤ cosh x + t * sinh x 
Arguments: {t : ℝ} (ht : |t| ≤ 1) (x : ℝ)
Goal: rexp (t * x) ≤ Real.cosh x + t * Real.sinh x
-- ampleSet_univ
@[simp]
theorem ampleSet_univ {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F] :
    AmpleSet (univ : Set F) 
Arguments: {F : Type u_2} [NormedAddCommGroup F] [NormedSpace ℝ F]
Goal: AmpleSet Set.univ
-- ampleSet_empty
@[simp]
theorem ampleSet_empty : AmpleSet (∅ : Set F) 
Arguments: {F : Type u_1} [AddCommGroup F] [Module ℝ F] [TopologicalSpace F]
Goal: AmpleSet ∅
-- AmpleSet.union
theorem union {s t : Set F} (hs : AmpleSet s) (ht : AmpleSet t) : AmpleSet (s ∪ t) 
Arguments: {F : Type u_1} [AddCommGroup F] [Module ℝ F] [TopologicalSpace F] {s t : Set F} (hs : AmpleSet s) (ht : AmpleSet t)
Goal: AmpleSet (s ∪ t)
-- AmpleSet.image
theorem image {s : Set E} (h : AmpleSet s) (L : E ≃ᵃL[ℝ] F) :
    AmpleSet (L '' s) 
Arguments: {F : Type u_1} [AddCommGroup F] [Module ℝ F] [TopologicalSpace F] {E : Type u_2} [AddCommGroup E] [Module ℝ E] [TopologicalSpace E] {s : Set E} (h : AmpleSet s) (L : E ≃ᵃL[ℝ] F)
Goal: AmpleSet (⇑L '' s)
-- AmpleSet.image_iff
theorem image_iff {s : Set E} (L : E ≃ᵃL[ℝ] F) :
    AmpleSet (L '' s) ↔ AmpleSet s 
Arguments: {F : Type u_1} [AddCommGroup F] [Module ℝ F] [TopologicalSpace F] {E : Type u_2} [AddCommGroup E] [Module ℝ E] [TopologicalSpace E] {s : Set E} (L : E ≃ᵃL[ℝ] F)
Goal: AmpleSet (⇑L '' s) ↔ AmpleSet s
-- AmpleSet.preimage
theorem preimage {s : Set F} (h : AmpleSet s) (L : E ≃ᵃL[ℝ] F) : AmpleSet (L ⁻¹' s) 
Arguments: {F : Type u_1} [AddCommGroup F] [Module ℝ F] [TopologicalSpace F] {E : Type u_2} [AddCommGroup E] [Module ℝ E] [TopologicalSpace E] {s : Set F} (h : AmpleSet s) (L : E ≃ᵃL[ℝ] F)
Goal: AmpleSet (⇑L ⁻¹' s)
-- AmpleSet.preimage_iff
theorem preimage_iff {s : Set F} (L : E ≃ᵃL[ℝ] F) :
    AmpleSet (L ⁻¹' s) ↔ AmpleSet s 
Arguments: {F : Type u_1} [AddCommGroup F] [Module ℝ F] [TopologicalSpace F] {E : Type u_2} [AddCommGroup E] [Module ℝ E] [TopologicalSpace E] {s : Set F} (L : E ≃ᵃL[ℝ] F)
Goal: AmpleSet (⇑L ⁻¹' s) ↔ AmpleSet s
-- AmpleSet.vadd
theorem vadd [ContinuousAdd E] {s : Set E} (h : AmpleSet s) {y : E} :
    AmpleSet (y +ᵥ s) 
Arguments: {E : Type u_2} [AddCommGroup E] [Module ℝ E] [TopologicalSpace E] [ContinuousAdd E] {s : Set E} (h : AmpleSet s) {y : E}
Goal: AmpleSet (y +ᵥ s)
-- AmpleSet.vadd_iff
theorem vadd_iff [ContinuousAdd E] {s : Set E} {y : E} :
    AmpleSet (y +ᵥ s) ↔ AmpleSet s 
Arguments: {E : Type u_2} [AddCommGroup E] [Module ℝ E] [TopologicalSpace E] [ContinuousAdd E] {s : Set E} {y : E}
Goal: AmpleSet (y +ᵥ s) ↔ AmpleSet s
-- AmpleSet.of_one_lt_codim
theorem of_one_lt_codim [TopologicalAddGroup F] [ContinuousSMul ℝ F] {E : Submodule ℝ F}
    (hcodim : 1 < Module.rank ℝ (F ⧸ E)) :
    AmpleSet (Eᶜ : Set F) 
Arguments: {F : Type u_1} [AddCommGroup F] [Module ℝ F] [TopologicalSpace F] [TopologicalAddGroup F] [ContinuousSMul ℝ F] {E : Submodule ℝ F} (hcodim : 1 < Module.rank ℝ (F ⧸ E))
Goal: AmpleSet (↑E)ᶜ
-- UniformConvexSpace.uniform_convex
class UniformConvexSpace (E : Type*) [SeminormedAddCommGroup E] : Prop where
  uniform_convex : ∀ ⦃ε : ℝ⦄,
    0 < ε → ∃ δ, 0 < δ ∧ ∀ ⦃x : E⦄, ‖x‖ = 1 → ∀ ⦃y⦄, ‖y‖ = 1 → ε ≤ ‖x - y‖ → ‖x + y‖ ≤ 2 - δ
Arguments: {E : Type u_1} [SeminormedAddCommGroup E] [self : UniformConvexSpace E] ⦃ε : ℝ⦄
Goal: 0 < ε → ∃ δ, 0 < δ ∧ ∀ ⦃x : E⦄, ‖x‖ = 1 → ∀ ⦃y : E⦄, ‖y‖ = 1 → ε ≤ ‖x - y‖ → ‖x + y‖ ≤ 2 - δ
-- exists_forall_sphere_dist_add_le_two_sub
theorem exists_forall_sphere_dist_add_le_two_sub (hε : 0 < ε) :
    ∃ δ, 0 < δ ∧ ∀ ⦃x : E⦄, ‖x‖ = 1 → ∀ ⦃y⦄, ‖y‖ = 1 → ε ≤ ‖x - y‖ → ‖x + y‖ ≤ 2 - δ 
Arguments: (E : Type u_1) [SeminormedAddCommGroup E] [UniformConvexSpace E] {ε : ℝ} (hε : 0 < ε)
Goal: ∃ δ, 0 < δ ∧ ∀ ⦃x : E⦄, ‖x‖ = 1 → ∀ ⦃y : E⦄, ‖y‖ = 1 → ε ≤ ‖x - y‖ → ‖x + y‖ ≤ 2 - δ
-- exists_forall_closed_ball_dist_add_le_two_sub
theorem exists_forall_closed_ball_dist_add_le_two_sub (hε : 0 < ε) :
    ∃ δ, 0 < δ ∧ ∀ ⦃x : E⦄, ‖x‖ ≤ 1 → ∀ ⦃y⦄, ‖y‖ ≤ 1 → ε ≤ ‖x - y‖ → ‖x + y‖ ≤ 2 - δ 
Arguments: (E : Type u_1) [SeminormedAddCommGroup E] [UniformConvexSpace E] {ε : ℝ} [NormedSpace ℝ E] (hε : 0 < ε)
Goal: ∃ δ, 0 < δ ∧ ∀ ⦃x : E⦄, ‖x‖ ≤ 1 → ∀ ⦃y : E⦄, ‖y‖ ≤ 1 → ε ≤ ‖x - y‖ → ‖x + y‖ ≤ 2 - δ
-- exists_forall_closed_ball_dist_add_le_two_mul_sub
theorem exists_forall_closed_ball_dist_add_le_two_mul_sub (hε : 0 < ε) (r : ℝ) :
    ∃ δ, 0 < δ ∧ ∀ ⦃x : E⦄, ‖x‖ ≤ r → ∀ ⦃y⦄, ‖y‖ ≤ r → ε ≤ ‖x - y‖ → ‖x + y‖ ≤ 2 * r - δ 
Arguments: (E : Type u_1) [SeminormedAddCommGroup E] [UniformConvexSpace E] {ε : ℝ} [NormedSpace ℝ E] (hε : 0 < ε) (r : ℝ)
Goal: ∃ δ, 0 < δ ∧ ∀ ⦃x : E⦄, ‖x‖ ≤ r → ∀ ⦃y : E⦄, ‖y‖ ≤ r → ε ≤ ‖x - y‖ → ‖x + y‖ ≤ 2 * r - δ
-- egauge_anti
@[mono, gcongr]
lemma egauge_anti (h : s ⊆ t) (x : E) : egauge 𝕜 t x ≤ egauge 𝕜 s x 
Arguments: (𝕜 : Type u_1) [NNNorm 𝕜] {E : Type u_2} [SMul 𝕜 E] {s t : Set E} (h : s ⊆ t) (x : E)
Goal: egauge 𝕜 t x ≤ egauge 𝕜 s x
-- egauge_empty
@[simp] lemma egauge_empty (x : E) : egauge 𝕜 ∅ x = ∞ 
Arguments: (𝕜 : Type u_1) [NNNorm 𝕜] {E : Type u_2} [SMul 𝕜 E] (x : E)
Goal: egauge 𝕜 ∅ x = ⊤
-- egauge_le_of_mem_smul
lemma egauge_le_of_mem_smul (h : x ∈ c • s) : egauge 𝕜 s x ≤ ‖c‖₊ 
Arguments: {𝕜 : Type u_1} [NNNorm 𝕜] {E : Type u_2} [SMul 𝕜 E] {c : 𝕜} {s : Set E} {x : E} (h : x ∈ c • s)
Goal: egauge 𝕜 s x ≤ ↑‖c‖₊