| import OAI.Analysis.FourierLLogL.Compress.Rent |
| /-! # Data processing for contextual cost -/ |
|
|
| open Set Function Filter |
| open scoped BigOperators |
| noncomputable section |
| namespace OAI |
|
|
| namespace FourierLLogL.Compress |
| open Law Real |
| variable {A B V W G E Ω Ω' : Type} [Fintype A] [Fintype B] |
| [Fintype V] [Fintype W] [Fintype G] [Fintype E] [Nonempty E] |
| [Fintype Ω] [Fintype Ω'] [AddCommGroup G] {n : ℕ} |
| set_option linter.unusedSectionVars false |
|
|
| lemma Hcond_congr {P : Law Ω} {X Y : Ω → A} {W W' : Ω → B} |
| (h : ∀ a, 0 < P a → X a = Y a) (h' : ∀ a, 0 < P a → W a = W' a) : |
| P.Hcond X W = P.Hcond Y W' := by |
| unfold Hcond |
| rw [H_congr_mem P h'] |
| congr 1 |
| refine H_congr_mem P fun a ha => ?_ |
| rw [h a ha,h' a ha] |
|
|
| lemma rent_proj_eq (tag : B → G) (w : B → V) (u : E → G) (c : E → ℝ) |
| (P : Law Ω) (X : Ω → Letters n A) (U : Ω → E) (σ : A → B) : |
| let Y := ctxt σ X |
| rent (tag ∘ σ) (w ∘ σ) u c P X U = |
| rent tag w u c P Y U + |
| ((∑ i, P.Hcond (readP X i) (readP Y i)) - |
| P.Hcond X (fun x => (Y x, ans tag Y (fun a => u (U a)) x))) := by |
| intro Y |
| let Z := ans tag Y (fun a => u (U a)) |
| have h1 (i : Fin n) : |
| P.Hcond (readP X i) ((w ∘ σ) ∘ readP X i) = |
| P.Hcond (readP X i) (readP Y i) + P.Hcond (readP Y i) (w ∘ readP Y i) := by |
| let R := (w ∘ readP Y i) |
| have he := Hcond_reduce P (readP X i) R σ |
| change P.Hcond _ R = _ + P.Hcond (readP Y i) R |
| rw [he]; congr 1 |
| apply Hcond_right_partition |
| simp only [R,Y,ctxt,readP,comp_apply,Prod.mk.injEq] |
| grind |
| have h2 : |
| P.Hcond X (fun x => (Z x,ctxt w Y x)) = |
| P.Hcond X (fun x => (Y x,Z x)) + |
| P.Hcond Y (fun x => (Z x,ctxt w Y x)) := by |
| nth_rw 1 [Hcond_reduce P X _ (fun v i => σ (v i))] |
| congr 1 |
| apply Hcond_right_partition |
| intro a b |
| simp only [Prod.mk.injEq,Y,ctxt,funext_iff] |
| grind |
| unfold rent |
| change _ - P.Hcond X (fun x => (Z x,ctxt w Y x))+_ = _ |
| rw [h2] |
| simp_rw [h1,Finset.sum_add_distrib] |
| dsimp only [Z] |
| ring |
|
|
| lemma rent_projection (tag : B → G) (w : B → V) (u : E → G) (c : E → ℝ) |
| (P : Law Ω) (X : Ω → Letters n A) (U : Ω → E) (σ : A → B) : |
| rent tag w u c P (ctxt σ X) U ≤ rent (tag ∘ σ) (w ∘ σ) u c P X U := by |
| rw [rent_proj_eq] |
| refine le_add_of_nonneg_right (sub_nonneg.mpr ?_) |
| let Y := ctxt σ X |
| let Z (x : Ω) := (Y x,ans tag Y (fun x => u (U x)) x) |
| refine (Hcond_vec_le P X Z).trans (Finset.sum_le_sum fun i _ => ?_) |
| apply Hcond_antitone |
| intro a b h |
| exact congrFun (congrArg Prod.fst h) i |
|
|
| lemma rent_congr_mem (tag : A → G) (w : A → V) (u : E → G) (c : E → ℝ) |
| (P : Law Ω) {X Y : Ω → Letters n A} (U : Ω → E) |
| (h : ∀ x, 0 < P x → X x=Y x) : |
| rent tag w u c P X U = rent tag w u c P Y U := by |
| unfold rent |
| suffices H : ∑ i, P.Hcond (readP X i) (w ∘ readP X i) = |
| ∑ i, P.Hcond (readP Y i) (w ∘ readP Y i) by |
| have hh (x : Ω) (hx : 0 < P x) : |
| (ans tag X (fun x => u (U x)) x, ctxt w X x) = |
| (ans tag Y (fun x => u (U x)) x, ctxt w Y x) := by |
| unfold ans ctxt; rw [h x hx] |
| rw [H] |
| have ht := Hcond_congr h (W:=fun x => (ans tag X (fun x => u (U x)) x, ctxt w X x)) |
| (W':=fun x => (ans tag Y (fun x => u (U x)) x, ctxt w Y x)) hh |
| rw [ht] |
| refine Finset.sum_congr rfl fun i _ => ?_ |
| apply Hcond_congr |
| · exact fun x hx => congrFun (h x hx) _ |
| · exact fun x hx => congrArg w (congrFun (h x hx) _) |
|
|
| lemma opt_proj (tag : B → G) (w : B → V) (u : E → G) (c : E → ℝ) |
| (p : Law A) (σ : A → B) (n : ℕ) : |
| opt n (p.send σ) tag w u c = opt n p (tag ∘ σ) (w ∘ σ) u c := by |
| classical |
| apply le_antisymm |
| · obtain ⟨P,hP,he⟩ := (opt_spec n p (tag ∘ σ) (w ∘ σ) u c).1 |
| rw [← he] |
| let X : WordSample n A E → Letters n A := Prod.fst |
| exact (opt_le_rent tag w u c (p.send σ) P (ctxt σ X) Prod.snd fun i => by |
| rw [← hP i,send_send]; rfl).trans (rent_projection tag w u c P _ _ _) |
| obtain ⟨P,hP,he⟩ := (opt_spec n (p.send σ) tag w u c).1 |
| let X : WordSample n B E → Letters n B := Prod.fst |
| let Q x := pack (fun i : Fin n => p.after σ (X x i)) |
| let R := P.withNext Q |
| let Y : WordSample n B E × (Letters n A) → Letters n A := Prod.snd |
| let B0 (z : WordSample n B E × Letters n A) := X z.1 |
| let error (z : WordSample n B E × Letters n A) := z.1.2 |
| have hr : hasRows p R Y := by |
| intro i |
| apply ext_of_Ex; intro f |
| rw [Ex_send] |
| change R.Ex (fun z => f (z.2 i)) = p.Ex f |
| unfold R |
| rw [Ex_withNext] |
| simp_rw [Q, Ex_pack_proj _ i f] |
| change P.Ex (fun x => (p.after σ (readP X i x)).Ex f) = _ |
| rw [← Ex_send P (readP X i) (fun b => (p.after σ b).Ex f),show P.send (readP X i) = _ from hP i] |
| exact p.after_Ex_sum σ (fun _ => f) |
| have heq (x : WordSample n B E × Letters n A) (hx : 0 < R x) : ctxt σ Y x = B0 x := by |
| rcases x with ⟨a,b⟩ |
| change 0 < P a * Q a b at hx |
| have hpos : 0 < P a ∧ 0 < Q a b := |
| (mul_pos_iff.mp hx).resolve_right (by intro hh; linarith [hh.1,P.nonneg a]) |
| funext i |
| have hi := (pack_pos (fun i => p.after σ (X a i)) b).mp hpos.2 i |
| have hmarg := P.send_pos (readP X i) hpos.1 |
| rw [show P.send (readP X i) = _ from hP i] at hmarg |
| exact ((after_mem hmarg).mp hi).1 |
| have hsrc : rent tag w u c R B0 error = opt n (p.send σ) tag w u c := by |
| have h1 := send_fst_withNext P Q |
| have hi := rent_send tag w u c R X Prod.snd Prod.fst |
| change rent tag w u c (R.send Prod.fst) X Prod.snd = _ at hi |
| rw [h1] at hi |
| exact hi.symm.trans he |
| refine (opt_le_rent (tag ∘ σ) (w ∘ σ) u c p R Y error hr).trans ?_ |
| rw [rent_proj_eq] |
| let B1 := ctxt σ Y |
| let Z (b : WordSample n B E × Letters n A) := |
| (B1 b, ans tag B1 (fun x => u (error x)) b) |
| let Z0 (b : WordSample n B E × Letters n A) := |
| (B0 b, ans tag B0 (fun x => u (error x)) b) |
| change rent tag w u c R B1 error + (_ - R.Hcond Y Z) ≤ _ |
| rw [rent_congr_mem tag w u c R error heq,hsrc] |
| suffices H : ∑ i, R.Hcond (readP Y i) (readP B1 i) ≤ R.Hcond Y Z by linarith |
| have hZ : R.Hcond Y Z = R.Hcond Y Z0 := |
| Hcond_congr (fun _ _ => rfl) fun x hx => by unfold Z Z0 ans; rw [show B1 x = B0 x from heq x hx] |
| rw [hZ] |
| apply le_trans (b:=R.Hcond Y Prod.fst) |
| · have H1 : R.Hcond Y Prod.fst = P.Ex (fun x => (Q x).entropy) := by |
| have H := Hcond_withNext' P Q (fun _ y => y) |
| simpa only [H_self] using H |
| have H2 (i : Fin n) : R.Hcond (readP Y i) (readP B1 i) = p.Hcond (fun a => a) σ := by |
| rw [← hr i] |
| rw [Hcond_send]; rfl |
| have H3 (i : Fin n) : |
| P.Ex (fun x => (p.after σ (X x i)).entropy) = p.Hcond (fun a => a) σ := by |
| rw [Hcond_after] |
| simp_rw [H_self] |
| have hi := hP i |
| rw [← hi,Ex_send]; rfl |
| rw [H1]; simp_rw [Q,entropy_pack,H2,Ex_finset_sum,H3]; exact le_rfl |
| · apply Hcond_antitone |
| rintro ⟨a,b⟩ ⟨a',b'⟩ h |
| cases (show a=a' from h) |
| rfl |
|
|
| lemma opt_refined (tag : B → G) (w : B → V) (w' : A → W) (u : E → G) (c : E → ℝ) |
| (p : Law A) (σ : A → B) (n : ℕ) (g : W → V) (h : w ∘ σ = g ∘ w') : |
| opt n p (tag ∘ σ) w' u c ≤ opt n (p.send σ) tag w u c := by |
| rw [opt_proj tag w] |
| obtain ⟨P,hP,he⟩ := (opt_spec n p (tag ∘ σ) (w ∘ σ) u c).1 |
| exact (opt_le_rent _ _ _ _ p P _ _ hP).trans |
| ((rent_antitone _ w' (w ∘ σ) u c g h P Prod.fst Prod.snd).trans he.le) |
|
|
| end FourierLLogL.Compress |
|
|
| end OAI |
|
|
