File: Mathlib/MeasureTheory/Function/L1Space.lean

full_name: MeasureTheory.lintegral_nnnorm_eq_lintegral_edist
code: theorem lintegral_nnnorm_eq_lintegral_edist (f : α → β) :
    ∫⁻ a, ‖f a‖₊ ∂μ = ∫⁻ a, edist (f a) 0 ∂μ 
goal: ∫⁻ (a : α), ↑‖f a‖₊ ∂μ = ∫⁻ (a : α), edist (f a) 0 ∂μ

full_name: MeasureTheory.lintegral_norm_eq_lintegral_edist
code: theorem lintegral_norm_eq_lintegral_edist (f : α → β) :
    ∫⁻ a, ENNReal.ofReal ‖f a‖ ∂μ = ∫⁻ a, edist (f a) 0 ∂μ 
goal: ∫⁻ (a : α), ENNReal.ofReal ‖f a‖ ∂μ = ∫⁻ (a : α), edist (f a) 0 ∂μ

full_name: MeasureTheory.lintegral_edist_triangle
code: theorem lintegral_edist_triangle {f g h : α → β} (hf : AEStronglyMeasurable f μ)
    (hh : AEStronglyMeasurable h μ) :
    (∫⁻ a, edist (f a) (g a) ∂μ) ≤ (∫⁻ a, edist (f a) (h a) ∂μ) + ∫⁻ a, edist (g a) (h a) ∂μ 
goal: ∫⁻ (a : α), edist (f a) (g a) ∂μ ≤ ∫⁻ (a : α), edist (f a) (h a) ∂μ + ∫⁻ (a : α), edist (g a) (h a) ∂μ

full_name: MeasureTheory.lintegral_nnnorm_zero
code: theorem lintegral_nnnorm_zero : (∫⁻ _ : α, ‖(0 : β)‖₊ ∂μ) = 0 
goal: ∫⁻ (x : α), ↑‖0‖₊ ∂μ = 0

full_name: MeasureTheory.lintegral_nnnorm_add_left
code: theorem lintegral_nnnorm_add_left {f : α → β} (hf : AEStronglyMeasurable f μ) (g : α → γ) :
    ∫⁻ a, ‖f a‖₊ + ‖g a‖₊ ∂μ = (∫⁻ a, ‖f a‖₊ ∂μ) + ∫⁻ a, ‖g a‖₊ ∂μ 
goal: ∫⁻ (a : α), ↑‖f a‖₊ + ↑‖g a‖₊ ∂μ = ∫⁻ (a : α), ↑‖f a‖₊ ∂μ + ∫⁻ (a : α), ↑‖g a‖₊ ∂μ

full_name: MeasureTheory.lintegral_nnnorm_add_right
code: theorem lintegral_nnnorm_add_right (f : α → β) {g : α → γ} (hg : AEStronglyMeasurable g μ) :
    ∫⁻ a, ‖f a‖₊ + ‖g a‖₊ ∂μ = (∫⁻ a, ‖f a‖₊ ∂μ) + ∫⁻ a, ‖g a‖₊ ∂μ 
goal: ∫⁻ (a : α), ↑‖f a‖₊ + ↑‖g a‖₊ ∂μ = ∫⁻ (a : α), ↑‖f a‖₊ ∂μ + ∫⁻ (a : α), ↑‖g a‖₊ ∂μ

full_name: MeasureTheory.lintegral_nnnorm_neg
code: theorem lintegral_nnnorm_neg {f : α → β} : (∫⁻ a, ‖(-f) a‖₊ ∂μ) = ∫⁻ a, ‖f a‖₊ ∂μ 
goal: ∫⁻ (a : α), ↑‖(-f) a‖₊ ∂μ = ∫⁻ (a : α), ↑‖f a‖₊ ∂μ

full_name: MeasureTheory.HasFiniteIntegral
code: /-- `HasFiniteIntegral f μ` means that the integral `∫⁻ a, ‖f a‖ ∂μ` is finite.
  `HasFiniteIntegral f` means `HasFiniteIntegral f volume`. -/
def HasFiniteIntegral {_ : MeasurableSpace α} (f : α → β) (μ : Measure α := by volume_tac) : Prop 
goal: {x : MeasurableSpace α} → (α → β) → autoParam (MeasureTheory.Measure α) _auto✝ → Prop

full_name: MeasureTheory.hasFiniteIntegral_def
code: theorem hasFiniteIntegral_def {_ : MeasurableSpace α} (f : α → β) (μ : Measure α) :
    HasFiniteIntegral f μ ↔ ((∫⁻ a, ‖f a‖₊ ∂μ) < ∞) 
goal: ∀ {x : MeasurableSpace α} (f : α → β) (μ : MeasureTheory.Measure α),
  MeasureTheory.HasFiniteIntegral f μ ↔ ∫⁻ (a : α), ↑‖f a‖₊ ∂μ < ⊤

full_name: MeasureTheory.hasFiniteIntegral_iff_norm
code: theorem hasFiniteIntegral_iff_norm (f : α → β) :
    HasFiniteIntegral f μ ↔ (∫⁻ a, ENNReal.ofReal ‖f a‖ ∂μ) < ∞ 
goal: MeasureTheory.HasFiniteIntegral f μ ↔ ∫⁻ (a : α), ENNReal.ofReal ‖f a‖ ∂μ < ⊤

full_name: MeasureTheory.hasFiniteIntegral_iff_edist
code: theorem hasFiniteIntegral_iff_edist (f : α → β) :
    HasFiniteIntegral f μ ↔ (∫⁻ a, edist (f a) 0 ∂μ) < ∞ 
goal: MeasureTheory.HasFiniteIntegral f μ ↔ ∫⁻ (a : α), edist (f a) 0 ∂μ < ⊤

full_name: MeasureTheory.hasFiniteIntegral_iff_ofReal
code: theorem hasFiniteIntegral_iff_ofReal {f : α → ℝ} (h : 0 ≤ᵐ[μ] f) :
    HasFiniteIntegral f μ ↔ (∫⁻ a, ENNReal.ofReal (f a) ∂μ) < ∞ 
goal: MeasureTheory.HasFiniteIntegral f μ ↔ ∫⁻ (a : α), ENNReal.ofReal (f a) ∂μ < ⊤

full_name: MeasureTheory.hasFiniteIntegral_iff_ofNNReal
code: theorem hasFiniteIntegral_iff_ofNNReal {f : α → ℝ≥0} :
    HasFiniteIntegral (fun x => (f x : ℝ)) μ ↔ (∫⁻ a, f a ∂μ) < ∞ 
goal: MeasureTheory.HasFiniteIntegral (fun x => ↑(f x)) μ ↔ ∫⁻ (a : α), ↑(f a) ∂μ < ⊤

full_name: MeasureTheory.HasFiniteIntegral.mono
code: theorem HasFiniteIntegral.mono {f : α → β} {g : α → γ} (hg : HasFiniteIntegral g μ)
    (h : ∀ᵐ a ∂μ, ‖f a‖ ≤ ‖g a‖) : HasFiniteIntegral f μ 
goal: MeasureTheory.HasFiniteIntegral f μ

full_name: MeasureTheory.HasFiniteIntegral.mono'
code: theorem HasFiniteIntegral.mono' {f : α → β} {g : α → ℝ} (hg : HasFiniteIntegral g μ)
    (h : ∀ᵐ a ∂μ, ‖f a‖ ≤ g a) : HasFiniteIntegral f μ 
goal: MeasureTheory.HasFiniteIntegral f μ

full_name: MeasureTheory.HasFiniteIntegral.congr'
code: theorem HasFiniteIntegral.congr' {f : α → β} {g : α → γ} (hf : HasFiniteIntegral f μ)
    (h : ∀ᵐ a ∂μ, ‖f a‖ = ‖g a‖) : HasFiniteIntegral g μ 
goal: MeasureTheory.HasFiniteIntegral g μ

full_name: MeasureTheory.hasFiniteIntegral_congr'
code: theorem hasFiniteIntegral_congr' {f : α → β} {g : α → γ} (h : ∀ᵐ a ∂μ, ‖f a‖ = ‖g a‖) :
    HasFiniteIntegral f μ ↔ HasFiniteIntegral g μ 
goal: MeasureTheory.HasFiniteIntegral f μ ↔ MeasureTheory.HasFiniteIntegral g μ

full_name: MeasureTheory.HasFiniteIntegral.congr
code: theorem HasFiniteIntegral.congr {f g : α → β} (hf : HasFiniteIntegral f μ) (h : f =ᵐ[μ] g) :
    HasFiniteIntegral g μ 
goal: MeasureTheory.HasFiniteIntegral g μ

full_name: MeasureTheory.hasFiniteIntegral_congr
code: theorem hasFiniteIntegral_congr {f g : α → β} (h : f =ᵐ[μ] g) :
    HasFiniteIntegral f μ ↔ HasFiniteIntegral g μ 
goal: MeasureTheory.HasFiniteIntegral f μ ↔ MeasureTheory.HasFiniteIntegral g μ

full_name: MeasureTheory.hasFiniteIntegral_const_iff
code: theorem hasFiniteIntegral_const_iff {c : β} :
    HasFiniteIntegral (fun _ : α => c) μ ↔ c = 0 ∨ μ univ < ∞ 
goal: MeasureTheory.HasFiniteIntegral (fun x => c) μ ↔ c = 0 ∨ μ Set.univ < ⊤

full_name: MeasureTheory.hasFiniteIntegral_const
code: theorem hasFiniteIntegral_const [IsFiniteMeasure μ] (c : β) :
    HasFiniteIntegral (fun _ : α => c) μ 
goal: MeasureTheory.HasFiniteIntegral (fun x => c) μ

full_name: MeasureTheory.hasFiniteIntegral_of_bounded
code: theorem hasFiniteIntegral_of_bounded [IsFiniteMeasure μ] {f : α → β} {C : ℝ}
    (hC : ∀ᵐ a ∂μ, ‖f a‖ ≤ C) : HasFiniteIntegral f μ 
goal: MeasureTheory.HasFiniteIntegral f μ

full_name: MeasureTheory.HasFiniteIntegral.of_finite
code: theorem HasFiniteIntegral.of_finite [Finite α] [IsFiniteMeasure μ] {f : α → β} :
    HasFiniteIntegral f μ 
goal: MeasureTheory.HasFiniteIntegral f μ

full_name: MeasureTheory.HasFiniteIntegral.mono_measure
code: theorem HasFiniteIntegral.mono_measure {f : α → β} (h : HasFiniteIntegral f ν) (hμ : μ ≤ ν) :
    HasFiniteIntegral f μ 
goal: MeasureTheory.HasFiniteIntegral f μ

full_name: MeasureTheory.HasFiniteIntegral.add_measure
code: theorem HasFiniteIntegral.add_measure {f : α → β} (hμ : HasFiniteIntegral f μ)
    (hν : HasFiniteIntegral f ν) : HasFiniteIntegral f (μ + ν) 
goal: MeasureTheory.HasFiniteIntegral f (μ + ν)

full_name: MeasureTheory.HasFiniteIntegral.left_of_add_measure
code: theorem HasFiniteIntegral.left_of_add_measure {f : α → β} (h : HasFiniteIntegral f (μ + ν)) :
    HasFiniteIntegral f μ 
goal: MeasureTheory.HasFiniteIntegral f μ

full_name: MeasureTheory.HasFiniteIntegral.right_of_add_measure
code: theorem HasFiniteIntegral.right_of_add_measure {f : α → β} (h : HasFiniteIntegral f (μ + ν)) :
    HasFiniteIntegral f ν 
goal: MeasureTheory.HasFiniteIntegral f ν

full_name: MeasureTheory.hasFiniteIntegral_add_measure
code: @[simp]
theorem hasFiniteIntegral_add_measure {f : α → β} :
    HasFiniteIntegral f (μ + ν) ↔ HasFiniteIntegral f μ ∧ HasFiniteIntegral f ν 
goal: MeasureTheory.HasFiniteIntegral f (μ + ν) ↔ MeasureTheory.HasFiniteIntegral f μ ∧ MeasureTheory.HasFiniteIntegral f ν

full_name: MeasureTheory.HasFiniteIntegral.smul_measure
code: theorem HasFiniteIntegral.smul_measure {f : α → β} (h : HasFiniteIntegral f μ) {c : ℝ≥0∞}
    (hc : c ≠ ∞) : HasFiniteIntegral f (c • μ) 
goal: MeasureTheory.HasFiniteIntegral f (c • μ)

full_name: MeasureTheory.hasFiniteIntegral_zero_measure
code: @[simp]
theorem hasFiniteIntegral_zero_measure {m : MeasurableSpace α} (f : α → β) :
    HasFiniteIntegral f (0 : Measure α) 
goal: MeasureTheory.HasFiniteIntegral f 0

full_name: MeasureTheory.hasFiniteIntegral_zero
code: @[simp]
theorem hasFiniteIntegral_zero : HasFiniteIntegral (fun _ : α => (0 : β)) μ 
goal: MeasureTheory.HasFiniteIntegral (fun x => 0) μ

full_name: MeasureTheory.HasFiniteIntegral.neg
code: theorem HasFiniteIntegral.neg {f : α → β} (hfi : HasFiniteIntegral f μ) :
    HasFiniteIntegral (-f) μ 
goal: MeasureTheory.HasFiniteIntegral (-f) μ

full_name: MeasureTheory.hasFiniteIntegral_neg_iff
code: @[simp]
theorem hasFiniteIntegral_neg_iff {f : α → β} : HasFiniteIntegral (-f) μ ↔ HasFiniteIntegral f μ 
goal: MeasureTheory.HasFiniteIntegral (-f) μ ↔ MeasureTheory.HasFiniteIntegral f μ

full_name: MeasureTheory.HasFiniteIntegral.norm
code: theorem HasFiniteIntegral.norm {f : α → β} (hfi : HasFiniteIntegral f μ) :
    HasFiniteIntegral (fun a => ‖f a‖) μ 
goal: MeasureTheory.HasFiniteIntegral (fun a => ‖f a‖) μ

full_name: MeasureTheory.hasFiniteIntegral_norm_iff
code: theorem hasFiniteIntegral_norm_iff (f : α → β) :
    HasFiniteIntegral (fun a => ‖f a‖) μ ↔ HasFiniteIntegral f μ 
goal: MeasureTheory.HasFiniteIntegral (fun a => ‖f a‖) μ ↔ MeasureTheory.HasFiniteIntegral f μ

full_name: MeasureTheory.hasFiniteIntegral_toReal_of_lintegral_ne_top
code: theorem hasFiniteIntegral_toReal_of_lintegral_ne_top {f : α → ℝ≥0∞} (hf : (∫⁻ x, f x ∂μ) ≠ ∞) :
    HasFiniteIntegral (fun x => (f x).toReal) μ 
goal: MeasureTheory.HasFiniteIntegral (fun x => (f x).toReal) μ

full_name: MeasureTheory.isFiniteMeasure_withDensity_ofReal
code: theorem isFiniteMeasure_withDensity_ofReal {f : α → ℝ} (hfi : HasFiniteIntegral f μ) :
    IsFiniteMeasure (μ.withDensity fun x => ENNReal.ofReal <| f x) 
goal: MeasureTheory.IsFiniteMeasure (μ.withDensity fun x => ENNReal.ofReal (f x))

full_name: MeasureTheory.all_ae_ofReal_F_le_bound
code: theorem all_ae_ofReal_F_le_bound (h : ∀ n, ∀ᵐ a ∂μ, ‖F n a‖ ≤ bound a) :
    ∀ n, ∀ᵐ a ∂μ, ENNReal.ofReal ‖F n a‖ ≤ ENNReal.ofReal (bound a) 
goal: ∀ᵐ (a : α) ∂μ, ENNReal.ofReal ‖F n a‖ ≤ ENNReal.ofReal (bound a)

full_name: MeasureTheory.all_ae_tendsto_ofReal_norm
code: theorem all_ae_tendsto_ofReal_norm (h : ∀ᵐ a ∂μ, Tendsto (fun n => F n a) atTop <| 𝓝 <| f a) :
    ∀ᵐ a ∂μ, Tendsto (fun n => ENNReal.ofReal ‖F n a‖) atTop <| 𝓝 <| ENNReal.ofReal ‖f a‖ 
goal: ∀ᵐ (a : α) ∂μ, Filter.Tendsto (fun n => ENNReal.ofReal ‖F n a‖) Filter.atTop (𝓝 (ENNReal.ofReal ‖f a‖))

full_name: MeasureTheory.all_ae_ofReal_f_le_bound
code: theorem all_ae_ofReal_f_le_bound (h_bound : ∀ n, ∀ᵐ a ∂μ, ‖F n a‖ ≤ bound a)
    (h_lim : ∀ᵐ a ∂μ, Tendsto (fun n => F n a) atTop (𝓝 (f a))) :
    ∀ᵐ a ∂μ, ENNReal.ofReal ‖f a‖ ≤ ENNReal.ofReal (bound a) 
goal: ∀ᵐ (a : α) ∂μ, ENNReal.ofReal ‖f a‖ ≤ ENNReal.ofReal (bound a)

full_name: MeasureTheory.hasFiniteIntegral_of_dominated_convergence
code: theorem hasFiniteIntegral_of_dominated_convergence {F : ℕ → α → β} {f : α → β} {bound : α → ℝ}
    (bound_hasFiniteIntegral : HasFiniteIntegral bound μ)
    (h_bound : ∀ n, ∀ᵐ a ∂μ, ‖F n a‖ ≤ bound a)
    (h_lim : ∀ᵐ a ∂μ, Tendsto (fun n => F n a) atTop (𝓝 (f a))) : HasFiniteIntegral f μ 
goal: MeasureTheory.HasFiniteIntegral f μ

full_name: MeasureTheory.tendsto_lintegral_norm_of_dominated_convergence
code: theorem tendsto_lintegral_norm_of_dominated_convergence {F : ℕ → α → β} {f : α → β} {bound : α → ℝ}
    (F_measurable : ∀ n, AEStronglyMeasurable (F n) μ)
    (bound_hasFiniteIntegral : HasFiniteIntegral bound μ)
    (h_bound : ∀ n, ∀ᵐ a ∂μ, ‖F n a‖ ≤ bound a)
    (h_lim : ∀ᵐ a ∂μ, Tendsto (fun n => F n a) atTop (𝓝 (f a))) :
    Tendsto (fun n => ∫⁻ a, ENNReal.ofReal ‖F n a - f a‖ ∂μ) atTop (𝓝 0) 
goal: Filter.Tendsto (fun n => ∫⁻ (a : α), ENNReal.ofReal ‖F n a - f a‖ ∂μ) Filter.atTop (𝓝 0)

full_name: MeasureTheory.HasFiniteIntegral.max_zero
code: theorem HasFiniteIntegral.max_zero {f : α → ℝ} (hf : HasFiniteIntegral f μ) :
    HasFiniteIntegral (fun a => max (f a) 0) μ 
goal: MeasureTheory.HasFiniteIntegral (fun a => max (f a) 0) μ

full_name: MeasureTheory.HasFiniteIntegral.min_zero
code: theorem HasFiniteIntegral.min_zero {f : α → ℝ} (hf : HasFiniteIntegral f μ) :
    HasFiniteIntegral (fun a => min (f a) 0) μ 
goal: MeasureTheory.HasFiniteIntegral (fun a => min (f a) 0) μ

full_name: MeasureTheory.HasFiniteIntegral.smul
code: theorem HasFiniteIntegral.smul [NormedAddCommGroup 𝕜] [SMulZeroClass 𝕜 β] [BoundedSMul 𝕜 β] (c : 𝕜)
    {f : α → β} : HasFiniteIntegral f μ → HasFiniteIntegral (c • f) μ 
goal: MeasureTheory.HasFiniteIntegral f μ → MeasureTheory.HasFiniteIntegral (c • f) μ

full_name: MeasureTheory.hasFiniteIntegral_smul_iff
code: theorem hasFiniteIntegral_smul_iff [NormedRing 𝕜] [MulActionWithZero 𝕜 β] [BoundedSMul 𝕜 β] {c : 𝕜}
    (hc : IsUnit c) (f : α → β) : HasFiniteIntegral (c • f) μ ↔ HasFiniteIntegral f μ 
goal: MeasureTheory.HasFiniteIntegral (c • f) μ ↔ MeasureTheory.HasFiniteIntegral f μ

full_name: MeasureTheory.HasFiniteIntegral.const_mul
code: theorem HasFiniteIntegral.const_mul [NormedRing 𝕜] {f : α → 𝕜} (h : HasFiniteIntegral f μ) (c : 𝕜) :
    HasFiniteIntegral (fun x => c * f x) μ 
goal: MeasureTheory.HasFiniteIntegral (fun x => c * f x) μ

full_name: MeasureTheory.HasFiniteIntegral.mul_const
code: theorem HasFiniteIntegral.mul_const [NormedRing 𝕜] {f : α → 𝕜} (h : HasFiniteIntegral f μ) (c : 𝕜) :
    HasFiniteIntegral (fun x => f x * c) μ 
goal: MeasureTheory.HasFiniteIntegral (fun x => f x * c) μ

full_name: MeasureTheory.Integrable
code: /-- `Integrable f μ` means that `f` is measurable and that the integral `∫⁻ a, ‖f a‖ ∂μ` is finite.
  `Integrable f` means `Integrable f volume`. -/
def Integrable {α} {_ : MeasurableSpace α} (f : α → β) (μ : Measure α := by volume_tac) : Prop 
goal: {x : MeasurableSpace α} → (α → β) → autoParam (MeasureTheory.Measure α) _auto✝ → Prop

full_name: MeasureTheory.memℒp_one_iff_integrable
code: theorem memℒp_one_iff_integrable {f : α → β} : Memℒp f 1 μ ↔ Integrable f μ 
goal: MeasureTheory.Memℒp f 1 μ ↔ MeasureTheory.Integrable f μ

full_name: MeasureTheory.Integrable.aestronglyMeasurable
code: theorem Integrable.aestronglyMeasurable {f : α → β} (hf : Integrable f μ) :
    AEStronglyMeasurable f μ 
goal: MeasureTheory.AEStronglyMeasurable f μ

full_name: MeasureTheory.Integrable.aemeasurable
code: theorem Integrable.aemeasurable [MeasurableSpace β] [BorelSpace β] {f : α → β}
    (hf : Integrable f μ) : AEMeasurable f μ 
goal: AEMeasurable f μ

full_name: MeasureTheory.Integrable.hasFiniteIntegral
code: theorem Integrable.hasFiniteIntegral {f : α → β} (hf : Integrable f μ) : HasFiniteIntegral f μ 
goal: MeasureTheory.HasFiniteIntegral f μ

full_name: MeasureTheory.Integrable.mono
code: theorem Integrable.mono {f : α → β} {g : α → γ} (hg : Integrable g μ)
    (hf : AEStronglyMeasurable f μ) (h : ∀ᵐ a ∂μ, ‖f a‖ ≤ ‖g a‖) : Integrable f μ 
goal: MeasureTheory.Integrable f μ

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

full_name: MeasureTheory.Integrable.congr'
code: theorem Integrable.congr' {f : α → β} {g : α → γ} (hf : Integrable f μ)
    (hg : AEStronglyMeasurable g μ) (h : ∀ᵐ a ∂μ, ‖f a‖ = ‖g a‖) : Integrable g μ 
goal: MeasureTheory.Integrable g μ

full_name: MeasureTheory.integrable_congr'
code: theorem integrable_congr' {f : α → β} {g : α → γ} (hf : AEStronglyMeasurable f μ)
    (hg : AEStronglyMeasurable g μ) (h : ∀ᵐ a ∂μ, ‖f a‖ = ‖g a‖) :
    Integrable f μ ↔ Integrable g μ 
goal: MeasureTheory.Integrable f μ ↔ MeasureTheory.Integrable g μ

full_name: MeasureTheory.Integrable.congr
code: theorem Integrable.congr {f g : α → β} (hf : Integrable f μ) (h : f =ᵐ[μ] g) : Integrable g μ 
goal: MeasureTheory.Integrable g μ

full_name: MeasureTheory.integrable_congr
code: theorem integrable_congr {f g : α → β} (h : f =ᵐ[μ] g) : Integrable f μ ↔ Integrable g μ 
goal: MeasureTheory.Integrable f μ ↔ MeasureTheory.Integrable g μ

full_name: MeasureTheory.integrable_const_iff
code: theorem integrable_const_iff {c : β} : Integrable (fun _ : α => c) μ ↔ c = 0 ∨ μ univ < ∞ 
goal: MeasureTheory.Integrable (fun x => c) μ ↔ c = 0 ∨ μ Set.univ < ⊤

full_name: MeasureTheory.integrable_const
code: @[simp]
theorem integrable_const [IsFiniteMeasure μ] (c : β) : Integrable (fun _ : α => c) μ 
goal: MeasureTheory.Integrable (fun x => c) μ

full_name: MeasureTheory.Integrable.of_finite
code: @[simp]
theorem Integrable.of_finite [Finite α] [MeasurableSpace α] [MeasurableSingletonClass α]
    (μ : Measure α) [IsFiniteMeasure μ] (f : α → β) : Integrable (fun a ↦ f a) μ 
goal: MeasureTheory.Integrable (fun a => f a) μ

full_name: MeasureTheory.Memℒp.integrable_norm_rpow
code: theorem Memℒp.integrable_norm_rpow {f : α → β} {p : ℝ≥0∞} (hf : Memℒp f p μ) (hp_ne_zero : p ≠ 0)
    (hp_ne_top : p ≠ ∞) : Integrable (fun x : α => ‖f x‖ ^ p.toReal) μ 
goal: MeasureTheory.Integrable (fun x => ‖f x‖ ^ p.toReal) μ

full_name: MeasureTheory.Memℒp.integrable_norm_rpow'
code: theorem Memℒp.integrable_norm_rpow' [IsFiniteMeasure μ] {f : α → β} {p : ℝ≥0∞} (hf : Memℒp f p μ) :
    Integrable (fun x : α => ‖f x‖ ^ p.toReal) μ 
goal: MeasureTheory.Integrable (fun x => ‖f x‖ ^ p.toReal) μ

full_name: MeasureTheory.Integrable.mono_measure
code: theorem Integrable.mono_measure {f : α → β} (h : Integrable f ν) (hμ : μ ≤ ν) : Integrable f μ 
goal: MeasureTheory.Integrable f μ

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

full_name: MeasureTheory.Integrable.add_measure
code: theorem Integrable.add_measure {f : α → β} (hμ : Integrable f μ) (hν : Integrable f ν) :
    Integrable f (μ + ν) 
goal: MeasureTheory.Integrable f (μ + ν)

full_name: MeasureTheory.Integrable.left_of_add_measure
code: theorem Integrable.left_of_add_measure {f : α → β} (h : Integrable f (μ + ν)) : Integrable f μ 
goal: MeasureTheory.Integrable f μ

full_name: MeasureTheory.Integrable.right_of_add_measure
code: theorem Integrable.right_of_add_measure {f : α → β} (h : Integrable f (μ + ν)) :
    Integrable f ν 
goal: MeasureTheory.Integrable f ν

full_name: MeasureTheory.integrable_add_measure
code: @[simp]
theorem integrable_add_measure {f : α → β} :
    Integrable f (μ + ν) ↔ Integrable f μ ∧ Integrable f ν 
goal: MeasureTheory.Integrable f (μ + ν) ↔ MeasureTheory.Integrable f μ ∧ MeasureTheory.Integrable f ν

full_name: MeasureTheory.integrable_zero_measure
code: @[simp]
theorem integrable_zero_measure {_ : MeasurableSpace α} {f : α → β} :
    Integrable f (0 : Measure α) 
goal: ∀ {x : MeasurableSpace α} {f : α → β}, MeasureTheory.Integrable f 0

full_name: MeasureTheory.integrable_finset_sum_measure
code: theorem integrable_finset_sum_measure {ι} {m : MeasurableSpace α} {f : α → β} {μ : ι → Measure α}
    {s : Finset ι} : Integrable f (∑ i ∈ s, μ i) ↔ ∀ i ∈ s, Integrable f (μ i) 
goal: MeasureTheory.Integrable f (∑ i ∈ s, μ i) ↔ ∀ i ∈ s, MeasureTheory.Integrable f (μ i)

full_name: MeasureTheory.Integrable.smul_measure
code: theorem Integrable.smul_measure {f : α → β} (h : Integrable f μ) {c : ℝ≥0∞} (hc : c ≠ ∞) :
    Integrable f (c • μ) 
goal: MeasureTheory.Integrable f (c • μ)

full_name: MeasureTheory.Integrable.smul_measure_nnreal
code: theorem Integrable.smul_measure_nnreal {f : α → β} (h : Integrable f μ) {c : ℝ≥0} :
    Integrable f (c • μ) 
goal: MeasureTheory.Integrable f (c • μ)

full_name: MeasureTheory.integrable_smul_measure
code: theorem integrable_smul_measure {f : α → β} {c : ℝ≥0∞} (h₁ : c ≠ 0) (h₂ : c ≠ ∞) :
    Integrable f (c • μ) ↔ Integrable f μ 
goal: MeasureTheory.Integrable f (c • μ) ↔ MeasureTheory.Integrable f μ

full_name: MeasureTheory.integrable_inv_smul_measure
code: theorem integrable_inv_smul_measure {f : α → β} {c : ℝ≥0∞} (h₁ : c ≠ 0) (h₂ : c ≠ ∞) :
    Integrable f (c⁻¹ • μ) ↔ Integrable f μ 
goal: MeasureTheory.Integrable f (c⁻¹ • μ) ↔ MeasureTheory.Integrable f μ

full_name: MeasureTheory.Integrable.to_average
code: theorem Integrable.to_average {f : α → β} (h : Integrable f μ) : Integrable f ((μ univ)⁻¹ • μ) 
goal: MeasureTheory.Integrable f ((μ Set.univ)⁻¹ • μ)

full_name: MeasureTheory.integrable_average
code: theorem integrable_average [IsFiniteMeasure μ] {f : α → β} :
    Integrable f ((μ univ)⁻¹ • μ) ↔ Integrable f μ 
goal: MeasureTheory.Integrable f ((μ Set.univ)⁻¹ • μ) ↔ MeasureTheory.Integrable f μ

full_name: MeasureTheory.integrable_map_measure
code: theorem integrable_map_measure {f : α → δ} {g : δ → β}
    (hg : AEStronglyMeasurable g (Measure.map f μ)) (hf : AEMeasurable f μ) :
    Integrable g (Measure.map f μ) ↔ Integrable (g ∘ f) μ 
goal: MeasureTheory.Integrable g (MeasureTheory.Measure.map f μ) ↔ MeasureTheory.Integrable (g ∘ f) μ

full_name: MeasureTheory.Integrable.comp_aemeasurable
code: theorem Integrable.comp_aemeasurable {f : α → δ} {g : δ → β} (hg : Integrable g (Measure.map f μ))
    (hf : AEMeasurable f μ) : Integrable (g ∘ f) μ 
goal: MeasureTheory.Integrable (g ∘ f) μ

full_name: MeasureTheory.Integrable.comp_measurable
code: theorem Integrable.comp_measurable {f : α → δ} {g : δ → β} (hg : Integrable g (Measure.map f μ))
    (hf : Measurable f) : Integrable (g ∘ f) μ 
goal: MeasureTheory.Integrable (g ∘ f) μ

full_name: MeasurableEmbedding.integrable_map_iff
code: theorem _root_.MeasurableEmbedding.integrable_map_iff {f : α → δ} (hf : MeasurableEmbedding f)
    {g : δ → β} : Integrable g (Measure.map f μ) ↔ Integrable (g ∘ f) μ 
goal: MeasureTheory.Integrable g (MeasureTheory.Measure.map f μ) ↔ MeasureTheory.Integrable (g ∘ f) μ

full_name: MeasureTheory.integrable_map_equiv
code: theorem integrable_map_equiv (f : α ≃ᵐ δ) (g : δ → β) :
    Integrable g (Measure.map f μ) ↔ Integrable (g ∘ f) μ 
goal: MeasureTheory.Integrable g (MeasureTheory.Measure.map (⇑f) μ) ↔ MeasureTheory.Integrable (g ∘ ⇑f) μ

full_name: MeasureTheory.MeasurePreserving.integrable_comp
code: theorem MeasurePreserving.integrable_comp {ν : Measure δ} {g : δ → β} {f : α → δ}
    (hf : MeasurePreserving f μ ν) (hg : AEStronglyMeasurable g ν) :
    Integrable (g ∘ f) μ ↔ Integrable g ν 
goal: MeasureTheory.Integrable (g ∘ f) μ ↔ MeasureTheory.Integrable g ν

full_name: MeasureTheory.MeasurePreserving.integrable_comp_emb
code: theorem MeasurePreserving.integrable_comp_emb {f : α → δ} {ν} (h₁ : MeasurePreserving f μ ν)
    (h₂ : MeasurableEmbedding f) {g : δ → β} : Integrable (g ∘ f) μ ↔ Integrable g ν 
goal: MeasureTheory.Integrable (g ∘ f) μ ↔ MeasureTheory.Integrable g ν

full_name: MeasureTheory.lintegral_edist_lt_top
code: theorem lintegral_edist_lt_top {f g : α → β} (hf : Integrable f μ) (hg : Integrable g μ) :
    (∫⁻ a, edist (f a) (g a) ∂μ) < ∞ 
goal: ∫⁻ (a : α), edist (f a) (g a) ∂μ < ⊤

full_name: MeasureTheory.integrable_zero
code: @[simp]
theorem integrable_zero : Integrable (fun _ => (0 : β)) μ 
goal: MeasureTheory.Integrable (fun x => 0) μ

full_name: MeasureTheory.Integrable.add'
code: theorem Integrable.add' {f g : α → β} (hf : Integrable f μ) (hg : Integrable g μ) :
    HasFiniteIntegral (f + g) μ 
goal: MeasureTheory.HasFiniteIntegral (f + g) μ

full_name: MeasureTheory.Integrable.add
code: theorem Integrable.add {f g : α → β} (hf : Integrable f μ) (hg : Integrable g μ) :
    Integrable (f + g) μ 
goal: MeasureTheory.Integrable (f + g) μ

full_name: MeasureTheory.integrable_finset_sum'
code: theorem integrable_finset_sum' {ι} (s : Finset ι) {f : ι → α → β}
    (hf : ∀ i ∈ s, Integrable (f i) μ) : Integrable (∑ i ∈ s, f i) μ 
goal: MeasureTheory.Integrable (∑ i ∈ s, f i) μ

full_name: MeasureTheory.integrable_finset_sum
code: theorem integrable_finset_sum {ι} (s : Finset ι) {f : ι → α → β}
    (hf : ∀ i ∈ s, Integrable (f i) μ) : Integrable (fun a => ∑ i ∈ s, f i a) μ 
goal: MeasureTheory.Integrable (fun a => ∑ i ∈ s, f i a) μ

full_name: MeasureTheory.Integrable.neg
code: theorem Integrable.neg {f : α → β} (hf : Integrable f μ) : Integrable (-f) μ 
goal: MeasureTheory.Integrable (-f) μ

full_name: MeasureTheory.integrable_neg_iff
code: @[simp]
theorem integrable_neg_iff {f : α → β} : Integrable (-f) μ ↔ Integrable f μ 
goal: MeasureTheory.Integrable (-f) μ ↔ MeasureTheory.Integrable f μ

full_name: MeasureTheory.integrable_add_iff_integrable_right
code: @[simp]
lemma integrable_add_iff_integrable_right {f g : α → β} (hf : Integrable f μ) :
    Integrable (f + g) μ ↔ Integrable g μ 
goal: MeasureTheory.Integrable (f + g) μ ↔ MeasureTheory.Integrable g μ

full_name: MeasureTheory.integrable_add_iff_integrable_left
code: @[simp]
lemma integrable_add_iff_integrable_left {f g : α → β} (hf : Integrable f μ) :
    Integrable (g + f) μ ↔ Integrable g μ 
goal: MeasureTheory.Integrable (g + f) μ ↔ MeasureTheory.Integrable g μ

full_name: MeasureTheory.integrable_left_of_integrable_add_of_nonneg
code: lemma integrable_left_of_integrable_add_of_nonneg {f g : α → ℝ}
    (h_meas : AEStronglyMeasurable f μ) (hf : 0 ≤ᵐ[μ] f) (hg : 0 ≤ᵐ[μ] g)
    (h_int : Integrable (f + g) μ) : Integrable f μ 
goal: MeasureTheory.Integrable f μ

full_name: MeasureTheory.integrable_right_of_integrable_add_of_nonneg
code: lemma integrable_right_of_integrable_add_of_nonneg {f g : α → ℝ}
    (h_meas : AEStronglyMeasurable f μ) (hf : 0 ≤ᵐ[μ] f) (hg : 0 ≤ᵐ[μ] g)
    (h_int : Integrable (f + g) μ) : Integrable g μ 
goal: MeasureTheory.Integrable g μ

full_name: MeasureTheory.integrable_add_iff_of_nonneg
code: lemma integrable_add_iff_of_nonneg {f g : α → ℝ} (h_meas : AEStronglyMeasurable f μ)
    (hf : 0 ≤ᵐ[μ] f) (hg : 0 ≤ᵐ[μ] g) :
    Integrable (f + g) μ ↔ Integrable f μ ∧ Integrable g μ 
goal: MeasureTheory.Integrable (f + g) μ ↔ MeasureTheory.Integrable f μ ∧ MeasureTheory.Integrable g μ

full_name: MeasureTheory.integrable_add_iff_of_nonpos
code: lemma integrable_add_iff_of_nonpos {f g : α → ℝ} (h_meas : AEStronglyMeasurable f μ)
    (hf : f ≤ᵐ[μ] 0) (hg : g ≤ᵐ[μ] 0) :
    Integrable (f + g) μ ↔ Integrable f μ ∧ Integrable g μ 
goal: MeasureTheory.Integrable (f + g) μ ↔ MeasureTheory.Integrable f μ ∧ MeasureTheory.Integrable g μ

full_name: MeasureTheory.integrable_add_const_iff
code: @[simp]
lemma integrable_add_const_iff [IsFiniteMeasure μ] {f : α → β} {c : β} :
    Integrable (fun x ↦ f x + c) μ ↔ Integrable f μ 
goal: MeasureTheory.Integrable (fun x => f x + c) μ ↔ MeasureTheory.Integrable f μ

full_name: MeasureTheory.integrable_const_add_iff
code: @[simp]
lemma integrable_const_add_iff [IsFiniteMeasure μ] {f : α → β} {c : β} :
    Integrable (fun x ↦ c + f x) μ ↔ Integrable f μ 
goal: MeasureTheory.Integrable (fun x => c + f x) μ ↔ MeasureTheory.Integrable f μ

full_name: MeasureTheory.Integrable.sub
code: theorem Integrable.sub {f g : α → β} (hf : Integrable f μ) (hg : Integrable g μ) :
    Integrable (f - g) μ 
goal: MeasureTheory.Integrable (f - g) μ

full_name: MeasureTheory.Integrable.norm
code: theorem Integrable.norm {f : α → β} (hf : Integrable f μ) : Integrable (fun a => ‖f a‖) μ 
goal: MeasureTheory.Integrable (fun a => ‖f a‖) μ

full_name: MeasureTheory.Integrable.inf
code: theorem Integrable.inf {β} [NormedLatticeAddCommGroup β] {f g : α → β} (hf : Integrable f μ)
    (hg : Integrable g μ) : Integrable (f ⊓ g) μ 
goal: MeasureTheory.Integrable (f ⊓ g) μ

full_name: MeasureTheory.Integrable.sup
code: theorem Integrable.sup {β} [NormedLatticeAddCommGroup β] {f g : α → β} (hf : Integrable f μ)
    (hg : Integrable g μ) : Integrable (f ⊔ g) μ 
goal: MeasureTheory.Integrable (f ⊔ g) μ

full_name: MeasureTheory.Integrable.abs
code: theorem Integrable.abs {β} [NormedLatticeAddCommGroup β] {f : α → β} (hf : Integrable f μ) :
    Integrable (fun a => |f a|) μ 
goal: MeasureTheory.Integrable (fun a => |f a|) μ

full_name: MeasureTheory.Integrable.bdd_mul
code: theorem Integrable.bdd_mul {F : Type*} [NormedDivisionRing F] {f g : α → F} (hint : Integrable g μ)
    (hm : AEStronglyMeasurable f μ) (hfbdd : ∃ C, ∀ x, ‖f x‖ ≤ C) :
    Integrable (fun x => f x * g x) μ 
goal: MeasureTheory.Integrable (fun x => f x * g x) μ

full_name: MeasureTheory.Integrable.essSup_smul
code: /-- **Hölder's inequality for integrable functions**: the scalar multiplication of an integrable
vector-valued function by a scalar function with finite essential supremum is integrable. -/
theorem Integrable.essSup_smul {𝕜 : Type*} [NormedField 𝕜] [NormedSpace 𝕜 β] {f : α → β}
    (hf : Integrable f μ) {g : α → 𝕜} (g_aestronglyMeasurable : AEStronglyMeasurable g μ)
    (ess_sup_g : essSup (fun x => (‖g x‖₊ : ℝ≥0∞)) μ ≠ ∞) :
    Integrable (fun x : α => g x • f x) μ 
goal: MeasureTheory.Integrable (fun x => g x • f x) μ

full_name: MeasureTheory.Integrable.smul_essSup
code: /-- Hölder's inequality for integrable functions: the scalar multiplication of an integrable
scalar-valued function by a vector-value function with finite essential supremum is integrable. -/
theorem Integrable.smul_essSup {𝕜 : Type*} [NormedRing 𝕜] [Module 𝕜 β] [BoundedSMul 𝕜 β]
    {f : α → 𝕜} (hf : Integrable f μ) {g : α → β}
    (g_aestronglyMeasurable : AEStronglyMeasurable g μ)
    (ess_sup_g : essSup (fun x => (‖g x‖₊ : ℝ≥0∞)) μ ≠ ∞) :
    Integrable (fun x : α => f x • g x) μ 
goal: MeasureTheory.Integrable (fun x => f x • g x) μ

full_name: MeasureTheory.integrable_norm_iff
code: theorem integrable_norm_iff {f : α → β} (hf : AEStronglyMeasurable f μ) :
    Integrable (fun a => ‖f a‖) μ ↔ Integrable f μ 
goal: MeasureTheory.Integrable (fun a => ‖f a‖) μ ↔ MeasureTheory.Integrable f μ

full_name: MeasureTheory.integrable_of_norm_sub_le
code: theorem integrable_of_norm_sub_le {f₀ f₁ : α → β} {g : α → ℝ} (hf₁_m : AEStronglyMeasurable f₁ μ)
    (hf₀_i : Integrable f₀ μ) (hg_i : Integrable g μ) (h : ∀ᵐ a ∂μ, ‖f₀ a - f₁ a‖ ≤ g a) :
    Integrable f₁ μ 
goal: MeasureTheory.Integrable f₁ μ

full_name: MeasureTheory.Integrable.prod_mk
code: theorem Integrable.prod_mk {f : α → β} {g : α → γ} (hf : Integrable f μ) (hg : Integrable g μ) :
    Integrable (fun x => (f x, g x)) μ 
goal: MeasureTheory.Integrable (fun x => (f x, g x)) μ

full_name: MeasureTheory.Memℒp.integrable
code: theorem Memℒp.integrable {q : ℝ≥0∞} (hq1 : 1 ≤ q) {f : α → β} [IsFiniteMeasure μ]
    (hfq : Memℒp f q μ) : Integrable f μ 
goal: MeasureTheory.Integrable f μ

full_name: MeasureTheory.Integrable.measure_norm_ge_lt_top
code: /-- A non-quantitative version of Markov inequality for integrable functions: the measure of points
where `‖f x‖ ≥ ε` is finite for all positive `ε`. -/
theorem Integrable.measure_norm_ge_lt_top {f : α → β} (hf : Integrable f μ) {ε : ℝ} (hε : 0 < ε) :
    μ { x | ε ≤ ‖f x‖ } < ∞ 
goal: μ {x | ε ≤ ‖f x‖} < ⊤

full_name: MeasureTheory.Integrable.measure_norm_gt_lt_top
code: /-- A non-quantitative version of Markov inequality for integrable functions: the measure of points
where `‖f x‖ > ε` is finite for all positive `ε`. -/
lemma Integrable.measure_norm_gt_lt_top {f : α → β} (hf : Integrable f μ) {ε : ℝ} (hε : 0 < ε) :
    μ {x | ε < ‖f x‖} < ∞ 
goal: μ {x | ε < ‖f x‖} < ⊤

full_name: MeasureTheory.Integrable.measure_ge_lt_top
code: /-- If `f` is `ℝ`-valued and integrable, then for any `c > 0` the set `{x | f x ≥ c}` has finite
measure. -/
lemma Integrable.measure_ge_lt_top {f : α → ℝ} (hf : Integrable f μ) {ε : ℝ} (ε_pos : 0 < ε) :
    μ {a : α | ε ≤ f a} < ∞ 
goal: μ {a | ε ≤ f a} < ⊤

full_name: MeasureTheory.Integrable.measure_le_lt_top
code: /-- If `f` is `ℝ`-valued and integrable, then for any `c < 0` the set `{x | f x ≤ c}` has finite
measure. -/
lemma Integrable.measure_le_lt_top {f : α → ℝ} (hf : Integrable f μ) {c : ℝ} (c_neg : c < 0) :
    μ {a : α | f a ≤ c} < ∞ 
goal: μ {a | f a ≤ c} < ⊤

full_name: MeasureTheory.Integrable.measure_gt_lt_top
code: /-- If `f` is `ℝ`-valued and integrable, then for any `c > 0` the set `{x | f x > c}` has finite
measure. -/
lemma Integrable.measure_gt_lt_top {f : α → ℝ} (hf : Integrable f μ) {ε : ℝ} (ε_pos : 0 < ε) :
    μ {a : α | ε < f a} < ∞ 
goal: μ {a | ε < f a} < ⊤

full_name: MeasureTheory.Integrable.measure_lt_lt_top
code: /-- If `f` is `ℝ`-valued and integrable, then for any `c < 0` the set `{x | f x < c}` has finite
measure. -/
lemma Integrable.measure_lt_lt_top {f : α → ℝ} (hf : Integrable f μ) {c : ℝ} (c_neg : c < 0) :
    μ {a : α | f a < c} < ∞ 
goal: μ {a | f a < c} < ⊤

full_name: MeasureTheory.LipschitzWith.integrable_comp_iff_of_antilipschitz
code: theorem LipschitzWith.integrable_comp_iff_of_antilipschitz {K K'} {f : α → β} {g : β → γ}
    (hg : LipschitzWith K g) (hg' : AntilipschitzWith K' g) (g0 : g 0 = 0) :
    Integrable (g ∘ f) μ ↔ Integrable f μ 
goal: MeasureTheory.Integrable (g ∘ f) μ ↔ MeasureTheory.Integrable f μ

full_name: MeasureTheory.Integrable.real_toNNReal
code: theorem Integrable.real_toNNReal {f : α → ℝ} (hf : Integrable f μ) :
    Integrable (fun x => ((f x).toNNReal : ℝ)) μ 
goal: MeasureTheory.Integrable (fun x => ↑(f x).toNNReal) μ

full_name: MeasureTheory.ofReal_toReal_ae_eq
code: theorem ofReal_toReal_ae_eq {f : α → ℝ≥0∞} (hf : ∀ᵐ x ∂μ, f x < ∞) :
    (fun x => ENNReal.ofReal (f x).toReal) =ᵐ[μ] f 
goal: (fun x => ENNReal.ofReal (f x).toReal) =ᵐ[μ] f

full_name: MeasureTheory.coe_toNNReal_ae_eq
code: theorem coe_toNNReal_ae_eq {f : α → ℝ≥0∞} (hf : ∀ᵐ x ∂μ, f x < ∞) :
    (fun x => ((f x).toNNReal : ℝ≥0∞)) =ᵐ[μ] f 
goal: (fun x => ↑(f x).toNNReal) =ᵐ[μ] f

full_name: MeasureTheory.hasFiniteIntegral_count_iff
code: /-- A function has finite integral for the counting measure iff its norm is summable. -/
lemma hasFiniteIntegral_count_iff :
    HasFiniteIntegral f Measure.count ↔ Summable (‖f ·‖) 
goal: MeasureTheory.HasFiniteIntegral f MeasureTheory.Measure.count ↔ Summable fun x => ‖f x‖

full_name: MeasureTheory.integrable_count_iff
code: /-- A function is integrable for the counting measure iff its norm is summable. -/
lemma integrable_count_iff :
    Integrable f Measure.count ↔ Summable (‖f ·‖) 
goal: MeasureTheory.Integrable f MeasureTheory.Measure.count ↔ Summable fun x => ‖f x‖

full_name: MeasureTheory.integrable_withDensity_iff_integrable_coe_smul
code: theorem integrable_withDensity_iff_integrable_coe_smul {f : α → ℝ≥0} (hf : Measurable f)
    {g : α → E} :
    Integrable g (μ.withDensity fun x => f x) ↔ Integrable (fun x => (f x : ℝ) • g x) μ 
goal: MeasureTheory.Integrable g (μ.withDensity fun x => ↑(f x)) ↔ MeasureTheory.Integrable (fun x => ↑(f x) • g x) μ

full_name: MeasureTheory.integrable_withDensity_iff_integrable_smul
code: theorem integrable_withDensity_iff_integrable_smul {f : α → ℝ≥0} (hf : Measurable f) {g : α → E} :
    Integrable g (μ.withDensity fun x => f x) ↔ Integrable (fun x => f x • g x) μ 
goal: MeasureTheory.Integrable g (μ.withDensity fun x => ↑(f x)) ↔ MeasureTheory.Integrable (fun x => f x • g x) μ

full_name: MeasureTheory.integrable_withDensity_iff_integrable_smul'
code: theorem integrable_withDensity_iff_integrable_smul' {f : α → ℝ≥0∞} (hf : Measurable f)
    (hflt : ∀ᵐ x ∂μ, f x < ∞) {g : α → E} :
    Integrable g (μ.withDensity f) ↔ Integrable (fun x => (f x).toReal • g x) μ 
goal: MeasureTheory.Integrable g (μ.withDensity f) ↔ MeasureTheory.Integrable (fun x => (f x).toReal • g x) μ

full_name: MeasureTheory.integrable_withDensity_iff_integrable_coe_smul₀
code: theorem integrable_withDensity_iff_integrable_coe_smul₀ {f : α → ℝ≥0} (hf : AEMeasurable f μ)
    {g : α → E} :
    Integrable g (μ.withDensity fun x => f x) ↔ Integrable (fun x => (f x : ℝ) • g x) μ 
goal: MeasureTheory.Integrable g (μ.withDensity fun x => ↑(f x)) ↔ MeasureTheory.Integrable (fun x => ↑(f x) • g x) μ

full_name: MeasureTheory.integrable_withDensity_iff_integrable_smul₀
code: theorem integrable_withDensity_iff_integrable_smul₀ {f : α → ℝ≥0} (hf : AEMeasurable f μ)
    {g : α → E} : Integrable g (μ.withDensity fun x => f x) ↔ Integrable (fun x => f x • g x) μ 
goal: MeasureTheory.Integrable g (μ.withDensity fun x => ↑(f x)) ↔ MeasureTheory.Integrable (fun x => f x • g x) μ

full_name: MeasureTheory.integrable_withDensity_iff
code: theorem integrable_withDensity_iff {f : α → ℝ≥0∞} (hf : Measurable f) (hflt : ∀ᵐ x ∂μ, f x < ∞)
    {g : α → ℝ} : Integrable g (μ.withDensity f) ↔ Integrable (fun x => g x * (f x).toReal) μ 
goal: MeasureTheory.Integrable g (μ.withDensity f) ↔ MeasureTheory.Integrable (fun x => g x * (f x).toReal) μ

full_name: MeasureTheory.memℒ1_smul_of_L1_withDensity
code: theorem memℒ1_smul_of_L1_withDensity {f : α → ℝ≥0} (f_meas : Measurable f)
    (u : Lp E 1 (μ.withDensity fun x => f x)) : Memℒp (fun x => f x • u x) 1 μ 
goal: MeasureTheory.Memℒp (fun x => f x • ↑↑u x) 1 μ

full_name: MeasureTheory.withDensitySMulLI
code: /-- The map `u ↦ f • u` is an isometry between the `L^1` spaces for `μ.withDensity f` and `μ`. -/
noncomputable def withDensitySMulLI {f : α → ℝ≥0} (f_meas : Measurable f) :
    Lp E 1 (μ.withDensity fun x => f x) →ₗᵢ[ℝ] Lp E 1 μ 
goal: ↥(MeasureTheory.Lp E 1 (μ.withDensity fun x => ↑(f x))) →ₗᵢ[ℝ] ↥(MeasureTheory.Lp E 1 μ)

full_name: MeasureTheory.withDensitySMulLI_apply
code: @[simp]
theorem withDensitySMulLI_apply {f : α → ℝ≥0} (f_meas : Measurable f)
    (u : Lp E 1 (μ.withDensity fun x => f x)) :
    withDensitySMulLI μ (E := E) f_meas u =
      (memℒ1_smul_of_L1_withDensity f_meas u).toLp fun x => f x • u x 
goal: (MeasureTheory.withDensitySMulLI μ f_meas) u = MeasureTheory.Memℒp.toLp (fun x => f x • ↑↑u x) ⋯

full_name: MeasureTheory.mem_ℒ1_toReal_of_lintegral_ne_top
code: theorem mem_ℒ1_toReal_of_lintegral_ne_top {f : α → ℝ≥0∞} (hfm : AEMeasurable f μ)
    (hfi : (∫⁻ x, f x ∂μ) ≠ ∞) : Memℒp (fun x => (f x).toReal) 1 μ 
goal: MeasureTheory.Memℒp (fun x => (f x).toReal) 1 μ

full_name: MeasureTheory.integrable_toReal_of_lintegral_ne_top
code: theorem integrable_toReal_of_lintegral_ne_top {f : α → ℝ≥0∞} (hfm : AEMeasurable f μ)
    (hfi : (∫⁻ x, f x ∂μ) ≠ ∞) : Integrable (fun x => (f x).toReal) μ 
goal: MeasureTheory.Integrable (fun x => (f x).toReal) μ

full_name: MeasureTheory.Integrable.pos_part
code: theorem Integrable.pos_part {f : α → ℝ} (hf : Integrable f μ) :
    Integrable (fun a => max (f a) 0) μ 
goal: MeasureTheory.Integrable (fun a => max (f a) 0) μ

full_name: MeasureTheory.Integrable.neg_part
code: theorem Integrable.neg_part {f : α → ℝ} (hf : Integrable f μ) :
    Integrable (fun a => max (-f a) 0) μ 
goal: MeasureTheory.Integrable (fun a => max (-f a) 0) μ

full_name: MeasureTheory.Integrable.smul
code: theorem Integrable.smul [NormedAddCommGroup 𝕜] [SMulZeroClass 𝕜 β] [BoundedSMul 𝕜 β] (c : 𝕜)
    {f : α → β} (hf : Integrable f μ) : Integrable (c • f) μ 
goal: MeasureTheory.Integrable (c • f) μ

full_name: IsUnit.integrable_smul_iff
code: theorem _root_.IsUnit.integrable_smul_iff [NormedRing 𝕜] [Module 𝕜 β] [BoundedSMul 𝕜 β] {c : 𝕜}
    (hc : IsUnit c) (f : α → β) : Integrable (c • f) μ ↔ Integrable f μ 
goal: MeasureTheory.Integrable (c • f) μ ↔ MeasureTheory.Integrable f μ

full_name: MeasureTheory.integrable_smul_iff
code: theorem integrable_smul_iff [NormedDivisionRing 𝕜] [Module 𝕜 β] [BoundedSMul 𝕜 β] {c : 𝕜}
    (hc : c ≠ 0) (f : α → β) : Integrable (c • f) μ ↔ Integrable f μ 
goal: MeasureTheory.Integrable (c • f) μ ↔ MeasureTheory.Integrable f μ

full_name: MeasureTheory.Integrable.smul_of_top_right
code: theorem Integrable.smul_of_top_right {f : α → β} {φ : α → 𝕜} (hf : Integrable f μ)
    (hφ : Memℒp φ ∞ μ) : Integrable (φ • f) μ 
goal: MeasureTheory.Integrable (φ • f) μ

full_name: MeasureTheory.Integrable.smul_of_top_left
code: theorem Integrable.smul_of_top_left {f : α → β} {φ : α → 𝕜} (hφ : Integrable φ μ)
    (hf : Memℒp f ∞ μ) : Integrable (φ • f) μ 
goal: MeasureTheory.Integrable (φ • f) μ

full_name: MeasureTheory.Integrable.smul_const
code: theorem Integrable.smul_const {f : α → 𝕜} (hf : Integrable f μ) (c : β) :
    Integrable (fun x => f x • c) μ 
goal: MeasureTheory.Integrable (fun x => f x • c) μ

full_name: MeasureTheory.integrable_smul_const
code: theorem integrable_smul_const {f : α → 𝕜} {c : E} (hc : c ≠ 0) :
    Integrable (fun x => f x • c) μ ↔ Integrable f μ 
goal: MeasureTheory.Integrable (fun x => f x • c) μ ↔ MeasureTheory.Integrable f μ

full_name: MeasureTheory.Integrable.const_mul
code: theorem Integrable.const_mul {f : α → 𝕜} (h : Integrable f μ) (c : 𝕜) :
    Integrable (fun x => c * f x) μ 
goal: MeasureTheory.Integrable (fun x => c * f x) μ

full_name: MeasureTheory.Integrable.const_mul'
code: theorem Integrable.const_mul' {f : α → 𝕜} (h : Integrable f μ) (c : 𝕜) :
    Integrable ((fun _ : α => c) * f) μ 
goal: MeasureTheory.Integrable ((fun x => c) * f) μ

full_name: MeasureTheory.Integrable.mul_const
code: theorem Integrable.mul_const {f : α → 𝕜} (h : Integrable f μ) (c : 𝕜) :
    Integrable (fun x => f x * c) μ 
goal: MeasureTheory.Integrable (fun x => f x * c) μ

full_name: MeasureTheory.Integrable.mul_const'
code: theorem Integrable.mul_const' {f : α → 𝕜} (h : Integrable f μ) (c : 𝕜) :
    Integrable (f * fun _ : α => c) μ 
goal: MeasureTheory.Integrable (f * fun x => c) μ

full_name: MeasureTheory.integrable_const_mul_iff
code: theorem integrable_const_mul_iff {c : 𝕜} (hc : IsUnit c) (f : α → 𝕜) :
    Integrable (fun x => c * f x) μ ↔ Integrable f μ 
goal: MeasureTheory.Integrable (fun x => c * f x) μ ↔ MeasureTheory.Integrable f μ

full_name: MeasureTheory.integrable_mul_const_iff
code: theorem integrable_mul_const_iff {c : 𝕜} (hc : IsUnit c) (f : α → 𝕜) :
    Integrable (fun x => f x * c) μ ↔ Integrable f μ 
goal: MeasureTheory.Integrable (fun x => f x * c) μ ↔ MeasureTheory.Integrable f μ

full_name: MeasureTheory.Integrable.bdd_mul'
code: theorem Integrable.bdd_mul' {f g : α → 𝕜} {c : ℝ} (hg : Integrable g μ)
    (hf : AEStronglyMeasurable f μ) (hf_bound : ∀ᵐ x ∂μ, ‖f x‖ ≤ c) :
    Integrable (fun x => f x * g x) μ 
goal: MeasureTheory.Integrable (fun x => f x * g x) μ

full_name: MeasureTheory.Integrable.div_const
code: theorem Integrable.div_const {f : α → 𝕜} (h : Integrable f μ) (c : 𝕜) :
    Integrable (fun x => f x / c) μ 
goal: MeasureTheory.Integrable (fun x => f x / c) μ

full_name: MeasureTheory.Integrable.ofReal
code: theorem Integrable.ofReal {f : α → ℝ} (hf : Integrable f μ) :
    Integrable (fun x => (f x : 𝕜)) μ 
goal: MeasureTheory.Integrable (fun x => ↑(f x)) μ

full_name: MeasureTheory.Integrable.re_im_iff
code: theorem Integrable.re_im_iff :
    Integrable (fun x => RCLike.re (f x)) μ ∧ Integrable (fun x => RCLike.im (f x)) μ ↔
      Integrable f μ 
goal: MeasureTheory.Integrable (fun x => RCLike.re (f x)) μ ∧ MeasureTheory.Integrable (fun x => RCLike.im (f x)) μ ↔
  MeasureTheory.Integrable f μ

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

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

full_name: MeasureTheory.Integrable.trim
code: theorem Integrable.trim (hm : m ≤ m0) (hf_int : Integrable f μ') (hf : StronglyMeasurable[m] f) :
    Integrable f (μ'.trim hm) 
goal: MeasureTheory.Integrable f (μ'.trim hm)

full_name: MeasureTheory.integrable_of_integrable_trim
code: theorem integrable_of_integrable_trim (hm : m ≤ m0) (hf_int : Integrable f (μ'.trim hm)) :
    Integrable f μ' 
goal: MeasureTheory.Integrable f μ'

full_name: MeasureTheory.integrable_of_forall_fin_meas_le'
code: theorem integrable_of_forall_fin_meas_le' {μ : Measure α} (hm : m ≤ m0) [SigmaFinite (μ.trim hm)]
    (C : ℝ≥0∞) (hC : C < ∞) {f : α → E} (hf_meas : AEStronglyMeasurable f μ)
    (hf : ∀ s, MeasurableSet[m] s → μ s ≠ ∞ → (∫⁻ x in s, ‖f x‖₊ ∂μ) ≤ C) : Integrable f μ 
goal: MeasureTheory.Integrable f μ

full_name: MeasureTheory.integrable_of_forall_fin_meas_le
code: theorem integrable_of_forall_fin_meas_le [SigmaFinite μ] (C : ℝ≥0∞) (hC : C < ∞) {f : α → E}
    (hf_meas : AEStronglyMeasurable f μ)
    (hf : ∀ s : Set α, MeasurableSet[m] s → μ s ≠ ∞ → (∫⁻ x in s, ‖f x‖₊ ∂μ) ≤ C) :
    Integrable f μ 
goal: MeasureTheory.Integrable f μ

full_name: MeasureTheory.AEEqFun.Integrable
code: /-- A class of almost everywhere equal functions is `Integrable` if its function representative
is integrable. -/
def Integrable (f : α →ₘ[μ] β) : Prop 
goal: Prop

full_name: MeasureTheory.AEEqFun.integrable_mk
code: theorem integrable_mk {f : α → β} (hf : AEStronglyMeasurable f μ) :
    Integrable (mk f hf : α →ₘ[μ] β) ↔ MeasureTheory.Integrable f μ 
goal: (MeasureTheory.AEEqFun.mk f hf).Integrable ↔ MeasureTheory.Integrable f μ

full_name: MeasureTheory.AEEqFun.integrable_coeFn
code: theorem integrable_coeFn {f : α →ₘ[μ] β} : MeasureTheory.Integrable f μ ↔ Integrable f 
goal: MeasureTheory.Integrable (↑f) μ ↔ f.Integrable

full_name: MeasureTheory.AEEqFun.integrable_zero
code: theorem integrable_zero : Integrable (0 : α →ₘ[μ] β) 
goal: MeasureTheory.AEEqFun.Integrable 0

full_name: MeasureTheory.AEEqFun.Integrable.neg
code: theorem Integrable.neg {f : α →ₘ[μ] β} : Integrable f → Integrable (-f) 
goal: f.Integrable → (-f).Integrable

full_name: MeasureTheory.AEEqFun.integrable_iff_mem_L1
code: theorem integrable_iff_mem_L1 {f : α →ₘ[μ] β} : Integrable f ↔ f ∈ (α →₁[μ] β) 
goal: f.Integrable ↔ f ∈ MeasureTheory.Lp β 1 μ

full_name: MeasureTheory.AEEqFun.Integrable.add
code: theorem Integrable.add {f g : α →ₘ[μ] β} : Integrable f → Integrable g → Integrable (f + g) 
goal: f.Integrable → g.Integrable → (f + g).Integrable

full_name: MeasureTheory.AEEqFun.Integrable.sub
code: theorem Integrable.sub {f g : α →ₘ[μ] β} (hf : Integrable f) (hg : Integrable g) :
    Integrable (f - g) 
goal: (f - g).Integrable

full_name: MeasureTheory.AEEqFun.Integrable.smul
code: theorem Integrable.smul {c : 𝕜} {f : α →ₘ[μ] β} : Integrable f → Integrable (c • f) 
goal: f.Integrable → (c • f).Integrable

full_name: MeasureTheory.L1.integrable_coeFn
code: theorem integrable_coeFn (f : α →₁[μ] β) : Integrable f μ 
goal: MeasureTheory.Integrable (↑↑f) μ

full_name: MeasureTheory.L1.hasFiniteIntegral_coeFn
code: theorem hasFiniteIntegral_coeFn (f : α →₁[μ] β) : HasFiniteIntegral f μ 
goal: MeasureTheory.HasFiniteIntegral (↑↑f) μ

full_name: MeasureTheory.L1.stronglyMeasurable_coeFn
code: theorem stronglyMeasurable_coeFn (f : α →₁[μ] β) : StronglyMeasurable f 
goal: MeasureTheory.StronglyMeasurable ↑↑f

full_name: MeasureTheory.L1.measurable_coeFn
code: theorem measurable_coeFn [MeasurableSpace β] [BorelSpace β] (f : α →₁[μ] β) : Measurable f 
goal: Measurable ↑↑f

full_name: MeasureTheory.L1.aestronglyMeasurable_coeFn
code: theorem aestronglyMeasurable_coeFn (f : α →₁[μ] β) : AEStronglyMeasurable f μ 
goal: MeasureTheory.AEStronglyMeasurable (↑↑f) μ

full_name: MeasureTheory.L1.aemeasurable_coeFn
code: theorem aemeasurable_coeFn [MeasurableSpace β] [BorelSpace β] (f : α →₁[μ] β) : AEMeasurable f μ 
goal: AEMeasurable (↑↑f) μ

full_name: MeasureTheory.L1.edist_def
code: theorem edist_def (f g : α →₁[μ] β) : edist f g = ∫⁻ a, edist (f a) (g a) ∂μ 
goal: edist f g = ∫⁻ (a : α), edist (↑↑f a) (↑↑g a) ∂μ

full_name: MeasureTheory.L1.dist_def
code: theorem dist_def (f g : α →₁[μ] β) : dist f g = (∫⁻ a, edist (f a) (g a) ∂μ).toReal 
goal: dist f g = (∫⁻ (a : α), edist (↑↑f a) (↑↑g a) ∂μ).toReal

full_name: MeasureTheory.L1.norm_def
code: theorem norm_def (f : α →₁[μ] β) : ‖f‖ = (∫⁻ a, ‖f a‖₊ ∂μ).toReal 
goal: ‖f‖ = (∫⁻ (a : α), ↑‖↑↑f a‖₊ ∂μ).toReal

full_name: MeasureTheory.L1.norm_sub_eq_lintegral
code: /-- Computing the norm of a difference between two L¹-functions. Note that this is not a
  special case of `norm_def` since `(f - g) x` and `f x - g x` are not equal
  (but only a.e.-equal). -/
theorem norm_sub_eq_lintegral (f g : α →₁[μ] β) :
    ‖f - g‖ = (∫⁻ x, (‖f x - g x‖₊ : ℝ≥0∞) ∂μ).toReal 
goal: ‖f - g‖ = (∫⁻ (x : α), ↑‖↑↑f x - ↑↑g x‖₊ ∂μ).toReal

full_name: MeasureTheory.L1.ofReal_norm_eq_lintegral
code: theorem ofReal_norm_eq_lintegral (f : α →₁[μ] β) :
    ENNReal.ofReal ‖f‖ = ∫⁻ x, (‖f x‖₊ : ℝ≥0∞) ∂μ 
goal: ENNReal.ofReal ‖f‖ = ∫⁻ (x : α), ↑‖↑↑f x‖₊ ∂μ

full_name: MeasureTheory.L1.ofReal_norm_sub_eq_lintegral
code: /-- Computing the norm of a difference between two L¹-functions. Note that this is not a
  special case of `ofReal_norm_eq_lintegral` since `(f - g) x` and `f x - g x` are not equal
  (but only a.e.-equal). -/
theorem ofReal_norm_sub_eq_lintegral (f g : α →₁[μ] β) :
    ENNReal.ofReal ‖f - g‖ = ∫⁻ x, (‖f x - g x‖₊ : ℝ≥0∞) ∂μ 
goal: ENNReal.ofReal ‖f - g‖ = ∫⁻ (x : α), ↑‖↑↑f x - ↑↑g x‖₊ ∂μ

full_name: MeasureTheory.Integrable.toL1
code: /-- Construct the equivalence class `[f]` of an integrable function `f`, as a member of the
space `L1 β 1 μ`. -/
def toL1 (f : α → β) (hf : Integrable f μ) : α →₁[μ] β 
goal: ↥(MeasureTheory.Lp β 1 μ)

full_name: MeasureTheory.Integrable.toL1_coeFn
code: @[simp]
theorem toL1_coeFn (f : α →₁[μ] β) (hf : Integrable f μ) : hf.toL1 f = f 
goal: MeasureTheory.Integrable.toL1 (↑↑f) hf = f

full_name: MeasureTheory.Integrable.coeFn_toL1
code: theorem coeFn_toL1 {f : α → β} (hf : Integrable f μ) : hf.toL1 f =ᵐ[μ] f 
goal: ↑↑(MeasureTheory.Integrable.toL1 f hf) =ᵐ[μ] f

full_name: MeasureTheory.Integrable.toL1_zero
code: @[simp]
theorem toL1_zero (h : Integrable (0 : α → β) μ) : h.toL1 0 = 0 
goal: MeasureTheory.Integrable.toL1 0 h = 0

full_name: MeasureTheory.Integrable.toL1_eq_mk
code: @[simp]
theorem toL1_eq_mk (f : α → β) (hf : Integrable f μ) :
    (hf.toL1 f : α →ₘ[μ] β) = AEEqFun.mk f hf.aestronglyMeasurable 
goal: ↑(MeasureTheory.Integrable.toL1 f hf) = MeasureTheory.AEEqFun.mk f ⋯

full_name: MeasureTheory.Integrable.toL1_eq_toL1_iff
code: @[simp]
theorem toL1_eq_toL1_iff (f g : α → β) (hf : Integrable f μ) (hg : Integrable g μ) :
    toL1 f hf = toL1 g hg ↔ f =ᵐ[μ] g 
goal: MeasureTheory.Integrable.toL1 f hf = MeasureTheory.Integrable.toL1 g hg ↔ f =ᵐ[μ] g

full_name: MeasureTheory.Integrable.toL1_add
code: theorem toL1_add (f g : α → β) (hf : Integrable f μ) (hg : Integrable g μ) :
    toL1 (f + g) (hf.add hg) = toL1 f hf + toL1 g hg 
goal: MeasureTheory.Integrable.toL1 (f + g) ⋯ = MeasureTheory.Integrable.toL1 f hf + MeasureTheory.Integrable.toL1 g hg

full_name: MeasureTheory.Integrable.toL1_neg
code: theorem toL1_neg (f : α → β) (hf : Integrable f μ) : toL1 (-f) (Integrable.neg hf) = -toL1 f hf 
goal: MeasureTheory.Integrable.toL1 (-f) ⋯ = -MeasureTheory.Integrable.toL1 f hf

full_name: MeasureTheory.Integrable.toL1_sub
code: theorem toL1_sub (f g : α → β) (hf : Integrable f μ) (hg : Integrable g μ) :
    toL1 (f - g) (hf.sub hg) = toL1 f hf - toL1 g hg 
goal: MeasureTheory.Integrable.toL1 (f - g) ⋯ = MeasureTheory.Integrable.toL1 f hf - MeasureTheory.Integrable.toL1 g hg

full_name: MeasureTheory.Integrable.norm_toL1
code: theorem norm_toL1 (f : α → β) (hf : Integrable f μ) :
    ‖hf.toL1 f‖ = ENNReal.toReal (∫⁻ a, edist (f a) 0 ∂μ) 
goal: ‖MeasureTheory.Integrable.toL1 f hf‖ = (∫⁻ (a : α), edist (f a) 0 ∂μ).toReal

full_name: MeasureTheory.Integrable.nnnorm_toL1
code: theorem nnnorm_toL1 {f : α → β} (hf : Integrable f μ) :
    (‖hf.toL1 f‖₊ : ℝ≥0∞) = ∫⁻ a, ‖f a‖₊ ∂μ 
goal: ↑‖MeasureTheory.Integrable.toL1 f hf‖₊ = ∫⁻ (a : α), ↑‖f a‖₊ ∂μ

full_name: MeasureTheory.Integrable.norm_toL1_eq_lintegral_norm
code: theorem norm_toL1_eq_lintegral_norm (f : α → β) (hf : Integrable f μ) :
    ‖hf.toL1 f‖ = ENNReal.toReal (∫⁻ a, ENNReal.ofReal ‖f a‖ ∂μ) 
goal: ‖MeasureTheory.Integrable.toL1 f hf‖ = (∫⁻ (a : α), ENNReal.ofReal ‖f a‖ ∂μ).toReal

full_name: MeasureTheory.Integrable.edist_toL1_toL1
code: @[simp]
theorem edist_toL1_toL1 (f g : α → β) (hf : Integrable f μ) (hg : Integrable g μ) :
    edist (hf.toL1 f) (hg.toL1 g) = ∫⁻ a, edist (f a) (g a) ∂μ 
goal: edist (MeasureTheory.Integrable.toL1 f hf) (MeasureTheory.Integrable.toL1 g hg) = ∫⁻ (a : α), edist (f a) (g a) ∂μ

full_name: MeasureTheory.Integrable.edist_toL1_zero
code: @[simp]
theorem edist_toL1_zero (f : α → β) (hf : Integrable f μ) :
    edist (hf.toL1 f) 0 = ∫⁻ a, edist (f a) 0 ∂μ 
goal: edist (MeasureTheory.Integrable.toL1 f hf) 0 = ∫⁻ (a : α), edist (f a) 0 ∂μ

full_name: MeasureTheory.Integrable.toL1_smul
code: theorem toL1_smul (f : α → β) (hf : Integrable f μ) (k : 𝕜) :
    toL1 (fun a => k • f a) (hf.smul k) = k • toL1 f hf 
goal: MeasureTheory.Integrable.toL1 (fun a => k • f a) ⋯ = k • MeasureTheory.Integrable.toL1 f hf

full_name: MeasureTheory.Integrable.toL1_smul'
code: theorem toL1_smul' (f : α → β) (hf : Integrable f μ) (k : 𝕜) :
    toL1 (k • f) (hf.smul k) = k • toL1 f hf 
goal: MeasureTheory.Integrable.toL1 (k • f) ⋯ = k • MeasureTheory.Integrable.toL1 f hf

full_name: MeasureTheory.HasFiniteIntegral.restrict
code: lemma HasFiniteIntegral.restrict (h : HasFiniteIntegral f μ) {s : Set α} :
    HasFiniteIntegral f (μ.restrict s) 
goal: MeasureTheory.HasFiniteIntegral f (μ.restrict s)

full_name: MeasureTheory.Integrable.restrict
code: lemma Integrable.restrict (f_intble : Integrable f μ) {s : Set α} :
    Integrable f (μ.restrict s) 
goal: MeasureTheory.Integrable f (μ.restrict s)

full_name: ContinuousLinearMap.integrable_comp
code: theorem ContinuousLinearMap.integrable_comp {φ : α → H} (L : H →L[𝕜] E) (φ_int : Integrable φ μ) :
    Integrable (fun a : α => L (φ a)) μ 
goal: MeasureTheory.Integrable (fun a => L (φ a)) μ

full_name: ContinuousLinearEquiv.integrable_comp_iff
code: @[simp]
theorem ContinuousLinearEquiv.integrable_comp_iff {φ : α → H} (L : H ≃L[𝕜] E) :
    Integrable (fun a : α ↦ L (φ a)) μ ↔ Integrable φ μ 
goal: MeasureTheory.Integrable (fun a => L (φ a)) μ ↔ MeasureTheory.Integrable φ μ

full_name: LinearIsometryEquiv.integrable_comp_iff
code: @[simp]
theorem LinearIsometryEquiv.integrable_comp_iff {φ : α → H} (L : H ≃ₗᵢ[𝕜] E) :
    Integrable (fun a : α ↦ L (φ a)) μ ↔ Integrable φ μ 
goal: MeasureTheory.Integrable (fun a => L (φ a)) μ ↔ MeasureTheory.Integrable φ μ

full_name: MeasureTheory.Integrable.apply_continuousLinearMap
code: theorem MeasureTheory.Integrable.apply_continuousLinearMap {φ : α → H →L[𝕜] E}
    (φ_int : Integrable φ μ) (v : H) : Integrable (fun a => φ a v) μ 
goal: MeasureTheory.Integrable (fun a => (φ a) v) μ

full_name: MeasureTheory.Integrable.fst
code: lemma Integrable.fst {f : α → E × F} (hf : Integrable f μ) : Integrable (fun x ↦ (f x).1) μ 
goal: MeasureTheory.Integrable (fun x => (f x).1) μ

full_name: MeasureTheory.Integrable.snd
code: lemma Integrable.snd {f : α → E × F} (hf : Integrable f μ) : Integrable (fun x ↦ (f x).2) μ 
goal: MeasureTheory.Integrable (fun x => (f x).2) μ

full_name: MeasureTheory.integrable_prod
code: lemma integrable_prod {f : α → E × F} :
    Integrable f μ ↔ Integrable (fun x ↦ (f x).1) μ ∧ Integrable (fun x ↦ (f x).2) μ 
goal: MeasureTheory.Integrable f μ ↔
  MeasureTheory.Integrable (fun x => (f x).1) μ ∧ MeasureTheory.Integrable (fun x => (f x).2) μ