Documentation

Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj

Consecutive composition of kernels #

This file is the first step towards Ionescu-Tulcea theorem, which allows for instance to construct the product of an infinite family of probability measures. The idea of the statement is as follows: consider a family of kernels κ : (n : ℕ) → Kernel (Π i : Iic n, X i) (X (n + 1)). One can interpret κ n as a kernel which takes as an input the trajectory of a point started in X 0 and moving X 0 → X 1 → X 2 → ... → X n and which outputs the distribution of the next position of the point in X (n + 1). If a b : ℕ and a < b, we can compose the kernels, and κ a ⊗ₖ κ (a + 1) ⊗ₖ ... ⊗ₖ κ b takes the trajectory up to time a as input and outputs the distribution of the trajectory in X (a + 1) × ... × X (b + 1).

The Ionescu-Tulcea theorem then tells us that these compositions can be extended into a kernel η : Kernel (Π i : Iic a, X i) → Π n > a, X n which given the trajectory up to time a outputs the distribution of the infinite trajectory started in X (a + 1). In other words this theorem makes sense of composing infinitely many kernels together.

To be able to even state the theorem we want to take the composition-product (see ProbabilityTheory.Kernel.compProd) of consecutive kernels. This however is not straightforward.

Consider n : ℕ. We cannot write (κ n) ⊗ₖ (κ (n + 1)) directly, we need to first introduce an equivalence to see κ (n + 1) as a kernel with codomain (Π i : Iic n, X i) × X (n + 1), and we get a Kernel (Π i : Iic n, X i) (X (n + 1) × (X (n + 2)). However we want to do multiple compostion at ones, i.e. write (κ n) ⊗ₖ ... ⊗ₖ (κ m) for n < m. This requires even more equivalences to make sense of, and at the end of the day we get kernels which still cannot be composed together.

To tackle this issue, we decide here to only consider kernels of the form Kernel (Π i : Iic a, X i) (Π i : Iic b, X i). In other words these kernels take as input a trajectory up to time a and output the distribution of the full trajectory up to time b. This is captured in the definition partialTraj κ a b (partialTraj stands for "partial trajectory"). The advantage of this approach is that it allows us to write for instance partialTraj κ b c ∘ₖ partialTraj κ a b = partialTraj κ a c (see partialTraj_comp_partialTraj.)

In this file we therefore define this family of kernels and prove some properties of it. In particular we provide at the end of the file some results to compute the integral of a function against partialTraj κ a b, taking inspiration from MeasureTheory.lmarginal.

Main definitions #

Main statements #

Tags #

Ionescu-Tulcea theorem, composition of kernels

Definition of partialTraj #

noncomputable def ProbabilityTheory.Kernel.partialTraj {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} (κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))) (a b : ) :
Kernel ((i : { x : // x Finset.Iic a }) → X i) ((i : { x : // x Finset.Iic b }) → X i)

Given a family of kernels κ n from X 0 × ... × X n to X (n + 1) for all n, construct a kernel from X 0 × ... × X a to X 0 × ... × X b by iterating κ.

The idea is that the input is some trajectory up to time a, and the ouptut is the distribution of the trajectory up to time b. In particular if b ≤ a, this is just a deterministic kernel (see partialTraj_le). The name partialTraj stands for "partial trajectory".

This kernel can be extended into a kernel with codomain Π n, X n via the Ionescu-Tulcea theorem.

Equations
  • One or more equations did not get rendered due to their size.
Instances For
    theorem ProbabilityTheory.Kernel.partialTraj_le {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {a b : } {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} (hba : b a) :

    If b ≤ a, given the trajectory up to time a, the trajectory up to time b is deterministic and is equal to the restriction of the trajectory up to time a.

    @[simp]
    theorem ProbabilityTheory.Kernel.partialTraj_self {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} (a : ) :
    @[simp]
    theorem ProbabilityTheory.Kernel.partialTraj_zero {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {a : } {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} :
    theorem ProbabilityTheory.Kernel.partialTraj_le_def {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {a b : } {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} (hab : a b) :
    partialTraj κ a b = Nat.leRec Kernel.id (fun (k : ) (x : a k) (κ_k : (fun (b : ) (x : a b) => Kernel ((i : { x : // x Finset.Iic a }) → X i) ((i : { x : // x Finset.Iic b }) → X i)) k x) => ((Kernel.id.prod ((κ k).map (MeasurableEquiv.piSingleton k))).comp κ_k).map (IicProdIoc k (k + 1))) hab
    theorem ProbabilityTheory.Kernel.partialTraj_succ_of_le {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {a b : } {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} (hab : a b) :
    partialTraj κ a (b + 1) = ((Kernel.id.prod ((κ b).map (MeasurableEquiv.piSingleton b))).comp (partialTraj κ a b)).map (IicProdIoc b (b + 1))
    instance ProbabilityTheory.Kernel.instIsSFiniteKernelForallValNatMemFinsetIicPartialTraj {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} (a b : ) :
    instance ProbabilityTheory.Kernel.instIsFiniteKernelForallValNatMemFinsetIicPartialTrajOfHAddOfNat {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} [∀ (n : ), IsFiniteKernel (κ n)] (a b : ) :
    instance ProbabilityTheory.Kernel.instIsZeroOrMarkovKernelForallValNatMemFinsetIicPartialTrajOfHAddOfNat {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} [∀ (n : ), IsZeroOrMarkovKernel (κ n)] (a b : ) :
    instance ProbabilityTheory.Kernel.instIsMarkovKernelForallValNatMemFinsetIicPartialTrajOfHAddOfNat {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} [∀ (n : ), IsMarkovKernel (κ n)] (a b : ) :
    theorem ProbabilityTheory.Kernel.partialTraj_succ_self {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} (a : ) :
    partialTraj κ a (a + 1) = (Kernel.id.prod ((κ a).map (MeasurableEquiv.piSingleton a))).map (IicProdIoc a (a + 1))
    theorem ProbabilityTheory.Kernel.partialTraj_succ_eq_comp {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {a b : } {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} (hab : a b) :
    partialTraj κ a (b + 1) = (partialTraj κ b (b + 1)).comp (partialTraj κ a b)
    theorem ProbabilityTheory.Kernel.partialTraj_comp_partialTraj {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {a b c : } {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} (hab : a b) (hbc : b c) :
    (partialTraj κ b c).comp (partialTraj κ a b) = partialTraj κ a c

    Given the trajectory up to time a, partialTraj κ a b gives the distribution of the trajectory up to time b. Then plugging this into partialTraj κ b c gives the distribution of the trajectory up to time c.

    theorem ProbabilityTheory.Kernel.partialTraj_eq_prod {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} [∀ (n : ), IsSFiniteKernel (κ n)] (a b : ) :

    This is a technical lemma saying that partialTraj κ a b consists of two independent parts, the first one being the identity. It allows to compute integrals.

    theorem ProbabilityTheory.Kernel.partialTraj_succ_map_frestrictLe₂ {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} [∀ (n : ), IsMarkovKernel (κ n)] (a b : ) :
    theorem ProbabilityTheory.Kernel.partialTraj_map_frestrictLe₂ {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {b c : } {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} [∀ (n : ), IsMarkovKernel (κ n)] (a : ) (hbc : b c) :

    If we restrict the distribution of the trajectory up to time c to times ≤ b we get the trajectory up to time b.

    theorem ProbabilityTheory.Kernel.partialTraj_map_frestrictLe₂_apply {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {a b c : } {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} [∀ (n : ), IsMarkovKernel (κ n)] (x₀ : (i : { x : // x Finset.Iic a }) → X i) (hbc : b c) :
    theorem ProbabilityTheory.Kernel.partialTraj_comp_partialTraj' {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {a b : } {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} [∀ (n : ), IsMarkovKernel (κ n)] (c : ) (hab : a b) :
    (partialTraj κ b c).comp (partialTraj κ a b) = partialTraj κ a c

    Same as partialTraj_comp_partialTraj but only assuming a ≤ b. It requires Markov kernels.

    theorem ProbabilityTheory.Kernel.partialTraj_comp_partialTraj'' {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {a : } {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} [∀ (n : ), IsMarkovKernel (κ n)] {b c : } (hcb : c b) :
    (partialTraj κ b c).comp (partialTraj κ a b) = partialTraj κ a c

    Same as partialTraj_comp_partialTraj but only assuming b ≤ c. It requires Markov kernels.

    Integrating against partialTraj #

    noncomputable def ProbabilityTheory.Kernel.lmarginalPartialTraj {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} (κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))) (a b : ) (f : ((n : ) → X n)ENNReal) (x₀ : (n : ) → X n) :

    This function computes the integral of a function f against partialTraj, and allows to view it as a function depending on all the variables.

    This is inspired by MeasureTheory.lmarginal, to be able to write lmarginalPartialTraj κ b c (lmarginalPartialTraj κ a b f) = lmarginalPartialTraj κ a c.

    Equations
    • One or more equations did not get rendered due to their size.
    Instances For
      theorem ProbabilityTheory.Kernel.lmarginalPartialTraj_le {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {a b : } (κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))) (hba : b a) {f : ((n : ) → X n)ENNReal} (mf : Measurable f) :

      If b ≤ a, then integrating f against partialTraj κ a b does nothing.

      theorem ProbabilityTheory.Kernel.lmarginalPartialTraj_mono {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} (a b : ) {f g : ((n : ) → X n)ENNReal} (hfg : f g) (x₀ : (n : ) → X n) :
      lmarginalPartialTraj κ a b f x₀ lmarginalPartialTraj κ a b g x₀
      theorem ProbabilityTheory.Kernel.lmarginalPartialTraj_eq_lintegral_map {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {a b : } {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} [∀ (n : ), IsSFiniteKernel (κ n)] {f : ((n : ) → X n)ENNReal} (mf : Measurable f) (x₀ : (n : ) → X n) :
      lmarginalPartialTraj κ a b f x₀ = ∫⁻ (x : (i : { x : // x Finset.Ioc a b }) → X i), f (Function.updateFinset x₀ (Finset.Ioc a b) x) ((partialTraj κ a b).map (Finset.restrict₂ )) (Preorder.frestrictLe a x₀)

      Integrating f against partialTraj κ a b x is the same as integrating only over the variables from x_{a+1} to x_b.

      theorem ProbabilityTheory.Kernel.lmarginalPartialTraj_succ {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} [∀ (n : ), IsSFiniteKernel (κ n)] (a : ) {f : ((n : ) → X n)ENNReal} (mf : Measurable f) (x₀ : (n : ) → X n) :
      lmarginalPartialTraj κ a (a + 1) f x₀ = ∫⁻ (x : X (a + 1)), f (Function.update x₀ (a + 1) x) (κ a) (Preorder.frestrictLe a x₀)

      Integrating f against partialTraj κ a (a + 1) is the same as integrating against κ a.

      theorem ProbabilityTheory.Kernel.measurable_lmarginalPartialTraj {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} (a b : ) {f : ((n : ) → X n)ENNReal} (hf : Measurable f) :
      theorem ProbabilityTheory.Kernel.lmarginalPartialTraj_self {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {a b c : } {κ : (n : ) → Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} (hab : a b) (hbc : b c) {f : ((n : ) → X n)ENNReal} (hf : Measurable f) :

      Integrating f against partialTraj κ a b and then against partialTraj κ b c is the same as integrating f against partialTraj κ a c.

      Lemmas about lmarginalPartialTraj and DependsOn #

      theorem DependsOn.lmarginalPartialTraj_of_le {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {a b : } {κ : (n : ) → ProbabilityTheory.Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} [∀ (n : ), ProbabilityTheory.IsMarkovKernel (κ n)] (c : ) {f : ((n : ) → X n)ENNReal} (mf : Measurable f) (hf : DependsOn f (Finset.Iic a)) (hab : a b) :

      If f only depends on the variables up to rank a and a ≤ b, integrating f against partialTraj κ b c does nothing.

      theorem DependsOn.lmarginalPartialTraj_const_right {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {a b c : } {κ : (n : ) → ProbabilityTheory.Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} [∀ (n : ), ProbabilityTheory.IsMarkovKernel (κ n)] {d : } {f : ((n : ) → X n)ENNReal} (mf : Measurable f) (hf : DependsOn f (Finset.Iic a)) (hac : a c) (had : a d) :

      If f only depends on the variables uo to rank a, integrating beyond rank a is the same as integrating up to rank a.

      theorem DependsOn.dependsOn_lmarginalPartialTraj {X : Type u_1} {mX : (n : ) → MeasurableSpace (X n)} {b : } {κ : (n : ) → ProbabilityTheory.Kernel ((i : { x : // x Finset.Iic n }) → X i) (X (n + 1))} [∀ (n : ), ProbabilityTheory.IsSFiniteKernel (κ n)] (a : ) {f : ((n : ) → X n)ENNReal} (hf : DependsOn f (Finset.Iic b)) (mf : Measurable f) :

      If f only depends on variables up to rank b, its integral from a to b only depends on variables up to rank a.