| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Probability.Tv |
| import OAI.Combinatorics.MatchingCount.Sampling.Component |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.WeightedOptions |
|
|
| open Finset |
|
|
| variable {Ω : Type*} [Fintype Ω] [DecidableEq Ω] |
|
|
| def metropolisChoice (c : WeightedOptions Ω) (w : Ω → ℚ) (hw : ∀ a, 0 < w a) (a : Ω) : |
| WeightedOptions Ω := c.accept a (fun b => min 1 (w b / w a)) |
| (fun b => le_min zero_le_one (div_nonneg (hw b).le (hw a).le)) |
| (fun _ => min_le_left _ _) |
|
|
| lemma real_law_sum (c : WeightedOptions Ω) : ∑ b, (c.law b : ℝ)=1 := by |
| exact_mod_cast c.law_sum |
|
|
| lemma row_eq_of_off (f g : Ω → ℝ) (hf : ∑ x, f x=1) (hg : ∑ x, g x=1) |
| (a : Ω) (h : ∀ b, a≠b → f b=g b) : f=g := by |
| funext b |
| by_cases hab : a=b |
| · subst b |
| have he : ∑ b ∈ univ.erase a, f b = ∑ b ∈ univ.erase a, g b := by |
| apply sum_congr rfl |
| intro b hb |
| exact h b (ne_of_mem_erase hb).symm |
| rw [←sum_erase_add _ _ (mem_univ a)] at hf hg |
| linarith |
| · exact h b hab |
|
|
| lemma min_ratio (x y : ℝ) (hx : 0 < x) : min (1:ℝ) (y/x) = min x y / x := by |
| by_cases h : x≤y |
| · rw [min_eq_left ((le_div_iff₀ hx).mpr (by simpa using h)),min_eq_left h,div_self hx.ne'] |
| · rw [min_eq_right ((div_le_one hx).mpr (le_of_not_ge h)),min_eq_right (le_of_not_ge h)] |
|
|
| theorem metropolisChoice_law (P : Replica.SymmetricProposal Ω) (c : Ω → WeightedOptions Ω) |
| (hc : ∀ a b, ((c a).law b : ℝ)=P.q a b) |
| (w : Ω → ℚ) (hw : ∀ a, 0 < w a) (a b : Ω) : |
| (((c a).metropolisChoice w hw a).law b : ℝ) = |
| Replica.metropolis P (fun x => (w x:ℝ)) a b := by |
| have hpos : ∀ x, (0:ℝ)<w x := fun x => by exact_mod_cast hw x |
| have hsum := real_law_sum ((c a).metropolisChoice w hw a) |
| have he := row_eq_of_off _ _ hsum (Replica.metropolis_row P _ hpos a) a (fun b hab => ?_) |
| · exact congrFun he b |
| rw [metropolisChoice,accept_law,ite_eq_right hab,add_zero] |
| push_cast |
| rw [hc,min_ratio _ _ (hpos a)] |
| simp only [Replica.metropolis,Replica.metropolisCapacity,ite_eq_right hab,Replica.offCapacity] |
| ring |
|
|
| omit [Fintype Ω] [DecidableEq Ω] in |
| lemma metropolisChoice_size (c : WeightedOptions Ω) (w : Ω → ℚ) (hw : ∀ a, 0 < w a) (a : Ω) : |
| (c.metropolisChoice w hw a).size = 2*c.size := by |
| simp only [metropolisChoice,accept] |
| omega |
|
|
| end MatchingFPRAS.WeightedOptions |
|
|
| namespace MatchingFPRAS.Variation |
|
|
| open Finset |
| open scoped Classical |
|
|
| variable {A B C : Type*} [Fintype A] [Fintype B] [Fintype C] |
|
|
| noncomputable def uniform (A : Type*) [Fintype A] (_ : A) : ℝ := 1/Fintype.card A |
|
|
| lemma uniform_nonneg (a : A) : 0≤uniform A a := by unfold uniform; positivity |
|
|
| lemma uniform_sum [Nonempty A] : ∑ a : A,uniform A a=1 := by |
| simp only [uniform,sum_const,nsmul_eq_mul] |
| exact mul_one_div_cancel (by exact_mod_cast Fintype.card_ne_zero : (Fintype.card A:ℝ)≠0) |
|
|
| noncomputable def imageLaw (f : A → B) : B → ℝ := push (uniform A) f |
|
|
| omit [Fintype B] in |
| lemma imageLaw_nonneg (f : A → B) (b : B) : 0 ≤ imageLaw f b := push_nonneg _ uniform_nonneg _ _ |
|
|
| lemma imageLaw_sum [Nonempty A] (f : A → B) : ∑ b,imageLaw f b=1 := push_sum _ uniform_sum _ |
|
|
| omit [Fintype B] in |
| lemma imageLaw_eq_count (f : A → B) (b : B) : |
| imageLaw f b=((univ.filter (fun a=>f a=b)).card:ℝ)/Fintype.card A := by |
| simp only [imageLaw,push,uniform] |
| rw [show (∑ x,if f x=b then (1:ℝ)/Fintype.card A else 0)= |
| (∑ x,if f x=b then (1:ℝ) else 0)/Fintype.card A by |
| simp only [sum_div,ite_div,zero_div]] |
| simp |
|
|
| lemma imageLaw_equiv (e : A ≃ B) : imageLaw e=uniform B := by |
| funext b |
| unfold imageLaw push uniform |
| rw [e.sum_comp (fun x=>if x=b then (1:ℝ)/Fintype.card A else 0)] |
| simp [Fintype.card_congr e] |
|
|
| omit [Fintype C] in |
| lemma imageLaw_comp_equiv (e : A ≃ B) (f : B → C) : imageLaw (f ∘ e)=imageLaw f := by |
| funext c |
| unfold imageLaw push uniform |
| rw [Fintype.card_congr e,←e.sum_comp (fun b=>if f b=c then (1:ℝ)/Fintype.card B else 0)] |
| rfl |
|
|
| omit [Fintype C] in |
| lemma push_comp (p : A → ℝ) (f : A → B) (g : B → C) : |
| push (push p f) g=push p (g ∘ f) := by |
| funext c |
| unfold push |
| have h (b : B) : (if g b=c then ∑ a,if f a=b then p a else 0 else 0)= |
| ∑ a,if g b=c then (if f a=b then p a else 0) else 0 := by |
| by_cases hh : g b=c <;> simp [hh] |
| simp_rw [h] |
| rw [sum_comm] |
| apply sum_congr rfl |
| intro a _ |
| simp only [←ite_and] |
| rw [show (fun b=>if g b=c ∧ f a=b then p a else 0)= |
| (fun b=>if f a=b then (if g b=c then p a else 0) else 0) by |
| funext b; split_ifs <;> simp_all] |
| simp |
|
|
| omit [Fintype C] in |
| lemma imageLaw_comp (f : A → B) (g : B → C) : imageLaw (g ∘ f)=push (imageLaw f) g := |
| (push_comp _ _ _).symm |
|
|
| lemma uniform_prod (a : A×B) : uniform (A×B) a=uniform A a.1*uniform B a.2 := by |
| simp [uniform,Fintype.card_prod,Nat.cast_mul,mul_comm] |
|
|
| variable {D : Type*} [Fintype D] |
|
|
| omit [Fintype C] in |
| lemma imageLaw_pair (f : A → B → C) : |
| imageLaw (fun x : A×B=>f x.1 x.2)=bind (uniform A) (fun a=>imageLaw (f a)) := by |
| funext c |
| simp only [imageLaw,push,bind,Fintype.sum_prod_type,uniform_prod,mul_sum] |
| apply sum_congr rfl |
| intro a _ |
| apply sum_congr rfl |
| intro b _ |
| split_ifs <;> simp |
|
|
| omit [Fintype C] in |
| lemma bind_push (p : A → ℝ) (f : A → B) (k : B → C → ℝ) : |
| bind (push p f) k=bind p (fun a=>k (f a)) := by |
| funext c |
| simp only [bind,push,sum_mul,ite_mul,zero_mul] |
| rw [sum_comm] |
| apply sum_congr rfl |
| intro a _ |
| simp |
|
|
| omit [Fintype C] in |
| lemma imageLaw_adaptive_pair (d : A → D) (f : D → B → C) : |
| imageLaw (fun x : A×B=>f (d x.1) x.2)=bind (imageLaw d) (fun a=>imageLaw (f a)) := by |
| rw [imageLaw_pair (fun a b=>f (d a) b), imageLaw,bind_push] |
|
|
| theorem uniform_sigma [Nonempty A] {E : B → Type*} [∀ b,Fintype (E b)] |
| (e : (Σ b,E b) ≃ A) (z : A) : |
| push (sigmaLift (fun b=>(Fintype.card (E b):ℝ)/Fintype.card A) |
| (fun b=>uniform (E b))) e z=uniform A z := by |
| have h (s : Sigma E) : sigmaLift (fun b=>(Fintype.card (E b):ℝ)/Fintype.card A) |
| (fun b=>uniform (E b)) s=uniform (Sigma E) s := by |
| have hn : (Fintype.card (E s.1):ℝ)≠0 := by |
| let : Nonempty (E s.1) := ⟨s.2⟩ |
| exact_mod_cast Fintype.card_ne_zero |
| simp only [sigmaLift,uniform,Fintype.card_congr e] |
| field_simp |
| have hh := congrArg (fun p=>push p e z) (funext h) |
| rw [hh] |
| exact congrFun (imageLaw_equiv e) z |
|
|
| open Finset |
| open scoped Classical |
|
|
| variable {A B C : Type*} [Fintype A] [Fintype B] [Fintype C] |
|
|
| omit [Fintype C] in |
| lemma imageLaw_ignore [Nonempty A] (f : B → C) : |
| imageLaw (fun x : A×B=>f x.2)=imageLaw f := by |
| rw [imageLaw_pair (fun _ b=>f b)] |
| funext c |
| simp only [bind,←sum_mul,uniform_sum,one_mul] |
|
|
| omit [Fintype B] in |
| lemma push_sigmaLift {E : A → Type*} [∀ a,Fintype (E a)] |
| (p : A → ℝ) (k : ∀ a,E a → ℝ) (f : (Σ a,E a) → B) : |
| push (sigmaLift p k) f=bind p (fun a=>push (k a) (fun e=>f ⟨a,e⟩)) := by |
| funext b |
| simp only [push,sigmaLift,bind,Fintype.sum_sigma,mul_sum] |
| apply sum_congr rfl |
| intro a _ |
| apply sum_congr rfl |
| intro e _ |
| split_ifs <;> simp |
|
|
| lemma imageLaw_subsingleton [Nonempty A] [Subsingleton B] (f : A → B) : |
| imageLaw f=uniform B := by |
| let : Nonempty B := ⟨f (Classical.choice (inferInstance : Nonempty A))⟩ |
| funext b |
| simp only [imageLaw,push,Subsingleton.elim (f _) b,ite_true,uniform_sum] |
| let : Unique B := ⟨⟨b⟩,fun x=>Subsingleton.elim x b⟩ |
| simp [uniform] |
|
|
| lemma tv_self (p : A → ℝ) : tv p p=0 := by simp [tv] |
|
|
| open scoped Classical |
|
|
| lemma imageLaw_fin_skip {B C D : Type*} [Fintype B] [Nonempty B] [Fintype C] [Fintype D] |
| (n : ℕ) (g : (Fin (n+2) → B) → C) (d : B → D) (f : D → (Fin n → B) → C) |
| (hg : ∀ bits,g bits=f (d (bits (Fin.last (n+1)))) (fun i=>bits i.castSucc.castSucc)) : |
| imageLaw g=bind (imageLaw d) (fun c=>imageLaw (f c)) := by |
| let e : (B×(B×(Fin n → B))) ≃ (Fin (n+2) → B) := |
| (Equiv.prodCongr (Equiv.refl B) (Fin.snocEquiv (fun _ : Fin (n+1)=>B))).trans |
| (Fin.snocEquiv (fun _ : Fin (n+2)=>B)) |
| have hE : g ∘ e=(fun x : B×(B×(Fin n→B))=>f (d x.1) x.2.2) := by |
| funext x |
| rw [Function.comp_apply,hg] |
| simp [e,Fin.snocEquiv] |
|
|
| rw [←imageLaw_comp_equiv e,hE,imageLaw_adaptive_pair d (fun c (u : B×(Fin n→B))=>f c u.2)] |
| simp_rw [imageLaw_ignore] |
|
|
| end MatchingFPRAS.Variation |
|
|
| namespace MatchingFPRAS.WeightedOptions |
|
|
| open Finset Variation FiniteChoice |
|
|
| variable {Ω : Type*} [Fintype Ω] [DecidableEq Ω] |
|
|
| def draw (c : WeightedOptions Ω) (k : ℕ) (bits : Fin k → Bool) : Ω := |
| c.out (chooseBits c.mass c.total k bits) |
|
|
| omit [Fintype Ω] [DecidableEq Ω] in |
| lemma chooseBits_imageLaw (c : WeightedOptions Ω) (k : ℕ) : |
| imageLaw (chooseBits c.mass c.total k) = fun i => (tapeLaw c.mass c.total k i:ℝ) := by |
| funext i |
| rw [imageLaw_eq_count] |
| simp only [Fintype.card_fun,Fintype.card_fin,Fintype.card_bool,Nat.cast_pow, |
| Nat.cast_ofNat,tapeLaw,Rat.cast_div,Rat.cast_natCast,Rat.cast_pow,Rat.cast_ofNat] |
| congr 2 |
| congr 1 |
| ext bits |
| simp only [mem_filter,mem_univ,true_and] |
|
|
| omit [Fintype Ω] in |
| lemma realLaw_push (c : WeightedOptions Ω) : |
| (fun b => (c.law b:ℝ))=push (fun i=>(c.mass i:ℝ)) c.out := by |
| funext b |
| unfold law push |
| simp only [Rat.cast_sum,apply_ite,Rat.cast_zero] |
|
|
| theorem draw_tv (c : WeightedOptions Ω) (k : ℕ) : |
| tv (imageLaw (c.draw k)) (fun b=>(c.law b:ℝ)) ≤ 2*c.size/(2:ℝ)^k := by |
| have h := fixed_bit_choice c.mass c.nonneg c.total k |
| rw [←tapeLaw_eq] at h |
| have hr : tv (fun i=>(tapeLaw c.mass c.total k i:ℝ)) (fun i=>(c.mass i:ℝ)) |
| ≤ 2*c.size/(2:ℝ)^k := by |
| change (∑ i : Fin c.size, |(tapeLaw c.mass c.total k i:ℝ)-(c.mass i:ℝ)|)/2 ≤ _ |
| have hh := (Rat.cast_le (K := ℝ)).mpr h |
| simpa only [Rat.cast_div,Rat.cast_sum,Rat.cast_abs,Rat.cast_sub,Rat.cast_mul, |
| Rat.cast_ofNat,Rat.cast_natCast,Rat.cast_pow] using hh |
| have hd : c.draw k = c.out ∘ chooseBits c.mass c.total k := rfl |
| rw [hd,imageLaw_comp,realLaw_push,chooseBits_imageLaw] |
| exact (push_contraction _ _ _).trans hr |
|
|
| def runDraw (c : ℕ → Ω → WeightedOptions Ω) (z : Ω) (k : ℕ) : |
| (n : ℕ) → (Fin n → Fin k → Bool) → Ω |
| | 0, _ => z |
| | n+1, bits => (c n (runDraw c z k n (Fin.init bits))).draw k (bits (Fin.last n)) |
|
|
| noncomputable def exactRun (c : ℕ → Ω → WeightedOptions Ω) (z : Ω) : ℕ → Ω → ℝ |
| | 0 => fun b => if z=b then 1 else 0 |
| | n+1 => bind (exactRun c z n) (fun s b => ((c n s).law b:ℝ)) |
|
|
| lemma exactRun_nonneg (c : ℕ → Ω → WeightedOptions Ω) (z : Ω) (n : ℕ) (b : Ω) : |
| 0≤exactRun c z n b := by |
| induction n generalizing b with |
| | zero => simp only [exactRun]; split_ifs <;> norm_num |
| | succ n ih => exact bind_nonneg _ _ ih (fun s b => by exact_mod_cast (c n s).law_nonneg b) b |
|
|
| lemma exactRun_sum (c : ℕ → Ω → WeightedOptions Ω) (z : Ω) (n : ℕ) : |
| ∑ b,exactRun c z n b=1 := by |
| induction n with |
| | zero => simp [exactRun] |
| | succ n ih => exact bind_sum _ _ ih (fun s => real_law_sum (c n s)) |
|
|
| omit [DecidableEq Ω] in |
| lemma runDraw_law (c : ℕ → Ω → WeightedOptions Ω) (z : Ω) (k n : ℕ) : |
| imageLaw (runDraw c z k (n+1)) = bind (imageLaw (runDraw c z k n)) |
| (fun s => imageLaw ((c n s).draw k)) := by |
| let e : ((Fin n → Fin k → Bool) × (Fin k → Bool)) ≃ (Fin (n+1) → Fin k → Bool) := |
| (Equiv.prodComm _ _).trans (Fin.snocEquiv (fun _ => Fin k → Bool)) |
| have h : runDraw c z k (n+1) ∘ e = |
| (fun u => (c n (runDraw c z k n u.1)).draw k u.2) := by |
| funext u |
| change (c n (runDraw c z k n (Fin.init (Fin.snoc (α := fun _ : Fin (n+1) => Fin k → Bool) u.1 u.2)))).draw k |
| (Fin.snoc (α := fun _ : Fin (n+1) => Fin k → Bool) u.1 u.2 (Fin.last n)) = _ |
| simp only [Fin.init_snoc,Fin.snoc_last] |
| rw [←imageLaw_comp_equiv e,h] |
| exact imageLaw_adaptive_pair (runDraw c z k n) (fun s bits => (c n s).draw k bits) |
|
|
| theorem runDraw_tv (c : ℕ → Ω → WeightedOptions Ω) (z : Ω) (k R n : ℕ) |
| (hR : ∀ j s, (c j s).size ≤ R) : |
| tv (imageLaw (runDraw c z k n)) (exactRun c z n) ≤ 2*n*R/(2:ℝ)^k := by |
| induction n with |
| | zero => |
| have h : imageLaw (runDraw c z k 0)=exactRun c z 0 := by |
| funext b |
| simp [imageLaw,push,Variation.uniform,runDraw,exactRun] |
| rw [h,tv_self] |
| norm_num |
| | succ n ih => |
| rw [runDraw_law] |
| change tv (bind _ _) (bind _ _)≤_ |
| let p := imageLaw (runDraw c z k n) |
| let q := exactRun c z n |
| let u := fun s => imageLaw ((c n s).draw k) |
| let v := fun s b => ((c n s).law b:ℝ) |
| have hu : ∀ s, tv (u s) (v s) ≤ 2*R/(2:ℝ)^k := by |
| intro s |
| exact ((c n s).draw_tv k).trans (div_le_div_of_nonneg_right |
| (mul_le_mul_of_nonneg_left (by exact_mod_cast hR n s) (by norm_num)) (by positivity)) |
| have h1 := bind_perturbation p u v (imageLaw_nonneg _) (imageLaw_sum _) _ hu |
| have h2 := bind_contraction p q v |
| (fun s b => by dsimp [v]; exact_mod_cast (c n s).law_nonneg b) (fun s => real_law_sum (c n s)) |
| calc |
| _ ≤ tv (bind p u) (bind p v)+tv (bind p v) (bind q v) := tv_triangle _ _ _ |
| _ ≤ 2*R/(2:ℝ)^k+2*n*R/(2:ℝ)^k := add_le_add h1 (h2.trans ih) |
| _ = _ := by push_cast; ring |
|
|
| end MatchingFPRAS.WeightedOptions |
|
|
| end OAI |
|
|
