ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Analysis/SpecificLimits/FloorPow.lean

full_name: tendsto_div_of_monotone_of_exists_subseq_tendsto_div
code: /-- If a monotone sequence `u` is such that `u n / n` tends to a limit `l` along subsequences with
exponential growth rate arbitrarily close to `1`, then `u n / n` tends to `l`. -/
theorem tendsto_div_of_monotone_of_exists_subseq_tendsto_div (u : ℕ → ℝ) (l : ℝ)
    (hmono : Monotone u)
    (hlim : ∀ a : ℝ, 1 < a → ∃ c : ℕ → ℕ, (∀ᶠ n in atTop, (c (n + 1) : ℝ) ≤ a * c n) ∧
      Tendsto c atTop atTop ∧ Tendsto (fun n => u (c n) / c n) atTop (𝓝 l)) :
    Tendsto (fun n => u n / n) atTop (𝓝 l) 
goal: Filter.Tendsto (fun n => u n / ↑n) Filter.atTop (𝓝 l)

full_name: tendsto_div_of_monotone_of_tendsto_div_floor_pow
code: /-- If a monotone sequence `u` is such that `u ⌊c^n⌋₊ / ⌊c^n⌋₊` converges to a limit `l` for all
`c > 1`, then `u n / n` tends to `l`. It is even enough to have the assumption for a sequence of
`c`s converging to `1`. -/
theorem tendsto_div_of_monotone_of_tendsto_div_floor_pow (u : ℕ → ℝ) (l : ℝ) (hmono : Monotone u)
    (c : ℕ → ℝ) (cone : ∀ k, 1 < c k) (clim : Tendsto c atTop (𝓝 1))
    (hc : ∀ k, Tendsto (fun n : ℕ => u ⌊c k ^ n⌋₊ / ⌊c k ^ n⌋₊) atTop (𝓝 l)) :
    Tendsto (fun n => u n / n) atTop (𝓝 l) 
goal: Filter.Tendsto (fun n => u n / ↑n) Filter.atTop (𝓝 l)

full_name: sum_div_pow_sq_le_div_sq
code: /-- The sum of `1/(c^i)^2` above a threshold `j` is comparable to `1/j^2`, up to a multiplicative
constant. -/
theorem sum_div_pow_sq_le_div_sq (N : ℕ) {j : ℝ} (hj : 0 < j) {c : ℝ} (hc : 1 < c) :
    (∑ i ∈ (range N).filter (j < c ^ ·), (1 : ℝ) / (c ^ i) ^ 2) ≤ c ^ 3 * (c - 1)⁻¹ / j ^ 2 
goal: ∑ i ∈ Finset.filter (fun x => j < c ^ x) (Finset.range N), 1 / (c ^ i) ^ 2 ≤ c ^ 3 * (c - 1)⁻¹ / j ^ 2

full_name: mul_pow_le_nat_floor_pow
code: theorem mul_pow_le_nat_floor_pow {c : ℝ} (hc : 1 < c) (i : ℕ) : (1 - c⁻¹) * c ^ i ≤ ⌊c ^ i⌋₊ 
goal: (1 - c⁻¹) * c ^ i ≤ ↑⌊c ^ i⌋₊

full_name: sum_div_nat_floor_pow_sq_le_div_sq
code: /-- The sum of `1/⌊c^i⌋₊^2` above a threshold `j` is comparable to `1/j^2`, up to a multiplicative
constant. -/
theorem sum_div_nat_floor_pow_sq_le_div_sq (N : ℕ) {j : ℝ} (hj : 0 < j) {c : ℝ} (hc : 1 < c) :
    (∑ i ∈ (range N).filter (j < ⌊c ^ ·⌋₊), (1 : ℝ) / (⌊c ^ i⌋₊ : ℝ) ^ 2) ≤
      c ^ 5 * (c - 1)⁻¹ ^ 3 / j ^ 2 
goal: ∑ i ∈ Finset.filter (fun x => j < ↑⌊c ^ x⌋₊) (Finset.range N), 1 / ↑⌊c ^ i⌋₊ ^ 2 ≤ c ^ 5 * (c - 1)⁻¹ ^ 3 / j ^ 2
File: Mathlib/Analysis/CstarAlgebra/Unitization.lean

full_name: «_aux_Mathlib_Analysis_CstarAlgebra_Unitization___macroRules_term_⋆_1»
code: local postfix:max "⋆" => star
goal: Lean.Macro

full_name: _aux_Mathlib_Analysis_CstarAlgebra_Unitization___unexpand_Star_star_1
code: local postfix:max "⋆" => star
goal: Lean.PrettyPrinter.Unexpander

full_name: ContinuousLinearMap.opNorm_mul_flip_apply
code: lemma opNorm_mul_flip_apply (a : E) : ‖(mul 𝕜 E).flip a‖ = ‖a‖ 
goal: ‖(ContinuousLinearMap.mul 𝕜 E).flip a‖ = ‖a‖

full_name: ContinuousLinearMap.opNNNorm_mul_flip_apply
code: lemma opNNNorm_mul_flip_apply (a : E) : ‖(mul 𝕜 E).flip a‖₊ = ‖a‖₊ 
goal: ‖(ContinuousLinearMap.mul 𝕜 E).flip a‖₊ = ‖a‖₊

full_name: ContinuousLinearMap.isometry_mul_flip
code: lemma isometry_mul_flip : Isometry (mul 𝕜 E).flip 
goal: Isometry ⇑(ContinuousLinearMap.mul 𝕜 E).flip

full_name: CstarRing.instRegularNormedAlgebra
code: /-- A C⋆-algebra over a densely normed field is a regular normed algebra. -/
instance CstarRing.instRegularNormedAlgebra : RegularNormedAlgebra 𝕜 E 
goal: RegularNormedAlgebra 𝕜 E

full_name: Unitization.norm_splitMul_snd_sq
code: /-- This is the key lemma used to establish the instance `Unitization.instCstarRing`
(i.e., proving that the norm on `Unitization 𝕜 E` satisfies the C⋆-property). We split this one
out so that declaring the `CstarRing` instance doesn't time out. -/
theorem Unitization.norm_splitMul_snd_sq (x : Unitization 𝕜 E) :
    ‖(Unitization.splitMul 𝕜 E x).snd‖ ^ 2 ≤ ‖(Unitization.splitMul 𝕜 E (star x * x)).snd‖ 
goal: ‖((Unitization.splitMul 𝕜 E) x).2‖ ^ 2 ≤ ‖((Unitization.splitMul 𝕜 E) (x⋆ * x)).2‖

full_name: Unitization.instCstarRing
code: /-- The norm on `Unitization 𝕜 E` satisfies the C⋆-property -/
instance Unitization.instCstarRing : CstarRing (Unitization 𝕜 E) 
goal: CstarRing (Unitization 𝕜 E)
File: Mathlib/Analysis/Convex/SpecificFunctions/Pow.lean

full_name: NNReal.strictConcaveOn_rpow
code: lemma strictConcaveOn_rpow {p : ℝ} (hp₀ : 0 < p) (hp₁ : p < 1) :
    StrictConcaveOn ℝ≥0 univ fun x : ℝ≥0 ↦ x ^ p 
goal: StrictConcaveOn NNReal Set.univ fun x => x ^ p

full_name: NNReal.concaveOn_rpow
code: lemma concaveOn_rpow {p : ℝ} (hp₀ : 0 ≤ p) (hp₁ : p ≤ 1) :
    ConcaveOn ℝ≥0 univ fun x : ℝ≥0 ↦ x ^ p 
goal: ConcaveOn NNReal Set.univ fun x => x ^ p

full_name: NNReal.strictConcaveOn_sqrt
code: lemma strictConcaveOn_sqrt : StrictConcaveOn ℝ≥0 univ NNReal.sqrt 
goal: StrictConcaveOn NNReal Set.univ ⇑NNReal.sqrt

full_name: Real.strictConcaveOn_rpow
code: lemma strictConcaveOn_rpow {p : ℝ} (hp₀ : 0 < p) (hp₁ : p < 1) :
    StrictConcaveOn ℝ (Set.Ici 0) fun x : ℝ ↦ x ^ p 
goal: StrictConcaveOn ℝ (Set.Ici 0) fun x => x ^ p

full_name: Real.concaveOn_rpow
code: lemma concaveOn_rpow {p : ℝ} (hp₀ : 0 ≤ p) (hp₁ : p ≤ 1) :
    ConcaveOn ℝ (Set.Ici 0) fun x : ℝ ↦ x ^ p 
goal: ConcaveOn ℝ (Set.Ici 0) fun x => x ^ p

full_name: Real.strictConcaveOn_sqrt
code: lemma strictConcaveOn_sqrt : StrictConcaveOn ℝ (Set.Ici 0) (√· : ℝ → ℝ) 
goal: StrictConcaveOn ℝ (Set.Ici 0) fun x => √x
File: Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean

full_name: strictConvexOn_pow
code: /-- `x^n`, `n : ℕ` is strictly convex on `[0, +∞)` for all `n` greater than `2`. -/
theorem strictConvexOn_pow {n : ℕ} (hn : 2 ≤ n) : StrictConvexOn ℝ (Ici 0) fun x : ℝ => x ^ n 
goal: StrictConvexOn ℝ (Set.Ici 0) fun x => x ^ n

full_name: Even.strictConvexOn_pow
code: /-- `x^n`, `n : ℕ` is strictly convex on the whole real line whenever `n ≠ 0` is even. -/
theorem Even.strictConvexOn_pow {n : ℕ} (hn : Even n) (h : n ≠ 0) :
    StrictConvexOn ℝ Set.univ fun x : ℝ => x ^ n 
goal: StrictConvexOn ℝ Set.univ fun x => x ^ n

full_name: Finset.prod_nonneg_of_card_nonpos_even
code: 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 
goal: 0 ≤ ∏ x ∈ s, f x

full_name: int_prod_range_nonneg
code: theorem int_prod_range_nonneg (m : ℤ) (n : ℕ) (hn : Even n) :
    0 ≤ ∏ k ∈ Finset.range n, (m - k) 
goal: 0 ≤ ∏ k ∈ Finset.range n, (m - ↑k)

full_name: int_prod_range_pos
code: theorem int_prod_range_pos {m : ℤ} {n : ℕ} (hn : Even n) (hm : m ∉ Ico (0 : ℤ) n) :
    0 < ∏ k ∈ Finset.range n, (m - k) 
goal: 0 < ∏ k ∈ Finset.range n, (m - ↑k)

full_name: strictConvexOn_zpow
code: /-- `x^m`, `m : ℤ` is convex on `(0, +∞)` for all `m` except `0` and `1`. -/
theorem strictConvexOn_zpow {m : ℤ} (hm₀ : m ≠ 0) (hm₁ : m ≠ 1) :
    StrictConvexOn ℝ (Ioi 0) fun x : ℝ => x ^ m 
goal: StrictConvexOn ℝ (Set.Ioi 0) fun x => x ^ m

full_name: hasDerivAt_sqrt_mul_log
code: theorem hasDerivAt_sqrt_mul_log {x : ℝ} (hx : x ≠ 0) :
    HasDerivAt (fun x => √x * log x) ((2 + log x) / (2 * √x)) x 
goal: HasDerivAt (fun x => √x * Real.log x) ((2 + Real.log x) / (2 * √x)) x

full_name: deriv_sqrt_mul_log
code: theorem deriv_sqrt_mul_log (x : ℝ) :
    deriv (fun x => √x * log x) x = (2 + log x) / (2 * √x) 
goal: deriv (fun x => √x * Real.log x) x = (2 + Real.log x) / (2 * √x)

full_name: deriv_sqrt_mul_log'
code: 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)

full_name: deriv2_sqrt_mul_log
code: theorem deriv2_sqrt_mul_log (x : ℝ) :
    deriv^[2] (fun x => √x * log x) x = -log x / (4 * √x ^ 3) 
goal: deriv^[2] (fun x => √x * Real.log x) x = -Real.log x / (4 * √x ^ 3)

full_name: strictConcaveOn_sqrt_mul_log_Ioi
code: 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

full_name: strictConcaveOn_sin_Icc
code: theorem strictConcaveOn_sin_Icc : StrictConcaveOn ℝ (Icc 0 π) sin 
goal: StrictConcaveOn ℝ (Set.Icc 0 π) Real.sin

full_name: strictConcaveOn_cos_Icc
code: theorem strictConcaveOn_cos_Icc : StrictConcaveOn ℝ (Icc (-(π / 2)) (π / 2)) cos 
goal: StrictConcaveOn ℝ (Set.Icc (-(π / 2)) (π / 2)) Real.cos
File: Mathlib/Analysis/Convex/SpecificFunctions/Basic.lean

full_name: strictConvexOn_exp
code: /-- `Real.exp` is strictly convex on the whole real line. -/
theorem strictConvexOn_exp : StrictConvexOn ℝ univ exp 
goal: StrictConvexOn ℝ Set.univ rexp

full_name: convexOn_exp
code: /-- `Real.exp` is convex on the whole real line. -/
theorem convexOn_exp : ConvexOn ℝ univ exp 
goal: ConvexOn ℝ Set.univ rexp

full_name: strictConcaveOn_log_Ioi
code: /-- `Real.log` is strictly concave on `(0, +∞)`. -/
theorem strictConcaveOn_log_Ioi : StrictConcaveOn ℝ (Ioi 0) log 
goal: StrictConcaveOn ℝ (Set.Ioi 0) Real.log

full_name: one_add_mul_self_lt_rpow_one_add
code: /-- **Bernoulli's inequality** for real exponents, strict version: for `1 < p` and `-1 ≤ s`, with
`s ≠ 0`, we have `1 + p * s < (1 + s) ^ p`. -/
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 
goal: 1 + p * s < (1 + s) ^ p

full_name: one_add_mul_self_le_rpow_one_add
code: /-- **Bernoulli's inequality** for real exponents, non-strict version: for `1 ≤ p` and `-1 ≤ s`
we have `1 + p * s ≤ (1 + s) ^ p`. -/
theorem one_add_mul_self_le_rpow_one_add {s : ℝ} (hs : -1 ≤ s) {p : ℝ} (hp : 1 ≤ p) :
    1 + p * s ≤ (1 + s) ^ p 
goal: 1 + p * s ≤ (1 + s) ^ p

full_name: rpow_one_add_lt_one_add_mul_self
code: /-- **Bernoulli's inequality** for real exponents, strict version: for `0 < p < 1` and `-1 ≤ s`,
with `s ≠ 0`, we have `(1 + s) ^ p < 1 + p * s`. -/
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 
goal: (1 + s) ^ p < 1 + p * s

full_name: rpow_one_add_le_one_add_mul_self
code: /-- **Bernoulli's inequality** for real exponents, non-strict version: for `0 ≤ p ≤ 1` and `-1 ≤ s`
we have `(1 + s) ^ p ≤ 1 + p * s`. -/
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 
goal: (1 + s) ^ p ≤ 1 + p * s

full_name: strictConvexOn_rpow
code: /-- For `p : ℝ` with `1 < p`, `fun x ↦ x ^ p` is strictly convex on $[0, +∞)$. -/
theorem strictConvexOn_rpow {p : ℝ} (hp : 1 < p) : StrictConvexOn ℝ (Ici 0) fun x : ℝ ↦ x ^ p 
goal: StrictConvexOn ℝ (Set.Ici 0) fun x => x ^ p

full_name: convexOn_rpow
code: theorem convexOn_rpow {p : ℝ} (hp : 1 ≤ p) : ConvexOn ℝ (Ici 0) fun x : ℝ ↦ x ^ p 
goal: ConvexOn ℝ (Set.Ici 0) fun x => x ^ p

full_name: strictConcaveOn_log_Iio
code: theorem strictConcaveOn_log_Iio : StrictConcaveOn ℝ (Iio 0) log 
goal: StrictConcaveOn ℝ (Set.Iio 0) Real.log

full_name: Real.exp_mul_le_cosh_add_mul_sinh
code: lemma exp_mul_le_cosh_add_mul_sinh {t : ℝ} (ht : |t| ≤ 1) (x : ℝ) :
    exp (t * x) ≤ cosh x + t * sinh x 
goal: rexp (t * x) ≤ Real.cosh x + t * Real.sinh x
File: Mathlib/Analysis/Convex/AmpleSet.lean

full_name: AmpleSet
code: /-- A subset of a topological real vector space is ample
if the convex hull of each of its connected components is the full space. -/
def AmpleSet (s : Set F) : Prop 
goal: Prop

full_name: ampleSet_univ
code: /-- A whole vector space is ample. -/
@[simp]
theorem ampleSet_univ {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F] :
    AmpleSet (univ : Set F) 
goal: AmpleSet Set.univ

full_name: ampleSet_empty
code: /-- The empty set in a vector space is ample. -/
@[simp]
theorem ampleSet_empty : AmpleSet (∅ : Set F) 
goal: AmpleSet ∅

full_name: AmpleSet.union
code: /-- The union of two ample sets is ample. -/
theorem union {s t : Set F} (hs : AmpleSet s) (ht : AmpleSet t) : AmpleSet (s ∪ t) 
goal: AmpleSet (s ∪ t)

full_name: AmpleSet.image
code: /-- Images of ample sets under continuous affine equivalences are ample. -/
theorem image {s : Set E} (h : AmpleSet s) (L : E ≃ᵃL[ℝ] F) :
    AmpleSet (L '' s) 
goal: AmpleSet (⇑L '' s)

full_name: AmpleSet.image_iff
code: /-- A set is ample iff its image under a continuous affine equivalence is. -/
theorem image_iff {s : Set E} (L : E ≃ᵃL[ℝ] F) :
    AmpleSet (L '' s) ↔ AmpleSet s 
goal: AmpleSet (⇑L '' s) ↔ AmpleSet s

full_name: AmpleSet.preimage
code: /-- Pre-images of ample sets under continuous affine equivalences are ample. -/
theorem preimage {s : Set F} (h : AmpleSet s) (L : E ≃ᵃL[ℝ] F) : AmpleSet (L ⁻¹' s) 
goal: AmpleSet (⇑L ⁻¹' s)

full_name: AmpleSet.preimage_iff
code: /-- A set is ample iff its pre-image under a continuous affine equivalence is. -/
theorem preimage_iff {s : Set F} (L : E ≃ᵃL[ℝ] F) :
    AmpleSet (L ⁻¹' s) ↔ AmpleSet s 
goal: AmpleSet (⇑L ⁻¹' s) ↔ AmpleSet s

full_name: AmpleSet.vadd
code: /-- Affine translations of ample sets are ample. -/
theorem vadd [ContinuousAdd E] {s : Set E} (h : AmpleSet s) {y : E} :
    AmpleSet (y +ᵥ s) 
goal: AmpleSet (y +ᵥ s)

full_name: AmpleSet.vadd_iff
code: /-- A set is ample iff its affine translation is. -/
theorem vadd_iff [ContinuousAdd E] {s : Set E} {y : E} :
    AmpleSet (y +ᵥ s) ↔ AmpleSet s 
goal: AmpleSet (y +ᵥ s) ↔ AmpleSet s

full_name: AmpleSet.of_one_lt_codim
code: /-- Let `E` be a linear subspace in a real vector space.
If `E` has codimension at least two, its complement is ample. -/
theorem of_one_lt_codim [TopologicalAddGroup F] [ContinuousSMul ℝ F] {E : Submodule ℝ F}
    (hcodim : 1 < Module.rank ℝ (F ⧸ E)) :
    AmpleSet (Eᶜ : Set F) 
goal: AmpleSet (↑E)ᶜ
File: Mathlib/Analysis/Convex/Uniform.lean

full_name: UniformConvexSpace.uniform_convex
code: /-- A *uniformly convex space* is a real normed space where the triangle inequality is strict with a
uniform bound. Namely, over the `x` and `y` of norm `1`, `‖x + y‖` is uniformly bounded above
by a constant `< 2` when `‖x - y‖` is uniformly bounded below by a positive constant. -/
class UniformConvexSpace (E : Type*) [SeminormedAddCommGroup E] : Prop where
  uniform_convex : ∀ ⦃ε : ℝ⦄,
    0 < ε → ∃ δ, 0 < δ ∧ ∀ ⦃x : E⦄, ‖x‖ = 1 → ∀ ⦃y⦄, ‖y‖ = 1 → ε ≤ ‖x - y‖ → ‖x + y‖ ≤ 2 - δ
goal: 0 < ε → ∃ δ, 0 < δ ∧ ∀ ⦃x : E⦄, ‖x‖ = 1 → ∀ ⦃y : E⦄, ‖y‖ = 1 → ε ≤ ‖x - y‖ → ‖x + y‖ ≤ 2 - δ

full_name: UniformConvexSpace
code: /-- A *uniformly convex space* is a real normed space where the triangle inequality is strict with a
uniform bound. Namely, over the `x` and `y` of norm `1`, `‖x + y‖` is uniformly bounded above
by a constant `< 2` when `‖x - y‖` is uniformly bounded below by a positive constant. -/
class UniformConvexSpace (E : Type*) [SeminormedAddCommGroup E] : Prop where
  uniform_convex : ∀ ⦃ε : ℝ⦄,
    0 < ε → ∃ δ, 0 < δ ∧ ∀ ⦃x : E⦄, ‖x‖ = 1 → ∀ ⦃y⦄, ‖y‖ = 1 → ε ≤ ‖x - y‖ → ‖x + y‖ ≤ 2 - δ
goal: Prop

full_name: exists_forall_sphere_dist_add_le_two_sub
code: theorem exists_forall_sphere_dist_add_le_two_sub (hε : 0 < ε) :
    ∃ δ, 0 < δ ∧ ∀ ⦃x : E⦄, ‖x‖ = 1 → ∀ ⦃y⦄, ‖y‖ = 1 → ε ≤ ‖x - y‖ → ‖x + y‖ ≤ 2 - δ 
goal: ∃ δ, 0 < δ ∧ ∀ ⦃x : E⦄, ‖x‖ = 1 → ∀ ⦃y : E⦄, ‖y‖ = 1 → ε ≤ ‖x - y‖ → ‖x + y‖ ≤ 2 - δ

full_name: exists_forall_closed_ball_dist_add_le_two_sub
code: 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 - δ 
goal: ∃ δ, 0 < δ ∧ ∀ ⦃x : E⦄, ‖x‖ ≤ 1 → ∀ ⦃y : E⦄, ‖y‖ ≤ 1 → ε ≤ ‖x - y‖ → ‖x + y‖ ≤ 2 - δ

full_name: exists_forall_closed_ball_dist_add_le_two_mul_sub
code: 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 - δ 
goal: ∃ δ, 0 < δ ∧ ∀ ⦃x : E⦄, ‖x‖ ≤ r → ∀ ⦃y : E⦄, ‖y‖ ≤ r → ε ≤ ‖x - y‖ → ‖x + y‖ ≤ 2 * r - δ

full_name: UniformConvexSpace.toStrictConvexSpace
code: instance (priority := 100) UniformConvexSpace.toStrictConvexSpace : StrictConvexSpace ℝ E 
goal: StrictConvexSpace ℝ E
File: Mathlib/Analysis/Convex/Complex.lean

full_name: convex_halfspace_re_lt
code: theorem convex_halfspace_re_lt (r : ℝ) : Convex ℝ { c : ℂ | c.re < r } 
goal: Convex ℝ {c | c.re < r}

full_name: convex_halfspace_re_le
code: theorem convex_halfspace_re_le (r : ℝ) : Convex ℝ { c : ℂ | c.re ≤ r } 
goal: Convex ℝ {c | c.re ≤ r}

full_name: convex_halfspace_re_gt
code: theorem convex_halfspace_re_gt (r : ℝ) : Convex ℝ { c : ℂ | r < c.re } 
goal: Convex ℝ {c | r < c.re}

full_name: convex_halfspace_re_ge
code: theorem convex_halfspace_re_ge (r : ℝ) : Convex ℝ { c : ℂ | r ≤ c.re } 
goal: Convex ℝ {c | r ≤ c.re}

full_name: convex_halfspace_im_lt
code: theorem convex_halfspace_im_lt (r : ℝ) : Convex ℝ { c : ℂ | c.im < r } 
goal: Convex ℝ {c | c.im < r}

full_name: convex_halfspace_im_le
code: theorem convex_halfspace_im_le (r : ℝ) : Convex ℝ { c : ℂ | c.im ≤ r } 
goal: Convex ℝ {c | c.im ≤ r}

full_name: convex_halfspace_im_gt
code: theorem convex_halfspace_im_gt (r : ℝ) : Convex ℝ { c : ℂ | r < c.im } 
goal: Convex ℝ {c | r < c.im}

full_name: convex_halfspace_im_ge
code: theorem convex_halfspace_im_ge (r : ℝ) : Convex ℝ { c : ℂ | r ≤ c.im } 
goal: Convex ℝ {c | r ≤ c.im}
File: Mathlib/Analysis/Convex/Contractible.lean

full_name: StarConvex.contractibleSpace
code: /-- A non-empty star convex set is a contractible space. -/
protected theorem StarConvex.contractibleSpace (h : StarConvex ℝ x s) (hne : s.Nonempty) :
    ContractibleSpace s 
goal: ContractibleSpace ↑s

full_name: Convex.contractibleSpace
code: /-- A non-empty convex set is a contractible space. -/
protected theorem Convex.contractibleSpace (hs : Convex ℝ s) (hne : s.Nonempty) :
    ContractibleSpace s 
goal: ContractibleSpace ↑s

full_name: RealTopologicalVectorSpace.contractibleSpace
code: instance (priority := 100) RealTopologicalVectorSpace.contractibleSpace : ContractibleSpace E 
goal: ContractibleSpace E
File: Mathlib/Analysis/Convex/StoneSeparation.lean

full_name: not_disjoint_segment_convexHull_triple
code: /-- In a tetrahedron with vertices `x`, `y`, `p`, `q`, any segment `[u, v]` joining the opposite
edges `[x, p]` and `[y, q]` passes through any triangle of vertices `p`, `q`, `z` where
`z ∈ [x, y]`. -/
theorem not_disjoint_segment_convexHull_triple {p q u v x y z : E} (hz : z ∈ segment 𝕜 x y)
    (hu : u ∈ segment 𝕜 x p) (hv : v ∈ segment 𝕜 y q) :
    ¬Disjoint (segment 𝕜 u v) (convexHull 𝕜 {p, q, z}) 
goal: ¬Disjoint (segment 𝕜 u v) ((convexHull 𝕜) {p, q, z})

full_name: exists_convex_convex_compl_subset
code: /-- **Stone's Separation Theorem** -/
theorem exists_convex_convex_compl_subset (hs : Convex 𝕜 s) (ht : Convex 𝕜 t) (hst : Disjoint s t) :
    ∃ C : Set E, Convex 𝕜 C ∧ Convex 𝕜 Cᶜ ∧ s ⊆ C ∧ t ⊆ Cᶜ 
goal: ∃ C, Convex 𝕜 C ∧ Convex 𝕜 Cᶜ ∧ s ⊆ C ∧ t ⊆ Cᶜ
File: Mathlib/Analysis/Convex/KreinMilman.lean

full_name: IsCompact.extremePoints_nonempty
code: /-- **Krein-Milman lemma**: In a LCTVS, any nonempty compact set has an extreme point. -/
theorem IsCompact.extremePoints_nonempty (hscomp : IsCompact s) (hsnemp : s.Nonempty) :
    (s.extremePoints ℝ).Nonempty 
goal: (Set.extremePoints ℝ s).Nonempty

full_name: closure_convexHull_extremePoints
code: /-- **Krein-Milman theorem**: In a LCTVS, any compact convex set is the closure of the convex hull
    of its extreme points. -/
theorem closure_convexHull_extremePoints (hscomp : IsCompact s) (hAconv : Convex ℝ s) :
    closure (convexHull ℝ <| s.extremePoints ℝ) = s 
goal: closure ((convexHull ℝ) (Set.extremePoints ℝ s)) = s

full_name: surjOn_extremePoints_image
code: /-- A continuous affine map is surjective from the extreme points of a compact set to the extreme
points of the image of that set. This inclusion is in general strict. -/
lemma surjOn_extremePoints_image (f : E →ᴬ[ℝ] F) (hs : IsCompact s) :
    SurjOn f (extremePoints ℝ s) (extremePoints ℝ (f '' s)) 
goal: Set.SurjOn (⇑f) (Set.extremePoints ℝ s) (Set.extremePoints ℝ (⇑f '' s))
File: Mathlib/Analysis/Convex/PartitionOfUnity.lean

full_name: PartitionOfUnity.finsum_smul_mem_convex
code: theorem PartitionOfUnity.finsum_smul_mem_convex {s : Set X} (f : PartitionOfUnity ι X s)
    {g : ι → X → E} {t : Set E} {x : X} (hx : x ∈ s) (hg : ∀ i, f i x ≠ 0 → g i x ∈ t)
    (ht : Convex ℝ t) : (∑ᶠ i, f i x • g i x) ∈ t 
goal: ∑ᶠ (i : ι), (f i) x • g i x ∈ t

full_name: exists_continuous_forall_mem_convex_of_local
code: /-- Let `X` be a normal paracompact topological space (e.g., any extended metric space). Let `E` be
a topological real vector space. Let `t : X → Set E` be a family of convex sets. Suppose that for
each point `x : X`, there exists a neighborhood `U ∈ 𝓝 X` and a function `g : X → E` that is
continuous on `U` and sends each `y ∈ U` to a point of `t y`. Then there exists a continuous map
`g : C(X, E)` such that `g x ∈ t x` for all `x`. See also
`exists_continuous_forall_mem_convex_of_local_const`. -/
theorem exists_continuous_forall_mem_convex_of_local (ht : ∀ x, Convex ℝ (t x))
    (H : ∀ x : X, ∃ U ∈ 𝓝 x, ∃ g : X → E, ContinuousOn g U ∧ ∀ y ∈ U, g y ∈ t y) :
    ∃ g : C(X, E), ∀ x, g x ∈ t x 
goal: ∃ g, ∀ (x : X), g x ∈ t x

full_name: exists_continuous_forall_mem_convex_of_local_const
code: /-- Let `X` be a normal paracompact topological space (e.g., any extended metric space). Let `E` be
a topological real vector space. Let `t : X → Set E` be a family of convex sets. Suppose that for
each point `x : X`, there exists a vector `c : E` that belongs to `t y` for all `y` in a
neighborhood of `x`. Then there exists a continuous map `g : C(X, E)` such that `g x ∈ t x` for all
`x`. See also `exists_continuous_forall_mem_convex_of_local`. -/
theorem exists_continuous_forall_mem_convex_of_local_const (ht : ∀ x, Convex ℝ (t x))
    (H : ∀ x : X, ∃ c : E, ∀ᶠ y in 𝓝 x, c ∈ t y) : ∃ g : C(X, E), ∀ x, g x ∈ t x 
goal: ∃ g, ∀ (x : X), g x ∈ t x