File: Mathlib/MeasureTheory/Function/LpSpace.lean

full_name: MeasureTheory.eLpNorm_aeeqFun
code: @[simp]
theorem eLpNorm_aeeqFun {α E : Type*} [MeasurableSpace α] {μ : Measure α} [NormedAddCommGroup E]
    {p : ℝ≥0∞} {f : α → E} (hf : AEStronglyMeasurable f μ) :
    eLpNorm (AEEqFun.mk f hf) p μ = eLpNorm f p μ 
goal: MeasureTheory.eLpNorm (↑(MeasureTheory.AEEqFun.mk f hf)) p μ = MeasureTheory.eLpNorm f p μ

full_name: MeasureTheory.Memℒp.eLpNorm_mk_lt_top
code: theorem Memℒp.eLpNorm_mk_lt_top {α E : Type*} [MeasurableSpace α] {μ : Measure α}
    [NormedAddCommGroup E] {p : ℝ≥0∞} {f : α → E} (hfp : Memℒp f p μ) :
    eLpNorm (AEEqFun.mk f hfp.1) p μ < ∞ 
goal: MeasureTheory.eLpNorm (↑(MeasureTheory.AEEqFun.mk f ⋯)) p μ < ⊤

full_name: MeasureTheory.Lp
code: /-- Lp space -/
def Lp {α} (E : Type*) {m : MeasurableSpace α} [NormedAddCommGroup E] (p : ℝ≥0∞)
    (μ : Measure α := by volume_tac) : AddSubgroup (α →ₘ[μ] E) 
goal: AddSubgroup (α →ₘ[μ] E)

full_name: MeasureTheory._aux_Mathlib_MeasureTheory_Function_LpSpace___unexpand_MeasureTheory_Lp_1
code: scoped notation:25 α' " →₁[" μ "] " E => MeasureTheory.Lp (α := α') E 1 μ
goal: Lean.PrettyPrinter.Unexpander

full_name: MeasureTheory.«_aux_Mathlib_MeasureTheory_Function_LpSpace___macroRules_MeasureTheory_term_→₁[_]__1»
code: scoped notation:25 α' " →₁[" μ "] " E => MeasureTheory.Lp (α := α') E 1 μ
goal: Lean.Macro

full_name: MeasureTheory._aux_Mathlib_MeasureTheory_Function_LpSpace___unexpand_MeasureTheory_Lp_2
code: scoped notation:25 α' " →₂[" μ "] " E => MeasureTheory.Lp (α := α') E 2 μ
goal: Lean.PrettyPrinter.Unexpander

full_name: MeasureTheory.«_aux_Mathlib_MeasureTheory_Function_LpSpace___macroRules_MeasureTheory_term_→₂[_]__1»
code: scoped notation:25 α' " →₂[" μ "] " E => MeasureTheory.Lp (α := α') E 2 μ
goal: Lean.Macro

full_name: MeasureTheory.Memℒp.toLp
code: /-- make an element of Lp from a function verifying `Memℒp` -/
def toLp (f : α → E) (h_mem_ℒp : Memℒp f p μ) : Lp E p μ 
goal: ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Memℒp.toLp_val
code: theorem toLp_val {f : α → E} (h : Memℒp f p μ) : (toLp f h).1 = AEEqFun.mk f h.1 
goal: ↑(MeasureTheory.Memℒp.toLp f h) = MeasureTheory.AEEqFun.mk f ⋯

full_name: MeasureTheory.Memℒp.coeFn_toLp
code: theorem coeFn_toLp {f : α → E} (hf : Memℒp f p μ) : hf.toLp f =ᵐ[μ] f 
goal: ↑↑(MeasureTheory.Memℒp.toLp f hf) =ᵐ[μ] f

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

full_name: MeasureTheory.Memℒp.toLp_eq_toLp_iff
code: @[simp]
theorem toLp_eq_toLp_iff {f g : α → E} (hf : Memℒp f p μ) (hg : Memℒp g p μ) :
    hf.toLp f = hg.toLp g ↔ f =ᵐ[μ] g 
goal: MeasureTheory.Memℒp.toLp f hf = MeasureTheory.Memℒp.toLp g hg ↔ f =ᵐ[μ] g

full_name: MeasureTheory.Memℒp.toLp_zero
code: @[simp]
theorem toLp_zero (h : Memℒp (0 : α → E) p μ) : h.toLp 0 = 0 
goal: MeasureTheory.Memℒp.toLp 0 h = 0

full_name: MeasureTheory.Memℒp.toLp_add
code: theorem toLp_add {f g : α → E} (hf : Memℒp f p μ) (hg : Memℒp g p μ) :
    (hf.add hg).toLp (f + g) = hf.toLp f + hg.toLp g 
goal: MeasureTheory.Memℒp.toLp (f + g) ⋯ = MeasureTheory.Memℒp.toLp f hf + MeasureTheory.Memℒp.toLp g hg

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

full_name: MeasureTheory.Memℒp.toLp_sub
code: theorem toLp_sub {f g : α → E} (hf : Memℒp f p μ) (hg : Memℒp g p μ) :
    (hf.sub hg).toLp (f - g) = hf.toLp f - hg.toLp g 
goal: MeasureTheory.Memℒp.toLp (f - g) ⋯ = MeasureTheory.Memℒp.toLp f hf - MeasureTheory.Memℒp.toLp g hg

full_name: MeasureTheory.Lp.instCoeFun
code: instance instCoeFun : CoeFun (Lp E p μ) (fun _ => α → E) 
goal: CoeFun ↥(MeasureTheory.Lp E p μ) fun x => α → E

full_name: MeasureTheory.Lp.ext
code: @[ext high]
theorem ext {f g : Lp E p μ} (h : f =ᵐ[μ] g) : f = g 
goal: f = g

full_name: MeasureTheory.Lp.ext_iff
code: theorem ext_iff {f g : Lp E p μ} : f = g ↔ f =ᵐ[μ] g 
goal: f = g ↔ ↑↑f =ᵐ[μ] ↑↑g

full_name: MeasureTheory.Lp.mem_Lp_iff_eLpNorm_lt_top
code: theorem mem_Lp_iff_eLpNorm_lt_top {f : α →ₘ[μ] E} : f ∈ Lp E p μ ↔ eLpNorm f p μ < ∞ 
goal: f ∈ MeasureTheory.Lp E p μ ↔ MeasureTheory.eLpNorm (↑f) p μ < ⊤

full_name: MeasureTheory.Lp.mem_Lp_iff_memℒp
code: theorem mem_Lp_iff_memℒp {f : α →ₘ[μ] E} : f ∈ Lp E p μ ↔ Memℒp f p μ 
goal: f ∈ MeasureTheory.Lp E p μ ↔ MeasureTheory.Memℒp (↑f) p μ

full_name: MeasureTheory.Lp.antitone
code: protected theorem antitone [IsFiniteMeasure μ] {p q : ℝ≥0∞} (hpq : p ≤ q) : Lp E q μ ≤ Lp E p μ 
goal: MeasureTheory.Lp E q μ ≤ MeasureTheory.Lp E p μ

full_name: MeasureTheory.Lp.coeFn_mk
code: @[simp]
theorem coeFn_mk {f : α →ₘ[μ] E} (hf : eLpNorm f p μ < ∞) : ((⟨f, hf⟩ : Lp E p μ) : α → E) = f 
goal: ↑↑⟨f, hf⟩ = ↑f

full_name: MeasureTheory.Lp.coe_mk
code: theorem coe_mk {f : α →ₘ[μ] E} (hf : eLpNorm f p μ < ∞) : ((⟨f, hf⟩ : Lp E p μ) : α →ₘ[μ] E) = f 
goal: ↑⟨f, hf⟩ = f

full_name: MeasureTheory.Lp.toLp_coeFn
code: @[simp]
theorem toLp_coeFn (f : Lp E p μ) (hf : Memℒp f p μ) : hf.toLp f = f 
goal: MeasureTheory.Memℒp.toLp (↑↑f) hf = f

full_name: MeasureTheory.Lp.eLpNorm_lt_top
code: theorem eLpNorm_lt_top (f : Lp E p μ) : eLpNorm f p μ < ∞ 
goal: MeasureTheory.eLpNorm (↑↑f) p μ < ⊤

full_name: MeasureTheory.Lp.eLpNorm_ne_top
code: theorem eLpNorm_ne_top (f : Lp E p μ) : eLpNorm f p μ ≠ ∞ 
goal: MeasureTheory.eLpNorm (↑↑f) p μ ≠ ⊤

full_name: MeasureTheory.Lp.stronglyMeasurable
code: @[measurability]
protected theorem stronglyMeasurable (f : Lp E p μ) : StronglyMeasurable f 
goal: MeasureTheory.StronglyMeasurable ↑↑f

full_name: MeasureTheory.Lp.aestronglyMeasurable
code: @[measurability]
protected theorem aestronglyMeasurable (f : Lp E p μ) : AEStronglyMeasurable f μ 
goal: MeasureTheory.AEStronglyMeasurable (↑↑f) μ

full_name: MeasureTheory.Lp.memℒp
code: protected theorem memℒp (f : Lp E p μ) : Memℒp f p μ 
goal: MeasureTheory.Memℒp (↑↑f) p μ

full_name: MeasureTheory.Lp.coeFn_zero
code: theorem coeFn_zero : ⇑(0 : Lp E p μ) =ᵐ[μ] 0 
goal: ↑↑0 =ᵐ[μ] 0

full_name: MeasureTheory.Lp.coeFn_neg
code: theorem coeFn_neg (f : Lp E p μ) : ⇑(-f) =ᵐ[μ] -f 
goal: ↑↑(-f) =ᵐ[μ] -↑↑f

full_name: MeasureTheory.Lp.coeFn_add
code: theorem coeFn_add (f g : Lp E p μ) : ⇑(f + g) =ᵐ[μ] f + g 
goal: ↑↑(f + g) =ᵐ[μ] ↑↑f + ↑↑g

full_name: MeasureTheory.Lp.coeFn_sub
code: theorem coeFn_sub (f g : Lp E p μ) : ⇑(f - g) =ᵐ[μ] f - g 
goal: ↑↑(f - g) =ᵐ[μ] ↑↑f - ↑↑g

full_name: MeasureTheory.Lp.const_mem_Lp
code: theorem const_mem_Lp (α) {_ : MeasurableSpace α} (μ : Measure α) (c : E) [IsFiniteMeasure μ] :
    @AEEqFun.const α _ _ μ _ c ∈ Lp E p μ 
goal: ∀ {x : MeasurableSpace α} (μ : MeasureTheory.Measure α) (c : E) [inst : MeasureTheory.IsFiniteMeasure μ],
  MeasureTheory.AEEqFun.const α c ∈ MeasureTheory.Lp E p μ

full_name: MeasureTheory.Lp.instNorm
code: instance instNorm : Norm (Lp E p μ) 
goal: Norm ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Lp.instNNNorm
code: instance instNNNorm : NNNorm (Lp E p μ) 
goal: NNNorm ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Lp.instDist
code: instance instDist : Dist (Lp E p μ) 
goal: Dist ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Lp.instEDist
code: instance instEDist : EDist (Lp E p μ) 
goal: EDist ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Lp.norm_def
code: theorem norm_def (f : Lp E p μ) : ‖f‖ = ENNReal.toReal (eLpNorm f p μ) 
goal: ‖f‖ = (MeasureTheory.eLpNorm (↑↑f) p μ).toReal

full_name: MeasureTheory.Lp.nnnorm_def
code: theorem nnnorm_def (f : Lp E p μ) : ‖f‖₊ = ENNReal.toNNReal (eLpNorm f p μ) 
goal: ‖f‖₊ = (MeasureTheory.eLpNorm (↑↑f) p μ).toNNReal

full_name: MeasureTheory.Lp.coe_nnnorm
code: @[simp, norm_cast]
protected theorem coe_nnnorm (f : Lp E p μ) : (‖f‖₊ : ℝ) = ‖f‖ 
goal: ↑‖f‖₊ = ‖f‖

full_name: MeasureTheory.Lp.nnnorm_coe_ennreal
code: @[simp, norm_cast]
theorem nnnorm_coe_ennreal (f : Lp E p μ) : (‖f‖₊ : ℝ≥0∞) = eLpNorm f p μ 
goal: ↑‖f‖₊ = MeasureTheory.eLpNorm (↑↑f) p μ

full_name: MeasureTheory.Lp.norm_toLp
code: @[simp]
lemma norm_toLp (f : α → E) (hf : Memℒp f p μ) : ‖hf.toLp f‖ = ENNReal.toReal (eLpNorm f p μ) 
goal: ‖MeasureTheory.Memℒp.toLp f hf‖ = (MeasureTheory.eLpNorm f p μ).toReal

full_name: MeasureTheory.Lp.nnnorm_toLp
code: @[simp]
theorem nnnorm_toLp (f : α → E) (hf : Memℒp f p μ) :
    ‖hf.toLp f‖₊ = ENNReal.toNNReal (eLpNorm f p μ) 
goal: ‖MeasureTheory.Memℒp.toLp f hf‖₊ = (MeasureTheory.eLpNorm f p μ).toNNReal

full_name: MeasureTheory.Lp.coe_nnnorm_toLp
code: theorem coe_nnnorm_toLp {f : α → E} (hf : Memℒp f p μ) : (‖hf.toLp f‖₊ : ℝ≥0∞) = eLpNorm f p μ 
goal: ↑‖MeasureTheory.Memℒp.toLp f hf‖₊ = MeasureTheory.eLpNorm f p μ

full_name: MeasureTheory.Lp.dist_def
code: theorem dist_def (f g : Lp E p μ) : dist f g = (eLpNorm (⇑f - ⇑g) p μ).toReal 
goal: dist f g = (MeasureTheory.eLpNorm (↑↑f - ↑↑g) p μ).toReal

full_name: MeasureTheory.Lp.edist_def
code: theorem edist_def (f g : Lp E p μ) : edist f g = eLpNorm (⇑f - ⇑g) p μ 
goal: edist f g = MeasureTheory.eLpNorm (↑↑f - ↑↑g) p μ

full_name: MeasureTheory.Lp.edist_dist
code: protected theorem edist_dist (f g : Lp E p μ) : edist f g = .ofReal (dist f g) 
goal: edist f g = ENNReal.ofReal (dist f g)

full_name: MeasureTheory.Lp.dist_edist
code: protected theorem dist_edist (f g : Lp E p μ) : dist f g = (edist f g).toReal 
goal: dist f g = (edist f g).toReal

full_name: MeasureTheory.Lp.dist_eq_norm
code: theorem dist_eq_norm (f g : Lp E p μ) : dist f g = ‖f - g‖ 
goal: dist f g = ‖f - g‖

full_name: MeasureTheory.Lp.edist_toLp_toLp
code: @[simp]
theorem edist_toLp_toLp (f g : α → E) (hf : Memℒp f p μ) (hg : Memℒp g p μ) :
    edist (hf.toLp f) (hg.toLp g) = eLpNorm (f - g) p μ 
goal: edist (MeasureTheory.Memℒp.toLp f hf) (MeasureTheory.Memℒp.toLp g hg) = MeasureTheory.eLpNorm (f - g) p μ

full_name: MeasureTheory.Lp.edist_toLp_zero
code: @[simp]
theorem edist_toLp_zero (f : α → E) (hf : Memℒp f p μ) : edist (hf.toLp f) 0 = eLpNorm f p μ 
goal: edist (MeasureTheory.Memℒp.toLp f hf) 0 = MeasureTheory.eLpNorm f p μ

full_name: MeasureTheory.Lp.nnnorm_zero
code: @[simp]
theorem nnnorm_zero : ‖(0 : Lp E p μ)‖₊ = 0 
goal: ‖0‖₊ = 0

full_name: MeasureTheory.Lp.norm_zero
code: @[simp]
theorem norm_zero : ‖(0 : Lp E p μ)‖ = 0 
goal: ‖0‖ = 0

full_name: MeasureTheory.Lp.norm_measure_zero
code: @[simp]
theorem norm_measure_zero (f : Lp E p (0 : MeasureTheory.Measure α)) : ‖f‖ = 0 
goal: ‖f‖ = 0

full_name: MeasureTheory.Lp.norm_exponent_zero
code: @[simp] theorem norm_exponent_zero (f : Lp E 0 μ) : ‖f‖ = 0 
goal: ‖f‖ = 0

full_name: MeasureTheory.Lp.nnnorm_eq_zero_iff
code: theorem nnnorm_eq_zero_iff {f : Lp E p μ} (hp : 0 < p) : ‖f‖₊ = 0 ↔ f = 0 
goal: ‖f‖₊ = 0 ↔ f = 0

full_name: MeasureTheory.Lp.norm_eq_zero_iff
code: theorem norm_eq_zero_iff {f : Lp E p μ} (hp : 0 < p) : ‖f‖ = 0 ↔ f = 0 
goal: ‖f‖ = 0 ↔ f = 0

full_name: MeasureTheory.Lp.eq_zero_iff_ae_eq_zero
code: theorem eq_zero_iff_ae_eq_zero {f : Lp E p μ} : f = 0 ↔ f =ᵐ[μ] 0 
goal: f = 0 ↔ ↑↑f =ᵐ[μ] 0

full_name: MeasureTheory.Lp.nnnorm_neg
code: @[simp]
theorem nnnorm_neg (f : Lp E p μ) : ‖-f‖₊ = ‖f‖₊ 
goal: ‖-f‖₊ = ‖f‖₊

full_name: MeasureTheory.Lp.norm_neg
code: @[simp]
theorem norm_neg (f : Lp E p μ) : ‖-f‖ = ‖f‖ 
goal: ‖-f‖ = ‖f‖

full_name: MeasureTheory.Lp.nnnorm_le_mul_nnnorm_of_ae_le_mul
code: theorem nnnorm_le_mul_nnnorm_of_ae_le_mul {c : ℝ≥0} {f : Lp E p μ} {g : Lp F p μ}
    (h : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ c * ‖g x‖₊) : ‖f‖₊ ≤ c * ‖g‖₊ 
goal: ‖f‖₊ ≤ c * ‖g‖₊

full_name: MeasureTheory.Lp.norm_le_mul_norm_of_ae_le_mul
code: theorem norm_le_mul_norm_of_ae_le_mul {c : ℝ} {f : Lp E p μ} {g : Lp F p μ}
    (h : ∀ᵐ x ∂μ, ‖f x‖ ≤ c * ‖g x‖) : ‖f‖ ≤ c * ‖g‖ 
goal: ‖f‖ ≤ c * ‖g‖

full_name: MeasureTheory.Lp.norm_le_norm_of_ae_le
code: theorem norm_le_norm_of_ae_le {f : Lp E p μ} {g : Lp F p μ} (h : ∀ᵐ x ∂μ, ‖f x‖ ≤ ‖g x‖) :
    ‖f‖ ≤ ‖g‖ 
goal: ‖f‖ ≤ ‖g‖

full_name: MeasureTheory.Lp.mem_Lp_of_nnnorm_ae_le_mul
code: theorem mem_Lp_of_nnnorm_ae_le_mul {c : ℝ≥0} {f : α →ₘ[μ] E} {g : Lp F p μ}
    (h : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ c * ‖g x‖₊) : f ∈ Lp E p μ 
goal: f ∈ MeasureTheory.Lp E p μ

full_name: MeasureTheory.Lp.mem_Lp_of_ae_le_mul
code: theorem mem_Lp_of_ae_le_mul {c : ℝ} {f : α →ₘ[μ] E} {g : Lp F p μ}
    (h : ∀ᵐ x ∂μ, ‖f x‖ ≤ c * ‖g x‖) : f ∈ Lp E p μ 
goal: f ∈ MeasureTheory.Lp E p μ

full_name: MeasureTheory.Lp.mem_Lp_of_nnnorm_ae_le
code: theorem mem_Lp_of_nnnorm_ae_le {f : α →ₘ[μ] E} {g : Lp F p μ} (h : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ ‖g x‖₊) :
    f ∈ Lp E p μ 
goal: f ∈ MeasureTheory.Lp E p μ

full_name: MeasureTheory.Lp.mem_Lp_of_ae_le
code: theorem mem_Lp_of_ae_le {f : α →ₘ[μ] E} {g : Lp F p μ} (h : ∀ᵐ x ∂μ, ‖f x‖ ≤ ‖g x‖) :
    f ∈ Lp E p μ 
goal: f ∈ MeasureTheory.Lp E p μ

full_name: MeasureTheory.Lp.mem_Lp_of_ae_nnnorm_bound
code: theorem mem_Lp_of_ae_nnnorm_bound [IsFiniteMeasure μ] {f : α →ₘ[μ] E} (C : ℝ≥0)
    (hfC : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ C) : f ∈ Lp E p μ 
goal: f ∈ MeasureTheory.Lp E p μ

full_name: MeasureTheory.Lp.mem_Lp_of_ae_bound
code: theorem mem_Lp_of_ae_bound [IsFiniteMeasure μ] {f : α →ₘ[μ] E} (C : ℝ) (hfC : ∀ᵐ x ∂μ, ‖f x‖ ≤ C) :
    f ∈ Lp E p μ 
goal: f ∈ MeasureTheory.Lp E p μ

full_name: MeasureTheory.Lp.nnnorm_le_of_ae_bound
code: theorem nnnorm_le_of_ae_bound [IsFiniteMeasure μ] {f : Lp E p μ} {C : ℝ≥0}
    (hfC : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ C) : ‖f‖₊ ≤ measureUnivNNReal μ ^ p.toReal⁻¹ * C 
goal: ‖f‖₊ ≤ MeasureTheory.measureUnivNNReal μ ^ p.toReal⁻¹ * C

full_name: MeasureTheory.Lp.norm_le_of_ae_bound
code: theorem norm_le_of_ae_bound [IsFiniteMeasure μ] {f : Lp E p μ} {C : ℝ} (hC : 0 ≤ C)
    (hfC : ∀ᵐ x ∂μ, ‖f x‖ ≤ C) : ‖f‖ ≤ measureUnivNNReal μ ^ p.toReal⁻¹ * C 
goal: ‖f‖ ≤ ↑(MeasureTheory.measureUnivNNReal μ) ^ p.toReal⁻¹ * C

full_name: MeasureTheory.Lp.instNormedAddCommGroup
code: instance instNormedAddCommGroup [hp : Fact (1 ≤ p)] : NormedAddCommGroup (Lp E p μ) 
goal: NormedAddCommGroup ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Lp.const_smul_mem_Lp
code: theorem const_smul_mem_Lp (c : 𝕜) (f : Lp E p μ) : c • (f : α →ₘ[μ] E) ∈ Lp E p μ 
goal: c • ↑f ∈ MeasureTheory.Lp E p μ

full_name: MeasureTheory.Lp.LpSubmodule
code: /-- The `𝕜`-submodule of elements of `α →ₘ[μ] E` whose `Lp` norm is finite.  This is `Lp E p μ`,
with extra structure. -/
def LpSubmodule : Submodule 𝕜 (α →ₘ[μ] E) 
goal: Submodule 𝕜 (α →ₘ[μ] E)

full_name: MeasureTheory.Lp.coe_LpSubmodule
code: theorem coe_LpSubmodule : (LpSubmodule E p μ 𝕜).toAddSubgroup = Lp E p μ 
goal: (MeasureTheory.Lp.LpSubmodule E p μ 𝕜).toAddSubgroup = MeasureTheory.Lp E p μ

full_name: MeasureTheory.Lp.instModule
code: instance instModule : Module 𝕜 (Lp E p μ) 
goal: Module 𝕜 ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Lp.coeFn_smul
code: theorem coeFn_smul (c : 𝕜) (f : Lp E p μ) : ⇑(c • f) =ᵐ[μ] c • ⇑f 
goal: ↑↑(c • f) =ᵐ[μ] c • ↑↑f

full_name: MeasureTheory.Lp.instIsCentralScalar
code: instance instIsCentralScalar [Module 𝕜ᵐᵒᵖ E] [BoundedSMul 𝕜ᵐᵒᵖ E] [IsCentralScalar 𝕜 E] :
    IsCentralScalar 𝕜 (Lp E p μ) 
goal: IsCentralScalar 𝕜 ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Lp.instSMulCommClass
code: instance instSMulCommClass [SMulCommClass 𝕜 𝕜' E] : SMulCommClass 𝕜 𝕜' (Lp E p μ) 
goal: SMulCommClass 𝕜 𝕜' ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Lp.instIsScalarTower
code: instance instIsScalarTower [SMul 𝕜 𝕜'] [IsScalarTower 𝕜 𝕜' E] : IsScalarTower 𝕜 𝕜' (Lp E p μ) 
goal: IsScalarTower 𝕜 𝕜' ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Lp.instBoundedSMul
code: instance instBoundedSMul [Fact (1 ≤ p)] : BoundedSMul 𝕜 (Lp E p μ) 
goal: BoundedSMul 𝕜 ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Lp.instNormedSpace
code: instance instNormedSpace [Fact (1 ≤ p)] : NormedSpace 𝕜 (Lp E p μ) 
goal: NormedSpace 𝕜 ↥(MeasureTheory.Lp E p μ)

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

full_name: MeasureTheory.eLpNormEssSup_indicator_le
code: theorem eLpNormEssSup_indicator_le (s : Set α) (f : α → G) :
    eLpNormEssSup (s.indicator f) μ ≤ eLpNormEssSup f μ 
goal: MeasureTheory.eLpNormEssSup (s.indicator f) μ ≤ MeasureTheory.eLpNormEssSup f μ

full_name: MeasureTheory.eLpNormEssSup_indicator_const_le
code: theorem eLpNormEssSup_indicator_const_le (s : Set α) (c : G) :
    eLpNormEssSup (s.indicator fun _ : α => c) μ ≤ ‖c‖₊ 
goal: MeasureTheory.eLpNormEssSup (s.indicator fun x => c) μ ≤ ↑‖c‖₊

full_name: MeasureTheory.eLpNormEssSup_indicator_const_eq
code: theorem eLpNormEssSup_indicator_const_eq (s : Set α) (c : G) (hμs : μ s ≠ 0) :
    eLpNormEssSup (s.indicator fun _ : α => c) μ = ‖c‖₊ 
goal: MeasureTheory.eLpNormEssSup (s.indicator fun x => c) μ = ↑‖c‖₊

full_name: MeasureTheory.eLpNorm_indicator_le
code: theorem eLpNorm_indicator_le (f : α → E) : eLpNorm (s.indicator f) p μ ≤ eLpNorm f p μ 
goal: MeasureTheory.eLpNorm (s.indicator f) p μ ≤ MeasureTheory.eLpNorm f p μ

full_name: MeasureTheory.eLpNorm_indicator_const₀
code: lemma eLpNorm_indicator_const₀ {c : G} (hs : NullMeasurableSet s μ) (hp : p ≠ 0) (hp_top : p ≠ ∞) :
    eLpNorm (s.indicator fun _ => c) p μ = ‖c‖₊ * μ s ^ (1 / p.toReal) 
goal: MeasureTheory.eLpNorm (s.indicator fun x => c) p μ = ↑‖c‖₊ * μ s ^ (1 / p.toReal)

full_name: MeasureTheory.eLpNorm_indicator_const
code: theorem eLpNorm_indicator_const {c : G} (hs : MeasurableSet s) (hp : p ≠ 0) (hp_top : p ≠ ∞) :
    eLpNorm (s.indicator fun _ => c) p μ = ‖c‖₊ * μ s ^ (1 / p.toReal) 
goal: MeasureTheory.eLpNorm (s.indicator fun x => c) p μ = ↑‖c‖₊ * μ s ^ (1 / p.toReal)

full_name: MeasureTheory.eLpNorm_indicator_const'
code: theorem eLpNorm_indicator_const' {c : G} (hs : MeasurableSet s) (hμs : μ s ≠ 0) (hp : p ≠ 0) :
    eLpNorm (s.indicator fun _ => c) p μ = ‖c‖₊ * μ s ^ (1 / p.toReal) 
goal: MeasureTheory.eLpNorm (s.indicator fun x => c) p μ = ↑‖c‖₊ * μ s ^ (1 / p.toReal)

full_name: MeasureTheory.eLpNorm_indicator_const_le
code: theorem eLpNorm_indicator_const_le (c : G) (p : ℝ≥0∞) :
    eLpNorm (s.indicator fun _ => c) p μ ≤ ‖c‖₊ * μ s ^ (1 / p.toReal) 
goal: MeasureTheory.eLpNorm (s.indicator fun x => c) p μ ≤ ↑‖c‖₊ * μ s ^ (1 / p.toReal)

full_name: MeasureTheory.Memℒp.indicator
code: theorem Memℒp.indicator (hs : MeasurableSet s) (hf : Memℒp f p μ) : Memℒp (s.indicator f) p μ 
goal: MeasureTheory.Memℒp (s.indicator f) p μ

full_name: MeasureTheory.eLpNormEssSup_indicator_eq_eLpNormEssSup_restrict
code: theorem eLpNormEssSup_indicator_eq_eLpNormEssSup_restrict {f : α → F} (hs : MeasurableSet s) :
    eLpNormEssSup (s.indicator f) μ = eLpNormEssSup f (μ.restrict s) 
goal: MeasureTheory.eLpNormEssSup (s.indicator f) μ = MeasureTheory.eLpNormEssSup f (μ.restrict s)

full_name: MeasureTheory.eLpNorm_indicator_eq_eLpNorm_restrict
code: theorem eLpNorm_indicator_eq_eLpNorm_restrict {f : α → F} (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.memℒp_indicator_iff_restrict
code: theorem memℒp_indicator_iff_restrict (hs : MeasurableSet s) :
    Memℒp (s.indicator f) p μ ↔ Memℒp f p (μ.restrict s) 
goal: MeasureTheory.Memℒp (s.indicator f) p μ ↔ MeasureTheory.Memℒp f p (μ.restrict s)

full_name: MeasureTheory.Memℒp.memℒp_of_exponent_le_of_measure_support_ne_top
code: /-- If a function is supported on a finite-measure set and belongs to `ℒ^p`, then it belongs to
`ℒ^q` for any `q ≤ p`. -/
theorem Memℒp.memℒp_of_exponent_le_of_measure_support_ne_top
    {p q : ℝ≥0∞} {f : α → E} (hfq : Memℒp f q μ) {s : Set α} (hf : ∀ x, x ∉ s → f x = 0)
    (hs : μ s ≠ ∞) (hpq : p ≤ q) : Memℒp f p μ 
goal: MeasureTheory.Memℒp f p μ

full_name: MeasureTheory.memℒp_indicator_const
code: theorem memℒp_indicator_const (p : ℝ≥0∞) (hs : MeasurableSet s) (c : E) (hμsc : c = 0 ∨ μ s ≠ ∞) :
    Memℒp (s.indicator fun _ => c) p μ 
goal: MeasureTheory.Memℒp (s.indicator fun x => c) p μ

full_name: MeasureTheory.exists_eLpNorm_indicator_le
code: /-- The `ℒ^p` norm of the indicator of a set is uniformly small if the set itself has small measure,
for any `p < ∞`. Given here as an existential `∀ ε > 0, ∃ η > 0, ...` to avoid later
management of `ℝ≥0∞`-arithmetic. -/
theorem exists_eLpNorm_indicator_le (hp : p ≠ ∞) (c : E) {ε : ℝ≥0∞} (hε : ε ≠ 0) :
    ∃ η : ℝ≥0, 0 < η ∧ ∀ s : Set α, μ s ≤ η → eLpNorm (s.indicator fun _ => c) p μ ≤ ε 
goal: ∃ η, 0 < η ∧ ∀ (s : Set α), μ s ≤ ↑η → MeasureTheory.eLpNorm (s.indicator fun x => c) p μ ≤ ε

full_name: MeasureTheory.Memℒp.piecewise
code: protected lemma Memℒp.piecewise [DecidablePred (· ∈ s)] {g}
    (hs : MeasurableSet s) (hf : Memℒp f p (μ.restrict s)) (hg : Memℒp g p (μ.restrict sᶜ)) :
    Memℒp (s.piecewise f g) p μ 
goal: MeasureTheory.Memℒp (s.piecewise f g) p μ

full_name: HasCompactSupport.memℒp_of_bound
code: /-- A bounded measurable function with compact support is in L^p. -/
theorem _root_.HasCompactSupport.memℒp_of_bound {f : X → E} (hf : HasCompactSupport f)
    (h2f : AEStronglyMeasurable f μ) (C : ℝ) (hfC : ∀ᵐ x ∂μ, ‖f x‖ ≤ C) : Memℒp f p μ 
goal: MeasureTheory.Memℒp f p μ

full_name: Continuous.memℒp_of_hasCompactSupport
code: /-- A continuous function with compact support is in L^p. -/
theorem _root_.Continuous.memℒp_of_hasCompactSupport [OpensMeasurableSpace X]
    {f : X → E} (hf : Continuous f) (h'f : HasCompactSupport f) : Memℒp f p μ 
goal: MeasureTheory.Memℒp f p μ

full_name: MeasureTheory.indicatorConstLp
code: /-- Indicator of a set as an element of `Lp`. -/
def indicatorConstLp (p : ℝ≥0∞) (hs : MeasurableSet s) (hμs : μ s ≠ ∞) (c : E) : Lp E p μ 
goal: ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.indicatorConstLp_add
code: /-- A version of `Set.indicator_add` for `MeasureTheory.indicatorConstLp`.-/
theorem indicatorConstLp_add {c' : E} :
    indicatorConstLp p hs hμs c + indicatorConstLp p hs hμs c' =
    indicatorConstLp p hs hμs (c + c') 
goal: MeasureTheory.indicatorConstLp p hs hμs c + MeasureTheory.indicatorConstLp p hs hμs c' =
  MeasureTheory.indicatorConstLp p hs hμs (c + c')

full_name: MeasureTheory.indicatorConstLp_sub
code: /-- A version of `Set.indicator_sub` for `MeasureTheory.indicatorConstLp`.-/
theorem indicatorConstLp_sub {c' : E} :
    indicatorConstLp p hs hμs c - indicatorConstLp p hs hμs c' =
    indicatorConstLp p hs hμs (c - c') 
goal: MeasureTheory.indicatorConstLp p hs hμs c - MeasureTheory.indicatorConstLp p hs hμs c' =
  MeasureTheory.indicatorConstLp p hs hμs (c - c')

full_name: MeasureTheory.indicatorConstLp_coeFn
code: theorem indicatorConstLp_coeFn : ⇑(indicatorConstLp p hs hμs c) =ᵐ[μ] s.indicator fun _ => c 
goal: ↑↑(MeasureTheory.indicatorConstLp p hs hμs c) =ᵐ[μ] s.indicator fun x => c

full_name: MeasureTheory.indicatorConstLp_coeFn_mem
code: theorem indicatorConstLp_coeFn_mem : ∀ᵐ x : α ∂μ, x ∈ s → indicatorConstLp p hs hμs c x = c 
goal: ∀ᵐ (x : α) ∂μ, x ∈ s → ↑↑(MeasureTheory.indicatorConstLp p hs hμs c) x = c

full_name: MeasureTheory.indicatorConstLp_coeFn_nmem
code: theorem indicatorConstLp_coeFn_nmem : ∀ᵐ x : α ∂μ, x ∉ s → indicatorConstLp p hs hμs c x = 0 
goal: ∀ᵐ (x : α) ∂μ, x ∉ s → ↑↑(MeasureTheory.indicatorConstLp p hs hμs c) x = 0

full_name: MeasureTheory.norm_indicatorConstLp
code: theorem norm_indicatorConstLp (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞) :
    ‖indicatorConstLp p hs hμs c‖ = ‖c‖ * (μ s).toReal ^ (1 / p.toReal) 
goal: ‖MeasureTheory.indicatorConstLp p hs hμs c‖ = ‖c‖ * (μ s).toReal ^ (1 / p.toReal)

full_name: MeasureTheory.norm_indicatorConstLp_top
code: theorem norm_indicatorConstLp_top (hμs_ne_zero : μ s ≠ 0) :
    ‖indicatorConstLp ∞ hs hμs c‖ = ‖c‖ 
goal: ‖MeasureTheory.indicatorConstLp ⊤ hs hμs c‖ = ‖c‖

full_name: MeasureTheory.norm_indicatorConstLp'
code: theorem norm_indicatorConstLp' (hp_pos : p ≠ 0) (hμs_pos : μ s ≠ 0) :
    ‖indicatorConstLp p hs hμs c‖ = ‖c‖ * (μ s).toReal ^ (1 / p.toReal) 
goal: ‖MeasureTheory.indicatorConstLp p hs hμs c‖ = ‖c‖ * (μ s).toReal ^ (1 / p.toReal)

full_name: MeasureTheory.norm_indicatorConstLp_le
code: theorem norm_indicatorConstLp_le :
    ‖indicatorConstLp p hs hμs c‖ ≤ ‖c‖ * (μ s).toReal ^ (1 / p.toReal) 
goal: ‖MeasureTheory.indicatorConstLp p hs hμs c‖ ≤ ‖c‖ * (μ s).toReal ^ (1 / p.toReal)

full_name: MeasureTheory.nnnorm_indicatorConstLp_le
code: theorem nnnorm_indicatorConstLp_le :
    ‖indicatorConstLp p hs hμs c‖₊ ≤ ‖c‖₊ * (μ s).toNNReal ^ (1 / p.toReal) 
goal: ‖MeasureTheory.indicatorConstLp p hs hμs c‖₊ ≤ ‖c‖₊ * (μ s).toNNReal ^ (1 / p.toReal)

full_name: MeasureTheory.ennnorm_indicatorConstLp_le
code: theorem ennnorm_indicatorConstLp_le :
    (‖indicatorConstLp p hs hμs c‖₊ : ℝ≥0∞) ≤ ‖c‖₊ * (μ s) ^ (1 / p.toReal) 
goal: ↑‖MeasureTheory.indicatorConstLp p hs hμs c‖₊ ≤ ↑‖c‖₊ * μ s ^ (1 / p.toReal)

full_name: MeasureTheory.edist_indicatorConstLp_eq_nnnorm
code: theorem edist_indicatorConstLp_eq_nnnorm {t : Set α} {ht : MeasurableSet t} {hμt : μ t ≠ ∞} :
    edist (indicatorConstLp p hs hμs c) (indicatorConstLp p ht hμt c) =
      ‖indicatorConstLp p (hs.symmDiff ht) (measure_symmDiff_ne_top hμs hμt) c‖₊ 
goal: edist (MeasureTheory.indicatorConstLp p hs hμs c) (MeasureTheory.indicatorConstLp p ht hμt c) =
  ↑‖MeasureTheory.indicatorConstLp p ⋯ ⋯ c‖₊

full_name: MeasureTheory.dist_indicatorConstLp_eq_norm
code: theorem dist_indicatorConstLp_eq_norm {t : Set α} {ht : MeasurableSet t} {hμt : μ t ≠ ∞} :
    dist (indicatorConstLp p hs hμs c) (indicatorConstLp p ht hμt c) =
      ‖indicatorConstLp p (hs.symmDiff ht) (measure_symmDiff_ne_top hμs hμt) c‖ 
goal: dist (MeasureTheory.indicatorConstLp p hs hμs c) (MeasureTheory.indicatorConstLp p ht hμt c) =
  ‖MeasureTheory.indicatorConstLp p ⋯ ⋯ c‖

full_name: MeasureTheory.tendsto_indicatorConstLp_set
code: /-- A family of `indicatorConstLp` functions tends to an `indicatorConstLp`,
if the underlying sets tend to the set in the sense of the measure of the symmetric difference. -/
theorem tendsto_indicatorConstLp_set [hp₁ : Fact (1 ≤ p)] {β : Type*} {l : Filter β} {t : β → Set α}
    {ht : ∀ b, MeasurableSet (t b)} {hμt : ∀ b, μ (t b) ≠ ∞} (hp : p ≠ ∞)
    (h : Tendsto (fun b ↦ μ (t b ∆ s)) l (𝓝 0)) :
    Tendsto (fun b ↦ indicatorConstLp p (ht b) (hμt b) c) l (𝓝 (indicatorConstLp p hs hμs c)) 
goal: Filter.Tendsto (fun b => MeasureTheory.indicatorConstLp p ⋯ ⋯ c) l (𝓝 (MeasureTheory.indicatorConstLp p hs hμs c))

full_name: MeasureTheory.continuous_indicatorConstLp_set
code: /-- A family of `indicatorConstLp` functions is continuous in the parameter,
if `μ (s y ∆ s x)` tends to zero as `y` tends to `x` for all `x`. -/
theorem continuous_indicatorConstLp_set [Fact (1 ≤ p)] {X : Type*} [TopologicalSpace X]
    {s : X → Set α} {hs : ∀ x, MeasurableSet (s x)} {hμs : ∀ x, μ (s x) ≠ ∞} (hp : p ≠ ∞)
    (h : ∀ x, Tendsto (fun y ↦ μ (s y ∆ s x)) (𝓝 x) (𝓝 0)) :
    Continuous fun x ↦ indicatorConstLp p (hs x) (hμs x) c 
goal: Continuous fun x => MeasureTheory.indicatorConstLp p ⋯ ⋯ c

full_name: MeasureTheory.indicatorConstLp_empty
code: @[simp]
theorem indicatorConstLp_empty :
    indicatorConstLp p MeasurableSet.empty (by simp : μ ∅ ≠ ∞) c = 0 
goal: MeasureTheory.indicatorConstLp p ⋯ ⋯ c = 0

full_name: MeasureTheory.indicatorConstLp_inj
code: theorem indicatorConstLp_inj {s t : Set α} (hs : MeasurableSet s) (hsμ : μ s ≠ ∞)
    (ht : MeasurableSet t) (htμ : μ t ≠ ∞) {c : E} (hc : c ≠ 0) :
    indicatorConstLp p hs hsμ c = indicatorConstLp p ht htμ c ↔ s =ᵐ[μ] t 
goal: MeasureTheory.indicatorConstLp p hs hsμ c = MeasureTheory.indicatorConstLp p ht htμ c ↔ s =ᵐ[μ] t

full_name: MeasureTheory.memℒp_add_of_disjoint
code: theorem memℒp_add_of_disjoint {f g : α → E} (h : Disjoint (support f) (support g))
    (hf : StronglyMeasurable f) (hg : StronglyMeasurable g) :
    Memℒp (f + g) p μ ↔ Memℒp f p μ ∧ Memℒp g p μ 
goal: MeasureTheory.Memℒp (f + g) p μ ↔ MeasureTheory.Memℒp f p μ ∧ MeasureTheory.Memℒp g p μ

full_name: MeasureTheory.indicatorConstLp_disjoint_union
code: /-- The indicator of a disjoint union of two sets is the sum of the indicators of the sets. -/
theorem indicatorConstLp_disjoint_union {s t : Set α} (hs : MeasurableSet s) (ht : MeasurableSet t)
    (hμs : μ s ≠ ∞) (hμt : μ t ≠ ∞) (hst : s ∩ t = ∅) (c : E) :
    indicatorConstLp p (hs.union ht) (measure_union_ne_top hμs hμt) c =
      indicatorConstLp p hs hμs c + indicatorConstLp p ht hμt c 
goal: MeasureTheory.indicatorConstLp p ⋯ ⋯ c =
  MeasureTheory.indicatorConstLp p hs hμs c + MeasureTheory.indicatorConstLp p ht hμt c

full_name: MeasureTheory.Lp.const
code: /-- Constant function as an element of `MeasureTheory.Lp` for a finite measure. -/
protected def Lp.const : E →+ Lp E p μ 
goal: E →+ ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Lp.coeFn_const
code: lemma Lp.coeFn_const : Lp.const p μ c =ᵐ[μ] Function.const α c 
goal: ↑↑((MeasureTheory.Lp.const p μ) c) =ᵐ[μ] Function.const α c

full_name: MeasureTheory.Lp.const_val
code: @[simp] lemma Lp.const_val : (Lp.const p μ c).1 = AEEqFun.const α c 
goal: ↑((MeasureTheory.Lp.const p μ) c) = MeasureTheory.AEEqFun.const α c

full_name: MeasureTheory.Memℒp.toLp_const
code: @[simp]
lemma Memℒp.toLp_const : Memℒp.toLp _ (memℒp_const c) = Lp.const p μ c 
goal: MeasureTheory.Memℒp.toLp (fun x => c) ⋯ = (MeasureTheory.Lp.const p μ) c

full_name: MeasureTheory.indicatorConstLp_univ
code: @[simp]
lemma indicatorConstLp_univ :
    indicatorConstLp p .univ (measure_ne_top μ _) c = Lp.const p μ c 
goal: MeasureTheory.indicatorConstLp p ⋯ ⋯ c = (MeasureTheory.Lp.const p μ) c

full_name: MeasureTheory.Lp.norm_const
code: theorem Lp.norm_const [NeZero μ] (hp_zero : p ≠ 0) :
    ‖Lp.const p μ c‖ = ‖c‖ * (μ Set.univ).toReal ^ (1 / p.toReal) 
goal: ‖(MeasureTheory.Lp.const p μ) c‖ = ‖c‖ * (μ Set.univ).toReal ^ (1 / p.toReal)

full_name: MeasureTheory.Lp.norm_const'
code: theorem Lp.norm_const' (hp_zero : p ≠ 0) (hp_top : p ≠ ∞) :
    ‖Lp.const p μ c‖ = ‖c‖ * (μ Set.univ).toReal ^ (1 / p.toReal) 
goal: ‖(MeasureTheory.Lp.const p μ) c‖ = ‖c‖ * (μ Set.univ).toReal ^ (1 / p.toReal)

full_name: MeasureTheory.Lp.norm_const_le
code: theorem Lp.norm_const_le : ‖Lp.const p μ c‖ ≤ ‖c‖ * (μ Set.univ).toReal ^ (1 / p.toReal) 
goal: ‖(MeasureTheory.Lp.const p μ) c‖ ≤ ‖c‖ * (μ Set.univ).toReal ^ (1 / p.toReal)

full_name: MeasureTheory.Lp.constₗ_apply
code: /-- `MeasureTheory.Lp.const` as a `LinearMap`. -/
@[simps] protected def Lp.constₗ (𝕜 : Type*) [NormedRing 𝕜] [Module 𝕜 E] [BoundedSMul 𝕜 E] :
    E →ₗ[𝕜] Lp E p μ 
goal: (MeasureTheory.Lp.constₗ p μ 𝕜) a = (MeasureTheory.Lp.const p μ) a

full_name: MeasureTheory.Lp.constₗ
code: /-- `MeasureTheory.Lp.const` as a `LinearMap`. -/
@[simps] protected def Lp.constₗ (𝕜 : Type*) [NormedRing 𝕜] [Module 𝕜 E] [BoundedSMul 𝕜 E] :
    E →ₗ[𝕜] Lp E p μ 
goal: E →ₗ[𝕜] ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Lp.constL
code: @[simps! apply]
protected def Lp.constL (𝕜 : Type*) [NormedField 𝕜] [NormedSpace 𝕜 E] [Fact (1 ≤ p)] :
    E →L[𝕜] Lp E p μ 
goal: E →L[𝕜] ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Lp.constL_apply
code: @[simps! apply]
protected def Lp.constL (𝕜 : Type*) [NormedField 𝕜] [NormedSpace 𝕜 E] [Fact (1 ≤ p)] :
    E →L[𝕜] Lp E p μ 
goal: (MeasureTheory.Lp.constL p μ 𝕜) a = (MeasureTheory.Lp.const p μ) a

full_name: MeasureTheory.Lp.norm_constL_le
code: theorem Lp.norm_constL_le (𝕜 : Type*) [NontriviallyNormedField 𝕜] [NormedSpace 𝕜 E]
    [Fact (1 ≤ p)] :
    ‖(Lp.constL p μ 𝕜 : E →L[𝕜] Lp E p μ)‖ ≤ (μ Set.univ).toReal ^ (1 / p.toReal) 
goal: ‖MeasureTheory.Lp.constL p μ 𝕜‖ ≤ (μ Set.univ).toReal ^ (1 / p.toReal)

full_name: MeasureTheory.Memℒp.norm_rpow_div
code: theorem Memℒp.norm_rpow_div {f : α → E} (hf : Memℒp f p μ) (q : ℝ≥0∞) :
    Memℒp (fun x : α => ‖f x‖ ^ q.toReal) (p / q) μ 
goal: MeasureTheory.Memℒp (fun x => ‖f x‖ ^ q.toReal) (p / q) μ

full_name: MeasureTheory.memℒp_norm_rpow_iff
code: theorem memℒp_norm_rpow_iff {q : ℝ≥0∞} {f : α → E} (hf : AEStronglyMeasurable f μ) (q_zero : q ≠ 0)
    (q_top : q ≠ ∞) : Memℒp (fun x : α => ‖f x‖ ^ q.toReal) (p / q) μ ↔ Memℒp f p μ 
goal: MeasureTheory.Memℒp (fun x => ‖f x‖ ^ q.toReal) (p / q) μ ↔ MeasureTheory.Memℒp f p μ

full_name: MeasureTheory.Memℒp.norm_rpow
code: theorem Memℒp.norm_rpow {f : α → E} (hf : Memℒp f p μ) (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞) :
    Memℒp (fun x : α => ‖f x‖ ^ p.toReal) 1 μ 
goal: MeasureTheory.Memℒp (fun x => ‖f x‖ ^ p.toReal) 1 μ

full_name: MeasureTheory.AEEqFun.compMeasurePreserving_mem_Lp
code: theorem AEEqFun.compMeasurePreserving_mem_Lp {β : Type*} [MeasurableSpace β]
    {μb : MeasureTheory.Measure β} {g : β →ₘ[μb] E} (hg : g ∈ Lp E p μb) {f : α → β}
    (hf : MeasurePreserving f μ μb) :
    g.compMeasurePreserving f hf ∈ Lp E p μ 
goal: g.compMeasurePreserving f hf ∈ MeasureTheory.Lp E p μ

full_name: MeasureTheory.Lp.compMeasurePreserving
code: /-- Composition of an `L^p` function with a measure preserving function is an `L^p` function. -/
def compMeasurePreserving (f : α → β) (hf : MeasurePreserving f μ μb) :
    Lp E p μb →+ Lp E p μ 
goal: ↥(MeasureTheory.Lp E p μb) →+ ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Lp.compMeasurePreserving_val
code: @[simp]
theorem compMeasurePreserving_val (g : Lp E p μb) (hf : MeasurePreserving f μ μb) :
    (compMeasurePreserving f hf g).1 = g.1.compMeasurePreserving f hf 
goal: ↑((MeasureTheory.Lp.compMeasurePreserving f hf) g) = (↑g).compMeasurePreserving f hf

full_name: MeasureTheory.Lp.coeFn_compMeasurePreserving
code: theorem coeFn_compMeasurePreserving (g : Lp E p μb) (hf : MeasurePreserving f μ μb) :
    compMeasurePreserving f hf g =ᵐ[μ] g ∘ f 
goal: ↑↑((MeasureTheory.Lp.compMeasurePreserving f hf) g) =ᵐ[μ] ↑↑g ∘ f

full_name: MeasureTheory.Lp.norm_compMeasurePreserving
code: @[simp]
theorem norm_compMeasurePreserving (g : Lp E p μb) (hf : MeasurePreserving f μ μb) :
    ‖compMeasurePreserving f hf g‖ = ‖g‖ 
goal: ‖(MeasureTheory.Lp.compMeasurePreserving f hf) g‖ = ‖g‖

full_name: MeasureTheory.Lp.isometry_compMeasurePreserving
code: theorem isometry_compMeasurePreserving [Fact (1 ≤ p)] (hf : MeasurePreserving f μ μb) :
    Isometry (compMeasurePreserving f hf : Lp E p μb → Lp E p μ) 
goal: Isometry ⇑(MeasureTheory.Lp.compMeasurePreserving f hf)

full_name: MeasureTheory.Lp.toLp_compMeasurePreserving
code: theorem toLp_compMeasurePreserving {g : β → E} (hg : Memℒp g p μb) (hf : MeasurePreserving f μ μb) :
    compMeasurePreserving f hf (hg.toLp g) = (hg.comp_measurePreserving hf).toLp _ 
goal: (MeasureTheory.Lp.compMeasurePreserving f hf) (MeasureTheory.Memℒp.toLp g hg) = MeasureTheory.Memℒp.toLp (g ∘ f) ⋯

full_name: MeasureTheory.Lp.indicatorConstLp_compMeasurePreserving
code: theorem indicatorConstLp_compMeasurePreserving {s : Set β} (hs : MeasurableSet s)
    (hμs : μb s ≠ ∞) (c : E) (hf : MeasurePreserving f μ μb) :
    Lp.compMeasurePreserving f hf (indicatorConstLp p hs hμs c) =
      indicatorConstLp p (hs.preimage hf.measurable)
        (by rwa [hf.measure_preimage hs.nullMeasurableSet]) c 
goal: (MeasureTheory.Lp.compMeasurePreserving f hf) (MeasureTheory.indicatorConstLp p hs hμs c) =
  MeasureTheory.indicatorConstLp p ⋯ ⋯ c

full_name: MeasureTheory.Lp.compMeasurePreservingₗ_apply
code: /-- `MeasureTheory.Lp.compMeasurePreserving` as a linear map. -/
@[simps]
def compMeasurePreservingₗ (f : α → β) (hf : MeasurePreserving f μ μb) :
    Lp E p μb →ₗ[𝕜] Lp E p μ 
goal: ∀ (a : ↥(MeasureTheory.Lp E p μb)),
  (MeasureTheory.Lp.compMeasurePreservingₗ 𝕜 f hf) a = (↑(MeasureTheory.Lp.compMeasurePreserving f hf)).toFun a

full_name: MeasureTheory.Lp.compMeasurePreservingₗ
code: /-- `MeasureTheory.Lp.compMeasurePreserving` as a linear map. -/
@[simps]
def compMeasurePreservingₗ (f : α → β) (hf : MeasurePreserving f μ μb) :
    Lp E p μb →ₗ[𝕜] Lp E p μ 
goal: ↥(MeasureTheory.Lp E p μb) →ₗ[𝕜] ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Lp.compMeasurePreservingₗᵢ_apply_coe
code: /-- `MeasureTheory.Lp.compMeasurePreserving` as a linear isometry. -/
@[simps!]
def compMeasurePreservingₗᵢ [Fact (1 ≤ p)] (f : α → β) (hf : MeasurePreserving f μ μb) :
    Lp E p μb →ₗᵢ[𝕜] Lp E p μ 
goal: ∀ (a : ↥(MeasureTheory.Lp E p μb)),
  ↑((MeasureTheory.Lp.compMeasurePreservingₗᵢ 𝕜 f hf) a) = (↑a).compMeasurePreserving f hf

full_name: MeasureTheory.Lp.compMeasurePreservingₗᵢ_toFun_coe
code: /-- `MeasureTheory.Lp.compMeasurePreserving` as a linear isometry. -/
@[simps!]
def compMeasurePreservingₗᵢ [Fact (1 ≤ p)] (f : α → β) (hf : MeasurePreserving f μ μb) :
    Lp E p μb →ₗᵢ[𝕜] Lp E p μ 
goal: ∀ (a : ↥(MeasureTheory.Lp E p μb)),
  ↑((MeasureTheory.Lp.compMeasurePreservingₗᵢ 𝕜 f hf) a) = (↑a).compMeasurePreserving f hf

full_name: MeasureTheory.Lp.compMeasurePreservingₗᵢ
code: /-- `MeasureTheory.Lp.compMeasurePreserving` as a linear isometry. -/
@[simps!]
def compMeasurePreservingₗᵢ [Fact (1 ≤ p)] (f : α → β) (hf : MeasurePreserving f μ μb) :
    Lp E p μb →ₗᵢ[𝕜] Lp E p μ 
goal: ↥(MeasureTheory.Lp E p μb) →ₗᵢ[𝕜] ↥(MeasureTheory.Lp E p μ)

full_name: LipschitzWith.comp_memℒp
code: theorem LipschitzWith.comp_memℒp {α E F} {K} [MeasurableSpace α] {μ : Measure α}
    [NormedAddCommGroup E] [NormedAddCommGroup F] {f : α → E} {g : E → F} (hg : LipschitzWith K g)
    (g0 : g 0 = 0) (hL : Memℒp f p μ) : Memℒp (g ∘ f) p μ 
goal: MeasureTheory.Memℒp (g ∘ f) p μ

full_name: MeasureTheory.Memℒp.of_comp_antilipschitzWith
code: theorem MeasureTheory.Memℒp.of_comp_antilipschitzWith {α E F} {K'} [MeasurableSpace α]
    {μ : Measure α} [NormedAddCommGroup E] [NormedAddCommGroup F] {f : α → E} {g : E → F}
    (hL : Memℒp (g ∘ f) p μ) (hg : UniformContinuous g) (hg' : AntilipschitzWith K' g)
    (g0 : g 0 = 0) : Memℒp f p μ 
goal: MeasureTheory.Memℒp f p μ

full_name: LipschitzWith.memℒp_comp_iff_of_antilipschitz
code: theorem memℒp_comp_iff_of_antilipschitz {α E F} {K K'} [MeasurableSpace α] {μ : Measure α}
    [NormedAddCommGroup E] [NormedAddCommGroup F] {f : α → E} {g : E → F} (hg : LipschitzWith K g)
    (hg' : AntilipschitzWith K' g) (g0 : g 0 = 0) : Memℒp (g ∘ f) p μ ↔ Memℒp f p μ 
goal: MeasureTheory.Memℒp (g ∘ f) p μ ↔ MeasureTheory.Memℒp f p μ

full_name: LipschitzWith.compLp
code: /-- When `g` is a Lipschitz function sending `0` to `0` and `f` is in `Lp`, then `g ∘ f` is well
defined as an element of `Lp`. -/
def compLp (hg : LipschitzWith c g) (g0 : g 0 = 0) (f : Lp E p μ) : Lp F p μ 
goal: ↥(MeasureTheory.Lp F p μ)

full_name: LipschitzWith.coeFn_compLp
code: theorem coeFn_compLp (hg : LipschitzWith c g) (g0 : g 0 = 0) (f : Lp E p μ) :
    hg.compLp g0 f =ᵐ[μ] g ∘ f 
goal: ↑↑(hg.compLp g0 f) =ᵐ[μ] g ∘ ↑↑f

full_name: LipschitzWith.compLp_zero
code: @[simp]
theorem compLp_zero (hg : LipschitzWith c g) (g0 : g 0 = 0) : hg.compLp g0 (0 : Lp E p μ) = 0 
goal: hg.compLp g0 0 = 0

full_name: LipschitzWith.norm_compLp_sub_le
code: theorem norm_compLp_sub_le (hg : LipschitzWith c g) (g0 : g 0 = 0) (f f' : Lp E p μ) :
    ‖hg.compLp g0 f - hg.compLp g0 f'‖ ≤ c * ‖f - f'‖ 
goal: ‖hg.compLp g0 f - hg.compLp g0 f'‖ ≤ ↑c * ‖f - f'‖

full_name: LipschitzWith.norm_compLp_le
code: theorem norm_compLp_le (hg : LipschitzWith c g) (g0 : g 0 = 0) (f : Lp E p μ) :
    ‖hg.compLp g0 f‖ ≤ c * ‖f‖ 
goal: ‖hg.compLp g0 f‖ ≤ ↑c * ‖f‖

full_name: LipschitzWith.lipschitzWith_compLp
code: theorem lipschitzWith_compLp [Fact (1 ≤ p)] (hg : LipschitzWith c g) (g0 : g 0 = 0) :
    LipschitzWith c (hg.compLp g0 : Lp E p μ → Lp F p μ) 
goal: LipschitzWith c (hg.compLp g0)

full_name: LipschitzWith.continuous_compLp
code: theorem continuous_compLp [Fact (1 ≤ p)] (hg : LipschitzWith c g) (g0 : g 0 = 0) :
    Continuous (hg.compLp g0 : Lp E p μ → Lp F p μ) 
goal: Continuous (hg.compLp g0)

full_name: ContinuousLinearMap.compLp
code: /-- Composing `f : Lp` with `L : E →L[𝕜] F`. -/
def compLp (L : E →L[𝕜] F) (f : Lp E p μ) : Lp F p μ 
goal: ↥(MeasureTheory.Lp F p μ)

full_name: ContinuousLinearMap.coeFn_compLp
code: theorem coeFn_compLp (L : E →L[𝕜] F) (f : Lp E p μ) : ∀ᵐ a ∂μ, (L.compLp f) a = L (f a) 
goal: ∀ᵐ (a : α) ∂μ, ↑↑(L.compLp f) a = L (↑↑f a)

full_name: ContinuousLinearMap.coeFn_compLp'
code: theorem coeFn_compLp' (L : E →L[𝕜] F) (f : Lp E p μ) : L.compLp f =ᵐ[μ] fun a => L (f a) 
goal: ↑↑(L.compLp f) =ᵐ[μ] fun a => L (↑↑f a)

full_name: ContinuousLinearMap.comp_memℒp
code: theorem comp_memℒp (L : E →L[𝕜] F) (f : Lp E p μ) : Memℒp (L ∘ f) p μ 
goal: MeasureTheory.Memℒp (⇑L ∘ ↑↑f) p μ

full_name: ContinuousLinearMap.comp_memℒp'
code: theorem comp_memℒp' (L : E →L[𝕜] F) {f : α → E} (hf : Memℒp f p μ) : Memℒp (L ∘ f) p μ 
goal: MeasureTheory.Memℒp (⇑L ∘ f) p μ

full_name: MeasureTheory.Memℒp.ofReal
code: theorem _root_.MeasureTheory.Memℒp.ofReal {f : α → ℝ} (hf : Memℒp f p μ) :
    Memℒp (fun x => (f x : K)) p μ 
goal: MeasureTheory.Memℒp (fun x => ↑(f x)) p μ

full_name: MeasureTheory.memℒp_re_im_iff
code: theorem _root_.MeasureTheory.memℒp_re_im_iff {f : α → K} :
    Memℒp (fun x ↦ RCLike.re (f x)) p μ ∧ Memℒp (fun x ↦ RCLike.im (f x)) p μ ↔
      Memℒp f p μ 
goal: MeasureTheory.Memℒp (fun x => RCLike.re (f x)) p μ ∧ MeasureTheory.Memℒp (fun x => RCLike.im (f x)) p μ ↔
  MeasureTheory.Memℒp f p μ

full_name: ContinuousLinearMap.add_compLp
code: theorem add_compLp (L L' : E →L[𝕜] F) (f : Lp E p μ) :
    (L + L').compLp f = L.compLp f + L'.compLp f 
goal: (L + L').compLp f = L.compLp f + L'.compLp f

full_name: ContinuousLinearMap.smul_compLp
code: theorem smul_compLp {𝕜'} [NormedRing 𝕜'] [Module 𝕜' F] [BoundedSMul 𝕜' F] [SMulCommClass 𝕜 𝕜' F]
    (c : 𝕜') (L : E →L[𝕜] F) (f : Lp E p μ) : (c • L).compLp f = c • L.compLp f 
goal: (c • L).compLp f = c • L.compLp f

full_name: ContinuousLinearMap.norm_compLp_le
code: theorem norm_compLp_le (L : E →L[𝕜] F) (f : Lp E p μ) : ‖L.compLp f‖ ≤ ‖L‖ * ‖f‖ 
goal: ‖L.compLp f‖ ≤ ‖L‖ * ‖f‖

full_name: ContinuousLinearMap.compLpₗ
code: /-- Composing `f : Lp E p μ` with `L : E →L[𝕜] F`, seen as a `𝕜`-linear map on `Lp E p μ`. -/
def compLpₗ (L : E →L[𝕜] F) : Lp E p μ →ₗ[𝕜] Lp F p μ 
goal: ↥(MeasureTheory.Lp E p μ) →ₗ[𝕜] ↥(MeasureTheory.Lp F p μ)

full_name: ContinuousLinearMap.compLpL
code: /-- Composing `f : Lp E p μ` with `L : E →L[𝕜] F`, seen as a continuous `𝕜`-linear map on
`Lp E p μ`. See also the similar
* `LinearMap.compLeft` for functions,
* `ContinuousLinearMap.compLeftContinuous` for continuous functions,
* `ContinuousLinearMap.compLeftContinuousBounded` for bounded continuous functions,
* `ContinuousLinearMap.compLeftContinuousCompact` for continuous functions on compact spaces.
-/
def compLpL [Fact (1 ≤ p)] (L : E →L[𝕜] F) : Lp E p μ →L[𝕜] Lp F p μ 
goal: ↥(MeasureTheory.Lp E p μ) →L[𝕜] ↥(MeasureTheory.Lp F p μ)

full_name: ContinuousLinearMap.coeFn_compLpL
code: theorem coeFn_compLpL [Fact (1 ≤ p)] (L : E →L[𝕜] F) (f : Lp E p μ) :
    L.compLpL p μ f =ᵐ[μ] fun a => L (f a) 
goal: ↑↑((ContinuousLinearMap.compLpL p μ L) f) =ᵐ[μ] fun a => L (↑↑f a)

full_name: ContinuousLinearMap.add_compLpL
code: theorem add_compLpL [Fact (1 ≤ p)] (L L' : E →L[𝕜] F) :
    (L + L').compLpL p μ = L.compLpL p μ + L'.compLpL p μ 
goal: ContinuousLinearMap.compLpL p μ (L + L') = ContinuousLinearMap.compLpL p μ L + ContinuousLinearMap.compLpL p μ L'

full_name: ContinuousLinearMap.smul_compLpL
code: theorem smul_compLpL [Fact (1 ≤ p)] {𝕜'} [NormedRing 𝕜'] [Module 𝕜' F] [BoundedSMul 𝕜' F]
    [SMulCommClass 𝕜 𝕜' F] (c : 𝕜') (L : E →L[𝕜] F) : (c • L).compLpL p μ = c • L.compLpL p μ 
goal: ContinuousLinearMap.compLpL p μ (c • L) = c • ContinuousLinearMap.compLpL p μ L

full_name: ContinuousLinearMap.norm_compLpL_le
code: theorem norm_compLpL_le [Fact (1 ≤ p)] (L : E →L[𝕜] F) : ‖L.compLpL p μ‖ ≤ ‖L‖ 
goal: ‖ContinuousLinearMap.compLpL p μ L‖ ≤ ‖L‖

full_name: MeasureTheory.indicatorConstLp_eq_toSpanSingleton_compLp
code: theorem indicatorConstLp_eq_toSpanSingleton_compLp {s : Set α} [NormedSpace ℝ F]
    (hs : MeasurableSet s) (hμs : μ s ≠ ∞) (x : F) :
    indicatorConstLp 2 hs hμs x =
      (ContinuousLinearMap.toSpanSingleton ℝ x).compLp (indicatorConstLp 2 hs hμs (1 : ℝ)) 
goal: MeasureTheory.indicatorConstLp 2 hs hμs x =
  (ContinuousLinearMap.toSpanSingleton ℝ x).compLp (MeasureTheory.indicatorConstLp 2 hs hμs 1)

full_name: MeasureTheory.Lp.lipschitzWith_pos_part
code: theorem lipschitzWith_pos_part : LipschitzWith 1 fun x : ℝ => max x 0 
goal: LipschitzWith 1 fun x => max x 0

full_name: MeasureTheory.Memℒp.pos_part
code: theorem _root_.MeasureTheory.Memℒp.pos_part {f : α → ℝ} (hf : Memℒp f p μ) :
    Memℒp (fun x => max (f x) 0) p μ 
goal: MeasureTheory.Memℒp (fun x => max (f x) 0) p μ

full_name: MeasureTheory.Memℒp.neg_part
code: theorem _root_.MeasureTheory.Memℒp.neg_part {f : α → ℝ} (hf : Memℒp f p μ) :
    Memℒp (fun x => max (-f x) 0) p μ 
goal: MeasureTheory.Memℒp (fun x => max (-f x) 0) p μ

full_name: MeasureTheory.Lp.posPart
code: /-- Positive part of a function in `L^p`. -/
def posPart (f : Lp ℝ p μ) : Lp ℝ p μ 
goal: ↥(MeasureTheory.Lp ℝ p μ)

full_name: MeasureTheory.Lp.negPart
code: /-- Negative part of a function in `L^p`. -/
def negPart (f : Lp ℝ p μ) : Lp ℝ p μ 
goal: ↥(MeasureTheory.Lp ℝ p μ)

full_name: MeasureTheory.Lp.coe_posPart
code: @[norm_cast]
theorem coe_posPart (f : Lp ℝ p μ) : (posPart f : α →ₘ[μ] ℝ) = (f : α →ₘ[μ] ℝ).posPart 
goal: ↑(MeasureTheory.Lp.posPart f) = (↑f).posPart

full_name: MeasureTheory.Lp.coeFn_posPart
code: theorem coeFn_posPart (f : Lp ℝ p μ) : ⇑(posPart f) =ᵐ[μ] fun a => max (f a) 0 
goal: ↑↑(MeasureTheory.Lp.posPart f) =ᵐ[μ] fun a => max (↑↑f a) 0

full_name: MeasureTheory.Lp.coeFn_negPart_eq_max
code: theorem coeFn_negPart_eq_max (f : Lp ℝ p μ) : ∀ᵐ a ∂μ, negPart f a = max (-f a) 0 
goal: ∀ᵐ (a : α) ∂μ, ↑↑(MeasureTheory.Lp.negPart f) a = max (-↑↑f a) 0

full_name: MeasureTheory.Lp.coeFn_negPart
code: theorem coeFn_negPart (f : Lp ℝ p μ) : ∀ᵐ a ∂μ, negPart f a = -min (f a) 0 
goal: ∀ᵐ (a : α) ∂μ, ↑↑(MeasureTheory.Lp.negPart f) a = -min (↑↑f a) 0

full_name: MeasureTheory.Lp.continuous_posPart
code: theorem continuous_posPart [Fact (1 ≤ p)] : Continuous fun f : Lp ℝ p μ => posPart f 
goal: Continuous fun f => MeasureTheory.Lp.posPart f

full_name: MeasureTheory.Lp.continuous_negPart
code: theorem continuous_negPart [Fact (1 ≤ p)] : Continuous fun f : Lp ℝ p μ => negPart f 
goal: Continuous fun f => MeasureTheory.Lp.negPart f

full_name: MeasureTheory.Lp.eLpNorm'_lim_eq_lintegral_liminf
code: theorem eLpNorm'_lim_eq_lintegral_liminf {ι} [Nonempty ι] [LinearOrder ι] {f : ι → α → G} {p : ℝ}
    (hp_nonneg : 0 ≤ p) {f_lim : α → G}
    (h_lim : ∀ᵐ x : α ∂μ, Tendsto (fun n => f n x) atTop (𝓝 (f_lim x))) :
    eLpNorm' f_lim p μ = (∫⁻ a, atTop.liminf fun m => (‖f m a‖₊ : ℝ≥0∞) ^ p ∂μ) ^ (1 / p) 
goal: MeasureTheory.eLpNorm' f_lim p μ = (∫⁻ (a : α), Filter.liminf (fun m => ↑‖f m a‖₊ ^ p) Filter.atTop ∂μ) ^ (1 / p)

full_name: MeasureTheory.Lp.eLpNorm'_lim_le_liminf_eLpNorm'
code: theorem eLpNorm'_lim_le_liminf_eLpNorm' {E} [NormedAddCommGroup E] {f : ℕ → α → E} {p : ℝ}
    (hp_pos : 0 < p) (hf : ∀ n, AEStronglyMeasurable (f n) μ) {f_lim : α → E}
    (h_lim : ∀ᵐ x : α ∂μ, Tendsto (fun n => f n x) atTop (𝓝 (f_lim x))) :
    eLpNorm' f_lim p μ ≤ atTop.liminf fun n => eLpNorm' (f n) p μ 
goal: MeasureTheory.eLpNorm' f_lim p μ ≤ Filter.liminf (fun n => MeasureTheory.eLpNorm' (f n) p μ) Filter.atTop

full_name: MeasureTheory.Lp.eLpNorm_exponent_top_lim_eq_essSup_liminf
code: theorem eLpNorm_exponent_top_lim_eq_essSup_liminf {ι} [Nonempty ι] [LinearOrder ι] {f : ι → α → G}
    {f_lim : α → G} (h_lim : ∀ᵐ x : α ∂μ, Tendsto (fun n => f n x) atTop (𝓝 (f_lim x))) :
    eLpNorm f_lim ∞ μ = essSup (fun x => atTop.liminf fun m => (‖f m x‖₊ : ℝ≥0∞)) μ 
goal: MeasureTheory.eLpNorm f_lim ⊤ μ = essSup (fun x => Filter.liminf (fun m => ↑‖f m x‖₊) Filter.atTop) μ

full_name: MeasureTheory.Lp.eLpNorm_exponent_top_lim_le_liminf_eLpNorm_exponent_top
code: theorem eLpNorm_exponent_top_lim_le_liminf_eLpNorm_exponent_top {ι} [Nonempty ι] [Countable ι]
    [LinearOrder ι] {f : ι → α → F} {f_lim : α → F}
    (h_lim : ∀ᵐ x : α ∂μ, Tendsto (fun n => f n x) atTop (𝓝 (f_lim x))) :
    eLpNorm f_lim ∞ μ ≤ atTop.liminf fun n => eLpNorm (f n) ∞ μ 
goal: MeasureTheory.eLpNorm f_lim ⊤ μ ≤ Filter.liminf (fun n => MeasureTheory.eLpNorm (f n) ⊤ μ) Filter.atTop

full_name: MeasureTheory.Lp.eLpNorm_lim_le_liminf_eLpNorm
code: theorem eLpNorm_lim_le_liminf_eLpNorm {E} [NormedAddCommGroup E] {f : ℕ → α → E}
    (hf : ∀ n, AEStronglyMeasurable (f n) μ) (f_lim : α → E)
    (h_lim : ∀ᵐ x : α ∂μ, Tendsto (fun n => f n x) atTop (𝓝 (f_lim x))) :
    eLpNorm f_lim p μ ≤ atTop.liminf fun n => eLpNorm (f n) p μ 
goal: MeasureTheory.eLpNorm f_lim p μ ≤ Filter.liminf (fun n => MeasureTheory.eLpNorm (f n) p μ) Filter.atTop

full_name: MeasureTheory.Lp.tendsto_Lp_iff_tendsto_ℒp'
code: theorem tendsto_Lp_iff_tendsto_ℒp' {ι} {fi : Filter ι} [Fact (1 ≤ p)] (f : ι → Lp E p μ)
    (f_lim : Lp E p μ) :
    fi.Tendsto f (𝓝 f_lim) ↔ fi.Tendsto (fun n => eLpNorm (⇑(f n) - ⇑f_lim) p μ) (𝓝 0) 
goal: Filter.Tendsto f fi (𝓝 f_lim) ↔ Filter.Tendsto (fun n => MeasureTheory.eLpNorm (↑↑(f n) - ↑↑f_lim) p μ) fi (𝓝 0)

full_name: MeasureTheory.Lp.tendsto_Lp_iff_tendsto_ℒp
code: theorem tendsto_Lp_iff_tendsto_ℒp {ι} {fi : Filter ι} [Fact (1 ≤ p)] (f : ι → Lp E p μ)
    (f_lim : α → E) (f_lim_ℒp : Memℒp f_lim p μ) :
    fi.Tendsto f (𝓝 (f_lim_ℒp.toLp f_lim)) ↔
      fi.Tendsto (fun n => eLpNorm (⇑(f n) - f_lim) p μ) (𝓝 0) 
goal: Filter.Tendsto f fi (𝓝 (MeasureTheory.Memℒp.toLp f_lim f_lim_ℒp)) ↔
  Filter.Tendsto (fun n => MeasureTheory.eLpNorm (↑↑(f n) - f_lim) p μ) fi (𝓝 0)

full_name: MeasureTheory.Lp.tendsto_Lp_iff_tendsto_ℒp''
code: theorem tendsto_Lp_iff_tendsto_ℒp'' {ι} {fi : Filter ι} [Fact (1 ≤ p)] (f : ι → α → E)
    (f_ℒp : ∀ n, Memℒp (f n) p μ) (f_lim : α → E) (f_lim_ℒp : Memℒp f_lim p μ) :
    fi.Tendsto (fun n => (f_ℒp n).toLp (f n)) (𝓝 (f_lim_ℒp.toLp f_lim)) ↔
      fi.Tendsto (fun n => eLpNorm (f n - f_lim) p μ) (𝓝 0) 
goal: Filter.Tendsto (fun n => MeasureTheory.Memℒp.toLp (f n) ⋯) fi (𝓝 (MeasureTheory.Memℒp.toLp f_lim f_lim_ℒp)) ↔
  Filter.Tendsto (fun n => MeasureTheory.eLpNorm (f n - f_lim) p μ) fi (𝓝 0)

full_name: MeasureTheory.Lp.tendsto_Lp_of_tendsto_ℒp
code: theorem tendsto_Lp_of_tendsto_ℒp {ι} {fi : Filter ι} [Fact (1 ≤ p)] {f : ι → Lp E p μ}
    (f_lim : α → E) (f_lim_ℒp : Memℒp f_lim p μ)
    (h_tendsto : fi.Tendsto (fun n => eLpNorm (⇑(f n) - f_lim) p μ) (𝓝 0)) :
    fi.Tendsto f (𝓝 (f_lim_ℒp.toLp f_lim)) 
goal: Filter.Tendsto f fi (𝓝 (MeasureTheory.Memℒp.toLp f_lim f_lim_ℒp))

full_name: MeasureTheory.Lp.cauchySeq_Lp_iff_cauchySeq_ℒp
code: theorem cauchySeq_Lp_iff_cauchySeq_ℒp {ι} [Nonempty ι] [SemilatticeSup ι] [hp : Fact (1 ≤ p)]
    (f : ι → Lp E p μ) :
    CauchySeq f ↔ Tendsto (fun n : ι × ι => eLpNorm (⇑(f n.fst) - ⇑(f n.snd)) p μ) atTop (𝓝 0) 
goal: CauchySeq f ↔ Filter.Tendsto (fun n => MeasureTheory.eLpNorm (↑↑(f n.1) - ↑↑(f n.2)) p μ) Filter.atTop (𝓝 0)

full_name: MeasureTheory.Lp.completeSpace_lp_of_cauchy_complete_ℒp
code: theorem completeSpace_lp_of_cauchy_complete_ℒp [hp : Fact (1 ≤ p)]
    (H :
      ∀ (f : ℕ → α → E) (hf : ∀ n, Memℒp (f n) p μ) (B : ℕ → ℝ≥0∞) (hB : ∑' i, B i < ∞)
        (h_cau : ∀ N n m : ℕ, N ≤ n → N ≤ m → eLpNorm (f n - f m) p μ < B N),
        ∃ (f_lim : α → E), Memℒp f_lim p μ ∧
          atTop.Tendsto (fun n => eLpNorm (f n - f_lim) p μ) (𝓝 0)) :
    CompleteSpace (Lp E p μ) 
goal: CompleteSpace ↥(MeasureTheory.Lp E p μ)

full_name: _private.Mathlib.MeasureTheory.Function.LpSpace.0.MeasureTheory.Lp.eLpNorm'_sum_norm_sub_le_tsum_of_cauchy_eLpNorm'
code: private theorem eLpNorm'_sum_norm_sub_le_tsum_of_cauchy_eLpNorm' {f : ℕ → α → E}
    (hf : ∀ n, AEStronglyMeasurable (f n) μ) {p : ℝ} (hp1 : 1 ≤ p) {B : ℕ → ℝ≥0∞}
    (h_cau : ∀ N n m : ℕ, N ≤ n → N ≤ m → eLpNorm' (f n - f m) p μ < B N) (n : ℕ) :
    eLpNorm' (fun x => ∑ i ∈ Finset.range (n + 1), ‖f (i + 1) x - f i x‖) p μ ≤ ∑' i, B i 
goal: MeasureTheory.eLpNorm' (fun x => ∑ i ∈ Finset.range (n + 1), ‖f (i + 1) x - f i x‖) p μ ≤ ∑' (i : ℕ), B i

full_name: _private.Mathlib.MeasureTheory.Function.LpSpace.0.MeasureTheory.Lp.lintegral_rpow_sum_coe_nnnorm_sub_le_rpow_tsum
code: private theorem lintegral_rpow_sum_coe_nnnorm_sub_le_rpow_tsum
    {f : ℕ → α → E} {p : ℝ} (hp1 : 1 ≤ p) {B : ℕ → ℝ≥0∞} (n : ℕ)
    (hn : eLpNorm' (fun x => ∑ i ∈ Finset.range (n + 1), ‖f (i + 1) x - f i x‖) p μ ≤ ∑' i, B i) :
    (∫⁻ a, (∑ i ∈ Finset.range (n + 1), ‖f (i + 1) a - f i a‖₊ : ℝ≥0∞) ^ p ∂μ) ≤
      (∑' i, B i) ^ p 
goal: ∫⁻ (a : α), (∑ i ∈ Finset.range (n + 1), ↑‖f (i + 1) a - f i a‖₊) ^ p ∂μ ≤ (∑' (i : ℕ), B i) ^ p

full_name: _private.Mathlib.MeasureTheory.Function.LpSpace.0.MeasureTheory.Lp.lintegral_rpow_tsum_coe_nnnorm_sub_le_tsum
code: private theorem lintegral_rpow_tsum_coe_nnnorm_sub_le_tsum {f : ℕ → α → E}
    (hf : ∀ n, AEStronglyMeasurable (f n) μ) {p : ℝ} (hp1 : 1 ≤ p) {B : ℕ → ℝ≥0∞}
    (h :
      ∀ n,
        (∫⁻ a, (∑ i ∈ Finset.range (n + 1), ‖f (i + 1) a - f i a‖₊ : ℝ≥0∞) ^ p ∂μ) ≤
          (∑' i, B i) ^ p) :
    (∫⁻ a, (∑' i, ‖f (i + 1) a - f i a‖₊ : ℝ≥0∞) ^ p ∂μ) ^ (1 / p) ≤ ∑' i, B i 
goal: (∫⁻ (a : α), (∑' (i : ℕ), ↑‖f (i + 1) a - f i a‖₊) ^ p ∂μ) ^ (1 / p) ≤ ∑' (i : ℕ), B i

full_name: _private.Mathlib.MeasureTheory.Function.LpSpace.0.MeasureTheory.Lp.tsum_nnnorm_sub_ae_lt_top
code: private theorem tsum_nnnorm_sub_ae_lt_top {f : ℕ → α → E} (hf : ∀ n, AEStronglyMeasurable (f n) μ)
    {p : ℝ} (hp1 : 1 ≤ p) {B : ℕ → ℝ≥0∞} (hB : ∑' i, B i ≠ ∞)
    (h : (∫⁻ a, (∑' i, ‖f (i + 1) a - f i a‖₊ : ℝ≥0∞) ^ p ∂μ) ^ (1 / p) ≤ ∑' i, B i) :
    ∀ᵐ x ∂μ, (∑' i, ‖f (i + 1) x - f i x‖₊ : ℝ≥0∞) < ∞ 
goal: ∀ᵐ (x : α) ∂μ, ∑' (i : ℕ), ↑‖f (i + 1) x - f i x‖₊ < ⊤

full_name: MeasureTheory.Lp.ae_tendsto_of_cauchy_eLpNorm'
code: theorem ae_tendsto_of_cauchy_eLpNorm' [CompleteSpace E] {f : ℕ → α → E} {p : ℝ}
    (hf : ∀ n, AEStronglyMeasurable (f n) μ) (hp1 : 1 ≤ p) {B : ℕ → ℝ≥0∞} (hB : ∑' i, B i ≠ ∞)
    (h_cau : ∀ N n m : ℕ, N ≤ n → N ≤ m → eLpNorm' (f n - f m) p μ < B N) :
    ∀ᵐ x ∂μ, ∃ l : E, atTop.Tendsto (fun n => f n x) (𝓝 l) 
goal: ∀ᵐ (x : α) ∂μ, ∃ l, Filter.Tendsto (fun n => f n x) Filter.atTop (𝓝 l)

full_name: MeasureTheory.Lp.ae_tendsto_of_cauchy_eLpNorm
code: theorem ae_tendsto_of_cauchy_eLpNorm [CompleteSpace E] {f : ℕ → α → E}
    (hf : ∀ n, AEStronglyMeasurable (f n) μ) (hp : 1 ≤ p) {B : ℕ → ℝ≥0∞} (hB : ∑' i, B i ≠ ∞)
    (h_cau : ∀ N n m : ℕ, N ≤ n → N ≤ m → eLpNorm (f n - f m) p μ < B N) :
    ∀ᵐ x ∂μ, ∃ l : E, atTop.Tendsto (fun n => f n x) (𝓝 l) 
goal: ∀ᵐ (x : α) ∂μ, ∃ l, Filter.Tendsto (fun n => f n x) Filter.atTop (𝓝 l)

full_name: MeasureTheory.Lp.cauchy_tendsto_of_tendsto
code: theorem cauchy_tendsto_of_tendsto {f : ℕ → α → E} (hf : ∀ n, AEStronglyMeasurable (f n) μ)
    (f_lim : α → E) {B : ℕ → ℝ≥0∞} (hB : ∑' i, B i ≠ ∞)
    (h_cau : ∀ N n m : ℕ, N ≤ n → N ≤ m → eLpNorm (f n - f m) p μ < B N)
    (h_lim : ∀ᵐ x : α ∂μ, Tendsto (fun n => f n x) atTop (𝓝 (f_lim x))) :
    atTop.Tendsto (fun n => eLpNorm (f n - f_lim) p μ) (𝓝 0) 
goal: Filter.Tendsto (fun n => MeasureTheory.eLpNorm (f n - f_lim) p μ) Filter.atTop (𝓝 0)

full_name: MeasureTheory.Lp.memℒp_of_cauchy_tendsto
code: theorem memℒp_of_cauchy_tendsto (hp : 1 ≤ p) {f : ℕ → α → E} (hf : ∀ n, Memℒp (f n) p μ)
    (f_lim : α → E) (h_lim_meas : AEStronglyMeasurable f_lim μ)
    (h_tendsto : atTop.Tendsto (fun n => eLpNorm (f n - f_lim) p μ) (𝓝 0)) : Memℒp f_lim p μ 
goal: MeasureTheory.Memℒp f_lim p μ

full_name: MeasureTheory.Lp.cauchy_complete_ℒp
code: theorem cauchy_complete_ℒp [CompleteSpace E] (hp : 1 ≤ p) {f : ℕ → α → E}
    (hf : ∀ n, Memℒp (f n) p μ) {B : ℕ → ℝ≥0∞} (hB : ∑' i, B i ≠ ∞)
    (h_cau : ∀ N n m : ℕ, N ≤ n → N ≤ m → eLpNorm (f n - f m) p μ < B N) :
    ∃ (f_lim : α → E), Memℒp f_lim p μ ∧
      atTop.Tendsto (fun n => eLpNorm (f n - f_lim) p μ) (𝓝 0) 
goal: ∃ f_lim,
  MeasureTheory.Memℒp f_lim p μ ∧ Filter.Tendsto (fun n => MeasureTheory.eLpNorm (f n - f_lim) p μ) Filter.atTop (𝓝 0)

full_name: MeasureTheory.Lp.instCompleteSpace
code: instance instCompleteSpace [CompleteSpace E] [hp : Fact (1 ≤ p)] : CompleteSpace (Lp E p μ) 
goal: CompleteSpace ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Lp.boundedContinuousFunction
code: /-- An additive subgroup of `Lp E p μ`, consisting of the equivalence classes which contain a
bounded continuous representative. -/
def MeasureTheory.Lp.boundedContinuousFunction : AddSubgroup (Lp E p μ) 
goal: AddSubgroup ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Lp.mem_boundedContinuousFunction_iff
code: /-- By definition, the elements of `Lp.boundedContinuousFunction E p μ` are the elements of
`Lp E p μ` which contain a bounded continuous representative. -/
theorem MeasureTheory.Lp.mem_boundedContinuousFunction_iff {f : Lp E p μ} :
    f ∈ MeasureTheory.Lp.boundedContinuousFunction E p μ ↔
      ∃ f₀ : α →ᵇ E, f₀.toContinuousMap.toAEEqFun μ = (f : α →ₘ[μ] E) 
goal: f ∈ MeasureTheory.Lp.boundedContinuousFunction E p μ ↔ ∃ f₀, ContinuousMap.toAEEqFun μ f₀.toContinuousMap = ↑f

full_name: BoundedContinuousFunction.mem_Lp
code: /-- A bounded continuous function on a finite-measure space is in `Lp`. -/
theorem mem_Lp (f : α →ᵇ E) : f.toContinuousMap.toAEEqFun μ ∈ Lp E p μ 
goal: ContinuousMap.toAEEqFun μ f.toContinuousMap ∈ MeasureTheory.Lp E p μ

full_name: BoundedContinuousFunction.Lp_nnnorm_le
code: /-- The `Lp`-norm of a bounded continuous function is at most a constant (depending on the measure
of the whole space) times its sup-norm. -/
theorem Lp_nnnorm_le (f : α →ᵇ E) :
    ‖(⟨f.toContinuousMap.toAEEqFun μ, mem_Lp f⟩ : Lp E p μ)‖₊ ≤
      measureUnivNNReal μ ^ p.toReal⁻¹ * ‖f‖₊ 
goal: ‖⟨ContinuousMap.toAEEqFun μ f.toContinuousMap, ⋯⟩‖₊ ≤ MeasureTheory.measureUnivNNReal μ ^ p.toReal⁻¹ * ‖f‖₊

full_name: BoundedContinuousFunction.Lp_norm_le
code: /-- The `Lp`-norm of a bounded continuous function is at most a constant (depending on the measure
of the whole space) times its sup-norm. -/
theorem Lp_norm_le (f : α →ᵇ E) :
    ‖(⟨f.toContinuousMap.toAEEqFun μ, mem_Lp f⟩ : Lp E p μ)‖ ≤
      measureUnivNNReal μ ^ p.toReal⁻¹ * ‖f‖ 
goal: ‖⟨ContinuousMap.toAEEqFun μ f.toContinuousMap, ⋯⟩‖ ≤ ↑(MeasureTheory.measureUnivNNReal μ) ^ p.toReal⁻¹ * ‖f‖

full_name: BoundedContinuousFunction.toLpHom
code: /-- The normed group homomorphism of considering a bounded continuous function on a finite-measure
space as an element of `Lp`. -/
def toLpHom [Fact (1 ≤ p)] : NormedAddGroupHom (α →ᵇ E) (Lp E p μ) 
goal: NormedAddGroupHom (α →ᵇ E) ↥(MeasureTheory.Lp E p μ)

full_name: BoundedContinuousFunction.range_toLpHom
code: theorem range_toLpHom [Fact (1 ≤ p)] :
    ((toLpHom p μ).range : AddSubgroup (Lp E p μ)) =
      MeasureTheory.Lp.boundedContinuousFunction E p μ 
goal: (BoundedContinuousFunction.toLpHom p μ).range = MeasureTheory.Lp.boundedContinuousFunction E p μ

full_name: BoundedContinuousFunction.toLp
code: /-- The bounded linear map of considering a bounded continuous function on a finite-measure space
as an element of `Lp`. -/
def toLp [NormedField 𝕜] [NormedSpace 𝕜 E] : (α →ᵇ E) →L[𝕜] Lp E p μ 
goal: (α →ᵇ E) →L[𝕜] ↥(MeasureTheory.Lp E p μ)

full_name: BoundedContinuousFunction.coeFn_toLp
code: theorem coeFn_toLp [NormedField 𝕜] [NormedSpace 𝕜 E] (f : α →ᵇ E) :
    toLp (E := E) p μ 𝕜 f =ᵐ[μ] f 
goal: ↑↑((BoundedContinuousFunction.toLp p μ 𝕜) f) =ᵐ[μ] ⇑f

full_name: BoundedContinuousFunction.range_toLp
code: theorem range_toLp [NormedField 𝕜] [NormedSpace 𝕜 E] :
    (LinearMap.range (toLp p μ 𝕜 : (α →ᵇ E) →L[𝕜] Lp E p μ)).toAddSubgroup =
      MeasureTheory.Lp.boundedContinuousFunction E p μ 
goal: (LinearMap.range (BoundedContinuousFunction.toLp p μ 𝕜)).toAddSubgroup =
  MeasureTheory.Lp.boundedContinuousFunction E p μ

full_name: BoundedContinuousFunction.toLp_norm_le
code: theorem toLp_norm_le [NontriviallyNormedField 𝕜] [NormedSpace 𝕜 E] :
    ‖(toLp p μ 𝕜 : (α →ᵇ E) →L[𝕜] Lp E p μ)‖ ≤ measureUnivNNReal μ ^ p.toReal⁻¹ 
goal: ‖BoundedContinuousFunction.toLp p μ 𝕜‖ ≤ ↑(MeasureTheory.measureUnivNNReal μ) ^ p.toReal⁻¹

full_name: BoundedContinuousFunction.toLp_inj
code: theorem toLp_inj {f g : α →ᵇ E} [μ.IsOpenPosMeasure] [NormedField 𝕜] [NormedSpace 𝕜 E] :
    toLp (E := E) p μ 𝕜 f = toLp (E := E) p μ 𝕜 g ↔ f = g 
goal: (BoundedContinuousFunction.toLp p μ 𝕜) f = (BoundedContinuousFunction.toLp p μ 𝕜) g ↔ f = g

full_name: BoundedContinuousFunction.toLp_injective
code: theorem toLp_injective [μ.IsOpenPosMeasure] [NormedField 𝕜] [NormedSpace 𝕜 E] :
    Function.Injective (⇑(toLp p μ 𝕜 : (α →ᵇ E) →L[𝕜] Lp E p μ)) 
goal: Function.Injective ⇑(BoundedContinuousFunction.toLp p μ 𝕜)

full_name: ContinuousMap.toLp
code: /-- The bounded linear map of considering a continuous function on a compact finite-measure
space `α` as an element of `Lp`.  By definition, the norm on `C(α, E)` is the sup-norm, transferred
from the space `α →ᵇ E` of bounded continuous functions, so this construction is just a matter of
transferring the structure from `BoundedContinuousFunction.toLp` along the isometry. -/
def toLp [NormedField 𝕜] [NormedSpace 𝕜 E] : C(α, E) →L[𝕜] Lp E p μ 
goal: C(α, E) →L[𝕜] ↥(MeasureTheory.Lp E p μ)

full_name: ContinuousMap.range_toLp
code: theorem range_toLp [NormedField 𝕜] [NormedSpace 𝕜 E] :
    (LinearMap.range (toLp p μ 𝕜 : C(α, E) →L[𝕜] Lp E p μ)).toAddSubgroup =
      MeasureTheory.Lp.boundedContinuousFunction E p μ 
goal: (LinearMap.range (ContinuousMap.toLp p μ 𝕜)).toAddSubgroup = MeasureTheory.Lp.boundedContinuousFunction E p μ

full_name: ContinuousMap.coeFn_toLp
code: theorem coeFn_toLp [NormedField 𝕜] [NormedSpace 𝕜 E] (f : C(α, E)) :
    toLp (E := E) p μ 𝕜 f =ᵐ[μ] f 
goal: ↑↑((ContinuousMap.toLp p μ 𝕜) f) =ᵐ[μ] ⇑f

full_name: ContinuousMap.toLp_def
code: theorem toLp_def [NormedField 𝕜] [NormedSpace 𝕜 E] (f : C(α, E)) :
    toLp (E := E) p μ 𝕜 f =
      BoundedContinuousFunction.toLp (E := E) p μ 𝕜 (linearIsometryBoundedOfCompact α E 𝕜 f) 
goal: (ContinuousMap.toLp p μ 𝕜) f =
  (BoundedContinuousFunction.toLp p μ 𝕜) ((ContinuousMap.linearIsometryBoundedOfCompact α E 𝕜) f)

full_name: ContinuousMap.toLp_comp_toContinuousMap
code: @[simp]
theorem toLp_comp_toContinuousMap [NormedField 𝕜] [NormedSpace 𝕜 E] (f : α →ᵇ E) :
    toLp (E := E) p μ 𝕜 f.toContinuousMap = BoundedContinuousFunction.toLp (E := E) p μ 𝕜 f 
goal: (ContinuousMap.toLp p μ 𝕜) f.toContinuousMap = (BoundedContinuousFunction.toLp p μ 𝕜) f

full_name: ContinuousMap.coe_toLp
code: @[simp]
theorem coe_toLp [NormedField 𝕜] [NormedSpace 𝕜 E] (f : C(α, E)) :
    (toLp (E := E) p μ 𝕜 f : α →ₘ[μ] E) = f.toAEEqFun μ 
goal: ↑((ContinuousMap.toLp p μ 𝕜) f) = ContinuousMap.toAEEqFun μ f

full_name: ContinuousMap.toLp_injective
code: theorem toLp_injective [μ.IsOpenPosMeasure] [NormedField 𝕜] [NormedSpace 𝕜 E] :
    Function.Injective (⇑(toLp p μ 𝕜 : C(α, E) →L[𝕜] Lp E p μ)) 
goal: Function.Injective ⇑(ContinuousMap.toLp p μ 𝕜)

full_name: ContinuousMap.toLp_inj
code: theorem toLp_inj {f g : C(α, E)} [μ.IsOpenPosMeasure] [NormedField 𝕜] [NormedSpace 𝕜 E] :
    toLp (E := E) p μ 𝕜 f = toLp (E := E) p μ 𝕜 g ↔ f = g 
goal: (ContinuousMap.toLp p μ 𝕜) f = (ContinuousMap.toLp p μ 𝕜) g ↔ f = g

full_name: ContinuousMap.hasSum_of_hasSum_Lp
code: /-- If a sum of continuous functions `g n` is convergent, and the same sum converges in `Lᵖ` to `h`,
then in fact `g n` converges uniformly to `h`.  -/
theorem hasSum_of_hasSum_Lp {β : Type*} [μ.IsOpenPosMeasure] [NormedField 𝕜] [NormedSpace 𝕜 E]
    {g : β → C(α, E)} {f : C(α, E)} (hg : Summable g)
    (hg2 : HasSum (toLp (E := E) p μ 𝕜 ∘ g) (toLp (E := E) p μ 𝕜 f)) : HasSum g f 
goal: HasSum g f

full_name: ContinuousMap.toLp_norm_eq_toLp_norm_coe
code: theorem toLp_norm_eq_toLp_norm_coe :
    ‖(toLp p μ 𝕜 : C(α, E) →L[𝕜] Lp E p μ)‖ =
      ‖(BoundedContinuousFunction.toLp p μ 𝕜 : (α →ᵇ E) →L[𝕜] Lp E p μ)‖ 
goal: ‖ContinuousMap.toLp p μ 𝕜‖ = ‖BoundedContinuousFunction.toLp p μ 𝕜‖

full_name: ContinuousMap.toLp_norm_le
code: /-- Bound for the operator norm of `ContinuousMap.toLp`. -/
theorem toLp_norm_le :
    ‖(toLp p μ 𝕜 : C(α, E) →L[𝕜] Lp E p μ)‖ ≤ measureUnivNNReal μ ^ p.toReal⁻¹ 
goal: ‖ContinuousMap.toLp p μ 𝕜‖ ≤ ↑(MeasureTheory.measureUnivNNReal μ) ^ p.toReal⁻¹

full_name: MeasureTheory.Lp.pow_mul_meas_ge_le_norm
code: theorem pow_mul_meas_ge_le_norm (f : Lp E p μ) (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞) (ε : ℝ≥0∞) :
    (ε * μ { x | ε ≤ (‖f x‖₊ : ℝ≥0∞) ^ p.toReal }) ^ (1 / p.toReal) ≤ ENNReal.ofReal ‖f‖ 
goal: (ε * μ {x | ε ≤ ↑‖↑↑f x‖₊ ^ p.toReal}) ^ (1 / p.toReal) ≤ ENNReal.ofReal ‖f‖

full_name: MeasureTheory.Lp.mul_meas_ge_le_pow_norm
code: theorem mul_meas_ge_le_pow_norm (f : Lp E p μ) (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞) (ε : ℝ≥0∞) :
    ε * μ { x | ε ≤ (‖f x‖₊ : ℝ≥0∞) ^ p.toReal } ≤ ENNReal.ofReal ‖f‖ ^ p.toReal 
goal: ε * μ {x | ε ≤ ↑‖↑↑f x‖₊ ^ p.toReal} ≤ ENNReal.ofReal ‖f‖ ^ p.toReal

full_name: MeasureTheory.Lp.mul_meas_ge_le_pow_norm'
code: /-- A version of Markov's inequality with elements of Lp. -/
theorem mul_meas_ge_le_pow_norm' (f : Lp E p μ) (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞)
    (ε : ℝ≥0∞) : ε ^ p.toReal * μ { x | ε ≤ ‖f x‖₊ } ≤ ENNReal.ofReal ‖f‖ ^ p.toReal 
goal: ε ^ p.toReal * μ {x | ε ≤ ↑‖↑↑f x‖₊} ≤ ENNReal.ofReal ‖f‖ ^ p.toReal

full_name: MeasureTheory.Lp.meas_ge_le_mul_pow_norm
code: theorem meas_ge_le_mul_pow_norm (f : Lp E p μ) (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞) {ε : ℝ≥0∞}
    (hε : ε ≠ 0) : μ { x | ε ≤ ‖f x‖₊ } ≤ ε⁻¹ ^ p.toReal * ENNReal.ofReal ‖f‖ ^ p.toReal 
goal: μ {x | ε ≤ ↑‖↑↑f x‖₊} ≤ ε⁻¹ ^ p.toReal * ENNReal.ofReal ‖f‖ ^ p.toReal