File: Mathlib/MeasureTheory/Measure/Dirac.lean

full_name: MeasureTheory.Measure.dirac
code: /-- The dirac measure. -/
def dirac (a : α) : Measure α 
goal: MeasureTheory.Measure α

full_name: MeasureTheory.Measure.instMeasureSpacePUnit
code: instance : MeasureSpace PUnit 
goal: MeasureTheory.MeasureSpace PUnit.{u_4 + 1}

full_name: MeasureTheory.Measure.le_dirac_apply
code: theorem le_dirac_apply {a} : s.indicator 1 a ≤ dirac a s 
goal: s.indicator 1 a ≤ (MeasureTheory.Measure.dirac a) s

full_name: MeasureTheory.Measure.dirac_apply'
code: @[simp]
theorem dirac_apply' (a : α) (hs : MeasurableSet s) : dirac a s = s.indicator 1 a 
goal: (MeasureTheory.Measure.dirac a) s = s.indicator 1 a

full_name: MeasureTheory.Measure.dirac_apply_of_mem
code: @[simp]
theorem dirac_apply_of_mem {a : α} (h : a ∈ s) : dirac a s = 1 
goal: (MeasureTheory.Measure.dirac a) s = 1

full_name: MeasureTheory.Measure.dirac_apply
code: @[simp]
theorem dirac_apply [MeasurableSingletonClass α] (a : α) (s : Set α) :
    dirac a s = s.indicator 1 a 
goal: (MeasureTheory.Measure.dirac a) s = s.indicator 1 a

full_name: MeasureTheory.Measure.map_dirac
code: theorem map_dirac {f : α → β} (hf : Measurable f) (a : α) : (dirac a).map f = dirac (f a) 
goal: MeasureTheory.Measure.map f (MeasureTheory.Measure.dirac a) = MeasureTheory.Measure.dirac (f a)

full_name: MeasureTheory.Measure.map_const
code: lemma map_const (μ : Measure α) (c : β) : μ.map (fun _ ↦ c) = (μ Set.univ) • dirac c 
goal: MeasureTheory.Measure.map (fun x => c) μ = μ Set.univ • MeasureTheory.Measure.dirac c

full_name: MeasureTheory.Measure.restrict_singleton
code: @[simp]
theorem restrict_singleton (μ : Measure α) (a : α) : μ.restrict {a} = μ {a} • dirac a 
goal: μ.restrict {a} = μ {a} • MeasureTheory.Measure.dirac a

full_name: MeasureTheory.Measure.map_eq_sum
code: /-- If `f` is a map with countable codomain, then `μ.map f` is a sum of Dirac measures. -/
theorem map_eq_sum [Countable β] [MeasurableSingletonClass β] (μ : Measure α) (f : α → β)
    (hf : Measurable f) : μ.map f = sum fun b : β => μ (f ⁻¹' {b}) • dirac b 
goal: MeasureTheory.Measure.map f μ = MeasureTheory.Measure.sum fun b => μ (f ⁻¹' {b}) • MeasureTheory.Measure.dirac b

full_name: MeasureTheory.Measure.sum_smul_dirac
code: /-- A measure on a countable type is a sum of Dirac measures. -/
@[simp]
theorem sum_smul_dirac [Countable α] [MeasurableSingletonClass α] (μ : Measure α) :
    (sum fun a => μ {a} • dirac a) = μ 
goal: (MeasureTheory.Measure.sum fun a => μ {a} • MeasureTheory.Measure.dirac a) = μ

full_name: MeasureTheory.Measure.tsum_indicator_apply_singleton
code: /-- Given that `α` is a countable, measurable space with all singleton sets measurable,
write the measure of a set `s` as the sum of the measure of `{x}` for all `x ∈ s`. -/
theorem tsum_indicator_apply_singleton [Countable α] [MeasurableSingletonClass α] (μ : Measure α)
    (s : Set α) (hs : MeasurableSet s) : (∑' x : α, s.indicator (fun x => μ {x}) x) = μ s 
goal: ∑' (x : α), s.indicator (fun x => μ {x}) x = μ s

full_name: MeasureTheory.mem_ae_dirac_iff
code: theorem mem_ae_dirac_iff {a : α} (hs : MeasurableSet s) : s ∈ ae (dirac a) ↔ a ∈ s 
goal: s ∈ MeasureTheory.ae (MeasureTheory.Measure.dirac a) ↔ a ∈ s

full_name: MeasureTheory.ae_dirac_iff
code: theorem ae_dirac_iff {a : α} {p : α → Prop} (hp : MeasurableSet { x | p x }) :
    (∀ᵐ x ∂dirac a, p x) ↔ p a 
goal: (∀ᵐ (x : α) ∂MeasureTheory.Measure.dirac a, p x) ↔ p a

full_name: MeasureTheory.ae_dirac_eq
code: @[simp]
theorem ae_dirac_eq [MeasurableSingletonClass α] (a : α) : ae (dirac a) = pure a 
goal: MeasureTheory.ae (MeasureTheory.Measure.dirac a) = pure a

full_name: MeasureTheory.ae_eq_dirac'
code: theorem ae_eq_dirac' [MeasurableSingletonClass β] {a : α} {f : α → β} (hf : Measurable f) :
    f =ᵐ[dirac a] const α (f a) 
goal: f =ᵐ[MeasureTheory.Measure.dirac a] Function.const α (f a)

full_name: MeasureTheory.ae_eq_dirac
code: theorem ae_eq_dirac [MeasurableSingletonClass α] {a : α} (f : α → δ) :
    f =ᵐ[dirac a] const α (f a) 
goal: f =ᵐ[MeasureTheory.Measure.dirac a] Function.const α (f a)

full_name: MeasureTheory.Measure.dirac.isProbabilityMeasure
code: instance Measure.dirac.isProbabilityMeasure {x : α} : IsProbabilityMeasure (dirac x) 
goal: MeasureTheory.IsProbabilityMeasure (MeasureTheory.Measure.dirac x)

full_name: MeasureTheory.Measure.dirac.instIsFiniteMeasure
code: instance Measure.dirac.instIsFiniteMeasure {a : α} : IsFiniteMeasure (dirac a) 
goal: MeasureTheory.IsFiniteMeasure (MeasureTheory.Measure.dirac a)

full_name: MeasureTheory.Measure.dirac.instSigmaFinite
code: instance Measure.dirac.instSigmaFinite {a : α} : SigmaFinite (dirac a) 
goal: MeasureTheory.SigmaFinite (MeasureTheory.Measure.dirac a)

full_name: MeasureTheory.restrict_dirac'
code: theorem restrict_dirac' (hs : MeasurableSet s) [Decidable (a ∈ s)] :
    (Measure.dirac a).restrict s = if a ∈ s then Measure.dirac a else 0 
goal: (MeasureTheory.Measure.dirac a).restrict s = if a ∈ s then MeasureTheory.Measure.dirac a else 0

full_name: MeasureTheory.restrict_dirac
code: theorem restrict_dirac [MeasurableSingletonClass α] [Decidable (a ∈ s)] :
    (Measure.dirac a).restrict s = if a ∈ s then Measure.dirac a else 0 
goal: (MeasureTheory.Measure.dirac a).restrict s = if a ∈ s then MeasureTheory.Measure.dirac a else 0

full_name: MeasureTheory.mutuallySingular_dirac
code: lemma mutuallySingular_dirac [MeasurableSingletonClass α] (x : α) (μ : Measure α) [NoAtoms μ] :
    Measure.dirac x ⟂ₘ μ 
goal: (MeasureTheory.Measure.dirac x).MutuallySingular μ

full_name: MeasureTheory.dirac_eq_dirac_iff_forall_mem_iff_mem
code: /-- Dirac delta measures at two points are equal if every measurable set contains either both or
neither of the points. -/
lemma dirac_eq_dirac_iff_forall_mem_iff_mem {x y : α} :
    Measure.dirac x = Measure.dirac y ↔ ∀ A, MeasurableSet A → (x ∈ A ↔ y ∈ A) 
goal: MeasureTheory.Measure.dirac x = MeasureTheory.Measure.dirac y ↔ ∀ (A : Set α), MeasurableSet A → (x ∈ A ↔ y ∈ A)

full_name: MeasureTheory.dirac_ne_dirac_iff_exists_measurableSet
code: /-- Dirac delta measures at two points are different if and only if there is a measurable set
containing one of the points but not the other. -/
lemma dirac_ne_dirac_iff_exists_measurableSet {x y : α} :
    Measure.dirac x ≠ Measure.dirac y ↔ ∃ A, MeasurableSet A ∧ x ∈ A ∧ y ∉ A 
goal: MeasureTheory.Measure.dirac x ≠ MeasureTheory.Measure.dirac y ↔ ∃ A, MeasurableSet A ∧ x ∈ A ∧ y ∉ A

full_name: MeasureTheory.dirac_ne_dirac
code: /-- Dirac delta measures at two different points are different, assuming the measurable space
separates points. -/
lemma dirac_ne_dirac [SeparatesPoints α] {x y : α} (x_ne_y : x ≠ y) :
    Measure.dirac x ≠ Measure.dirac y 
goal: MeasureTheory.Measure.dirac x ≠ MeasureTheory.Measure.dirac y

full_name: MeasureTheory.dirac_ne_dirac_iff
code: /-- Dirac delta measures at two points are different if and only if the two points are different,
assuming the measurable space separates points. -/
lemma dirac_ne_dirac_iff [SeparatesPoints α] {x y : α} :
    Measure.dirac x ≠ Measure.dirac y ↔ x ≠ y 
goal: MeasureTheory.Measure.dirac x ≠ MeasureTheory.Measure.dirac y ↔ x ≠ y

full_name: MeasureTheory.dirac_eq_dirac_iff
code: /-- Dirac delta measures at two points are equal if and only if the two points are equal,
assuming the measurable space separates points. -/
lemma dirac_eq_dirac_iff [SeparatesPoints α] {x y : α} :
    Measure.dirac x = Measure.dirac y ↔ x = y 
goal: MeasureTheory.Measure.dirac x = MeasureTheory.Measure.dirac y ↔ x = y

full_name: MeasureTheory.injective_dirac
code: /-- The assignment `x ↦ dirac x` is injective, assuming the measurable space separates points. -/
lemma injective_dirac [SeparatesPoints α] :
    Function.Injective (fun (x : α) ↦ dirac x) 
goal: Function.Injective fun x => MeasureTheory.Measure.dirac x