File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

full_name: MeasureTheory.«_aux_Mathlib_MeasureTheory_Function_SimpleFuncDenseLp___macroRules_MeasureTheory_term_→ₛ__1»
code: local infixr:25 " →ₛ " => SimpleFunc
goal: Lean.Macro

full_name: MeasureTheory._aux_Mathlib_MeasureTheory_Function_SimpleFuncDenseLp___unexpand_MeasureTheory_SimpleFunc_1
code: local infixr:25 " →ₛ " => SimpleFunc
goal: Lean.PrettyPrinter.Unexpander

full_name: MeasureTheory.SimpleFunc.nnnorm_approxOn_le
code: theorem nnnorm_approxOn_le [OpensMeasurableSpace E] {f : β → E} (hf : Measurable f) {s : Set E}
    {y₀ : E} (h₀ : y₀ ∈ s) [SeparableSpace s] (x : β) (n : ℕ) :
    ‖approxOn f hf s y₀ h₀ n x - f x‖₊ ≤ ‖f x - y₀‖₊ 
goal: ‖↑(MeasureTheory.SimpleFunc.approxOn f hf s y₀ h₀ n) x - f x‖₊ ≤ ‖f x - y₀‖₊

full_name: MeasureTheory.SimpleFunc.norm_approxOn_y₀_le
code: theorem norm_approxOn_y₀_le [OpensMeasurableSpace E] {f : β → E} (hf : Measurable f) {s : Set E}
    {y₀ : E} (h₀ : y₀ ∈ s) [SeparableSpace s] (x : β) (n : ℕ) :
    ‖approxOn f hf s y₀ h₀ n x - y₀‖ ≤ ‖f x - y₀‖ + ‖f x - y₀‖ 
goal: ‖↑(MeasureTheory.SimpleFunc.approxOn f hf s y₀ h₀ n) x - y₀‖ ≤ ‖f x - y₀‖ + ‖f x - y₀‖

full_name: MeasureTheory.SimpleFunc.norm_approxOn_zero_le
code: theorem norm_approxOn_zero_le [OpensMeasurableSpace E] {f : β → E} (hf : Measurable f) {s : Set E}
    (h₀ : (0 : E) ∈ s) [SeparableSpace s] (x : β) (n : ℕ) :
    ‖approxOn f hf s 0 h₀ n x‖ ≤ ‖f x‖ + ‖f x‖ 
goal: ‖↑(MeasureTheory.SimpleFunc.approxOn f hf s 0 h₀ n) x‖ ≤ ‖f x‖ + ‖f x‖

full_name: MeasureTheory.SimpleFunc.tendsto_approxOn_Lp_eLpNorm
code: theorem tendsto_approxOn_Lp_eLpNorm [OpensMeasurableSpace E] {f : β → E} (hf : Measurable f)
    {s : Set E} {y₀ : E} (h₀ : y₀ ∈ s) [SeparableSpace s] (hp_ne_top : p ≠ ∞) {μ : Measure β}
    (hμ : ∀ᵐ x ∂μ, f x ∈ closure s) (hi : eLpNorm (fun x => f x - y₀) p μ < ∞) :
    Tendsto (fun n => eLpNorm (⇑(approxOn f hf s y₀ h₀ n) - f) p μ) atTop (𝓝 0) 
goal: Filter.Tendsto (fun n => MeasureTheory.eLpNorm (↑(MeasureTheory.SimpleFunc.approxOn f hf s y₀ h₀ n) - f) p μ)
  Filter.atTop (𝓝 0)

full_name: MeasureTheory.SimpleFunc.memℒp_approxOn
code: theorem memℒp_approxOn [BorelSpace E] {f : β → E} {μ : Measure β} (fmeas : Measurable f)
    (hf : Memℒp f p μ) {s : Set E} {y₀ : E} (h₀ : y₀ ∈ s) [SeparableSpace s]
    (hi₀ : Memℒp (fun _ => y₀) p μ) (n : ℕ) : Memℒp (approxOn f fmeas s y₀ h₀ n) p μ 
goal: MeasureTheory.Memℒp (↑(MeasureTheory.SimpleFunc.approxOn f fmeas s y₀ h₀ n)) p μ

full_name: MeasureTheory.SimpleFunc.tendsto_approxOn_range_Lp_eLpNorm
code: theorem tendsto_approxOn_range_Lp_eLpNorm [BorelSpace E] {f : β → E} (hp_ne_top : p ≠ ∞)
    {μ : Measure β} (fmeas : Measurable f) [SeparableSpace (range f ∪ {0} : Set E)]
    (hf : eLpNorm f p μ < ∞) :
    Tendsto (fun n => eLpNorm (⇑(approxOn f fmeas (range f ∪ {0}) 0 (by simp) n) - f) p μ)
      atTop (𝓝 0) 
goal: Filter.Tendsto
  (fun n => MeasureTheory.eLpNorm (↑(MeasureTheory.SimpleFunc.approxOn f fmeas (Set.range f ∪ {0}) 0 ⋯ n) - f) p μ)
  Filter.atTop (𝓝 0)

full_name: MeasureTheory.SimpleFunc.memℒp_approxOn_range
code: theorem memℒp_approxOn_range [BorelSpace E] {f : β → E} {μ : Measure β} (fmeas : Measurable f)
    [SeparableSpace (range f ∪ {0} : Set E)] (hf : Memℒp f p μ) (n : ℕ) :
    Memℒp (approxOn f fmeas (range f ∪ {0}) 0 (by simp) n) p μ 
goal: MeasureTheory.Memℒp (↑(MeasureTheory.SimpleFunc.approxOn f fmeas (Set.range f ∪ {0}) 0 ⋯ n)) p μ

full_name: MeasureTheory.SimpleFunc.tendsto_approxOn_range_Lp
code: theorem tendsto_approxOn_range_Lp [BorelSpace E] {f : β → E} [hp : Fact (1 ≤ p)] (hp_ne_top : p ≠ ∞)
    {μ : Measure β} (fmeas : Measurable f) [SeparableSpace (range f ∪ {0} : Set E)]
    (hf : Memℒp f p μ) :
    Tendsto
      (fun n =>
        (memℒp_approxOn_range fmeas hf n).toLp (approxOn f fmeas (range f ∪ {0}) 0 (by simp) n))
      atTop (𝓝 (hf.toLp f)) 
goal: Filter.Tendsto
  (fun n => MeasureTheory.Memℒp.toLp ↑(MeasureTheory.SimpleFunc.approxOn f fmeas (Set.range f ∪ {0}) 0 ⋯ n) ⋯)
  Filter.atTop (𝓝 (MeasureTheory.Memℒp.toLp f hf))

full_name: MeasureTheory.Memℒp.exists_simpleFunc_eLpNorm_sub_lt
code: /-- Any function in `ℒp` can be approximated by a simple function if `p < ∞`. -/
theorem _root_.MeasureTheory.Memℒp.exists_simpleFunc_eLpNorm_sub_lt {E : Type*}
    [NormedAddCommGroup E] {f : β → E} {μ : Measure β} (hf : Memℒp f p μ) (hp_ne_top : p ≠ ∞)
    {ε : ℝ≥0∞} (hε : ε ≠ 0) : ∃ g : β →ₛ E, eLpNorm (f - ⇑g) p μ < ε ∧ Memℒp g p μ 
goal: ∃ g, MeasureTheory.eLpNorm (f - ↑g) p μ < ε ∧ MeasureTheory.Memℒp (↑g) p μ

full_name: MeasureTheory.SimpleFunc.tendsto_approxOn_L1_nnnorm
code: theorem tendsto_approxOn_L1_nnnorm [OpensMeasurableSpace E] {f : β → E} (hf : Measurable f)
    {s : Set E} {y₀ : E} (h₀ : y₀ ∈ s) [SeparableSpace s] {μ : Measure β}
    (hμ : ∀ᵐ x ∂μ, f x ∈ closure s) (hi : HasFiniteIntegral (fun x => f x - y₀) μ) :
    Tendsto (fun n => ∫⁻ x, ‖approxOn f hf s y₀ h₀ n x - f x‖₊ ∂μ) atTop (𝓝 0) 
goal: Filter.Tendsto (fun n => ∫⁻ (x : β), ↑‖↑(MeasureTheory.SimpleFunc.approxOn f hf s y₀ h₀ n) x - f x‖₊ ∂μ) Filter.atTop
  (𝓝 0)

full_name: MeasureTheory.SimpleFunc.integrable_approxOn
code: theorem integrable_approxOn [BorelSpace E] {f : β → E} {μ : Measure β} (fmeas : Measurable f)
    (hf : Integrable f μ) {s : Set E} {y₀ : E} (h₀ : y₀ ∈ s) [SeparableSpace s]
    (hi₀ : Integrable (fun _ => y₀) μ) (n : ℕ) : Integrable (approxOn f fmeas s y₀ h₀ n) μ 
goal: MeasureTheory.Integrable (↑(MeasureTheory.SimpleFunc.approxOn f fmeas s y₀ h₀ n)) μ

full_name: MeasureTheory.SimpleFunc.tendsto_approxOn_range_L1_nnnorm
code: theorem tendsto_approxOn_range_L1_nnnorm [OpensMeasurableSpace E] {f : β → E} {μ : Measure β}
    [SeparableSpace (range f ∪ {0} : Set E)] (fmeas : Measurable f) (hf : Integrable f μ) :
    Tendsto (fun n => ∫⁻ x, ‖approxOn f fmeas (range f ∪ {0}) 0 (by simp) n x - f x‖₊ ∂μ) atTop
      (𝓝 0) 
goal: Filter.Tendsto
  (fun n => ∫⁻ (x : β), ↑‖↑(MeasureTheory.SimpleFunc.approxOn f fmeas (Set.range f ∪ {0}) 0 ⋯ n) x - f x‖₊ ∂μ)
  Filter.atTop (𝓝 0)

full_name: MeasureTheory.SimpleFunc.integrable_approxOn_range
code: theorem integrable_approxOn_range [BorelSpace E] {f : β → E} {μ : Measure β} (fmeas : Measurable f)
    [SeparableSpace (range f ∪ {0} : Set E)] (hf : Integrable f μ) (n : ℕ) :
    Integrable (approxOn f fmeas (range f ∪ {0}) 0 (by simp) n) μ 
goal: MeasureTheory.Integrable (↑(MeasureTheory.SimpleFunc.approxOn f fmeas (Set.range f ∪ {0}) 0 ⋯ n)) μ

full_name: MeasureTheory.SimpleFunc.exists_forall_norm_le
code: theorem exists_forall_norm_le (f : α →ₛ F) : ∃ C, ∀ x, ‖f x‖ ≤ C 
goal: ∃ C, ∀ (x : α), ‖↑f x‖ ≤ C

full_name: MeasureTheory.SimpleFunc.memℒp_zero
code: theorem memℒp_zero (f : α →ₛ E) (μ : Measure α) : Memℒp f 0 μ 
goal: MeasureTheory.Memℒp (↑f) 0 μ

full_name: MeasureTheory.SimpleFunc.memℒp_top
code: theorem memℒp_top (f : α →ₛ E) (μ : Measure α) : Memℒp f ∞ μ 
goal: MeasureTheory.Memℒp ↑f ⊤ μ

full_name: MeasureTheory.SimpleFunc.eLpNorm'_eq
code: protected theorem eLpNorm'_eq {p : ℝ} (f : α →ₛ F) (μ : Measure α) :
    eLpNorm' f p μ = (∑ y ∈ f.range, (‖y‖₊ : ℝ≥0∞) ^ p * μ (f ⁻¹' {y})) ^ (1 / p) 
goal: MeasureTheory.eLpNorm' (↑f) p μ = (∑ y ∈ f.range, ↑‖y‖₊ ^ p * μ (↑f ⁻¹' {y})) ^ (1 / p)

full_name: MeasureTheory.SimpleFunc.measure_preimage_lt_top_of_memℒp
code: theorem measure_preimage_lt_top_of_memℒp (hp_pos : p ≠ 0) (hp_ne_top : p ≠ ∞) (f : α →ₛ E)
    (hf : Memℒp f p μ) (y : E) (hy_ne : y ≠ 0) : μ (f ⁻¹' {y}) < ∞ 
goal: μ (↑f ⁻¹' {y}) < ⊤

full_name: MeasureTheory.SimpleFunc.memℒp_of_finite_measure_preimage
code: theorem memℒp_of_finite_measure_preimage (p : ℝ≥0∞) {f : α →ₛ E}
    (hf : ∀ y, y ≠ 0 → μ (f ⁻¹' {y}) < ∞) : Memℒp f p μ 
goal: MeasureTheory.Memℒp (↑f) p μ

full_name: MeasureTheory.SimpleFunc.memℒp_iff
code: theorem memℒp_iff {f : α →ₛ E} (hp_pos : p ≠ 0) (hp_ne_top : p ≠ ∞) :
    Memℒp f p μ ↔ ∀ y, y ≠ 0 → μ (f ⁻¹' {y}) < ∞ 
goal: MeasureTheory.Memℒp (↑f) p μ ↔ ∀ (y : E), y ≠ 0 → μ (↑f ⁻¹' {y}) < ⊤

full_name: MeasureTheory.SimpleFunc.integrable_iff
code: theorem integrable_iff {f : α →ₛ E} : Integrable f μ ↔ ∀ y, y ≠ 0 → μ (f ⁻¹' {y}) < ∞ 
goal: MeasureTheory.Integrable (↑f) μ ↔ ∀ (y : E), y ≠ 0 → μ (↑f ⁻¹' {y}) < ⊤

full_name: MeasureTheory.SimpleFunc.memℒp_iff_integrable
code: theorem memℒp_iff_integrable {f : α →ₛ E} (hp_pos : p ≠ 0) (hp_ne_top : p ≠ ∞) :
    Memℒp f p μ ↔ Integrable f μ 
goal: MeasureTheory.Memℒp (↑f) p μ ↔ MeasureTheory.Integrable (↑f) μ

full_name: MeasureTheory.SimpleFunc.memℒp_iff_finMeasSupp
code: theorem memℒp_iff_finMeasSupp {f : α →ₛ E} (hp_pos : p ≠ 0) (hp_ne_top : p ≠ ∞) :
    Memℒp f p μ ↔ f.FinMeasSupp μ 
goal: MeasureTheory.Memℒp (↑f) p μ ↔ f.FinMeasSupp μ

full_name: MeasureTheory.SimpleFunc.integrable_iff_finMeasSupp
code: theorem integrable_iff_finMeasSupp {f : α →ₛ E} : Integrable f μ ↔ f.FinMeasSupp μ 
goal: MeasureTheory.Integrable (↑f) μ ↔ f.FinMeasSupp μ

full_name: MeasureTheory.SimpleFunc.FinMeasSupp.integrable
code: theorem FinMeasSupp.integrable {f : α →ₛ E} (h : f.FinMeasSupp μ) : Integrable f μ 
goal: MeasureTheory.Integrable (↑f) μ

full_name: MeasureTheory.SimpleFunc.integrable_pair
code: theorem integrable_pair {f : α →ₛ E} {g : α →ₛ F} :
    Integrable f μ → Integrable g μ → Integrable (pair f g) μ 
goal: MeasureTheory.Integrable (↑f) μ → MeasureTheory.Integrable (↑g) μ → MeasureTheory.Integrable (↑(f.pair g)) μ

full_name: MeasureTheory.SimpleFunc.memℒp_of_isFiniteMeasure
code: theorem memℒp_of_isFiniteMeasure (f : α →ₛ E) (p : ℝ≥0∞) (μ : Measure α) [IsFiniteMeasure μ] :
    Memℒp f p μ 
goal: MeasureTheory.Memℒp (↑f) p μ

full_name: MeasureTheory.SimpleFunc.integrable_of_isFiniteMeasure
code: theorem integrable_of_isFiniteMeasure [IsFiniteMeasure μ] (f : α →ₛ E) : Integrable f μ 
goal: MeasureTheory.Integrable (↑f) μ

full_name: MeasureTheory.SimpleFunc.measure_preimage_lt_top_of_integrable
code: theorem measure_preimage_lt_top_of_integrable (f : α →ₛ E) (hf : Integrable f μ) {x : E}
    (hx : x ≠ 0) : μ (f ⁻¹' {x}) < ∞ 
goal: μ (↑f ⁻¹' {x}) < ⊤

full_name: MeasureTheory.SimpleFunc.measure_support_lt_top
code: theorem measure_support_lt_top [Zero β] (f : α →ₛ β) (hf : ∀ y, y ≠ 0 → μ (f ⁻¹' {y}) < ∞) :
    μ (support f) < ∞ 
goal: μ (Function.support ↑f) < ⊤

full_name: MeasureTheory.SimpleFunc.measure_support_lt_top_of_memℒp
code: theorem measure_support_lt_top_of_memℒp (f : α →ₛ E) (hf : Memℒp f p μ) (hp_ne_zero : p ≠ 0)
    (hp_ne_top : p ≠ ∞) : μ (support f) < ∞ 
goal: μ (Function.support ↑f) < ⊤

full_name: MeasureTheory.SimpleFunc.measure_support_lt_top_of_integrable
code: theorem measure_support_lt_top_of_integrable (f : α →ₛ E) (hf : Integrable f μ) :
    μ (support f) < ∞ 
goal: μ (Function.support ↑f) < ⊤

full_name: MeasureTheory.SimpleFunc.measure_lt_top_of_memℒp_indicator
code: theorem measure_lt_top_of_memℒp_indicator (hp_pos : p ≠ 0) (hp_ne_top : p ≠ ∞) {c : E} (hc : c ≠ 0)
    {s : Set α} (hs : MeasurableSet s) (hcs : Memℒp ((const α c).piecewise s hs (const α 0)) p μ) :
    μ s < ⊤ 
goal: μ s < ⊤

full_name: MeasureTheory.Lp.simpleFunc
code: /-- `Lp.simpleFunc` is a subspace of Lp consisting of equivalence classes of an integrable simple
    function. -/
def simpleFunc : AddSubgroup (Lp E p μ) 
goal: AddSubgroup ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Lp.simpleFunc.eq'
code: protected theorem eq' {f g : Lp.simpleFunc E p μ} : (f : α →ₘ[μ] E) = (g : α →ₘ[μ] E) → f = g 
goal: ↑↑f = ↑↑g → f = g

full_name: MeasureTheory.Lp.simpleFunc.smul
code: /-- If `E` is a normed space, `Lp.simpleFunc E p μ` is a `SMul`. Not declared as an
instance as it is (as of writing) used only in the construction of the Bochner integral. -/
protected def smul : SMul 𝕜 (Lp.simpleFunc E p μ) 
goal: SMul 𝕜 ↥(MeasureTheory.Lp.simpleFunc E p μ)

full_name: MeasureTheory.Lp.simpleFunc.coe_smul
code: @[simp, norm_cast]
theorem coe_smul (c : 𝕜) (f : Lp.simpleFunc E p μ) :
    ((c • f : Lp.simpleFunc E p μ) : Lp E p μ) = c • (f : Lp E p μ) 
goal: ↑(c • f) = c • ↑f

full_name: MeasureTheory.Lp.simpleFunc.module
code: /-- If `E` is a normed space, `Lp.simpleFunc E p μ` is a module. Not declared as an
instance as it is (as of writing) used only in the construction of the Bochner integral. -/
protected def module : Module 𝕜 (Lp.simpleFunc E p μ) 
goal: Module 𝕜 ↥(MeasureTheory.Lp.simpleFunc E p μ)

full_name: MeasureTheory.Lp.simpleFunc.boundedSMul
code: /-- If `E` is a normed space, `Lp.simpleFunc E p μ` is a normed space. Not declared as an
instance as it is (as of writing) used only in the construction of the Bochner integral. -/
protected theorem boundedSMul [Fact (1 ≤ p)] : BoundedSMul 𝕜 (Lp.simpleFunc E p μ) 
goal: BoundedSMul 𝕜 ↥(MeasureTheory.Lp.simpleFunc E p μ)

full_name: MeasureTheory.Lp.simpleFunc.normedSpace
code: /-- If `E` is a normed space, `Lp.simpleFunc E p μ` is a normed space. Not declared as an
instance as it is (as of writing) used only in the construction of the Bochner integral. -/
protected def normedSpace {𝕜} [NormedField 𝕜] [NormedSpace 𝕜 E] [Fact (1 ≤ p)] :
    NormedSpace 𝕜 (Lp.simpleFunc E p μ) 
goal: NormedSpace 𝕜 ↥(MeasureTheory.Lp.simpleFunc E p μ)

full_name: MeasureTheory.Lp.simpleFunc.toLp
code: /-- Construct the equivalence class `[f]` of a simple function `f` satisfying `Memℒp`. -/
abbrev toLp (f : α →ₛ E) (hf : Memℒp f p μ) : Lp.simpleFunc E p μ 
goal: ↥(MeasureTheory.Lp.simpleFunc E p μ)

full_name: MeasureTheory.Lp.simpleFunc.toLp_eq_toLp
code: theorem toLp_eq_toLp (f : α →ₛ E) (hf : Memℒp f p μ) : (toLp f hf : Lp E p μ) = hf.toLp f 
goal: ↑(MeasureTheory.Lp.simpleFunc.toLp f hf) = MeasureTheory.Memℒp.toLp (↑f) hf

full_name: MeasureTheory.Lp.simpleFunc.toLp_eq_mk
code: theorem toLp_eq_mk (f : α →ₛ E) (hf : Memℒp f p μ) :
    (toLp f hf : α →ₘ[μ] E) = AEEqFun.mk f f.aestronglyMeasurable 
goal: ↑↑(MeasureTheory.Lp.simpleFunc.toLp f hf) = MeasureTheory.AEEqFun.mk ↑f ⋯

full_name: MeasureTheory.Lp.simpleFunc.toLp_zero
code: theorem toLp_zero : toLp (0 : α →ₛ E) zero_memℒp = (0 : Lp.simpleFunc E p μ) 
goal: MeasureTheory.Lp.simpleFunc.toLp 0 ⋯ = 0

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

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

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

full_name: MeasureTheory.Lp.simpleFunc.toLp_smul
code: theorem toLp_smul (f : α →ₛ E) (hf : Memℒp f p μ) (c : 𝕜) :
    toLp (c • f) (hf.const_smul c) = c • toLp f hf 
goal: MeasureTheory.Lp.simpleFunc.toLp (c • f) ⋯ = c • MeasureTheory.Lp.simpleFunc.toLp f hf

full_name: MeasureTheory.Lp.simpleFunc.norm_toLp
code: nonrec theorem norm_toLp [Fact (1 ≤ p)] (f : α →ₛ E) (hf : Memℒp f p μ) :
    ‖toLp f hf‖ = ENNReal.toReal (eLpNorm f p μ) 
goal: ‖MeasureTheory.Lp.simpleFunc.toLp f hf‖ = (MeasureTheory.eLpNorm (↑f) p μ).toReal

full_name: MeasureTheory.Lp.simpleFunc.toSimpleFunc
code: /-- Find a representative of a `Lp.simpleFunc`. -/
def toSimpleFunc (f : Lp.simpleFunc E p μ) : α →ₛ E 
goal: MeasureTheory.SimpleFunc α E

full_name: MeasureTheory.Lp.simpleFunc.measurable
code: /-- `(toSimpleFunc f)` is measurable. -/
@[measurability]
protected theorem measurable [MeasurableSpace E] (f : Lp.simpleFunc E p μ) :
    Measurable (toSimpleFunc f) 
goal: Measurable ↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc f)

full_name: MeasureTheory.Lp.simpleFunc.stronglyMeasurable
code: protected theorem stronglyMeasurable (f : Lp.simpleFunc E p μ) :
    StronglyMeasurable (toSimpleFunc f) 
goal: MeasureTheory.StronglyMeasurable ↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc f)

full_name: MeasureTheory.Lp.simpleFunc.aemeasurable
code: @[measurability]
protected theorem aemeasurable [MeasurableSpace E] (f : Lp.simpleFunc E p μ) :
    AEMeasurable (toSimpleFunc f) μ 
goal: AEMeasurable (↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc f)) μ

full_name: MeasureTheory.Lp.simpleFunc.aestronglyMeasurable
code: protected theorem aestronglyMeasurable (f : Lp.simpleFunc E p μ) :
    AEStronglyMeasurable (toSimpleFunc f) μ 
goal: MeasureTheory.AEStronglyMeasurable (↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc f)) μ

full_name: MeasureTheory.Lp.simpleFunc.toSimpleFunc_eq_toFun
code: theorem toSimpleFunc_eq_toFun (f : Lp.simpleFunc E p μ) : toSimpleFunc f =ᵐ[μ] f 
goal: ↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc f) =ᵐ[μ] ↑↑↑f

full_name: MeasureTheory.Lp.simpleFunc.memℒp
code: /-- `toSimpleFunc f` satisfies the predicate `Memℒp`. -/
protected theorem memℒp (f : Lp.simpleFunc E p μ) : Memℒp (toSimpleFunc f) p μ 
goal: MeasureTheory.Memℒp (↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc f)) p μ

full_name: MeasureTheory.Lp.simpleFunc.toLp_toSimpleFunc
code: theorem toLp_toSimpleFunc (f : Lp.simpleFunc E p μ) :
    toLp (toSimpleFunc f) (simpleFunc.memℒp f) = f 
goal: MeasureTheory.Lp.simpleFunc.toLp (MeasureTheory.Lp.simpleFunc.toSimpleFunc f) ⋯ = f

full_name: MeasureTheory.Lp.simpleFunc.toSimpleFunc_toLp
code: theorem toSimpleFunc_toLp (f : α →ₛ E) (hfi : Memℒp f p μ) : toSimpleFunc (toLp f hfi) =ᵐ[μ] f 
goal: ↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc (MeasureTheory.Lp.simpleFunc.toLp f hfi)) =ᵐ[μ] ↑f

full_name: MeasureTheory.Lp.simpleFunc.zero_toSimpleFunc
code: theorem zero_toSimpleFunc : toSimpleFunc (0 : Lp.simpleFunc E p μ) =ᵐ[μ] 0 
goal: ↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc 0) =ᵐ[μ] 0

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

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

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

full_name: MeasureTheory.Lp.simpleFunc.smul_toSimpleFunc
code: theorem smul_toSimpleFunc (k : 𝕜) (f : Lp.simpleFunc E p μ) :
    toSimpleFunc (k • f) =ᵐ[μ] k • ⇑(toSimpleFunc f) 
goal: ↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc (k • f)) =ᵐ[μ] k • ↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc f)

full_name: MeasureTheory.Lp.simpleFunc.norm_toSimpleFunc
code: theorem norm_toSimpleFunc [Fact (1 ≤ p)] (f : Lp.simpleFunc E p μ) :
    ‖f‖ = ENNReal.toReal (eLpNorm (toSimpleFunc f) p μ) 
goal: ‖f‖ = (MeasureTheory.eLpNorm (↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc f)) p μ).toReal

full_name: MeasureTheory.Lp.simpleFunc.indicatorConst
code: /-- The characteristic function of a finite-measure measurable set `s`, as an `Lp` simple function.
-/
def indicatorConst {s : Set α} (hs : MeasurableSet s) (hμs : μ s ≠ ∞) (c : E) :
    Lp.simpleFunc E p μ 
goal: ↥(MeasureTheory.Lp.simpleFunc E p μ)

full_name: MeasureTheory.Lp.simpleFunc.coe_indicatorConst
code: @[simp]
theorem coe_indicatorConst {s : Set α} (hs : MeasurableSet s) (hμs : μ s ≠ ∞) (c : E) :
    (↑(indicatorConst p hs hμs c) : Lp E p μ) = indicatorConstLp p hs hμs c 
goal: ↑(MeasureTheory.Lp.simpleFunc.indicatorConst p hs hμs c) = MeasureTheory.indicatorConstLp p hs hμs c

full_name: MeasureTheory.Lp.simpleFunc.toSimpleFunc_indicatorConst
code: theorem toSimpleFunc_indicatorConst {s : Set α} (hs : MeasurableSet s) (hμs : μ s ≠ ∞) (c : E) :
    toSimpleFunc (indicatorConst p hs hμs c) =ᵐ[μ]
      (SimpleFunc.const _ c).piecewise s hs (SimpleFunc.const _ 0) 
goal: ↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc (MeasureTheory.Lp.simpleFunc.indicatorConst p hs hμs c)) =ᵐ[μ]
  ↑(MeasureTheory.SimpleFunc.piecewise s hs (MeasureTheory.SimpleFunc.const α c) (MeasureTheory.SimpleFunc.const α 0))

full_name: MeasureTheory.Lp.simpleFunc.induction
code: /-- To prove something for an arbitrary `Lp` simple function, with `0 < p < ∞`, it suffices to show
that the property holds for (multiples of) characteristic functions of finite-measure measurable
sets and is closed under addition (of functions with disjoint support). -/
@[elab_as_elim]
protected theorem induction (hp_pos : p ≠ 0) (hp_ne_top : p ≠ ∞) {P : Lp.simpleFunc E p μ → Prop}
    (h_ind :
      ∀ (c : E) {s : Set α} (hs : MeasurableSet s) (hμs : μ s < ∞),
        P (Lp.simpleFunc.indicatorConst p hs hμs.ne c))
    (h_add :
      ∀ ⦃f g : α →ₛ E⦄,
        ∀ hf : Memℒp f p μ,
          ∀ hg : Memℒp g p μ,
            Disjoint (support f) (support g) →
              P (Lp.simpleFunc.toLp f hf) →
                P (Lp.simpleFunc.toLp g hg) → P (Lp.simpleFunc.toLp f hf + Lp.simpleFunc.toLp g hg))
    (f : Lp.simpleFunc E p μ) : P f 
goal: P f

full_name: MeasureTheory.Lp.simpleFunc.uniformContinuous
code: protected theorem uniformContinuous : UniformContinuous ((↑) : Lp.simpleFunc E p μ → Lp E p μ) 
goal: UniformContinuous Subtype.val

full_name: MeasureTheory.Lp.simpleFunc.uniformEmbedding
code: protected theorem uniformEmbedding : UniformEmbedding ((↑) : Lp.simpleFunc E p μ → Lp E p μ) 
goal: UniformEmbedding Subtype.val

full_name: MeasureTheory.Lp.simpleFunc.uniformInducing
code: protected theorem uniformInducing : UniformInducing ((↑) : Lp.simpleFunc E p μ → Lp E p μ) 
goal: UniformInducing Subtype.val

full_name: MeasureTheory.Lp.simpleFunc.denseEmbedding
code: protected theorem denseEmbedding (hp_ne_top : p ≠ ∞) :
    DenseEmbedding ((↑) : Lp.simpleFunc E p μ → Lp E p μ) 
goal: DenseEmbedding Subtype.val

full_name: MeasureTheory.Lp.simpleFunc.denseInducing
code: protected theorem denseInducing (hp_ne_top : p ≠ ∞) :
    DenseInducing ((↑) : Lp.simpleFunc E p μ → Lp E p μ) 
goal: DenseInducing Subtype.val

full_name: MeasureTheory.Lp.simpleFunc.denseRange
code: protected theorem denseRange (hp_ne_top : p ≠ ∞) :
    DenseRange ((↑) : Lp.simpleFunc E p μ → Lp E p μ) 
goal: DenseRange Subtype.val

full_name: MeasureTheory.Lp.simpleFunc.dense
code: protected theorem dense (hp_ne_top : p ≠ ∞) : Dense (Lp.simpleFunc E p μ : Set (Lp E p μ)) 
goal: Dense ↑(MeasureTheory.Lp.simpleFunc E p μ)

full_name: MeasureTheory.Lp.simpleFunc.coeToLp
code: /-- The embedding of Lp simple functions into Lp functions, as a continuous linear map. -/
def coeToLp : Lp.simpleFunc E p μ →L[𝕜] Lp E p μ 
goal: ↥(MeasureTheory.Lp.simpleFunc E p μ) →L[𝕜] ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Lp.simpleFunc.coeFn_le
code: theorem coeFn_le (f g : Lp.simpleFunc G p μ) : (f : α → G) ≤ᵐ[μ] g ↔ f ≤ g 
goal: ↑↑↑f ≤ᵐ[μ] ↑↑↑g ↔ f ≤ g

full_name: MeasureTheory.Lp.simpleFunc.instCovariantClassLE
code: instance instCovariantClassLE :
    CovariantClass (Lp.simpleFunc G p μ) (Lp.simpleFunc G p μ) (· + ·) (· ≤ ·) 
goal: CovariantClass (↥(MeasureTheory.Lp.simpleFunc G p μ)) (↥(MeasureTheory.Lp.simpleFunc G p μ)) (fun x x_1 => x + x_1)
  fun x x_1 => x ≤ x_1

full_name: MeasureTheory.Lp.simpleFunc.coeFn_zero
code: theorem coeFn_zero : (0 : Lp.simpleFunc G p μ) =ᵐ[μ] (0 : α → G) 
goal: ↑↑↑0 =ᵐ[μ] 0

full_name: MeasureTheory.Lp.simpleFunc.coeFn_nonneg
code: theorem coeFn_nonneg (f : Lp.simpleFunc G p μ) : (0 : α → G) ≤ᵐ[μ] f ↔ 0 ≤ f 
goal: 0 ≤ᵐ[μ] ↑↑↑f ↔ 0 ≤ f

full_name: MeasureTheory.Lp.simpleFunc.exists_simpleFunc_nonneg_ae_eq
code: theorem exists_simpleFunc_nonneg_ae_eq {f : Lp.simpleFunc G p μ} (hf : 0 ≤ f) :
    ∃ f' : α →ₛ G, 0 ≤ f' ∧ f =ᵐ[μ] f' 
goal: ∃ f', 0 ≤ f' ∧ ↑↑↑f =ᵐ[μ] ↑f'

full_name: MeasureTheory.Lp.simpleFunc.coeSimpleFuncNonnegToLpNonneg
code: /-- Coercion from nonnegative simple functions of Lp to nonnegative functions of Lp. -/
def coeSimpleFuncNonnegToLpNonneg :
    { g : Lp.simpleFunc G p μ // 0 ≤ g } → { g : Lp G p μ // 0 ≤ g } 
goal: { g // 0 ≤ g } → { g // 0 ≤ g }

full_name: MeasureTheory.Lp.simpleFunc.denseRange_coeSimpleFuncNonnegToLpNonneg
code: theorem denseRange_coeSimpleFuncNonnegToLpNonneg [hp : Fact (1 ≤ p)] (hp_ne_top : p ≠ ∞) :
    DenseRange (coeSimpleFuncNonnegToLpNonneg p μ G) 
goal: DenseRange (MeasureTheory.Lp.simpleFunc.coeSimpleFuncNonnegToLpNonneg p μ G)

full_name: MeasureTheory.Lp.induction
code: /-- To prove something for an arbitrary `Lp` function in a second countable Borel normed group, it
suffices to show that
* the property holds for (multiples of) characteristic functions;
* is closed under addition;
* the set of functions in `Lp` for which the property holds is closed.
-/
@[elab_as_elim]
theorem Lp.induction [_i : Fact (1 ≤ p)] (hp_ne_top : p ≠ ∞) (P : Lp E p μ → Prop)
    (h_ind : ∀ (c : E) {s : Set α} (hs : MeasurableSet s) (hμs : μ s < ∞),
      P (Lp.simpleFunc.indicatorConst p hs hμs.ne c))
    (h_add : ∀ ⦃f g⦄, ∀ hf : Memℒp f p μ, ∀ hg : Memℒp g p μ, Disjoint (support f) (support g) →
      P (hf.toLp f) → P (hg.toLp g) → P (hf.toLp f + hg.toLp g))
    (h_closed : IsClosed { f : Lp E p μ | P f }) : ∀ f : Lp E p μ, P f 
goal: P f

full_name: MeasureTheory.Memℒp.induction
code: /-- To prove something for an arbitrary `Memℒp` function in a second countable
Borel normed group, it suffices to show that
* the property holds for (multiples of) characteristic functions;
* is closed under addition;
* the set of functions in the `Lᵖ` space for which the property holds is closed.
* the property is closed under the almost-everywhere equal relation.

It is possible to make the hypotheses in the induction steps a bit stronger, and such conditions
can be added once we need them (for example in `h_add` it is only necessary to consider the sum of
a simple function with a multiple of a characteristic function and that the intersection
of their images is a subset of `{0}`).
-/
@[elab_as_elim]
theorem Memℒp.induction [_i : Fact (1 ≤ p)] (hp_ne_top : p ≠ ∞) (P : (α → E) → Prop)
    (h_ind : ∀ (c : E) ⦃s⦄, MeasurableSet s → μ s < ∞ → P (s.indicator fun _ => c))
    (h_add : ∀ ⦃f g : α → E⦄, Disjoint (support f) (support g) → Memℒp f p μ → Memℒp g p μ →
      P f → P g → P (f + g))
    (h_closed : IsClosed { f : Lp E p μ | P f })
    (h_ae : ∀ ⦃f g⦄, f =ᵐ[μ] g → Memℒp f p μ → P f → P g) :
    ∀ ⦃f : α → E⦄, Memℒp f p μ → P f 
goal: MeasureTheory.Memℒp f p μ → P f

full_name: MeasureTheory.Memℒp.induction_dense
code: /-- If a set of ae strongly measurable functions is stable under addition and approximates
characteristic functions in `ℒp`, then it is dense in `ℒp`. -/
theorem Memℒp.induction_dense (hp_ne_top : p ≠ ∞) (P : (α → E) → Prop)
    (h0P :
      ∀ (c : E) ⦃s : Set α⦄,
        MeasurableSet s →
          μ s < ∞ →
            ∀ {ε : ℝ≥0∞}, ε ≠ 0 → ∃ g : α → E, eLpNorm (g - s.indicator fun _ => c) p μ ≤ ε ∧ P g)
    (h1P : ∀ f g, P f → P g → P (f + g)) (h2P : ∀ f, P f → AEStronglyMeasurable f μ) {f : α → E}
    (hf : Memℒp f p μ) {ε : ℝ≥0∞} (hε : ε ≠ 0) : ∃ g : α → E, eLpNorm (f - g) p μ ≤ ε ∧ P g 
goal: ∃ g, MeasureTheory.eLpNorm (f - g) p μ ≤ ε ∧ P g

full_name: MeasureTheory.«_aux_Mathlib_MeasureTheory_Function_SimpleFuncDenseLp___macroRules_MeasureTheory_term_→₁ₛ[_]__1»
code: @[inherit_doc MeasureTheory.Lp.simpleFunc]
notation:25 α " →₁ₛ[" μ "] " E => @MeasureTheory.Lp.simpleFunc α E _ _ 1 μ
goal: Lean.Macro

full_name: MeasureTheory.L1.SimpleFunc.toLp_one_eq_toL1
code: theorem L1.SimpleFunc.toLp_one_eq_toL1 (f : α →ₛ E) (hf : Integrable f μ) :
    (Lp.simpleFunc.toLp f (memℒp_one_iff_integrable.2 hf) : α →₁[μ] E) = hf.toL1 f 
goal: ↑(MeasureTheory.Lp.simpleFunc.toLp f ⋯) = MeasureTheory.Integrable.toL1 (↑f) hf

full_name: MeasureTheory.L1.SimpleFunc.integrable
code: protected theorem L1.SimpleFunc.integrable (f : α →₁ₛ[μ] E) :
    Integrable (Lp.simpleFunc.toSimpleFunc f) μ 
goal: MeasureTheory.Integrable (↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc f)) μ

full_name: MeasureTheory.Integrable.induction
code: /-- To prove something for an arbitrary integrable function in a normed group,
it suffices to show that
* the property holds for (multiples of) characteristic functions;
* is closed under addition;
* the set of functions in the `L¹` space for which the property holds is closed.
* the property is closed under the almost-everywhere equal relation.

It is possible to make the hypotheses in the induction steps a bit stronger, and such conditions
can be added once we need them (for example in `h_add` it is only necessary to consider the sum of
a simple function with a multiple of a characteristic function and that the intersection
of their images is a subset of `{0}`).
-/
@[elab_as_elim]
theorem Integrable.induction (P : (α → E) → Prop)
    (h_ind : ∀ (c : E) ⦃s⦄, MeasurableSet s → μ s < ∞ → P (s.indicator fun _ => c))
    (h_add :
      ∀ ⦃f g : α → E⦄,
        Disjoint (support f) (support g) → Integrable f μ → Integrable g μ → P f → P g → P (f + g))
    (h_closed : IsClosed { f : α →₁[μ] E | P f })
    (h_ae : ∀ ⦃f g⦄, f =ᵐ[μ] g → Integrable f μ → P f → P g) :
    ∀ ⦃f : α → E⦄, Integrable f μ → P f 
goal: MeasureTheory.Integrable f μ → P f