fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
measurableSet_eq_stopping_time [AddGroup ι] [TopologicalSpace ι] [MeasurableSpace ι]
[BorelSpace ι] [OrderTopology ι] [MeasurableSingletonClass ι] [SecondCountableTopology ι]
[MeasurableSub₂ ι] (hτ : IsStoppingTime f τ) (hπ : IsStoppingTime f π) :
MeasurableSet[hτ.measurableSpace] {ω | τ ω = π ω} := by
rw [hτ.measurableSet]
intro j
have : {ω | τ ω = π ω} ∩ {ω | τ ω ≤ j} =
{ω | min (τ ω) j = min (π ω) j} ∩ {ω | τ ω ≤ j} ∩ {ω | π ω ≤ j} := by
ext1 ω
simp only [Set.mem_inter_iff, Set.mem_setOf_eq]
refine ⟨fun h => ⟨⟨?_, h.2⟩, ?_⟩, fun h => ⟨?_, h.1.2⟩⟩
· rw [h.1]
· rw [← h.1]; exact h.2
· obtain ⟨h', hσ_le⟩ := h
obtain ⟨h_eq, hτ_le⟩ := h'
rwa [min_eq_left hτ_le, min_eq_left hσ_le] at h_eq
rw [this]
refine
MeasurableSet.inter (MeasurableSet.inter ?_ (hτ.measurableSet_le j)) (hπ.measurableSet_le j)
apply measurableSet_eq_fun
· exact (hτ.min_const j).measurable_of_le fun _ => min_le_right _ _
· exact (hπ.min_const j).measurable_of_le fun _ => min_le_right _ _ | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_eq_stopping_time | null |
measurableSet_eq_stopping_time_of_countable [Countable ι] [TopologicalSpace ι]
[MeasurableSpace ι] [BorelSpace ι] [OrderTopology ι] [MeasurableSingletonClass ι]
[SecondCountableTopology ι] (hτ : IsStoppingTime f τ) (hπ : IsStoppingTime f π) :
MeasurableSet[hτ.measurableSpace] {ω | τ ω = π ω} := by
rw [hτ.measurableSet]
intro j
have : {ω | τ ω = π ω} ∩ {ω | τ ω ≤ j} =
{ω | min (τ ω) j = min (π ω) j} ∩ {ω | τ ω ≤ j} ∩ {ω | π ω ≤ j} := by
ext1 ω
simp only [Set.mem_inter_iff, Set.mem_setOf_eq]
refine ⟨fun h => ⟨⟨?_, h.2⟩, ?_⟩, fun h => ⟨?_, h.1.2⟩⟩
· rw [h.1]
· rw [← h.1]; exact h.2
· obtain ⟨h', hπ_le⟩ := h
obtain ⟨h_eq, hτ_le⟩ := h'
rwa [min_eq_left hτ_le, min_eq_left hπ_le] at h_eq
rw [this]
refine
MeasurableSet.inter (MeasurableSet.inter ?_ (hτ.measurableSet_le j)) (hπ.measurableSet_le j)
apply measurableSet_eq_fun_of_countable
· exact (hτ.min_const j).measurable_of_le fun _ => min_le_right _ _
· exact (hπ.min_const j).measurable_of_le fun _ => min_le_right _ _ | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_eq_stopping_time_of_countable | null |
stoppedValue (u : ι → Ω → β) (τ : Ω → ι) : Ω → β := fun ω => u (τ ω) ω | def | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | stoppedValue | Given a map `u : ι → Ω → E`, its stopped value with respect to the stopping
time `τ` is the map `x ↦ u (τ ω) ω`. |
stoppedValue_const (u : ι → Ω → β) (i : ι) : (stoppedValue u fun _ => i) = u i :=
rfl
variable [LinearOrder ι] | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | stoppedValue_const | null |
stoppedProcess (u : ι → Ω → β) (τ : Ω → ι) : ι → Ω → β := fun i ω => u (min i (τ ω)) ω | def | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | stoppedProcess | Given a map `u : ι → Ω → E`, the stopped process with respect to `τ` is `u i ω` if
`i ≤ τ ω`, and `u (τ ω) ω` otherwise.
Intuitively, the stopped process stops evolving once the stopping time has occurred. |
stoppedProcess_eq_stoppedValue {u : ι → Ω → β} {τ : Ω → ι} :
stoppedProcess u τ = fun i => stoppedValue u fun ω => min i (τ ω) :=
rfl | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | stoppedProcess_eq_stoppedValue | null |
stoppedValue_stoppedProcess {u : ι → Ω → β} {τ σ : Ω → ι} :
stoppedValue (stoppedProcess u τ) σ = stoppedValue u fun ω => min (σ ω) (τ ω) :=
rfl | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | stoppedValue_stoppedProcess | null |
stoppedProcess_eq_of_le {u : ι → Ω → β} {τ : Ω → ι} {i : ι} {ω : Ω} (h : i ≤ τ ω) :
stoppedProcess u τ i ω = u i ω := by simp [stoppedProcess, min_eq_left h] | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | stoppedProcess_eq_of_le | null |
stoppedProcess_eq_of_ge {u : ι → Ω → β} {τ : Ω → ι} {i : ι} {ω : Ω} (h : τ ω ≤ i) :
stoppedProcess u τ i ω = u (τ ω) ω := by simp [stoppedProcess, min_eq_right h] | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | stoppedProcess_eq_of_ge | null |
progMeasurable_min_stopping_time [PseudoMetrizableSpace ι] (hτ : IsStoppingTime f τ) :
ProgMeasurable f fun i ω => min i (τ ω) := by
intro i
let m_prod : MeasurableSpace (Set.Iic i × Ω) := Subtype.instMeasurableSpace.prod (f i)
let m_set : ∀ t : Set (Set.Iic i × Ω), MeasurableSpace t := fun _ =>
@Subtype.instMeasurableSpace (Set.Iic i × Ω) _ m_prod
let s := {p : Set.Iic i × Ω | τ p.2 ≤ i}
have hs : MeasurableSet[m_prod] s := @measurable_snd (Set.Iic i) Ω _ (f i) _ (hτ i)
have h_meas_fst : ∀ t : Set (Set.Iic i × Ω),
Measurable[m_set t] fun x : t => ((x : Set.Iic i × Ω).fst : ι) :=
fun t => (@measurable_subtype_coe (Set.Iic i × Ω) m_prod _).fst.subtype_val
apply Measurable.stronglyMeasurable
refine measurable_of_restrict_of_restrict_compl hs ?_ ?_
· refine @Measurable.min _ _ _ _ _ (m_set s) _ _ _ _ _ (h_meas_fst s) ?_
refine @measurable_of_Iic ι s _ _ _ (m_set s) _ _ _ _ fun j => ?_
have h_set_eq : (fun x : s => τ (x : Set.Iic i × Ω).snd) ⁻¹' Set.Iic j =
(fun x : s => (x : Set.Iic i × Ω).snd) ⁻¹' {ω | τ ω ≤ min i j} := by
ext1 ω
simp only [Set.mem_preimage, Set.mem_Iic, iff_and_self, le_min_iff, Set.mem_setOf_eq]
exact fun _ => ω.prop
rw [h_set_eq]
suffices h_meas : @Measurable _ _ (m_set s) (f i) fun x : s ↦ (x : Set.Iic i × Ω).snd from
h_meas (f.mono (min_le_left _ _) _ (hτ.measurableSet_le (min i j)))
exact measurable_snd.comp (@measurable_subtype_coe _ m_prod _)
· letI sc := sᶜ
suffices h_min_eq_left :
(fun x : sc => min (↑(x : Set.Iic i × Ω).fst) (τ (x : Set.Iic i × Ω).snd)) = fun x : sc =>
↑(x : Set.Iic i × Ω).fst by
simp +unfoldPartialApp only [sc, Set.restrict, h_min_eq_left]
exact h_meas_fst _
ext1 ω
rw [min_eq_left]
have hx_fst_le : ↑(ω : Set.Iic i × Ω).fst ≤ i := (ω : Set.Iic i × Ω).fst.prop
refine hx_fst_le.trans (le_of_lt ?_)
convert ω.prop
simp only [sc, s, not_le, Set.mem_compl_iff, Set.mem_setOf_eq] | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | progMeasurable_min_stopping_time | null |
ProgMeasurable.stoppedProcess [PseudoMetrizableSpace ι] (h : ProgMeasurable f u)
(hτ : IsStoppingTime f τ) : ProgMeasurable f (stoppedProcess u τ) :=
h.comp (progMeasurable_min_stopping_time hτ) fun _ _ => min_le_left _ _ | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | ProgMeasurable.stoppedProcess | null |
ProgMeasurable.adapted_stoppedProcess [PseudoMetrizableSpace ι] (h : ProgMeasurable f u)
(hτ : IsStoppingTime f τ) : Adapted f (MeasureTheory.stoppedProcess u τ) :=
(h.stoppedProcess hτ).adapted | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | ProgMeasurable.adapted_stoppedProcess | null |
ProgMeasurable.stronglyMeasurable_stoppedProcess [PseudoMetrizableSpace ι]
(hu : ProgMeasurable f u) (hτ : IsStoppingTime f τ) (i : ι) :
StronglyMeasurable (MeasureTheory.stoppedProcess u τ i) :=
(hu.adapted_stoppedProcess hτ i).mono (f.le _) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | ProgMeasurable.stronglyMeasurable_stoppedProcess | null |
stronglyMeasurable_stoppedValue_of_le (h : ProgMeasurable f u) (hτ : IsStoppingTime f τ)
{n : ι} (hτ_le : ∀ ω, τ ω ≤ n) : StronglyMeasurable[f n] (stoppedValue u τ) := by
have : stoppedValue u τ =
(fun p : Set.Iic n × Ω => u (↑p.fst) p.snd) ∘ fun ω => (⟨τ ω, hτ_le ω⟩, ω) := by
ext1 ω; simp only [stoppedValue, Function.comp_apply]
rw [this]
refine StronglyMeasurable.comp_measurable (h n) ?_
exact (hτ.measurable_of_le hτ_le).subtype_mk.prodMk measurable_id | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | stronglyMeasurable_stoppedValue_of_le | null |
measurable_stoppedValue [PseudoMetrizableSpace β] [MeasurableSpace β] [BorelSpace β]
(hf_prog : ProgMeasurable f u) (hτ : IsStoppingTime f τ) :
Measurable[hτ.measurableSpace] (stoppedValue u τ) := by
have h_str_meas : ∀ i, StronglyMeasurable[f i] (stoppedValue u fun ω => min (τ ω) i) := fun i =>
stronglyMeasurable_stoppedValue_of_le hf_prog (hτ.min_const i) fun _ => min_le_right _ _
intro t ht i
suffices stoppedValue u τ ⁻¹' t ∩ {ω : Ω | τ ω ≤ i} =
(stoppedValue u fun ω => min (τ ω) i) ⁻¹' t ∩ {ω : Ω | τ ω ≤ i} by
rw [this]; exact ((h_str_meas i).measurable ht).inter (hτ.measurableSet_le i)
ext1 ω
simp only [stoppedValue, Set.mem_inter_iff, Set.mem_preimage, Set.mem_setOf_eq,
and_congr_left_iff]
intro h
rw [min_eq_left h] | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurable_stoppedValue | null |
stoppedValue_eq_of_mem_finset [AddCommMonoid E] {s : Finset ι} (hbdd : ∀ ω, τ ω ∈ s) :
stoppedValue u τ = ∑ i ∈ s, Set.indicator {ω | τ ω = i} (u i) := by
ext y
classical
rw [stoppedValue, Finset.sum_apply, Finset.sum_indicator_eq_sum_filter]
suffices {i ∈ s | y ∈ {ω : Ω | τ ω = i}} = ({τ y} : Finset ι) by
rw [this, Finset.sum_singleton]
ext1 ω
simp only [Set.mem_setOf_eq, Finset.mem_filter, Finset.mem_singleton]
constructor <;> intro h
· exact h.2.symm
· refine ⟨?_, h.symm⟩; rw [h]; exact hbdd y | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | stoppedValue_eq_of_mem_finset | null |
stoppedValue_eq' [Preorder ι] [LocallyFiniteOrderBot ι] [AddCommMonoid E] {N : ι}
(hbdd : ∀ ω, τ ω ≤ N) :
stoppedValue u τ = ∑ i ∈ Finset.Iic N, Set.indicator {ω | τ ω = i} (u i) :=
stoppedValue_eq_of_mem_finset fun ω => Finset.mem_Iic.mpr (hbdd ω) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | stoppedValue_eq' | null |
stoppedProcess_eq_of_mem_finset [LinearOrder ι] [AddCommMonoid E] {s : Finset ι} (n : ι)
(hbdd : ∀ ω, τ ω < n → τ ω ∈ s) : stoppedProcess u τ n = Set.indicator {a | n ≤ τ a} (u n) +
∑ i ∈ s with i < n, Set.indicator {ω | τ ω = i} (u i) := by
ext ω
rw [Pi.add_apply, Finset.sum_apply]
rcases le_or_gt n (τ ω) with h | h
· rw [stoppedProcess_eq_of_le h, Set.indicator_of_mem, Finset.sum_eq_zero, add_zero]
· intro m hm
refine Set.indicator_of_notMem ?_ _
rw [Finset.mem_filter] at hm
exact (hm.2.trans_le h).ne'
· exact h
· rw [stoppedProcess_eq_of_ge (le_of_lt h), Finset.sum_eq_single_of_mem (τ ω)]
· rw [Set.indicator_of_notMem, zero_add, Set.indicator_of_mem] <;> rw [Set.mem_setOf]
exact not_le.2 h
· rw [Finset.mem_filter]
exact ⟨hbdd ω h, h⟩
· intro b _ hneq
rw [Set.indicator_of_notMem]
rw [Set.mem_setOf]
exact hneq.symm | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | stoppedProcess_eq_of_mem_finset | null |
stoppedProcess_eq'' [LinearOrder ι] [LocallyFiniteOrderBot ι] [AddCommMonoid E] (n : ι) :
stoppedProcess u τ n = Set.indicator {a | n ≤ τ a} (u n) +
∑ i ∈ Finset.Iio n, Set.indicator {ω | τ ω = i} (u i) := by
have h_mem : ∀ ω, τ ω < n → τ ω ∈ Finset.Iio n := fun ω h => Finset.mem_Iio.mpr h
rw [stoppedProcess_eq_of_mem_finset n h_mem]
congr with i
simp | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | stoppedProcess_eq'' | null |
memLp_stoppedValue_of_mem_finset (hτ : IsStoppingTime ℱ τ) (hu : ∀ n, MemLp (u n) p μ)
{s : Finset ι} (hbdd : ∀ ω, τ ω ∈ s) : MemLp (stoppedValue u τ) p μ := by
rw [stoppedValue_eq_of_mem_finset hbdd]
refine memLp_finset_sum' _ fun i _ => MemLp.indicator ?_ (hu i)
refine ℱ.le i {a : Ω | τ a = i} (hτ.measurableSet_eq_of_countable_range ?_ i)
refine ((Finset.finite_toSet s).subset fun ω hω => ?_).countable
obtain ⟨y, rfl⟩ := hω
exact hbdd y | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | memLp_stoppedValue_of_mem_finset | null |
memLp_stoppedValue [LocallyFiniteOrderBot ι] (hτ : IsStoppingTime ℱ τ)
(hu : ∀ n, MemLp (u n) p μ) {N : ι} (hbdd : ∀ ω, τ ω ≤ N) : MemLp (stoppedValue u τ) p μ :=
memLp_stoppedValue_of_mem_finset hτ hu fun ω => Finset.mem_Iic.mpr (hbdd ω) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | memLp_stoppedValue | null |
integrable_stoppedValue_of_mem_finset (hτ : IsStoppingTime ℱ τ)
(hu : ∀ n, Integrable (u n) μ) {s : Finset ι} (hbdd : ∀ ω, τ ω ∈ s) :
Integrable (stoppedValue u τ) μ := by
simp_rw [← memLp_one_iff_integrable] at hu ⊢
exact memLp_stoppedValue_of_mem_finset hτ hu hbdd
variable (ι) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | integrable_stoppedValue_of_mem_finset | null |
integrable_stoppedValue [LocallyFiniteOrderBot ι] (hτ : IsStoppingTime ℱ τ)
(hu : ∀ n, Integrable (u n) μ) {N : ι} (hbdd : ∀ ω, τ ω ≤ N) :
Integrable (stoppedValue u τ) μ :=
integrable_stoppedValue_of_mem_finset hτ hu fun ω => Finset.mem_Iic.mpr (hbdd ω) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | integrable_stoppedValue | null |
memLp_stoppedProcess_of_mem_finset (hτ : IsStoppingTime ℱ τ) (hu : ∀ n, MemLp (u n) p μ)
(n : ι) {s : Finset ι} (hbdd : ∀ ω, τ ω < n → τ ω ∈ s) : MemLp (stoppedProcess u τ n) p μ := by
rw [stoppedProcess_eq_of_mem_finset n hbdd]
refine MemLp.add ?_ ?_
· exact MemLp.indicator (ℱ.le n {a : Ω | n ≤ τ a} (hτ.measurableSet_ge n)) (hu n)
· suffices MemLp (fun ω => ∑ i ∈ s with i < n, {a : Ω | τ a = i}.indicator (u i) ω) p μ by
convert this using 1; ext1 ω; simp only [Finset.sum_apply]
refine memLp_finset_sum _ fun i _ => MemLp.indicator ?_ (hu i)
exact ℱ.le i {a : Ω | τ a = i} (hτ.measurableSet_eq i) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | memLp_stoppedProcess_of_mem_finset | null |
memLp_stoppedProcess [LocallyFiniteOrderBot ι] (hτ : IsStoppingTime ℱ τ)
(hu : ∀ n, MemLp (u n) p μ) (n : ι) : MemLp (stoppedProcess u τ n) p μ :=
memLp_stoppedProcess_of_mem_finset hτ hu n fun _ h => Finset.mem_Iio.mpr h | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | memLp_stoppedProcess | null |
integrable_stoppedProcess_of_mem_finset (hτ : IsStoppingTime ℱ τ)
(hu : ∀ n, Integrable (u n) μ) (n : ι) {s : Finset ι} (hbdd : ∀ ω, τ ω < n → τ ω ∈ s) :
Integrable (stoppedProcess u τ n) μ := by
simp_rw [← memLp_one_iff_integrable] at hu ⊢
exact memLp_stoppedProcess_of_mem_finset hτ hu n hbdd | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | integrable_stoppedProcess_of_mem_finset | null |
integrable_stoppedProcess [LocallyFiniteOrderBot ι] (hτ : IsStoppingTime ℱ τ)
(hu : ∀ n, Integrable (u n) μ) (n : ι) : Integrable (stoppedProcess u τ n) μ :=
integrable_stoppedProcess_of_mem_finset hτ hu n fun _ h => Finset.mem_Iio.mpr h | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | integrable_stoppedProcess | null |
Adapted.stoppedProcess [MetrizableSpace ι] (hu : Adapted f u)
(hu_cont : ∀ ω, Continuous fun i => u i ω) (hτ : IsStoppingTime f τ) :
Adapted f (stoppedProcess u τ) :=
((hu.progMeasurable_of_continuous hu_cont).stoppedProcess hτ).adapted | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | Adapted.stoppedProcess | The stopped process of an adapted process with continuous paths is adapted. |
Adapted.stoppedProcess_of_discrete [DiscreteTopology ι] (hu : Adapted f u)
(hτ : IsStoppingTime f τ) : Adapted f (MeasureTheory.stoppedProcess u τ) :=
(hu.progMeasurable_of_discrete.stoppedProcess hτ).adapted | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | Adapted.stoppedProcess_of_discrete | If the indexing order has the discrete topology, then the stopped process of an adapted process
is adapted. |
Adapted.stronglyMeasurable_stoppedProcess [MetrizableSpace ι] (hu : Adapted f u)
(hu_cont : ∀ ω, Continuous fun i => u i ω) (hτ : IsStoppingTime f τ) (n : ι) :
StronglyMeasurable (MeasureTheory.stoppedProcess u τ n) :=
(hu.progMeasurable_of_continuous hu_cont).stronglyMeasurable_stoppedProcess hτ n | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | Adapted.stronglyMeasurable_stoppedProcess | null |
Adapted.stronglyMeasurable_stoppedProcess_of_discrete [DiscreteTopology ι]
(hu : Adapted f u) (hτ : IsStoppingTime f τ) (n : ι) :
StronglyMeasurable (MeasureTheory.stoppedProcess u τ n) :=
hu.progMeasurable_of_discrete.stronglyMeasurable_stoppedProcess hτ n | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | Adapted.stronglyMeasurable_stoppedProcess_of_discrete | null |
stoppedValue_sub_eq_sum [AddCommGroup β] (hle : τ ≤ π) :
stoppedValue u π - stoppedValue u τ = fun ω =>
(∑ i ∈ Finset.Ico (τ ω) (π ω), (u (i + 1) - u i)) ω := by
ext ω
rw [Finset.sum_Ico_eq_sub _ (hle ω), Finset.sum_range_sub, Finset.sum_range_sub]
simp [stoppedValue] | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | stoppedValue_sub_eq_sum | null |
stoppedValue_sub_eq_sum' [AddCommGroup β] (hle : τ ≤ π) {N : ℕ} (hbdd : ∀ ω, π ω ≤ N) :
stoppedValue u π - stoppedValue u τ = fun ω =>
(∑ i ∈ Finset.range (N + 1), Set.indicator {ω | τ ω ≤ i ∧ i < π ω} (u (i + 1) - u i)) ω := by
rw [stoppedValue_sub_eq_sum hle]
ext ω
simp only [Finset.sum_apply, Finset.sum_indicator_eq_sum_filter]
refine Finset.sum_congr ?_ fun _ _ => rfl
ext i
simp only [Finset.mem_filter, Set.mem_setOf_eq, Finset.mem_range, Finset.mem_Ico]
exact ⟨fun h => ⟨lt_trans h.2 (Nat.lt_succ_iff.2 <| hbdd _), h⟩, fun h => h.2⟩ | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | stoppedValue_sub_eq_sum' | null |
stoppedValue_eq {N : ℕ} (hbdd : ∀ ω, τ ω ≤ N) : stoppedValue u τ = fun x =>
(∑ i ∈ Finset.range (N + 1), Set.indicator {ω | τ ω = i} (u i)) x :=
stoppedValue_eq_of_mem_finset fun ω => Finset.mem_range_succ_iff.mpr (hbdd ω) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | stoppedValue_eq | null |
stoppedProcess_eq (n : ℕ) : stoppedProcess u τ n = Set.indicator {a | n ≤ τ a} (u n) +
∑ i ∈ Finset.range n, Set.indicator {ω | τ ω = i} (u i) := by
rw [stoppedProcess_eq'' n]
congr with i
rw [Finset.mem_Iio, Finset.mem_range] | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | stoppedProcess_eq | null |
stoppedProcess_eq' (n : ℕ) : stoppedProcess u τ n = Set.indicator {a | n + 1 ≤ τ a} (u n) +
∑ i ∈ Finset.range (n + 1), Set.indicator {a | τ a = i} (u i) := by
have : {a | n ≤ τ a}.indicator (u n) =
{a | n + 1 ≤ τ a}.indicator (u n) + {a | τ a = n}.indicator (u n) := by
ext x
rw [add_comm, Pi.add_apply, ← Set.indicator_union_of_notMem_inter]
· simp_rw [@eq_comm _ _ n, @le_iff_eq_or_lt _ _ n, Nat.succ_le_iff, Set.setOf_or]
· rintro ⟨h₁, h₂⟩
rw [Set.mem_setOf] at h₁ h₂
exact (Nat.succ_le_iff.1 h₂).ne h₁.symm
rw [stoppedProcess_eq, this, Finset.sum_range_succ_comm, ← add_assoc] | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | stoppedProcess_eq' | null |
IsStoppingTime.piecewise_of_le (hτ_st : IsStoppingTime 𝒢 τ) (hη_st : IsStoppingTime 𝒢 η)
(hτ : ∀ ω, i ≤ τ ω) (hη : ∀ ω, i ≤ η ω) (hs : MeasurableSet[𝒢 i] s) :
IsStoppingTime 𝒢 (s.piecewise τ η) := by
intro n
have : {ω | s.piecewise τ η ω ≤ n} = s ∩ {ω | τ ω ≤ n} ∪ sᶜ ∩ {ω | η ω ≤ n} := by
ext1 ω
simp only [Set.piecewise, Set.mem_setOf_eq]
by_cases hx : ω ∈ s <;> simp [hx]
rw [this]
by_cases hin : i ≤ n
· have hs_n : MeasurableSet[𝒢 n] s := 𝒢.mono hin _ hs
exact (hs_n.inter (hτ_st n)).union (hs_n.compl.inter (hη_st n))
· have hτn : ∀ ω, ¬τ ω ≤ n := fun ω hτn => hin ((hτ ω).trans hτn)
have hηn : ∀ ω, ¬η ω ≤ n := fun ω hηn => hin ((hη ω).trans hηn)
simp [hτn, hηn, @MeasurableSet.empty _ _] | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | IsStoppingTime.piecewise_of_le | Given stopping times `τ` and `η` which are bounded below, `Set.piecewise s τ η` is also
a stopping time with respect to the same filtration. |
isStoppingTime_piecewise_const (hij : i ≤ j) (hs : MeasurableSet[𝒢 i] s) :
IsStoppingTime 𝒢 (s.piecewise (fun _ => i) fun _ => j) :=
(isStoppingTime_const 𝒢 i).piecewise_of_le (isStoppingTime_const 𝒢 j) (fun _ => le_rfl)
(fun _ => hij) hs | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | isStoppingTime_piecewise_const | null |
stoppedValue_piecewise_const {ι' : Type*} {i j : ι'} {f : ι' → Ω → ℝ} :
stoppedValue f (s.piecewise (fun _ => i) fun _ => j) = s.piecewise (f i) (f j) := by
ext ω; rw [stoppedValue]; by_cases hx : ω ∈ s <;> simp [hx] | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | stoppedValue_piecewise_const | null |
stoppedValue_piecewise_const' {ι' : Type*} {i j : ι'} {f : ι' → Ω → ℝ} :
stoppedValue f (s.piecewise (fun _ => i) fun _ => j) =
s.indicator (f i) + sᶜ.indicator (f j) := by
ext ω; rw [stoppedValue]; by_cases hx : ω ∈ s <;> simp [hx] | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | stoppedValue_piecewise_const' | null |
condExp_stopping_time_ae_eq_restrict_eq_of_countable_range [SigmaFiniteFiltration μ ℱ]
(hτ : IsStoppingTime ℱ τ) (h_countable : (Set.range τ).Countable)
[SigmaFinite (μ.trim (hτ.measurableSpace_le_of_countable_range h_countable))] (i : ι) :
μ[f|hτ.measurableSpace] =ᵐ[μ.restrict {x | τ x = i}] μ[f|ℱ i] := by
refine condExp_ae_eq_restrict_of_measurableSpace_eq_on
(hτ.measurableSpace_le_of_countable_range h_countable) (ℱ.le i)
(hτ.measurableSet_eq_of_countable_range' h_countable i) fun t => ?_
rw [Set.inter_comm _ t, IsStoppingTime.measurableSet_inter_eq_iff] | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | condExp_stopping_time_ae_eq_restrict_eq_of_countable_range | null |
condExp_stopping_time_ae_eq_restrict_eq_of_countable [Countable ι]
[SigmaFiniteFiltration μ ℱ] (hτ : IsStoppingTime ℱ τ)
[SigmaFinite (μ.trim hτ.measurableSpace_le_of_countable)] (i : ι) :
μ[f|hτ.measurableSpace] =ᵐ[μ.restrict {x | τ x = i}] μ[f|ℱ i] :=
condExp_stopping_time_ae_eq_restrict_eq_of_countable_range hτ (Set.to_countable _) i
variable [(Filter.atTop : Filter ι).IsCountablyGenerated] | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | condExp_stopping_time_ae_eq_restrict_eq_of_countable | null |
condExp_min_stopping_time_ae_eq_restrict_le_const (hτ : IsStoppingTime ℱ τ) (i : ι)
[SigmaFinite (μ.trim (hτ.min_const i).measurableSpace_le)] :
μ[f|(hτ.min_const i).measurableSpace] =ᵐ[μ.restrict {x | τ x ≤ i}] μ[f|hτ.measurableSpace] := by
have : SigmaFinite (μ.trim hτ.measurableSpace_le) :=
haveI h_le : (hτ.min_const i).measurableSpace ≤ hτ.measurableSpace := by
rw [IsStoppingTime.measurableSpace_min_const]
exact inf_le_left
sigmaFiniteTrim_mono _ h_le
refine (condExp_ae_eq_restrict_of_measurableSpace_eq_on hτ.measurableSpace_le
(hτ.min_const i).measurableSpace_le (hτ.measurableSet_le' i) fun t => ?_).symm
rw [Set.inter_comm _ t, hτ.measurableSet_inter_le_const_iff]
variable [TopologicalSpace ι] [OrderTopology ι] | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | condExp_min_stopping_time_ae_eq_restrict_le_const | null |
condExp_stopping_time_ae_eq_restrict_eq [FirstCountableTopology ι]
[SigmaFiniteFiltration μ ℱ] (hτ : IsStoppingTime ℱ τ)
[SigmaFinite (μ.trim hτ.measurableSpace_le)] (i : ι) :
μ[f|hτ.measurableSpace] =ᵐ[μ.restrict {x | τ x = i}] μ[f|ℱ i] := by
refine condExp_ae_eq_restrict_of_measurableSpace_eq_on hτ.measurableSpace_le (ℱ.le i)
(hτ.measurableSet_eq' i) fun t => ?_
rw [Set.inter_comm _ t, IsStoppingTime.measurableSet_inter_eq_iff] | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | condExp_stopping_time_ae_eq_restrict_eq | null |
condExp_min_stopping_time_ae_eq_restrict_le [MeasurableSpace ι] [SecondCountableTopology ι]
[BorelSpace ι] (hτ : IsStoppingTime ℱ τ) (hσ : IsStoppingTime ℱ σ)
[SigmaFinite (μ.trim (hτ.min hσ).measurableSpace_le)] :
μ[f|(hτ.min hσ).measurableSpace] =ᵐ[μ.restrict {x | τ x ≤ σ x}] μ[f|hτ.measurableSpace] := by
have : SigmaFinite (μ.trim hτ.measurableSpace_le) :=
haveI h_le : (hτ.min hσ).measurableSpace ≤ hτ.measurableSpace := by
rw [IsStoppingTime.measurableSpace_min]
· exact inf_le_left
· simp_all only
sigmaFiniteTrim_mono _ h_le
refine (condExp_ae_eq_restrict_of_measurableSpace_eq_on hτ.measurableSpace_le
(hτ.min hσ).measurableSpace_le (hτ.measurableSet_le_stopping_time hσ) fun t => ?_).symm
rw [Set.inter_comm _ t, IsStoppingTime.measurableSet_inter_le_iff]; simp_all only | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | condExp_min_stopping_time_ae_eq_restrict_le | null |
noncomputable
avgRisk {m𝓨 : MeasurableSpace 𝓨}
(ℓ : Θ → 𝓨 → ℝ≥0∞) (P : Kernel Θ 𝓧) (κ : Kernel 𝓧 𝓨) (π : Measure Θ) : ℝ≥0∞ :=
∫⁻ θ, ∫⁻ y, ℓ θ y ∂((κ ∘ₖ P) θ) ∂π | def | Probability | [
"Mathlib.Probability.Kernel.Composition.Comp"
] | Mathlib/Probability/Decision/Risk/Defs.lean | avgRisk | The average risk of an estimator `κ` on an estimation task with loss `ℓ` and
data generating kernel `P` with respect to a prior `π`. |
noncomputable
bayesRisk [MeasurableSpace 𝓨] (ℓ : Θ → 𝓨 → ℝ≥0∞) (P : Kernel Θ 𝓧) (π : Measure Θ) : ℝ≥0∞ :=
⨅ (κ : Kernel 𝓧 𝓨) (_ : IsMarkovKernel κ), avgRisk ℓ P κ π | def | Probability | [
"Mathlib.Probability.Kernel.Composition.Comp"
] | Mathlib/Probability/Decision/Risk/Defs.lean | bayesRisk | The Bayes risk with respect to a prior `π`, defined as the infimum of the average risks of all
estimators. |
noncomputable
minimaxRisk [MeasurableSpace 𝓨] (ℓ : Θ → 𝓨 → ℝ≥0∞) (P : Kernel Θ 𝓧) : ℝ≥0∞ :=
⨅ (κ : Kernel 𝓧 𝓨) (_ : IsMarkovKernel κ), ⨆ θ, ∫⁻ y, ℓ θ y ∂((κ ∘ₖ P) θ)
variable {m𝓨 : MeasurableSpace 𝓨}
{ℓ : Θ → 𝓨 → ℝ≥0∞} {P : Kernel Θ 𝓧} {κ : Kernel 𝓧 𝓨} {π : Measure Θ} | def | Probability | [
"Mathlib.Probability.Kernel.Composition.Comp"
] | Mathlib/Probability/Decision/Risk/Defs.lean | minimaxRisk | The minimax risk, defined as the infimum over estimators of the maximal risk of
the estimator. |
@[simp]
avgRisk_zero_left (ℓ : Θ → 𝓨 → ℝ≥0∞) (κ : Kernel 𝓧 𝓨) (π : Measure Θ) :
avgRisk ℓ (0 : Kernel Θ 𝓧) κ π = 0 := by simp [avgRisk]
@[simp] | lemma | Probability | [
"Mathlib.Probability.Kernel.Composition.Comp"
] | Mathlib/Probability/Decision/Risk/Defs.lean | avgRisk_zero_left | null |
avgRisk_zero_right (ℓ : Θ → 𝓨 → ℝ≥0∞) (P : Kernel Θ 𝓧) (π : Measure Θ) :
avgRisk ℓ P (0 : Kernel 𝓧 𝓨) π = 0 := by simp [avgRisk]
@[simp] | lemma | Probability | [
"Mathlib.Probability.Kernel.Composition.Comp"
] | Mathlib/Probability/Decision/Risk/Defs.lean | avgRisk_zero_right | null |
avgRisk_zero_prior (ℓ : Θ → 𝓨 → ℝ≥0∞) (P : Kernel Θ 𝓧) (κ : Kernel 𝓧 𝓨) :
avgRisk ℓ P κ 0 = 0 := by simp [avgRisk]
@[simp] | lemma | Probability | [
"Mathlib.Probability.Kernel.Composition.Comp"
] | Mathlib/Probability/Decision/Risk/Defs.lean | avgRisk_zero_prior | null |
bayesRisk_zero_left [Nonempty 𝓨] (ℓ : Θ → 𝓨 → ℝ≥0∞) (π : Measure Θ) :
bayesRisk ℓ (0 : Kernel Θ 𝓧) π = 0 := by simp [bayesRisk, iInf_subtype']
@[simp] | lemma | Probability | [
"Mathlib.Probability.Kernel.Composition.Comp"
] | Mathlib/Probability/Decision/Risk/Defs.lean | bayesRisk_zero_left | null |
bayesRisk_zero_right [Nonempty 𝓨] (ℓ : Θ → 𝓨 → ℝ≥0∞) (P : Kernel Θ 𝓧) :
bayesRisk ℓ P (0 : Measure Θ) = 0 := by simp [bayesRisk, iInf_subtype']
@[simp] | lemma | Probability | [
"Mathlib.Probability.Kernel.Composition.Comp"
] | Mathlib/Probability/Decision/Risk/Defs.lean | bayesRisk_zero_right | null |
minimaxRisk_zero [Nonempty 𝓨] (ℓ : Θ → 𝓨 → ℝ≥0∞) :
minimaxRisk ℓ (0 : Kernel Θ 𝓧) = 0 := by simp [minimaxRisk, iInf_subtype'] | lemma | Probability | [
"Mathlib.Probability.Kernel.Composition.Comp"
] | Mathlib/Probability/Decision/Risk/Defs.lean | minimaxRisk_zero | null |
@[simp]
avgRisk_of_isEmpty [IsEmpty 𝓧] : avgRisk ℓ P κ π = 0 := by
simp [Subsingleton.elim P 0]
@[simp] | lemma | Probability | [
"Mathlib.Probability.Kernel.Composition.Comp"
] | Mathlib/Probability/Decision/Risk/Defs.lean | avgRisk_of_isEmpty | null |
avgRisk_of_isEmpty' [IsEmpty 𝓨] : avgRisk ℓ P κ π = 0 := by
simp [Subsingleton.elim κ 0]
@[simp] | lemma | Probability | [
"Mathlib.Probability.Kernel.Composition.Comp"
] | Mathlib/Probability/Decision/Risk/Defs.lean | avgRisk_of_isEmpty' | null |
avgRisk_of_isEmpty'' [IsEmpty Θ] : avgRisk ℓ P κ π = 0 := by
simp [avgRisk]
@[simp] | lemma | Probability | [
"Mathlib.Probability.Kernel.Composition.Comp"
] | Mathlib/Probability/Decision/Risk/Defs.lean | avgRisk_of_isEmpty'' | null |
bayesRisk_of_isEmpty [IsEmpty 𝓧] : bayesRisk ℓ P π = 0 := by
simp [bayesRisk]
@[simp] | lemma | Probability | [
"Mathlib.Probability.Kernel.Composition.Comp"
] | Mathlib/Probability/Decision/Risk/Defs.lean | bayesRisk_of_isEmpty | null |
bayesRisk_of_isEmpty' [Nonempty 𝓧] [IsEmpty 𝓨] :
bayesRisk ℓ P π = ∞ := by
have : IsEmpty (Subtype (@IsMarkovKernel 𝓧 𝓨 m𝓧 m𝓨)) := by
simp only [isEmpty_subtype]
exact fun κ ↦ Subsingleton.elim κ 0 ▸ Kernel.not_isMarkovKernel_zero
simp [bayesRisk, iInf_subtype']
@[simp] | lemma | Probability | [
"Mathlib.Probability.Kernel.Composition.Comp"
] | Mathlib/Probability/Decision/Risk/Defs.lean | bayesRisk_of_isEmpty' | null |
bayesRisk_of_isEmpty'' [IsEmpty Θ] [Nonempty 𝓨] :
bayesRisk ℓ P π = 0 := by
simp [bayesRisk, iInf_subtype']
@[simp] | lemma | Probability | [
"Mathlib.Probability.Kernel.Composition.Comp"
] | Mathlib/Probability/Decision/Risk/Defs.lean | bayesRisk_of_isEmpty'' | null |
minimaxRisk_of_isEmpty [IsEmpty 𝓧] : minimaxRisk ℓ P = 0 := by
simp [minimaxRisk, Subsingleton.elim P 0]
@[simp] | lemma | Probability | [
"Mathlib.Probability.Kernel.Composition.Comp"
] | Mathlib/Probability/Decision/Risk/Defs.lean | minimaxRisk_of_isEmpty | null |
minimaxRisk_of_isEmpty' [Nonempty 𝓧] [IsEmpty 𝓨] : minimaxRisk ℓ P = ∞ := by
have : IsEmpty (Subtype (@IsMarkovKernel 𝓧 𝓨 m𝓧 m𝓨)) := by
simp only [isEmpty_subtype]
exact fun κ ↦ Subsingleton.elim κ 0 ▸ Kernel.not_isMarkovKernel_zero
simp [minimaxRisk, iInf_subtype']
@[simp] | lemma | Probability | [
"Mathlib.Probability.Kernel.Composition.Comp"
] | Mathlib/Probability/Decision/Risk/Defs.lean | minimaxRisk_of_isEmpty' | null |
minimaxRisk_of_isEmpty'' [Nonempty 𝓨] [IsEmpty Θ] : minimaxRisk ℓ P = 0 := by
simp [minimaxRisk, iInf_subtype'] | lemma | Probability | [
"Mathlib.Probability.Kernel.Composition.Comp"
] | Mathlib/Probability/Decision/Risk/Defs.lean | minimaxRisk_of_isEmpty'' | null |
IsGaussian {E : Type*} [TopologicalSpace E] [AddCommMonoid E] [Module ℝ E]
{mE : MeasurableSpace E} (μ : Measure E) : Prop where
map_eq_gaussianReal (L : StrongDual ℝ E) : μ.map L = gaussianReal (μ[L]) (Var[L; μ]).toNNReal | class | Probability | [
"Mathlib.Probability.Distributions.Gaussian.Real"
] | Mathlib/Probability/Distributions/Gaussian/Basic.lean | IsGaussian | A measure is Gaussian if its map by every continuous linear form is a real Gaussian measure. |
IsGaussian.toIsProbabilityMeasure {E : Type*} [TopologicalSpace E] [AddCommMonoid E]
[Module ℝ E] {mE : MeasurableSpace E} (μ : Measure E) [IsGaussian μ] :
IsProbabilityMeasure μ where
measure_univ := by
have : μ.map (0 : StrongDual ℝ E) Set.univ = 1 := by simp [IsGaussian.map_eq_gaussianReal]
simpa [Measure.map_apply (by fun_prop : Measurable (0 : StrongDual ℝ E)) .univ] using this | instance | Probability | [
"Mathlib.Probability.Distributions.Gaussian.Real"
] | Mathlib/Probability/Distributions/Gaussian/Basic.lean | IsGaussian.toIsProbabilityMeasure | A Gaussian measure is a probability measure. |
isGaussian_gaussianReal (m : ℝ) (v : ℝ≥0) : IsGaussian (gaussianReal m v) where
map_eq_gaussianReal L := by
rw [gaussianReal_map_continuousLinearMap]
simp only [integral_continuousLinearMap_gaussianReal, variance_continuousLinearMap_gaussianReal,
Real.coe_toNNReal']
congr
rw [Real.toNNReal_mul (by positivity), Real.toNNReal_coe]
congr
simp only [left_eq_sup]
positivity
variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [MeasurableSpace E] [BorelSpace E]
[NormedAddCommGroup F] [NormedSpace ℝ F] [MeasurableSpace F] [BorelSpace F]
{μ : Measure E} [IsGaussian μ] | instance | Probability | [
"Mathlib.Probability.Distributions.Gaussian.Real"
] | Mathlib/Probability/Distributions/Gaussian/Basic.lean | isGaussian_gaussianReal | A real Gaussian measure is Gaussian. |
isGaussian_map (L : E →L[ℝ] F) : IsGaussian (μ.map L) where
map_eq_gaussianReal L' := by
rw [Measure.map_map (by fun_prop) (by fun_prop)]
change Measure.map (L'.comp L) μ = _
rw [IsGaussian.map_eq_gaussianReal (L'.comp L)]
congr
· rw [integral_map (by fun_prop) (by fun_prop)]
simp
· rw [← variance_id_map (by fun_prop)]
conv_rhs => rw [← variance_id_map (by fun_prop)]
rw [Measure.map_map (by fun_prop) (by fun_prop)]
simp | instance | Probability | [
"Mathlib.Probability.Distributions.Gaussian.Real"
] | Mathlib/Probability/Distributions/Gaussian/Basic.lean | isGaussian_map | Dirac measures are Gaussian. -/
instance {x : E} : IsGaussian (Measure.dirac x) where
map_eq_gaussianReal L := by rw [Measure.map_dirac (by fun_prop)]; simp
lemma IsGaussian.memLp_dual (μ : Measure E) [IsGaussian μ] (L : StrongDual ℝ E)
(p : ℝ≥0∞) (hp : p ≠ ∞) :
MemLp L p μ := by
suffices MemLp (id ∘ L) p μ from this
rw [← memLp_map_measure_iff (by fun_prop) (by fun_prop), IsGaussian.map_eq_gaussianReal L]
convert memLp_id_gaussianReal p.toNNReal
simp [hp]
@[fun_prop]
lemma IsGaussian.integrable_dual (μ : Measure E) [IsGaussian μ] (L : StrongDual ℝ E) :
Integrable L μ := by
rw [← memLp_one_iff_integrable]
exact IsGaussian.memLp_dual μ L 1 (by simp)
/-- The map of a Gaussian measure by a continuous linear map is Gaussian. |
isGaussian_map_equiv (L : E ≃L[ℝ] F) : IsGaussian (μ.map L) :=
isGaussian_map (L : E →L[ℝ] F) | instance | Probability | [
"Mathlib.Probability.Distributions.Gaussian.Real"
] | Mathlib/Probability/Distributions/Gaussian/Basic.lean | isGaussian_map_equiv | null |
isGaussian_map_equiv_iff {μ : Measure E} (L : E ≃L[ℝ] F) :
IsGaussian (μ.map L) ↔ IsGaussian μ := by
refine ⟨fun h ↦ ?_, fun _ ↦ inferInstance⟩
suffices μ = (μ.map L).map L.symm by rw [this]; infer_instance
rw [Measure.map_map (by fun_prop) (by fun_prop)]
simp | lemma | Probability | [
"Mathlib.Probability.Distributions.Gaussian.Real"
] | Mathlib/Probability/Distributions/Gaussian/Basic.lean | isGaussian_map_equiv_iff | null |
IsGaussian.charFunDual_eq (L : StrongDual ℝ E) :
charFunDual μ L = exp (μ[L] * I - Var[L; μ] / 2) := by
calc charFunDual μ L
_ = charFun (μ.map L) 1 := by rw [charFunDual_eq_charFun_map_one]
_ = charFun (gaussianReal (μ[L]) (Var[L; μ]).toNNReal) 1 := by
rw [IsGaussian.map_eq_gaussianReal L]
_ = exp (μ[L] * I - Var[L; μ] / 2) := by
rw [charFun_gaussianReal]
simp only [ofReal_one, one_mul, Real.coe_toNNReal', one_pow, mul_one]
congr
· rw [integral_complex_ofReal]
· simp only [sup_eq_left]
exact variance_nonneg _ _ | lemma | Probability | [
"Mathlib.Probability.Distributions.Gaussian.Real"
] | Mathlib/Probability/Distributions/Gaussian/Basic.lean | IsGaussian.charFunDual_eq | The characteristic function of a Gaussian measure `μ` has value
`exp (μ[L] * I - Var[L; μ] / 2)` at `L : Dual ℝ E`. |
isGaussian_iff_charFunDual_eq {μ : Measure E} [IsFiniteMeasure μ] :
IsGaussian μ ↔ ∀ L : StrongDual ℝ E, charFunDual μ L = exp (μ[L] * I - Var[L; μ] / 2) := by
refine ⟨fun h ↦ h.charFunDual_eq, fun h ↦ ⟨fun L ↦ Measure.ext_of_charFun ?_⟩⟩
ext u
rw [charFun_map_eq_charFunDual_smul L u, h (u • L), charFun_gaussianReal]
simp only [ContinuousLinearMap.coe_smul', Pi.smul_apply, smul_eq_mul, ofReal_mul,
Real.coe_toNNReal']
congr
· rw [integral_const_mul, integral_complex_ofReal]
· rw [max_eq_left (variance_nonneg _ _), mul_comm, ← ofReal_pow, ← ofReal_mul, ← variance_mul]
congr
alias ⟨_, isGaussian_of_charFunDual_eq⟩ := isGaussian_iff_charFunDual_eq | theorem | Probability | [
"Mathlib.Probability.Distributions.Gaussian.Real"
] | Mathlib/Probability/Distributions/Gaussian/Basic.lean | isGaussian_iff_charFunDual_eq | A finite measure is Gaussian iff its characteristic function has value
`exp (μ[L] * I - Var[L; μ] / 2)` for every `L : Dual ℝ E`. |
isGaussian_conv [SecondCountableTopology E]
{μ ν : Measure E} [IsGaussian μ] [IsGaussian ν] :
IsGaussian (μ ∗ ν) where
map_eq_gaussianReal L := by
have : (μ ∗ ν)[L] = ∫ x, x ∂((μ.map L).conv (ν.map L)) := by
rw [← Measure.map_conv_continuousLinearMap L,
integral_map (φ := L) (by fun_prop) (by fun_prop)]
rw [Measure.map_conv_continuousLinearMap L, this, ← variance_id_map (by fun_prop),
Measure.map_conv_continuousLinearMap L, IsGaussian.map_eq_gaussianReal L,
IsGaussian.map_eq_gaussianReal L, gaussianReal_conv_gaussianReal]
congr <;> simp [variance_nonneg] | instance | Probability | [
"Mathlib.Probability.Distributions.Gaussian.Real"
] | Mathlib/Probability/Distributions/Gaussian/Basic.lean | isGaussian_conv | null |
noncomputable
gaussianPDFReal (μ : ℝ) (v : ℝ≥0) (x : ℝ) : ℝ :=
(√(2 * π * v))⁻¹ * rexp (- (x - μ)^2 / (2 * v)) | def | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | gaussianPDFReal | Probability density function of the Gaussian distribution with mean `μ` and variance `v`. |
gaussianPDFReal_def (μ : ℝ) (v : ℝ≥0) :
gaussianPDFReal μ v =
fun x ↦ (√(2 * π * v))⁻¹ * rexp (- (x - μ)^2 / (2 * v)) := rfl
@[simp] | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | gaussianPDFReal_def | null |
gaussianPDFReal_zero_var (m : ℝ) : gaussianPDFReal m 0 = 0 := by
ext1 x
simp [gaussianPDFReal] | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | gaussianPDFReal_zero_var | null |
gaussianPDFReal_pos (μ : ℝ) (v : ℝ≥0) (x : ℝ) (hv : v ≠ 0) : 0 < gaussianPDFReal μ v x := by
rw [gaussianPDFReal]
positivity | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | gaussianPDFReal_pos | The Gaussian pdf is positive when the variance is not zero. |
gaussianPDFReal_nonneg (μ : ℝ) (v : ℝ≥0) (x : ℝ) : 0 ≤ gaussianPDFReal μ v x := by
rw [gaussianPDFReal]
positivity | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | gaussianPDFReal_nonneg | The Gaussian pdf is nonnegative. |
@[fun_prop]
measurable_gaussianPDFReal (μ : ℝ) (v : ℝ≥0) : Measurable (gaussianPDFReal μ v) :=
(((measurable_id.add_const _).pow_const _).neg.div_const _).exp.const_mul _ | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | measurable_gaussianPDFReal | The Gaussian pdf is measurable. |
@[fun_prop]
stronglyMeasurable_gaussianPDFReal (μ : ℝ) (v : ℝ≥0) :
StronglyMeasurable (gaussianPDFReal μ v) :=
(measurable_gaussianPDFReal μ v).stronglyMeasurable
@[fun_prop] | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | stronglyMeasurable_gaussianPDFReal | The Gaussian pdf is strongly measurable. |
integrable_gaussianPDFReal (μ : ℝ) (v : ℝ≥0) :
Integrable (gaussianPDFReal μ v) := by
rw [gaussianPDFReal_def]
by_cases hv : v = 0
· simp [hv]
let g : ℝ → ℝ := fun x ↦ (√(2 * π * v))⁻¹ * rexp (- x ^ 2 / (2 * v))
have hg : Integrable g := by
suffices g = fun x ↦ (√(2 * π * v))⁻¹ * rexp (- (2 * v)⁻¹ * x ^ 2) by
rw [this]
refine (integrable_exp_neg_mul_sq ?_).const_mul (√(2 * π * v))⁻¹
simp [lt_of_le_of_ne (zero_le _) (Ne.symm hv)]
ext x
simp only [g, NNReal.zero_le_coe, Real.sqrt_mul',
mul_inv_rev, NNReal.coe_mul, NNReal.coe_inv, NNReal.coe_ofNat, neg_mul, mul_eq_mul_left_iff,
Real.exp_eq_exp, mul_eq_zero, inv_eq_zero, Real.sqrt_eq_zero, NNReal.coe_eq_zero, hv,
false_or]
rw [mul_comm]
left
field_simp
exact Integrable.comp_sub_right hg μ | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | integrable_gaussianPDFReal | null |
lintegral_gaussianPDFReal_eq_one (μ : ℝ) {v : ℝ≥0} (h : v ≠ 0) :
∫⁻ x, ENNReal.ofReal (gaussianPDFReal μ v x) = 1 := by
rw [← ENNReal.toReal_eq_one_iff]
have hfm : AEStronglyMeasurable (gaussianPDFReal μ v) volume := by fun_prop
have hf : 0 ≤ₐₛ gaussianPDFReal μ v := ae_of_all _ (gaussianPDFReal_nonneg μ v)
rw [← integral_eq_lintegral_of_nonneg_ae hf hfm]
simp only [gaussianPDFReal,
integral_const_mul]
rw [integral_sub_right_eq_self (μ := volume) (fun a ↦ rexp (-a ^ 2 / ((2 : ℝ) * v))) μ]
simp only [div_eq_inv_mul, mul_inv_rev,
mul_neg]
simp_rw [← neg_mul]
rw [neg_mul, integral_gaussian, ← Real.sqrt_inv, ← Real.sqrt_mul]
· simp [field]
· positivity | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | lintegral_gaussianPDFReal_eq_one | The Gaussian distribution pdf integrates to 1 when the variance is not zero. |
integral_gaussianPDFReal_eq_one (μ : ℝ) {v : ℝ≥0} (hv : v ≠ 0) :
∫ x, gaussianPDFReal μ v x = 1 := by
have h := lintegral_gaussianPDFReal_eq_one μ hv
rw [← ofReal_integral_eq_lintegral_ofReal (integrable_gaussianPDFReal _ _)
(ae_of_all _ (gaussianPDFReal_nonneg _ _)), ← ENNReal.ofReal_one] at h
rwa [← ENNReal.ofReal_eq_ofReal_iff (integral_nonneg (gaussianPDFReal_nonneg _ _)) zero_le_one] | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | integral_gaussianPDFReal_eq_one | The Gaussian distribution pdf integrates to 1 when the variance is not zero. |
gaussianPDFReal_sub {μ : ℝ} {v : ℝ≥0} (x y : ℝ) :
gaussianPDFReal μ v (x - y) = gaussianPDFReal (μ + y) v x := by
simp only [gaussianPDFReal]
rw [sub_add_eq_sub_sub_swap] | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | gaussianPDFReal_sub | null |
gaussianPDFReal_add {μ : ℝ} {v : ℝ≥0} (x y : ℝ) :
gaussianPDFReal μ v (x + y) = gaussianPDFReal (μ - y) v x := by
rw [sub_eq_add_neg, ← gaussianPDFReal_sub, sub_eq_add_neg, neg_neg] | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | gaussianPDFReal_add | null |
gaussianPDFReal_inv_mul {μ : ℝ} {v : ℝ≥0} {c : ℝ} (hc : c ≠ 0) (x : ℝ) :
gaussianPDFReal μ v (c⁻¹ * x) = |c| * gaussianPDFReal (c * μ) (⟨c^2, sq_nonneg _⟩ * v) x := by
simp only [gaussianPDFReal.eq_1, NNReal.zero_le_coe,
Real.sqrt_mul', mul_inv_rev, NNReal.coe_mul, NNReal.coe_mk]
rw [← mul_assoc]
refine congr_arg₂ _ ?_ ?_
· simp (disch := positivity) only [Real.sqrt_mul, mul_inv_rev, field]
rw [Real.sqrt_sq_eq_abs]
· congr 1
field_simp | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | gaussianPDFReal_inv_mul | null |
gaussianPDFReal_mul {μ : ℝ} {v : ℝ≥0} {c : ℝ} (hc : c ≠ 0) (x : ℝ) :
gaussianPDFReal μ v (c * x)
= |c⁻¹| * gaussianPDFReal (c⁻¹ * μ) (⟨(c^2)⁻¹, inv_nonneg.mpr (sq_nonneg _)⟩ * v) x := by
conv_lhs => rw [← inv_inv c, gaussianPDFReal_inv_mul (inv_ne_zero hc)]
simp | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | gaussianPDFReal_mul | null |
noncomputable
gaussianPDF (μ : ℝ) (v : ℝ≥0) (x : ℝ) : ℝ≥0∞ := ENNReal.ofReal (gaussianPDFReal μ v x) | def | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | gaussianPDF | The pdf of a Gaussian distribution on ℝ with mean `μ` and variance `v`. |
gaussianPDF_def (μ : ℝ) (v : ℝ≥0) :
gaussianPDF μ v = fun x ↦ ENNReal.ofReal (gaussianPDFReal μ v x) := rfl
@[simp] | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | gaussianPDF_def | null |
gaussianPDF_zero_var (μ : ℝ) : gaussianPDF μ 0 = 0 := by ext; simp [gaussianPDF]
@[simp] | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | gaussianPDF_zero_var | null |
toReal_gaussianPDF {μ : ℝ} {v : ℝ≥0} (x : ℝ) :
(gaussianPDF μ v x).toReal = gaussianPDFReal μ v x := by
rw [gaussianPDF, ENNReal.toReal_ofReal (gaussianPDFReal_nonneg μ v x)] | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | toReal_gaussianPDF | null |
gaussianPDF_pos (μ : ℝ) {v : ℝ≥0} (hv : v ≠ 0) (x : ℝ) : 0 < gaussianPDF μ v x := by
rw [gaussianPDF, ENNReal.ofReal_pos]
exact gaussianPDFReal_pos _ _ _ hv | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | gaussianPDF_pos | null |
gaussianPDF_lt_top {μ : ℝ} {v : ℝ≥0} {x : ℝ} : gaussianPDF μ v x < ∞ := by simp [gaussianPDF] | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | gaussianPDF_lt_top | null |
gaussianPDF_ne_top {μ : ℝ} {v : ℝ≥0} {x : ℝ} : gaussianPDF μ v x ≠ ∞ := by simp [gaussianPDF]
@[simp] | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | gaussianPDF_ne_top | null |
support_gaussianPDF {μ : ℝ} {v : ℝ≥0} (hv : v ≠ 0) :
Function.support (gaussianPDF μ v) = Set.univ := by
ext x
simp only [Set.mem_univ, iff_true]
exact (gaussianPDF_pos _ hv x).ne'
@[measurability, fun_prop] | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | support_gaussianPDF | null |
measurable_gaussianPDF (μ : ℝ) (v : ℝ≥0) : Measurable (gaussianPDF μ v) :=
(measurable_gaussianPDFReal _ _).ennreal_ofReal
@[simp] | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | measurable_gaussianPDF | null |
lintegral_gaussianPDF_eq_one (μ : ℝ) {v : ℝ≥0} (h : v ≠ 0) :
∫⁻ x, gaussianPDF μ v x = 1 :=
lintegral_gaussianPDFReal_eq_one μ h | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | lintegral_gaussianPDF_eq_one | null |
noncomputable
gaussianReal (μ : ℝ) (v : ℝ≥0) : Measure ℝ :=
if v = 0 then Measure.dirac μ else volume.withDensity (gaussianPDF μ v) | def | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | gaussianReal | A Gaussian distribution on `ℝ` with mean `μ` and variance `v`. |
gaussianReal_of_var_ne_zero (μ : ℝ) {v : ℝ≥0} (hv : v ≠ 0) :
gaussianReal μ v = volume.withDensity (gaussianPDF μ v) := if_neg hv
@[simp] | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | gaussianReal_of_var_ne_zero | null |
gaussianReal_zero_var (μ : ℝ) : gaussianReal μ 0 = Measure.dirac μ := if_pos rfl | lemma | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | gaussianReal_zero_var | null |
instIsProbabilityMeasureGaussianReal (μ : ℝ) (v : ℝ≥0) :
IsProbabilityMeasure (gaussianReal μ v) where
measure_univ := by by_cases h : v = 0 <;> simp [gaussianReal_of_var_ne_zero, h] | instance | Probability | [
"Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform",
"Mathlib.MeasureTheory.Group.Convolution",
"Mathlib.Probability.Moments.MGFAnalytic",
"Mathlib.Probability.Independence.Basic"
] | Mathlib/Probability/Distributions/Gaussian/Real.lean | instIsProbabilityMeasureGaussianReal | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.