File: Mathlib/Analysis/Convex/Strong.lean

full_name: UniformConvexOn
code: /-- A function `f` from a real normed space is uniformly convex with modulus `φ` if
`f (t • x + (1 - t) • y) ≤ t • f x + (1 - t) • f y - t * (1 - t) * φ ‖x - y‖` for all `t ∈ [0, 1]`.

`φ` is usually taken to be a monotone function such that `φ r = 0 ↔ r = 0`. -/
def UniformConvexOn (s : Set E) (φ : ℝ → ℝ) (f : E → ℝ) : Prop 
goal: Prop

full_name: UniformConcaveOn
code: /-- A function `f` from a real normed space is uniformly concave with modulus `φ` if
`t • f x + (1 - t) • f y + t * (1 - t) * φ ‖x - y‖ ≤ f (t • x + (1 - t) • y)` for all `t ∈ [0, 1]`.

`φ` is usually taken to be a monotone function such that `φ r = 0 ↔ r = 0`. -/
def UniformConcaveOn (s : Set E) (φ : ℝ → ℝ) (f : E → ℝ) : Prop 
goal: Prop

full_name: uniformConvexOn_zero
code: @[simp] lemma uniformConvexOn_zero : UniformConvexOn s 0 f ↔ ConvexOn ℝ s f 
goal: UniformConvexOn s 0 f ↔ ConvexOn ℝ s f

full_name: uniformConcaveOn_zero
code: @[simp] lemma uniformConcaveOn_zero : UniformConcaveOn s 0 f ↔ ConcaveOn ℝ s f 
goal: UniformConcaveOn s 0 f ↔ ConcaveOn ℝ s f

full_name: UniformConvexOn.mono
code: lemma UniformConvexOn.mono (hψφ : ψ ≤ φ) (hf : UniformConvexOn s φ f) : UniformConvexOn s ψ f 
goal: UniformConvexOn s ψ f

full_name: UniformConcaveOn.mono
code: lemma UniformConcaveOn.mono (hψφ : ψ ≤ φ) (hf : UniformConcaveOn s φ f) : UniformConcaveOn s ψ f 
goal: UniformConcaveOn s ψ f

full_name: UniformConvexOn.convexOn
code: lemma UniformConvexOn.convexOn (hf : UniformConvexOn s φ f) (hφ : 0 ≤ φ) : ConvexOn ℝ s f 
goal: ConvexOn ℝ s f

full_name: UniformConcaveOn.concaveOn
code: lemma UniformConcaveOn.concaveOn (hf : UniformConcaveOn s φ f) (hφ : 0 ≤ φ) : ConcaveOn ℝ s f 
goal: ConcaveOn ℝ s f

full_name: UniformConvexOn.strictConvexOn
code: lemma UniformConvexOn.strictConvexOn (hf : UniformConvexOn s φ f) (hφ : ∀ r, r ≠ 0 → 0 < φ r) :
    StrictConvexOn ℝ s f 
goal: StrictConvexOn ℝ s f

full_name: UniformConcaveOn.strictConcaveOn
code: lemma UniformConcaveOn.strictConcaveOn (hf : UniformConcaveOn s φ f) (hφ : ∀ r, r ≠ 0 → 0 < φ r) :
    StrictConcaveOn ℝ s f 
goal: StrictConcaveOn ℝ s f

full_name: UniformConvexOn.add
code: lemma UniformConvexOn.add (hf : UniformConvexOn s φ f) (hg : UniformConvexOn s ψ g) :
    UniformConvexOn s (φ + ψ) (f + g) 
goal: UniformConvexOn s (φ + ψ) (f + g)

full_name: UniformConcaveOn.add
code: lemma UniformConcaveOn.add (hf : UniformConcaveOn s φ f) (hg : UniformConcaveOn s ψ g) :
    UniformConcaveOn s (φ + ψ) (f + g) 
goal: UniformConcaveOn s (φ + ψ) (f + g)

full_name: UniformConvexOn.neg
code: lemma UniformConvexOn.neg (hf : UniformConvexOn s φ f) : UniformConcaveOn s φ (-f) 
goal: UniformConcaveOn s φ (-f)

full_name: UniformConcaveOn.neg
code: lemma UniformConcaveOn.neg (hf : UniformConcaveOn s φ f) : UniformConvexOn s φ (-f) 
goal: UniformConvexOn s φ (-f)

full_name: UniformConvexOn.sub
code: lemma UniformConvexOn.sub (hf : UniformConvexOn s φ f) (hg : UniformConcaveOn s ψ g) :
    UniformConvexOn s (φ + ψ) (f - g) 
goal: UniformConvexOn s (φ + ψ) (f - g)

full_name: UniformConcaveOn.sub
code: lemma UniformConcaveOn.sub (hf : UniformConcaveOn s φ f) (hg : UniformConvexOn s ψ g) :
    UniformConcaveOn s (φ + ψ) (f - g) 
goal: UniformConcaveOn s (φ + ψ) (f - g)

full_name: StrongConvexOn
code: /-- A function `f` from a real normed space is `m`-strongly convex if it is uniformly convex with
modulus `φ(r) = m / 2 * r ^ 2`.

In an inner product space, this is equivalent to `x ↦ f x - m / 2 * ‖x‖ ^ 2` being convex. -/
def StrongConvexOn (s : Set E) (m : ℝ) : (E → ℝ) → Prop 
goal: (E → ℝ) → Prop

full_name: StrongConcaveOn
code: /-- A function `f` from a real normed space is `m`-strongly concave if is strongly concave with
modulus `φ(r) = m / 2 * r ^ 2`.

In an inner product space, this is equivalent to `x ↦ f x + m / 2 * ‖x‖ ^ 2` being concave. -/
def StrongConcaveOn (s : Set E) (m : ℝ) : (E → ℝ) → Prop 
goal: (E → ℝ) → Prop

full_name: StrongConvexOn.mono
code: nonrec lemma StrongConvexOn.mono (hmn : m ≤ n) (hf : StrongConvexOn s n f) : StrongConvexOn s m f 
goal: StrongConvexOn s m f

full_name: StrongConcaveOn.mono
code: nonrec lemma StrongConcaveOn.mono (hmn : m ≤ n) (hf : StrongConcaveOn s n f) :
    StrongConcaveOn s m f 
goal: StrongConcaveOn s m f

full_name: strongConvexOn_zero
code: @[simp] lemma strongConvexOn_zero : StrongConvexOn s 0 f ↔ ConvexOn ℝ s f 
goal: StrongConvexOn s 0 f ↔ ConvexOn ℝ s f

full_name: strongConcaveOn_zero
code: @[simp] lemma strongConcaveOn_zero : StrongConcaveOn s 0 f ↔ ConcaveOn ℝ s f 
goal: StrongConcaveOn s 0 f ↔ ConcaveOn ℝ s f

full_name: StrongConvexOn.strictConvexOn
code: nonrec lemma StrongConvexOn.strictConvexOn (hf : StrongConvexOn s m f) (hm : 0 < m) :
    StrictConvexOn ℝ s f 
goal: StrictConvexOn ℝ s f

full_name: StrongConcaveOn.strictConcaveOn
code: nonrec lemma StrongConcaveOn.strictConcaveOn (hf : StrongConcaveOn s m f) (hm : 0 < m) :
    StrictConcaveOn ℝ s f 
goal: StrictConcaveOn ℝ s f

full_name: _private.Mathlib.Analysis.Convex.Strong.0.aux_sub
code: private lemma aux_sub (ha : 0 ≤ a) (hb : 0 ≤ b) (hab : a + b = 1) :
    a * (f x - m / (2 : ℝ) * ‖x‖ ^ 2) + b * (f y - m / (2 : ℝ) * ‖y‖ ^ 2) +
      m / (2 : ℝ) * ‖a • x + b • y‖ ^ 2
      = a * f x + b * f y - m / (2 : ℝ) * a * b * ‖x - y‖ ^ 2 
goal: a * (f x - m / 2 * ‖x‖ ^ 2) + b * (f y - m / 2 * ‖y‖ ^ 2) + m / 2 * ‖a • x + b • y‖ ^ 2 =
  a * f x + b * f y - m / 2 * a * b * ‖x - y‖ ^ 2

full_name: _private.Mathlib.Analysis.Convex.Strong.0.aux_add
code: private lemma aux_add (ha : 0 ≤ a) (hb : 0 ≤ b) (hab : a + b = 1) :
    a * (f x + m / (2 : ℝ) * ‖x‖ ^ 2) + b * (f y + m / (2 : ℝ) * ‖y‖ ^ 2) -
      m / (2 : ℝ) * ‖a • x + b • y‖ ^ 2
      = a * f x + b * f y + m / (2 : ℝ) * a * b * ‖x - y‖ ^ 2 
goal: a * (f x + m / 2 * ‖x‖ ^ 2) + b * (f y + m / 2 * ‖y‖ ^ 2) - m / 2 * ‖a • x + b • y‖ ^ 2 =
  a * f x + b * f y + m / 2 * a * b * ‖x - y‖ ^ 2

full_name: strongConvexOn_iff_convex
code: lemma strongConvexOn_iff_convex :
    StrongConvexOn s m f ↔ ConvexOn ℝ s fun x ↦ f x - m / (2 : ℝ) * ‖x‖ ^ 2 
goal: StrongConvexOn s m f ↔ ConvexOn ℝ s fun x => f x - m / 2 * ‖x‖ ^ 2

full_name: strongConcaveOn_iff_convex
code: lemma strongConcaveOn_iff_convex :
    StrongConcaveOn s m f ↔ ConcaveOn ℝ s fun x ↦ f x + m / (2 : ℝ) * ‖x‖ ^ 2 
goal: StrongConcaveOn s m f ↔ ConcaveOn ℝ s fun x => f x + m / 2 * ‖x‖ ^ 2