File: Mathlib/MeasureTheory/Measure/WithDensity.lean

full_name: MeasureTheory.Measure.withDensity
code: /-- Given a measure `μ : Measure α` and a function `f : α → ℝ≥0∞`, `μ.withDensity f` is the
measure such that for a measurable set `s` we have `μ.withDensity f s = ∫⁻ a in s, f a ∂μ`. -/
noncomputable
def Measure.withDensity {m : MeasurableSpace α} (μ : Measure α) (f : α → ℝ≥0∞) : Measure α 
goal: MeasureTheory.Measure α

full_name: MeasureTheory.withDensity_apply
code: @[simp]
theorem withDensity_apply (f : α → ℝ≥0∞) {s : Set α} (hs : MeasurableSet s) :
    μ.withDensity f s = ∫⁻ a in s, f a ∂μ 
goal: (μ.withDensity f) s = ∫⁻ (a : α) in s, f a ∂μ

full_name: MeasureTheory.withDensity_apply_le
code: theorem withDensity_apply_le (f : α → ℝ≥0∞) (s : Set α) :
    ∫⁻ a in s, f a ∂μ ≤ μ.withDensity f s 
goal: ∫⁻ (a : α) in s, f a ∂μ ≤ (μ.withDensity f) s

full_name: MeasureTheory.withDensity_apply'
code: theorem withDensity_apply' [SFinite μ] (f : α → ℝ≥0∞) (s : Set α) :
    μ.withDensity f s = ∫⁻ a in s, f a ∂μ 
goal: (μ.withDensity f) s = ∫⁻ (a : α) in s, f a ∂μ

full_name: MeasureTheory.withDensity_zero_left
code: @[simp]
lemma withDensity_zero_left (f : α → ℝ≥0∞) : (0 : Measure α).withDensity f = 0 
goal: MeasureTheory.Measure.withDensity 0 f = 0

full_name: MeasureTheory.withDensity_congr_ae
code: theorem withDensity_congr_ae {f g : α → ℝ≥0∞} (h : f =ᵐ[μ] g) :
    μ.withDensity f = μ.withDensity g 
goal: μ.withDensity f = μ.withDensity g

full_name: MeasureTheory.withDensity_mono
code: lemma withDensity_mono {f g : α → ℝ≥0∞} (hfg : f ≤ᵐ[μ] g) :
    μ.withDensity f ≤ μ.withDensity g 
goal: μ.withDensity f ≤ μ.withDensity g

full_name: MeasureTheory.withDensity_add_left
code: theorem withDensity_add_left {f : α → ℝ≥0∞} (hf : Measurable f) (g : α → ℝ≥0∞) :
    μ.withDensity (f + g) = μ.withDensity f + μ.withDensity g 
goal: μ.withDensity (f + g) = μ.withDensity f + μ.withDensity g

full_name: MeasureTheory.withDensity_add_right
code: theorem withDensity_add_right (f : α → ℝ≥0∞) {g : α → ℝ≥0∞} (hg : Measurable g) :
    μ.withDensity (f + g) = μ.withDensity f + μ.withDensity g 
goal: μ.withDensity (f + g) = μ.withDensity f + μ.withDensity g

full_name: MeasureTheory.withDensity_add_measure
code: theorem withDensity_add_measure {m : MeasurableSpace α} (μ ν : Measure α) (f : α → ℝ≥0∞) :
    (μ + ν).withDensity f = μ.withDensity f + ν.withDensity f 
goal: (μ + ν).withDensity f = μ.withDensity f + ν.withDensity f

full_name: MeasureTheory.withDensity_sum
code: theorem withDensity_sum {ι : Type*} {m : MeasurableSpace α} (μ : ι → Measure α) (f : α → ℝ≥0∞) :
    (sum μ).withDensity f = sum fun n => (μ n).withDensity f 
goal: (MeasureTheory.Measure.sum μ).withDensity f = MeasureTheory.Measure.sum fun n => (μ n).withDensity f

full_name: MeasureTheory.withDensity_smul
code: theorem withDensity_smul (r : ℝ≥0∞) {f : α → ℝ≥0∞} (hf : Measurable f) :
    μ.withDensity (r • f) = r • μ.withDensity f 
goal: μ.withDensity (r • f) = r • μ.withDensity f

full_name: MeasureTheory.withDensity_smul'
code: theorem withDensity_smul' (r : ℝ≥0∞) (f : α → ℝ≥0∞) (hr : r ≠ ∞) :
    μ.withDensity (r • f) = r • μ.withDensity f 
goal: μ.withDensity (r • f) = r • μ.withDensity f

full_name: MeasureTheory.withDensity_smul_measure
code: theorem withDensity_smul_measure (r : ℝ≥0∞) (f : α → ℝ≥0∞) :
    (r • μ).withDensity f = r • μ.withDensity f 
goal: (r • μ).withDensity f = r • μ.withDensity f

full_name: MeasureTheory.isFiniteMeasure_withDensity
code: theorem isFiniteMeasure_withDensity {f : α → ℝ≥0∞} (hf : ∫⁻ a, f a ∂μ ≠ ∞) :
    IsFiniteMeasure (μ.withDensity f) 
goal: MeasureTheory.IsFiniteMeasure (μ.withDensity f)

full_name: MeasureTheory.withDensity_absolutelyContinuous
code: theorem withDensity_absolutelyContinuous {m : MeasurableSpace α} (μ : Measure α) (f : α → ℝ≥0∞) :
    μ.withDensity f ≪ μ 
goal: (μ.withDensity f).AbsolutelyContinuous μ

full_name: MeasureTheory.withDensity_zero
code: @[simp]
theorem withDensity_zero : μ.withDensity 0 = 0 
goal: μ.withDensity 0 = 0

full_name: MeasureTheory.withDensity_one
code: @[simp]
theorem withDensity_one : μ.withDensity 1 = μ 
goal: μ.withDensity 1 = μ

full_name: MeasureTheory.withDensity_const
code: @[simp]
theorem withDensity_const (c : ℝ≥0∞) : μ.withDensity (fun _ ↦ c) = c • μ 
goal: (μ.withDensity fun x => c) = c • μ

full_name: MeasureTheory.withDensity_tsum
code: theorem withDensity_tsum {ι : Type*} [Countable ι] {f : ι → α → ℝ≥0∞} (h : ∀ i, Measurable (f i)) :
    μ.withDensity (∑' n, f n) = sum fun n => μ.withDensity (f n) 
goal: μ.withDensity (∑' (n : ι), f n) = MeasureTheory.Measure.sum fun n => μ.withDensity (f n)

full_name: MeasureTheory.withDensity_indicator
code: theorem withDensity_indicator {s : Set α} (hs : MeasurableSet s) (f : α → ℝ≥0∞) :
    μ.withDensity (s.indicator f) = (μ.restrict s).withDensity f 
goal: μ.withDensity (s.indicator f) = (μ.restrict s).withDensity f

full_name: MeasureTheory.withDensity_indicator_one
code: theorem withDensity_indicator_one {s : Set α} (hs : MeasurableSet s) :
    μ.withDensity (s.indicator 1) = μ.restrict s 
goal: μ.withDensity (s.indicator 1) = μ.restrict s

full_name: MeasureTheory.withDensity_ofReal_mutuallySingular
code: theorem withDensity_ofReal_mutuallySingular {f : α → ℝ} (hf : Measurable f) :
    (μ.withDensity fun x => ENNReal.ofReal <| f x) ⟂ₘ
      μ.withDensity fun x => ENNReal.ofReal <| -f x 
goal: (μ.withDensity fun x => ENNReal.ofReal (f x)).MutuallySingular (μ.withDensity fun x => ENNReal.ofReal (-f x))

full_name: MeasureTheory.restrict_withDensity
code: theorem restrict_withDensity {s : Set α} (hs : MeasurableSet s) (f : α → ℝ≥0∞) :
    (μ.withDensity f).restrict s = (μ.restrict s).withDensity f 
goal: (μ.withDensity f).restrict s = (μ.restrict s).withDensity f

full_name: MeasureTheory.restrict_withDensity'
code: theorem restrict_withDensity' [SFinite μ] (s : Set α) (f : α → ℝ≥0∞) :
    (μ.withDensity f).restrict s = (μ.restrict s).withDensity f 
goal: (μ.withDensity f).restrict s = (μ.restrict s).withDensity f

full_name: MeasureTheory.trim_withDensity
code: lemma trim_withDensity {m m0 : MeasurableSpace α} {μ : Measure α}
    (hm : m ≤ m0) {f : α → ℝ≥0∞} (hf : Measurable[m] f) :
    (μ.withDensity f).trim hm = (μ.trim hm).withDensity f 
goal: (μ.withDensity f).trim hm = (μ.trim hm).withDensity f

full_name: MeasureTheory.Measure.MutuallySingular.withDensity
code: lemma Measure.MutuallySingular.withDensity {ν : Measure α} {f : α → ℝ≥0∞} (h : μ ⟂ₘ ν) :
    μ.withDensity f ⟂ₘ ν 
goal: (μ.withDensity f).MutuallySingular ν

full_name: MeasureTheory.withDensity_eq_zero_iff
code: @[simp]
theorem withDensity_eq_zero_iff {f : α → ℝ≥0∞} (hf : AEMeasurable f μ) :
    μ.withDensity f = 0 ↔ f =ᵐ[μ] 0 
goal: μ.withDensity f = 0 ↔ f =ᵐ[μ] 0

full_name: MeasureTheory.withDensity_apply_eq_zero'
code: theorem withDensity_apply_eq_zero' {f : α → ℝ≥0∞} {s : Set α} (hf : AEMeasurable f μ) :
    μ.withDensity f s = 0 ↔ μ ({ x | f x ≠ 0 } ∩ s) = 0 
goal: (μ.withDensity f) s = 0 ↔ μ ({x | f x ≠ 0} ∩ s) = 0

full_name: MeasureTheory.withDensity_apply_eq_zero
code: theorem withDensity_apply_eq_zero {f : α → ℝ≥0∞} {s : Set α} (hf : Measurable f) :
    μ.withDensity f s = 0 ↔ μ ({ x | f x ≠ 0 } ∩ s) = 0 
goal: (μ.withDensity f) s = 0 ↔ μ ({x | f x ≠ 0} ∩ s) = 0

full_name: MeasureTheory.ae_withDensity_iff'
code: theorem ae_withDensity_iff' {p : α → Prop} {f : α → ℝ≥0∞} (hf : AEMeasurable f μ) :
    (∀ᵐ x ∂μ.withDensity f, p x) ↔ ∀ᵐ x ∂μ, f x ≠ 0 → p x 
goal: (∀ᵐ (x : α) ∂μ.withDensity f, p x) ↔ ∀ᵐ (x : α) ∂μ, f x ≠ 0 → p x

full_name: MeasureTheory.ae_withDensity_iff
code: theorem ae_withDensity_iff {p : α → Prop} {f : α → ℝ≥0∞} (hf : Measurable f) :
    (∀ᵐ x ∂μ.withDensity f, p x) ↔ ∀ᵐ x ∂μ, f x ≠ 0 → p x 
goal: (∀ᵐ (x : α) ∂μ.withDensity f, p x) ↔ ∀ᵐ (x : α) ∂μ, f x ≠ 0 → p x

full_name: MeasureTheory.ae_withDensity_iff_ae_restrict'
code: theorem ae_withDensity_iff_ae_restrict' {p : α → Prop} {f : α → ℝ≥0∞}
    (hf : AEMeasurable f μ) :
    (∀ᵐ x ∂μ.withDensity f, p x) ↔ ∀ᵐ x ∂μ.restrict { x | f x ≠ 0 }, p x 
goal: (∀ᵐ (x : α) ∂μ.withDensity f, p x) ↔ ∀ᵐ (x : α) ∂μ.restrict {x | f x ≠ 0}, p x

full_name: MeasureTheory.ae_withDensity_iff_ae_restrict
code: theorem ae_withDensity_iff_ae_restrict {p : α → Prop} {f : α → ℝ≥0∞} (hf : Measurable f) :
    (∀ᵐ x ∂μ.withDensity f, p x) ↔ ∀ᵐ x ∂μ.restrict { x | f x ≠ 0 }, p x 
goal: (∀ᵐ (x : α) ∂μ.withDensity f, p x) ↔ ∀ᵐ (x : α) ∂μ.restrict {x | f x ≠ 0}, p x

full_name: MeasureTheory.aemeasurable_withDensity_ennreal_iff'
code: theorem aemeasurable_withDensity_ennreal_iff' {f : α → ℝ≥0}
    (hf : AEMeasurable f μ) {g : α → ℝ≥0∞} :
    AEMeasurable g (μ.withDensity fun x => (f x : ℝ≥0∞)) ↔
      AEMeasurable (fun x => (f x : ℝ≥0∞) * g x) μ 
goal: AEMeasurable g (μ.withDensity fun x => ↑(f x)) ↔ AEMeasurable (fun x => ↑(f x) * g x) μ

full_name: MeasureTheory.aemeasurable_withDensity_ennreal_iff
code: theorem aemeasurable_withDensity_ennreal_iff {f : α → ℝ≥0} (hf : Measurable f) {g : α → ℝ≥0∞} :
    AEMeasurable g (μ.withDensity fun x => (f x : ℝ≥0∞)) ↔
      AEMeasurable (fun x => (f x : ℝ≥0∞) * g x) μ 
goal: AEMeasurable g (μ.withDensity fun x => ↑(f x)) ↔ AEMeasurable (fun x => ↑(f x) * g x) μ

full_name: MeasureTheory.lintegral_withDensity_eq_lintegral_mul
code: /-- This is Exercise 1.2.1 from [tao2010]. It allows you to express integration of a measurable
function with respect to `(μ.withDensity f)` as an integral with respect to `μ`, called the base
measure. `μ` is often the Lebesgue measure, and in this circumstance `f` is the probability density
function, and `(μ.withDensity f)` represents any continuous random variable as a
probability measure, such as the uniform distribution between 0 and 1, the Gaussian distribution,
the exponential distribution, the Beta distribution, or the Cauchy distribution (see Section 2.4
of [wasserman2004]). Thus, this method shows how to one can calculate expectations, variances,
and other moments as a function of the probability density function.
 -/
theorem lintegral_withDensity_eq_lintegral_mul (μ : Measure α) {f : α → ℝ≥0∞}
    (h_mf : Measurable f) :
    ∀ {g : α → ℝ≥0∞}, Measurable g → ∫⁻ a, g a ∂μ.withDensity f = ∫⁻ a, (f * g) a ∂μ 
goal: Measurable g → ∫⁻ (a : α), g a ∂μ.withDensity f = ∫⁻ (a : α), (f * g) a ∂μ

full_name: MeasureTheory.setLIntegral_withDensity_eq_setLIntegral_mul
code: theorem setLIntegral_withDensity_eq_setLIntegral_mul (μ : Measure α) {f g : α → ℝ≥0∞}
    (hf : Measurable f) (hg : Measurable g) {s : Set α} (hs : MeasurableSet s) :
    ∫⁻ x in s, g x ∂μ.withDensity f = ∫⁻ x in s, (f * g) x ∂μ 
goal: ∫⁻ (x : α) in s, g x ∂μ.withDensity f = ∫⁻ (x : α) in s, (f * g) x ∂μ

full_name: MeasureTheory.lintegral_withDensity_eq_lintegral_mul₀'
code: /-- The Lebesgue integral of `g` with respect to the measure `μ.withDensity f` coincides with
the integral of `f * g`. This version assumes that `g` is almost everywhere measurable. For a
version without conditions on `g` but requiring that `f` is almost everywhere finite, see
`lintegral_withDensity_eq_lintegral_mul_non_measurable` -/
theorem lintegral_withDensity_eq_lintegral_mul₀' {μ : Measure α} {f : α → ℝ≥0∞}
    (hf : AEMeasurable f μ) {g : α → ℝ≥0∞} (hg : AEMeasurable g (μ.withDensity f)) :
    ∫⁻ a, g a ∂μ.withDensity f = ∫⁻ a, (f * g) a ∂μ 
goal: ∫⁻ (a : α), g a ∂μ.withDensity f = ∫⁻ (a : α), (f * g) a ∂μ

full_name: MeasureTheory.setLIntegral_withDensity_eq_lintegral_mul₀'
code: lemma setLIntegral_withDensity_eq_lintegral_mul₀' {μ : Measure α} {f : α → ℝ≥0∞}
    (hf : AEMeasurable f μ) {g : α → ℝ≥0∞} (hg : AEMeasurable g (μ.withDensity f))
    {s : Set α} (hs : MeasurableSet s) :
    ∫⁻ a in s, g a ∂μ.withDensity f = ∫⁻ a in s, (f * g) a ∂μ 
goal: ∫⁻ (a : α) in s, g a ∂μ.withDensity f = ∫⁻ (a : α) in s, (f * g) a ∂μ

full_name: MeasureTheory.lintegral_withDensity_eq_lintegral_mul₀
code: theorem lintegral_withDensity_eq_lintegral_mul₀ {μ : Measure α} {f : α → ℝ≥0∞}
    (hf : AEMeasurable f μ) {g : α → ℝ≥0∞} (hg : AEMeasurable g μ) :
    ∫⁻ a, g a ∂μ.withDensity f = ∫⁻ a, (f * g) a ∂μ 
goal: ∫⁻ (a : α), g a ∂μ.withDensity f = ∫⁻ (a : α), (f * g) a ∂μ

full_name: MeasureTheory.setLIntegral_withDensity_eq_lintegral_mul₀
code: lemma setLIntegral_withDensity_eq_lintegral_mul₀ {μ : Measure α} {f : α → ℝ≥0∞}
    (hf : AEMeasurable f μ) {g : α → ℝ≥0∞} (hg : AEMeasurable g μ)
    {s : Set α} (hs : MeasurableSet s) :
    ∫⁻ a in s, g a ∂μ.withDensity f = ∫⁻ a in s, (f * g) a ∂μ 
goal: ∫⁻ (a : α) in s, g a ∂μ.withDensity f = ∫⁻ (a : α) in s, (f * g) a ∂μ

full_name: MeasureTheory.lintegral_withDensity_le_lintegral_mul
code: theorem lintegral_withDensity_le_lintegral_mul (μ : Measure α) {f : α → ℝ≥0∞}
    (f_meas : Measurable f) (g : α → ℝ≥0∞) : (∫⁻ a, g a ∂μ.withDensity f) ≤ ∫⁻ a, (f * g) a ∂μ 
goal: ∫⁻ (a : α), g a ∂μ.withDensity f ≤ ∫⁻ (a : α), (f * g) a ∂μ

full_name: MeasureTheory.lintegral_withDensity_eq_lintegral_mul_non_measurable
code: theorem lintegral_withDensity_eq_lintegral_mul_non_measurable (μ : Measure α) {f : α → ℝ≥0∞}
    (f_meas : Measurable f) (hf : ∀ᵐ x ∂μ, f x < ∞) (g : α → ℝ≥0∞) :
    ∫⁻ a, g a ∂μ.withDensity f = ∫⁻ a, (f * g) a ∂μ 
goal: ∫⁻ (a : α), g a ∂μ.withDensity f = ∫⁻ (a : α), (f * g) a ∂μ

full_name: MeasureTheory.setLIntegral_withDensity_eq_setLIntegral_mul_non_measurable
code: theorem setLIntegral_withDensity_eq_setLIntegral_mul_non_measurable (μ : Measure α) {f : α → ℝ≥0∞}
    (f_meas : Measurable f) (g : α → ℝ≥0∞) {s : Set α} (hs : MeasurableSet s)
    (hf : ∀ᵐ x ∂μ.restrict s, f x < ∞) :
    ∫⁻ a in s, g a ∂μ.withDensity f = ∫⁻ a in s, (f * g) a ∂μ 
goal: ∫⁻ (a : α) in s, g a ∂μ.withDensity f = ∫⁻ (a : α) in s, (f * g) a ∂μ

full_name: MeasureTheory.lintegral_withDensity_eq_lintegral_mul_non_measurable₀
code: theorem lintegral_withDensity_eq_lintegral_mul_non_measurable₀ (μ : Measure α) {f : α → ℝ≥0∞}
    (hf : AEMeasurable f μ) (h'f : ∀ᵐ x ∂μ, f x < ∞) (g : α → ℝ≥0∞) :
    ∫⁻ a, g a ∂μ.withDensity f = ∫⁻ a, (f * g) a ∂μ 
goal: ∫⁻ (a : α), g a ∂μ.withDensity f = ∫⁻ (a : α), (f * g) a ∂μ

full_name: MeasureTheory.setLIntegral_withDensity_eq_setLIntegral_mul_non_measurable₀
code: theorem setLIntegral_withDensity_eq_setLIntegral_mul_non_measurable₀ (μ : Measure α)
    {f : α → ℝ≥0∞} {s : Set α} (hf : AEMeasurable f (μ.restrict s)) (g : α → ℝ≥0∞)
    (hs : MeasurableSet s) (h'f : ∀ᵐ x ∂μ.restrict s, f x < ∞) :
    ∫⁻ a in s, g a ∂μ.withDensity f = ∫⁻ a in s, (f * g) a ∂μ 
goal: ∫⁻ (a : α) in s, g a ∂μ.withDensity f = ∫⁻ (a : α) in s, (f * g) a ∂μ

full_name: MeasureTheory.setLIntegral_withDensity_eq_setLIntegral_mul_non_measurable₀'
code: theorem setLIntegral_withDensity_eq_setLIntegral_mul_non_measurable₀' (μ : Measure α) [SFinite μ]
    {f : α → ℝ≥0∞} (s : Set α) (hf : AEMeasurable f (μ.restrict s)) (g : α → ℝ≥0∞)
    (h'f : ∀ᵐ x ∂μ.restrict s, f x < ∞) :
    ∫⁻ a in s, g a ∂μ.withDensity f = ∫⁻ a in s, (f * g) a ∂μ 
goal: ∫⁻ (a : α) in s, g a ∂μ.withDensity f = ∫⁻ (a : α) in s, (f * g) a ∂μ

full_name: MeasureTheory.withDensity_mul₀
code: theorem withDensity_mul₀ {μ : Measure α} {f g : α → ℝ≥0∞}
    (hf : AEMeasurable f μ) (hg : AEMeasurable g μ) :
    μ.withDensity (f * g) = (μ.withDensity f).withDensity g 
goal: μ.withDensity (f * g) = (μ.withDensity f).withDensity g

full_name: MeasureTheory.withDensity_mul
code: theorem withDensity_mul (μ : Measure α) {f g : α → ℝ≥0∞} (hf : Measurable f) (hg : Measurable g) :
    μ.withDensity (f * g) = (μ.withDensity f).withDensity g 
goal: μ.withDensity (f * g) = (μ.withDensity f).withDensity g

full_name: MeasureTheory.withDensity_inv_same_le
code: lemma withDensity_inv_same_le {μ : Measure α} {f : α → ℝ≥0∞} (hf : AEMeasurable f μ) :
    (μ.withDensity f).withDensity f⁻¹ ≤ μ 
goal: (μ.withDensity f).withDensity f⁻¹ ≤ μ

full_name: MeasureTheory.withDensity_inv_same₀
code: lemma withDensity_inv_same₀ {μ : Measure α} {f : α → ℝ≥0∞}
    (hf : AEMeasurable f μ) (hf_ne_zero : ∀ᵐ x ∂μ, f x ≠ 0) (hf_ne_top : ∀ᵐ x ∂μ, f x ≠ ∞) :
    (μ.withDensity f).withDensity (fun x ↦ (f x)⁻¹) = μ 
goal: ((μ.withDensity f).withDensity fun x => (f x)⁻¹) = μ

full_name: MeasureTheory.withDensity_inv_same
code: lemma withDensity_inv_same {μ : Measure α} {f : α → ℝ≥0∞}
    (hf : Measurable f) (hf_ne_zero : ∀ᵐ x ∂μ, f x ≠ 0) (hf_ne_top : ∀ᵐ x ∂μ, f x ≠ ∞) :
    (μ.withDensity f).withDensity (fun x ↦ (f x)⁻¹) = μ 
goal: ((μ.withDensity f).withDensity fun x => (f x)⁻¹) = μ

full_name: MeasureTheory.withDensity_absolutelyContinuous'
code: /-- If `f` is almost everywhere positive, then `μ ≪ μ.withDensity f`. See also
`withDensity_absolutelyContinuous` for the reverse direction, which always holds. -/
lemma withDensity_absolutelyContinuous' {μ : Measure α} {f : α → ℝ≥0∞}
    (hf : AEMeasurable f μ) (hf_ne_zero : ∀ᵐ x ∂μ, f x ≠ 0) :
    μ ≪ μ.withDensity f 
goal: μ.AbsolutelyContinuous (μ.withDensity f)

full_name: MeasureTheory.withDensity_ae_eq
code: theorem withDensity_ae_eq {β : Type} {f g : α → β} {d : α → ℝ≥0∞}
    (hd : AEMeasurable d μ) (h_ae_nonneg : ∀ᵐ x ∂μ, d x ≠ 0) :
    f =ᵐ[μ.withDensity d] g ↔ f =ᵐ[μ] g 
goal: f =ᵐ[μ.withDensity d] g ↔ f =ᵐ[μ] g

full_name: MeasureTheory.SigmaFinite.withDensity
code: /-- If `μ` is a σ-finite measure, then so is `μ.withDensity fun x ↦ f x`
for any `ℝ≥0`-valued function `f`. -/
protected instance SigmaFinite.withDensity [SigmaFinite μ] (f : α → ℝ≥0) :
    SigmaFinite (μ.withDensity (fun x ↦ f x)) 
goal: MeasureTheory.SigmaFinite (μ.withDensity fun x => ↑(f x))

full_name: MeasureTheory.SigmaFinite.withDensity_of_ne_top
code: lemma SigmaFinite.withDensity_of_ne_top [SigmaFinite μ] {f : α → ℝ≥0∞}
    (hf_ne_top : ∀ᵐ x ∂μ, f x ≠ ∞) : SigmaFinite (μ.withDensity f) 
goal: MeasureTheory.SigmaFinite (μ.withDensity f)

full_name: MeasureTheory.SigmaFinite.withDensity_of_ne_top'
code: lemma SigmaFinite.withDensity_of_ne_top' [SigmaFinite μ] {f : α → ℝ≥0∞} (hf_ne_top : ∀ x, f x ≠ ∞) :
    SigmaFinite (μ.withDensity f) 
goal: MeasureTheory.SigmaFinite (μ.withDensity f)

full_name: MeasureTheory.SigmaFinite.withDensity_ofReal
code: instance SigmaFinite.withDensity_ofReal [SigmaFinite μ] (f : α → ℝ) :
    SigmaFinite (μ.withDensity (fun x ↦ ENNReal.ofReal (f x))) 
goal: MeasureTheory.SigmaFinite (μ.withDensity fun x => ENNReal.ofReal (f x))

full_name: MeasureTheory.exists_measurable_le_withDensity_eq
code: theorem exists_measurable_le_withDensity_eq [SFinite μ] (f : α → ℝ≥0∞) :
    ∃ g, Measurable g ∧ g ≤ f ∧ μ.withDensity g = μ.withDensity f 
goal: ∃ g, Measurable g ∧ g ≤ f ∧ μ.withDensity g = μ.withDensity f

full_name: MeasureTheory.Measure.withDensity.instSFinite
code: /-- If `μ` is an `s`-finite measure, then so is `μ.withDensity f`. -/
instance Measure.withDensity.instSFinite [SFinite μ] {f : α → ℝ≥0∞} :
    SFinite (μ.withDensity f) 
goal: MeasureTheory.SFinite (μ.withDensity f)

full_name: MeasureTheory.sFinite_withDensity_of_sigmaFinite_of_measurable
code: @[deprecated Measure.withDensity.instSFinite (since := "2024-07-14"), nolint unusedArguments]
lemma sFinite_withDensity_of_sigmaFinite_of_measurable (μ : Measure α) [SigmaFinite μ]
    {f : α → ℝ≥0∞} (_hf : Measurable f) :
    SFinite (μ.withDensity f) 
goal: MeasureTheory.SFinite (μ.withDensity f)

full_name: MeasureTheory.sFinite_withDensity_of_measurable
code: @[deprecated Measure.withDensity.instSFinite (since := "2024-07-14"), nolint unusedArguments]
lemma sFinite_withDensity_of_measurable (μ : Measure α) [SFinite μ]
    {f : α → ℝ≥0∞} (_hf : Measurable f) :
    SFinite (μ.withDensity f) 
goal: MeasureTheory.SFinite (μ.withDensity f)

full_name: MeasureTheory.IsLocallyFiniteMeasure.withDensity_coe
code: lemma IsLocallyFiniteMeasure.withDensity_coe {f : α → ℝ≥0} (hf : Continuous f) :
    IsLocallyFiniteMeasure (μ.withDensity fun x ↦ f x) 
goal: MeasureTheory.IsLocallyFiniteMeasure (μ.withDensity fun x => ↑(f x))

full_name: MeasureTheory.IsLocallyFiniteMeasure.withDensity_ofReal
code: lemma IsLocallyFiniteMeasure.withDensity_ofReal {f : α → ℝ} (hf : Continuous f) :
    IsLocallyFiniteMeasure (μ.withDensity fun x ↦ .ofReal (f x)) 
goal: MeasureTheory.IsLocallyFiniteMeasure (μ.withDensity fun x => ENNReal.ofReal (f x))