File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

full_name: Real.volume_eq_stieltjes_id
code: /-- The volume on the real line (as a particular case of the volume on a finite-dimensional
inner product space) coincides with the Stieltjes measure coming from the identity function. -/
theorem volume_eq_stieltjes_id : (volume : Measure ℝ) = StieltjesFunction.id.measure 
goal: MeasureTheory.volume = StieltjesFunction.id.measure

full_name: Real.volume_val
code: theorem volume_val (s) : volume s = StieltjesFunction.id.measure s 
goal: MeasureTheory.volume s = StieltjesFunction.id.measure s

full_name: Real.volume_Ico
code: @[simp]
theorem volume_Ico {a b : ℝ} : volume (Ico a b) = ofReal (b - a) 
goal: MeasureTheory.volume (Set.Ico a b) = ENNReal.ofReal (b - a)

full_name: Real.volume_Icc
code: @[simp]
theorem volume_Icc {a b : ℝ} : volume (Icc a b) = ofReal (b - a) 
goal: MeasureTheory.volume (Set.Icc a b) = ENNReal.ofReal (b - a)

full_name: Real.volume_Ioo
code: @[simp]
theorem volume_Ioo {a b : ℝ} : volume (Ioo a b) = ofReal (b - a) 
goal: MeasureTheory.volume (Set.Ioo a b) = ENNReal.ofReal (b - a)

full_name: Real.volume_Ioc
code: @[simp]
theorem volume_Ioc {a b : ℝ} : volume (Ioc a b) = ofReal (b - a) 
goal: MeasureTheory.volume (Set.Ioc a b) = ENNReal.ofReal (b - a)

full_name: Real.volume_singleton
code: theorem volume_singleton {a : ℝ} : volume ({a} : Set ℝ) = 0 
goal: MeasureTheory.volume {a} = 0

full_name: Real.volume_univ
code: theorem volume_univ : volume (univ : Set ℝ) = ∞ 
goal: MeasureTheory.volume Set.univ = ⊤

full_name: Real.volume_ball
code: @[simp]
theorem volume_ball (a r : ℝ) : volume (Metric.ball a r) = ofReal (2 * r) 
goal: MeasureTheory.volume (Metric.ball a r) = ENNReal.ofReal (2 * r)

full_name: Real.volume_closedBall
code: @[simp]
theorem volume_closedBall (a r : ℝ) : volume (Metric.closedBall a r) = ofReal (2 * r) 
goal: MeasureTheory.volume (Metric.closedBall a r) = ENNReal.ofReal (2 * r)

full_name: Real.volume_emetric_ball
code: @[simp]
theorem volume_emetric_ball (a : ℝ) (r : ℝ≥0∞) : volume (EMetric.ball a r) = 2 * r 
goal: MeasureTheory.volume (EMetric.ball a r) = 2 * r

full_name: Real.volume_emetric_closedBall
code: @[simp]
theorem volume_emetric_closedBall (a : ℝ) (r : ℝ≥0∞) : volume (EMetric.closedBall a r) = 2 * r 
goal: MeasureTheory.volume (EMetric.closedBall a r) = 2 * r

full_name: Real.noAtoms_volume
code: instance noAtoms_volume : NoAtoms (volume : Measure ℝ) 
goal: MeasureTheory.NoAtoms MeasureTheory.volume

full_name: Real.volume_interval
code: @[simp]
theorem volume_interval {a b : ℝ} : volume (uIcc a b) = ofReal |b - a| 
goal: MeasureTheory.volume (Set.uIcc a b) = ENNReal.ofReal |b - a|

full_name: Real.volume_Ioi
code: @[simp]
theorem volume_Ioi {a : ℝ} : volume (Ioi a) = ∞ 
goal: MeasureTheory.volume (Set.Ioi a) = ⊤

full_name: Real.volume_Ici
code: @[simp]
theorem volume_Ici {a : ℝ} : volume (Ici a) = ∞ 
goal: MeasureTheory.volume (Set.Ici a) = ⊤

full_name: Real.volume_Iio
code: @[simp]
theorem volume_Iio {a : ℝ} : volume (Iio a) = ∞ 
goal: MeasureTheory.volume (Set.Iio a) = ⊤

full_name: Real.volume_Iic
code: @[simp]
theorem volume_Iic {a : ℝ} : volume (Iic a) = ∞ 
goal: MeasureTheory.volume (Set.Iic a) = ⊤

full_name: Real.locallyFinite_volume
code: instance locallyFinite_volume : IsLocallyFiniteMeasure (volume : Measure ℝ) 
goal: MeasureTheory.IsLocallyFiniteMeasure MeasureTheory.volume

full_name: Real.isFiniteMeasure_restrict_Icc
code: instance isFiniteMeasure_restrict_Icc (x y : ℝ) : IsFiniteMeasure (volume.restrict (Icc x y)) 
goal: MeasureTheory.IsFiniteMeasure (MeasureTheory.volume.restrict (Set.Icc x y))

full_name: Real.isFiniteMeasure_restrict_Ico
code: instance isFiniteMeasure_restrict_Ico (x y : ℝ) : IsFiniteMeasure (volume.restrict (Ico x y)) 
goal: MeasureTheory.IsFiniteMeasure (MeasureTheory.volume.restrict (Set.Ico x y))

full_name: Real.isFiniteMeasure_restrict_Ioc
code: instance isFiniteMeasure_restrict_Ioc (x y : ℝ) : IsFiniteMeasure (volume.restrict (Ioc x y)) 
goal: MeasureTheory.IsFiniteMeasure (MeasureTheory.volume.restrict (Set.Ioc x y))

full_name: Real.isFiniteMeasure_restrict_Ioo
code: instance isFiniteMeasure_restrict_Ioo (x y : ℝ) : IsFiniteMeasure (volume.restrict (Ioo x y)) 
goal: MeasureTheory.IsFiniteMeasure (MeasureTheory.volume.restrict (Set.Ioo x y))

full_name: Real.volume_le_diam
code: theorem volume_le_diam (s : Set ℝ) : volume s ≤ EMetric.diam s 
goal: MeasureTheory.volume s ≤ EMetric.diam s

full_name: Filter.Eventually.volume_pos_of_nhds_real
code: theorem _root_.Filter.Eventually.volume_pos_of_nhds_real {p : ℝ → Prop} {a : ℝ}
    (h : ∀ᶠ x in 𝓝 a, p x) : (0 : ℝ≥0∞) < volume { x | p x } 
goal: 0 < MeasureTheory.volume {x | p x}

full_name: Real.volume_Icc_pi
code: theorem volume_Icc_pi {a b : ι → ℝ} : volume (Icc a b) = ∏ i, ENNReal.ofReal (b i - a i) 
goal: MeasureTheory.volume (Set.Icc a b) = ∏ i : ι, ENNReal.ofReal (b i - a i)

full_name: Real.volume_Icc_pi_toReal
code: @[simp]
theorem volume_Icc_pi_toReal {a b : ι → ℝ} (h : a ≤ b) :
    (volume (Icc a b)).toReal = ∏ i, (b i - a i) 
goal: (MeasureTheory.volume (Set.Icc a b)).toReal = ∏ i : ι, (b i - a i)

full_name: Real.volume_pi_Ioo
code: theorem volume_pi_Ioo {a b : ι → ℝ} :
    volume (pi univ fun i => Ioo (a i) (b i)) = ∏ i, ENNReal.ofReal (b i - a i) 
goal: MeasureTheory.volume (Set.univ.pi fun i => Set.Ioo (a i) (b i)) = ∏ i : ι, ENNReal.ofReal (b i - a i)

full_name: Real.volume_pi_Ioo_toReal
code: @[simp]
theorem volume_pi_Ioo_toReal {a b : ι → ℝ} (h : a ≤ b) :
    (volume (pi univ fun i => Ioo (a i) (b i))).toReal = ∏ i, (b i - a i) 
goal: (MeasureTheory.volume (Set.univ.pi fun i => Set.Ioo (a i) (b i))).toReal = ∏ i : ι, (b i - a i)

full_name: Real.volume_pi_Ioc
code: theorem volume_pi_Ioc {a b : ι → ℝ} :
    volume (pi univ fun i => Ioc (a i) (b i)) = ∏ i, ENNReal.ofReal (b i - a i) 
goal: MeasureTheory.volume (Set.univ.pi fun i => Set.Ioc (a i) (b i)) = ∏ i : ι, ENNReal.ofReal (b i - a i)

full_name: Real.volume_pi_Ioc_toReal
code: @[simp]
theorem volume_pi_Ioc_toReal {a b : ι → ℝ} (h : a ≤ b) :
    (volume (pi univ fun i => Ioc (a i) (b i))).toReal = ∏ i, (b i - a i) 
goal: (MeasureTheory.volume (Set.univ.pi fun i => Set.Ioc (a i) (b i))).toReal = ∏ i : ι, (b i - a i)

full_name: Real.volume_pi_Ico
code: theorem volume_pi_Ico {a b : ι → ℝ} :
    volume (pi univ fun i => Ico (a i) (b i)) = ∏ i, ENNReal.ofReal (b i - a i) 
goal: MeasureTheory.volume (Set.univ.pi fun i => Set.Ico (a i) (b i)) = ∏ i : ι, ENNReal.ofReal (b i - a i)

full_name: Real.volume_pi_Ico_toReal
code: @[simp]
theorem volume_pi_Ico_toReal {a b : ι → ℝ} (h : a ≤ b) :
    (volume (pi univ fun i => Ico (a i) (b i))).toReal = ∏ i, (b i - a i) 
goal: (MeasureTheory.volume (Set.univ.pi fun i => Set.Ico (a i) (b i))).toReal = ∏ i : ι, (b i - a i)

full_name: Real.volume_pi_ball
code: @[simp]
nonrec theorem volume_pi_ball (a : ι → ℝ) {r : ℝ} (hr : 0 < r) :
    volume (Metric.ball a r) = ENNReal.ofReal ((2 * r) ^ Fintype.card ι) 
goal: MeasureTheory.volume (Metric.ball a r) = ENNReal.ofReal ((2 * r) ^ Fintype.card ι)

full_name: Real.volume_pi_closedBall
code: @[simp]
nonrec theorem volume_pi_closedBall (a : ι → ℝ) {r : ℝ} (hr : 0 ≤ r) :
    volume (Metric.closedBall a r) = ENNReal.ofReal ((2 * r) ^ Fintype.card ι) 
goal: MeasureTheory.volume (Metric.closedBall a r) = ENNReal.ofReal ((2 * r) ^ Fintype.card ι)

full_name: Real.volume_pi_le_prod_diam
code: theorem volume_pi_le_prod_diam (s : Set (ι → ℝ)) :
    volume s ≤ ∏ i : ι, EMetric.diam (Function.eval i '' s) 
goal: MeasureTheory.volume s ≤ ∏ i : ι, EMetric.diam (Function.eval i '' s)

full_name: Real.volume_pi_le_diam_pow
code: theorem volume_pi_le_diam_pow (s : Set (ι → ℝ)) : volume s ≤ EMetric.diam s ^ Fintype.card ι 
goal: MeasureTheory.volume s ≤ EMetric.diam s ^ Fintype.card ι

full_name: Real.smul_map_volume_mul_left
code: theorem smul_map_volume_mul_left {a : ℝ} (h : a ≠ 0) :
    ENNReal.ofReal |a| • Measure.map (a * ·) volume = volume 
goal: ENNReal.ofReal |a| • MeasureTheory.Measure.map (fun x => a * x) MeasureTheory.volume = MeasureTheory.volume

full_name: Real.map_volume_mul_left
code: theorem map_volume_mul_left {a : ℝ} (h : a ≠ 0) :
    Measure.map (a * ·) volume = ENNReal.ofReal |a⁻¹| • volume 
goal: MeasureTheory.Measure.map (fun x => a * x) MeasureTheory.volume = ENNReal.ofReal |a⁻¹| • MeasureTheory.volume

full_name: Real.volume_preimage_mul_left
code: @[simp]
theorem volume_preimage_mul_left {a : ℝ} (h : a ≠ 0) (s : Set ℝ) :
    volume ((a * ·) ⁻¹' s) = ENNReal.ofReal (abs a⁻¹) * volume s 
goal: MeasureTheory.volume ((fun x => a * x) ⁻¹' s) = ENNReal.ofReal |a⁻¹| * MeasureTheory.volume s

full_name: Real.smul_map_volume_mul_right
code: theorem smul_map_volume_mul_right {a : ℝ} (h : a ≠ 0) :
    ENNReal.ofReal |a| • Measure.map (· * a) volume = volume 
goal: ENNReal.ofReal |a| • MeasureTheory.Measure.map (fun x => x * a) MeasureTheory.volume = MeasureTheory.volume

full_name: Real.map_volume_mul_right
code: theorem map_volume_mul_right {a : ℝ} (h : a ≠ 0) :
    Measure.map (· * a) volume = ENNReal.ofReal |a⁻¹| • volume 
goal: MeasureTheory.Measure.map (fun x => x * a) MeasureTheory.volume = ENNReal.ofReal |a⁻¹| • MeasureTheory.volume

full_name: Real.volume_preimage_mul_right
code: @[simp]
theorem volume_preimage_mul_right {a : ℝ} (h : a ≠ 0) (s : Set ℝ) :
    volume ((· * a) ⁻¹' s) = ENNReal.ofReal (abs a⁻¹) * volume s 
goal: MeasureTheory.volume ((fun x => x * a) ⁻¹' s) = ENNReal.ofReal |a⁻¹| * MeasureTheory.volume s

full_name: Real.smul_map_diagonal_volume_pi
code: /-- A diagonal matrix rescales Lebesgue according to its determinant. This is a special case of
`Real.map_matrix_volume_pi_eq_smul_volume_pi`, that one should use instead (and whose proof
uses this particular case). -/
theorem smul_map_diagonal_volume_pi [DecidableEq ι] {D : ι → ℝ} (h : det (diagonal D) ≠ 0) :
    ENNReal.ofReal (abs (det (diagonal D))) • Measure.map (toLin' (diagonal D)) volume =
      volume 
goal: ENNReal.ofReal |(Matrix.diagonal D).det| •
    MeasureTheory.Measure.map (⇑(Matrix.toLin' (Matrix.diagonal D))) MeasureTheory.volume =
  MeasureTheory.volume

full_name: Real.volume_preserving_transvectionStruct
code: /-- A transvection preserves Lebesgue measure. -/
theorem volume_preserving_transvectionStruct [DecidableEq ι] (t : TransvectionStruct ι ℝ) :
    MeasurePreserving (toLin' t.toMatrix) 
goal: MeasureTheory.MeasurePreserving (⇑(Matrix.toLin' t.toMatrix)) MeasureTheory.volume MeasureTheory.volume

full_name: Real.map_matrix_volume_pi_eq_smul_volume_pi
code: /-- Any invertible matrix rescales Lebesgue measure through the absolute value of its
determinant. -/
theorem map_matrix_volume_pi_eq_smul_volume_pi [DecidableEq ι] {M : Matrix ι ι ℝ} (hM : det M ≠ 0) :
    Measure.map (toLin' M) volume = ENNReal.ofReal (abs (det M)⁻¹) • volume 
goal: MeasureTheory.Measure.map (⇑(Matrix.toLin' M)) MeasureTheory.volume = ENNReal.ofReal |M.det⁻¹| • MeasureTheory.volume

full_name: Real.map_linearMap_volume_pi_eq_smul_volume_pi
code: /-- Any invertible linear map rescales Lebesgue measure through the absolute value of its
determinant. -/
theorem map_linearMap_volume_pi_eq_smul_volume_pi {f : (ι → ℝ) →ₗ[ℝ] ι → ℝ}
    (hf : LinearMap.det f ≠ 0) : Measure.map f volume =
      ENNReal.ofReal (abs (LinearMap.det f)⁻¹) • volume 
goal: MeasureTheory.Measure.map (⇑f) MeasureTheory.volume = ENNReal.ofReal |(LinearMap.det f)⁻¹| • MeasureTheory.volume

full_name: regionBetween
code: /-- The region between two real-valued functions on an arbitrary set. -/
def regionBetween (f g : α → ℝ) (s : Set α) : Set (α × ℝ) 
goal: Set (α × ℝ)

full_name: regionBetween_subset
code: theorem regionBetween_subset (f g : α → ℝ) (s : Set α) : regionBetween f g s ⊆ s ×ˢ univ 
goal: regionBetween f g s ⊆ s ×ˢ Set.univ

full_name: measurableSet_regionBetween
code: /-- The region between two measurable functions on a measurable set is measurable. -/
theorem measurableSet_regionBetween (hf : Measurable f) (hg : Measurable g) (hs : MeasurableSet s) :
    MeasurableSet (regionBetween f g s) 
goal: MeasurableSet (regionBetween f g s)

full_name: measurableSet_region_between_oc
code: /-- The region between two measurable functions on a measurable set is measurable;
a version for the region together with the graph of the upper function. -/
theorem measurableSet_region_between_oc (hf : Measurable f) (hg : Measurable g)
    (hs : MeasurableSet s) :
    MeasurableSet { p : α × ℝ | p.fst ∈ s ∧ p.snd ∈ Ioc (f p.fst) (g p.fst) } 
goal: MeasurableSet {p | p.1 ∈ s ∧ p.2 ∈ Set.Ioc (f p.1) (g p.1)}

full_name: measurableSet_region_between_co
code: /-- The region between two measurable functions on a measurable set is measurable;
a version for the region together with the graph of the lower function. -/
theorem measurableSet_region_between_co (hf : Measurable f) (hg : Measurable g)
    (hs : MeasurableSet s) :
    MeasurableSet { p : α × ℝ | p.fst ∈ s ∧ p.snd ∈ Ico (f p.fst) (g p.fst) } 
goal: MeasurableSet {p | p.1 ∈ s ∧ p.2 ∈ Set.Ico (f p.1) (g p.1)}

full_name: measurableSet_region_between_cc
code: /-- The region between two measurable functions on a measurable set is measurable;
a version for the region together with the graphs of both functions. -/
theorem measurableSet_region_between_cc (hf : Measurable f) (hg : Measurable g)
    (hs : MeasurableSet s) :
    MeasurableSet { p : α × ℝ | p.fst ∈ s ∧ p.snd ∈ Icc (f p.fst) (g p.fst) } 
goal: MeasurableSet {p | p.1 ∈ s ∧ p.2 ∈ Set.Icc (f p.1) (g p.1)}

full_name: measurableSet_graph
code: /-- The graph of a measurable function is a measurable set. -/
theorem measurableSet_graph (hf : Measurable f) :
    MeasurableSet { p : α × ℝ | p.snd = f p.fst } 
goal: MeasurableSet {p | p.2 = f p.1}

full_name: volume_regionBetween_eq_lintegral'
code: theorem volume_regionBetween_eq_lintegral' (hf : Measurable f) (hg : Measurable g)
    (hs : MeasurableSet s) :
    μ.prod volume (regionBetween f g s) = ∫⁻ y in s, ENNReal.ofReal ((g - f) y) ∂μ 
goal: (μ.prod MeasureTheory.volume) (regionBetween f g s) = ∫⁻ (y : α) in s, ENNReal.ofReal ((g - f) y) ∂μ

full_name: volume_regionBetween_eq_lintegral
code: /-- The volume of the region between two almost everywhere measurable functions on a measurable set
    can be represented as a Lebesgue integral. -/
theorem volume_regionBetween_eq_lintegral [SFinite μ] (hf : AEMeasurable f (μ.restrict s))
    (hg : AEMeasurable g (μ.restrict s)) (hs : MeasurableSet s) :
    μ.prod volume (regionBetween f g s) = ∫⁻ y in s, ENNReal.ofReal ((g - f) y) ∂μ 
goal: (μ.prod MeasureTheory.volume) (regionBetween f g s) = ∫⁻ (y : α) in s, ENNReal.ofReal ((g - f) y) ∂μ

full_name: nullMeasurableSet_regionBetween
code: /-- The region between two a.e.-measurable functions on a null-measurable set is null-measurable. -/
lemma nullMeasurableSet_regionBetween (μ : Measure α)
    {f g : α → ℝ} (f_mble : AEMeasurable f μ) (g_mble : AEMeasurable g μ)
    {s : Set α} (s_mble : NullMeasurableSet s μ) :
    NullMeasurableSet {p : α × ℝ | p.1 ∈ s ∧ p.snd ∈ Ioo (f p.fst) (g p.fst)} (μ.prod volume) 
goal: MeasureTheory.NullMeasurableSet {p | p.1 ∈ s ∧ p.2 ∈ Set.Ioo (f p.1) (g p.1)} (μ.prod MeasureTheory.volume)

full_name: nullMeasurableSet_region_between_oc
code: /-- The region between two a.e.-measurable functions on a null-measurable set is null-measurable;
a version for the region together with the graph of the upper function. -/
lemma nullMeasurableSet_region_between_oc (μ : Measure α)
    {f g : α → ℝ} (f_mble : AEMeasurable f μ) (g_mble : AEMeasurable g μ)
    {s : Set α} (s_mble : NullMeasurableSet s μ) :
    NullMeasurableSet {p : α × ℝ | p.1 ∈ s ∧ p.snd ∈ Ioc (f p.fst) (g p.fst)} (μ.prod volume) 
goal: MeasureTheory.NullMeasurableSet {p | p.1 ∈ s ∧ p.2 ∈ Set.Ioc (f p.1) (g p.1)} (μ.prod MeasureTheory.volume)

full_name: nullMeasurableSet_region_between_co
code: /-- The region between two a.e.-measurable functions on a null-measurable set is null-measurable;
a version for the region together with the graph of the lower function. -/
lemma nullMeasurableSet_region_between_co (μ : Measure α)
    {f g : α → ℝ} (f_mble : AEMeasurable f μ) (g_mble : AEMeasurable g μ)
    {s : Set α} (s_mble : NullMeasurableSet s μ) :
    NullMeasurableSet {p : α × ℝ | p.1 ∈ s ∧ p.snd ∈ Ico (f p.fst) (g p.fst)} (μ.prod volume) 
goal: MeasureTheory.NullMeasurableSet {p | p.1 ∈ s ∧ p.2 ∈ Set.Ico (f p.1) (g p.1)} (μ.prod MeasureTheory.volume)

full_name: nullMeasurableSet_region_between_cc
code: /-- The region between two a.e.-measurable functions on a null-measurable set is null-measurable;
a version for the region together with the graphs of both functions. -/
lemma nullMeasurableSet_region_between_cc (μ : Measure α)
    {f g : α → ℝ} (f_mble : AEMeasurable f μ) (g_mble : AEMeasurable g μ)
    {s : Set α} (s_mble : NullMeasurableSet s μ) :
    NullMeasurableSet {p : α × ℝ | p.1 ∈ s ∧ p.snd ∈ Icc (f p.fst) (g p.fst)} (μ.prod volume) 
goal: MeasureTheory.NullMeasurableSet {p | p.1 ∈ s ∧ p.2 ∈ Set.Icc (f p.1) (g p.1)} (μ.prod MeasureTheory.volume)

full_name: ae_restrict_of_ae_restrict_inter_Ioo
code: /-- Consider a real set `s`. If a property is true almost everywhere in `s ∩ (a, b)` for
all `a, b ∈ s`, then it is true almost everywhere in `s`. Formulated with `μ.restrict`.
See also `ae_of_mem_of_ae_of_mem_inter_Ioo`. -/
theorem ae_restrict_of_ae_restrict_inter_Ioo {μ : Measure ℝ} [NoAtoms μ] {s : Set ℝ} {p : ℝ → Prop}
    (h : ∀ a b, a ∈ s → b ∈ s → a < b → ∀ᵐ x ∂μ.restrict (s ∩ Ioo a b), p x) :
    ∀ᵐ x ∂μ.restrict s, p x 
goal: ∀ᵐ (x : ℝ) ∂μ.restrict s, p x

full_name: ae_of_mem_of_ae_of_mem_inter_Ioo
code: /-- Consider a real set `s`. If a property is true almost everywhere in `s ∩ (a, b)` for
all `a, b ∈ s`, then it is true almost everywhere in `s`. Formulated with bare membership.
See also `ae_restrict_of_ae_restrict_inter_Ioo`. -/
theorem ae_of_mem_of_ae_of_mem_inter_Ioo {μ : Measure ℝ} [NoAtoms μ] {s : Set ℝ} {p : ℝ → Prop}
    (h : ∀ a b, a ∈ s → b ∈ s → a < b → ∀ᵐ x ∂μ, x ∈ s ∩ Ioo a b → p x) :
    ∀ᵐ x ∂μ, x ∈ s → p x 
goal: ∀ᵐ (x : ℝ) ∂μ, x ∈ s → p x