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 ⌀ |
|---|---|---|---|---|---|---|
stoppedValue_hitting_mem [ConditionallyCompleteLinearOrder ι] [WellFoundedLT ι]
{u : ι → Ω → β} {s : Set β} {n m : ι} {ω : Ω} (h : ∃ j ∈ Set.Icc n m, u j ω ∈ s) :
stoppedValue u (hitting u s n m) ω ∈ s := by
simp only [stoppedValue, hitting, if_pos h]
obtain ⟨j, hj₁, hj₂⟩ := h
have : sInf (Set.Icc n m ∩ {i | u i ω ∈ s}) ∈ Set.Icc n m ∩ {i | u i ω ∈ s} :=
csInf_mem (Set.nonempty_of_mem ⟨hj₁, hj₂⟩)
exact this.2 | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | stoppedValue_hitting_mem | null |
isStoppingTime_hitting_isStoppingTime [ConditionallyCompleteLinearOrder ι]
[WellFoundedLT ι] [Countable ι] [TopologicalSpace ι] [OrderTopology ι]
[FirstCountableTopology ι] [TopologicalSpace β] [PseudoMetrizableSpace β] [MeasurableSpace β]
[BorelSpace β] {f : Filtration ι m} {u : ι → Ω → β} {τ : Ω → ι} (hτ : IsStoppingTime f τ)
{N : ι} (hτbdd : ∀ x, τ x ≤ N) {s : Set β} (hs : MeasurableSet s) (hf : Adapted f u) :
IsStoppingTime f fun x => hitting u s (τ x) N x := by
intro n
have h₁ : {x | hitting u s (τ x) N x ≤ n} =
(⋃ i ≤ n, {x | τ x = i} ∩ {x | hitting u s i N x ≤ n}) ∪
⋃ i > n, {x | τ x = i} ∩ {x | hitting u s i N x ≤ n} := by
ext x
simp [← or_and_right, le_or_gt]
have h₂ : ⋃ i > n, {x | τ x = i} ∩ {x | hitting u s i N x ≤ n} = ∅ := by
ext x
simp only [gt_iff_lt, Set.mem_iUnion, Set.mem_inter_iff, Set.mem_setOf_eq, exists_prop,
Set.mem_empty_iff_false, iff_false, not_exists, not_and, not_le]
rintro m hm rfl
exact lt_of_lt_of_le hm (le_hitting (hτbdd _) _)
rw [h₁, h₂, Set.union_empty]
exact MeasurableSet.iUnion fun i => MeasurableSet.iUnion fun hi =>
(f.mono hi _ (hτ.measurableSet_eq i)).inter (hitting_isStoppingTime hf hs n) | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | isStoppingTime_hitting_isStoppingTime | The hitting time of a discrete process with the starting time indexed by a stopping time
is a stopping time. |
hitting_eq_sInf (ω : Ω) : hitting u s ⊥ ⊤ ω = sInf {i : ι | u i ω ∈ s} := by
simp only [hitting, Set.Icc_bot,
Set.Iic_top, Set.univ_inter, ite_eq_left_iff, not_exists]
intro h_notMem_s
symm
rw [sInf_eq_top]
simp only [Set.mem_univ, true_and] at h_notMem_s
exact fun i hi_mem_s => absurd hi_mem_s (h_notMem_s i) | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | hitting_eq_sInf | null |
hitting_bot_le_iff {i n : ι} {ω : Ω} (hx : ∃ j, j ≤ n ∧ u j ω ∈ s) :
hitting u s ⊥ n ω ≤ i ↔ ∃ j ≤ i, u j ω ∈ s := by
rcases lt_or_ge i n with hi | hi
· rw [hitting_le_iff_of_lt _ hi]
simp
· simp only [(hitting_le ω).trans hi, true_iff]
obtain ⟨j, hj₁, hj₂⟩ := hx
exact ⟨j, hj₁.trans hi, hj₂⟩ | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | hitting_bot_le_iff | null |
IsKolmogorovProcess (X : T → Ω → E) (P : Measure Ω) (p q : ℝ) (M : ℝ≥0) : Prop where
measurablePair : ∀ s t : T, Measurable[_, borel (E × E)] fun ω ↦ (X s ω, X t ω)
kolmogorovCondition : ∀ s t : T, ∫⁻ ω, edist (X s ω) (X t ω) ^ p ∂P ≤ M * edist s t ^ q
p_pos : 0 < p
q_pos : 0 < q | structure | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | IsKolmogorovProcess | A stochastic process `X : T → Ω → E` on an index space `T` and a measurable space `Ω`
with measure `P` is said to satisfy the Kolmogorov condition with exponents `p, q` and constant `M`
if for all `s, t : T`, the pair `(X s, X t)` is measurable for the Borel sigma-algebra on `E × E`
and the following condition holds: `∫⁻ ω, edist (X s ω) (X t ω) ^ p ∂P ≤ M * edist s t ^ q`. |
IsAEKolmogorovProcess (X : T → Ω → E) (P : Measure Ω) (p q : ℝ) (M : ℝ≥0) : Prop :=
∃ Y, IsKolmogorovProcess Y P p q M ∧ ∀ t, X t =ᵐ[P] Y t | def | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | IsAEKolmogorovProcess | Property of being a modification of a stochastic process that satisfies the Kolmogorov
condition (`IsKolmogorovProcess`). |
IsKolmogorovProcess.IsAEKolmogorovProcess (hX : IsKolmogorovProcess X P p q M) :
IsAEKolmogorovProcess X P p q M := ⟨X, hX, by simp⟩ | lemma | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | IsKolmogorovProcess.IsAEKolmogorovProcess | null |
protected noncomputable
mk (X : T → Ω → E) (h : IsAEKolmogorovProcess X P p q M) : T → Ω → E :=
Classical.choose h | def | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | mk | A process with the property `IsKolmogorovProcess` such that `∀ t, X t =ᵐ[P] h.mk X t`. |
IsKolmogorovProcess_mk (h : IsAEKolmogorovProcess X P p q M) :
IsKolmogorovProcess (h.mk X) P p q M := (Classical.choose_spec h).1 | lemma | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | IsKolmogorovProcess_mk | null |
ae_eq_mk (h : IsAEKolmogorovProcess X P p q M) : ∀ t, X t =ᵐ[P] h.mk X t :=
(Classical.choose_spec h).2 | lemma | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | ae_eq_mk | null |
kolmogorovCondition (hX : IsAEKolmogorovProcess X P p q M) (s t : T) :
∫⁻ ω, edist (X s ω) (X t ω) ^ p ∂P ≤ M * edist s t ^ q := by
convert hX.IsKolmogorovProcess_mk.kolmogorovCondition s t using 1
refine lintegral_congr_ae ?_
filter_upwards [hX.ae_eq_mk s, hX.ae_eq_mk t] with ω hω₁ hω₂
simp_rw [hω₁, hω₂] | lemma | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | kolmogorovCondition | null |
p_pos (hX : IsAEKolmogorovProcess X P p q M) : 0 < p := hX.IsKolmogorovProcess_mk.p_pos | lemma | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | p_pos | null |
q_pos (hX : IsAEKolmogorovProcess X P p q M) : 0 < q := hX.IsKolmogorovProcess_mk.q_pos | lemma | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | q_pos | null |
congr {Y : T → Ω → E} (hX : IsAEKolmogorovProcess X P p q M)
(h : ∀ t, X t =ᵐ[P] Y t) :
IsAEKolmogorovProcess Y P p q M := by
refine ⟨hX.mk X, hX.IsKolmogorovProcess_mk, fun t ↦ ?_⟩
filter_upwards [hX.ae_eq_mk t, h t] with ω hX hY using hY.symm.trans hX | lemma | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | congr | null |
IsKolmogorovProcess.stronglyMeasurable_edist
(hX : IsKolmogorovProcess X P p q M) {s t : T} :
StronglyMeasurable (fun ω ↦ edist (X s ω) (X t ω)) := by
borelize (E × E)
exact continuous_edist.stronglyMeasurable.comp_measurable (hX.measurablePair s t) | lemma | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | IsKolmogorovProcess.stronglyMeasurable_edist | null |
IsAEKolmogorovProcess.aestronglyMeasurable_edist
(hX : IsAEKolmogorovProcess X P p q M) {s t : T} :
AEStronglyMeasurable (fun ω ↦ edist (X s ω) (X t ω)) P := by
refine ⟨(fun ω ↦ edist (hX.mk X s ω) (hX.mk X t ω)),
hX.IsKolmogorovProcess_mk.stronglyMeasurable_edist, ?_⟩
filter_upwards [hX.ae_eq_mk s, hX.ae_eq_mk t] with ω hω₁ hω₂ using by simp [hω₁, hω₂] | lemma | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | IsAEKolmogorovProcess.aestronglyMeasurable_edist | null |
IsKolmogorovProcess.measurable_edist (hX : IsKolmogorovProcess X P p q M) {s t : T} :
Measurable (fun ω ↦ edist (X s ω) (X t ω)) := hX.stronglyMeasurable_edist.measurable | lemma | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | IsKolmogorovProcess.measurable_edist | null |
IsAEKolmogorovProcess.aemeasurable_edist (hX : IsAEKolmogorovProcess X P p q M) {s t : T} :
AEMeasurable (fun ω ↦ edist (X s ω) (X t ω)) P := hX.aestronglyMeasurable_edist.aemeasurable
variable [MeasurableSpace E] [BorelSpace E] | lemma | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | IsAEKolmogorovProcess.aemeasurable_edist | null |
IsKolmogorovProcess.measurable (hX : IsKolmogorovProcess X P p q M) (s : T) :
Measurable (X s) :=
(measurable_fst.mono prod_le_borel_prod le_rfl).comp (hX.measurablePair s s) | lemma | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | IsKolmogorovProcess.measurable | null |
IsAEKolmogorovProcess.aemeasurable (hX : IsAEKolmogorovProcess X P p q M) (s : T) :
AEMeasurable (X s) P := by
refine ⟨hX.mk X s, hX.IsKolmogorovProcess_mk.measurable s, ?_⟩
filter_upwards [hX.ae_eq_mk s] with ω hω using hω | lemma | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | IsAEKolmogorovProcess.aemeasurable | null |
IsKolmogorovProcess.mk_of_secondCountableTopology [SecondCountableTopology E]
(h_meas : ∀ s, Measurable (X s))
(h_kol : ∀ s t : T, ∫⁻ ω, (edist (X s ω) (X t ω)) ^ p ∂P ≤ M * edist s t ^ q)
(hp : 0 < p) (hq : 0 < q) :
IsKolmogorovProcess X P p q M where
measurablePair s t := by
suffices Measurable (fun ω ↦ (X s ω, X t ω)) by
rwa [Prod.borelSpace.measurable_eq] at this
fun_prop
kolmogorovCondition := h_kol
p_pos := hp
q_pos := hq | lemma | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | IsKolmogorovProcess.mk_of_secondCountableTopology | null |
IsAEKolmogorovProcess.edist_eq_zero (hX : IsAEKolmogorovProcess X P p q M)
{s t : T} (h : edist s t = 0) :
∀ᵐ ω ∂P, edist (X s ω) (X t ω) = 0 := by
suffices ∀ᵐ ω ∂P, edist (X s ω) (X t ω) ^ p = 0 by
filter_upwards [this] with ω hω
simpa [hX.p_pos, not_lt_of_gt hX.p_pos] using hω
refine (lintegral_eq_zero_iff' (hX.aemeasurable_edist.pow_const p)).mp ?_
refine le_antisymm ?_ zero_le'
calc ∫⁻ ω, edist (X s ω) (X t ω) ^ p ∂P
_ ≤ M * edist s t ^ q := hX.kolmogorovCondition s t
_ = 0 := by simp [h, hX.q_pos] | lemma | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | IsAEKolmogorovProcess.edist_eq_zero | null |
IsKolmogorovProcess.edist_eq_zero (hX : IsKolmogorovProcess X P p q M)
{s t : T} (h : edist s t = 0) :
∀ᵐ ω ∂P, edist (X s ω) (X t ω) = 0 :=
hX.IsAEKolmogorovProcess.edist_eq_zero h | lemma | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | IsKolmogorovProcess.edist_eq_zero | null |
IsAEKolmogorovProcess.edist_eq_zero_of_const_eq_zero (hX : IsAEKolmogorovProcess X P p q 0)
(s t : T) :
∀ᵐ ω ∂P, edist (X s ω) (X t ω) = 0 := by
suffices ∀ᵐ ω ∂P, edist (X s ω) (X t ω) ^ p = 0 by
filter_upwards [this] with ω hω
simpa [hX.p_pos, not_lt_of_gt hX.p_pos] using hω
refine (lintegral_eq_zero_iff' (hX.aemeasurable_edist.pow_const p)).mp ?_
refine le_antisymm ?_ zero_le'
calc ∫⁻ ω, edist (X s ω) (X t ω) ^ p ∂P
_ ≤ 0 * edist s t ^ q := hX.kolmogorovCondition s t
_ = 0 := by simp | lemma | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | IsAEKolmogorovProcess.edist_eq_zero_of_const_eq_zero | null |
IsKolmogorovProcess.edist_eq_zero_of_const_eq_zero (hX : IsKolmogorovProcess X P p q 0)
(s t : T) :
∀ᵐ ω ∂P, edist (X s ω) (X t ω) = 0 :=
hX.IsAEKolmogorovProcess.edist_eq_zero_of_const_eq_zero s t | lemma | Probability | [
"Mathlib.MeasureTheory.Function.SpecialFunctions.Basic",
"Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable",
"Mathlib.MeasureTheory.Integral.Lebesgue.Basic"
] | Mathlib/Probability/Process/Kolmogorov.lean | IsKolmogorovProcess.edist_eq_zero_of_const_eq_zero | null |
partitionFiltration (ht : ∀ n, MeasurableSet (t n)) :
Filtration ℕ m where
seq n := generateFrom (memPartition t n)
mono' := monotone_nat_of_le_succ (generateFrom_memPartition_le_succ _)
le' := generateFrom_memPartition_le ht | def | Probability | [
"Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated",
"Mathlib.Probability.Process.Filtration"
] | Mathlib/Probability/Process/PartitionFiltration.lean | partitionFiltration | A filtration built from the measurable spaces generated by the partitions `memPartition t n` for
all `n : ℕ`. |
measurableSet_partitionFiltration_of_mem (ht : ∀ n, MeasurableSet (t n)) (n : ℕ) {s : Set α}
(hs : s ∈ memPartition t n) :
MeasurableSet[partitionFiltration ht n] s :=
measurableSet_generateFrom hs | lemma | Probability | [
"Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated",
"Mathlib.Probability.Process.Filtration"
] | Mathlib/Probability/Process/PartitionFiltration.lean | measurableSet_partitionFiltration_of_mem | null |
measurableSet_partitionFiltration_memPartitionSet (ht : ∀ n, MeasurableSet (t n))
(n : ℕ) (a : α) :
MeasurableSet[partitionFiltration ht n] (memPartitionSet t n a) :=
measurableSet_partitionFiltration_of_mem ht n (memPartitionSet_mem t n a) | lemma | Probability | [
"Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated",
"Mathlib.Probability.Process.Filtration"
] | Mathlib/Probability/Process/PartitionFiltration.lean | measurableSet_partitionFiltration_memPartitionSet | null |
measurable_memPartitionSet_subtype (ht : ∀ n, MeasurableSet (t n)) (n : ℕ)
(m : MeasurableSpace (memPartition t n)) :
@Measurable α (memPartition t n) (partitionFiltration ht n) m
(fun a ↦ ⟨memPartitionSet t n a, memPartitionSet_mem t n a⟩) := by
refine @measurable_to_countable' (memPartition t n) α m _
(partitionFiltration ht n) _ (fun s ↦ ?_)
rcases s with ⟨s, hs⟩
suffices MeasurableSet[partitionFiltration ht n] {x | memPartitionSet t n x = s} by
convert this
ext x
simp
simp_rw [memPartitionSet_eq_iff _ hs]
exact measurableSet_partitionFiltration_of_mem _ _ hs | lemma | Probability | [
"Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated",
"Mathlib.Probability.Process.Filtration"
] | Mathlib/Probability/Process/PartitionFiltration.lean | measurable_memPartitionSet_subtype | null |
measurable_partitionFiltration_memPartitionSet (ht : ∀ n, MeasurableSet (t n)) (n : ℕ) :
Measurable[partitionFiltration ht n] (memPartitionSet t n) :=
measurable_subtype_coe.comp (measurable_memPartitionSet_subtype ht _ _) | lemma | Probability | [
"Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated",
"Mathlib.Probability.Process.Filtration"
] | Mathlib/Probability/Process/PartitionFiltration.lean | measurable_partitionFiltration_memPartitionSet | null |
measurable_memPartitionSet (ht : ∀ n, MeasurableSet (t n)) (n : ℕ) :
Measurable (memPartitionSet t n) :=
(measurable_partitionFiltration_memPartitionSet ht n).mono ((partitionFiltration ht).le n) le_rfl | lemma | Probability | [
"Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated",
"Mathlib.Probability.Process.Filtration"
] | Mathlib/Probability/Process/PartitionFiltration.lean | measurable_memPartitionSet | null |
iSup_partitionFiltration_eq_generateFrom_range (ht : ∀ n, MeasurableSet (t n)) :
⨆ n, partitionFiltration ht n = generateFrom (Set.range t) := by
conv_rhs => rw [← generateFrom_iUnion_memPartition t, ← iSup_generateFrom]
rfl | lemma | Probability | [
"Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated",
"Mathlib.Probability.Process.Filtration"
] | Mathlib/Probability/Process/PartitionFiltration.lean | iSup_partitionFiltration_eq_generateFrom_range | null |
iSup_partitionFiltration (ht : ∀ n, MeasurableSet (t n))
(ht_range : generateFrom (Set.range t) = m) :
⨆ n, partitionFiltration ht n = m := by
rw [iSup_partitionFiltration_eq_generateFrom_range ht, ht_range] | lemma | Probability | [
"Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated",
"Mathlib.Probability.Process.Filtration"
] | Mathlib/Probability/Process/PartitionFiltration.lean | iSup_partitionFiltration | null |
countableFiltration (α : Type*) [m : MeasurableSpace α] [CountablyGenerated α] :
Filtration ℕ m where
seq n := generateFrom (countablePartition α n)
mono' := monotone_nat_of_le_succ (generateFrom_countablePartition_le_succ _)
le' := generateFrom_countablePartition_le α | def | Probability | [
"Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated",
"Mathlib.Probability.Process.Filtration"
] | Mathlib/Probability/Process/PartitionFiltration.lean | countableFiltration | A filtration built from the measurable spaces generated by `countablePartition α n` for
all `n : ℕ`. |
measurableSet_countableFiltration_of_mem (n : ℕ) {s : Set α}
(hs : s ∈ countablePartition α n) :
MeasurableSet[countableFiltration α n] s :=
measurableSet_generateFrom hs | lemma | Probability | [
"Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated",
"Mathlib.Probability.Process.Filtration"
] | Mathlib/Probability/Process/PartitionFiltration.lean | measurableSet_countableFiltration_of_mem | null |
measurableSet_countableFiltration_countablePartitionSet (n : ℕ) (t : α) :
MeasurableSet[countableFiltration α n] (countablePartitionSet n t) :=
measurableSet_countableFiltration_of_mem n (countablePartitionSet_mem n t) | lemma | Probability | [
"Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated",
"Mathlib.Probability.Process.Filtration"
] | Mathlib/Probability/Process/PartitionFiltration.lean | measurableSet_countableFiltration_countablePartitionSet | null |
measurable_countablePartitionSet_subtype (n : ℕ)
(m : MeasurableSpace (countablePartition α n)) :
@Measurable α (countablePartition α n) (countableFiltration α n) m
(fun a ↦ ⟨countablePartitionSet n a, countablePartitionSet_mem n a⟩) :=
measurable_memPartitionSet_subtype
(measurableSet_enumerateCountable_countableGeneratingSet (α := α)) n m | lemma | Probability | [
"Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated",
"Mathlib.Probability.Process.Filtration"
] | Mathlib/Probability/Process/PartitionFiltration.lean | measurable_countablePartitionSet_subtype | null |
measurable_countableFiltration_countablePartitionSet (α : Type*)
[MeasurableSpace α] [CountablyGenerated α] (n : ℕ) :
Measurable[countableFiltration α n] (countablePartitionSet n) :=
measurable_subtype_coe.comp (measurable_countablePartitionSet_subtype _ _) | lemma | Probability | [
"Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated",
"Mathlib.Probability.Process.Filtration"
] | Mathlib/Probability/Process/PartitionFiltration.lean | measurable_countableFiltration_countablePartitionSet | null |
measurable_countablePartitionSet (α : Type*) [MeasurableSpace α] [CountablyGenerated α]
(n : ℕ) :
Measurable (countablePartitionSet (α := α) n) :=
(measurable_countableFiltration_countablePartitionSet α n).mono ((countableFiltration α).le n)
le_rfl | lemma | Probability | [
"Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated",
"Mathlib.Probability.Process.Filtration"
] | Mathlib/Probability/Process/PartitionFiltration.lean | measurable_countablePartitionSet | null |
iSup_countableFiltration (α : Type*) [m : MeasurableSpace α] [CountablyGenerated α] :
⨆ n, countableFiltration α n = m := by
conv_rhs => rw [← generateFrom_iUnion_countablePartition α, ← iSup_generateFrom]
rfl | lemma | Probability | [
"Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated",
"Mathlib.Probability.Process.Filtration"
] | Mathlib/Probability/Process/PartitionFiltration.lean | iSup_countableFiltration | null |
IsStoppingTime [Preorder ι] (f : Filtration ι m) (τ : Ω → ι) :=
∀ i : ι, MeasurableSet[f i] <| {ω | τ ω ≤ i} | def | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | IsStoppingTime | A stopping time with respect to some filtration `f` is a function
`τ` such that for all `i`, the preimage of `{j | j ≤ i}` along `τ` is measurable
with respect to `f i`.
Intuitively, the stopping time `τ` describes some stopping rule such that at time
`i`, we may determine it with the information we have at time `i`. |
isStoppingTime_const [Preorder ι] (f : Filtration ι m) (i : ι) :
IsStoppingTime f fun _ => i := fun j => by simp only [MeasurableSet.const] | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | isStoppingTime_const | null |
protected IsStoppingTime.measurableSet_le (hτ : IsStoppingTime f τ) (i : ι) :
MeasurableSet[f i] {ω | τ ω ≤ i} :=
hτ i | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | IsStoppingTime.measurableSet_le | null |
IsStoppingTime.measurableSet_lt_of_pred [PredOrder ι] (hτ : IsStoppingTime f τ) (i : ι) :
MeasurableSet[f i] {ω | τ ω < i} := by
by_cases hi_min : IsMin i
· suffices {ω : Ω | τ ω < i} = ∅ by rw [this]; exact @MeasurableSet.empty _ (f i)
ext1 ω
simp only [Set.mem_setOf_eq, Set.mem_empty_iff_false, iff_false]
rw [isMin_iff_forall_not_lt] at hi_min
exact hi_min (τ ω)
have : {ω : Ω | τ ω < i} = τ ⁻¹' Set.Iic (pred i) := by ext; simp [Iic_pred_of_not_isMin hi_min]
rw [this]
exact f.mono (pred_le i) _ (hτ.measurableSet_le <| pred i) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | IsStoppingTime.measurableSet_lt_of_pred | null |
protected measurableSet_eq_of_countable_range (hτ : IsStoppingTime f τ)
(h_countable : (Set.range τ).Countable) (i : ι) : MeasurableSet[f i] {ω | τ ω = i} := by
have : {ω | τ ω = i} = {ω | τ ω ≤ i} \ ⋃ (j ∈ Set.range τ) (_ : j < i), {ω | τ ω ≤ j} := by
ext1 a
simp only [Set.mem_setOf_eq, Set.mem_range, Set.iUnion_exists, Set.iUnion_iUnion_eq',
Set.mem_diff, Set.mem_iUnion, exists_prop, not_exists, not_and]
constructor <;> intro h
· simp only [h, lt_iff_le_not_ge, le_refl, and_imp, imp_self, imp_true_iff, and_self_iff]
· exact h.1.eq_or_lt.resolve_right fun h_lt => h.2 a h_lt le_rfl
rw [this]
refine (hτ.measurableSet_le i).diff ?_
refine MeasurableSet.biUnion h_countable fun j _ => ?_
classical
rw [Set.iUnion_eq_if]
split_ifs with hji
· exact f.mono hji.le _ (hτ.measurableSet_le j)
· exact @MeasurableSet.empty _ (f i) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_eq_of_countable_range | null |
protected measurableSet_eq_of_countable [Countable ι] (hτ : IsStoppingTime f τ) (i : ι) :
MeasurableSet[f i] {ω | τ ω = i} :=
hτ.measurableSet_eq_of_countable_range (Set.to_countable _) i | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_eq_of_countable | null |
protected measurableSet_lt_of_countable_range (hτ : IsStoppingTime f τ)
(h_countable : (Set.range τ).Countable) (i : ι) : MeasurableSet[f i] {ω | τ ω < i} := by
have : {ω | τ ω < i} = {ω | τ ω ≤ i} \ {ω | τ ω = i} := by ext1 ω; simp [lt_iff_le_and_ne]
rw [this]
exact (hτ.measurableSet_le i).diff (hτ.measurableSet_eq_of_countable_range h_countable i) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_lt_of_countable_range | null |
protected measurableSet_lt_of_countable [Countable ι] (hτ : IsStoppingTime f τ) (i : ι) :
MeasurableSet[f i] {ω | τ ω < i} :=
hτ.measurableSet_lt_of_countable_range (Set.to_countable _) i | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_lt_of_countable | null |
protected measurableSet_ge_of_countable_range {ι} [LinearOrder ι] {τ : Ω → ι}
{f : Filtration ι m} (hτ : IsStoppingTime f τ) (h_countable : (Set.range τ).Countable) (i : ι) :
MeasurableSet[f i] {ω | i ≤ τ ω} := by
have : {ω | i ≤ τ ω} = {ω | τ ω < i}ᶜ := by
ext1 ω; simp only [Set.mem_setOf_eq, Set.mem_compl_iff, not_lt]
rw [this]
exact (hτ.measurableSet_lt_of_countable_range h_countable i).compl | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_ge_of_countable_range | null |
protected measurableSet_ge_of_countable {ι} [LinearOrder ι] {τ : Ω → ι} {f : Filtration ι m}
[Countable ι] (hτ : IsStoppingTime f τ) (i : ι) : MeasurableSet[f i] {ω | i ≤ τ ω} :=
hτ.measurableSet_ge_of_countable_range (Set.to_countable _) i | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_ge_of_countable | null |
IsStoppingTime.measurableSet_gt (hτ : IsStoppingTime f τ) (i : ι) :
MeasurableSet[f i] {ω | i < τ ω} := by
have : {ω | i < τ ω} = {ω | τ ω ≤ i}ᶜ := by
ext1 ω; simp only [Set.mem_setOf_eq, Set.mem_compl_iff, not_le]
rw [this]
exact (hτ.measurableSet_le i).compl | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | IsStoppingTime.measurableSet_gt | null |
IsStoppingTime.measurableSet_lt_of_isLUB (hτ : IsStoppingTime f τ) (i : ι)
(h_lub : IsLUB (Set.Iio i) i) : MeasurableSet[f i] {ω | τ ω < i} := by
by_cases hi_min : IsMin i
· suffices {ω | τ ω < i} = ∅ by rw [this]; exact @MeasurableSet.empty _ (f i)
ext1 ω
simp only [Set.mem_setOf_eq, Set.mem_empty_iff_false, iff_false]
exact isMin_iff_forall_not_lt.mp hi_min (τ ω)
obtain ⟨seq, -, -, h_tendsto, h_bound⟩ :
∃ seq : ℕ → ι, Monotone seq ∧ (∀ j, seq j ≤ i) ∧ Tendsto seq atTop (𝓝 i) ∧ ∀ j, seq j < i :=
h_lub.exists_seq_monotone_tendsto (not_isMin_iff.mp hi_min)
have h_Ioi_eq_Union : Set.Iio i = ⋃ j, {k | k ≤ seq j} := by
ext1 k
simp only [Set.mem_Iio, Set.mem_iUnion, Set.mem_setOf_eq]
refine ⟨fun hk_lt_i => ?_, fun h_exists_k_le_seq => ?_⟩
· rw [tendsto_atTop'] at h_tendsto
have h_nhds : Set.Ici k ∈ 𝓝 i :=
mem_nhds_iff.mpr ⟨Set.Ioi k, Set.Ioi_subset_Ici le_rfl, isOpen_Ioi, hk_lt_i⟩
obtain ⟨a, ha⟩ : ∃ a : ℕ, ∀ b : ℕ, b ≥ a → k ≤ seq b := h_tendsto (Set.Ici k) h_nhds
exact ⟨a, ha a le_rfl⟩
· obtain ⟨j, hk_seq_j⟩ := h_exists_k_le_seq
exact hk_seq_j.trans_lt (h_bound j)
have h_lt_eq_preimage : {ω | τ ω < i} = τ ⁻¹' Set.Iio i := by
ext1 ω; simp only [Set.mem_setOf_eq, Set.mem_preimage, Set.mem_Iio]
rw [h_lt_eq_preimage, h_Ioi_eq_Union]
simp only [Set.preimage_iUnion, Set.preimage_setOf_eq]
exact MeasurableSet.iUnion fun n => f.mono (h_bound n).le _ (hτ.measurableSet_le (seq n)) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | IsStoppingTime.measurableSet_lt_of_isLUB | Auxiliary lemma for `MeasureTheory.IsStoppingTime.measurableSet_lt`. |
IsStoppingTime.measurableSet_lt (hτ : IsStoppingTime f τ) (i : ι) :
MeasurableSet[f i] {ω | τ ω < i} := by
obtain ⟨i', hi'_lub⟩ : ∃ i', IsLUB (Set.Iio i) i' := exists_lub_Iio i
rcases lub_Iio_eq_self_or_Iio_eq_Iic i hi'_lub with hi'_eq_i | h_Iio_eq_Iic
· rw [← hi'_eq_i] at hi'_lub ⊢
exact hτ.measurableSet_lt_of_isLUB i' hi'_lub
· have h_lt_eq_preimage : {ω : Ω | τ ω < i} = τ ⁻¹' Set.Iio i := rfl
rw [h_lt_eq_preimage, h_Iio_eq_Iic]
exact f.mono (lub_Iio_le i hi'_lub) _ (hτ.measurableSet_le i') | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | IsStoppingTime.measurableSet_lt | null |
IsStoppingTime.measurableSet_ge (hτ : IsStoppingTime f τ) (i : ι) :
MeasurableSet[f i] {ω | i ≤ τ ω} := by
have : {ω | i ≤ τ ω} = {ω | τ ω < i}ᶜ := by
ext1 ω; simp only [Set.mem_setOf_eq, Set.mem_compl_iff, not_lt]
rw [this]
exact (hτ.measurableSet_lt i).compl | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | IsStoppingTime.measurableSet_ge | null |
IsStoppingTime.measurableSet_eq (hτ : IsStoppingTime f τ) (i : ι) :
MeasurableSet[f i] {ω | τ ω = i} := by
have : {ω | τ ω = i} = {ω | τ ω ≤ i} ∩ {ω | τ ω ≥ i} := by
ext1 ω; simp only [Set.mem_setOf_eq, Set.mem_inter_iff, le_antisymm_iff]
rw [this]
exact (hτ.measurableSet_le i).inter (hτ.measurableSet_ge i) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | IsStoppingTime.measurableSet_eq | null |
IsStoppingTime.measurableSet_eq_le (hτ : IsStoppingTime f τ) {i j : ι} (hle : i ≤ j) :
MeasurableSet[f j] {ω | τ ω = i} :=
f.mono hle _ <| hτ.measurableSet_eq i | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | IsStoppingTime.measurableSet_eq_le | null |
IsStoppingTime.measurableSet_lt_le (hτ : IsStoppingTime f τ) {i j : ι} (hle : i ≤ j) :
MeasurableSet[f j] {ω | τ ω < i} :=
f.mono hle _ <| hτ.measurableSet_lt i | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | IsStoppingTime.measurableSet_lt_le | null |
isStoppingTime_of_measurableSet_eq [Preorder ι] [Countable ι] {f : Filtration ι m}
{τ : Ω → ι} (hτ : ∀ i, MeasurableSet[f i] {ω | τ ω = i}) : IsStoppingTime f τ := by
intro i
rw [show {ω | τ ω ≤ i} = ⋃ k ≤ i, {ω | τ ω = k} by ext; simp]
refine MeasurableSet.biUnion (Set.to_countable _) fun k hk => ?_
exact f.mono hk _ (hτ k) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | isStoppingTime_of_measurableSet_eq | null |
protected max [LinearOrder ι] {f : Filtration ι m} {τ π : Ω → ι} (hτ : IsStoppingTime f τ)
(hπ : IsStoppingTime f π) : IsStoppingTime f fun ω => max (τ ω) (π ω) := by
intro i
simp_rw [max_le_iff, Set.setOf_and]
exact (hτ i).inter (hπ i) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | max | null |
protected max_const [LinearOrder ι] {f : Filtration ι m} {τ : Ω → ι}
(hτ : IsStoppingTime f τ) (i : ι) : IsStoppingTime f fun ω => max (τ ω) i :=
hτ.max (isStoppingTime_const f i) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | max_const | null |
protected min [LinearOrder ι] {f : Filtration ι m} {τ π : Ω → ι} (hτ : IsStoppingTime f τ)
(hπ : IsStoppingTime f π) : IsStoppingTime f fun ω => min (τ ω) (π ω) := by
intro i
simp_rw [min_le_iff, Set.setOf_or]
exact (hτ i).union (hπ i) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | min | null |
protected min_const [LinearOrder ι] {f : Filtration ι m} {τ : Ω → ι}
(hτ : IsStoppingTime f τ) (i : ι) : IsStoppingTime f fun ω => min (τ ω) i :=
hτ.min (isStoppingTime_const f i) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | min_const | null |
add_const [AddGroup ι] [Preorder ι] [AddRightMono ι]
[AddLeftMono ι] {f : Filtration ι m} {τ : Ω → ι} (hτ : IsStoppingTime f τ)
{i : ι} (hi : 0 ≤ i) : IsStoppingTime f fun ω => τ ω + i := by
intro j
simp_rw [← le_sub_iff_add_le]
exact f.mono (sub_le_self j hi) _ (hτ (j - i)) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | add_const | null |
add_const_nat {f : Filtration ℕ m} {τ : Ω → ℕ} (hτ : IsStoppingTime f τ) {i : ℕ} :
IsStoppingTime f fun ω => τ ω + i := by
refine isStoppingTime_of_measurableSet_eq fun j => ?_
by_cases hij : i ≤ j
· simp_rw [eq_comm, ← Nat.sub_eq_iff_eq_add hij, eq_comm]
exact f.mono (j.sub_le i) _ (hτ.measurableSet_eq (j - i))
· rw [not_le] at hij
convert @MeasurableSet.empty _ (f.1 j)
ext ω
simp only [Set.mem_empty_iff_false, iff_false, Set.mem_setOf]
cutsat | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | add_const_nat | null |
add {f : Filtration ℕ m} {τ π : Ω → ℕ} (hτ : IsStoppingTime f τ) (hπ : IsStoppingTime f π) :
IsStoppingTime f (τ + π) := by
intro i
rw [(_ : {ω | (τ + π) ω ≤ i} = ⋃ k ≤ i, {ω | π ω = k} ∩ {ω | τ ω + k ≤ i})]
· exact MeasurableSet.iUnion fun k =>
MeasurableSet.iUnion fun hk => (hπ.measurableSet_eq_le hk).inter (hτ.add_const_nat i)
ext ω
simp only [Pi.add_apply, Set.mem_setOf_eq, Set.mem_iUnion, Set.mem_inter_iff, exists_prop]
refine ⟨fun h => ⟨π ω, by cutsat, rfl, h⟩, ?_⟩
rintro ⟨j, hj, rfl, h⟩
assumption | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | add | null |
protected measurableSpace (hτ : IsStoppingTime f τ) : MeasurableSpace Ω where
MeasurableSet' s := ∀ i : ι, MeasurableSet[f i] (s ∩ {ω | τ ω ≤ i})
measurableSet_empty i := (Set.empty_inter {ω | τ ω ≤ i}).symm ▸ @MeasurableSet.empty _ (f i)
measurableSet_compl s hs i := by
rw [(_ : sᶜ ∩ {ω | τ ω ≤ i} = (sᶜ ∪ {ω | τ ω ≤ i}ᶜ) ∩ {ω | τ ω ≤ i})]
· refine MeasurableSet.inter ?_ ?_
· rw [← Set.compl_inter]
exact (hs i).compl
· exact hτ i
· rw [Set.union_inter_distrib_right]
simp only [Set.compl_inter_self, Set.union_empty]
measurableSet_iUnion s hs i := by
rw [forall_swap] at hs
rw [Set.iUnion_inter]
exact MeasurableSet.iUnion (hs i) | def | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSpace | The associated σ-algebra with a stopping time. |
protected measurableSet (hτ : IsStoppingTime f τ) (s : Set Ω) :
MeasurableSet[hτ.measurableSpace] s ↔ ∀ i : ι, MeasurableSet[f i] (s ∩ {ω | τ ω ≤ i}) :=
Iff.rfl | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet | null |
measurableSpace_mono (hτ : IsStoppingTime f τ) (hπ : IsStoppingTime f π) (hle : τ ≤ π) :
hτ.measurableSpace ≤ hπ.measurableSpace := by
intro s hs i
rw [(_ : s ∩ {ω | π ω ≤ i} = s ∩ {ω | τ ω ≤ i} ∩ {ω | π ω ≤ i})]
· exact (hs i).inter (hπ i)
· ext
simp only [Set.mem_inter_iff, iff_self_and, and_congr_left_iff, Set.mem_setOf_eq]
intro hle' _
exact le_trans (hle _) hle' | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSpace_mono | null |
measurableSpace_le_of_countable [Countable ι] (hτ : IsStoppingTime f τ) :
hτ.measurableSpace ≤ m := by
intro s hs
change ∀ i, MeasurableSet[f i] (s ∩ {ω | τ ω ≤ i}) at hs
rw [(_ : s = ⋃ i, s ∩ {ω | τ ω ≤ i})]
· exact MeasurableSet.iUnion fun i => f.le i _ (hs i)
· ext ω; constructor <;> rw [Set.mem_iUnion]
· exact fun hx => ⟨τ ω, hx, le_rfl⟩
· rintro ⟨_, hx, _⟩
exact hx | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSpace_le_of_countable | null |
measurableSpace_le [IsCountablyGenerated (atTop : Filter ι)] [IsDirected ι (· ≤ ·)]
(hτ : IsStoppingTime f τ) : hτ.measurableSpace ≤ m := by
intro s hs
cases isEmpty_or_nonempty ι
· haveI : IsEmpty Ω := ⟨fun ω => IsEmpty.false (τ ω)⟩
apply Subsingleton.measurableSet
· change ∀ i, MeasurableSet[f i] (s ∩ {ω | τ ω ≤ i}) at hs
obtain ⟨seq : ℕ → ι, h_seq_tendsto⟩ := (atTop : Filter ι).exists_seq_tendsto
rw [(_ : s = ⋃ n, s ∩ {ω | τ ω ≤ seq n})]
· exact MeasurableSet.iUnion fun i => f.le (seq i) _ (hs (seq i))
· ext ω; constructor <;> rw [Set.mem_iUnion]
· intro hx
suffices ∃ i, τ ω ≤ seq i from ⟨this.choose, hx, this.choose_spec⟩
rw [tendsto_atTop] at h_seq_tendsto
exact (h_seq_tendsto (τ ω)).exists
· rintro ⟨_, hx, _⟩
exact hx | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSpace_le | null |
@[simp]
measurableSpace_const (f : Filtration ι m) (i : ι) :
(isStoppingTime_const f i).measurableSpace = f i := by
ext1 s
change MeasurableSet[(isStoppingTime_const f i).measurableSpace] s ↔ MeasurableSet[f i] s
rw [IsStoppingTime.measurableSet]
constructor <;> intro h
· specialize h i
simpa only [le_refl, Set.setOf_true, Set.inter_univ] using h
· intro j
by_cases hij : i ≤ j
· simp only [hij, Set.setOf_true, Set.inter_univ]
exact f.mono hij _ h
· simp only [hij, Set.setOf_false, Set.inter_empty, @MeasurableSet.empty _ (f.1 j)] | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSpace_const | null |
measurableSet_inter_eq_iff (hτ : IsStoppingTime f τ) (s : Set Ω) (i : ι) :
MeasurableSet[hτ.measurableSpace] (s ∩ {ω | τ ω = i}) ↔
MeasurableSet[f i] (s ∩ {ω | τ ω = i}) := by
have : ∀ j, {ω : Ω | τ ω = i} ∩ {ω : Ω | τ ω ≤ j} = {ω : Ω | τ ω = i} ∩ {_ω | i ≤ j} := by
intro j
ext1 ω
simp only [Set.mem_inter_iff, Set.mem_setOf_eq, and_congr_right_iff]
intro hxi
rw [hxi]
constructor <;> intro h
· specialize h i
simpa only [Set.inter_assoc, this, le_refl, Set.setOf_true, Set.inter_univ] using h
· intro j
rw [Set.inter_assoc, this]
by_cases hij : i ≤ j
· simp only [hij, Set.setOf_true, Set.inter_univ]
exact f.mono hij _ h
· simp [hij] | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_inter_eq_iff | null |
measurableSpace_le_of_le_const (hτ : IsStoppingTime f τ) {i : ι} (hτ_le : ∀ ω, τ ω ≤ i) :
hτ.measurableSpace ≤ f i :=
(measurableSpace_mono hτ _ hτ_le).trans (measurableSpace_const _ _).le | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSpace_le_of_le_const | null |
measurableSpace_le_of_le (hτ : IsStoppingTime f τ) {n : ι} (hτ_le : ∀ ω, τ ω ≤ n) :
hτ.measurableSpace ≤ m :=
(hτ.measurableSpace_le_of_le_const hτ_le).trans (f.le n) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSpace_le_of_le | null |
le_measurableSpace_of_const_le (hτ : IsStoppingTime f τ) {i : ι} (hτ_le : ∀ ω, i ≤ τ ω) :
f i ≤ hτ.measurableSpace :=
(measurableSpace_const _ _).symm.le.trans (measurableSpace_mono _ hτ hτ_le) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | le_measurableSpace_of_const_le | null |
sigmaFinite_stopping_time {ι} [SemilatticeSup ι] [OrderBot ι]
[(Filter.atTop : Filter ι).IsCountablyGenerated] {μ : Measure Ω} {f : Filtration ι m}
{τ : Ω → ι} [SigmaFiniteFiltration μ f] (hτ : IsStoppingTime f τ) :
SigmaFinite (μ.trim hτ.measurableSpace_le) := by
refine @sigmaFiniteTrim_mono _ _ ?_ _ _ _ ?_ ?_
· exact f ⊥
· exact hτ.le_measurableSpace_of_const_le fun _ => bot_le
· infer_instance | instance | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | sigmaFinite_stopping_time | null |
sigmaFinite_stopping_time_of_le {ι} [SemilatticeSup ι] [OrderBot ι] {μ : Measure Ω}
{f : Filtration ι m} {τ : Ω → ι} [SigmaFiniteFiltration μ f] (hτ : IsStoppingTime f τ) {n : ι}
(hτ_le : ∀ ω, τ ω ≤ n) : SigmaFinite (μ.trim (hτ.measurableSpace_le_of_le hτ_le)) := by
refine @sigmaFiniteTrim_mono _ _ ?_ _ _ _ ?_ ?_
· exact f ⊥
· exact hτ.le_measurableSpace_of_const_le fun _ => bot_le
· infer_instance | instance | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | sigmaFinite_stopping_time_of_le | null |
protected measurableSet_le' (hτ : IsStoppingTime f τ) (i : ι) :
MeasurableSet[hτ.measurableSpace] {ω | τ ω ≤ i} := by
intro j
have : {ω : Ω | τ ω ≤ i} ∩ {ω : Ω | τ ω ≤ j} = {ω : Ω | τ ω ≤ min i j} := by
ext1 ω; simp only [Set.mem_inter_iff, Set.mem_setOf_eq, le_min_iff]
rw [this]
exact f.mono (min_le_right i j) _ (hτ _) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_le' | null |
protected measurableSet_gt' (hτ : IsStoppingTime f τ) (i : ι) :
MeasurableSet[hτ.measurableSpace] {ω | i < τ ω} := by
have : {ω : Ω | i < τ ω} = {ω : Ω | τ ω ≤ i}ᶜ := by ext1 ω; simp
rw [this]
exact (hτ.measurableSet_le' i).compl | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_gt' | null |
protected measurableSet_eq' [TopologicalSpace ι] [OrderTopology ι]
[FirstCountableTopology ι] (hτ : IsStoppingTime f τ) (i : ι) :
MeasurableSet[hτ.measurableSpace] {ω | τ ω = i} := by
rw [← Set.univ_inter {ω | τ ω = i}, measurableSet_inter_eq_iff, Set.univ_inter]
exact hτ.measurableSet_eq i | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_eq' | null |
protected measurableSet_ge' [TopologicalSpace ι] [OrderTopology ι]
[FirstCountableTopology ι] (hτ : IsStoppingTime f τ) (i : ι) :
MeasurableSet[hτ.measurableSpace] {ω | i ≤ τ ω} := by
have : {ω | i ≤ τ ω} = {ω | τ ω = i} ∪ {ω | i < τ ω} := by
ext1 ω
simp only [le_iff_lt_or_eq, Set.mem_setOf_eq, Set.mem_union]
rw [@eq_comm _ i, or_comm]
rw [this]
exact (hτ.measurableSet_eq' i).union (hτ.measurableSet_gt' i) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_ge' | null |
protected measurableSet_lt' [TopologicalSpace ι] [OrderTopology ι]
[FirstCountableTopology ι] (hτ : IsStoppingTime f τ) (i : ι) :
MeasurableSet[hτ.measurableSpace] {ω | τ ω < i} := by
have : {ω | τ ω < i} = {ω | τ ω ≤ i} \ {ω | τ ω = i} := by
ext1 ω
simp only [lt_iff_le_and_ne, Set.mem_setOf_eq, Set.mem_diff]
rw [this]
exact (hτ.measurableSet_le' i).diff (hτ.measurableSet_eq' i) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_lt' | null |
protected measurableSet_eq_of_countable_range' (hτ : IsStoppingTime f τ)
(h_countable : (Set.range τ).Countable) (i : ι) :
MeasurableSet[hτ.measurableSpace] {ω | τ ω = i} := by
rw [← Set.univ_inter {ω | τ ω = i}, measurableSet_inter_eq_iff, Set.univ_inter]
exact hτ.measurableSet_eq_of_countable_range h_countable i | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_eq_of_countable_range' | null |
protected measurableSet_eq_of_countable' [Countable ι] (hτ : IsStoppingTime f τ) (i : ι) :
MeasurableSet[hτ.measurableSpace] {ω | τ ω = i} :=
hτ.measurableSet_eq_of_countable_range' (Set.to_countable _) i | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_eq_of_countable' | null |
protected measurableSet_ge_of_countable_range' (hτ : IsStoppingTime f τ)
(h_countable : (Set.range τ).Countable) (i : ι) :
MeasurableSet[hτ.measurableSpace] {ω | i ≤ τ ω} := by
have : {ω | i ≤ τ ω} = {ω | τ ω = i} ∪ {ω | i < τ ω} := by
ext1 ω
simp only [le_iff_lt_or_eq, Set.mem_setOf_eq, Set.mem_union]
rw [@eq_comm _ i, or_comm]
rw [this]
exact (hτ.measurableSet_eq_of_countable_range' h_countable i).union (hτ.measurableSet_gt' i) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_ge_of_countable_range' | null |
protected measurableSet_ge_of_countable' [Countable ι] (hτ : IsStoppingTime f τ) (i : ι) :
MeasurableSet[hτ.measurableSpace] {ω | i ≤ τ ω} :=
hτ.measurableSet_ge_of_countable_range' (Set.to_countable _) i | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_ge_of_countable' | null |
protected measurableSet_lt_of_countable_range' (hτ : IsStoppingTime f τ)
(h_countable : (Set.range τ).Countable) (i : ι) :
MeasurableSet[hτ.measurableSpace] {ω | τ ω < i} := by
have : {ω | τ ω < i} = {ω | τ ω ≤ i} \ {ω | τ ω = i} := by
ext1 ω
simp only [lt_iff_le_and_ne, Set.mem_setOf_eq, Set.mem_diff]
rw [this]
exact (hτ.measurableSet_le' i).diff (hτ.measurableSet_eq_of_countable_range' h_countable i) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_lt_of_countable_range' | null |
protected measurableSet_lt_of_countable' [Countable ι] (hτ : IsStoppingTime f τ) (i : ι) :
MeasurableSet[hτ.measurableSpace] {ω | τ ω < i} :=
hτ.measurableSet_lt_of_countable_range' (Set.to_countable _) i | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_lt_of_countable' | null |
protected measurableSpace_le_of_countable_range (hτ : IsStoppingTime f τ)
(h_countable : (Set.range τ).Countable) : hτ.measurableSpace ≤ m := by
intro s hs
change ∀ i, MeasurableSet[f i] (s ∩ {ω | τ ω ≤ i}) at hs
rw [(_ : s = ⋃ i ∈ Set.range τ, s ∩ {ω | τ ω ≤ i})]
· exact MeasurableSet.biUnion h_countable fun i _ => f.le i _ (hs i)
· ext ω
constructor <;> rw [Set.mem_iUnion]
· exact fun hx => ⟨τ ω, by simpa using hx⟩
· rintro ⟨i, hx⟩
simp only [Set.mem_range, Set.iUnion_exists, Set.mem_iUnion, Set.mem_inter_iff,
Set.mem_setOf_eq, exists_prop, exists_and_right] at hx
exact hx.2.1 | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSpace_le_of_countable_range | null |
protected measurable [TopologicalSpace ι] [MeasurableSpace ι] [BorelSpace ι]
[OrderTopology ι] [SecondCountableTopology ι] (hτ : IsStoppingTime f τ) :
Measurable[hτ.measurableSpace] τ :=
@measurable_of_Iic ι Ω _ _ _ hτ.measurableSpace _ _ _ _ fun i => hτ.measurableSet_le' i | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurable | null |
protected measurable_of_le [TopologicalSpace ι] [MeasurableSpace ι] [BorelSpace ι]
[OrderTopology ι] [SecondCountableTopology ι] (hτ : IsStoppingTime f τ) {i : ι}
(hτ_le : ∀ ω, τ ω ≤ i) : Measurable[f i] τ :=
hτ.measurable.mono (measurableSpace_le_of_le_const _ hτ_le) le_rfl | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurable_of_le | null |
measurableSpace_min (hτ : IsStoppingTime f τ) (hπ : IsStoppingTime f π) :
(hτ.min hπ).measurableSpace = hτ.measurableSpace ⊓ hπ.measurableSpace := by
refine le_antisymm ?_ ?_
· exact le_inf (measurableSpace_mono _ hτ fun _ => min_le_left _ _)
(measurableSpace_mono _ hπ fun _ => min_le_right _ _)
· intro s
change MeasurableSet[hτ.measurableSpace] s ∧ MeasurableSet[hπ.measurableSpace] s →
MeasurableSet[(hτ.min hπ).measurableSpace] s
simp_rw [IsStoppingTime.measurableSet]
have : ∀ i, {ω | min (τ ω) (π ω) ≤ i} = {ω | τ ω ≤ i} ∪ {ω | π ω ≤ i} := by
intro i; ext1 ω; simp
simp_rw [this, Set.inter_union_distrib_left]
exact fun h i => (h.left i).union (h.right i) | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSpace_min | null |
measurableSet_min_iff (hτ : IsStoppingTime f τ) (hπ : IsStoppingTime f π) (s : Set Ω) :
MeasurableSet[(hτ.min hπ).measurableSpace] s ↔
MeasurableSet[hτ.measurableSpace] s ∧ MeasurableSet[hπ.measurableSpace] s := by
rw [measurableSpace_min hτ hπ]; rfl | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_min_iff | null |
measurableSpace_min_const (hτ : IsStoppingTime f τ) {i : ι} :
(hτ.min_const i).measurableSpace = hτ.measurableSpace ⊓ f i := by
rw [hτ.measurableSpace_min (isStoppingTime_const _ i), measurableSpace_const] | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSpace_min_const | null |
measurableSet_min_const_iff (hτ : IsStoppingTime f τ) (s : Set Ω) {i : ι} :
MeasurableSet[(hτ.min_const i).measurableSpace] s ↔
MeasurableSet[hτ.measurableSpace] s ∧ MeasurableSet[f i] s := by
rw [measurableSpace_min_const hτ]; apply MeasurableSpace.measurableSet_inf | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_min_const_iff | null |
measurableSet_inter_le [TopologicalSpace ι] [SecondCountableTopology ι] [OrderTopology ι]
[MeasurableSpace ι] [BorelSpace ι] (hτ : IsStoppingTime f τ) (hπ : IsStoppingTime f π)
(s : Set Ω) (hs : MeasurableSet[hτ.measurableSpace] s) :
MeasurableSet[(hτ.min hπ).measurableSpace] (s ∩ {ω | τ ω ≤ π ω}) := by
simp_rw [IsStoppingTime.measurableSet] at hs ⊢
intro i
have : s ∩ {ω | τ ω ≤ π ω} ∩ {ω | min (τ ω) (π ω) ≤ i} =
s ∩ {ω | τ ω ≤ i} ∩ {ω | min (τ ω) (π ω) ≤ i} ∩
{ω | min (τ ω) i ≤ min (min (τ ω) (π ω)) i} := by
ext1 ω
simp only [min_le_iff, Set.mem_inter_iff, Set.mem_setOf_eq, le_min_iff, le_refl, true_and,
true_or]
by_cases hτi : τ ω ≤ i
· simp only [hτi, true_or, and_true, and_congr_right_iff]
intro
constructor <;> intro h
· exact Or.inl h
· rcases h with h | h
· exact h
· exact hτi.trans h
simp only [hτi, false_or, and_false, false_and, iff_false, not_and, not_le, and_imp]
refine fun _ hτ_le_π => lt_of_lt_of_le ?_ hτ_le_π
rw [← not_le]
exact hτi
rw [this]
refine ((hs i).inter ((hτ.min hπ) i)).inter ?_
apply @measurableSet_le _ _ _ _ _ (Filtration.seq f i) _ _ _ _ _ ?_ ?_
· exact (hτ.min_const i).measurable_of_le fun _ => min_le_right _ _
· exact ((hτ.min hπ).min_const i).measurable_of_le fun _ => min_le_right _ _ | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_inter_le | null |
measurableSet_inter_le_iff [TopologicalSpace ι] [SecondCountableTopology ι]
[OrderTopology ι] [MeasurableSpace ι] [BorelSpace ι] (hτ : IsStoppingTime f τ)
(hπ : IsStoppingTime f π) (s : Set Ω) :
MeasurableSet[hτ.measurableSpace] (s ∩ {ω | τ ω ≤ π ω}) ↔
MeasurableSet[(hτ.min hπ).measurableSpace] (s ∩ {ω | τ ω ≤ π ω}) := by
constructor <;> intro h
· have : s ∩ {ω | τ ω ≤ π ω} = s ∩ {ω | τ ω ≤ π ω} ∩ {ω | τ ω ≤ π ω} := by
rw [Set.inter_assoc, Set.inter_self]
rw [this]
exact measurableSet_inter_le _ hπ _ h
· rw [measurableSet_min_iff hτ hπ] at h
exact h.1 | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_inter_le_iff | null |
measurableSet_inter_le_const_iff (hτ : IsStoppingTime f τ) (s : Set Ω) (i : ι) :
MeasurableSet[hτ.measurableSpace] (s ∩ {ω | τ ω ≤ i}) ↔
MeasurableSet[(hτ.min_const i).measurableSpace] (s ∩ {ω | τ ω ≤ i}) := by
rw [IsStoppingTime.measurableSet_min_iff hτ (isStoppingTime_const _ i),
IsStoppingTime.measurableSpace_const, IsStoppingTime.measurableSet]
refine ⟨fun h => ⟨h, ?_⟩, fun h j => h.1 j⟩
specialize h i
rwa [Set.inter_assoc, Set.inter_self] at h | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_inter_le_const_iff | null |
measurableSet_le_stopping_time [TopologicalSpace ι] [SecondCountableTopology ι]
[OrderTopology ι] [MeasurableSpace ι] [BorelSpace ι] (hτ : IsStoppingTime f τ)
(hπ : IsStoppingTime f π) : MeasurableSet[hτ.measurableSpace] {ω | τ ω ≤ π ω} := by
rw [hτ.measurableSet]
intro j
have : {ω | τ ω ≤ π ω} ∩ {ω | τ ω ≤ j} = {ω | min (τ ω) j ≤ min (π ω) j} ∩ {ω | τ ω ≤ j} := by
ext1 ω
simp only [Set.mem_inter_iff, Set.mem_setOf_eq, min_le_iff, le_min_iff, le_refl,
and_congr_left_iff]
intro h
simp only [h, or_self_iff, and_true]
rw [Iff.comm, or_iff_left_iff_imp]
exact h.trans
rw [this]
refine MeasurableSet.inter ?_ (hτ.measurableSet_le j)
apply @measurableSet_le _ _ _ _ _ (Filtration.seq f j) _ _ _ _ _ ?_ ?_
· 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_le_stopping_time | null |
measurableSet_stopping_time_le [TopologicalSpace ι] [SecondCountableTopology ι]
[OrderTopology ι] [MeasurableSpace ι] [BorelSpace ι] (hτ : IsStoppingTime f τ)
(hπ : IsStoppingTime f π) : MeasurableSet[hπ.measurableSpace] {ω | τ ω ≤ π ω} := by
suffices MeasurableSet[(hτ.min hπ).measurableSpace] {ω : Ω | τ ω ≤ π ω} by
rw [measurableSet_min_iff hτ hπ] at this; exact this.2
rw [← Set.univ_inter {ω : Ω | τ ω ≤ π ω}, ← hτ.measurableSet_inter_le_iff hπ, Set.univ_inter]
exact measurableSet_le_stopping_time hτ hπ | theorem | Probability | [
"Mathlib.Probability.Process.Adapted",
"Mathlib.MeasureTheory.Constructions.BorelSpace.Order"
] | Mathlib/Probability/Process/Stopping.lean | measurableSet_stopping_time_le | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.