math / data /lean /OAI /Combinatorics /KServer /Ranks.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
15.5 kB
import Mathlib
namespace OAI
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.RankTracking
variable {Ξ© : Type*} [Fintype Ξ©]
def avg (w : Ξ© β†’ ℝ) (f : Ξ© β†’ ℝ) : ℝ := βˆ‘ Ο‰, w Ο‰*f Ο‰
lemma avg_add (w f g : Ξ© β†’ ℝ) : avg w (fun Ο‰ => f Ο‰+g Ο‰)=avg w f+avg w g := by
simp [avg,mul_add,sum_add_distrib]
lemma avg_sub (w f g : Ξ© β†’ ℝ) : avg w (fun Ο‰ => f Ο‰-g Ο‰)=avg w f-avg w g := by
simp [avg,mul_sub,sum_sub_distrib]
lemma avg_mul (w f : Ξ© β†’ ℝ) (c : ℝ) : avg w (fun Ο‰ => c*f Ο‰)=c*avg w f := by
simp only [avg,mul_sum,mul_left_comm (w _) c]
lemma avg_sum (w : Ξ© β†’ ℝ) {ΞΉ : Type*} [Fintype ΞΉ] (f : ΞΉ β†’ Ξ© β†’ ℝ) :
avg w (fun Ο‰ => βˆ‘ i, f i Ο‰)=βˆ‘ i, avg w (f i) := by
simp only [avg,mul_sum]; rw [sum_comm]
lemma avg_mono {w f g : Ξ© β†’ ℝ} (hw : βˆ€ Ο‰, 0 ≀ w Ο‰) (h : βˆ€ Ο‰, f Ο‰ ≀ g Ο‰) :
avg w f ≀ avg w g := sum_le_sum fun Ο‰ _ => mul_le_mul_of_nonneg_left (h Ο‰) (hw Ο‰)
lemma avg_const (w : Ξ© β†’ ℝ) (hw : βˆ‘ Ο‰, w Ο‰=1) (c : ℝ) : avg w (fun _ => c)=c := by
simp [avg,←sum_mul,hw]
/-- Functions known from the observed finite history label. -/
def Adapted (H : Ξ© β†’ β„•) (f : Ξ© β†’ ℝ) : Prop := βˆ€ Ο‰ Ο‰', H Ο‰=H Ο‰' β†’ f Ο‰=f Ο‰'
/-- Increasing history information, adapted ranks, and the literal finite
conditional tower relation for old counts under the new observation. -/
structure FilteredRanks (w : Ξ© β†’ ℝ) where
history : β„• β†’ Ξ© β†’ β„•
refines : βˆ€ t Ο‰ Ο‰', history (t+1) Ο‰=history (t+1) Ο‰' β†’ history t Ο‰=history t Ο‰'
p : β„• β†’ Ξ© β†’ ℝ
before : β„• β†’ Ξ© β†’ ℝ
range : βˆ€ t Ο‰, p t Ο‰ ∈ Set.Icc 0 1
before_range : βˆ€ t Ο‰, before t Ο‰ ∈ Set.Icc 0 1
adapted : βˆ€ t, Adapted (history t) (p t)
filtering : βˆ€ t h, βˆ‘ Ο‰ ∈ Finset.univ.filter (fun Ο‰ => history t Ο‰=h),
w Ο‰*(before (t+1) Ο‰-p t Ο‰)=0
lemma fiber_weighted_zero (H : Ξ© β†’ β„•) (f g : Ξ© β†’ ℝ)
(hf : Adapted H f) (hg : βˆ€ h, βˆ‘ Ο‰ ∈ Finset.univ.filter (fun Ο‰ => H Ο‰=h), g Ο‰=0) :
βˆ‘ Ο‰, f Ο‰*g Ο‰=0 := by
classical
let c : β„• β†’ ℝ := fun h => if hh : βˆƒ Ο‰, H Ο‰=h then f hh.choose else 0
have hc : βˆ€ Ο‰, f Ο‰=c (H Ο‰) := by
intro Ο‰
dsimp [c]
rw [dite_eq_left βŸ¨Ο‰,rfl⟩]
exact hf Ο‰ _ (Exists.choose_spec (show βˆƒ Ο‰', H Ο‰'=H Ο‰ from βŸ¨Ο‰,rfl⟩)).symm
have hs : (βˆ‘ Ο‰, f Ο‰*g Ο‰) =
βˆ‘ h ∈ Finset.univ.image H, βˆ‘ Ο‰ ∈ Finset.univ.filter (fun Ο‰ => H Ο‰=h), f Ο‰*g Ο‰ := by
symm
exact Finset.sum_fiberwise_of_maps_to (by intro Ο‰ _; exact Finset.mem_image.mpr βŸ¨Ο‰,Finset.mem_univ _,rfl⟩) _
rw [hs]
apply sum_eq_zero
intro h _
calc _ = c h*(βˆ‘ Ο‰ ∈ Finset.univ.filter (fun Ο‰ => H Ο‰=h), g Ο‰) := by
rw [mul_sum]
apply sum_congr rfl
intro ω hω
rw [hc ω,(Finset.mem_filter.mp hω).2]
_ = 0 := by rw [hg,mul_zero]
lemma filtering_affine {w : Ξ© β†’ ℝ} (R : FilteredRanks w) (t : β„•) (f : Ξ© β†’ ℝ)
(hf : Adapted (R.history t) f) :
avg w (fun Ο‰ => f Ο‰*(R.before (t+1) Ο‰-R.p t Ο‰))=0 := by
unfold avg
simp_rw [mul_left_comm (w _) (f _)]
exact fiber_weighted_zero (R.history t) f _ hf (R.filtering t)
end KServer.RankTracking
/-! Construction of the rank martingales from the actual finite hidden law.
No filtering identity is postulated in the construction below. -/
namespace KServer.PosteriorRanks
open Finset
open RankTracking
variable {Ξ© : Type*} [Fintype Ξ©]
def fiber (H : Ξ© β†’ β„•) (h : β„•) : Finset Ξ© := univ.filter (fun Ο‰ => H Ο‰=h)
def mass (w : Ξ© β†’ ℝ) (H : Ξ© β†’ β„•) (h : β„•) : ℝ := βˆ‘ Ο‰ ∈ fiber H h, w Ο‰
def numerator (w : Ξ© β†’ ℝ) (H : Ξ© β†’ β„•) (f : Ξ© β†’ ℝ) (h : β„•) : ℝ :=
βˆ‘ Ο‰ ∈ fiber H h, w Ο‰*f Ο‰
def posterior (w : Ξ© β†’ ℝ) (H : Ξ© β†’ β„•) (f : Ξ© β†’ ℝ) (Ο‰ : Ξ©) : ℝ :=
numerator w H f (H Ο‰) / mass w H (H Ο‰)
lemma mass_nonneg {w : Ξ© β†’ ℝ} (hw : βˆ€ Ο‰, 0 ≀ w Ο‰) (H h) : 0 ≀ mass w H h :=
sum_nonneg fun Ο‰ _ => hw Ο‰
lemma numerator_zero {w : Ξ© β†’ ℝ} (hw : βˆ€ Ο‰, 0 ≀ w Ο‰) {H h}
(hm : mass w H h=0) (f : Ξ© β†’ ℝ) : numerator w H f h=0 := by
have hzero : βˆ€ Ο‰ ∈ fiber H h, w Ο‰=0 :=
(sum_eq_zero_iff_of_nonneg (fun Ο‰ _ => hw Ο‰)).mp hm
exact sum_eq_zero fun ω hω => by rw [hzero ω hω,zero_mul]
lemma posterior_adapted (w : Ξ© β†’ ℝ) (H : Ξ© β†’ β„•) (f : Ξ© β†’ ℝ) :
Adapted H (posterior w H f) := by
intro Ο‰ Ο‰' hh
simp only [posterior,hh]
lemma posterior_range {w : Ξ© β†’ ℝ} (hw : βˆ€ Ο‰, 0 ≀ w Ο‰)
(H : Ξ© β†’ β„•) {f : Ξ© β†’ ℝ} (hf : βˆ€ Ο‰, f Ο‰ ∈ Set.Icc 0 1) (Ο‰ : Ξ©) :
posterior w H f Ο‰ ∈ Set.Icc 0 1 := by
have hm := mass_nonneg hw H (H Ο‰)
have hn : 0 ≀ numerator w H f (H Ο‰) := sum_nonneg fun z _ => mul_nonneg (hw z) (hf z).1
have hnle : numerator w H f (H Ο‰) ≀ mass w H (H Ο‰) := by
apply sum_le_sum
intro z _
exact mul_le_of_le_one_right (hw z) (hf z).2
constructor
Β· exact div_nonneg hn hm
Β· by_cases hz : mass w H (H Ο‰)=0
Β· simp [posterior,hz]
Β· exact (div_le_one (lt_of_le_of_ne hm (Ne.symm hz))).mpr hnle
lemma fiber_posterior {w : Ξ© β†’ ℝ} (hw : βˆ€ Ο‰, 0 ≀ w Ο‰)
(H : Ξ© β†’ β„•) (f : Ξ© β†’ ℝ) (h : β„•) :
βˆ‘ Ο‰ ∈ fiber H h, w Ο‰*posterior w H f Ο‰ = numerator w H f h := by
calc _ = mass w H h*(numerator w H f h/mass w H h) := by
unfold mass
rw [sum_mul]
apply sum_congr rfl
intro ω hω
simp only [fiber,mem_filter,mem_univ,true_and] at hω
rw [posterior,hω]
rfl
_ = numerator w H f h := by
by_cases hm : mass w H h=0
Β· rw [hm,numerator_zero hw hm f]; norm_num
Β· field_simp
lemma fiber_difference {w : Ξ© β†’ ℝ} (hw : βˆ€ Ο‰, 0 ≀ w Ο‰)
(H : Ξ© β†’ β„•) (f : Ξ© β†’ ℝ) (h : β„•) :
βˆ‘ Ο‰ ∈ fiber H h, w Ο‰*(posterior w H f Ο‰-f Ο‰)=0 := by
simp only [mul_sub,sum_sub_distrib,fiber_posterior hw,numerator,sub_self]
lemma weighted_posterior {w : Ξ© β†’ ℝ} (hw : βˆ€ Ο‰, 0 ≀ w Ο‰)
(H : Ξ© β†’ β„•) (f g : Ξ© β†’ ℝ) (hg : Adapted H g) :
avg w (fun Ο‰ => g Ο‰*posterior w H f Ο‰)=avg w (fun Ο‰ => g Ο‰*f Ο‰) := by
have hh := fiber_weighted_zero H g (fun Ο‰ => w Ο‰*(posterior w H f Ο‰-f Ο‰)) hg
(fiber_difference hw H f)
simp only [mul_sub,mul_left_comm (g _) (w _),sum_sub_distrib] at hh
exact sub_eq_zero.mp hh
lemma posterior_avg {w : Ξ© β†’ ℝ} (hw : βˆ€ Ο‰, 0 ≀ w Ο‰) (H : Ξ© β†’ β„•) (f : Ξ© β†’ ℝ) :
avg w (posterior w H f)=avg w f := by
simpa only [one_mul] using weighted_posterior hw H f (fun _ => 1) (by intro _ _ _; rfl)
lemma filtered_fiber {w : Ξ© β†’ ℝ} (hw : βˆ€ Ο‰, 0 ≀ w Ο‰) (H H' : Ξ© β†’ β„•)
(hr : βˆ€ Ο‰ Ο‰', H' Ο‰=H' Ο‰' β†’ H Ο‰=H Ο‰') (f : Ξ© β†’ ℝ) (h : β„•) :
βˆ‘ Ο‰ ∈ fiber H h, w Ο‰*(posterior w H' f Ο‰-posterior w H f Ο‰)=0 := by
let g := fun Ο‰ => if H Ο‰=h then (1:ℝ) else 0
have hga : Adapted H g := by intro Ο‰ z hz; simp [g,hz]
have hgb : Adapted H' g := by intro Ο‰ z hz; simp [g,hr Ο‰ z hz]
have ha := weighted_posterior hw H f g hga
have hb := weighted_posterior hw H' f g hgb
have hh : avg w (fun Ο‰ => g Ο‰*posterior w H' f Ο‰)-
avg w (fun Ο‰ => g Ο‰*posterior w H f Ο‰)=0 := by rw [ha,hb,sub_self]
rw [←avg_sub] at hh
unfold avg at hh
simpa only [fiber,sum_filter,g,ite_mul,one_mul,zero_mul,ite_sub_ite,sub_zero,
mul_ite,mul_zero] using hh
/-- The true post-filtering, post-drift ranks and the filtered old ranks on an
arbitrary finite experiment with increasing observations. -/
def rank (N : Ξ© β†’ β„•) (a : β„•) (Ο‰ : Ξ©) : ℝ := if N Ο‰ ≀ a then 1 else 0
omit [Fintype Ξ©] in
lemma rank_range (N : Ξ© β†’ β„•) (a : β„•) (Ο‰ : Ξ©) : rank N a Ο‰ ∈ Set.Icc 0 1 := by
unfold rank; split_ifs <;> norm_num
def rankProcess {w : Ξ© β†’ ℝ} (hw : βˆ€ Ο‰, 0 ≀ w Ο‰)
(H : β„• β†’ Ξ© β†’ β„•) (hr : βˆ€ t Ο‰ z, H (t+1) Ο‰=H (t+1) z β†’ H t Ο‰=H t z)
(N : β„• β†’ Ξ© β†’ β„•) (a : β„•) : FilteredRanks w where
history := H
refines := hr
p := fun t => posterior w (H t) (rank (N t) a)
before := fun t => posterior w (H t) (rank (N (t-1)) a)
range := fun t Ο‰ => posterior_range hw (H t) (rank_range (N t) a) Ο‰
before_range := fun t Ο‰ => posterior_range hw (H t) (rank_range (N (t-1)) a) Ο‰
adapted := fun t => posterior_adapted w (H t) (rank (N t) a)
filtering := by
intro t h
simp only [Nat.add_sub_cancel]
exact filtered_fiber hw (H t) (H (t+1)) (hr t) (rank (N t) a) h
lemma posterior_sub (w : Ξ© β†’ ℝ) (H : Ξ© β†’ β„•) (f g : Ξ© β†’ ℝ) (Ο‰ : Ξ©) :
posterior w H (fun z => f z-g z) Ο‰ = posterior w H f Ο‰-posterior w H g Ο‰ := by
simp only [posterior,numerator,mul_sub,sum_sub_distrib,sub_div]
lemma abs_posterior_le {w : Ξ© β†’ ℝ} (hw : βˆ€ Ο‰, 0 ≀ w Ο‰)
(H : Ξ© β†’ β„•) (f : Ξ© β†’ ℝ) (Ο‰ : Ξ©) :
|posterior w H f Ο‰| ≀ posterior w H (fun z => |f z|) Ο‰ := by
have hn : |numerator w H f (H Ο‰)| ≀ numerator w H (fun z => |f z|) (H Ο‰) := by
unfold numerator
calc _ ≀ βˆ‘ z ∈ fiber H (H Ο‰), |w z*f z| := abs_sum_le_sum_abs _ _
_ = _ := by apply sum_congr rfl; intro z _; rw [abs_mul,abs_of_nonneg (hw z)]
unfold posterior
rw [abs_div,abs_of_nonneg (mass_nonneg hw H (H Ο‰))]
exact div_le_div_of_nonneg_right hn (mass_nonneg hw H (H Ο‰))
/-- Conditional averaging cannot increase the drift, even at zero-mass
histories, where the quotient convention simply chooses zero. -/
theorem posterior_drift {w : Ξ© β†’ ℝ} (hw : βˆ€ Ο‰, 0 ≀ w Ο‰)
(H : Ξ© β†’ β„•) (f g : Ξ© β†’ ℝ) :
avg w (fun Ο‰ => |posterior w H f Ο‰-posterior w H g Ο‰|) ≀
avg w (fun Ο‰ => |f Ο‰-g Ο‰|) := by
calc _ = avg w (fun Ο‰ => |posterior w H (fun z => f z-g z) Ο‰|) := by simp only [posterior_sub]
_ ≀ avg w (posterior w H (fun z => |f z-g z|)) :=
avg_mono hw (abs_posterior_le hw H (fun z => f z-g z))
_ = _ := posterior_avg hw H _
lemma sum_below {k N : β„•} (hN : N ≀ k) :
(βˆ‘ a : Fin k, if a.val < N then (1 : ℝ) else 0) = N := by
rw [Fin.sum_univ_eq_sum_range (fun a => if a < N then (1 : ℝ) else 0), ← sum_filter]
have h : (range k).filter (fun a => a < N) = range N := by
ext a
simp only [mem_filter, mem_range]
omega
rw [h]
simp
lemma sum_above {k N : β„•} (hN : N ≀ k) :
(βˆ‘ a : Fin k, if N ≀ a.val then (1 : ℝ) else 0) = (k:ℝ)-N := by
have hsum : (βˆ‘ a : Fin k, if N ≀ a.val then (1 : ℝ) else 0)+
(βˆ‘ a : Fin k, if a.val < N then (1 : ℝ) else 0) = k := by
rw [←sum_add_distrib]
have hterm (a : Fin k) : (if N ≀ a.val then (1:ℝ) else 0)+(if a.val < N then (1:ℝ) else 0)=1 := by
split_ifs <;> first | (exfalso; omega) | norm_num
simp_rw [hterm]
simp
rw [sum_below hN] at hsum
linarith
lemma indicator_count_distance {k n m : β„•} (hn : n ≀ k) (hm : m ≀ k) :
(βˆ‘ a : Fin k, |(if n ≀ a.val then (1:ℝ) else 0)-(if m ≀ a.val then (1:ℝ) else 0)|) =
|(n:ℝ)-m| := by
wlog hnm : n ≀ m generalizing n m
Β· rw [abs_sub_comm (n:ℝ) m]
rw [←this hm hn (le_of_not_ge hnm)]
exact sum_congr rfl fun a _ => abs_sub_comm _ _
have hnmR : (n:ℝ) ≀ m := by exact_mod_cast hnm
calc _ = βˆ‘ a : Fin k, ((if n ≀ a.val then (1:ℝ) else 0)-(if m ≀ a.val then (1:ℝ) else 0)) := by
apply sum_congr rfl
intro a _
apply abs_of_nonneg
split_ifs <;> first | (exfalso; omega) | norm_num
_ = (m:ℝ)-n := by rw [sum_sub_distrib,sum_above hn,sum_above hm]; ring
_ = |(n:ℝ)-m| := by rw [abs_of_nonpos (sub_nonpos.mpr hnmR)]; ring
/-- The exact Β§03 all-rank drift budget, derived from the finite hidden count
process rather than assumed as an interface. -/
theorem rank_drift_count {w : Ξ© β†’ ℝ} (hw : βˆ€ Ο‰, 0 ≀ w Ο‰)
(H : Ξ© β†’ β„•) {k : β„•} (N M : Ξ© β†’ β„•) (hN : βˆ€ Ο‰, N Ο‰ ≀ k) (hM : βˆ€ Ο‰, M Ο‰ ≀ k) :
(βˆ‘ a : Fin k, avg w (fun Ο‰ => |posterior w H (rank N a.val) Ο‰-
posterior w H (rank M a.val) Ο‰|)) ≀ avg w (fun Ο‰ => |(N Ο‰:ℝ)-M Ο‰|) := by
calc _ ≀ βˆ‘ a : Fin k, avg w (fun Ο‰ => |rank N a.val Ο‰-rank M a.val Ο‰|) :=
sum_le_sum fun a _ => posterior_drift hw H _ _
_ = avg w (fun Ο‰ => βˆ‘ a : Fin k, |rank N a.val Ο‰-rank M a.val Ο‰|) :=
(avg_sum w _).symm
_ = _ := by
congr 1
funext Ο‰
exact indicator_count_distance (hN Ο‰) (hM Ο‰)
/-- The instantiated process defined above obeys the source estimate with
actual one-step hidden-count motion on its right-hand side. -/
theorem rankProcess_drift {w : Ξ© β†’ ℝ} (hw : βˆ€ Ο‰, 0 ≀ w Ο‰)
(H : β„• β†’ Ξ© β†’ β„•) (hr : βˆ€ t Ο‰ z, H (t+1) Ο‰=H (t+1) z β†’ H t Ο‰=H t z)
{k : β„•} (N : β„• β†’ Ξ© β†’ β„•) (hN : βˆ€ t Ο‰, N t Ο‰ ≀ k) (t : β„•) :
(βˆ‘ a : Fin k, avg w (fun Ο‰ => |(rankProcess hw H hr N a.val).p (t+1) Ο‰-
(rankProcess hw H hr N a.val).before (t+1) Ο‰|)) ≀
avg w (fun Ο‰ => |(N (t+1) Ο‰:ℝ)-N t Ο‰|) := by
simpa only [rankProcess,Nat.add_sub_cancel] using
rank_drift_count hw (H (t+1)) (N (t+1)) (N t) (hN (t+1)) (hN t)
end KServer.PosteriorRanks
/-! ## The actual finite hidden experiment of Β§02
The input is drawn once. Its selected optimum is hidden, whereas a finite
independent partition tape and the true request prefix are observed. No
conditioning on rounding outcomes enters this experiment. -/
namespace KServer.PosteriorRanks
variable {Ξ© : Type*} [Fintype Ξ©]
lemma mass_pos_of_weight {w : Ξ© β†’ ℝ} (hw : βˆ€ Ο‰, 0≀w Ο‰) (H : Ξ© β†’ β„•)
(ω : Ω) (hω : 0<w ω) : 0 < mass w H (H ω) := by
apply hω.trans_le
exact single_le_sum (fun z _ => hw z) (by simp [fiber])
lemma posterior_nonneg {w : Ξ© β†’ ℝ} (hw : βˆ€ Ο‰, 0≀w Ο‰) (H : Ξ© β†’ β„•)
{f : Ξ© β†’ ℝ} (hf : βˆ€ Ο‰, 0≀f Ο‰) (Ο‰ : Ξ©) : 0≀posterior w H f Ο‰ :=
div_nonneg (sum_nonneg fun z _ => mul_nonneg (hw z) (hf z)) (mass_nonneg hw H _)
lemma posterior_sum {I : Type*} [Fintype I] (w : Ξ© β†’ ℝ) (H : Ξ© β†’ β„•)
(f : I β†’ Ξ© β†’ ℝ) (Ο‰ : Ξ©) :
posterior w H (fun z => βˆ‘ i,f i z) Ο‰=βˆ‘ i,posterior w H (f i) Ο‰ := by
simp only [posterior,numerator,mul_sum,sum_div]
rw [sum_comm]
lemma posterior_fiber_const {w : Ξ© β†’ ℝ} {H : Ξ© β†’ β„•} {f : Ξ© β†’ ℝ}
(Ο‰ : Ξ©) {c : ℝ} (hf : βˆ€ z,H z=H Ο‰ β†’ f z=c) (hm : mass w H (H Ο‰)β‰ 0) :
posterior w H f Ο‰=c := by
have hn : numerator w H f (H Ο‰)=mass w H (H Ο‰)*c := by
unfold numerator mass
rw [sum_mul]
apply sum_congr rfl
intro z hz
rw [hf z (mem_filter.mp hz).2]
rw [posterior,hn,mul_div_cancel_leftβ‚€ _ hm]
lemma posterior_mono_fiber {w : Ξ© β†’ ℝ} (hw : βˆ€ Ο‰,0≀w Ο‰) {H : Ξ© β†’ β„•}
{f g : Ξ© β†’ ℝ} (Ο‰ : Ξ©) (hfg : βˆ€ z,H z=H Ο‰ β†’ f z≀g z) :
posterior w H f ω≀posterior w H g Ο‰ := by
apply div_le_div_of_nonneg_right _ (mass_nonneg hw H _)
apply sum_le_sum
intro z hz
exact mul_le_mul_of_nonneg_left (hfg z (mem_filter.mp hz).2) (hw z)
lemma posterior_add (w : Ξ© β†’ ℝ) (H : Ξ© β†’ β„•) (f g : Ξ© β†’ ℝ) (Ο‰ : Ξ©) :
posterior w H (fun z => f z+g z) Ο‰=posterior w H f Ο‰+posterior w H g Ο‰ := by
simp [posterior,numerator,mul_add,sum_add_distrib,add_div]
lemma posterior_mul (w : Ξ© β†’ ℝ) (H : Ξ© β†’ β„•) (f : Ξ© β†’ ℝ) (c : ℝ) (Ο‰ : Ξ©) :
posterior w H (fun z => f z*c) Ο‰=posterior w H f Ο‰*c := by
simp only [posterior,numerator,←mul_assoc,←sum_mul]
ring
end KServer.PosteriorRanks
end
end OAI