| import OAI.Analysis.FourierLLogL.Compress.Variational |
| /-! # Indexed blocks of letters -/ |
|
|
| open Function Filter Set |
| open scoped BigOperators |
| noncomputable section |
| namespace OAI |
|
|
| namespace FourierLLogL.Compress |
| open Law Real |
|
|
| abbrev Letters (n : ℕ) (α : Type) := Fin n → α |
| abbrev WordSample (n : ℕ) (α G : Type) := Sample (Fin n) α G |
|
|
| variable {ι τ κ n m k : ℕ} {α Ω G : Type} |
|
|
| def offset (j l : ℕ) (h : j+l ≤ n) (i : Fin l) : Fin n := ⟨j+i, by have := i.isLt; omega⟩ |
|
|
| def readBlock (X : Ω → Letters n α) (j l : ℕ) (h : j+l ≤ n) := |
| keep X (offset j l h) |
| def prefixB (X : Ω → Letters n α) (l : ℕ) (h : l ≤ n) := readBlock X 0 l (by omega) |
| def readLetter (X : Ω → Letters n α) (j : ℕ) (h : j<n) := fun x => X x ⟨j,h⟩ |
|
|
| lemma offset_injective (j l : ℕ) (h : j+l ≤ n) : Injective (offset j l h) := by |
| intro a b hab |
| have H := congrArg Fin.val hab |
| simp only [offset,Nat.add_left_cancel_iff] at H |
| exact Fin.ext H |
|
|
| lemma prefix_partition (X : Ω → Letters n α) (l k : ℕ) (h : l+k ≤ n) (x y : Ω) : |
| prefixB X (l+k) h x = prefixB X (l+k) h y ↔ |
| prefixB X l (by omega) x = prefixB X l (by omega) y ∧ readBlock X l k h x = readBlock X l k h y := by |
| simp only [funext_iff] |
| constructor |
| · intro H; constructor |
| · intro i |
| exact H (i.castAdd k) |
| · intro ⟨i,hi⟩ |
| have h1 := H (⟨l+i,by omega⟩:Fin (l+k)) |
| simpa only [prefixB,readBlock,keep,offset,zero_add] using h1 |
| · rintro ⟨H,G⟩ ⟨i,hi⟩ |
| by_cases hp : i < l |
| · exact H ⟨i,hp⟩ |
| · have h1 := G (⟨i-l,by omega⟩:Fin k) |
| simpa only [prefixB,readBlock,keep,offset,zero_add, Nat.add_sub_of_le (le_of_not_gt hp)] |
| using h1 |
|
|
| lemma prefix_last_partition (X : Ω → Letters n α) (l : ℕ) (h : l<n) (x y : Ω) : |
| prefixB X (l+1) h x = prefixB X (l+1) h y ↔ |
| readLetter X l h x = readLetter X l h y ∧ |
| prefixB X l (by omega) x = prefixB X l (by omega) y := by |
| rw [prefix_partition X l 1 h] |
| have HH : readBlock X l 1 h x = readBlock X l 1 h y ↔ readLetter X l h x = readLetter X l h y := |
| ⟨fun e => congrFun e (0:Fin 1),fun e => by funext i; rw [Subsingleton.elim i 0]; exact e⟩ |
| rw [HH,and_comm] |
|
|
| lemma prefix_zero (X : Ω → Letters n α) : prefixB X 0 (by omega) = fun _ => Fin.elim0 := |
| funext fun _ => Subsingleton.elim _ _ |
|
|
| lemma prefix_all (X : Ω → Letters n α) : prefixB X n le_rfl = X := by |
| funext a ⟨i,hi⟩ |
| simp only [prefixB,readBlock,keep,offset,zero_add] |
|
|
| lemma block_cut (X : Ω → Letters n α) (j m l : ℕ) (h : j+m ≤ n) (hl : l ≤ m) : |
| readBlock X j l (by omega) = prefixB (readBlock X j m h) l hl := by |
| funext a ⟨i,hi⟩; simp only [prefixB,readBlock,keep,offset,zero_add] |
|
|
| lemma block_in_prefix (X : Ω → Letters n α) (j k l : ℕ) (hk : j+k ≤ l) (hl : l ≤ n) : |
| readBlock X j k (hk.trans hl) = readBlock (prefixB X l hl) j k hk := by |
| funext a ⟨i,hi⟩; simp only [prefixB,readBlock,keep,offset,zero_add] |
|
|
|
|
| def splitIx {n : ℕ} (l m : ℕ) (h : l+m=n) : (Fin m ⊕ Fin l) ≃ Fin n := |
| ((Equiv.sumComm _ _).trans finSumFinEquiv).trans (finCongr h) |
|
|
| lemma splitIx_left (l m : ℕ) (h : l+m=n) (i : Fin m) : |
| splitIx l m h (.inl i) = offset l m h.le i := by |
| apply Fin.ext |
| simp only [splitIx,Equiv.trans_apply,finCongr_apply_coe] |
| rfl |
|
|
| lemma splitIx_right (l m : ℕ) (h : l+m=n) (i : Fin l) : |
| splitIx l m h (.inr i) = offset 0 l (by omega : 0+l≤n) i := by |
| apply Fin.ext |
| simp only [splitIx,Equiv.trans_apply,finCongr_apply_coe,offset,zero_add] |
| rfl |
|
|
|
|
| section reindex |
| variable {I J K : Type} [Fintype I] [DecidableEq I] [Fintype J] [DecidableEq J] |
| [Fintype K] [DecidableEq K] |
|
|
| omit [Fintype I] [Fintype J] [DecidableEq J] [DecidableEq I] in |
| lemma lift_perm (g : J → I) (hg : Injective g) (e : Equiv.Perm J) : |
| ∃ f : Equiv.Perm I, (∀ i, f (g i) = g (e i)) ∧ ∀ x, x ∉ range g → f x = x := by |
| classical |
| let T := (Equiv.sumCongr (Equiv.ofInjective g hg) (Equiv.refl {x : I // x ∉ range g})) |
| |>.trans (Equiv.sumCompl (fun x => x ∈ range g)) |
| let E := Equiv.sumCongr e (Equiv.refl {x : I // x ∉ range g}) |
| have H (x) : ((T.symm.trans E).trans T) (T x) = T (E x) := by simp |
| refine ⟨(T.symm.trans E).trans T,fun i => H (.inl i),fun x hx => ?_⟩ |
| exact H (.inr ⟨x,hx⟩) |
|
|
| variable [Fintype α] [Fintype G] |
|
|
| def subSample (g : J → I) (p : Sample I α G) : Sample J α G := |
| ((fun j => p.1 (g j)), p.2) |
|
|
| lemma exch_subSample {P : Law (Sample I α G)} (hx : exch P) |
| (g : J → I) (hg : Injective g) : exch (P.send (subSample g)) := by |
| intro e |
| obtain ⟨f,hf,hf'⟩ := lift_perm g hg e |
| rw [send_send] |
| have HH := congrArg (fun R : Law (Sample I α G) => R.send (subSample g)) (hx f) |
| rw [send_send] at HH |
| simpa [subSample,appPerm,hf] using HH |
|
|
| lemma exch_subSample_cond {P : Law (Sample I α G)} (hx : exch P) |
| (g : J → I) (hg : Injective g) (u : K → I) (hu : ∀ i, u i ∉ range g) |
| (w : K → α) : |
| let W := keep (fun p : Sample I α G => p.1) u |
| exch ((P.after W w).send (subSample g)) := by |
| intro W e |
| obtain ⟨f,hf,hf'⟩ := lift_perm g hg e |
| have HH := congrArg (fun R : Law (Sample I α G) => R.send fun x => (subSample g x,W x)) (hx f) |
| rw [send_send] at HH |
| have h1 (x : Sample I α G) : subSample g (appPerm f x) = appPerm e (subSample g x) := by |
| simp only [appPerm,subSample,hf] |
| have h2 (x : Sample I α G) : W (appPerm f x) = W x := by |
| funext i |
| simp only [W,keep,appPerm,hf' _ (hu i)] |
| simp_rw [h1,h2] at HH |
| rw [send_send] |
| exact after_send_eq_of_send_pair_eq (X:=fun x => appPerm e (subSample g x)) (W:=W) |
| (Y:=subSample g) (V:=W) HH w |
|
|
| end reindex |
|
|
| section billsplit |
| variable [Fintype α] [Fintype Ω] [Fintype G] [AddCommGroup G] |
| lemma prefix_bill (tag : α → G) (c : G → ℝ) (q : Law α) |
| (P : Law Ω) (X : Ω → Letters n α) (U : Ω → G) (h : covered P X q) |
| (j m : ℕ) (hh : j+m ≤ n) : |
| let W := prefixB X j (by omega) |
| (P.send W).Ex (fun w => bill tag c q (P.after W w) (readBlock X j m hh) U) ≤ |
| bill tag c q P X U := by |
| intro W |
| let l := n-j |
| have he : j+l=n := by dsimp [l]; omega |
| have hhh := bill_split tag c q P X U h (splitIx j l he) |
| let V := readBlock X j l he.le |
| have H1 : |
| (P.send W).Ex (fun w => bill tag c q (P.after W w) V U) ≤ bill tag c q P X U := by |
| simpa only [W,V,prefixB,readBlock,splitIx_left,splitIx_right] using hhh |
| apply le_trans ?_ H1 |
| refine Ex_mono_mem _ (fun w hw => ?_) |
| have hB : readBlock X j m hh = prefixB V m (by omega) := block_cut X j l m he.le (by omega) |
| rw [hB] |
| exact bill_subfamily tag c q _ V U |
| (covered_subfamily (covered_after h _ _ hw) _) _ (offset_injective 0 m _) |
| end billsplit |
|
|
| end FourierLLogL.Compress |
|
|
| end OAI |
|
|
