`Learning.IsAlgEnvSeq.absolutelyContinuous_map_history`🔗

This page has the declaration's own card below, then its dependency graph, then a card for each dependency (type dependencies first, then the rest of the transitive closure). For a theorem, the graph and the dependency cards only follow its statement's dependencies (its proof is replaced by sorry, so what it proves doesn't depend on how); for everything else, both the type and the body/value are followed, since their content is part of what later declarations build on.

Minimal Lean file

`absolutelyContinuous_map_history`🔗

LemmaLearning.IsAlgEnvSeq.absolutelyContinuous_map_history

Details

No docstring.

theorem

Learning.IsAlgEnvSeq.absolutelyContinuous_map_history.{u_1, u_2, u_3,
    u_4}
  {𝓐 : Type u_1} {𝓨 : Type u_2} [MeasurableSpace 𝓐] [MeasurableSpace 𝓨]
  {Ω : Type u_3} [MeasurableSpace Ω] {alg : Algorithm 𝓐 𝓨}
  {env : Environment 𝓐 𝓨} {A : ℕ → Ω → 𝓐} {Y : ℕ → Ω → 𝓨}
  {P : MeasureTheory.Measure Ω} [MeasureTheory.IsFiniteMeasure P]
  {Ω₀ : Type u_4} [MeasurableSpace Ω₀] {alg₀ : Algorithm 𝓐 𝓨}
  {A₀ : ℕ → Ω₀ → 𝓐} {Y₀ : ℕ → Ω₀ → 𝓨} {P₀ : MeasureTheory.Measure Ω₀}
  [MeasureTheory.IsProbabilityMeasure P₀]
  (h : IsAlgEnvSeq A Y alg env P) (h₀ : IsAlgEnvSeq A₀ Y₀ alg₀ env P₀)
  (hc : Algorithm.AbsolutelyContinuous alg alg₀) (n : ℕ) :
  MeasureTheory.Measure.AbsolutelyContinuous
    (MeasureTheory.Measure.map (history A Y n) P)
    (MeasureTheory.Measure.map (history A₀ Y₀ n) P₀)
Learning.IsAlgEnvSeq.absolutelyContinuous_map_history.{u_1,
    u_2, u_3, u_4}
  {𝓐 : Type u_1} {𝓨 : Type u_2}
  [MeasurableSpace 𝓐] [MeasurableSpace 𝓨]
  {Ω : Type u_3} [MeasurableSpace Ω]
  {alg : Algorithm 𝓐 𝓨}
  {env : Environment 𝓐 𝓨} {A : ℕ → Ω → 𝓐}
  {Y : ℕ → Ω → 𝓨}
  {P : MeasureTheory.Measure Ω}
  [MeasureTheory.IsFiniteMeasure P]
  {Ω₀ : Type u_4} [MeasurableSpace Ω₀]
  {alg₀ : Algorithm 𝓐 𝓨} {A₀ : ℕ → Ω₀ → 𝓐}
  {Y₀ : ℕ → Ω₀ → 𝓨}
  {P₀ : MeasureTheory.Measure Ω₀}
  [MeasureTheory.IsProbabilityMeasure P₀]
  (h : IsAlgEnvSeq A Y alg env P)
  (h₀ : IsAlgEnvSeq A₀ Y₀ alg₀ env P₀)
  (hc :
    Algorithm.AbsolutelyContinuous alg
      alg₀)
  (n : ℕ) :
  MeasureTheory.Measure.AbsolutelyContinuous
    (MeasureTheory.Measure.map
      (history A Y n) P)
    (MeasureTheory.Measure.map
      (history A₀ Y₀ n) P₀)

Code

lemma absolutelyContinuous_map_history (h : IsAlgEnvSeq A Y alg env P)
    (h₀ : IsAlgEnvSeq A₀ Y₀ alg₀ env P₀) (hc : alg ≪ₐ alg₀) (n : ℕ) :
    P.map (history A Y n) ≪ P₀.map (history A₀ Y₀ n)

Type uses (5)

Body uses (13)

Actions: Source · Open Issue

Proof

by
  induction n with
  | zero =>
    rw [h.hasLaw_history_zero.map_eq, h₀.hasLaw_history_zero.map_eq]
    apply Measure.AbsolutelyContinuous.map _ (by fun_prop)
    rw [h.hasLaw_step_zero.map_eq, h₀.hasLaw_step_zero.map_eq]
    exact Measure.AbsolutelyContinuous.compProd_left hc.p0 _
  | succ n ih =>
    simp_rw [history_succ]
    rw [← Measure.map_map (by fun_prop), ← Measure.map_map (by fun_prop)]
    rotate_left
    · exact (h₀.measurable_history n).prodMk (h₀.measurable_step (n + 1))
    · exact (h.measurable_history n).prodMk (h.measurable_step (n + 1))
    apply Measure.AbsolutelyContinuous.map _ (by fun_prop)
    rw [(h.hasCondDistrib_step n).map_eq, (h₀.hasCondDistrib_step n).map_eq]
    apply Measure.AbsolutelyContinuous.compProd ih
    filter_upwards with h' using Measure.AbsolutelyContinuous.compProd_left_apply (hc.policy n h') _

Dependency graph

Type dependencies (5)

`Algorithm`🔗

StructureLearning.Algorithm

Details

A stochastic, sequential algorithm.

structure

Learning.Algorithm.{u_4, u_5} (𝓐 : Type u_4) (𝓨 : Type u_5)
  [MeasurableSpace 𝓐] [MeasurableSpace 𝓨] : Type (max u_4 u_5)
Learning.Algorithm.{u_4, u_5}
  (𝓐 : Type u_4) (𝓨 : Type u_5)
  [MeasurableSpace 𝓐]
  [MeasurableSpace 𝓨] : Type (max u_4 u_5)

Code

structure Algorithm (𝓐 𝓨 : Type*) [MeasurableSpace 𝓐] [MeasurableSpace 𝓨] where
  /-- Policy or sampling rule: distribution of the next action. -/
  policy : (n : ℕ) → Kernel (Iic n → 𝓐 × 𝓨) 𝓐
  /-- The policy is a Markov kernel. -/
  [h_policy : ∀ n, IsMarkovKernel (policy n)]
  /-- Distribution of the first action. -/
  p0 : Measure 𝓐
  /-- The first action distribution is a probability measure. -/
  [hp0 : IsProbabilityMeasure p0]

Used by (216)

Actions: Source · Open Issue

`Environment`🔗

StructureLearning.Environment

Details

A stochastic environment.

structure

Learning.Environment.{u_4, u_5} (𝓐 : Type u_4) (𝓨 : Type u_5)
  [MeasurableSpace 𝓐] [MeasurableSpace 𝓨] : Type (max u_4 u_5)
Learning.Environment.{u_4, u_5}
  (𝓐 : Type u_4) (𝓨 : Type u_5)
  [MeasurableSpace 𝓐]
  [MeasurableSpace 𝓨] : Type (max u_4 u_5)

Code

structure Environment (𝓐 𝓨 : Type*) [MeasurableSpace 𝓐] [MeasurableSpace 𝓨] where
  /-- Distribution of the next observation as function of the past history. -/
  feedback : (n : ℕ) → Kernel ((Iic n → 𝓐 × 𝓨) × 𝓐) 𝓨
  /-- The feedback kernels are Markov kernels. -/
  [h_feedback : ∀ n, IsMarkovKernel (feedback n)]
  /-- Distribution of the first observation given the first action. -/
  ν0 : Kernel 𝓐 𝓨
  /-- The initial observation kernel is a Markov kernel. -/
  [hp0 : IsMarkovKernel ν0]

Used by (128)

Actions: Source · Open Issue

`IsAlgEnvSeq`🔗

StructureLearning.IsAlgEnvSeq

Details

An algorithm-environment sequence: a sequence of actions and feedbacks generated by an algorithm interacting with an environment.

structure

Learning.IsAlgEnvSeq.{u_1, u_2, u_3} {𝓐 : Type u_1} {𝓨 : Type u_2}
  {Ω : Type u_3} {m𝓐 : MeasurableSpace 𝓐} {m𝓨 : MeasurableSpace 𝓨}
  {mΩ : MeasurableSpace Ω} (A : ℕ → Ω → 𝓐) (Y : ℕ → Ω → 𝓨)
  (alg : Algorithm 𝓐 𝓨) (env : Environment 𝓐 𝓨)
  (P : MeasureTheory.Measure Ω) [MeasureTheory.IsFiniteMeasure P] : Prop
Learning.IsAlgEnvSeq.{u_1, u_2, u_3}
  {𝓐 : Type u_1} {𝓨 : Type u_2}
  {Ω : Type u_3} {m𝓐 : MeasurableSpace 𝓐}
  {m𝓨 : MeasurableSpace 𝓨}
  {mΩ : MeasurableSpace Ω} (A : ℕ → Ω → 𝓐)
  (Y : ℕ → Ω → 𝓨) (alg : Algorithm 𝓐 𝓨)
  (env : Environment 𝓐 𝓨)
  (P : MeasureTheory.Measure Ω)
  [MeasureTheory.IsFiniteMeasure P] : Prop

Code

structure IsAlgEnvSeq
    (A : ℕ → Ω → 𝓐) (Y : ℕ → Ω → 𝓨) (alg : Algorithm 𝓐 𝓨) (env : Environment 𝓐 𝓨)
    (P : Measure Ω) [IsFiniteMeasure P] : Prop where
  /-- The action sequence is measurable. -/
  measurable_action n : Measurable (A n) := by fun_prop
  /-- The feedback sequence is measurable. -/
  measurable_feedback n : Measurable (Y n) := by fun_prop
  /-- The first action has the correct law. -/
  hasLaw_action_zero : HasLaw (fun ω ↦ (A 0 ω)) alg.p0 P
  /-- The first feedback has the correct conditional distribution. -/
  hasCondDistrib_feedback_zero : HasCondDistrib (Y 0) (A 0) env.ν0 P
  /-- The next action has the correct conditional distribution given the history. -/
  hasCondDistrib_action n :
    HasCondDistrib (A (n + 1)) (history A Y n) (alg.policy n) P
  /-- The next feedback has the correct conditional distribution given the history and
  next action. -/
  hasCondDistrib_feedback n :
    HasCondDistrib (Y (n + 1)) (fun ω ↦ (history A Y n ω, A (n + 1) ω))
      (env.feedback n) P

Type uses (3)

Used by (111)

Actions: Source · Open Issue

`AbsolutelyContinuous`🔗

StructureLearning.Algorithm.AbsolutelyContinuous

Details

For every time and history, the distribution over actions according to alg is absolutely continuous with respect to the distribution over actions according to alg₀.

structure

Learning.Algorithm.AbsolutelyContinuous.{u_1, u_2} {𝓐 : Type u_1}
  {𝓨 : Type u_2} [MeasurableSpace 𝓐] [MeasurableSpace 𝓨]
  (alg alg₀ : Algorithm 𝓐 𝓨) : Prop
Learning.Algorithm.AbsolutelyContinuous.{u_1,
    u_2}
  {𝓐 : Type u_1} {𝓨 : Type u_2}
  [MeasurableSpace 𝓐] [MeasurableSpace 𝓨]
  (alg alg₀ : Algorithm 𝓐 𝓨) : Prop

Code

structure AbsolutelyContinuous (alg alg₀ : Algorithm 𝓐 𝓨) : Prop where
  p0 : alg.p0 ≪ alg₀.p0
  policy n h : alg.policy n h ≪ alg₀.policy n h

Type uses (1)

Algorithm

Used by (7)

Actions: Source · Open Issue

`history`🔗

DefinitionLearning.history

Details

History of the algorithm-environment sequence up to time n.

def

Learning.history.{u_1, u_2, u_3} {𝓐 : Type u_1} {𝓨 : Type u_2}
  {Ω : Type u_3} (A : ℕ → Ω → 𝓐) (Y : ℕ → Ω → 𝓨) (n : ℕ) (ω : Ω) :
  ↥(Finset.Iic n) → 𝓐 × 𝓨
Learning.history.{u_1, u_2, u_3}
  {𝓐 : Type u_1} {𝓨 : Type u_2}
  {Ω : Type u_3} (A : ℕ → Ω → 𝓐)
  (Y : ℕ → Ω → 𝓨) (n : ℕ) (ω : Ω) :
  ↥(Finset.Iic n) → 𝓐 × 𝓨

Code

def history (A : ℕ → Ω → 𝓐) (Y : ℕ → Ω → 𝓨) (n : ℕ) (ω : Ω) : Iic n → 𝓐 × 𝓨 :=
  fun i ↦ (A i ω, Y i ω)

Used by (72)

Actions: Source · Open Issue

Learning.IsAlgEnvSeq.absolutelyContinuous_map_history🔗

absolutelyContinuous_map_history🔗

Algorithm🔗

Environment🔗

IsAlgEnvSeq🔗

AbsolutelyContinuous🔗

history🔗

`Learning.IsAlgEnvSeq.absolutelyContinuous_map_history`🔗

`absolutelyContinuous_map_history`🔗

`Algorithm`🔗

`Environment`🔗

`IsAlgEnvSeq`🔗

`AbsolutelyContinuous`🔗

`history`🔗