File: Mathlib/MeasureTheory/Measure/OpenPos.lean

full_name: MeasureTheory.Measure.IsOpenPosMeasure
code: /-- A measure is said to be `IsOpenPosMeasure` if it is positive on nonempty open sets. -/
class IsOpenPosMeasure : Prop where
  open_pos : ∀ U : Set X, IsOpen U → U.Nonempty → μ U ≠ 0
goal: Prop

full_name: MeasureTheory.Measure.IsOpenPosMeasure.open_pos
code: /-- A measure is said to be `IsOpenPosMeasure` if it is positive on nonempty open sets. -/
class IsOpenPosMeasure : Prop where
  open_pos : ∀ U : Set X, IsOpen U → U.Nonempty → μ U ≠ 0
goal: IsOpen U → U.Nonempty → μ U ≠ 0

full_name: IsOpen.measure_ne_zero
code: theorem _root_.IsOpen.measure_ne_zero (hU : IsOpen U) (hne : U.Nonempty) : μ U ≠ 0 
goal: μ U ≠ 0

full_name: IsOpen.measure_pos
code: theorem _root_.IsOpen.measure_pos (hU : IsOpen U) (hne : U.Nonempty) : 0 < μ U 
goal: 0 < μ U

full_name: MeasureTheory.Measure.instNeZeroOfNonempty
code: instance (priority := 100) [Nonempty X] : NeZero μ 
goal: NeZero μ

full_name: IsOpen.measure_pos_iff
code: theorem _root_.IsOpen.measure_pos_iff (hU : IsOpen U) : 0 < μ U ↔ U.Nonempty 
goal: 0 < μ U ↔ U.Nonempty

full_name: IsOpen.measure_eq_zero_iff
code: theorem _root_.IsOpen.measure_eq_zero_iff (hU : IsOpen U) : μ U = 0 ↔ U = ∅ 
goal: μ U = 0 ↔ U = ∅

full_name: MeasureTheory.Measure.measure_pos_of_nonempty_interior
code: theorem measure_pos_of_nonempty_interior (h : (interior s).Nonempty) : 0 < μ s 
goal: 0 < μ s

full_name: MeasureTheory.Measure.measure_pos_of_mem_nhds
code: theorem measure_pos_of_mem_nhds (h : s ∈ 𝓝 x) : 0 < μ s 
goal: 0 < μ s

full_name: MeasureTheory.Measure.isOpenPosMeasure_smul
code: theorem isOpenPosMeasure_smul {c : ℝ≥0∞} (h : c ≠ 0) : IsOpenPosMeasure (c • μ) 
goal: (c • μ).IsOpenPosMeasure

full_name: MeasureTheory.Measure.AbsolutelyContinuous.isOpenPosMeasure
code: protected theorem AbsolutelyContinuous.isOpenPosMeasure (h : μ ≪ ν) : IsOpenPosMeasure ν 
goal: ν.IsOpenPosMeasure

full_name: LE.le.isOpenPosMeasure
code: theorem _root_.LE.le.isOpenPosMeasure (h : μ ≤ ν) : IsOpenPosMeasure ν 
goal: ν.IsOpenPosMeasure

full_name: IsOpen.measure_zero_iff_eq_empty
code: theorem _root_.IsOpen.measure_zero_iff_eq_empty (hU : IsOpen U) :
    μ U = 0 ↔ U = ∅ 
goal: μ U = 0 ↔ U = ∅

full_name: IsOpen.ae_eq_empty_iff_eq
code: theorem _root_.IsOpen.ae_eq_empty_iff_eq (hU : IsOpen U) :
    U =ᵐ[μ] (∅ : Set X) ↔ U = ∅ 
goal: U =ᵐ[μ] ∅ ↔ U = ∅

full_name: IsOpen.eq_empty_of_measure_zero
code: /-- An open null set w.r.t. an `IsOpenPosMeasure` is empty. -/
theorem _root_.IsOpen.eq_empty_of_measure_zero (hU : IsOpen U) (h₀ : μ U = 0) : U = ∅ 
goal: U = ∅

full_name: IsClosed.ae_eq_univ_iff_eq
code: theorem _root_.IsClosed.ae_eq_univ_iff_eq (hF : IsClosed F) :
    F =ᵐ[μ] univ ↔ F = univ 
goal: F =ᵐ[μ] Set.univ ↔ F = Set.univ

full_name: IsClosed.measure_eq_univ_iff_eq
code: theorem _root_.IsClosed.measure_eq_univ_iff_eq [OpensMeasurableSpace X] [IsFiniteMeasure μ]
    (hF : IsClosed F) :
    μ F = μ univ ↔ F = univ 
goal: μ F = μ Set.univ ↔ F = Set.univ

full_name: IsClosed.measure_eq_one_iff_eq_univ
code: theorem _root_.IsClosed.measure_eq_one_iff_eq_univ [OpensMeasurableSpace X] [IsProbabilityMeasure μ]
    (hF : IsClosed F) :
    μ F = 1 ↔ F = univ 
goal: μ F = 1 ↔ F = Set.univ

full_name: MeasureTheory.Measure.interior_eq_empty_of_null
code: /-- A null set has empty interior. -/
theorem interior_eq_empty_of_null (hs : μ s = 0) : interior s = ∅ 
goal: interior s = ∅

full_name: MeasureTheory.Measure.eqOn_open_of_ae_eq
code: /-- If two functions are a.e. equal on an open set and are continuous on this set, then they are
equal on this set. -/
theorem eqOn_open_of_ae_eq {f g : X → Y} (h : f =ᵐ[μ.restrict U] g) (hU : IsOpen U)
    (hf : ContinuousOn f U) (hg : ContinuousOn g U) : EqOn f g U 
goal: Set.EqOn f g U

full_name: MeasureTheory.Measure.eq_of_ae_eq
code: /-- If two continuous functions are a.e. equal, then they are equal. -/
theorem eq_of_ae_eq {f g : X → Y} (h : f =ᵐ[μ] g) (hf : Continuous f) (hg : Continuous g) : f = g 
goal: f = g

full_name: MeasureTheory.Measure.eqOn_of_ae_eq
code: theorem eqOn_of_ae_eq {f g : X → Y} (h : f =ᵐ[μ.restrict s] g) (hf : ContinuousOn f s)
    (hg : ContinuousOn g s) (hU : s ⊆ closure (interior s)) : EqOn f g s 
goal: Set.EqOn f g s

full_name: Continuous.ae_eq_iff_eq
code: theorem _root_.Continuous.ae_eq_iff_eq {f g : X → Y} (hf : Continuous f) (hg : Continuous g) :
    f =ᵐ[μ] g ↔ f = g 
goal: f =ᵐ[μ] g ↔ f = g

full_name: Continuous.isOpenPosMeasure_map
code: theorem _root_.Continuous.isOpenPosMeasure_map [OpensMeasurableSpace X]
    {Z : Type*} [TopologicalSpace Z] [MeasurableSpace Z] [BorelSpace Z]
    {f : X → Z} (hf : Continuous f) (hf_surj : Function.Surjective f) :
    (Measure.map f μ).IsOpenPosMeasure 
goal: (MeasureTheory.Measure.map f μ).IsOpenPosMeasure

full_name: MeasureTheory.Measure.measure_Ioi_pos
code: theorem measure_Ioi_pos [NoMaxOrder X] (a : X) : 0 < μ (Ioi a) 
goal: 0 < μ (Set.Ioi a)

full_name: MeasureTheory.Measure.measure_Iio_pos
code: theorem measure_Iio_pos [NoMinOrder X] (a : X) : 0 < μ (Iio a) 
goal: 0 < μ (Set.Iio a)

full_name: MeasureTheory.Measure.measure_Ioo_pos
code: theorem measure_Ioo_pos [DenselyOrdered X] {a b : X} : 0 < μ (Ioo a b) ↔ a < b 
goal: 0 < μ (Set.Ioo a b) ↔ a < b

full_name: MeasureTheory.Measure.measure_Ioo_eq_zero
code: theorem measure_Ioo_eq_zero [DenselyOrdered X] {a b : X} : μ (Ioo a b) = 0 ↔ b ≤ a 
goal: μ (Set.Ioo a b) = 0 ↔ b ≤ a

full_name: MeasureTheory.Measure.eqOn_Ioo_of_ae_eq
code: theorem eqOn_Ioo_of_ae_eq {a b : X} {f g : X → Y} (hfg : f =ᵐ[μ.restrict (Ioo a b)] g)
    (hf : ContinuousOn f (Ioo a b)) (hg : ContinuousOn g (Ioo a b)) : EqOn f g (Ioo a b) 
goal: Set.EqOn f g (Set.Ioo a b)

full_name: MeasureTheory.Measure.eqOn_Ioc_of_ae_eq
code: theorem eqOn_Ioc_of_ae_eq [DenselyOrdered X] {a b : X} {f g : X → Y}
    (hfg : f =ᵐ[μ.restrict (Ioc a b)] g) (hf : ContinuousOn f (Ioc a b))
    (hg : ContinuousOn g (Ioc a b)) : EqOn f g (Ioc a b) 
goal: Set.EqOn f g (Set.Ioc a b)

full_name: MeasureTheory.Measure.eqOn_Ico_of_ae_eq
code: theorem eqOn_Ico_of_ae_eq [DenselyOrdered X] {a b : X} {f g : X → Y}
    (hfg : f =ᵐ[μ.restrict (Ico a b)] g) (hf : ContinuousOn f (Ico a b))
    (hg : ContinuousOn g (Ico a b)) : EqOn f g (Ico a b) 
goal: Set.EqOn f g (Set.Ico a b)

full_name: MeasureTheory.Measure.eqOn_Icc_of_ae_eq
code: theorem eqOn_Icc_of_ae_eq [DenselyOrdered X] {a b : X} (hne : a ≠ b) {f g : X → Y}
    (hfg : f =ᵐ[μ.restrict (Icc a b)] g) (hf : ContinuousOn f (Icc a b))
    (hg : ContinuousOn g (Icc a b)) : EqOn f g (Icc a b) 
goal: Set.EqOn f g (Set.Icc a b)

full_name: Metric.measure_ball_pos
code: theorem measure_ball_pos (x : X) {r : ℝ} (hr : 0 < r) : 0 < μ (ball x r) 
goal: 0 < μ (Metric.ball x r)

full_name: Metric.measure_closedBall_pos
code: /-- See also `Metric.measure_closedBall_pos_iff`. -/
theorem measure_closedBall_pos (x : X) {r : ℝ} (hr : 0 < r) : 0 < μ (closedBall x r) 
goal: 0 < μ (Metric.closedBall x r)

full_name: Metric.measure_closedBall_pos_iff
code: @[simp] lemma measure_closedBall_pos_iff {X : Type*} [MetricSpace X] {m : MeasurableSpace X}
    (μ : Measure X) [IsOpenPosMeasure μ] [NoAtoms μ] {x : X} {r : ℝ} :
    0 < μ (closedBall x r) ↔ 0 < r 
goal: 0 < μ (Metric.closedBall x r) ↔ 0 < r

full_name: EMetric.measure_ball_pos
code: theorem measure_ball_pos (x : X) {r : ℝ≥0∞} (hr : r ≠ 0) : 0 < μ (ball x r) 
goal: 0 < μ (EMetric.ball x r)

full_name: EMetric.measure_closedBall_pos
code: theorem measure_closedBall_pos (x : X) {r : ℝ≥0∞} (hr : r ≠ 0) : 0 < μ (closedBall x r) 
goal: 0 < μ (EMetric.closedBall x r)

full_name: IsNowhereDense.of_isClosed_null
code: /-- A *closed* measure zero subset is nowhere dense. (Closedness is required: for instance, the
rational numbers are countable (thus have measure zero), but are dense (hence not nowhere dense). -/
lemma IsNowhereDense.of_isClosed_null (h₁s : IsClosed s) (h₂s : μ s = 0) :
    IsNowhereDense s 
goal: IsNowhereDense s

full_name: IsMeagre.of_isSigmaCompact_null
code: /-- A σ-compact measure zero subset is meagre.
(More generally, every Fσ set of measure zero is meagre.) -/
lemma IsMeagre.of_isSigmaCompact_null [T2Space X] (h₁s : IsSigmaCompact s) (h₂s : μ s = 0) :
    IsMeagre s 
goal: IsMeagre s