Download data/lean/OAI/Combinatorics/KServer/Ranks.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 15.5 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/KServer/Ranks.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Combinatorics/KServer/Ranks.lean
-
curl -L -o Ranks.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/KServer/Ranks.lean
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 | |