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 ⌀ |
|---|---|---|---|---|---|---|
support_bind : (p.bind f).support = ⋃ a ∈ p.support, (f a).support :=
Set.ext fun b => by simp [mem_support_iff, ENNReal.tsum_eq_zero, not_or] | theorem | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | support_bind | null |
mem_support_bind_iff (b : β) :
b ∈ (p.bind f).support ↔ ∃ a ∈ p.support, b ∈ (f a).support := by
simp only [support_bind, Set.mem_iUnion, exists_prop]
@[simp] | theorem | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | mem_support_bind_iff | null |
pure_bind (a : α) (f : α → PMF β) : (pure a).bind f = f a := by
classical
have : ∀ b a', ite (a' = a) (f a' b) 0 = ite (a' = a) (f a b) 0 := fun b a' => by
split_ifs with h <;> simp [h]
ext b
simp [this]
@[simp] | theorem | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | pure_bind | null |
bind_pure : p.bind pure = p :=
PMF.ext fun x => (bind_apply _ _ _).trans (_root_.trans
(tsum_eq_single x fun y hy => by rw [pure_apply_of_ne _ _ hy.symm, mul_zero]) <|
by rw [pure_apply_self, mul_one])
@[simp] | theorem | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | bind_pure | null |
bind_const (p : PMF α) (q : PMF β) : (p.bind fun _ => q) = q :=
PMF.ext fun x => by rw [bind_apply, ENNReal.tsum_mul_right, tsum_coe, one_mul]
@[simp] | theorem | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | bind_const | null |
bind_bind : (p.bind f).bind g = p.bind fun a => (f a).bind g :=
PMF.ext fun b => by
simpa only [ENNReal.coe_inj.symm, bind_apply, ENNReal.tsum_mul_left.symm,
ENNReal.tsum_mul_right.symm, mul_assoc, mul_left_comm, mul_comm] using ENNReal.tsum_comm | theorem | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | bind_bind | null |
bind_comm (p : PMF α) (q : PMF β) (f : α → β → PMF γ) :
(p.bind fun a => q.bind (f a)) = q.bind fun b => p.bind fun a => f a b :=
PMF.ext fun b => by
simpa only [ENNReal.coe_inj.symm, bind_apply, ENNReal.tsum_mul_left.symm,
ENNReal.tsum_mul_right.symm, mul_assoc, mul_left_comm, mul_comm] using ENNReal.tsum_comm | theorem | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | bind_comm | null |
@[simp]
toOuterMeasure_bind_apply :
(p.bind f).toOuterMeasure s = ∑' a, p a * (f a).toOuterMeasure s := by
classical
calc
(p.bind f).toOuterMeasure s = ∑' b, if b ∈ s then ∑' a, p a * f a b else 0 := by
simp [toOuterMeasure_apply, Set.indicator_apply]
_ = ∑' (b) (a), p a * if b ∈ s then f a b else 0 := tsum_congr fun b => by split_ifs <;> simp
_ = ∑' (a) (b), p a * if b ∈ s then f a b else 0 := ENNReal.tsum_comm
_ = ∑' a, p a * ∑' b, if b ∈ s then f a b else 0 := tsum_congr fun _ => ENNReal.tsum_mul_left
_ = ∑' a, p a * ∑' b, if b ∈ s then f a b else 0 :=
(tsum_congr fun a => (congr_arg fun x => p a * x) <| tsum_congr fun b => by split_ifs <;> rfl)
_ = ∑' a, p a * (f a).toOuterMeasure s :=
tsum_congr fun a => by simp only [toOuterMeasure_apply, Set.indicator_apply] | theorem | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | toOuterMeasure_bind_apply | null |
@[simp]
toMeasure_bind_apply [MeasurableSpace β] (hs : MeasurableSet s) :
(p.bind f).toMeasure s = ∑' a, p a * (f a).toMeasure s :=
(toMeasure_apply_eq_toOuterMeasure_apply (p.bind f) hs).trans
((toOuterMeasure_bind_apply p f s).trans
(tsum_congr fun a =>
congr_arg (fun x => p a * x) (toMeasure_apply_eq_toOuterMeasure_apply (f a) hs).symm)) | theorem | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | toMeasure_bind_apply | The measure of a set under `p.bind f` is the sum over `a : α`
of the probability of `a` under `p` times the measure of the set under `f a`. |
bindOnSupport (p : PMF α) (f : ∀ a ∈ p.support, PMF β) : PMF β :=
⟨fun b => ∑' a, p a * if h : p a = 0 then 0 else f a h b, ENNReal.summable.hasSum_iff.2 (by
refine ENNReal.tsum_comm.trans (_root_.trans (tsum_congr fun a => ?_) p.tsum_coe)
simp_rw [ENNReal.tsum_mul_left]
split_ifs with h
· simp only [h, zero_mul]
· rw [(f a h).tsum_coe, mul_one])⟩
variable {p : PMF α} (f : ∀ a ∈ p.support, PMF β)
@[simp] | def | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | bindOnSupport | Generalized version of `bind` allowing `f` to only be defined on the support of `p`.
`p.bind f` is equivalent to `p.bindOnSupport (fun a _ ↦ f a)`, see `bindOnSupport_eq_bind`. |
bindOnSupport_apply (b : β) :
p.bindOnSupport f b = ∑' a, p a * if h : p a = 0 then 0 else f a h b := rfl
@[simp] | theorem | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | bindOnSupport_apply | null |
support_bindOnSupport :
(p.bindOnSupport f).support = ⋃ (a : α) (h : a ∈ p.support), (f a h).support := by
refine Set.ext fun b => ?_
simp only [ENNReal.tsum_eq_zero, not_or, mem_support_iff, bindOnSupport_apply, Ne, not_forall,
mul_eq_zero, Set.mem_iUnion]
exact
⟨fun hb =>
let ⟨a, ⟨ha, ha'⟩⟩ := hb
⟨a, ha, by simpa [ha] using ha'⟩,
fun hb =>
let ⟨a, ha, ha'⟩ := hb
⟨a, ⟨ha, by simpa [(mem_support_iff _ a).1 ha] using ha'⟩⟩⟩ | theorem | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | support_bindOnSupport | null |
mem_support_bindOnSupport_iff (b : β) :
b ∈ (p.bindOnSupport f).support ↔ ∃ (a : α) (h : a ∈ p.support), b ∈ (f a h).support := by
simp only [support_bindOnSupport, Set.mem_iUnion] | theorem | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | mem_support_bindOnSupport_iff | null |
@[simp]
bindOnSupport_eq_bind (p : PMF α) (f : α → PMF β) :
(p.bindOnSupport fun a _ => f a) = p.bind f := by
ext b
have : ∀ a, ite (p a = 0) 0 (p a * f a b) = p a * f a b :=
fun a => ite_eq_right_iff.2 fun h => h.symm ▸ symm (zero_mul <| f a b)
simp only [bindOnSupport_apply fun a _ => f a, p.bind_apply f, dite_eq_ite, mul_ite,
mul_zero, this] | theorem | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | bindOnSupport_eq_bind | `bindOnSupport` reduces to `bind` if `f` doesn't depend on the additional hypothesis. |
bindOnSupport_eq_zero_iff (b : β) :
p.bindOnSupport f b = 0 ↔ ∀ (a) (ha : p a ≠ 0), f a ha b = 0 := by
simp only [bindOnSupport_apply, ENNReal.tsum_eq_zero, mul_eq_zero, or_iff_not_imp_left]
exact ⟨fun h a ha => Trans.trans (dif_neg ha).symm (h a ha),
fun h a ha => Trans.trans (dif_neg ha) (h a ha)⟩
@[simp] | theorem | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | bindOnSupport_eq_zero_iff | null |
pure_bindOnSupport (a : α) (f : ∀ (a' : α) (_ : a' ∈ (pure a).support), PMF β) :
(pure a).bindOnSupport f = f a ((mem_support_pure_iff a a).mpr rfl) := by
refine PMF.ext fun b => ?_
simp only [bindOnSupport_apply, pure_apply]
classical
refine _root_.trans (tsum_congr fun a' => ?_) (tsum_ite_eq a _)
by_cases h : a' = a <;> simp [h] | theorem | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | pure_bindOnSupport | null |
bindOnSupport_pure (p : PMF α) : (p.bindOnSupport fun a _ => pure a) = p := by
simp only [PMF.bind_pure, PMF.bindOnSupport_eq_bind]
@[simp] | theorem | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | bindOnSupport_pure | null |
bindOnSupport_bindOnSupport (p : PMF α) (f : ∀ a ∈ p.support, PMF β)
(g : ∀ b ∈ (p.bindOnSupport f).support, PMF γ) :
(p.bindOnSupport f).bindOnSupport g =
p.bindOnSupport fun a ha =>
(f a ha).bindOnSupport fun b hb =>
g b ((mem_support_bindOnSupport_iff f b).mpr ⟨a, ha, hb⟩) := by
refine PMF.ext fun a => ?_
dsimp only [bindOnSupport_apply]
simp only [← tsum_dite_right, ENNReal.tsum_mul_left.symm, ENNReal.tsum_mul_right.symm]
classical
simp only [ENNReal.tsum_eq_zero]
refine ENNReal.tsum_comm.trans (tsum_congr fun a' => tsum_congr fun b => ?_)
split_ifs with h _ h_1 H h_2
any_goals ring1
· absurd H
simpa [h] using h_1 a'
· simp [h_2] | theorem | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | bindOnSupport_bindOnSupport | null |
bindOnSupport_comm (p : PMF α) (q : PMF β) (f : ∀ a ∈ p.support, ∀ b ∈ q.support, PMF γ) :
(p.bindOnSupport fun a ha => q.bindOnSupport (f a ha)) =
q.bindOnSupport fun b hb => p.bindOnSupport fun a ha => f a ha b hb := by
apply PMF.ext; rintro c
simp only [bindOnSupport_apply, ← tsum_dite_right,
ENNReal.tsum_mul_left.symm]
refine _root_.trans ENNReal.tsum_comm (tsum_congr fun b => tsum_congr fun a => ?_)
split_ifs with h1 h2 h2 <;> ring | theorem | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | bindOnSupport_comm | null |
@[simp]
toOuterMeasure_bindOnSupport_apply :
(p.bindOnSupport f).toOuterMeasure s =
∑' a, p a * if h : p a = 0 then 0 else (f a h).toOuterMeasure s := by
simp only [toOuterMeasure_apply]
classical
calc
(∑' b, ite (b ∈ s) (∑' a, p a * dite (p a = 0) (fun h => 0) fun h => f a h b) 0) =
∑' (b) (a), ite (b ∈ s) (p a * dite (p a = 0) (fun h => 0) fun h => f a h b) 0 :=
tsum_congr fun b => by split_ifs with hbs <;> simp only [tsum_zero]
_ = ∑' (a) (b), ite (b ∈ s) (p a * dite (p a = 0) (fun h => 0) fun h => f a h b) 0 :=
ENNReal.tsum_comm
_ = ∑' a, p a * ∑' b, ite (b ∈ s) (dite (p a = 0) (fun h => 0) fun h => f a h b) 0 :=
(tsum_congr fun a => by simp only [← ENNReal.tsum_mul_left, mul_ite, mul_zero])
_ = ∑' a, p a * dite (p a = 0) (fun h => 0) fun h => ∑' b, ite (b ∈ s) (f a h b) 0 :=
tsum_congr fun a => by split_ifs with ha <;> simp only [ite_self, tsum_zero] | theorem | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | toOuterMeasure_bindOnSupport_apply | null |
@[simp]
toMeasure_bindOnSupport_apply [MeasurableSpace β] (hs : MeasurableSet s) :
(p.bindOnSupport f).toMeasure s =
∑' a, p a * if h : p a = 0 then 0 else (f a h).toMeasure s := by
simp only [toMeasure_apply_eq_toOuterMeasure_apply _ hs, toOuterMeasure_bindOnSupport_apply] | theorem | Probability | [
"Mathlib.Probability.ProbabilityMassFunction.Basic"
] | Mathlib/Probability/ProbabilityMassFunction/Monad.lean | toMeasure_bindOnSupport_apply | The measure of a set under `p.bindOnSupport f` is the sum over `a : α`
of the probability of `a` under `p` times the measure of the set under `f a _`.
The additional if statement is needed since `f` is only a partial function. |
Adapted (f : Filtration ι m) (u : ι → Ω → β) : Prop :=
∀ i : ι, StronglyMeasurable[f i] (u i) | def | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | Adapted | A sequence of functions `u` is adapted to a filtration `f` if for all `i`,
`u i` is `f i`-measurable. |
@[to_additive]
protected mul [Mul β] [ContinuousMul β] (hu : Adapted f u) (hv : Adapted f v) :
Adapted f (u * v) := fun i => (hu i).mul (hv i)
@[to_additive] | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | mul | null |
protected div [Div β] [ContinuousDiv β] (hu : Adapted f u) (hv : Adapted f v) :
Adapted f (u / v) := fun i => (hu i).div (hv i)
@[to_additive] | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | div | null |
protected inv [Group β] [ContinuousInv β] (hu : Adapted f u) :
Adapted f u⁻¹ := fun i => (hu i).inv | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | inv | null |
protected smul [SMul ℝ β] [ContinuousConstSMul ℝ β] (c : ℝ) (hu : Adapted f u) :
Adapted f (c • u) := fun i => (hu i).const_smul c | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | smul | null |
protected stronglyMeasurable {i : ι} (hf : Adapted f u) : StronglyMeasurable[m] (u i) :=
(hf i).mono (f.le i) | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | stronglyMeasurable | null |
stronglyMeasurable_le {i j : ι} (hf : Adapted f u) (hij : i ≤ j) :
StronglyMeasurable[f j] (u i) := (hf i).mono (f.mono hij) | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | stronglyMeasurable_le | null |
adapted_const (f : Filtration ι m) (x : β) : Adapted f fun _ _ => x := fun _ =>
stronglyMeasurable_const
variable (β) in | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | adapted_const | null |
adapted_zero [Zero β] (f : Filtration ι m) : Adapted f (0 : ι → Ω → β) := fun i =>
@stronglyMeasurable_zero Ω β (f i) _ _ | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | adapted_zero | null |
Filtration.adapted_natural [MetrizableSpace β] [mβ : MeasurableSpace β] [BorelSpace β]
{u : ι → Ω → β} (hum : ∀ i, StronglyMeasurable[m] (u i)) :
Adapted (Filtration.natural u hum) u := by
intro i
refine StronglyMeasurable.mono ?_ (le_iSup₂_of_le i (le_refl i) le_rfl)
rw [stronglyMeasurable_iff_measurable_separable]
exact ⟨measurable_iff_comap_le.2 le_rfl, (hum i).isSeparable_range⟩ | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | Filtration.adapted_natural | null |
ProgMeasurable [MeasurableSpace ι] (f : Filtration ι m) (u : ι → Ω → β) : Prop :=
∀ i, StronglyMeasurable[Subtype.instMeasurableSpace.prod (f i)] fun p : Set.Iic i × Ω => u p.1 p.2 | def | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | ProgMeasurable | Progressively measurable process. A sequence of functions `u` is said to be progressively
measurable with respect to a filtration `f` if at each point in time `i`, `u` restricted to
`Set.Iic i × Ω` is measurable with respect to the product `MeasurableSpace` structure where the
σ-algebra used for `Ω` is `f i`.
The usual definition uses the interval `[0,i]`, which we replace by `Set.Iic i`. We recover the
usual definition for index types `ℝ≥0` or `ℕ`. |
progMeasurable_const [MeasurableSpace ι] (f : Filtration ι m) (b : β) :
ProgMeasurable f (fun _ _ => b : ι → Ω → β) := fun i =>
@stronglyMeasurable_const _ _ (Subtype.instMeasurableSpace.prod (f i)) _ _ | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | progMeasurable_const | null |
protected adapted (h : ProgMeasurable f u) : Adapted f u := by
intro i
have : u i = (fun p : Set.Iic i × Ω => u p.1 p.2) ∘ fun x => (⟨i, Set.mem_Iic.mpr le_rfl⟩, x) :=
rfl
rw [this]
exact (h i).comp_measurable measurable_prodMk_left | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | adapted | null |
protected comp {t : ι → Ω → ι} [TopologicalSpace ι] [BorelSpace ι] [PseudoMetrizableSpace ι]
(h : ProgMeasurable f u) (ht : ProgMeasurable f t) (ht_le : ∀ i ω, t i ω ≤ i) :
ProgMeasurable f fun i ω => u (t i ω) ω := by
intro i
have : (fun p : ↥(Set.Iic i) × Ω => u (t (p.fst : ι) p.snd) p.snd) =
(fun p : ↥(Set.Iic i) × Ω => u (p.fst : ι) p.snd) ∘ fun p : ↥(Set.Iic i) × Ω =>
(⟨t (p.fst : ι) p.snd, Set.mem_Iic.mpr ((ht_le _ _).trans p.fst.prop)⟩, p.snd) := rfl
rw [this]
exact (h i).comp_measurable ((ht i).measurable.subtype_mk.prodMk measurable_snd) | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | comp | null |
@[to_additive]
protected mul [Mul β] [ContinuousMul β] (hu : ProgMeasurable f u)
(hv : ProgMeasurable f v) : ProgMeasurable f fun i ω => u i ω * v i ω := fun i =>
(hu i).mul (hv i)
@[to_additive] | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | mul | null |
protected finset_prod' {γ} [CommMonoid β] [ContinuousMul β] {U : γ → ι → Ω → β}
{s : Finset γ} (h : ∀ c ∈ s, ProgMeasurable f (U c)) : ProgMeasurable f (∏ c ∈ s, U c) :=
Finset.prod_induction U (ProgMeasurable f) (fun _ _ => ProgMeasurable.mul)
(progMeasurable_const _ 1) h
@[to_additive] | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | finset_prod' | null |
protected finset_prod {γ} [CommMonoid β] [ContinuousMul β] {U : γ → ι → Ω → β}
{s : Finset γ} (h : ∀ c ∈ s, ProgMeasurable f (U c)) :
ProgMeasurable f fun i a => ∏ c ∈ s, U c i a := by
convert ProgMeasurable.finset_prod' h using 1; ext (i a); simp only [Finset.prod_apply]
@[to_additive] | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | finset_prod | null |
protected inv [Group β] [ContinuousInv β] (hu : ProgMeasurable f u) :
ProgMeasurable f fun i ω => (u i ω)⁻¹ := fun i => (hu i).inv
@[to_additive] | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | inv | null |
protected div [Group β] [ContinuousDiv β] (hu : ProgMeasurable f u)
(hv : ProgMeasurable f v) : ProgMeasurable f fun i ω => u i ω / v i ω := fun i =>
(hu i).div (hv i) | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | div | null |
progMeasurable_of_tendsto' {γ} [MeasurableSpace ι] [PseudoMetrizableSpace β]
(fltr : Filter γ) [fltr.NeBot] [fltr.IsCountablyGenerated] {U : γ → ι → Ω → β}
(h : ∀ l, ProgMeasurable f (U l)) (h_tendsto : Tendsto U fltr (𝓝 u)) : ProgMeasurable f u := by
intro i
apply @stronglyMeasurable_of_tendsto (Set.Iic i × Ω) β γ
(MeasurableSpace.prod _ (f i)) _ _ fltr _ _ _ _ fun l => h l i
rw [tendsto_pi_nhds] at h_tendsto ⊢
intro x
specialize h_tendsto x.fst
rw [tendsto_nhds] at h_tendsto ⊢
exact fun s hs h_mem => h_tendsto {g | g x.snd ∈ s} (hs.preimage (continuous_apply x.snd)) h_mem | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | progMeasurable_of_tendsto' | null |
progMeasurable_of_tendsto [MeasurableSpace ι] [PseudoMetrizableSpace β] {U : ℕ → ι → Ω → β}
(h : ∀ l, ProgMeasurable f (U l)) (h_tendsto : Tendsto U atTop (𝓝 u)) : ProgMeasurable f u :=
progMeasurable_of_tendsto' atTop h h_tendsto | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | progMeasurable_of_tendsto | null |
Adapted.progMeasurable_of_continuous [TopologicalSpace ι] [MetrizableSpace ι]
[SecondCountableTopology ι] [MeasurableSpace ι] [OpensMeasurableSpace ι]
[PseudoMetrizableSpace β] (h : Adapted f u) (hu_cont : ∀ ω, Continuous fun i => u i ω) :
ProgMeasurable f u := fun i =>
@stronglyMeasurable_uncurry_of_continuous_of_stronglyMeasurable _ _ (Set.Iic i) _ _ _ _ _ _ _
(f i) _ (fun ω => (hu_cont ω).comp continuous_induced_dom) fun j => (h j).mono (f.mono j.prop) | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | Adapted.progMeasurable_of_continuous | A continuous and adapted process is progressively measurable. |
Adapted.progMeasurable_of_discrete [TopologicalSpace ι] [DiscreteTopology ι]
[SecondCountableTopology ι] [MeasurableSpace ι] [OpensMeasurableSpace ι]
[PseudoMetrizableSpace β] (h : Adapted f u) : ProgMeasurable f u :=
h.progMeasurable_of_continuous fun _ => continuous_of_discreteTopology | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | Adapted.progMeasurable_of_discrete | For filtrations indexed by a discrete order, `Adapted` and `ProgMeasurable` are equivalent.
This lemma provides `Adapted f u → ProgMeasurable f u`.
See `ProgMeasurable.adapted` for the reverse direction, which is true more generally. |
Predictable.adapted {f : Filtration ℕ m} {u : ℕ → Ω → β} (hu : Adapted f fun n => u (n + 1))
(hu0 : StronglyMeasurable[f 0] (u 0)) : Adapted f u := fun n =>
match n with
| 0 => hu0
| n + 1 => (hu n).mono (f.mono n.le_succ) | theorem | Probability | [
"Mathlib.Probability.Process.Filtration",
"Mathlib.Topology.Instances.Discrete"
] | Mathlib/Probability/Process/Adapted.lean | Predictable.adapted | null |
Filtration {Ω : Type*} (ι : Type*) [Preorder ι] (m : MeasurableSpace Ω) where
/-- The sequence of sub-σ-algebras of `m` -/
seq : ι → MeasurableSpace Ω
mono' : Monotone seq
le' : ∀ i : ι, seq i ≤ m
attribute [coe] Filtration.seq
variable {Ω β ι : Type*} {m : MeasurableSpace Ω} | structure | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | Filtration | A `Filtration` on a measurable space `Ω` with σ-algebra `m` is a monotone
sequence of sub-σ-algebras of `m`. |
protected mono {i j : ι} (f : Filtration ι m) (hij : i ≤ j) : f i ≤ f j :=
f.mono' hij | theorem | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | mono | null |
protected le (f : Filtration ι m) (i : ι) : f i ≤ m :=
f.le' i
@[ext] | theorem | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | le | null |
protected ext {f g : Filtration ι m} (h : (f : ι → MeasurableSpace Ω) = g) : f = g := by
cases f; cases g; congr
variable (ι) in | theorem | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | ext | null |
const (m' : MeasurableSpace Ω) (hm' : m' ≤ m) : Filtration ι m :=
⟨fun _ => m', monotone_const, fun _ => hm'⟩
@[simp] | def | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | const | The constant filtration which is equal to `m` for all `i : ι`. |
const_apply {m' : MeasurableSpace Ω} {hm' : m' ≤ m} (i : ι) : const ι m' hm' i = m' :=
rfl | theorem | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | const_apply | null |
@[norm_cast]
coeFn_sup {f g : Filtration ι m} : ⇑(f ⊔ g) = ⇑f ⊔ ⇑g :=
rfl | theorem | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | coeFn_sup | null |
@[norm_cast]
coeFn_inf {f g : Filtration ι m} : ⇑(f ⊓ g) = ⇑f ⊓ ⇑g :=
rfl | theorem | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | coeFn_inf | null |
sSup_def (s : Set (Filtration ι m)) (i : ι) :
sSup s i = sSup ((fun f : Filtration ι m => f i) '' s) :=
rfl
open scoped Classical in | theorem | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | sSup_def | null |
sInf_def (s : Set (Filtration ι m)) (i : ι) :
sInf s i = if Set.Nonempty s then sInf ((fun f : Filtration ι m => f i) '' s) else m :=
rfl | theorem | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | sInf_def | null |
noncomputable instCompleteLattice : CompleteLattice (Filtration ι m) where
le := (· ≤ ·)
le_refl _ _ := le_rfl
le_trans _ _ _ h_fg h_gh i := (h_fg i).trans (h_gh i)
le_antisymm _ _ h_fg h_gf := Filtration.ext <| funext fun i => (h_fg i).antisymm (h_gf i)
sup := (· ⊔ ·)
le_sup_left _ _ _ := le_sup_left
le_sup_right _ _ _ := le_sup_right
sup_le _ _ _ h_fh h_gh i := sup_le (h_fh i) (h_gh _)
inf := (· ⊓ ·)
inf_le_left _ _ _ := inf_le_left
inf_le_right _ _ _ := inf_le_right
le_inf _ _ _ h_fg h_fh i := le_inf (h_fg i) (h_fh i)
sSup := sSup
le_sSup _ f hf_mem _ := le_sSup ⟨f, hf_mem, rfl⟩
sSup_le s f h_forall i :=
sSup_le fun m' hm' => by
obtain ⟨g, hg_mem, hfm'⟩ := hm'
rw [← hfm']
exact h_forall g hg_mem i
sInf := sInf
sInf_le s f hf_mem i := by
have hs : s.Nonempty := ⟨f, hf_mem⟩
simp only [sInf_def, hs, if_true]
exact sInf_le ⟨f, hf_mem, rfl⟩
le_sInf s f h_forall i := by
by_cases hs : s.Nonempty
swap; · simp only [sInf_def, hs, if_false]; exact f.le i
simp only [sInf_def, hs, if_true, le_sInf_iff, Set.mem_image, forall_exists_index, and_imp,
forall_apply_eq_imp_iff₂]
exact fun g hg_mem => h_forall g hg_mem i
top := ⊤
bot := ⊥
le_top f i := f.le' i
bot_le _ _ := bot_le | instance | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | instCompleteLattice | null |
measurableSet_of_filtration [Preorder ι] {f : Filtration ι m} {s : Set Ω} {i : ι}
(hs : MeasurableSet[f i] s) : MeasurableSet[m] s :=
f.le i s hs | theorem | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | measurableSet_of_filtration | null |
SigmaFiniteFiltration [Preorder ι] (μ : Measure Ω) (f : Filtration ι m) : Prop where
SigmaFinite : ∀ i : ι, SigmaFinite (μ.trim (f.le i)) | class | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | SigmaFiniteFiltration | A measure is σ-finite with respect to filtration if it is σ-finite with respect
to all the sub-σ-algebra of the filtration. |
sigmaFinite_of_sigmaFiniteFiltration [Preorder ι] (μ : Measure Ω) (f : Filtration ι m)
[hf : SigmaFiniteFiltration μ f] (i : ι) : SigmaFinite (μ.trim (f.le i)) :=
hf.SigmaFinite _ | instance | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | sigmaFinite_of_sigmaFiniteFiltration | null |
Integrable.uniformIntegrable_condExp_filtration [Preorder ι] {μ : Measure Ω}
[IsFiniteMeasure μ] {f : Filtration ι m} {g : Ω → ℝ} (hg : Integrable g μ) :
UniformIntegrable (fun i => μ[g|f i]) 1 μ :=
hg.uniformIntegrable_condExp f.le | theorem | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | Integrable.uniformIntegrable_condExp_filtration | Given an integrable function `g`, the conditional expectations of `g` with respect to a
filtration is uniformly integrable. |
Filtration.condExp_condExp [Preorder ι] {E : Type*} [NormedAddCommGroup E]
[NormedSpace ℝ E] [CompleteSpace E] (f : Ω → E) {μ : Measure Ω} (ℱ : Filtration ι m)
{i j : ι} (hij : i ≤ j) [SigmaFinite (μ.trim (ℱ.le j))] :
μ[μ[f|ℱ j]|ℱ i] =ᵐ[μ] μ[f|ℱ i] := condExp_condExp_of_le (ℱ.mono hij) (ℱ.le j) | theorem | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | Filtration.condExp_condExp | null |
filtrationOfSet {s : ι → Set Ω} (hsm : ∀ i, MeasurableSet (s i)) : Filtration ι m where
seq i := MeasurableSpace.generateFrom {t | ∃ j ≤ i, s j = t}
mono' _ _ hnm := MeasurableSpace.generateFrom_mono fun _ ⟨k, hk₁, hk₂⟩ => ⟨k, hk₁.trans hnm, hk₂⟩
le' _ := MeasurableSpace.generateFrom_le fun _ ⟨k, _, hk₂⟩ => hk₂ ▸ hsm k | def | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | filtrationOfSet | Given a sequence of measurable sets `(sₙ)`, `filtrationOfSet` is the smallest filtration
such that `sₙ` is measurable with respect to the `n`-th sub-σ-algebra in `filtrationOfSet`. |
measurableSet_filtrationOfSet {s : ι → Set Ω} (hsm : ∀ i, MeasurableSet[m] (s i)) (i : ι)
{j : ι} (hj : j ≤ i) : MeasurableSet[filtrationOfSet hsm i] (s j) :=
MeasurableSpace.measurableSet_generateFrom ⟨j, hj, rfl⟩ | theorem | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | measurableSet_filtrationOfSet | null |
measurableSet_filtrationOfSet' {s : ι → Set Ω} (hsm : ∀ n, MeasurableSet[m] (s n))
(i : ι) : MeasurableSet[filtrationOfSet hsm i] (s i) :=
measurableSet_filtrationOfSet hsm i le_rfl | theorem | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | measurableSet_filtrationOfSet' | null |
natural (u : ι → Ω → β) (hum : ∀ i, StronglyMeasurable (u i)) : Filtration ι m where
seq i := ⨆ j ≤ i, MeasurableSpace.comap (u j) mβ
mono' _ _ hij := biSup_mono fun _ => ge_trans hij
le' i := by
refine iSup₂_le ?_
rintro j _ s ⟨t, ht, rfl⟩
exact (hum j).measurable ht | def | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | natural | Given a sequence of functions, the natural filtration is the smallest sequence
of σ-algebras such that that sequence of functions is measurable with respect to
the filtration. |
filtrationOfSet_eq_natural [MulZeroOneClass β] [Nontrivial β] {s : ι → Set Ω}
(hsm : ∀ i, MeasurableSet[m] (s i)) :
filtrationOfSet hsm = natural (fun i => (s i).indicator (fun _ => 1 : Ω → β)) fun i =>
stronglyMeasurable_one.indicator (hsm i) := by
simp only [filtrationOfSet, natural, measurableSpace_iSup_eq, exists_prop, mk.injEq]
ext1 i
refine le_antisymm (generateFrom_le ?_) (generateFrom_le ?_)
· rintro _ ⟨j, hij, rfl⟩
refine measurableSet_generateFrom ⟨j, measurableSet_generateFrom ⟨hij, ?_⟩⟩
rw [comap_eq_generateFrom]
refine measurableSet_generateFrom ⟨{1}, measurableSet_singleton 1, ?_⟩
ext x
simp
· rintro t ⟨n, ht⟩
suffices MeasurableSpace.generateFrom {t | n ≤ i ∧
MeasurableSet[MeasurableSpace.comap ((s n).indicator (fun _ => 1 : Ω → β)) mβ] t} ≤
MeasurableSpace.generateFrom {t | ∃ (j : ι), j ≤ i ∧ s j = t} by
exact this _ ht
refine generateFrom_le ?_
rintro t ⟨hn, u, _, hu'⟩
obtain heq | heq | heq | heq := Set.indicator_const_preimage (s n) u (1 : β)
on_goal 4 => rw [Set.mem_singleton_iff] at heq
all_goals rw [heq] at hu'; rw [← hu']
exacts [MeasurableSet.univ, measurableSet_generateFrom ⟨n, hn, rfl⟩,
MeasurableSet.compl (measurableSet_generateFrom ⟨n, hn, rfl⟩), measurableSet_empty _] | theorem | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | filtrationOfSet_eq_natural | null |
noncomputable limitProcess (f : ι → Ω → E) (ℱ : Filtration ι m)
(μ : Measure Ω) :=
if h : ∃ g : Ω → E,
StronglyMeasurable[⨆ n, ℱ n] g ∧ ∀ᵐ ω ∂μ, Tendsto (fun n => f n ω) atTop (𝓝 (g ω)) then
Classical.choose h else 0 | def | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | limitProcess | Given a process `f` and a filtration `ℱ`, if `f` converges to some `g` almost everywhere and
`g` is `⨆ n, ℱ n`-measurable, then `limitProcess f ℱ μ` chooses said `g`, else it returns 0.
This definition is used to phrase the a.e. martingale convergence theorem
`Submartingale.ae_tendsto_limitProcess` where an L¹-bounded submartingale `f` adapted to `ℱ`
converges to `limitProcess f ℱ μ` `μ`-almost everywhere. |
stronglyMeasurable_limitProcess : StronglyMeasurable[⨆ n, ℱ n] (limitProcess f ℱ μ) := by
rw [limitProcess]
split_ifs with h
exacts [(Classical.choose_spec h).1, stronglyMeasurable_zero] | theorem | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | stronglyMeasurable_limitProcess | null |
stronglyMeasurable_limit_process' : StronglyMeasurable[m] (limitProcess f ℱ μ) :=
stronglyMeasurable_limitProcess.mono (sSup_le fun _ ⟨_, hn⟩ => hn ▸ ℱ.le _) | theorem | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | stronglyMeasurable_limit_process' | null |
memLp_limitProcess_of_eLpNorm_bdd {R : ℝ≥0} {p : ℝ≥0∞} {F : Type*} [NormedAddCommGroup F]
{ℱ : Filtration ℕ m} {f : ℕ → Ω → F} (hfm : ∀ n, AEStronglyMeasurable (f n) μ)
(hbdd : ∀ n, eLpNorm (f n) p μ ≤ R) : MemLp (limitProcess f ℱ μ) p μ := by
rw [limitProcess]
split_ifs with h
· refine ⟨StronglyMeasurable.aestronglyMeasurable
((Classical.choose_spec h).1.mono (sSup_le fun m ⟨n, hn⟩ => hn ▸ ℱ.le _)),
lt_of_le_of_lt (Lp.eLpNorm_lim_le_liminf_eLpNorm hfm _ (Classical.choose_spec h).2)
(lt_of_le_of_lt ?_ (ENNReal.coe_lt_top : ↑R < ∞))⟩
simp_rw [liminf_eq, eventually_atTop]
exact sSup_le fun b ⟨a, ha⟩ => (ha a le_rfl).trans (hbdd _)
· exact MemLp.zero | theorem | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | memLp_limitProcess_of_eLpNorm_bdd | null |
piLE : @Filtration (Π i, X i) ι _ pi where
seq i := pi.comap (restrictLe i)
mono' i j hij := by
simp only
rw [← restrictLe₂_comp_restrictLe hij, ← comap_comp]
exact comap_mono (measurable_restrictLe₂ _).comap_le
le' i := (measurable_restrictLe i).comap_le
variable [LocallyFiniteOrderBot ι] | def | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | piLE | The canonical filtration on the product space `Π i, X i`, where `piLE i`
consists of measurable sets depending only on coordinates `≤ i`. |
piLE_eq_comap_frestrictLe (i : ι) : piLE (X := X) i = pi.comap (frestrictLe i) := by
apply le_antisymm
· simp_rw [piLE, ← piCongrLeft_comp_frestrictLe, ← MeasurableEquiv.coe_piCongrLeft, ← comap_comp]
exact MeasurableSpace.comap_mono <| Measurable.comap_le (by fun_prop)
· rw [← piCongrLeft_comp_restrictLe, ← MeasurableEquiv.coe_piCongrLeft, ← comap_comp]
exact MeasurableSpace.comap_mono <| Measurable.comap_le (by fun_prop) | lemma | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | piLE_eq_comap_frestrictLe | null |
piFinset : @Filtration (Π i, X i) (Finset ι) _ pi where
seq s := pi.comap s.restrict
mono' s t hst := by
simp only
rw [← restrict₂_comp_restrict hst, ← comap_comp]
exact comap_mono (measurable_restrict₂ hst).comap_le
le' s := s.measurable_restrict.comap_le | def | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | piFinset | The filtration of events which only depends on finitely many coordinates
on the product space `Π i, X i`, `piFinset s` consists of measurable sets depending only on
coordinates in `s`, where `s : Finset ι`. |
piFinset_eq_comap_restrict (s : Finset ι) :
piFinset (X := X) s = pi.comap s.toSet.restrict := rfl | lemma | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | piFinset_eq_comap_restrict | null |
cylinderEventsCompl : Filtration (Finset α)ᵒᵈ (.pi (X := fun _ : α ↦ Ω)) where
seq Λ := cylinderEvents (↑(OrderDual.ofDual Λ))ᶜ
mono' _ _ h := cylinderEvents_mono <| Set.compl_subset_compl_of_subset h
le' _ := cylinderEvents_le_pi | def | Probability | [
"Mathlib.MeasureTheory.Constructions.Cylinders",
"Mathlib.MeasureTheory.Function.ConditionalExpectation.Real",
"Mathlib.MeasureTheory.MeasurableSpace.PreorderRestrict"
] | Mathlib/Probability/Process/Filtration.lean | cylinderEventsCompl | The exterior σ-algebras of finite sets of `α` form a cofiltration indexed by `Finset α`. |
isProjectiveMeasureFamily_map_restrict (hX : ∀ t, AEMeasurable (X t) P) :
IsProjectiveMeasureFamily (fun I ↦ P.map (fun ω ↦ I.restrict (X · ω))) := by
intro I J hJI
rw [AEMeasurable.map_map_of_aemeasurable (Finset.measurable_restrict₂ _).aemeasurable]
· simp [Finset.restrict_def, Finset.restrict₂_def, Function.comp_def]
· exact aemeasurable_pi_lambda _ fun _ ↦ hX _ | lemma | Probability | [
"Mathlib.MeasureTheory.Constructions.Projective",
"Mathlib.Probability.IdentDistrib"
] | Mathlib/Probability/Process/FiniteDimensionalLaws.lean | isProjectiveMeasureFamily_map_restrict | The finite-dimensional distributions of a stochastic process are a projective measure family. |
isProjectiveLimit_map (hX : AEMeasurable (fun ω ↦ (X · ω)) P) :
IsProjectiveLimit (P.map (fun ω ↦ (X · ω))) (fun I ↦ P.map (fun ω ↦ I.restrict (X · ω))) := by
intro I
rw [AEMeasurable.map_map_of_aemeasurable (Finset.measurable_restrict _).aemeasurable hX,
Function.comp_def] | lemma | Probability | [
"Mathlib.MeasureTheory.Constructions.Projective",
"Mathlib.Probability.IdentDistrib"
] | Mathlib/Probability/Process/FiniteDimensionalLaws.lean | isProjectiveLimit_map | The projective limit of the finite-dimensional distributions of a stochastic process is the law
of the process. |
map_eq_iff_forall_finset_map_restrict_eq [IsFiniteMeasure P]
(hX : AEMeasurable (fun ω ↦ (X · ω)) P) (hY : AEMeasurable (fun ω ↦ (Y · ω)) P) :
P.map (fun ω ↦ (X · ω)) = P.map (fun ω ↦ (Y · ω))
↔ ∀ I : Finset T, P.map (fun ω ↦ I.restrict (X · ω)) = P.map (fun ω ↦ I.restrict (Y · ω)) := by
refine ⟨fun h I ↦ ?_, fun h ↦ ?_⟩
· have hX' : P.map (fun ω ↦ I.restrict (X · ω)) = (P.map (fun ω ↦ (X · ω))).map I.restrict := by
rw [AEMeasurable.map_map_of_aemeasurable (by fun_prop) hX, Function.comp_def]
have hY' : P.map (fun ω ↦ I.restrict (Y · ω)) = (P.map (fun ω ↦ (Y · ω))).map I.restrict := by
rw [AEMeasurable.map_map_of_aemeasurable (by fun_prop) hY, Function.comp_def]
rw [hX', hY', h]
· have hX' := isProjectiveLimit_map hX
simp_rw [h] at hX'
exact hX'.unique (isProjectiveLimit_map hY) | lemma | Probability | [
"Mathlib.MeasureTheory.Constructions.Projective",
"Mathlib.Probability.IdentDistrib"
] | Mathlib/Probability/Process/FiniteDimensionalLaws.lean | map_eq_iff_forall_finset_map_restrict_eq | Two stochastic processes have same law iff they have the same
finite-dimensional distributions. |
identDistrib_iff_forall_finset_identDistrib [IsFiniteMeasure P]
(hX : AEMeasurable (fun ω ↦ (X · ω)) P) (hY : AEMeasurable (fun ω ↦ (Y · ω)) P) :
IdentDistrib (fun ω ↦ (X · ω)) (fun ω ↦ (Y · ω)) P P
↔ ∀ I : Finset T,
IdentDistrib (fun ω ↦ I.restrict (X · ω)) (fun ω ↦ I.restrict (Y · ω)) P P := by
refine ⟨fun h I ↦ ⟨?_, ?_, ?_⟩, fun h ↦ ⟨hX, hY, ?_⟩⟩
· exact (Finset.measurable_restrict _).comp_aemeasurable hX
· exact (Finset.measurable_restrict _).comp_aemeasurable hY
· exact (map_eq_iff_forall_finset_map_restrict_eq hX hY).mp h.map_eq I
· exact (map_eq_iff_forall_finset_map_restrict_eq hX hY).mpr (fun I ↦ (h I).map_eq) | lemma | Probability | [
"Mathlib.MeasureTheory.Constructions.Projective",
"Mathlib.Probability.IdentDistrib"
] | Mathlib/Probability/Process/FiniteDimensionalLaws.lean | identDistrib_iff_forall_finset_identDistrib | Two stochastic processes are identically distributed iff they have the same
finite-dimensional distributions. |
map_restrict_eq_of_forall_ae_eq (h : ∀ t, X t =ᵐ[P] Y t) (I : Finset T) :
P.map (fun ω ↦ I.restrict (X · ω)) = P.map (fun ω ↦ I.restrict (Y · ω)) := by
have h' : ∀ᵐ ω ∂P, ∀ (i : I), X i ω = Y i ω := by
rw [MeasureTheory.ae_all_iff]
exact fun i ↦ h i
refine Measure.map_congr ?_
filter_upwards [h'] with ω h using funext h | lemma | Probability | [
"Mathlib.MeasureTheory.Constructions.Projective",
"Mathlib.Probability.IdentDistrib"
] | Mathlib/Probability/Process/FiniteDimensionalLaws.lean | map_restrict_eq_of_forall_ae_eq | If two processes are modifications of each other, then they have the same finite-dimensional
distributions. |
map_eq_of_forall_ae_eq [IsFiniteMeasure P]
(hX : AEMeasurable (fun ω ↦ (X · ω)) P) (hY : AEMeasurable (fun ω ↦ (Y · ω)) P)
(h : ∀ t, X t =ᵐ[P] Y t) :
P.map (fun ω ↦ (X · ω)) = P.map (fun ω ↦ (Y · ω)) := by
rw [map_eq_iff_forall_finset_map_restrict_eq hX hY]
exact fun I ↦ map_restrict_eq_of_forall_ae_eq h I | lemma | Probability | [
"Mathlib.MeasureTheory.Constructions.Projective",
"Mathlib.Probability.IdentDistrib"
] | Mathlib/Probability/Process/FiniteDimensionalLaws.lean | map_eq_of_forall_ae_eq | If two processes are modifications of each other, then they have the same distribution. |
noncomputable hitting [Preorder ι] [InfSet ι] (u : ι → Ω → β)
(s : Set β) (n m : ι) : Ω → ι :=
fun x => if ∃ j ∈ Set.Icc n m, u j x ∈ s
then sInf (Set.Icc n m ∩ {i : ι | u i x ∈ s}) else m
open scoped Classical in | def | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | hitting | Hitting time: given a stochastic process `u` and a set `s`, `hitting u s n m` is the first time
`u` is in `s` after time `n` and before time `m` (if `u` does not hit `s` after time `n` and
before `m` then the hitting time is simply `m`).
The hitting time is a stopping time if the process is adapted and discrete. |
hitting_def [Preorder ι] [InfSet ι] (u : ι → Ω → β) (s : Set β) (n m : ι) :
hitting u s n m =
fun x => if ∃ j ∈ Set.Icc n m, u j x ∈ s then sInf (Set.Icc n m ∩ {i : ι | u i x ∈ s}) else m :=
rfl | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | hitting_def | null |
hitting_of_lt {m : ι} (h : m < n) : hitting u s n m ω = m := by
grind [hitting, not_le, Set.Icc_eq_empty] | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | hitting_of_lt | This lemma is strictly weaker than `hitting_of_le`. |
hitting_le {m : ι} (ω : Ω) : hitting u s n m ω ≤ m := by
simp only [hitting]
split_ifs with h
· obtain ⟨j, hj₁, hj₂⟩ := h
change j ∈ {i | u i ω ∈ s} at hj₂
exact (csInf_le (BddBelow.inter_of_left bddBelow_Icc) (Set.mem_inter hj₁ hj₂)).trans hj₁.2
· exact le_rfl | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | hitting_le | null |
notMem_of_lt_hitting {m k : ι} (hk₁ : k < hitting u s n m ω) (hk₂ : n ≤ k) :
u k ω ∉ s := by
classical
intro h
have hexists : ∃ j ∈ Set.Icc n m, u j ω ∈ s := ⟨k, ⟨hk₂, le_trans hk₁.le <| hitting_le _⟩, h⟩
refine not_le.2 hk₁ ?_
simp_rw [hitting, if_pos hexists]
exact csInf_le bddBelow_Icc.inter_of_left ⟨⟨hk₂, le_trans hk₁.le <| hitting_le _⟩, h⟩
@[deprecated (since := "2025-05-23")] alias not_mem_of_lt_hitting := notMem_of_lt_hitting | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | notMem_of_lt_hitting | null |
hitting_eq_end_iff {m : ι} : hitting u s n m ω = m ↔
(∃ j ∈ Set.Icc n m, u j ω ∈ s) → sInf (Set.Icc n m ∩ {i : ι | u i ω ∈ s}) = m := by
classical
rw [hitting, ite_eq_right_iff] | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | hitting_eq_end_iff | null |
hitting_of_le {m : ι} (hmn : m ≤ n) : hitting u s n m ω = m := by
obtain rfl | h := le_iff_eq_or_lt.1 hmn
· classical
rw [hitting, ite_eq_right_iff, forall_exists_index]
conv => intro; rw [Set.mem_Icc, Set.Icc_self, and_imp, and_imp]
intro i hi₁ hi₂ hi
rw [Set.inter_eq_left.2, csInf_singleton]
exact Set.singleton_subset_iff.2 (le_antisymm hi₂ hi₁ ▸ hi)
· exact hitting_of_lt h | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | hitting_of_le | null |
le_hitting {m : ι} (hnm : n ≤ m) (ω : Ω) : n ≤ hitting u s n m ω := by
simp only [hitting]
split_ifs with h
· refine le_csInf ?_ fun b hb => ?_
· obtain ⟨k, hk_Icc, hk_s⟩ := h
exact ⟨k, hk_Icc, hk_s⟩
· rw [Set.mem_inter_iff] at hb
exact hb.1.1
· exact hnm | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | le_hitting | null |
le_hitting_of_exists {m : ι} (h_exists : ∃ j ∈ Set.Icc n m, u j ω ∈ s) :
n ≤ hitting u s n m ω := by
refine le_hitting ?_ ω
by_contra h
rw [Set.Icc_eq_empty_of_lt (not_le.mp h)] at h_exists
simp at h_exists | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | le_hitting_of_exists | null |
hitting_mem_Icc {m : ι} (hnm : n ≤ m) (ω : Ω) : hitting u s n m ω ∈ Set.Icc n m :=
⟨le_hitting hnm ω, hitting_le ω⟩ | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | hitting_mem_Icc | null |
hitting_mem_set [WellFoundedLT ι] {m : ι} (h_exists : ∃ j ∈ Set.Icc n m, u j ω ∈ s) :
u (hitting u s n m ω) ω ∈ s := by
simp_rw [hitting, if_pos h_exists]
have h_nonempty : (Set.Icc n m ∩ {i : ι | u i ω ∈ s}).Nonempty := by
obtain ⟨k, hk₁, hk₂⟩ := h_exists
exact ⟨k, Set.mem_inter hk₁ hk₂⟩
have h_mem := csInf_mem h_nonempty
rw [Set.mem_inter_iff] at h_mem
exact h_mem.2 | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | hitting_mem_set | null |
hitting_mem_set_of_hitting_lt [WellFoundedLT ι] {m : ι} (hl : hitting u s n m ω < m) :
u (hitting u s n m ω) ω ∈ s := by
by_cases h : ∃ j ∈ Set.Icc n m, u j ω ∈ s
· exact hitting_mem_set h
· simp_rw [hitting, if_neg h] at hl
exact False.elim (hl.ne rfl) | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | hitting_mem_set_of_hitting_lt | null |
hitting_le_of_mem {m : ι} (hin : n ≤ i) (him : i ≤ m) (his : u i ω ∈ s) :
hitting u s n m ω ≤ i := by
have h_exists : ∃ k ∈ Set.Icc n m, u k ω ∈ s := ⟨i, ⟨hin, him⟩, his⟩
simp_rw [hitting, if_pos h_exists]
exact csInf_le (BddBelow.inter_of_left bddBelow_Icc) (Set.mem_inter ⟨hin, him⟩ his) | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | hitting_le_of_mem | null |
hitting_le_iff_of_exists [WellFoundedLT ι] {m : ι}
(h_exists : ∃ j ∈ Set.Icc n m, u j ω ∈ s) :
hitting u s n m ω ≤ i ↔ ∃ j ∈ Set.Icc n i, u j ω ∈ s := by
constructor <;> intro h'
· exact ⟨hitting u s n m ω, ⟨le_hitting_of_exists h_exists, h'⟩, hitting_mem_set h_exists⟩
· have h'' : ∃ k ∈ Set.Icc n (min m i), u k ω ∈ s := by
obtain ⟨k₁, hk₁_mem, hk₁_s⟩ := h_exists
obtain ⟨k₂, hk₂_mem, hk₂_s⟩ := h'
refine ⟨min k₁ k₂, ⟨le_min hk₁_mem.1 hk₂_mem.1, min_le_min hk₁_mem.2 hk₂_mem.2⟩, ?_⟩
exact min_rec' (fun j => u j ω ∈ s) hk₁_s hk₂_s
obtain ⟨k, hk₁, hk₂⟩ := h''
refine le_trans ?_ (hk₁.2.trans (min_le_right _ _))
exact hitting_le_of_mem hk₁.1 (hk₁.2.trans (min_le_left _ _)) hk₂ | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | hitting_le_iff_of_exists | null |
hitting_le_iff_of_lt [WellFoundedLT ι] {m : ι} (i : ι) (hi : i < m) :
hitting u s n m ω ≤ i ↔ ∃ j ∈ Set.Icc n i, u j ω ∈ s := by
by_cases h_exists : ∃ j ∈ Set.Icc n m, u j ω ∈ s
· rw [hitting_le_iff_of_exists h_exists]
· simp_rw [hitting, if_neg h_exists]
push_neg at h_exists
simp only [not_le.mpr hi, Set.mem_Icc, false_iff, not_exists, not_and, and_imp]
exact fun k hkn hki => h_exists k ⟨hkn, hki.trans hi.le⟩ | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | hitting_le_iff_of_lt | null |
hitting_lt_iff [WellFoundedLT ι] {m : ι} (i : ι) (hi : i ≤ m) :
hitting u s n m ω < i ↔ ∃ j ∈ Set.Ico n i, u j ω ∈ s := by
constructor <;> intro h'
· have h : ∃ j ∈ Set.Icc n m, u j ω ∈ s := by
by_contra h
simp_rw [hitting, if_neg h, ← not_le] at h'
exact h' hi
exact ⟨hitting u s n m ω, ⟨le_hitting_of_exists h, h'⟩, hitting_mem_set h⟩
· obtain ⟨k, hk₁, hk₂⟩ := h'
refine lt_of_le_of_lt ?_ hk₁.2
exact hitting_le_of_mem hk₁.1 (hk₁.2.le.trans hi) hk₂ | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | hitting_lt_iff | null |
hitting_eq_hitting_of_exists {m₁ m₂ : ι} (h : m₁ ≤ m₂)
(h' : ∃ j ∈ Set.Icc n m₁, u j ω ∈ s) : hitting u s n m₁ ω = hitting u s n m₂ ω := by
simp only [hitting, if_pos h']
obtain ⟨j, hj₁, hj₂⟩ := h'
rw [if_pos]
· refine le_antisymm ?_ (by gcongr; exacts [bddBelow_Icc.inter_of_left, ⟨j, hj₁, hj₂⟩])
refine le_csInf ⟨j, Set.Icc_subset_Icc_right h hj₁, hj₂⟩ fun i hi => ?_
by_cases hi' : i ≤ m₁
· exact csInf_le bddBelow_Icc.inter_of_left ⟨⟨hi.1.1, hi'⟩, hi.2⟩
· change j ∈ {i | u i ω ∈ s} at hj₂
exact ((csInf_le bddBelow_Icc.inter_of_left ⟨hj₁, hj₂⟩).trans hj₁.2).trans (le_of_not_ge hi')
exact ⟨j, ⟨hj₁.1, hj₁.2.trans h⟩, hj₂⟩ | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | hitting_eq_hitting_of_exists | null |
hitting_mono {m₁ m₂ : ι} (hm : m₁ ≤ m₂) : hitting u s n m₁ ω ≤ hitting u s n m₂ ω := by
by_cases h : ∃ j ∈ Set.Icc n m₁, u j ω ∈ s
· exact (hitting_eq_hitting_of_exists hm h).le
· simp_rw [hitting, if_neg h]
split_ifs with h'
· obtain ⟨j, hj₁, hj₂⟩ := h'
refine le_csInf ⟨j, hj₁, hj₂⟩ ?_
by_contra hneg; push_neg at hneg
obtain ⟨i, hi₁, hi₂⟩ := hneg
exact h ⟨i, ⟨hi₁.1.1, hi₂.le⟩, hi₁.2⟩
· exact hm | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | hitting_mono | null |
hitting_isStoppingTime [ConditionallyCompleteLinearOrder ι] [WellFoundedLT ι]
[Countable ι] [TopologicalSpace β] [PseudoMetrizableSpace β] [MeasurableSpace β] [BorelSpace β]
{f : Filtration ι m} {u : ι → Ω → β} {s : Set β} {n n' : ι} (hu : Adapted f u)
(hs : MeasurableSet s) : IsStoppingTime f (hitting u s n n') := by
intro i
rcases le_or_gt n' i with hi | hi
· have h_le : ∀ ω, hitting u s n n' ω ≤ i := fun x => (hitting_le x).trans hi
simp [h_le]
· have h_set_eq_Union : {ω | hitting u s n n' ω ≤ i} = ⋃ j ∈ Set.Icc n i, u j ⁻¹' s := by
ext x
rw [Set.mem_setOf_eq, hitting_le_iff_of_lt _ hi]
simp only [Set.mem_Icc, exists_prop, Set.mem_iUnion, Set.mem_preimage]
rw [h_set_eq_Union]
exact MeasurableSet.iUnion fun j =>
MeasurableSet.iUnion fun hj => f.mono hj.2 _ ((hu j).measurable hs) | theorem | Probability | [
"Mathlib.Probability.Process.Stopping",
"Mathlib.Tactic.AdaptationNote"
] | Mathlib/Probability/Process/HittingTime.lean | hitting_isStoppingTime | A discrete hitting time is a stopping time. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.