| import Mathlib |
| import OAI.Probability.Contingency.CompletionTranslation |
|
|
| namespace OAI |
|
|
| /-! Small Poincare. -/ |
|
|
| noncomputable section |
|
|
| open scoped BigOperators |
| open scoped BigOperators |
| namespace Contingency.PaddedGraph |
| noncomputable section |
| open FiniteChain |
| variable {m n a b : ℕ} (d C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (er : Fin a ≃ {i // d^20≤r i}) (ec : Fin b ≃ {j // d^20≤c j}) |
| (i₀ : Fin a) (j₀ : Fin b) |
| (hrc : (∑ i,r i)=∑ j,c j) (hd : 14≤d) (hm : m ≤ d) (hn : n ≤ d) (hmn : m*n≤d) |
| [Nonempty (GraphState (d^20) r c)] |
|
|
| theorem smallDim_one (d : ℕ) (hd : 14≤d) : 1≤d := by omega |
|
|
| local notation "A" => smallData (d^20) (d^12) d r c er ec i₀ j₀ hrc (smallDim_one d hd) hmn |
|
|
| include hm hn in |
| theorem small_poincare (hC2 : 2≤C) (hC : ∀ i,paddedRow (d^20) (d^12) r c i≤C) |
| (H : GraphState (d^20) r c → ℝ) : |
| (A).chain.variance H ≤ (d:ℝ)^160*(A).chain.energy H := by |
| have hd' : (1:ℝ)≤d := by exact_mod_cast (smallDim_one d hd) |
| have hd0 : (0:ℝ)<d := by linarith |
| have hU : 2≤d^20 := by |
| calc |
| 2 ≤ 14^20 := by norm_num |
| _ ≤ d^20 := Nat.pow_le_pow_left hd _ |
| have hv := graph_poincare (d^20) (d^12) C d r c hU hC2 (by omega) hmn hrc hC |
| (extendGraph (d^20) r c H) |
| have he := graphEnergy_le_accepted (d^20) C d r c er ec i₀ j₀ hrc hd hm hn hmn hC H |
| let S : ℝ := ∑ X,∑ Y,edgeCount (d^20) (d^12) r c er ec i₀ j₀ X Y*(H X-H Y)^2 |
| have hs : 0≤S := Finset.sum_nonneg (fun X _ => Finset.sum_nonneg (fun Y _ => |
| mul_nonneg (edgeCount_nonneg (d^20) (d^12) r c er ec i₀ j₀ X Y) (sq_nonneg _))) |
| have hvar : (A).chain.variance H=graphVariance (d^20) (d^12) r c (extendGraph (d^20) r c H)/(A).total := by |
| rw [AcceptedData.variance_formula] |
| congr 1 |
| unfold graphVariance |
| have hh : extendGraph (d^20) r c H ∘ graphUnderlying (d^20) r c=H := by |
| funext X; exact extendGraph_apply (d^20) r c H X |
| rw [hh]; rfl |
| have hEn : (A).chain.energy H=(proposalRate (32*d^2)/(A).total)*S/2 := by |
| rw [AcceptedData.energy_formula]; rfl |
| have hq := (smallProposal_bounds d (by omega)).1 |
| have hrate : S/(A).total ≤128*(d:ℝ)^2*(A).chain.energy H := by |
| rw [hEn] |
| have hsum := mul_le_mul_of_nonneg_right hq hs |
| apply (div_le_iff₀ (A).total_pos).mpr |
| field_simp [(A).total_pos.ne'] |
| have hh : S≤64*(d:ℝ)^2*(proposalRate (32*d^2)*S) := by |
| have hh := hsum |
| rw [one_div_mul_eq_div,div_le_iff₀ (by positivity : 0<64*(d:ℝ)^2)] at hh |
| nlinarith only [hh] |
| nlinarith only [hh] |
| have hpow : 770*(d:ℝ)^4*((d^20:ℕ):ℝ)^6*2=1540*(d:ℝ)^124 := by |
| push_cast |
| rw [← pow_mul] |
| ring |
| have hvarS : (A).chain.variance H ≤1540*(d:ℝ)^124*(S/(A).total) := by |
| rw [hvar] |
| apply (div_le_iff₀ (A).total_pos).mpr |
| have hh := hv.trans (mul_le_mul_of_nonneg_left he (by positivity)) |
| change graphVariance (d^20) (d^12) r c (extendGraph (d^20) r c H) ≤ _ at hh |
| calc |
| _ ≤ 770*(d:ℝ)^4*((d^20:ℕ):ℝ)^6*(2*S) := hh |
| _ = (1540*(d:ℝ)^124)*S := by rw [← mul_assoc,hpow] |
| _ = _ := by field_simp [(A).total_pos.ne'] |
| have hconst : 197120*(d:ℝ)^126≤(d:ℝ)^160 := by |
| have hh : (197120:ℝ)≤(d:ℝ)^34 := by |
| calc |
| _ ≤ (14:ℝ)^34 := by norm_num |
| _ ≤ _ := pow_le_pow_left₀ (by norm_num) (by exact_mod_cast hd) _ |
| have hh' := mul_le_mul_of_nonneg_right hh (pow_nonneg hd0.le 126) |
| calc |
| _ ≤ (d:ℝ)^34*(d:ℝ)^126 := hh' |
| _ = _ := by rw [← pow_add] |
| calc |
| _ ≤ 1540*(d:ℝ)^124*(S/(A).total) := hvarS |
| _ ≤ 1540*(d:ℝ)^124*(128*(d:ℝ)^2*(A).chain.energy H) := mul_le_mul_of_nonneg_left hrate (by positivity) |
| _ = (197120*(d:ℝ)^126)*(A).chain.energy H := by ring |
| _ ≤ _ := mul_le_mul_of_nonneg_right hconst (by rw [hEn]; have hp : 0 ≤ proposalRate (32*d^2) := le_trans (by positivity) hq; exact div_nonneg (mul_nonneg (div_nonneg hp (A).total_pos.le) hs) (by norm_num)) |
|
|
| end |
| end Contingency.PaddedGraph |
|
|
| |
|
|
| |
|
|
| open scoped BigOperators |
| namespace Contingency.PaddedGraph |
| noncomputable section |
| variable {m n : ℕ} (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
|
|
| def smallPart (Z : Tables r c) (w : Cell m n) : ℤ := |
| if IsSmall U r c w then Z.val w.1 w.2 else 0 |
|
|
| theorem table_row_bound (Z : Tables r c) (i : Fin m) (j : Fin n) : Z.val i j≤r i := by |
| rw [← Z.property.1 i] |
| exact Finset.single_le_sum (fun j _ => Nat.zero_le (Z.val i j)) (Finset.mem_univ j) |
|
|
| theorem table_col_bound (Z : Tables r c) (i : Fin m) (j : Fin n) : Z.val i j≤c j := by |
| rw [← Z.property.2 j] |
| exact Finset.single_le_sum (fun i _ => Nat.zero_le (Z.val i j)) (Finset.mem_univ i) |
|
|
| theorem smallPart_bounds (Z : Tables r c) (w : Cell m n) : |
| 0≤ smallPart U r c Z w ∧ smallPart U r c Z w≤U := by |
| unfold smallPart |
| split_ifs with h |
| · constructor |
| · positivity |
| · have hr := table_row_bound r c Z w.1 w.2 |
| have hc := table_col_bound r c Z w.1 w.2 |
| simp only [IsSmall,IsLarge,not_and_or,not_le] at h |
| rcases h with h | h <;> exact_mod_cast (by omega : Z.val w.1 w.2≤U) |
| · constructor <;> positivity |
|
|
| theorem smallPart_row (Z : Tables r c) (i : Fin m) : |
| rowSum (smallPart U r c Z) i≤r i ∧ |
| ((∀ j,¬IsLarge U r c (i,j)) → rowSum (smallPart U r c Z) i=r i) := by |
| have he : (∑ j,(Z.val i j:ℤ))=r i := by exact_mod_cast Z.property.1 i |
| constructor |
| · rw [← he] |
| apply Finset.sum_le_sum; intro j _ |
| dsimp [smallPart] |
| split_ifs |
| · rfl |
| · positivity |
| · intro h |
| simpa only [rowSum,smallPart,show ∀ j,IsSmall U r c (i,j) from h,ite_true] using he |
|
|
| theorem smallPart_col (Z : Tables r c) (j : Fin n) : |
| colSum (smallPart U r c Z) j≤c j ∧ |
| ((∀ i,¬IsLarge U r c (i,j)) → colSum (smallPart U r c Z) j=c j) := by |
| have he : (∑ i,(Z.val i j:ℤ))=c j := by exact_mod_cast Z.property.2 j |
| constructor |
| · rw [← he] |
| apply Finset.sum_le_sum; intro i _ |
| dsimp [smallPart] |
| split_ifs |
| · rfl |
| · positivity |
| · intro h |
| simpa only [colSum,smallPart,show ∀ i,IsSmall U r c (i,j) from h,ite_true] using he |
|
|
| |
|
|
| def initialTransversal (Z : Tables r c) : TransverseState U r c := by |
| refine ⟨⟨smallPart U r c Z,smallPart U r c Z⟩,?_,rfl⟩ |
| refine ⟨?_,?_,smallPart_row U r c Z,smallPart_col U r c Z⟩ |
| · intro w |
| exact ⟨(smallPart_bounds U r c Z w).1,(smallPart_bounds U r c Z w).2,smallPart_bounds U r c Z w⟩ |
| · intro w hw |
| simp [smallPart,IsSmall,hw] |
|
|
| theorem transverse_nonempty (hrc : (∑ i,r i)=∑ j,c j) : Nonempty (TransverseState U r c) := by |
| obtain ⟨Z⟩ := tables_nonempty r c hrc |
| exact ⟨initialTransversal U r c Z⟩ |
|
|
| theorem graph_nonempty (hrc : (∑ i,r i)=∑ j,c j) : Nonempty (GraphState U r c) := by |
| obtain ⟨X⟩ := transverse_nonempty U r c hrc |
| exact ⟨Sum.inl X⟩ |
|
|
| end |
| end Contingency.PaddedGraph |
|
|
| |
|
|
| |
|
|
| open scoped BigOperators |
| namespace Contingency.PaddedGraph |
| noncomputable section |
| variable {m n : ℕ} (U L d : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
|
|
| def transverseMass : ℕ := ∑ X : TransverseState U r c,weight U L r c X.val |
| def graphMass : ℕ := ∑ X : GraphState U r c,weight U L r c (graphUnderlying U r c X) |
|
|
| theorem transverseMass_pos (hrc : (∑ i,r i)=∑ j,c j) : 0<transverseMass U L r c := by |
| let := transverse_nonempty U r c hrc |
| apply Finset.sum_pos |
| · intro X _ |
| exact graph_weight_pos U L r c (Sum.inl X) hrc |
| · exact Finset.univ_nonempty |
|
|
| def taggedState (X : DefectiveState U r c) : (Cell m n × Cell m n) × TransverseState U r c := |
| (defectPair U r c X,repairedState U r c X) |
|
|
| theorem taggedState_injective : Function.Injective (taggedState U r c) := by |
| intro X Y h |
| apply taggedRepair_injective U r c |
| apply Prod.ext |
| · exact congrArg (fun p : (Cell m n × Cell m n) × TransverseState U r c => p.1) h |
| · exact congrArg (fun p : (Cell m n × Cell m n) × TransverseState U r c => transverseProfile U r c p.2) h |
|
|
| theorem defectMass_le (hmn : m*n≤d) : |
| (∑ X : DefectiveState U r c,weight U L r c X.val)≤d^2*transverseMass U L r c := by |
| classical |
| calc |
| _ ≤ ∑ X : DefectiveState U r c,weight U L r c (repairedState U r c X).val := by |
| apply Finset.sum_le_sum; intro X _ |
| exact weight_repair_le U L r c _ _ X.val (defectPair_spec U r c X) |
| _ = ∑ pp∈Finset.univ.image (taggedState U r c),weight U L r c pp.2.val := by |
| rw [Finset.sum_image (fun X _ Y _ h => taggedState_injective U r c h)] |
| rfl |
| _ ≤ ∑ pp : (Cell m n × Cell m n) × TransverseState U r c,weight U L r c pp.2.val := |
| Finset.sum_le_sum_of_subset (Finset.subset_univ _) |
| _ = (m*n)^2*transverseMass U L r c := by |
| simp [Fintype.sum_prod_type,transverseMass,Cell,pow_two,Nat.mul_assoc] |
| _ ≤ _ := Nat.mul_le_mul_right _ (Nat.pow_le_pow_left hmn 2) |
|
|
| theorem graphMass_bounds (hrc : (∑ i,r i)=∑ j,c j) (hmn : m*n≤d) : |
| 0<transverseMass U L r c ∧ transverseMass U L r c≤graphMass U L r c ∧ |
| graphMass U L r c≤(1+d^2)*transverseMass U L r c := by |
| have he : graphMass U L r c=transverseMass U L r c+ |
| ∑ X : DefectiveState U r c,weight U L r c X.val := by |
| unfold graphMass transverseMass |
| rw [Fintype.sum_sum_type] |
| rfl |
| have hd := defectMass_le U L d r c hmn |
| rw [he] |
| refine ⟨transverseMass_pos U L r c hrc,by omega,?_⟩ |
| rw [Nat.add_mul,Nat.one_mul] |
| exact Nat.add_le_add_left hd _ |
|
|
| end |
| end Contingency.PaddedGraph |
|
|
| |
|
|
| |
|
|
| open scoped BigOperators |
| namespace Contingency.PaddedGraph |
| noncomputable section |
| variable {m n : ℕ} (U L C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
|
|
| abbrev Joint := Σ X : GraphState U r c, Completion U L r c (graphUnderlying U r c X) |
|
|
| instance : Fintype (Joint U L r c) := by |
| letI (X : GraphState U r c) : Fintype (Completion U L r c (graphUnderlying U r c X)) := Fintype.ofFinite _ |
| exact inferInstance |
|
|
| theorem joint_card : Nat.card (Joint U L r c)=graphMass U L r c := by |
| let (X : GraphState U r c) : Fintype (Completion U L r c (graphUnderlying U r c X)) := Fintype.ofFinite _ |
| rw [Nat.card_eq_fintype_card,Fintype.card_sigma] |
| unfold graphMass |
| apply Finset.sum_congr rfl |
| intro X _ |
| rw [weight,ite_eq_left (graph_feasible U r c X),Nat.card_eq_fintype_card] |
|
|
| def jointCoordinates (P : Joint U L r c) : Coordinate m n → ℤ := |
| fullCoordinates U C r c (graphUnderlying U r c P.1) P.2.val |
|
|
| theorem jointCoordinates_injective : Function.Injective (jointCoordinates U L C r c) := by |
| intro P Q h |
| have hsmall (w : Cell m n) (hw : IsSmall U r c w) : |
| (graphUnderlying U r c P.1).x w=(graphUnderlying U r c Q.1).x w ∧ |
| (graphUnderlying U r c P.1).q w=(graphUnderlying U r c Q.1).q w := by |
| have hx := congrFun h (true,w) |
| have hq := congrFun h (false,w) |
| simp only [jointCoordinates,fullCoordinates,P.2.property.2.1 w hw,Q.2.property.2.1 w hw, |
| Bool.false_eq_true,ite_false,ite_true,add_zero] at hx hq |
| exact ⟨hx,by omega⟩ |
| have hX : graphUnderlying U r c P.1=graphUnderlying U r c Q.1 := by |
| apply State.ext |
| · funext w |
| by_cases hw : IsSmall U r c w |
| · exact (hsmall w hw).1 |
| · rw [(graph_feasible U r c P.1).2.1 w (Classical.not_not.mp hw) |>.1, |
| (graph_feasible U r c Q.1).2.1 w (Classical.not_not.mp hw) |>.1] |
| · funext w |
| by_cases hw : IsSmall U r c w |
| · exact (hsmall w hw).2 |
| · rw [(graph_feasible U r c P.1).2.1 w (Classical.not_not.mp hw) |>.2, |
| (graph_feasible U r c Q.1).2.1 w (Classical.not_not.mp hw) |>.2] |
| have hA : P.2.val=Q.2.val := by |
| funext w |
| have hx := congrFun h (true,w) |
| simp only [jointCoordinates,fullCoordinates,ite_true,hX] at hx |
| omega |
| have he := graphUnderlying_injective U r c hX |
| cases P with | mk X A => |
| cases Q with | mk Y B => |
| dsimp only at he |
| subst Y |
| congr 1 |
| exact Subtype.ext hA |
|
|
| def jointCode (hU : U≤C) (hC : ∀ i,paddedRow U L r c i≤C) |
| (P : Joint U L r c) : Coordinate m n → Fin (C+1) := fun w => |
| ⟨(jointCoordinates U L C r c P w).toNat,by |
| have hh := fullCoordinates_inBox U L C r c _ (graph_feasible U r c P.1) P.2 hC w |
| have hc : capacity U C r c w.2≤C := by unfold capacity; split_ifs <;> omega |
| change 0≤jointCoordinates U L C r c P w ∧ jointCoordinates U L C r c P w≤capacity U C r c w.2 at hh |
| omega⟩ |
|
|
| theorem jointCode_injective (hU : U≤C) (hC : ∀ i,paddedRow U L r c i≤C) : |
| Function.Injective (jointCode U L C r c hU hC) := by |
| intro P Q h |
| apply jointCoordinates_injective U L C r c |
| funext w |
| have hh := congrArg (fun f : Coordinate m n → Fin (C+1) => (f w).val) h |
| have hP := (fullCoordinates_inBox U L C r c _ (graph_feasible U r c P.1) P.2 hC w).1 |
| have hQ := (fullCoordinates_inBox U L C r c _ (graph_feasible U r c Q.1) Q.2 hC w).1 |
| change (jointCoordinates U L C r c P w).toNat=(jointCoordinates U L C r c Q w).toNat at hh |
| change 0≤jointCoordinates U L C r c P w at hP |
| change 0≤jointCoordinates U L C r c Q w at hQ |
| omega |
|
|
| theorem graphMass_upper (d : ℕ) (hmn : m*n≤d) |
| (hU : U≤C) (hC : ∀ i,paddedRow U L r c i≤C) : graphMass U L r c≤(C+1)^(2*d) := by |
| rw [← joint_card U L r c] |
| calc |
| _ ≤ Nat.card (Coordinate m n → Fin (C+1)) := |
| Nat.card_le_card_of_injective _ (jointCode_injective U L C r c hU hC) |
| _ = (C+1)^(2*(m*n)) := by simp [Coordinate,Cell] |
| _ ≤ _ := Nat.pow_le_pow_right (by omega) (Nat.mul_le_mul_left 2 hmn) |
|
|
| theorem stationary_lower (d : ℕ) (hrc : (∑ i,r i)=∑ j,c j) (hmn : m*n≤d) |
| (hU : U≤C) (hC : ∀ i,paddedRow U L r c i≤C) (X : GraphState U r c) : |
| 1/(C+1:ℝ)^(2*d) ≤ (weight U L r c (graphUnderlying U r c X):ℝ)/graphMass U L r c := by |
| have hM := graphMass_upper U L C r c d hmn hU hC |
| have hpos := graphMass_bounds U L d r c hrc hmn |
| have hMp : (0:ℝ)<graphMass U L r c := by exact_mod_cast lt_of_lt_of_le hpos.1 hpos.2.1 |
| have hw : (1:ℝ)≤weight U L r c (graphUnderlying U r c X) := by exact_mod_cast graph_weight_pos U L r c X hrc |
| apply (div_le_div_iff₀ (by positivity) hMp).mpr |
| have hM' : (graphMass U L r c:ℝ)≤(C+1:ℝ)^(2*d) := by exact_mod_cast hM |
| nlinarith [mul_le_mul_of_nonneg_right hw (show 0≤(C+1:ℝ)^(2*d) by positivity)] |
|
|
| end |
| end Contingency.PaddedGraph |
|
|
| |
|
|
| |
|
|
| open scoped BigOperators |
| namespace Contingency.PaddedGraph |
| noncomputable section |
| open FiniteChain |
| variable {m n a b : ℕ} (d C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (er : Fin a ≃ {i // d^20≤r i}) (ec : Fin b ≃ {j // d^20≤c j}) |
| (i₀ : Fin a) (j₀ : Fin b) |
| (hrc : (∑ i,r i)=∑ j,c j) (hd : 14≤d) (hm : m≤d) (hn : n≤d) (hmn : m*n≤d) |
| [Nonempty (GraphState (d^20) r c)] |
| local notation "A" => smallData (d^20) (d^12) d r c er ec i₀ j₀ hrc (smallDim_one d hd) hmn |
|
|
| omit [Nonempty (GraphState (d^20) r c)] in |
| theorem small_total : (A).total=(graphMass (d^20) (d^12) r c:ℝ) := by |
| simp [AcceptedData.total,smallData,graphMass,Nat.cast_sum] |
|
|
| include hm hn in |
| |
| theorem small_mixing (hC2 : 2≤C) (hU : d^20≤C) |
| (hC : ∀ i,paddedRow (d^20) (d^12) r c i≤C) (t : ℕ) (X : GraphState (d^20) r c) : |
| ((A).chain.walk X t).tv (A).chain.invariant≤ |
| (C+1:ℝ)^(2*d)*Real.exp (-(t:ℝ)/(d:ℝ)^160) := by |
| rw [Chain.walk_tv] |
| have hk : (1:ℝ)≤(d:ℝ)^160 := one_le_pow₀ (by exact_mod_cast smallDim_one d hd) |
| have hvar := small_poincare d C r c er ec i₀ j₀ hrc hd hm hn hmn hC2 hC |
| have hmin (Y : GraphState (d^20) r c) : 1/(C+1:ℝ)^(2*d)≤(A).chain.π Y := by |
| change _≤(weight (d^20) (d^12) r c (graphUnderlying (d^20) r c Y):ℝ)/(A).total |
| rw [small_total d r c er ec i₀ j₀ hrc hd hmn] |
| exact stationary_lower (d^20) (d^12) C r c d hrc hmn hU hC Y |
| have hh := (A).chain.mixing_bound_min ((d:ℝ)^160) hk hvar |
| (1/(C+1:ℝ)^(2*d)) (by positivity) hmin t X |
| simpa only [one_div,inv_inv] using hh |
|
|
| end |
| end Contingency.PaddedGraph |
|
|
| |
|
|
| |
|
|
| open scoped BigOperators |
| namespace Contingency.PaddedGraph |
| noncomputable section |
| variable {m n a c' : ℕ} (d b k C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (er : Fin (a+1) ≃ {i // d^20 ≤ r i}) (ec : Fin (c'+1) ≃ {j // d^20 ≤ c j}) |
| (hrc : (∑ i,r i)=∑ j,c j) (hd : 14 ≤ d) (hm : m ≤ d) (hn : n ≤ d) (hmn : m*n ≤ d) |
| (hC : ∀ i,paddedRow (d^20) (d^12) r c i ≤ C) (hCb : C ≤ 2^b) |
|
|
| local notation "Comp" => fun X : GraphState (d^20) r c => Completion (d^20) (d^12) r c (graphUnderlying (d^20) r c X) |
| local instance (X : GraphState (d^20) r c) : Fintype (Comp X) := Fintype.ofFinite _ |
| attribute [local instance] Dense.BinProblem.tableFintype |
|
|
| include hrc in |
| lemma comp_nonempty (X : GraphState (d^20) r c) : Nonempty (Comp X) := completion_nonempty _ _ _ _ _ hrc |
|
|
| include hC hCb in |
| lemma blockRow_upper (X : GraphState (d^20) r c) (i : Fin (a+1)) : |
| blockRow (d^20) (d^12) r c er X i ≤ 2^b := by |
| have hf := graph_feasible (d^20) r c X |
| have hn : 0 ≤ rowSum (graphUnderlying (d^20) r c X).x (er i).val := |
| Finset.sum_nonneg (fun j _ => (hf.1 ((er i).val,j)).1) |
| have hh := hC (er i).val |
| have hb' : (C:ℤ) ≤ 2^b := by exact_mod_cast hCb |
| apply Int.ofNat_le.mp |
| change (rowNat (d^20) (d^12) r c _ _:ℤ) ≤ ((2^b:ℕ):ℤ) |
| rw [rowNat_cast _ _ _ _ _ hf] |
| unfold paddedRow at hh |
| unfold residualRow |
| push_cast |
| omega |
|
|
| abbrev blockDraw (X : GraphState (d^20) r c) (fallback : Comp X) : DyadicLaw (Comp X) := by |
| classical |
| let e := blockEquiv (d^20) (d^12) r c er ec X |
| let ha := (block_dimensions (d^20) r c er ec).1.trans hm |
| let hc := (block_dimensions (d^20) r c er ec).2.trans hn |
| let hac := (Nat.mul_le_mul (block_dimensions (d^20) r c er ec).1 |
| (block_dimensions (d^20) r c er ec).2).trans hmn |
| let hR := fun i => block_row_lower (d^20) (d^12) r c er ec X i 0 |
| let hP := fun j => block_col_lower (d^20) (d^12) r c er ec X 0 j |
| exact (Dense.literalDraw d _ _ hd ha hc hac hR hP (block_totals _ _ _ _ er ec X hrc) b k |
| (blockRow_upper d b C r c er hC hCb X) (e fallback)).map e.symm |
|
|
| theorem blockDraw_bits (X : GraphState (d^20) r c) (fallback : Comp X) : |
| (blockDraw d b k C r c er ec hrc hd hm hn hmn hC hCb X fallback).bits=Schedule.RD d b k := by |
| classical |
| simp only [blockDraw,DyadicLaw.map_bits,Dense.literalDraw_bits] |
|
|
| theorem blockDraw_tv (hk : 1 ≤ k) (X : GraphState (d^20) r c) (fallback : Comp X) : |
| letI := completion_nonempty (d^20) (d^12) r c X hrc |
| (blockDraw d b k C r c er ec hrc hd hm hn hmn hC hCb X fallback).toLaw.tv (Law.uniform (Comp X)) ≤ |
| (2:ℝ)^(-(Schedule.h d b k:ℤ)) := by |
| classical |
| let := completion_nonempty (d^20) (d^12) r c X hrc |
| let e := blockEquiv (d^20) (d^12) r c er ec X |
| let := tables_nonempty _ _ (block_totals (d^20) (d^12) r c er ec X hrc) |
| unfold blockDraw |
| rw [DyadicLaw.toLaw_map,← Law.uniform_map_equiv e.symm] |
| exact (Law.tv_map e.symm _ _).trans (Dense.literalDraw_tv _ _ _ _ _ _ _ _ _ _ b k hk _ _) |
|
|
| end |
| end Contingency.PaddedGraph |
|
|
| |
|
|
| |
|
|
| open scoped BigOperators |
| namespace Contingency |
| noncomputable section |
| namespace Law |
|
|
| theorem uniform_event {α : Type*} [Fintype α] [Nonempty α] (p : α → Prop) [DecidablePred p] : |
| ((uniform α).map (fun x => decide (p x))).mass true=(Nat.card {x // p x}:ℝ)/Nat.card α := by |
| classical |
| simp only [map,bind,pure,uniform,decide_eq_true_eq,mul_ite,mul_one,mul_zero] |
| rw [← Finset.sum_filter] |
| simp only [Finset.sum_const,nsmul_eq_mul,← Nat.card_eq_fintype_card] |
| have he : (Finset.univ.filter p).card=Nat.card {x // p x} := by |
| rw [Nat.card_eq_fintype_card,Fintype.card_subtype] |
| rw [he] |
| ring |
|
|
| end Law |
| namespace PaddedGraph |
| open CompletionTranslation FiniteChain |
| variable {m n a c' : ℕ} (U L d : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (er : Fin a ≃ {i // U ≤ r i}) (ec : Fin c' ≃ {j // U ≤ c j}) (i₀ : Fin a) (j₀ : Fin c') |
| (hrc : (∑ i,r i)=∑ j,c j) (hd : 1 ≤ d) (hmn : m*n ≤ d) |
|
|
| local notation "Comp" => fun X : GraphState U r c => Completion U L r c (graphUnderlying U r c X) |
| local instance (X : GraphState U r c) : Fintype (Comp X) := Fintype.ofFinite _ |
| attribute [local instance] Dense.BinProblem.tableFintype |
|
|
| include hd hmn in |
| lemma proposal_degree (X : GraphState U r c) : |
| (Finset.univ.filter (GraphAdj U r c X)).card ≤ 2^(Nat.clog 2 (32*d^2)) := by |
| have hh := graph_degree U r c d hmn X |
| have hp : 1 ≤ d^2 := one_le_pow₀ hd |
| exact (hh.trans (by omega)).trans (Nat.le_pow_clog (by norm_num) _) |
|
|
| abbrev smallProposal (X : GraphState U r c) : DyadicLaw (GraphState U r c) := |
| DyadicLaw.neighborProposal (GraphAdj U r c) X (Nat.clog 2 (32*d^2)) |
| (GraphAdj.irrefl U r c X) (proposal_degree U d r c hd hmn X) |
|
|
| def completionTest (X Y : GraphState U r c) (A : Comp X) : Bool := |
| decide (∀ i j,0 ≤ (((blockEquiv U L r c er ec X A).val i j):ℤ)+blockD U L r c er ec i₀ j₀ X Y i j) |
|
|
| def completionKernel (μ : ∀ X,Law (Comp X)) (X : GraphState U r c) : Law (GraphState U r c) := |
| (smallProposal U d r c hd hmn X).toLaw.accept |
| (fun Y => (μ X).map (completionTest U L r c er ec i₀ j₀ X Y)) X |
|
|
| def implementedTransition (μ : ∀ X,DyadicLaw (Comp X)) (S : ℕ) (hS : ∀ X,(μ X).bits=S) |
| (X : GraphState U r c) : DyadicLaw (GraphState U r c) := by |
| classical |
| exact (smallProposal U d r c hd hmn X).bind |
| (fun Y => (μ X).map (fun A => if completionTest U L r c er ec i₀ j₀ X Y A then Y else X)) S |
| (fun _ => by rw [DyadicLaw.map_bits,hS]) |
|
|
| theorem implementedTransition_bits (μ : ∀ X,DyadicLaw (Comp X)) (S : ℕ) (hS : ∀ X,(μ X).bits=S) |
| (X : GraphState U r c) : |
| (implementedTransition U L d r c er ec i₀ j₀ hd hmn μ S hS X).bits=Nat.clog 2 (32*d^2)+S := rfl |
|
|
| theorem toLaw_implementedTransition (μ : ∀ X,DyadicLaw (Comp X)) (S : ℕ) (hS : ∀ X,(μ X).bits=S) |
| (X : GraphState U r c) : |
| (implementedTransition U L d r c er ec i₀ j₀ hd hmn μ S hS X).toLaw= |
| completionKernel U L d r c er ec i₀ j₀ hd hmn (fun X => (μ X).toLaw) X := by |
| classical |
| simp only [implementedTransition,DyadicLaw.toLaw_bind,DyadicLaw.toLaw_map, |
| completionKernel,Law.accept,Law.map_map] |
|
|
| theorem completionKernel_tv (μ ν : ∀ X,Law (Comp X)) (X : GraphState U r c) : |
| (completionKernel U L d r c er ec i₀ j₀ hd hmn μ X).tv |
| (completionKernel U L d r c er ec i₀ j₀ hd hmn ν X) ≤ (μ X).tv (ν X) := by |
| unfold completionKernel Law.accept |
| apply Law.tv_bind_right_bound |
| intro Y |
| exact (Law.tv_map _ _ _).trans (Law.tv_map _ _ _) |
|
|
| abbrev idealCompletion (X : GraphState U r c) : Law (Comp X) := |
| @Law.uniform (Comp X) inferInstance (completion_nonempty U L r c X hrc) |
|
|
| theorem idealCompletion_test (X Y : GraphState U r c) : |
| ((idealCompletion U L r c hrc X).map (completionTest U L r c er ec i₀ j₀ X Y)).mass true= |
| (acceptCount U L r c er ec i₀ j₀ X Y:ℝ)/weight U L r c (graphUnderlying U r c X) := by |
| classical |
| let := completion_nonempty U L r c X hrc |
| let : Fintype (Tables (blockRow U L r c er X) (blockCol U L r c ec X)) := Fintype.ofFinite _ |
| let := tables_nonempty _ _ (block_totals U L r c er ec X hrc) |
| let e := blockEquiv U L r c er ec X |
| let p := fun A : Tables (blockRow U L r c er X) (blockCol U L r c ec X) => |
| ∀ i j,0 ≤ (A.val i j:ℤ)+blockD U L r c er ec i₀ j₀ X Y i j |
| have he : completionTest U L r c er ec i₀ j₀ X Y = fun A => decide (p (e A)) := rfl |
| rw [he] |
| change ((Law.uniform (Comp X)).map (fun A => decide (p (e A)))).mass true=_ |
| rw [← Law.map_map (Law.uniform (Comp X)) e (fun A => decide (p A)),Law.uniform_map_equiv e,Law.uniform_event] |
| rw [block_card U L r c er ec X] |
| rfl |
|
|
| variable [Nonempty (GraphState U r c)] |
| theorem idealCompletion_kernel (X : GraphState U r c) : |
| completionKernel U L d r c er ec i₀ j₀ hd hmn (idealCompletion U L r c hrc) X= |
| (smallData U L d r c er ec i₀ j₀ hrc hd hmn).chain.transition X := by |
| classical |
| apply Law.ext_offdiag _ _ X |
| intro Y hXY |
| rw [completionKernel,Law.accept_offdiag _ _ _ _ hXY, |
| DyadicLaw.neighborProposal_offdiag _ _ _ _ _ _ hXY,idealCompletion_test] |
| simp only [FiniteChain.Chain.transition,AcceptedData.chain,AcceptedData.kernel,ite_eq_right hXY, |
| AcceptedData.rate,smallData,edgeCount,proposalRate] |
| split_ifs <;> ring |
|
|
| end PaddedGraph |
| end |
| end Contingency |
|
|
| |
|
|
| |
|
|
| open scoped BigOperators |
| namespace Contingency |
| noncomputable section |
| open FiniteChain |
| namespace DyadicLaw |
| variable {α : Type*} [Fintype α] [DecidableEq α] |
|
|
| |
| theorem walk_tv_chain (q : α → DyadicLaw α) (S : ℕ) (hS : ∀ x,(q x).bits=S) |
| (C : Chain α) (δ : ℝ) (hq : ∀ x,(q x).toLaw.tv (C.transition x)≤δ) (x₀ : α) (t : ℕ) : |
| (walk q S hS x₀ t).toLaw.tv (C.walk x₀ t)≤(t:ℝ)*δ := by |
| induction t with |
| | zero => simp [walk,toLaw_pure,Chain.walk] |
| | succ t ih => |
| rw [walk,toLaw_bind,Chain.walk] |
| have hh := Law.tv_bind (walk q S hS x₀ t).toLaw (C.walk x₀ t) |
| (fun x => (q x).toLaw) C.transition δ hq |
| push_cast |
| linarith |
|
|
| end DyadicLaw |
| namespace PaddedGraph |
| variable {m n a c' : ℕ} (U L d : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) |
| (er : Fin a ≃ {i // U ≤ r i}) (ec : Fin c' ≃ {j // U ≤ c j}) (i₀ : Fin a) (j₀ : Fin c') |
| (hrc : (∑ i,r i)=∑ j,c j) (hd : 1 ≤ d) (hmn : m*n ≤ d) |
| [Nonempty (GraphState U r c)] |
| local notation "Comp" => fun X : GraphState U r c => Completion U L r c (graphUnderlying U r c X) |
| local instance (X : GraphState U r c) : Fintype (Comp X) := Fintype.ofFinite _ |
|
|
| abbrev implementedWalk (μ : ∀ X,DyadicLaw (Comp X)) (S : ℕ) (hS : ∀ X,(μ X).bits=S) |
| (X₀ : GraphState U r c) (t : ℕ) : DyadicLaw (GraphState U r c) := by |
| classical |
| exact DyadicLaw.walk (implementedTransition U L d r c er ec i₀ j₀ hd hmn μ S hS) |
| (Nat.clog 2 (32*d^2)+S) (implementedTransition_bits U L d r c er ec i₀ j₀ hd hmn μ S hS) X₀ t |
|
|
| theorem implementedWalk_tv (μ : ∀ X,DyadicLaw (Comp X)) (S : ℕ) (hS : ∀ X,(μ X).bits=S) |
| (δ : ℝ) (hμ : ∀ X,(μ X).toLaw.tv (idealCompletion U L r c hrc X)≤δ) |
| (X₀ : GraphState U r c) (t : ℕ) : |
| (implementedWalk U L d r c er ec i₀ j₀ hd hmn μ S hS X₀ t).toLaw.tv |
| ((smallData U L d r c er ec i₀ j₀ hrc hd hmn).chain.walk X₀ t)≤(t:ℝ)*δ := by |
| classical |
| apply DyadicLaw.walk_tv_chain |
| intro X |
| rw [toLaw_implementedTransition,← idealCompletion_kernel U L d r c er ec i₀ j₀ hrc hd hmn] |
| exact (completionKernel_tv U L d r c er ec i₀ j₀ hd hmn _ _ X).trans (hμ X) |
|
|
| end PaddedGraph |
| end |
| end Contingency |
|
|
| end |
|
|
| end OAI |
|
|
