`Learning.measurable_rewardByCountUntil_of`🔗

Lemma

From the authors

Measurability of rewardByCountUntil A R' t with respect to a σ-algebra m for which the actions and rewards before time t and the auxiliary array are measurable.

Types

𝓐 : Type u_2m𝓐 : MeasurableSpace 𝓐A measurable space is a space equipped with a σ-algebra.DecidableEq 𝓐MeasurableEq 𝓐Typeclass for a measurable space α for which the diagonal of α × α is measurable.
R : Type u_3mR : MeasurableSpace R
Ω : Type u_4m : MeasurableSpace (Ω × (ℕ → 𝓐 → R))

Given

A : ℕ → Ω → 𝓐
R' : ℕ → Ω → R
t : ℕ

Assuming

hA : ∀ i < t, Measurable fun ω => A i ω.1A function f between measurable spaces is measurable if the preimage of every measurable set is measurable.
hR : ∀ i < t, Measurable fun ω => R' i ω.1
hZ : Measurable Prod.snd

Then

Measurable (rewardByCountUntil A R' t)

MeasurableSpace : Type u_6 → Type u_6

A measurable space is a space equipped with a σ-algebra.

DecidableEq : Sort u → Sort (max 1 u)

Propositional equality is `Decidable` for all elements of a type.

In other words, an instance of `DecidableEq α` is a means of deciding the proposition `a = b` is
for all `a b : α`.

MeasurableEq : (α : Type u_1) → [MeasurableSpace α] → Prop

Typeclass for a measurable space `α` for which the diagonal of `α × α` is measurable.

Prod : Type u → Type v → Type (max u v)

The product type, usually written `α × β`. Product types are also called pair or tuple types.
Elements of this type are pairs in which the first element is an `α` and the second element is a
`β`.

Products nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`.


Conventions for notations in identifiers:

 * The recommended spelling of `×` in identifiers is `Prod`.

Nat : Type

The natural numbers, starting at zero.

This type is special-cased by both the kernel and the compiler, and overridden with an efficient
implementation. Both use a fast arbitrary-precision arithmetic library (usually
[GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed.

Measurable : {α : Type u_1} → {β : Type u_2} → [MeasurableSpace α] → [MeasurableSpace β] → (α → β) → Prop

A function `f` between measurable spaces is measurable if the preimage of every
measurable set is measurable.

Prod.snd : {α : Type u} → {β : Type v} → α × β → β

The second element of a pair.

Learning.rewardByCountUntil : {𝓐 : Type u_2} →
  {R : Type u_3} → {Ω : Type u_4} → [DecidableEq 𝓐] → (ℕ → Ω → 𝓐) → (ℕ → Ω → R) → ℕ → Ω × (ℕ → 𝓐 → R) → 𝓐 × ℕ → R

Array of rewards by count, truncated at time `t`: the entry `(a, m)` is the reward received at
the `(m + 1)`-th pull of action `a` if that pull happened before time `t`, and the entry
`(m + 1, a)` of the auxiliary array `ω.2` otherwise.

This is an auxiliary definition used to prove results about the distribution of `rewardByCount`.

It is defined recursively: at time `t`, the
entry `(A t, pullCount A (A t) t)` is replaced by the reward `R' t`.
See `rewardByCountUntil_apply_of_lt_pullCount` and `rewardByCountUntil_apply_of_pullCount_le`.

Go to its page

Code

lemma measurable_rewardByCountUntil_of {m : MeasurableSpace (Ω × (ℕ → 𝓐 → R))}
    [MeasurableEq 𝓐] (t : ℕ)
    (hA : ∀ i < t, Measurable[m] (fun ω : Ω × (ℕ → 𝓐 → R) ↦ A i ω.1))
    (hR : ∀ i < t, Measurable[m] (fun ω : Ω × (ℕ → 𝓐 → R) ↦ R' i ω.1))
    (hZ : Measurable[m] (Prod.snd : Ω × (ℕ → 𝓐 → R) → ℕ → 𝓐 → R)) :
    Measurable[m] (rewardByCountUntil A R' t)

Proof

by
  induction t with
  | zero =>
    have : rewardByCountUntil A R' 0 = (fun z (p : 𝓐 × ℕ) ↦ z (p.2 + 1) p.1) ∘ Prod.snd := rfl
    rw [this]
    exact Measurable.comp (by fun_prop) hZ
  | succ t ih =>
    have ht : t < t + 1 := Nat.lt_succ_self t
    have ih := ih (fun i hi ↦ hA i (hi.trans ht)) (fun i hi ↦ hR i (hi.trans ht))
    have hg : Measurable[m] (fun ω : Ω × (ℕ → 𝓐 → R) ↦
        (A t ω.1, pullCount A (A t ω.1) t ω.1)) := by
      refine Measurable.prodMk (hA t ht) ?_
      simp_rw [pullCount_eq_sum]
      refine Finset.measurable_sum _ fun s hs ↦ Measurable.ite ?_ measurable_const measurable_const
      exact measurableSet_eq_fun (hA s ((Finset.mem_range.1 hs).trans ht)) (hA t ht)
    refine measurable_pi_iff.2 fun p ↦ ?_
    simp_rw [rewardByCountUntil_add_one, Function.update_apply]
    refine Measurable.ite ?_ (hR t ht) ((measurable_pi_apply p).comp ih)
    have h_set : {ω : Ω × (ℕ → 𝓐 → R) | p = (A t ω.1, pullCount A (A t ω.1) t ω.1)}
        = (fun ω : Ω × (ℕ → 𝓐 → R) ↦ (A t ω.1, pullCount A (A t ω.1) t ω.1)) ⁻¹' {p} := by
      ext ω
      simp [eq_comm]
    rw [h_set]
    exact hg (measurableSet_singleton p)

New in v4.34.0-rc2-31-g21d7e67 (2026-09-07), and its meaning has not changed since.

Self-contained, with its dependencies inlined and proofs replaced by sorry: download the raw file · open it in the Lean web editor.

Dependency graph

Audit surface: 2 project declarations, 29 external constants

✓ Proved: no sorry anywhere in its closure

This is the tool's own reading of one build's recorded axioms, and it is not robust against an author who wants it to pass. Checking meant to be relied on should go through Comparator, which replays the proof through the kernel from an export against an explicit list of permitted axioms.

Learning.measurable_rewardByCountUntil_of🔗

`Learning.measurable_rewardByCountUntil_of`🔗