File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

full_name: MeasureTheory.eLpNorm'
code: /-- `(∫ ‖f a‖^q ∂μ) ^ (1/q)`, which is a seminorm on the space of measurable functions for which
this quantity is finite -/
def eLpNorm' {_ : MeasurableSpace α} (f : α → F) (q : ℝ) (μ : Measure α) : ℝ≥0∞ 
goal: {x : MeasurableSpace α} → (α → F) → ℝ → MeasureTheory.Measure α → ℝ≥0∞

full_name: MeasureTheory.eLpNormEssSup
code: /-- seminorm for `ℒ∞`, equal to the essential supremum of `‖f‖`. -/
def eLpNormEssSup {_ : MeasurableSpace α} (f : α → F) (μ : Measure α) 
goal: {x : MeasurableSpace α} → (α → F) → MeasureTheory.Measure α → ℝ≥0∞

full_name: MeasureTheory.eLpNorm
code: /-- `ℒp` seminorm, equal to `0` for `p=0`, to `(∫ ‖f a‖^p ∂μ) ^ (1/p)` for `0 < p < ∞` and to
`essSup ‖f‖ μ` for `p = ∞`. -/
def eLpNorm {_ : MeasurableSpace α} (f : α → F) (p : ℝ≥0∞) (μ : Measure α) : ℝ≥0∞ 
goal: {x : MeasurableSpace α} → (α → F) → ℝ≥0∞ → MeasureTheory.Measure α → ℝ≥0∞

full_name: MeasureTheory.eLpNorm_eq_eLpNorm'
code: theorem eLpNorm_eq_eLpNorm' (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞) {f : α → F} :
    eLpNorm f p μ = eLpNorm' f (ENNReal.toReal p) μ 
goal: MeasureTheory.eLpNorm f p μ = MeasureTheory.eLpNorm' f p.toReal μ

full_name: MeasureTheory.eLpNorm_nnreal_eq_eLpNorm'
code: lemma eLpNorm_nnreal_eq_eLpNorm' {f : α → F} {p : ℝ≥0} (hp : p ≠ 0) :
    eLpNorm f p μ = eLpNorm' f p μ 
goal: MeasureTheory.eLpNorm f (↑p) μ = MeasureTheory.eLpNorm' f (↑p) μ

full_name: MeasureTheory.eLpNorm_eq_lintegral_rpow_nnnorm
code: theorem eLpNorm_eq_lintegral_rpow_nnnorm (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞) {f : α → F} :
    eLpNorm f p μ = (∫⁻ x, (‖f x‖₊ : ℝ≥0∞) ^ p.toReal ∂μ) ^ (1 / p.toReal) 
goal: MeasureTheory.eLpNorm f p μ = (∫⁻ (x : α), ↑‖f x‖₊ ^ p.toReal ∂μ) ^ (1 / p.toReal)

full_name: MeasureTheory.eLpNorm_nnreal_eq_lintegral
code: lemma eLpNorm_nnreal_eq_lintegral {f : α → F} {p : ℝ≥0} (hp : p ≠ 0) :
    eLpNorm f p μ = (∫⁻ x, ‖f x‖₊ ^ (p : ℝ) ∂μ) ^ (1 / (p : ℝ)) 
goal: MeasureTheory.eLpNorm f (↑p) μ = (∫⁻ (x : α), ↑‖f x‖₊ ^ ↑p ∂μ) ^ (1 / ↑p)

full_name: MeasureTheory.eLpNorm_one_eq_lintegral_nnnorm
code: theorem eLpNorm_one_eq_lintegral_nnnorm {f : α → F} : eLpNorm f 1 μ = ∫⁻ x, ‖f x‖₊ ∂μ 
goal: MeasureTheory.eLpNorm f 1 μ = ∫⁻ (x : α), ↑‖f x‖₊ ∂μ

full_name: MeasureTheory.eLpNorm_exponent_top
code: @[simp]
theorem eLpNorm_exponent_top {f : α → F} : eLpNorm f ∞ μ = eLpNormEssSup f μ 
goal: MeasureTheory.eLpNorm f ⊤ μ = MeasureTheory.eLpNormEssSup f μ

full_name: MeasureTheory.Memℒp
code: /-- The property that `f:α→E` is ae strongly measurable and `(∫ ‖f a‖^p ∂μ)^(1/p)` is finite
if `p < ∞`, or `essSup f < ∞` if `p = ∞`. -/
def Memℒp {α} {_ : MeasurableSpace α} (f : α → E) (p : ℝ≥0∞)
    (μ : Measure α := by volume_tac) : Prop 
goal: {x : MeasurableSpace α} → (α → E) → ℝ≥0∞ → autoParam (MeasureTheory.Measure α) _auto✝ → Prop

full_name: MeasureTheory.Memℒp.aestronglyMeasurable
code: theorem Memℒp.aestronglyMeasurable {f : α → E} {p : ℝ≥0∞} (h : Memℒp f p μ) :
    AEStronglyMeasurable f μ 
goal: MeasureTheory.AEStronglyMeasurable f μ

full_name: MeasureTheory.lintegral_rpow_nnnorm_eq_rpow_eLpNorm'
code: theorem lintegral_rpow_nnnorm_eq_rpow_eLpNorm' {f : α → F} (hq0_lt : 0 < q) :
    ∫⁻ a, (‖f a‖₊ : ℝ≥0∞) ^ q ∂μ = eLpNorm' f q μ ^ q 
goal: ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ = MeasureTheory.eLpNorm' f q μ ^ q

full_name: MeasureTheory.eLpNorm_nnreal_pow_eq_lintegral
code: lemma eLpNorm_nnreal_pow_eq_lintegral {f : α → F} {p : ℝ≥0} (hp : p ≠ 0) :
    eLpNorm f p μ ^ (p : ℝ) = ∫⁻ x, ‖f x‖₊ ^ (p : ℝ) ∂μ 
goal: MeasureTheory.eLpNorm f (↑p) μ ^ ↑p = ∫⁻ (x : α), ↑‖f x‖₊ ^ ↑p ∂μ

full_name: MeasureTheory.Memℒp.eLpNorm_lt_top
code: theorem Memℒp.eLpNorm_lt_top {f : α → E} (hfp : Memℒp f p μ) : eLpNorm f p μ < ∞ 
goal: MeasureTheory.eLpNorm f p μ < ⊤

full_name: MeasureTheory.Memℒp.eLpNorm_ne_top
code: theorem Memℒp.eLpNorm_ne_top {f : α → E} (hfp : Memℒp f p μ) : eLpNorm f p μ ≠ ∞ 
goal: MeasureTheory.eLpNorm f p μ ≠ ⊤

full_name: MeasureTheory.lintegral_rpow_nnnorm_lt_top_of_eLpNorm'_lt_top
code: theorem lintegral_rpow_nnnorm_lt_top_of_eLpNorm'_lt_top {f : α → F} (hq0_lt : 0 < q)
    (hfq : eLpNorm' f q μ < ∞) : (∫⁻ a, (‖f a‖₊ : ℝ≥0∞) ^ q ∂μ) < ∞ 
goal: ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ < ⊤

full_name: MeasureTheory.lintegral_rpow_nnnorm_lt_top_of_eLpNorm_lt_top
code: theorem lintegral_rpow_nnnorm_lt_top_of_eLpNorm_lt_top {f : α → F} (hp_ne_zero : p ≠ 0)
    (hp_ne_top : p ≠ ∞) (hfp : eLpNorm f p μ < ∞) : (∫⁻ a, (‖f a‖₊ : ℝ≥0∞) ^ p.toReal ∂μ) < ∞ 
goal: ∫⁻ (a : α), ↑‖f a‖₊ ^ p.toReal ∂μ < ⊤

full_name: MeasureTheory.eLpNorm_lt_top_iff_lintegral_rpow_nnnorm_lt_top
code: theorem eLpNorm_lt_top_iff_lintegral_rpow_nnnorm_lt_top {f : α → F} (hp_ne_zero : p ≠ 0)
    (hp_ne_top : p ≠ ∞) : eLpNorm f p μ < ∞ ↔ (∫⁻ a, (‖f a‖₊ : ℝ≥0∞) ^ p.toReal ∂μ) < ∞ 
goal: MeasureTheory.eLpNorm f p μ < ⊤ ↔ ∫⁻ (a : α), ↑‖f a‖₊ ^ p.toReal ∂μ < ⊤

full_name: MeasureTheory.eLpNorm'_exponent_zero
code: @[simp]
theorem eLpNorm'_exponent_zero {f : α → F} : eLpNorm' f 0 μ = 1 
goal: MeasureTheory.eLpNorm' f 0 μ = 1

full_name: MeasureTheory.eLpNorm_exponent_zero
code: @[simp]
theorem eLpNorm_exponent_zero {f : α → F} : eLpNorm f 0 μ = 0 
goal: MeasureTheory.eLpNorm f 0 μ = 0

full_name: MeasureTheory.memℒp_zero_iff_aestronglyMeasurable
code: @[simp]
theorem memℒp_zero_iff_aestronglyMeasurable {f : α → E} :
    Memℒp f 0 μ ↔ AEStronglyMeasurable f μ 
goal: MeasureTheory.Memℒp f 0 μ ↔ MeasureTheory.AEStronglyMeasurable f μ

full_name: MeasureTheory.eLpNorm'_zero
code: @[simp]
theorem eLpNorm'_zero (hp0_lt : 0 < q) : eLpNorm' (0 : α → F) q μ = 0 
goal: MeasureTheory.eLpNorm' 0 q μ = 0

full_name: MeasureTheory.eLpNorm'_zero'
code: @[simp]
theorem eLpNorm'_zero' (hq0_ne : q ≠ 0) (hμ : μ ≠ 0) : eLpNorm' (0 : α → F) q μ = 0 
goal: MeasureTheory.eLpNorm' 0 q μ = 0

full_name: MeasureTheory.eLpNormEssSup_zero
code: @[simp]
theorem eLpNormEssSup_zero : eLpNormEssSup (0 : α → F) μ = 0 
goal: MeasureTheory.eLpNormEssSup 0 μ = 0

full_name: MeasureTheory.eLpNorm_zero
code: @[simp]
theorem eLpNorm_zero : eLpNorm (0 : α → F) p μ = 0 
goal: MeasureTheory.eLpNorm 0 p μ = 0

full_name: MeasureTheory.eLpNorm_zero'
code: @[simp]
theorem eLpNorm_zero' : eLpNorm (fun _ : α => (0 : F)) p μ = 0 
goal: MeasureTheory.eLpNorm (fun x => 0) p μ = 0

full_name: MeasureTheory.zero_memℒp
code: theorem zero_memℒp : Memℒp (0 : α → E) p μ 
goal: MeasureTheory.Memℒp 0 p μ

full_name: MeasureTheory.zero_mem_ℒp'
code: theorem zero_mem_ℒp' : Memℒp (fun _ : α => (0 : E)) p μ 
goal: MeasureTheory.Memℒp (fun x => 0) p μ

full_name: MeasureTheory.eLpNorm'_measure_zero_of_pos
code: theorem eLpNorm'_measure_zero_of_pos {f : α → F} (hq_pos : 0 < q) :
    eLpNorm' f q (0 : Measure α) = 0 
goal: MeasureTheory.eLpNorm' f q 0 = 0

full_name: MeasureTheory.eLpNorm'_measure_zero_of_exponent_zero
code: theorem eLpNorm'_measure_zero_of_exponent_zero {f : α → F} : eLpNorm' f 0 (0 : Measure α) = 1 
goal: MeasureTheory.eLpNorm' f 0 0 = 1

full_name: MeasureTheory.eLpNorm'_measure_zero_of_neg
code: theorem eLpNorm'_measure_zero_of_neg {f : α → F} (hq_neg : q < 0) :
    eLpNorm' f q (0 : Measure α) = ∞ 
goal: MeasureTheory.eLpNorm' f q 0 = ⊤

full_name: MeasureTheory.eLpNormEssSup_measure_zero
code: @[simp]
theorem eLpNormEssSup_measure_zero {f : α → F} : eLpNormEssSup f (0 : Measure α) = 0 
goal: MeasureTheory.eLpNormEssSup f 0 = 0

full_name: MeasureTheory.eLpNorm_measure_zero
code: @[simp]
theorem eLpNorm_measure_zero {f : α → F} : eLpNorm f p (0 : Measure α) = 0 
goal: MeasureTheory.eLpNorm f p 0 = 0

full_name: MeasureTheory.eLpNorm'_neg
code: @[simp]
theorem eLpNorm'_neg {f : α → F} : eLpNorm' (-f) q μ = eLpNorm' f q μ 
goal: MeasureTheory.eLpNorm' (-f) q μ = MeasureTheory.eLpNorm' f q μ

full_name: MeasureTheory.eLpNorm_neg
code: @[simp]
theorem eLpNorm_neg {f : α → F} : eLpNorm (-f) p μ = eLpNorm f p μ 
goal: MeasureTheory.eLpNorm (-f) p μ = MeasureTheory.eLpNorm f p μ

full_name: MeasureTheory.Memℒp.neg
code: theorem Memℒp.neg {f : α → E} (hf : Memℒp f p μ) : Memℒp (-f) p μ 
goal: MeasureTheory.Memℒp (-f) p μ

full_name: MeasureTheory.memℒp_neg_iff
code: theorem memℒp_neg_iff {f : α → E} : Memℒp (-f) p μ ↔ Memℒp f p μ 
goal: MeasureTheory.Memℒp (-f) p μ ↔ MeasureTheory.Memℒp f p μ

full_name: MeasureTheory.eLpNorm_indicator_eq_restrict
code: theorem eLpNorm_indicator_eq_restrict {f : α → E} {s : Set α} (hs : MeasurableSet s) :
    eLpNorm (s.indicator f) p μ = eLpNorm f p (μ.restrict s) 
goal: MeasureTheory.eLpNorm (s.indicator f) p μ = MeasureTheory.eLpNorm f p (μ.restrict s)

full_name: MeasureTheory.eLpNorm'_const
code: theorem eLpNorm'_const (c : F) (hq_pos : 0 < q) :
    eLpNorm' (fun _ : α => c) q μ = (‖c‖₊ : ℝ≥0∞) * μ Set.univ ^ (1 / q) 
goal: MeasureTheory.eLpNorm' (fun x => c) q μ = ↑‖c‖₊ * μ Set.univ ^ (1 / q)

full_name: MeasureTheory.eLpNorm'_const'
code: theorem eLpNorm'_const' [IsFiniteMeasure μ] (c : F) (hc_ne_zero : c ≠ 0) (hq_ne_zero : q ≠ 0) :
    eLpNorm' (fun _ : α => c) q μ = (‖c‖₊ : ℝ≥0∞) * μ Set.univ ^ (1 / q) 
goal: MeasureTheory.eLpNorm' (fun x => c) q μ = ↑‖c‖₊ * μ Set.univ ^ (1 / q)

full_name: MeasureTheory.eLpNormEssSup_const
code: theorem eLpNormEssSup_const (c : F) (hμ : μ ≠ 0) :
    eLpNormEssSup (fun _ : α => c) μ = (‖c‖₊ : ℝ≥0∞) 
goal: MeasureTheory.eLpNormEssSup (fun x => c) μ = ↑‖c‖₊

full_name: MeasureTheory.eLpNorm'_const_of_isProbabilityMeasure
code: theorem eLpNorm'_const_of_isProbabilityMeasure (c : F) (hq_pos : 0 < q) [IsProbabilityMeasure μ] :
    eLpNorm' (fun _ : α => c) q μ = (‖c‖₊ : ℝ≥0∞) 
goal: MeasureTheory.eLpNorm' (fun x => c) q μ = ↑‖c‖₊

full_name: MeasureTheory.eLpNorm_const
code: theorem eLpNorm_const (c : F) (h0 : p ≠ 0) (hμ : μ ≠ 0) :
    eLpNorm (fun _ : α => c) p μ = (‖c‖₊ : ℝ≥0∞) * μ Set.univ ^ (1 / ENNReal.toReal p) 
goal: MeasureTheory.eLpNorm (fun x => c) p μ = ↑‖c‖₊ * μ Set.univ ^ (1 / p.toReal)

full_name: MeasureTheory.eLpNorm_const'
code: theorem eLpNorm_const' (c : F) (h0 : p ≠ 0) (h_top : p ≠ ∞) :
    eLpNorm (fun _ : α => c) p μ = (‖c‖₊ : ℝ≥0∞) * μ Set.univ ^ (1 / ENNReal.toReal p) 
goal: MeasureTheory.eLpNorm (fun x => c) p μ = ↑‖c‖₊ * μ Set.univ ^ (1 / p.toReal)

full_name: MeasureTheory.eLpNorm_const_lt_top_iff
code: theorem eLpNorm_const_lt_top_iff {p : ℝ≥0∞} {c : F} (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞) :
    eLpNorm (fun _ : α => c) p μ < ∞ ↔ c = 0 ∨ μ Set.univ < ∞ 
goal: MeasureTheory.eLpNorm (fun x => c) p μ < ⊤ ↔ c = 0 ∨ μ Set.univ < ⊤

full_name: MeasureTheory.memℒp_const
code: theorem memℒp_const (c : E) [IsFiniteMeasure μ] : Memℒp (fun _ : α => c) p μ 
goal: MeasureTheory.Memℒp (fun x => c) p μ

full_name: MeasureTheory.memℒp_top_const
code: theorem memℒp_top_const (c : E) : Memℒp (fun _ : α => c) ∞ μ 
goal: MeasureTheory.Memℒp (fun x => c) ⊤ μ

full_name: MeasureTheory.memℒp_const_iff
code: theorem memℒp_const_iff {p : ℝ≥0∞} {c : E} (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞) :
    Memℒp (fun _ : α => c) p μ ↔ c = 0 ∨ μ Set.univ < ∞ 
goal: MeasureTheory.Memℒp (fun x => c) p μ ↔ c = 0 ∨ μ Set.univ < ⊤

full_name: MeasureTheory.eLpNorm'_mono_nnnorm_ae
code: lemma eLpNorm'_mono_nnnorm_ae {f : α → F} {g : α → G} (hq : 0 ≤ q) (h : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ ‖g x‖₊) :
    eLpNorm' f q μ ≤ eLpNorm' g q μ 
goal: MeasureTheory.eLpNorm' f q μ ≤ MeasureTheory.eLpNorm' g q μ

full_name: MeasureTheory.eLpNorm'_mono_ae
code: theorem eLpNorm'_mono_ae {f : α → F} {g : α → G} (hq : 0 ≤ q) (h : ∀ᵐ x ∂μ, ‖f x‖ ≤ ‖g x‖) :
    eLpNorm' f q μ ≤ eLpNorm' g q μ 
goal: MeasureTheory.eLpNorm' f q μ ≤ MeasureTheory.eLpNorm' g q μ

full_name: MeasureTheory.eLpNorm'_congr_nnnorm_ae
code: theorem eLpNorm'_congr_nnnorm_ae {f g : α → F} (hfg : ∀ᵐ x ∂μ, ‖f x‖₊ = ‖g x‖₊) :
    eLpNorm' f q μ = eLpNorm' g q μ 
goal: MeasureTheory.eLpNorm' f q μ = MeasureTheory.eLpNorm' g q μ

full_name: MeasureTheory.eLpNorm'_congr_norm_ae
code: theorem eLpNorm'_congr_norm_ae {f g : α → F} (hfg : ∀ᵐ x ∂μ, ‖f x‖ = ‖g x‖) :
    eLpNorm' f q μ = eLpNorm' g q μ 
goal: MeasureTheory.eLpNorm' f q μ = MeasureTheory.eLpNorm' g q μ

full_name: MeasureTheory.eLpNorm'_congr_ae
code: theorem eLpNorm'_congr_ae {f g : α → F} (hfg : f =ᵐ[μ] g) : eLpNorm' f q μ = eLpNorm' g q μ 
goal: MeasureTheory.eLpNorm' f q μ = MeasureTheory.eLpNorm' g q μ

full_name: MeasureTheory.eLpNormEssSup_congr_ae
code: theorem eLpNormEssSup_congr_ae {f g : α → F} (hfg : f =ᵐ[μ] g) :
    eLpNormEssSup f μ = eLpNormEssSup g μ 
goal: MeasureTheory.eLpNormEssSup f μ = MeasureTheory.eLpNormEssSup g μ

full_name: MeasureTheory.eLpNormEssSup_mono_nnnorm_ae
code: theorem eLpNormEssSup_mono_nnnorm_ae {f g : α → F} (hfg : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ ‖g x‖₊) :
    eLpNormEssSup f μ ≤ eLpNormEssSup g μ 
goal: MeasureTheory.eLpNormEssSup f μ ≤ MeasureTheory.eLpNormEssSup g μ

full_name: MeasureTheory.eLpNorm_mono_nnnorm_ae
code: theorem eLpNorm_mono_nnnorm_ae {f : α → F} {g : α → G} (h : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ ‖g x‖₊) :
    eLpNorm f p μ ≤ eLpNorm g p μ 
goal: MeasureTheory.eLpNorm f p μ ≤ MeasureTheory.eLpNorm g p μ

full_name: MeasureTheory.eLpNorm_mono_ae
code: theorem eLpNorm_mono_ae {f : α → F} {g : α → G} (h : ∀ᵐ x ∂μ, ‖f x‖ ≤ ‖g x‖) :
    eLpNorm f p μ ≤ eLpNorm g p μ 
goal: MeasureTheory.eLpNorm f p μ ≤ MeasureTheory.eLpNorm g p μ

full_name: MeasureTheory.eLpNorm_mono_ae_real
code: theorem eLpNorm_mono_ae_real {f : α → F} {g : α → ℝ} (h : ∀ᵐ x ∂μ, ‖f x‖ ≤ g x) :
    eLpNorm f p μ ≤ eLpNorm g p μ 
goal: MeasureTheory.eLpNorm f p μ ≤ MeasureTheory.eLpNorm g p μ

full_name: MeasureTheory.eLpNorm_mono_nnnorm
code: theorem eLpNorm_mono_nnnorm {f : α → F} {g : α → G} (h : ∀ x, ‖f x‖₊ ≤ ‖g x‖₊) :
    eLpNorm f p μ ≤ eLpNorm g p μ 
goal: MeasureTheory.eLpNorm f p μ ≤ MeasureTheory.eLpNorm g p μ

full_name: MeasureTheory.eLpNorm_mono
code: theorem eLpNorm_mono {f : α → F} {g : α → G} (h : ∀ x, ‖f x‖ ≤ ‖g x‖) :
    eLpNorm f p μ ≤ eLpNorm g p μ 
goal: MeasureTheory.eLpNorm f p μ ≤ MeasureTheory.eLpNorm g p μ

full_name: MeasureTheory.eLpNorm_mono_real
code: theorem eLpNorm_mono_real {f : α → F} {g : α → ℝ} (h : ∀ x, ‖f x‖ ≤ g x) :
    eLpNorm f p μ ≤ eLpNorm g p μ 
goal: MeasureTheory.eLpNorm f p μ ≤ MeasureTheory.eLpNorm g p μ

full_name: MeasureTheory.eLpNormEssSup_le_of_ae_nnnorm_bound
code: theorem eLpNormEssSup_le_of_ae_nnnorm_bound {f : α → F} {C : ℝ≥0} (hfC : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ C) :
    eLpNormEssSup f μ ≤ C 
goal: MeasureTheory.eLpNormEssSup f μ ≤ ↑C

full_name: MeasureTheory.eLpNormEssSup_le_of_ae_bound
code: theorem eLpNormEssSup_le_of_ae_bound {f : α → F} {C : ℝ} (hfC : ∀ᵐ x ∂μ, ‖f x‖ ≤ C) :
    eLpNormEssSup f μ ≤ ENNReal.ofReal C 
goal: MeasureTheory.eLpNormEssSup f μ ≤ ENNReal.ofReal C

full_name: MeasureTheory.eLpNormEssSup_lt_top_of_ae_nnnorm_bound
code: theorem eLpNormEssSup_lt_top_of_ae_nnnorm_bound {f : α → F} {C : ℝ≥0} (hfC : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ C) :
    eLpNormEssSup f μ < ∞ 
goal: MeasureTheory.eLpNormEssSup f μ < ⊤

full_name: MeasureTheory.eLpNormEssSup_lt_top_of_ae_bound
code: theorem eLpNormEssSup_lt_top_of_ae_bound {f : α → F} {C : ℝ} (hfC : ∀ᵐ x ∂μ, ‖f x‖ ≤ C) :
    eLpNormEssSup f μ < ∞ 
goal: MeasureTheory.eLpNormEssSup f μ < ⊤

full_name: MeasureTheory.eLpNorm_le_of_ae_nnnorm_bound
code: theorem eLpNorm_le_of_ae_nnnorm_bound {f : α → F} {C : ℝ≥0} (hfC : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ C) :
    eLpNorm f p μ ≤ C • μ Set.univ ^ p.toReal⁻¹ 
goal: MeasureTheory.eLpNorm f p μ ≤ C • μ Set.univ ^ p.toReal⁻¹

full_name: MeasureTheory.eLpNorm_le_of_ae_bound
code: theorem eLpNorm_le_of_ae_bound {f : α → F} {C : ℝ} (hfC : ∀ᵐ x ∂μ, ‖f x‖ ≤ C) :
    eLpNorm f p μ ≤ μ Set.univ ^ p.toReal⁻¹ * ENNReal.ofReal C 
goal: MeasureTheory.eLpNorm f p μ ≤ μ Set.univ ^ p.toReal⁻¹ * ENNReal.ofReal C

full_name: MeasureTheory.eLpNorm_congr_nnnorm_ae
code: theorem eLpNorm_congr_nnnorm_ae {f : α → F} {g : α → G} (hfg : ∀ᵐ x ∂μ, ‖f x‖₊ = ‖g x‖₊) :
    eLpNorm f p μ = eLpNorm g p μ 
goal: MeasureTheory.eLpNorm f p μ = MeasureTheory.eLpNorm g p μ

full_name: MeasureTheory.eLpNorm_congr_norm_ae
code: theorem eLpNorm_congr_norm_ae {f : α → F} {g : α → G} (hfg : ∀ᵐ x ∂μ, ‖f x‖ = ‖g x‖) :
    eLpNorm f p μ = eLpNorm g p μ 
goal: MeasureTheory.eLpNorm f p μ = MeasureTheory.eLpNorm g p μ

full_name: MeasureTheory.eLpNorm_indicator_sub_indicator
code: theorem eLpNorm_indicator_sub_indicator (s t : Set α) (f : α → E) :
    eLpNorm (s.indicator f - t.indicator f) p μ = eLpNorm ((s ∆ t).indicator f) p μ 
goal: MeasureTheory.eLpNorm (s.indicator f - t.indicator f) p μ = MeasureTheory.eLpNorm ((symmDiff s t).indicator f) p μ

full_name: MeasureTheory.eLpNorm'_norm
code: @[simp]
theorem eLpNorm'_norm {f : α → F} :
    eLpNorm' (fun a => ‖f a‖) q μ = eLpNorm' f q μ 
goal: MeasureTheory.eLpNorm' (fun a => ‖f a‖) q μ = MeasureTheory.eLpNorm' f q μ

full_name: MeasureTheory.eLpNorm_norm
code: @[simp]
theorem eLpNorm_norm (f : α → F) : eLpNorm (fun x => ‖f x‖) p μ = eLpNorm f p μ 
goal: MeasureTheory.eLpNorm (fun x => ‖f x‖) p μ = MeasureTheory.eLpNorm f p μ

full_name: MeasureTheory.eLpNorm'_norm_rpow
code: theorem eLpNorm'_norm_rpow (f : α → F) (p q : ℝ) (hq_pos : 0 < q) :
    eLpNorm' (fun x => ‖f x‖ ^ q) p μ = eLpNorm' f (p * q) μ ^ q 
goal: MeasureTheory.eLpNorm' (fun x => ‖f x‖ ^ q) p μ = MeasureTheory.eLpNorm' f (p * q) μ ^ q

full_name: MeasureTheory.eLpNorm_norm_rpow
code: theorem eLpNorm_norm_rpow (f : α → F) (hq_pos : 0 < q) :
    eLpNorm (fun x => ‖f x‖ ^ q) p μ = eLpNorm f (p * ENNReal.ofReal q) μ ^ q 
goal: MeasureTheory.eLpNorm (fun x => ‖f x‖ ^ q) p μ = MeasureTheory.eLpNorm f (p * ENNReal.ofReal q) μ ^ q

full_name: MeasureTheory.eLpNorm_congr_ae
code: theorem eLpNorm_congr_ae {f g : α → F} (hfg : f =ᵐ[μ] g) : eLpNorm f p μ = eLpNorm g p μ 
goal: MeasureTheory.eLpNorm f p μ = MeasureTheory.eLpNorm g p μ

full_name: MeasureTheory.memℒp_congr_ae
code: theorem memℒp_congr_ae {f g : α → E} (hfg : f =ᵐ[μ] g) : Memℒp f p μ ↔ Memℒp g p μ 
goal: MeasureTheory.Memℒp f p μ ↔ MeasureTheory.Memℒp g p μ

full_name: MeasureTheory.Memℒp.ae_eq
code: theorem Memℒp.ae_eq {f g : α → E} (hfg : f =ᵐ[μ] g) (hf_Lp : Memℒp f p μ) : Memℒp g p μ 
goal: MeasureTheory.Memℒp g p μ

full_name: MeasureTheory.Memℒp.of_le
code: theorem Memℒp.of_le {f : α → E} {g : α → F} (hg : Memℒp g p μ) (hf : AEStronglyMeasurable f μ)
    (hfg : ∀ᵐ x ∂μ, ‖f x‖ ≤ ‖g x‖) : Memℒp f p μ 
goal: MeasureTheory.Memℒp f p μ

full_name: MeasureTheory.Memℒp.mono'
code: theorem Memℒp.mono' {f : α → E} {g : α → ℝ} (hg : Memℒp g p μ) (hf : AEStronglyMeasurable f μ)
    (h : ∀ᵐ a ∂μ, ‖f a‖ ≤ g a) : Memℒp f p μ 
goal: MeasureTheory.Memℒp f p μ

full_name: MeasureTheory.Memℒp.congr_norm
code: theorem Memℒp.congr_norm {f : α → E} {g : α → F} (hf : Memℒp f p μ) (hg : AEStronglyMeasurable g μ)
    (h : ∀ᵐ a ∂μ, ‖f a‖ = ‖g a‖) : Memℒp g p μ 
goal: MeasureTheory.Memℒp g p μ

full_name: MeasureTheory.memℒp_congr_norm
code: theorem memℒp_congr_norm {f : α → E} {g : α → F} (hf : AEStronglyMeasurable f μ)
    (hg : AEStronglyMeasurable g μ) (h : ∀ᵐ a ∂μ, ‖f a‖ = ‖g a‖) : Memℒp f p μ ↔ Memℒp g p μ 
goal: MeasureTheory.Memℒp f p μ ↔ MeasureTheory.Memℒp g p μ

full_name: MeasureTheory.memℒp_top_of_bound
code: theorem memℒp_top_of_bound {f : α → E} (hf : AEStronglyMeasurable f μ) (C : ℝ)
    (hfC : ∀ᵐ x ∂μ, ‖f x‖ ≤ C) : Memℒp f ∞ μ 
goal: MeasureTheory.Memℒp f ⊤ μ

full_name: MeasureTheory.Memℒp.of_bound
code: theorem Memℒp.of_bound [IsFiniteMeasure μ] {f : α → E} (hf : AEStronglyMeasurable f μ) (C : ℝ)
    (hfC : ∀ᵐ x ∂μ, ‖f x‖ ≤ C) : Memℒp f p μ 
goal: MeasureTheory.Memℒp f p μ

full_name: MeasureTheory.eLpNorm'_mono_measure
code: @[mono]
theorem eLpNorm'_mono_measure (f : α → F) (hμν : ν ≤ μ) (hq : 0 ≤ q) :
    eLpNorm' f q ν ≤ eLpNorm' f q μ 
goal: MeasureTheory.eLpNorm' f q ν ≤ MeasureTheory.eLpNorm' f q μ

full_name: MeasureTheory.eLpNormEssSup_mono_measure
code: @[mono]
theorem eLpNormEssSup_mono_measure (f : α → F) (hμν : ν ≪ μ) :
    eLpNormEssSup f ν ≤ eLpNormEssSup f μ 
goal: MeasureTheory.eLpNormEssSup f ν ≤ MeasureTheory.eLpNormEssSup f μ

full_name: MeasureTheory.eLpNorm_mono_measure
code: @[mono]
theorem eLpNorm_mono_measure (f : α → F) (hμν : ν ≤ μ) : eLpNorm f p ν ≤ eLpNorm f p μ 
goal: MeasureTheory.eLpNorm f p ν ≤ MeasureTheory.eLpNorm f p μ

full_name: MeasureTheory.Memℒp.mono_measure
code: theorem Memℒp.mono_measure {f : α → E} (hμν : ν ≤ μ) (hf : Memℒp f p μ) : Memℒp f p ν 
goal: MeasureTheory.Memℒp f p ν

full_name: MeasureTheory.eLpNorm_restrict_le
code: lemma eLpNorm_restrict_le (f : α → F) (p : ℝ≥0∞) (μ : Measure α) (s : Set α) :
    eLpNorm f p (μ.restrict s) ≤ eLpNorm f p μ 
goal: MeasureTheory.eLpNorm f p (μ.restrict s) ≤ MeasureTheory.eLpNorm f p μ

full_name: MeasureTheory.eLpNorm_restrict_eq_of_support_subset
code: /-- For a function `f` with support in `s`, the Lᵖ norms of `f` with respect to `μ` and
`μ.restrict s` are the same. -/
theorem eLpNorm_restrict_eq_of_support_subset {s : Set α} {f : α → F} (hsf : f.support ⊆ s) :
    eLpNorm f p (μ.restrict s) = eLpNorm f p μ 
goal: MeasureTheory.eLpNorm f p (μ.restrict s) = MeasureTheory.eLpNorm f p μ

full_name: MeasureTheory.Memℒp.restrict
code: theorem Memℒp.restrict (s : Set α) {f : α → E} (hf : Memℒp f p μ) : Memℒp f p (μ.restrict s) 
goal: MeasureTheory.Memℒp f p (μ.restrict s)

full_name: MeasureTheory.eLpNorm'_smul_measure
code: theorem eLpNorm'_smul_measure {p : ℝ} (hp : 0 ≤ p) {f : α → F} (c : ℝ≥0∞) :
    eLpNorm' f p (c • μ) = c ^ (1 / p) * eLpNorm' f p μ 
goal: MeasureTheory.eLpNorm' f p (c • μ) = c ^ (1 / p) * MeasureTheory.eLpNorm' f p μ

full_name: MeasureTheory.eLpNormEssSup_smul_measure
code: theorem eLpNormEssSup_smul_measure {f : α → F} {c : ℝ≥0∞} (hc : c ≠ 0) :
    eLpNormEssSup f (c • μ) = eLpNormEssSup f μ 
goal: MeasureTheory.eLpNormEssSup f (c • μ) = MeasureTheory.eLpNormEssSup f μ

full_name: _private.Mathlib.MeasureTheory.Function.LpSeminorm.Basic.0.MeasureTheory.eLpNorm_smul_measure_of_ne_zero_of_ne_top
code: /-- Use `eLpNorm_smul_measure_of_ne_top` instead. -/
private theorem eLpNorm_smul_measure_of_ne_zero_of_ne_top {p : ℝ≥0∞} (hp_ne_zero : p ≠ 0)
    (hp_ne_top : p ≠ ∞) {f : α → F} (c : ℝ≥0∞) :
    eLpNorm f p (c • μ) = c ^ (1 / p).toReal • eLpNorm f p μ 
goal: MeasureTheory.eLpNorm f p (c • μ) = c ^ (1 / p).toReal • MeasureTheory.eLpNorm f p μ

full_name: MeasureTheory.eLpNorm_smul_measure_of_ne_zero
code: theorem eLpNorm_smul_measure_of_ne_zero {p : ℝ≥0∞} {f : α → F} {c : ℝ≥0∞} (hc : c ≠ 0) :
    eLpNorm f p (c • μ) = c ^ (1 / p).toReal • eLpNorm f p μ 
goal: MeasureTheory.eLpNorm f p (c • μ) = c ^ (1 / p).toReal • MeasureTheory.eLpNorm f p μ

full_name: MeasureTheory.eLpNorm_smul_measure_of_ne_top
code: theorem eLpNorm_smul_measure_of_ne_top {p : ℝ≥0∞} (hp_ne_top : p ≠ ∞) {f : α → F} (c : ℝ≥0∞) :
    eLpNorm f p (c • μ) = c ^ (1 / p).toReal • eLpNorm f p μ 
goal: MeasureTheory.eLpNorm f p (c • μ) = c ^ (1 / p).toReal • MeasureTheory.eLpNorm f p μ

full_name: MeasureTheory.eLpNorm_one_smul_measure
code: theorem eLpNorm_one_smul_measure {f : α → F} (c : ℝ≥0∞) :
    eLpNorm f 1 (c • μ) = c * eLpNorm f 1 μ 
goal: MeasureTheory.eLpNorm f 1 (c • μ) = c * MeasureTheory.eLpNorm f 1 μ

full_name: MeasureTheory.Memℒp.of_measure_le_smul
code: theorem Memℒp.of_measure_le_smul {μ' : Measure α} (c : ℝ≥0∞) (hc : c ≠ ∞) (hμ'_le : μ' ≤ c • μ)
    {f : α → E} (hf : Memℒp f p μ) : Memℒp f p μ' 
goal: MeasureTheory.Memℒp f p μ'

full_name: MeasureTheory.Memℒp.smul_measure
code: theorem Memℒp.smul_measure {f : α → E} {c : ℝ≥0∞} (hf : Memℒp f p μ) (hc : c ≠ ∞) :
    Memℒp f p (c • μ) 
goal: MeasureTheory.Memℒp f p (c • μ)

full_name: MeasureTheory.eLpNorm_one_add_measure
code: theorem eLpNorm_one_add_measure (f : α → F) (μ ν : Measure α) :
    eLpNorm f 1 (μ + ν) = eLpNorm f 1 μ + eLpNorm f 1 ν 
goal: MeasureTheory.eLpNorm f 1 (μ + ν) = MeasureTheory.eLpNorm f 1 μ + MeasureTheory.eLpNorm f 1 ν

full_name: MeasureTheory.eLpNorm_le_add_measure_right
code: theorem eLpNorm_le_add_measure_right (f : α → F) (μ ν : Measure α) {p : ℝ≥0∞} :
    eLpNorm f p μ ≤ eLpNorm f p (μ + ν) 
goal: MeasureTheory.eLpNorm f p μ ≤ MeasureTheory.eLpNorm f p (μ + ν)

full_name: MeasureTheory.eLpNorm_le_add_measure_left
code: theorem eLpNorm_le_add_measure_left (f : α → F) (μ ν : Measure α) {p : ℝ≥0∞} :
    eLpNorm f p ν ≤ eLpNorm f p (μ + ν) 
goal: MeasureTheory.eLpNorm f p ν ≤ MeasureTheory.eLpNorm f p (μ + ν)

full_name: MeasureTheory.Memℒp.left_of_add_measure
code: theorem Memℒp.left_of_add_measure {f : α → E} (h : Memℒp f p (μ + ν)) : Memℒp f p μ 
goal: MeasureTheory.Memℒp f p μ

full_name: MeasureTheory.Memℒp.right_of_add_measure
code: theorem Memℒp.right_of_add_measure {f : α → E} (h : Memℒp f p (μ + ν)) : Memℒp f p ν 
goal: MeasureTheory.Memℒp f p ν

full_name: MeasureTheory.Memℒp.norm
code: theorem Memℒp.norm {f : α → E} (h : Memℒp f p μ) : Memℒp (fun x => ‖f x‖) p μ 
goal: MeasureTheory.Memℒp (fun x => ‖f x‖) p μ

full_name: MeasureTheory.memℒp_norm_iff
code: theorem memℒp_norm_iff {f : α → E} (hf : AEStronglyMeasurable f μ) :
    Memℒp (fun x => ‖f x‖) p μ ↔ Memℒp f p μ 
goal: MeasureTheory.Memℒp (fun x => ‖f x‖) p μ ↔ MeasureTheory.Memℒp f p μ

full_name: MeasureTheory.eLpNorm'_eq_zero_of_ae_zero
code: theorem eLpNorm'_eq_zero_of_ae_zero {f : α → F} (hq0_lt : 0 < q) (hf_zero : f =ᵐ[μ] 0) :
    eLpNorm' f q μ = 0 
goal: MeasureTheory.eLpNorm' f q μ = 0

full_name: MeasureTheory.eLpNorm'_eq_zero_of_ae_zero'
code: theorem eLpNorm'_eq_zero_of_ae_zero' (hq0_ne : q ≠ 0) (hμ : μ ≠ 0) {f : α → F}
    (hf_zero : f =ᵐ[μ] 0) :
    eLpNorm' f q μ = 0 
goal: MeasureTheory.eLpNorm' f q μ = 0

full_name: MeasureTheory.ae_eq_zero_of_eLpNorm'_eq_zero
code: theorem ae_eq_zero_of_eLpNorm'_eq_zero {f : α → E} (hq0 : 0 ≤ q) (hf : AEStronglyMeasurable f μ)
    (h : eLpNorm' f q μ = 0) : f =ᵐ[μ] 0 
goal: f =ᵐ[μ] 0

full_name: MeasureTheory.eLpNorm'_eq_zero_iff
code: theorem eLpNorm'_eq_zero_iff (hq0_lt : 0 < q) {f : α → E} (hf : AEStronglyMeasurable f μ) :
    eLpNorm' f q μ = 0 ↔ f =ᵐ[μ] 0 
goal: MeasureTheory.eLpNorm' f q μ = 0 ↔ f =ᵐ[μ] 0

full_name: MeasureTheory.coe_nnnorm_ae_le_eLpNormEssSup
code: theorem coe_nnnorm_ae_le_eLpNormEssSup {_ : MeasurableSpace α} (f : α → F) (μ : Measure α) :
    ∀ᵐ x ∂μ, (‖f x‖₊ : ℝ≥0∞) ≤ eLpNormEssSup f μ 
goal: ∀ {x : MeasurableSpace α} (f : α → F) (μ : MeasureTheory.Measure α),
  ∀ᵐ (x_1 : α) ∂μ, ↑‖f x_1‖₊ ≤ MeasureTheory.eLpNormEssSup f μ

full_name: MeasureTheory.eLpNormEssSup_eq_zero_iff
code: @[simp]
theorem eLpNormEssSup_eq_zero_iff {f : α → F} : eLpNormEssSup f μ = 0 ↔ f =ᵐ[μ] 0 
goal: MeasureTheory.eLpNormEssSup f μ = 0 ↔ f =ᵐ[μ] 0

full_name: MeasureTheory.eLpNorm_eq_zero_iff
code: theorem eLpNorm_eq_zero_iff {f : α → E} (hf : AEStronglyMeasurable f μ) (h0 : p ≠ 0) :
    eLpNorm f p μ = 0 ↔ f =ᵐ[μ] 0 
goal: MeasureTheory.eLpNorm f p μ = 0 ↔ f =ᵐ[μ] 0

full_name: MeasureTheory.ae_le_eLpNormEssSup
code: theorem ae_le_eLpNormEssSup {f : α → F} : ∀ᵐ y ∂μ, ‖f y‖₊ ≤ eLpNormEssSup f μ 
goal: ∀ᵐ (y : α) ∂μ, ↑‖f y‖₊ ≤ MeasureTheory.eLpNormEssSup f μ

full_name: MeasureTheory.meas_eLpNormEssSup_lt
code: theorem meas_eLpNormEssSup_lt {f : α → F} : μ { y | eLpNormEssSup f μ < ‖f y‖₊ } = 0 
goal: μ {y | MeasureTheory.eLpNormEssSup f μ < ↑‖f y‖₊} = 0

full_name: MeasureTheory.eLpNormEssSup_piecewise
code: lemma eLpNormEssSup_piecewise {s : Set α} (f g : α → E) [DecidablePred (· ∈ s)]
    (hs : MeasurableSet s) :
    eLpNormEssSup (Set.piecewise s f g) μ
      = max (eLpNormEssSup f (μ.restrict s)) (eLpNormEssSup g (μ.restrict sᶜ)) 
goal: MeasureTheory.eLpNormEssSup (s.piecewise f g) μ =
  max (MeasureTheory.eLpNormEssSup f (μ.restrict s)) (MeasureTheory.eLpNormEssSup g (μ.restrict sᶜ))

full_name: MeasureTheory.eLpNorm_top_piecewise
code: lemma eLpNorm_top_piecewise {s : Set α} (f g : α → E) [DecidablePred (· ∈ s)]
    (hs : MeasurableSet s) :
    eLpNorm (Set.piecewise s f g) ∞ μ
      = max (eLpNorm f ∞ (μ.restrict s)) (eLpNorm g ∞ (μ.restrict sᶜ)) 
goal: MeasureTheory.eLpNorm (s.piecewise f g) ⊤ μ =
  max (MeasureTheory.eLpNorm f ⊤ (μ.restrict s)) (MeasureTheory.eLpNorm g ⊤ (μ.restrict sᶜ))

full_name: MeasureTheory.eLpNormEssSup_map_measure
code: theorem eLpNormEssSup_map_measure (hg : AEStronglyMeasurable g (Measure.map f μ))
    (hf : AEMeasurable f μ) : eLpNormEssSup g (Measure.map f μ) = eLpNormEssSup (g ∘ f) μ 
goal: MeasureTheory.eLpNormEssSup g (MeasureTheory.Measure.map f μ) = MeasureTheory.eLpNormEssSup (g ∘ f) μ

full_name: MeasureTheory.eLpNorm_map_measure
code: theorem eLpNorm_map_measure (hg : AEStronglyMeasurable g (Measure.map f μ))
    (hf : AEMeasurable f μ) : eLpNorm g p (Measure.map f μ) = eLpNorm (g ∘ f) p μ 
goal: MeasureTheory.eLpNorm g p (MeasureTheory.Measure.map f μ) = MeasureTheory.eLpNorm (g ∘ f) p μ

full_name: MeasureTheory.memℒp_map_measure_iff
code: theorem memℒp_map_measure_iff (hg : AEStronglyMeasurable g (Measure.map f μ))
    (hf : AEMeasurable f μ) : Memℒp g p (Measure.map f μ) ↔ Memℒp (g ∘ f) p μ 
goal: MeasureTheory.Memℒp g p (MeasureTheory.Measure.map f μ) ↔ MeasureTheory.Memℒp (g ∘ f) p μ

full_name: MeasureTheory.Memℒp.comp_of_map
code: theorem Memℒp.comp_of_map (hg : Memℒp g p (Measure.map f μ)) (hf : AEMeasurable f μ) :
    Memℒp (g ∘ f) p μ 
goal: MeasureTheory.Memℒp (g ∘ f) p μ

full_name: MeasureTheory.eLpNorm_comp_measurePreserving
code: theorem eLpNorm_comp_measurePreserving {ν : MeasureTheory.Measure β} (hg : AEStronglyMeasurable g ν)
    (hf : MeasurePreserving f μ ν) : eLpNorm (g ∘ f) p μ = eLpNorm g p ν 
goal: MeasureTheory.eLpNorm (g ∘ f) p μ = MeasureTheory.eLpNorm g p ν

full_name: MeasureTheory.AEEqFun.eLpNorm_compMeasurePreserving
code: theorem AEEqFun.eLpNorm_compMeasurePreserving {ν : MeasureTheory.Measure β} (g : β →ₘ[ν] E)
    (hf : MeasurePreserving f μ ν) :
    eLpNorm (g.compMeasurePreserving f hf) p μ = eLpNorm g p ν 
goal: MeasureTheory.eLpNorm (↑(g.compMeasurePreserving f hf)) p μ = MeasureTheory.eLpNorm (↑g) p ν

full_name: MeasureTheory.Memℒp.comp_measurePreserving
code: theorem Memℒp.comp_measurePreserving {ν : MeasureTheory.Measure β} (hg : Memℒp g p ν)
    (hf : MeasurePreserving f μ ν) : Memℒp (g ∘ f) p μ 
goal: MeasureTheory.Memℒp (g ∘ f) p μ

full_name: MeasurableEmbedding.eLpNormEssSup_map_measure
code: theorem _root_.MeasurableEmbedding.eLpNormEssSup_map_measure {g : β → F}
    (hf : MeasurableEmbedding f) : eLpNormEssSup g (Measure.map f μ) = eLpNormEssSup (g ∘ f) μ 
goal: MeasureTheory.eLpNormEssSup g (MeasureTheory.Measure.map f μ) = MeasureTheory.eLpNormEssSup (g ∘ f) μ

full_name: MeasurableEmbedding.eLpNorm_map_measure
code: theorem _root_.MeasurableEmbedding.eLpNorm_map_measure {g : β → F} (hf : MeasurableEmbedding f) :
    eLpNorm g p (Measure.map f μ) = eLpNorm (g ∘ f) p μ 
goal: MeasureTheory.eLpNorm g p (MeasureTheory.Measure.map f μ) = MeasureTheory.eLpNorm (g ∘ f) p μ

full_name: MeasurableEmbedding.memℒp_map_measure_iff
code: theorem _root_.MeasurableEmbedding.memℒp_map_measure_iff {g : β → F} (hf : MeasurableEmbedding f) :
    Memℒp g p (Measure.map f μ) ↔ Memℒp (g ∘ f) p μ 
goal: MeasureTheory.Memℒp g p (MeasureTheory.Measure.map f μ) ↔ MeasureTheory.Memℒp (g ∘ f) p μ

full_name: MeasurableEquiv.memℒp_map_measure_iff
code: theorem _root_.MeasurableEquiv.memℒp_map_measure_iff (f : α ≃ᵐ β) {g : β → F} :
    Memℒp g p (Measure.map f μ) ↔ Memℒp (g ∘ f) p μ 
goal: MeasureTheory.Memℒp g p (MeasureTheory.Measure.map (⇑f) μ) ↔ MeasureTheory.Memℒp (g ∘ ⇑f) p μ

full_name: MeasureTheory.eLpNorm'_le_nnreal_smul_eLpNorm'_of_ae_le_mul
code: theorem eLpNorm'_le_nnreal_smul_eLpNorm'_of_ae_le_mul {f : α → F} {g : α → G} {c : ℝ≥0}
    (h : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ c * ‖g x‖₊) {p : ℝ} (hp : 0 < p) :
    eLpNorm' f p μ ≤ c • eLpNorm' g p μ 
goal: MeasureTheory.eLpNorm' f p μ ≤ c • MeasureTheory.eLpNorm' g p μ

full_name: MeasureTheory.eLpNormEssSup_le_nnreal_smul_eLpNormEssSup_of_ae_le_mul
code: theorem eLpNormEssSup_le_nnreal_smul_eLpNormEssSup_of_ae_le_mul {f : α → F} {g : α → G} {c : ℝ≥0}
    (h : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ c * ‖g x‖₊) : eLpNormEssSup f μ ≤ c • eLpNormEssSup g μ 
goal: MeasureTheory.eLpNormEssSup f μ ≤ c • MeasureTheory.eLpNormEssSup g μ

full_name: MeasureTheory.eLpNorm_le_nnreal_smul_eLpNorm_of_ae_le_mul
code: theorem eLpNorm_le_nnreal_smul_eLpNorm_of_ae_le_mul {f : α → F} {g : α → G} {c : ℝ≥0}
    (h : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ c * ‖g x‖₊) (p : ℝ≥0∞) : eLpNorm f p μ ≤ c • eLpNorm g p μ 
goal: MeasureTheory.eLpNorm f p μ ≤ c • MeasureTheory.eLpNorm g p μ

full_name: _private.Mathlib.MeasureTheory.Function.LpSeminorm.Basic.0.MeasureTheory.le_mul_iff_eq_zero_of_nonneg_of_neg_of_nonneg
code: private theorem le_mul_iff_eq_zero_of_nonneg_of_neg_of_nonneg {α} [LinearOrderedSemiring α]
    {a b c : α} (ha : 0 ≤ a) (hb : b < 0) (hc : 0 ≤ c) : a ≤ b * c ↔ a = 0 ∧ c = 0 
goal: a ≤ b * c ↔ a = 0 ∧ c = 0

full_name: MeasureTheory.eLpNorm_eq_zero_and_zero_of_ae_le_mul_neg
code: /-- When `c` is negative, `‖f x‖ ≤ c * ‖g x‖` is nonsense and forces both `f` and `g` to have an
`eLpNorm` of `0`. -/
theorem eLpNorm_eq_zero_and_zero_of_ae_le_mul_neg {f : α → F} {g : α → G} {c : ℝ}
    (h : ∀ᵐ x ∂μ, ‖f x‖ ≤ c * ‖g x‖) (hc : c < 0) (p : ℝ≥0∞) :
    eLpNorm f p μ = 0 ∧ eLpNorm g p μ = 0 
goal: MeasureTheory.eLpNorm f p μ = 0 ∧ MeasureTheory.eLpNorm g p μ = 0

full_name: MeasureTheory.eLpNorm_le_mul_eLpNorm_of_ae_le_mul
code: theorem eLpNorm_le_mul_eLpNorm_of_ae_le_mul {f : α → F} {g : α → G} {c : ℝ}
    (h : ∀ᵐ x ∂μ, ‖f x‖ ≤ c * ‖g x‖) (p : ℝ≥0∞) :
    eLpNorm f p μ ≤ ENNReal.ofReal c * eLpNorm g p μ 
goal: MeasureTheory.eLpNorm f p μ ≤ ENNReal.ofReal c * MeasureTheory.eLpNorm g p μ

full_name: MeasureTheory.Memℒp.of_nnnorm_le_mul
code: theorem Memℒp.of_nnnorm_le_mul {f : α → E} {g : α → F} {c : ℝ≥0} (hg : Memℒp g p μ)
    (hf : AEStronglyMeasurable f μ) (hfg : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ c * ‖g x‖₊) : Memℒp f p μ 
goal: MeasureTheory.Memℒp f p μ

full_name: MeasureTheory.Memℒp.of_le_mul
code: theorem Memℒp.of_le_mul {f : α → E} {g : α → F} {c : ℝ} (hg : Memℒp g p μ)
    (hf : AEStronglyMeasurable f μ) (hfg : ∀ᵐ x ∂μ, ‖f x‖ ≤ c * ‖g x‖) : Memℒp f p μ 
goal: MeasureTheory.Memℒp f p μ

full_name: MeasureTheory.eLpNorm'_const_smul_le
code: theorem eLpNorm'_const_smul_le (c : 𝕜) (f : α → F) (hq_pos : 0 < q) :
    eLpNorm' (c • f) q μ ≤ ‖c‖₊ • eLpNorm' f q μ 
goal: MeasureTheory.eLpNorm' (c • f) q μ ≤ ‖c‖₊ • MeasureTheory.eLpNorm' f q μ

full_name: MeasureTheory.eLpNormEssSup_const_smul_le
code: theorem eLpNormEssSup_const_smul_le (c : 𝕜) (f : α → F) :
    eLpNormEssSup (c • f) μ ≤ ‖c‖₊ • eLpNormEssSup f μ 
goal: MeasureTheory.eLpNormEssSup (c • f) μ ≤ ‖c‖₊ • MeasureTheory.eLpNormEssSup f μ

full_name: MeasureTheory.eLpNorm_const_smul_le
code: theorem eLpNorm_const_smul_le (c : 𝕜) (f : α → F) : eLpNorm (c • f) p μ ≤ ‖c‖₊ • eLpNorm f p μ 
goal: MeasureTheory.eLpNorm (c • f) p μ ≤ ‖c‖₊ • MeasureTheory.eLpNorm f p μ

full_name: MeasureTheory.Memℒp.const_smul
code: theorem Memℒp.const_smul {f : α → E} (hf : Memℒp f p μ) (c : 𝕜) : Memℒp (c • f) p μ 
goal: MeasureTheory.Memℒp (c • f) p μ

full_name: MeasureTheory.Memℒp.const_mul
code: theorem Memℒp.const_mul {R} [NormedRing R] {f : α → R} (hf : Memℒp f p μ) (c : R) :
    Memℒp (fun x => c * f x) p μ 
goal: MeasureTheory.Memℒp (fun x => c * f x) p μ

full_name: MeasureTheory.eLpNorm'_const_smul
code: theorem eLpNorm'_const_smul {f : α → F} (c : 𝕜) (hq_pos : 0 < q) :
    eLpNorm' (c • f) q μ = ‖c‖₊ • eLpNorm' f q μ 
goal: MeasureTheory.eLpNorm' (c • f) q μ = ‖c‖₊ • MeasureTheory.eLpNorm' f q μ

full_name: MeasureTheory.eLpNormEssSup_const_smul
code: theorem eLpNormEssSup_const_smul (c : 𝕜) (f : α → F) :
    eLpNormEssSup (c • f) μ = (‖c‖₊ : ℝ≥0∞) * eLpNormEssSup f μ 
goal: MeasureTheory.eLpNormEssSup (c • f) μ = ↑‖c‖₊ * MeasureTheory.eLpNormEssSup f μ

full_name: MeasureTheory.eLpNorm_const_smul
code: theorem eLpNorm_const_smul (c : 𝕜) (f : α → F) :
    eLpNorm (c • f) p μ = (‖c‖₊ : ℝ≥0∞) * eLpNorm f p μ 
goal: MeasureTheory.eLpNorm (c • f) p μ = ↑‖c‖₊ * MeasureTheory.eLpNorm f p μ

full_name: MeasureTheory.le_eLpNorm_of_bddBelow
code: theorem le_eLpNorm_of_bddBelow (hp : p ≠ 0) (hp' : p ≠ ∞) {f : α → F} (C : ℝ≥0) {s : Set α}
    (hs : MeasurableSet s) (hf : ∀ᵐ x ∂μ, x ∈ s → C ≤ ‖f x‖₊) :
    C • μ s ^ (1 / p.toReal) ≤ eLpNorm f p μ 
goal: C • μ s ^ (1 / p.toReal) ≤ MeasureTheory.eLpNorm f p μ

full_name: MeasureTheory.Memℒp.re
code: theorem Memℒp.re (hf : Memℒp f p μ) : Memℒp (fun x => RCLike.re (f x)) p μ 
goal: MeasureTheory.Memℒp (fun x => RCLike.re (f x)) p μ

full_name: MeasureTheory.Memℒp.im
code: theorem Memℒp.im (hf : Memℒp f p μ) : Memℒp (fun x => RCLike.im (f x)) p μ 
goal: MeasureTheory.Memℒp (fun x => RCLike.im (f x)) p μ

full_name: MeasureTheory.ae_bdd_liminf_atTop_rpow_of_eLpNorm_bdd
code: theorem ae_bdd_liminf_atTop_rpow_of_eLpNorm_bdd {p : ℝ≥0∞} {f : ℕ → α → E}
    (hfmeas : ∀ n, Measurable (f n)) (hbdd : ∀ n, eLpNorm (f n) p μ ≤ R) :
    ∀ᵐ x ∂μ, liminf (fun n => ((‖f n x‖₊ : ℝ≥0∞) ^ p.toReal : ℝ≥0∞)) atTop < ∞ 
goal: ∀ᵐ (x : α) ∂μ, Filter.liminf (fun n => ↑‖f n x‖₊ ^ p.toReal) Filter.atTop < ⊤

full_name: MeasureTheory.ae_bdd_liminf_atTop_of_eLpNorm_bdd
code: theorem ae_bdd_liminf_atTop_of_eLpNorm_bdd {p : ℝ≥0∞} (hp : p ≠ 0) {f : ℕ → α → E}
    (hfmeas : ∀ n, Measurable (f n)) (hbdd : ∀ n, eLpNorm (f n) p μ ≤ R) :
    ∀ᵐ x ∂μ, liminf (fun n => (‖f n x‖₊ : ℝ≥0∞)) atTop < ∞ 
goal: ∀ᵐ (x : α) ∂μ, Filter.liminf (fun n => ↑‖f n x‖₊) Filter.atTop < ⊤

full_name: Continuous.memℒp_top_of_hasCompactSupport
code: /-- A continuous function with compact support belongs to `L^∞`.
See `Continuous.memℒp_of_hasCompactSupport` for a version for `L^p`. -/
theorem _root_.Continuous.memℒp_top_of_hasCompactSupport
    {X : Type*} [TopologicalSpace X] [MeasurableSpace X] [OpensMeasurableSpace X]
    {f : X → E} (hf : Continuous f) (h'f : HasCompactSupport f) (μ : Measure X) : Memℒp f ⊤ μ 
goal: MeasureTheory.Memℒp f ⊤ μ

full_name: MeasureTheory.Memℒp.exists_eLpNorm_indicator_compl_lt
code: /-- A single function that is `Memℒp f p μ` is tight with respect to `μ`. -/
theorem Memℒp.exists_eLpNorm_indicator_compl_lt {β : Type*} [NormedAddCommGroup β] (hp_top : p ≠ ∞)
    {f : α → β} (hf : Memℒp f p μ) {ε : ℝ≥0∞} (hε : ε ≠ 0) :
    ∃ s : Set α, MeasurableSet s ∧ μ s < ∞ ∧ eLpNorm (sᶜ.indicator f) p μ < ε 
goal: ∃ s, MeasurableSet s ∧ μ s < ⊤ ∧ MeasureTheory.eLpNorm (sᶜ.indicator f) p μ < ε