| 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] |
|
|
| / |
| def Adapted (H : Ω → ℕ) (f : Ω → ℝ) : Prop := ∀ ω ω', H ω=H ω' → f ω=f ω' |
|
|
| / |
| 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 |
|
|
| / |
| 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 ω)) |
|
|
| / |
| 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 |
|
|
| / |
| 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 ω) |
|
|
| / |
| 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 |
|
|
