| import OAI.Dynamics.StandardMap.EntropyEndpoint |
| import OAI.Dynamics.StandardMap.Coding.ReconstructionEntropy |
|
|
| namespace OAI |
|
|
| section |
| namespace HyperbolicCoding.MatrixCoupling |
| open scoped BigOperators |
| variable {A B : Type*} [Fintype A] [Fintype B] [DecidableEq A] [DecidableEq B] |
| {p : A → ℝ} {q : B → ℝ} |
|
|
| noncomputable def extendRows (S : Finset A) (g : S → B → ℝ) (a : A) (b : B) : ℝ := |
| if h : a∈S then g ⟨a,h⟩ b else 0 |
|
|
| omit [Fintype B] [DecidableEq B] in |
| lemma sum_extendRows (S : Finset A) (g : S → B → ℝ) (b : B) : |
| (∑ a,extendRows S g a b)=∑ a : S,g a b := by |
| exact (Finset.sum_attach_eq_sum_dite S (fun a => g a b)).symm |
| |
| omit [Fintype A] [Fintype B] [DecidableEq B] in |
| lemma extendRows_nonneg (S : Finset A) (g : S → B → ℝ) (hg : ∀ a b,0≤g a b) (a b) : |
| 0≤extendRows S g a b := by |
| unfold extendRows |
| split |
| · exact hg _ _ |
| · rfl |
|
|
| omit [Fintype A] [DecidableEq B] in |
| lemma extendRows_sum (S : Finset A) (g : S → B → ℝ) (a : A) : |
| (∑ b,extendRows S g a b)=if h : a∈S then ∑ b,g ⟨a,h⟩ b else 0 := by |
| unfold extendRows |
| split < |
|
|
| omit [DecidableEq B] in |
| lemma sum_extendRows_mul (S : Finset A) (g : S → B → ℝ) (c : A → B → ℝ) : |
| (∑ a,∑ b,extendRows S g a b*c a b)=∑ a : S,∑ b,g a b*c a b := by |
| have he (a : A) : (∑ b,extendRows S g a b*c a b)= |
| if h : a∈S then ∑ b,g ⟨a,h⟩ b*c a b else 0 := by |
| unfold extendRows |
| split < |
| simp_rw [he] |
| exact (Finset.sum_attach_eq_sum_dite S (fun a => ∑ b,g a b*c a b)).symm |
| |
| noncomputable def replaceSub (R : MatrixCoupling p q) (S : Finset A) |
| {u : S → ℝ} {v : B → ℝ} (G H : MatrixCoupling u v) |
| (hle : ∀ a b,G.weight a b≤R.weight a b) : MatrixCoupling p q where |
| weight a b := R.weight a b-extendRows S G.weight a b+extendRows S H.weight a b |
| nonneg a b := by |
| have hg : extendRows S G.weight a b≤R.weight a b := by |
| unfold extendRows |
| split |
| · exact hle _ _ |
| · exact R.nonneg _ _ |
| exact add_nonneg (sub_nonneg.mpr hg) (extendRows_nonneg S _ H.nonneg a b) |
| row a := by |
| simp only [Finset.sum_add_distrib,Finset.sum_sub_distrib,R.row,extendRows_sum,G.row,H.row] |
| ring |
| col b := by |
| simp only [Finset.sum_add_distrib,Finset.sum_sub_distrib,R.col,sum_extendRows,G.col,H.col] |
| ring |
|
|
| omit [DecidableEq B] in |
| lemma replaceSub_cost (R : MatrixCoupling p q) (S : Finset A) |
| {u : S → ℝ} {v : B → ℝ} (G H : MatrixCoupling u v) |
| (hle : ∀ a b,G.weight a b≤R.weight a b) (c : A → B → ℝ) : |
| (R.replaceSub S G H hle).cost c=R.cost c-G.cost (fun a b => c a b)+H.cost (fun a b => c a b) := by |
| unfold cost replaceSub |
| simp only [add_mul,sub_mul,Finset.sum_add_distrib,Finset.sum_sub_distrib,sum_extendRows_mul] |
| |
| omit [DecidableEq B] in |
| lemma replaceSub_bounded_cost (R : MatrixCoupling p q) (hp : ∑ a,p a=1) (S : Finset A) |
| {u : S → ℝ} {v : B → ℝ} (G H : MatrixCoupling u v) |
| (hle : ∀ a b,G.weight a b≤R.weight a b) (c : A → B → ℝ) (hc1 : ∀ a b,c a b≤1) : |
| (R.replaceSub S G H hle).cost c≤1-(∑ a,u a)+H.cost (fun a b => c a b) := by |
| have hres (a : A) (b : B) : 0≤R.weight a b-extendRows S G.weight a b := by |
| apply sub_nonneg.mpr |
| unfold extendRows |
| split |
| · exact hle _ _ |
| · exact R.nonneg _ _ |
| have hb : (∑ a,∑ b,(R.weight a b-extendRows S G.weight a b)*c a b)≤1-(∑ a,u a) := by |
| calc |
| _≤∑ a,∑ b,(R.weight a b-extendRows S G.weight a b) := by |
| apply Finset.sum_le_sum |
| apply Finset.sum_le_sum |
| exact mul_le_of_le_one_right (hres a b) (hc1 a b) |
| _=_ := by |
| simp only [Finset.sum_sub_distrib,R.row,hp] |
| congr 1 |
| rw [Finset.sum_comm] |
| simp only [sum_extendRows] |
| rw [Finset.sum_comm] |
| simp only [G.row] |
| rw [replaceSub_cost] |
| have he : R.cost c-G.cost (fun a b => c a b)= |
| ∑ a,∑ b,(R.weight a b-extendRows S G.weight a b)*c a b := by |
| simp only [sub_mul,Finset.sum_sub_distrib,sum_extendRows_mul,cost] |
| rw [he] |
| linarith |
|
|
| noncomputable def divide (R : MatrixCoupling p q) {t : ℝ} (ht : 0<t) : |
| MatrixCoupling (fun a => p a/t) (fun b => q b/t) where |
| weight a b := R.weight a b/t |
| nonneg a b := div_nonneg (R.nonneg a b) ht.le |
| row a := by rw [←Finset.sum_div,R.row] |
| col b := by rw [←Finset.sum_div,R.col] |
|
|
| omit [DecidableEq A] [DecidableEq B] in |
| lemma divide_cost (R : MatrixCoupling p q) {t : ℝ} (ht : 0<t) (c : A → B → ℝ) : |
| (R.divide ht).cost c=R.cost c/t := by |
| simp only [cost,divide,div_mul_eq_mul_div,←Finset.sum_div] |
| |
| theorem decodable_coupling_total [Nonempty A] {ε : ℝ} (hε : 0<ε) |
| (R : MatrixCoupling p q) (t : ℝ) (ht : 0<t) (hsum : (∑ b,q b)=t) |
| (c : A → B → ℝ) (hc0 : ∀ a b,0≤c a b) (hc1 : ∀ a b,c a b≤1) |
| (M : ℝ) (hM : ∀ b,q b≤M) (hsmall : (Fintype.card A : ℝ)*M≤t*decodingThreshold ε) : |
| ∃ (D : B → A) (H : MatrixCoupling p q), |
| H.cost (fun a b => symbolCost a (D b))<t*ε ∧ H.cost c<R.cost c+t*ε := by |
| let V := R.divide ht |
| have hVs : (∑ b,q b/t)=1 := by rw [←Finset.sum_div,hsum,div_self ht.ne'] |
| have hVm : ∀ b,q b/t≤M/t := fun b => div_le_div_of_nonneg_right (hM b) ht.le |
| have hsize : (Fintype.card A : ℝ)*(M/t)≤decodingThreshold ε := by |
| rw [←mul_div_assoc] |
| exact (div_le_iff₀ ht).mpr (by simpa only [mul_comm] using hsmall) |
| obtain ⟨D,H,hD,hH⟩ := decodable_coupling_tolerance hε V hVs c hc0 hc1 (M/t) hVm hsize |
| let W : MatrixCoupling p q := { |
| weight a b := t*H.weight a b |
| nonneg a b := mul_nonneg ht.le (H.nonneg a b) |
| row a := by rw [←Finset.mul_sum,H.row]; exact mul_div_cancel₀ _ ht.ne' |
| col b := by rw [←Finset.mul_sum,H.col]; exact mul_div_cancel₀ _ ht.ne' } |
| have hwcost (d : A → B → ℝ) : W.cost d=t*H.cost d := by |
| unfold cost |
| simp only [W,mul_assoc,←Finset.mul_sum] |
| refine ⟨D,W,?_,?_⟩ |
| · rw [hwcost] |
| exact mul_lt_mul_of_pos_left hD ht |
| · rw [hwcost] |
| have h := mul_lt_mul_of_pos_left hH ht |
| rw [show V.cost c=R.cost c/t from R.divide_cost ht c] at h |
| rw [mul_add,mul_div_cancel₀ _ ht.ne'] at h |
| exact h |
|
|
| theorem decodable_subtransport {ε : ℝ} (hε : 0<ε) |
| (R : MatrixCoupling p q) (hp : ∑ a,p a=1) (S : Finset A) (hS : S.Nonempty) |
| {u : S → ℝ} {v : B → ℝ} (G : MatrixCoupling u v) |
| (hle : ∀ a b,G.weight a b≤R.weight a b) (t : ℝ) (ht : 0<t) (hsum : (∑ a,u a)=t) |
| (c : A → B → ℝ) (hc0 : ∀ a b,0≤c a b) (hc1 : ∀ a b,c a b≤1) |
| (M : ℝ) (hM : ∀ b,v b≤M) (hsmall : (S.card : ℝ)*M≤t*decodingThreshold ε) : |
| ∃ (D : B → A) (H : MatrixCoupling p q), |
| H.cost (fun a b => symbolCost a (D b))<1-t+t*ε ∧ H.cost c<R.cost c+t*ε := by |
| obtain ⟨a,ha⟩ := hS |
| have : Nonempty S := ⟨⟨a,ha⟩⟩ |
| have hsumv : (∑ b,v b)=t := by |
| simp_rw [←G.col] |
| rw [Finset.sum_comm] |
| simp only [G.row,hsum] |
| obtain ⟨D,H,hD,hH⟩ := decodable_coupling_total hε G t ht hsumv |
| (fun a b => c a b) (fun a b => hc0 a b) (fun a b => hc1 a b) M hM (by simpa using hsmall) |
| let D' : B → A := fun b => (D b).val |
| let H' := R.replaceSub S G H hle |
| have he (a : S) (b : B) : symbolCost (a : A) (D' b)=symbolCost a (D b) := by |
| simp only [symbolCost,D',Subtype.val_inj] |
| split_ifs < |
| have hb := R.replaceSub_bounded_cost hp S G H hle (fun a b => symbolCost a (D' b)) |
| (fun a b => symbolCost_le_one a (D' b)) |
| simp_rw [he] at hb |
| rw [hsum] at hb |
| refine ⟨D',H',by dsimp only [H']; linarith,?_⟩ |
| dsimp only [H'] |
| rw [replaceSub_cost] |
| linarith |
|
|
| noncomputable def rectangle (R : MatrixCoupling p q) (S : Finset A) (T : Finset B) : |
| MatrixCoupling (fun a : S => ∑ b,if b∈T then R.weight a b else 0) |
| (fun b => ∑ a : S,if b∈T then R.weight a b else 0) where |
| weight a b := if b∈T then R.weight a b else 0 |
| nonneg a b := by split < |
| row _ := rfl |
| col _ := rfl |
|
|
| omit [DecidableEq A] in |
| lemma rectangle_weight_le (R : MatrixCoupling p q) (S : Finset A) (T : Finset B) (a : S) (b : B) : |
| (R.rectangle S T).weight a b≤R.weight a b := by |
| dsimp [rectangle] |
| split |
| · exact le_rfl |
| · exact R.nonneg _ _ |
|
|
| omit [DecidableEq B] in |
| lemma sum_subtype_weight_le (R : MatrixCoupling p q) (S : Finset A) (b : B) : |
| (∑ a : S,R.weight a b)≤q b := by |
| rw [←sum_extendRows S (fun a b => R.weight a b) b,←R.col b] |
| apply Finset.sum_le_sum |
| intro a _ |
| unfold extendRows |
| split |
| · exact le_rfl |
| · exact R.nonneg _ _ |
|
|
| lemma rectangle_right_bound (R : MatrixCoupling p q) (S : Finset A) (T : Finset B) |
| {M : ℝ} (hM0 : 0≤M) (hM : ∀ b∈T,q b≤M) (b : B) : |
| (∑ a : S,if b∈T then R.weight a b else 0)≤M := by |
| by_cases hb : b∈T |
| · simpa only [ite_eq_left hb] using (R.sum_subtype_weight_le S b).trans (hM b hb) |
| · simpa only [ite_eq_right hb,Finset.sum_const_zero] using hM0 |
|
|
| omit [DecidableEq A] in |
| lemma rectangle_mass (R : MatrixCoupling p q) (S : Finset A) (T : Finset B) : |
| (∑ a : S,∑ b,if b∈T then R.weight a b else 0)=∑ a∈S,∑ b∈T,R.weight a b := by |
| simp only [Finset.sum_ite_mem,Finset.univ_inter] |
| exact (Finset.sum_subtype S (fun _ => Iff.rfl) (fun a : A => ∑ b∈T,R.weight a b)).symm |
| |
| omit [DecidableEq A] in |
| lemma rectangle_mass_ge (R : MatrixCoupling p q) (hp : ∑ a,p a=1) (S : Finset A) (T : Finset B) : |
| (∑ a∈S,p a)+(∑ b∈T,q b)-1≤∑ a : S,∑ b,if b∈T then R.weight a b else 0 := by |
| rw [rectangle_mass] |
| have hsplit : (∑ a∈S,p a)=(∑ a∈S,∑ b∈T,R.weight a b)+(∑ a∈S,∑ b∈Tᶜ,R.weight a b) := by |
| rw [←Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl |
| intro a _ |
| rw [Finset.sum_add_sum_compl,R.row] |
| have hbad : (∑ a∈S,∑ b∈Tᶜ,R.weight a b)≤∑ b∈Tᶜ,q b := by |
| rw [Finset.sum_comm] |
| apply Finset.sum_le_sum |
| intro b _ |
| rw [←R.col b] |
| exact Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ S) (fun a _ _ => R.nonneg a b) |
| have htotal : (∑ b∈T,q b)+(∑ b∈Tᶜ,q b)=1 := by |
| rw [Finset.sum_add_sum_compl] |
| simp_rw [←R.col] |
| rw [Finset.sum_comm] |
| simp only [R.row,hp] |
| linarith |
|
|
| theorem decodable_typical_coupling {ε θ : ℝ} (hε : 0 < ε) |
| (_hθ : 0 ≤ θ) (hθsmall : θ < 1/2) |
| (R : MatrixCoupling p q) (hp : ∑ a,p a=1) |
| (S : Finset A) (T : Finset B) |
| (hS : 1-θ ≤ ∑ a∈S,p a) (hT : 1-θ ≤ ∑ b∈T,q b) |
| (M : ℝ) (hM0 : 0 ≤ M) (hM : ∀ b∈T,q b ≤ M) |
| (hsize : (S.card : ℝ)*M ≤ (1-2*θ)*decodingThreshold ε) |
| (c : A → B → ℝ) (hc0 : ∀ a b,0 ≤ c a b) (hc1 : ∀ a b,c a b ≤ 1) : |
| ∃ (D : B → A) (H : MatrixCoupling p q), |
| H.cost (fun a b => symbolCost a (D b)) < 2*θ+ε ∧ H.cost c < R.cost c+ε := by |
| let G := R.rectangle S T |
| let t : ℝ := ∑ a : S,∑ b,if b∈T then R.weight a b else 0 |
| have htlo : 1-2*θ ≤ t := by |
| have h := R.rectangle_mass_ge hp S T |
| dsimp only [t] |
| linarith |
| have ht : 0 < t := by linarith |
| have hthi : t ≤ 1 := by |
| dsimp only [t] |
| rw [R.rectangle_mass] |
| calc |
| _ ≤ ∑ a∈S,∑ b,R.weight a b := by |
| apply Finset.sum_le_sum |
| intro a _ |
| exact Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ T) |
| (fun b _ _ => R.nonneg a b) |
| _ = ∑ a∈S,p a := by simp only [R.row] |
| _ ≤ ∑ a,p a := Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ S) |
| (fun a _ _ => R.left_nonneg a) |
| _ = 1 := hp |
| have hSne : S.Nonempty := by |
| by_contra h |
| have he := Finset.not_nonempty_iff_eq_empty.mp h |
| simp only [he,Finset.sum_empty] at hS |
| linarith |
| have hthreshold : 0 ≤ decodingThreshold ε := (decodingThreshold_pos hε).le |
| have hsize' : (S.card : ℝ)*M ≤ t*decodingThreshold ε := |
| hsize.trans (mul_le_mul_of_nonneg_right htlo hthreshold) |
| obtain ⟨D,H,hD,hH⟩ := decodable_subtransport hε R hp S hSne G |
| (R.rectangle_weight_le S T) t ht rfl c hc0 hc1 M |
| (R.rectangle_right_bound S T hM0 hM) hsize' |
| have hte : t*ε ≤ ε := mul_le_of_le_one_left hε.le hthi |
| exact ⟨D,H,by linarith,by linarith⟩ |
|
|
| end HyperbolicCoding.MatrixCoupling |
|
|
| end |
| section |
| namespace HyperbolicCoding |
| open scoped BigOperators |
| variable {A B : Type*} [Fintype A] [Fintype B] [DecidableEq B] |
| |
| noncomputable def pushWeight (q : A → ℝ) (f : A → B) (b : B) : ℝ := |
| ∑ a,if f a=b then q a else 0 |
|
|
| lemma pushWeight_sum (q : A → ℝ) (f : A → B) : |
| (∑ b,pushWeight q f b)=∑ a,q a := by |
| unfold pushWeight |
| rw [Finset.sum_comm] |
| simp |
|
|
| omit [Fintype B] in |
| lemma pushWeight_nonneg (q : A → ℝ) (hq : ∀ a,0 ≤ q a) (f : A → B) (b : B) : |
| 0 ≤ pushWeight q f b := by |
| apply Finset.sum_nonneg |
| intro a _ |
| split < |
|
|
| omit [Fintype B] in |
| lemma pushWeight_add (q r : A → ℝ) (f : A → B) (b : B) : |
| pushWeight (fun a => q a+r a) f b=pushWeight q f b+pushWeight r f b := by |
| simp only [pushWeight,←Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl |
| intro a _ |
| split < |
|
|
| omit [Fintype B] in |
| lemma pushWeight_bound (q : A → ℝ) (f : A → B) {M K : ℝ} (hM : ∀ a,q a ≤ M) |
| (hM0 : 0 ≤ M) (hf : ∀ b,(Fintype.card {a // f a=b} : ℝ) ≤ K) (b : B) : |
| pushWeight q f b ≤ K*M := by |
| calc |
| _ ≤ ∑ a : A,if f a=b then M else 0 := by |
| apply Finset.sum_le_sum |
| intro a _ |
| split < |
| _ = (Fintype.card {a // f a=b} : ℝ)*M := by |
| simp only [Finset.sum_ite,Finset.sum_const,nsmul_eq_mul,mul_zero,add_zero] |
| congr 1 |
| rw [Fintype.card_subtype] |
| _ ≤ K*M := mul_le_mul_of_nonneg_right (hf b) hM0 |
|
|
| theorem typical_pushforward [DecidableEq A] |
| (q : A → ℝ) (hq : ∀ a,0 ≤ q a) (hs : ∑ a,q a=1) |
| (f : A → B) (S : Finset A) {M K ε : ℝ} (hM0 : 0 ≤ M) (_hK0 : 0 ≤ K) |
| (hM : ∀ a∈S,q a ≤ M) (hf : ∀ b,(Fintype.card {a // f a=b} : ℝ) ≤ K) |
| (hbad : (∑ a : A,if a∉S then q a else 0) ≤ ε) : |
| ∃ T : Finset B, |
| (∀ b∈T,pushWeight q f b ≤ 2*K*M) ∧ |
| 1-2*ε ≤ ∑ b∈T,pushWeight q f b := by |
| let u : A → ℝ := fun a => if a∈S then q a else 0 |
| let v : A → ℝ := fun a => if a∉S then q a else 0 |
| have hu0 : ∀ a,0 ≤ u a := by intro a |
| have hv0 : ∀ a,0 ≤ v a := by intro a |
| have huM : ∀ a,u a ≤ M := by |
| intro a |
| · exact hM a ‹_› |
| · exact hM0 |
| have heq (a : A) : q a=u a+v a := by |
| dsimp [u,v] |
| by_cases ha : a∈S < |
| have hpush (b : B) : pushWeight q f b=pushWeight u f b+pushWeight v f b := by |
| conv_lhs => rw [show q=(fun a => u a+v a) from funext heq] |
| exact pushWeight_add u v f b |
| have hub (b : B) : pushWeight u f b ≤ K*M := pushWeight_bound u f huM hM0 hf b |
| let T := Finset.univ.filter (fun b => pushWeight v f b ≤ K*M) |
| have hmem (b : B) : b∈T ↔ pushWeight v f b ≤ K*M := by simp [T] |
| refine ⟨T,?_,?_⟩ |
| · intro b hb |
| rw [hmem] at hb |
| rw [hpush] |
| linarith [hub b] |
| · have hout : (∑ b∈Tᶜ,pushWeight q f b) ≤ 2*ε := by |
| calc |
| _ ≤ ∑ b∈Tᶜ,2*pushWeight v f b := by |
| apply Finset.sum_le_sum |
| intro b hb |
| have hnot : K*M < pushWeight v f b := by |
| have := Finset.mem_compl.mp hb |
| rw [hmem] at this |
| exact lt_of_not_ge this |
| rw [hpush] |
| linarith [hub b] |
| _ = 2*(∑ b∈Tᶜ,pushWeight v f b) := by rw [Finset.mul_sum] |
| _ ≤ 2*(∑ b,pushWeight v f b) := by |
| apply mul_le_mul_of_nonneg_left _ (by norm_num) |
| exact Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ _) |
| (fun b _ _ => pushWeight_nonneg v hv0 f b) |
| _ ≤ 2*ε := by rw [pushWeight_sum] |
| have hsplit : (∑ b∈T,pushWeight q f b)+(∑ b∈Tᶜ,pushWeight q f b)=1 := by |
| rw [Finset.sum_add_sum_compl,pushWeight_sum,hs] |
| linarith |
|
|
| end HyperbolicCoding |
|
|
| end |
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set StandardMapEntropy.Entropy |
| open scoped BigOperators ENNReal |
| variable {A B C : Type*} [Fintype A] [Fintype B] [Fintype C] |
|
|
| namespace MatrixCoupling |
| variable {p : A → ℝ} {q : B → ℝ} |
| noncomputable def pushRight [DecidableEq C] (R : MatrixCoupling p q) (f : B → C) : |
| MatrixCoupling p (pushWeight q f) where |
| weight a c := pushWeight (R.weight a) f c |
| nonneg a c := pushWeight_nonneg _ (R.nonneg a) _ c |
| row a := by rw [pushWeight_sum,R.row] |
| col c := by |
| simp only [pushWeight] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro b _ |
| split |
| · exact R.col b |
| · simp |
|
|
| lemma pushRight_cost [DecidableEq C] (R : MatrixCoupling p q) (f : B → C) (c : A → C → ℝ) : |
| (R.pushRight f).cost c=R.cost (fun a b => c a (f b)) := by |
| simp only [cost,pushRight,pushWeight,Finset.sum_mul] |
| apply Finset.sum_congr rfl |
| intro a _ |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro b _ |
| simp only [ite_mul,zero_mul,Finset.sum_ite_eq,Finset.mem_univ,ite_true] |
|
|
| end MatrixCoupling |
|
|
| omit [Fintype A] in |
| lemma mass_mem_finset {X : Type*} [MeasurableSpace X] [MeasurableSpace A] |
| [MeasurableSingletonClass A] (μ : Measure X) [IsFiniteMeasure μ] |
| (p : X → A) (hp : Measurable p) (S : Finset A) : |
| (∑ a∈S,mass μ p a)=μ.real {x | p x∈S} := by |
| have hm (a : A) : mass μ p a=(μ.map p).real {a} := |
| (map_measureReal_apply hp (measurableSet_singleton a)).symm |
| simp_rw [hm] |
| rw [sum_measureReal_singleton,map_measureReal_apply hp S.measurableSet] |
| rfl |
| |
| omit [Fintype A] in |
| lemma mass_codebook_lower {X : Type*} [MeasurableSpace X] [MeasurableSpace A] |
| [MeasurableSingletonClass A] (μ : Measure X) [IsProbabilityMeasure μ] |
| (p : X → A) (hp : Measurable p) (S : Finset A) {ε : ℝ} |
| (hbad : μ.real {x | p x∉S}<ε) : 1-ε < ∑ a∈S,mass μ p a := by |
| rw [mass_mem_finset μ p hp S] |
| have hh := measureReal_add_measureReal_compl (μ:=μ) (hp S.measurableSet) |
| have he : (p ⁻¹' (S : Set A))ᶜ={x | p x∉S} := rfl |
| rw [he] at hh |
| simp only [Measure.real,measure_univ,ENNReal.toReal_one] at hh |
| change μ.real {x | p x∈S}+μ.real {x | p x∉S}=1 at hh |
| linarith |
| |
| end HyperbolicCoding |
| |
| end |
| section |
| namespace HyperbolicCoding.MatrixCoupling |
| open scoped BigOperators |
| variable {A B : Type*} [Fintype A] [Fintype B] [DecidableEq A] [DecidableEq B] |
| {p : A → ℝ} {q : B → ℝ} |
| |
| theorem decodable_after_sanitizing {ε θ : ℝ} (hε : 0 < ε) (hθ : 0 ≤ θ) |
| (hθsmall : θ < 1/4) (R : MatrixCoupling p q) (hp : ∑ a,p a=1) |
| (S : Finset A) (T : Finset B) (hS : 1-θ ≤ ∑ a∈S,p a) |
| (hbad : (∑ b : B,if b∉T then q b else 0) ≤ θ) |
| (f : B → B) (M K : ℝ) (hM0 : 0 ≤ M) (hK0 : 0 ≤ K) |
| (hM : ∀ b∈T,q b ≤ M) (hf : ∀ b,(Fintype.card {v // f v=b} : ℝ) ≤ K) |
| (hsize : (S.card : ℝ)*(2*K*M) ≤ (1-4*θ)*decodingThreshold ε) |
| (c : A → B → ℝ) (hc0 : ∀ a b,0 ≤ c a b) (hc1 : ∀ a b,c a b ≤ 1) |
| (κ : ℝ) (hcmap : ∀ a b,c a (f b) ≤ c a b+κ) : |
| ∃ (D : B → A) (H : MatrixCoupling p (pushWeight q f)), |
| H.cost (fun a b => symbolCost a (D b)) < 4*θ+ε ∧ |
| H.cost c < R.cost c+κ+ε := by |
| have hq : (∑ b,q b)=1 := by |
| simp_rw [←R.col] |
| rw [Finset.sum_comm] |
| simp only [R.row,hp] |
| obtain ⟨V,hVm,hV⟩ := typical_pushforward q R.right_nonneg hq f T hM0 hK0 hM hf hbad |
| have hs2 : 1-2*θ ≤ ∑ a∈S,p a := by linarith |
| have hsize' : (S.card : ℝ)*(2*K*M) ≤ (1-2*(2*θ))*decodingThreshold ε := by |
| convert hsize using 1 |
| ring |
| obtain ⟨D,H,hD,hH⟩ := decodable_typical_coupling hε (show 0 ≤ 2*θ by positivity) |
| (show 2*θ < 1/2 by linarith) (R.pushRight f) hp S V hs2 hV (2*K*M) |
| (by positivity) hVm hsize' c hc0 hc1 |
| have hcost : (R.pushRight f).cost c ≤ R.cost c+κ := by |
| rw [pushRight_cost] |
| have h := R.cost_mono (fun a b => c a (f b)) (fun a b => 1*c a b+κ) |
| (fun a b => by simpa only [one_mul] using hcmap a b) |
| rw [R.cost_affine hp 1 κ c,one_mul] at h |
| exact h |
| refine ⟨D,H,?_,?_⟩ <;> linarith |
| |
| theorem marked_word_decodable_coupling {C : Type*} [Fintype C] [DecidableEq C] |
| {n r : ℕ} {u : C → ℝ} (β : A → ℝ) (_hβ : ∀ a,0 ≤ β a) (_hβsum : ∑ a,β a=1) |
| {ε θ L : ℝ} (hε : 0 < ε) (hθ : 0 ≤ θ) (hθsmall : θ < 1/4) |
| (R : MatrixCoupling u (productWordWeight β n)) (hu : ∑ a,u a=1) |
| (S : Finset C) (T : Finset (Fin n → A)) (hS : 1-θ ≤ ∑ a∈S,u a) |
| (hT : ∀ w∈T,productWordWeight β n w ≤ Real.exp (-L)) |
| (hbad : (∑ w : Fin n → A,if w∉T then productWordWeight β n w else 0) ≤ θ) |
| (zero one : A) |
| (hsize : (S.card : ℝ)*(2*(Fintype.card A : ℝ)^(Marker.reserved n r).card*Real.exp (-L)) ≤ |
| (1-4*θ)*decodingThreshold ε) |
| (c : C → (Fin n → A) → ℝ) (hc0 : ∀ a b,0 ≤ c a b) (hc1 : ∀ a b,c a b ≤ 1) |
| (κ : ℝ) (hcmap : ∀ a b,c a (Marker.markWord r zero one b) ≤ c a b+κ) : |
| ∃ (D : (Fin n → A) → C) |
| (H : MatrixCoupling u (pushWeight (productWordWeight β n) (Marker.markWord r zero one))), |
| H.cost (fun a b => symbolCost a (D b)) < 4*θ+ε ∧ |
| H.cost c < R.cost c+κ+ε := by |
| apply decodable_after_sanitizing hε hθ hθsmall R hu S T hS hbad |
| (Marker.markWord r zero one) (Real.exp (-L)) ((Fintype.card A : ℝ)^(Marker.reserved n r).card) |
| (Real.exp_pos _).le (by positivity) hT _ hsize c hc0 hc1 κ hcmap |
| intro b |
| exact_mod_cast Marker.markWord_fiber_card (r:=r) zero one b |
| |
| end HyperbolicCoding.MatrixCoupling |
| |
| end |
| |
| end OAI |
| |
