| import Mathlib |
| import OAI.Analysis.HardSphere.Geometry.EnnrealTsumFinset |
| import OAI.Analysis.HardSphere.Geometry.NominalDrift |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators Classical |
| open scoped BigOperators Classical |
| open scoped BigOperators Classical |
| open scoped ENNReal NNReal |
| open scoped ENNReal |
| namespace HardSphere.Lattice |
|
|
| def endpointDanger {K : ℕ} [NeZero K] (B : Finset (DiscreteTorus K)) (x : DiscreteTorus K) : Prop := |
| ∃ F∈candidateSets (torusRangeGraph K 1), F⊆B ∧ ∃ c∈F, torusNear K F.card x c |
|
|
| lemma fill_endpoint_danger {K : ℕ} [NeZero K] (hK : 2<K) |
| (B : Finset (DiscreteTorus K)) (r x : Vertex) (hr : torusProjection K r∈B) |
| (hsmall : (badComponent (torusRangeGraph K 1) B (torusProjection K r)).card<K) |
| (C : Finset Vertex) |
| (hC : (↑C : Set Vertex)=periodicLift K 1 (badComponent (torusRangeGraph K 1) B (torusProjection K r)) r) |
| (hx : x∉exterior C) : endpointDanger B (torusProjection K x) := by |
| let F := badComponent (torusRangeGraph K 1) B (torusProjection K r) |
| have hrF : torusProjection K r∈F := mem_own_badComponent _ _ hr |
| obtain ⟨D,hD,_,hspan⟩ := small_periodic_lifts (a:=1) (by simpa using hK) F |
| (by simpa using hsmall) (badComponent_preconnected _ _ _) r hrF |
| have hCD : C=D := Finset.coe_injective (hC.trans hD.symm) |
| subst D |
| have hrC : r∈C := by change r∈(↑C:Set Vertex); rw [hC]; exact ⟨hrF,.refl⟩ |
| have hbox := fill_subset_coordinateBox C (show x∈fill C from hx) |
| have hbound (i : Fin 3) : |x i-r i|≤F.card := by |
| obtain ⟨⟨l,hl,hlx⟩,⟨u,hu,hxu⟩⟩ := hbox i |
| have hlow := hspan l hl r hrC i |
| have hhigh := hspan u hu r hrC i |
| obtain ⟨hlow₁,hlow₂⟩ := abs_le.mp hlow |
| obtain ⟨hhigh₁,hhigh₂⟩ := abs_le.mp hhigh |
| exact abs_le.mpr ⟨by omega,by omega⟩ |
| refine ⟨F,badComponents_candidate _ B (Finset.mem_image.mpr ⟨torusProjection K r,hr,rfl⟩), |
| badComponent_subset _ B _,torusProjection K r,hrF,projection_near hbound⟩ |
|
|
| lemma endpointsExterior_of_no_danger {K : ℕ} [NeZero K] (hK : 2<K) |
| (B : Finset (DiscreteTorus K)) (v w : Vertex) |
| (hsmall : ∀ z∈B, (badComponent (torusRangeGraph K 1) B z).card<K) |
| (hv : ¬endpointDanger B (torusProjection K v)) (hw : ¬endpointDanger B (torusProjection K w)) : |
| endpointsExterior B v w := by |
| intro r hr C hC |
| constructor |
| · by_contra hn |
| exact hv (fill_endpoint_danger hK B r v hr (hsmall _ hr) C hC hn) |
| · by_contra hn |
| exact hw (fill_endpoint_danger hK B r w hr (hsmall _ hr) C hC hn) |
|
|
| def acceptedEnvironment {K : ℕ} [NeZero K] (a : ℕ) (B : Finset (DiscreteTorus K)) (v w : Vertex) : Prop := |
| ¬LargeBadComponent (torusRangeGraph K a) B (K/(10*a)) ∧ endpointsExterior B v w |
|
|
| lemma small_star_of_no_large {K a : ℕ} [NeZero K] (ha : 1≤a) |
| (B : Finset (DiscreteTorus K)) (hB : ¬LargeBadComponent (torusRangeGraph K a) B (K/(10*a))) : |
| ∀ z∈B, (badComponent (torusRangeGraph K 1) B z).card<K := by |
| intro z hz |
| have hC : badComponent (torusRangeGraph K a) B z∈badComponents (torusRangeGraph K a) B := |
| Finset.mem_image.mpr ⟨z,hz,rfl⟩ |
| have hcard : (badComponent (torusRangeGraph K a) B z).card<K/(10*a) := by |
| by_contra hn |
| exact hB ⟨_,hC,by omega⟩ |
| have hsub : badComponent (torusRangeGraph K 1) B z ⊆ badComponent (torusRangeGraph K a) B z := by |
| intro y hy |
| rcases (mem_badComponent _ _ _ _).mp hy with ⟨hyB,hzy⟩ |
| exact (mem_badComponent _ _ _ _).mpr ⟨hyB,hzy.mono (badGraph_graphMono (torusRangeGraph_mono ha) B)⟩ |
| exact (Finset.card_le_card hsub).trans_lt (hcard.trans_le (Nat.div_le_self _ _)) |
|
|
| lemma rejection_subset {K a : ℕ} [NeZero K] (hK : 2<K) (ha : 1≤a) |
| (B : Finset (DiscreteTorus K)) (v w : Vertex) (hE : ¬acceptedEnvironment a B v w) : |
| LargeBadComponent (torusRangeGraph K a) B (K/(10*a)) ∨ |
| endpointDanger B (torusProjection K v) ∨ endpointDanger B (torusProjection K w) := by |
| by_contra h |
| push Not at h |
| apply hE |
| exact ⟨h.1,endpointsExterior_of_no_danger hK B v w (small_star_of_no_large ha B h.1) h.2.1 h.2.2⟩ |
|
|
| def endpointAnimals {K : ℕ} [NeZero K] (x : DiscreteTorus K) (m : ℕ) : Finset (Finset (DiscreteTorus K)) := |
| (torusBall m x).biUnion (fun c ↦ rootedAnimals (torusRangeGraph K 1) c m) |
|
|
| lemma endpointAnimals_card {K : ℕ} [NeZero K] (x : DiscreteTorus K) (m : ℕ) : |
| (endpointAnimals x m).card≤(2*m+1)^3*(2^27)^m := by |
| calc |
| _ ≤ ∑ c∈torusBall m x, (rootedAnimals (torusRangeGraph K 1) c m).card := Finset.card_biUnion_le |
| _ ≤ ∑ _c∈torusBall m x, (2^27)^m := by |
| apply Finset.sum_le_sum |
| intro c _ |
| exact rootedAnimals_card_le _ 27 (by simpa using torusRange_degree (K:=K) 1) c m |
| _ = (torusBall m x).card*(2^27)^m := by simp |
| _ ≤ _ := Nat.mul_le_mul_right _ (torusNear_ball_card _ _) |
|
|
| lemma mem_endpointAnimals_card {K : ℕ} [NeZero K] (x : DiscreteTorus K) (m : ℕ) |
| {F : Finset (DiscreteTorus K)} (hF : F∈endpointAnimals x m) : F.card=m := by |
| obtain ⟨c,_,hF⟩ := Finset.mem_biUnion.mp hF |
| exact (Finset.mem_filter.mp hF).2.2.1 |
|
|
| lemma danger_contains_endpointAnimal {K : ℕ} [NeZero K] (B : Finset (DiscreteTorus K)) |
| (x : DiscreteTorus K) (h : endpointDanger B x) : |
| ∃ m : ℕ, ∃ F∈endpointAnimals x (m+1), F⊆B := by |
| obtain ⟨F,hF,hFB,c,hc,hxc⟩ := h |
| have hpos := Finset.card_pos.mpr (candidate_nonempty _ hF) |
| have hcard : F.card-1+1=F.card := by omega |
| refine ⟨F.card-1,F,?_,hFB⟩ |
| rw [hcard] |
| exact Finset.mem_biUnion.mpr ⟨c,(mem_torusBall _ _ _).mpr hxc, |
| Finset.mem_filter.mpr ⟨Finset.mem_univ _,hc,rfl,fun y hy ↦ candidate_reach _ hF hc hy⟩⟩ |
|
|
| theorem endpointDanger_probability {K : ℕ} [NeZero K] |
| (μ : PMF (Finset (DiscreteTorus K))) (p : ℝ≥0∞) (hbad : JointBadLaw μ p) (x : DiscreteTorus K) : |
| (∑' B, if endpointDanger B x then μ B else 0) ≤ |
| ∑' m : ℕ, ((2*(m+1)+1)^3:ℕ)*(((2^27:ℕ):ℝ≥0∞)*p)^(m+1) := by |
| have hpoint (B : Finset (DiscreteTorus K)) : |
| (if endpointDanger B x then μ B else 0) ≤ |
| ∑' m : ℕ, ∑ F∈endpointAnimals x (m+1), if F⊆B then μ B else 0 := by |
| by_cases h : endpointDanger B x |
| · obtain ⟨m,F,hF,hFB⟩ := danger_contains_endpointAnimal B x h |
| rw [ite_eq_left h] |
| exact le_trans (by |
| simpa only [ite_eq_left hFB] using |
| (Finset.single_le_sum (f := fun F : Finset (DiscreteTorus K) ↦ if F⊆B then μ B else 0) |
| (fun _ _ ↦ zero_le) hF)) (ENNReal.le_tsum m) |
| · rw [ite_eq_right h]; exact zero_le |
| calc |
| _ ≤ ∑' B, ∑' m : ℕ, ∑ F∈endpointAnimals x (m+1), if F⊆B then μ B else 0 := ENNReal.tsum_le_tsum hpoint |
| _ = ∑' m : ℕ, ∑ F∈endpointAnimals x (m+1), ∑' B, if F⊆B then μ B else 0 := by |
| rw [ENNReal.tsum_comm] |
| exact tsum_congr fun m ↦ ennreal_tsum_finset _ _ |
| _ ≤ ∑' m : ℕ, ∑ _F∈endpointAnimals x (m+1), p^(m+1) := by |
| apply ENNReal.tsum_le_tsum |
| intro m |
| apply Finset.sum_le_sum |
| intro F hF |
| simpa only [mem_endpointAnimals_card x (m+1) hF] using hbad F |
| _ ≤ _ := by |
| apply ENNReal.tsum_le_tsum |
| intro m |
| simp only [Finset.sum_const,nsmul_eq_mul] |
| calc |
| _ ≤ (((2*(m+1)+1)^3*(2^27)^(m+1):ℕ):ℝ≥0∞)*p^(m+1) := by |
| apply mul_le_mul' _ le_rfl |
| exact_mod_cast endpointAnimals_card x (m+1) |
| _ = _ := by simp only [Nat.cast_mul,Nat.cast_pow,mul_pow]; ring |
|
|
| open scoped NNReal |
| lemma endpoint_polynomial_le (m : ℕ) : (2*(m+1)+1)^3≤27*8^m := by |
| have hs : m+1≤2^m := by |
| induction m with |
| | zero => norm_num |
| | succ m ih => |
| rw [pow_succ] |
| have hp := Nat.one_le_pow m 2 (by norm_num) |
| omega |
| calc |
| _ ≤ (3*2^m)^3 := Nat.pow_le_pow_left (by nlinarith) 3 |
| _ = _ := by rw [mul_pow,← pow_mul,Nat.mul_comm m 3,pow_mul]; norm_num |
|
|
| lemma endpoint_series_le (q : ℝ≥0∞) (hq : q≤1/16) : |
| (∑' m : ℕ, ((2*(m+1)+1)^3:ℕ)*q^(m+1))≤54*q := by |
| have h8 : (8:ℝ≥0∞)*q≤1/2 := by |
| calc |
| _ ≤ 8*(1/16:ℝ≥0∞) := mul_le_mul' le_rfl hq |
| _ = _ := by |
| have h : (8:ℝ≥0)*(1/16)=1/2 := by norm_num |
| have hh := congrArg (fun x : ℝ≥0 ↦ (x:ℝ≥0∞)) h |
| simpa only [ENNReal.coe_mul,ENNReal.coe_div (show (16:ℝ≥0)≠0 by norm_num), |
| ENNReal.coe_div (show (2:ℝ≥0)≠0 by norm_num),ENNReal.coe_ofNat,ENNReal.coe_one] using hh |
| calc |
| _ ≤ ∑' m : ℕ, 27*q*((1/2:ℝ≥0∞)^m) := by |
| apply ENNReal.tsum_le_tsum |
| intro m |
| calc |
| _ ≤ (27*8^m:ℝ≥0∞)*q^(m+1) := by |
| apply mul_le_mul' _ le_rfl |
| exact_mod_cast endpoint_polynomial_le m |
| _ = 27*q*((8*q)^m) := by rw [pow_succ,mul_pow]; ring |
| _ ≤ _ := mul_le_mul' le_rfl (pow_le_pow_left' h8 m) |
| _ = _ := by rw [ENNReal.tsum_mul_left,ENNReal.tsum_geometric]; norm_num; ring |
|
|
| lemma rejection_probability {K a : ℕ} [NeZero K] (hK : 2<K) (ha : 1≤a) |
| (hm : 1≤K/(10*a)) (μ : PMF (Finset (DiscreteTorus K))) (p : ℝ≥0∞) |
| (hbad : JointBadLaw μ p) (v w : Vertex) : |
| (∑' B, if ¬acceptedEnvironment a B v w then μ B else 0)≤ |
| (K:ℝ≥0∞)^3*(((2^((2*a+1)^3):ℕ):ℝ≥0∞)*p)^(K/(10*a))+ |
| 2*∑' m : ℕ, ((2*(m+1)+1)^3:ℕ)*(((2^27:ℕ):ℝ≥0∞)*p)^(m+1) := by |
| have hpoint (B : Finset (DiscreteTorus K)) : |
| (if ¬acceptedEnvironment a B v w then μ B else 0)≤ |
| (if LargeBadComponent (torusRangeGraph K a) B (K/(10*a)) then μ B else 0)+ |
| (if endpointDanger B (torusProjection K v) then μ B else 0)+ |
| (if endpointDanger B (torusProjection K w) then μ B else 0) := by |
| by_cases hE : ¬acceptedEnvironment a B v w |
| · rw [ite_eq_left hE] |
| rcases rejection_subset hK ha B v w hE with h|h|h |
| · rw [ite_eq_left h]; exact le_add_of_le_left le_self_add |
| · rw [ite_eq_left h]; exact le_add_of_le_left le_add_self |
| · rw [ite_eq_left h]; exact le_add_self |
| · rw [ite_eq_right hE]; exact zero_le |
| calc |
| _ ≤ _ := ENNReal.tsum_le_tsum hpoint |
| _ = _ := by rw [ENNReal.tsum_add,ENNReal.tsum_add] |
| _ ≤ _ := add_le_add (add_le_add |
| (largeBadComponent_probability (torusRangeGraph K a) ((2*a+1)^3) |
| (torusRange_degree a) μ p hbad (K/(10*a)) hm) |
| (endpointDanger_probability μ p hbad (torusProjection K v))) |
| (endpointDanger_probability μ p hbad (torusProjection K w)) |
| _ = _ := by |
| simp only [DiscreteTorus,Fintype.card_fun,Fintype.card_fin,ZMod.card,Nat.cast_pow] |
| ring |
|
|
| lemma large_rejection_eventually (a : ℕ) (ha : 1≤a) : |
| ∀ᶠ K : ℕ in Filter.atTop, (K:ℝ)^3*(1/2:ℝ)^(K/(10*a))≤1/4 := by |
| let d := 10*a |
| have hd : 0<d := by dsimp [d]; omega |
| have hl := tendsto_pow_const_mul_const_pow_of_lt_one 3 (by norm_num : (0:ℝ)≤1/2) |
| (by norm_num : (1/2:ℝ)<1) |
| have hlim : Filter.Tendsto (fun j : ℕ ↦ ((2*d:ℕ):ℝ)^3*((j:ℝ)^3*(1/2:ℝ)^j)) Filter.atTop (nhds 0) := by |
| simpa using hl.const_mul (((2*d:ℕ):ℝ)^3) |
| have hSmall : ∀ᶠ j : ℕ in Filter.atTop, |
| ((2*d:ℕ):ℝ)^3*((j:ℝ)^3*(1/2:ℝ)^j)≤1/4 := |
| (hlim.eventually (gt_mem_nhds (by norm_num : (0:ℝ)<1/4))).mono (fun _ h ↦ h.le) |
| have hdiv := Nat.tendsto_div_const_atTop (ne_of_gt hd) |
| filter_upwards [hdiv.eventually hSmall,Filter.eventually_ge_atTop d] with K hsm hKd |
| have hj : 1≤K/d := (Nat.le_div_iff_mul_le hd).mpr (by simpa using hKd) |
| have hK : K≤(2*d)*(K/d) := by |
| have hb := Nat.lt_mul_div_succ K hd |
| nlinarith |
| calc |
| _ ≤ (((2*d:ℕ):ℝ)*(K/d:ℕ))^3*(1/2:ℝ)^(K/d) := by |
| apply mul_le_mul_of_nonneg_right _ (by positivity) |
| apply pow_le_pow_left₀ (by positivity) |
| exact_mod_cast hK |
| _ = ((2*d:ℕ):ℝ)^3*((K/d:ℕ)^3*(1/2:ℝ)^(K/d)) := by ring |
| _ ≤ _ := hsm |
|
|
| lemma pmf_complement_half {α : Type*} (μ : PMF α) (E : α → Prop) |
| (h : (∑' x, if ¬E x then μ x else 0)≤(1/2:ℝ≥0∞)) : |
| (1/2:ℝ≥0∞)≤∑' x, if E x then μ x else 0 := by |
| have he : (∑' x, if E x then μ x else 0)+(∑' x, if ¬E x then μ x else 0)=1 := by |
| rw [← ENNReal.tsum_add] |
| convert μ.tsum_coe using 1 |
| apply tsum_congr |
| intro x |
| by_cases hx : E x <;> simp [hx] |
| have hn : (∑' x, if ¬E x then μ x else 0)≠∞ := ne_of_lt (h.trans_lt (by norm_num)) |
| calc |
| (1/2:ℝ≥0∞)=1-(1/2) := by norm_num |
| _ ≤ 1-(∑' x, if ¬E x then μ x else 0) := tsub_le_tsub_left h 1 |
| _ = _ := by rw [← he,ENNReal.add_sub_cancel_right hn] |
|
|
| theorem acceptedEnvironment_mass (a : ℕ) (ha : 1≤a) : |
| ∃ p₀ : ℝ, 0<p₀ ∧ ∃ K₀ : ℕ, ∀ K : ℕ, K₀≤K → ∀ _ : NeZero K, |
| ∀ μ : PMF (Finset (DiscreteTorus K)), ∀ p : ℝ, 0≤p → p≤p₀ → |
| JointBadLaw μ (ENNReal.ofReal p) → ∀ v w : Vertex, |
| (1/2:ℝ≥0∞)≤∑' B, if acceptedEnvironment a B v w then μ B else 0 := by |
| let A : ℝ := (2:ℝ)^((2*a+1)^3) |
| let D : ℝ := (2:ℝ)^27 |
| have hA : 0<A := by dsimp [A]; positivity |
| have hD : 0<D := by dsimp [D]; positivity |
| let p₀ : ℝ := min ((1/432)/D) ((1/2)/A) |
| have hp₀ : 0<p₀ := lt_min (div_pos (by norm_num) hD) (div_pos (by norm_num) hA) |
| obtain ⟨M,hM⟩ := Filter.eventually_atTop.mp (large_rejection_eventually a ha) |
| refine ⟨p₀,hp₀,max M (10*a+3),?_⟩ |
| intro K hK inst μ p hp hpp hbad v w |
| have hKM : M≤K := (le_max_left _ _).trans hK |
| have hKd : 10*a+3≤K := (le_max_right _ _).trans hK |
| have hK2 : 2<K := by omega |
| have hm : 1≤K/(10*a) := (Nat.le_div_iff_mul_le (by omega)).mpr (by omega) |
| have hqD : D*p≤1/432 := by |
| have h := (le_div_iff₀ hD).mp (hpp.trans (min_le_left _ _)) |
| nlinarith |
| have hqA : A*p≤1/2 := by |
| have h := (le_div_iff₀ hA).mp (hpp.trans (min_le_right _ _)) |
| nlinarith |
| have hDeq : ((2^27:ℕ):ℝ≥0∞)*ENNReal.ofReal p=ENNReal.ofReal (D*p) := by |
| rw [ENNReal.ofReal_mul hD.le] |
| simp only [D,ENNReal.ofReal_pow (by norm_num : (0:ℝ)≤2),ENNReal.ofReal_ofNat,Nat.cast_pow,Nat.cast_ofNat] |
| have hAeq : ((2^((2*a+1)^3):ℕ):ℝ≥0∞)*ENNReal.ofReal p=ENNReal.ofReal (A*p) := by |
| rw [ENNReal.ofReal_mul hA.le] |
| simp only [A,ENNReal.ofReal_pow (by norm_num : (0:ℝ)≤2),ENNReal.ofReal_ofNat,Nat.cast_pow,Nat.cast_ofNat] |
| have hqDen : ENNReal.ofReal (D*p)≤1/16 := by |
| calc |
| _ ≤ ENNReal.ofReal (1/16:ℝ) := ENNReal.ofReal_le_ofReal (by linarith) |
| _ = _ := by rw [ENNReal.ofReal_div_of_pos (by norm_num),ENNReal.ofReal_one,ENNReal.ofReal_ofNat] |
| have hseries : (∑' m : ℕ, ((2*(m+1)+1)^3:ℕ)* |
| (((2^27:ℕ):ℝ≥0∞)*ENNReal.ofReal p)^(m+1))≤ENNReal.ofReal (1/8:ℝ) := by |
| rw [hDeq] |
| refine (endpoint_series_le _ hqDen).trans ?_ |
| calc |
| _ = ENNReal.ofReal (54*(D*p)) := by rw [ENNReal.ofReal_mul (p:=54) (q:=D*p) (by norm_num),ENNReal.ofReal_ofNat] |
| _ ≤ _ := ENNReal.ofReal_le_ofReal (by linarith) |
| have hlarge : (K:ℝ≥0∞)^3*(((2^((2*a+1)^3):ℕ):ℝ≥0∞)*ENNReal.ofReal p)^(K/(10*a))≤ |
| ENNReal.ofReal (1/4:ℝ) := by |
| rw [hAeq] |
| calc |
| _ ≤ (K:ℝ≥0∞)^3*(ENNReal.ofReal (1/2:ℝ))^(K/(10*a)) := |
| mul_le_mul' le_rfl (pow_le_pow_left' (ENNReal.ofReal_le_ofReal hqA) _) |
| _ = ENNReal.ofReal ((K:ℝ)^3*(1/2:ℝ)^(K/(10*a))) := by |
| rw [ENNReal.ofReal_mul (by positivity),ENNReal.ofReal_pow (by positivity), |
| ENNReal.ofReal_pow (by norm_num),ENNReal.ofReal_natCast] |
| _ ≤ _ := ENNReal.ofReal_le_ofReal (hM K hKM) |
| apply pmf_complement_half μ (fun B ↦ acceptedEnvironment a B v w) |
| refine (rejection_probability hK2 ha hm μ _ hbad v w).trans ?_ |
| refine (add_le_add hlarge (mul_le_mul' le_rfl hseries)).trans_eq ?_ |
| rw [show (2:ℝ≥0∞)=ENNReal.ofReal (2:ℝ) by norm_num, |
| ← ENNReal.ofReal_mul (by norm_num),← ENNReal.ofReal_add (by norm_num) (by norm_num)] |
| norm_num [ENNReal.ofReal_div_of_pos] |
|
|
| def SimpleGoodPath {K : ℕ} (B : Finset (DiscreteTorus K)) (x y : DiscreteTorus K) := |
| {p : (torusNearestGraph K).Walk x y // p.IsPath ∧ ∀ z∈p.support, z∉B} |
|
|
| lemma exists_nominal_detour {K m n : ℕ} [NeZero K] (hK : 2<K) (R : ℕ) |
| (hn : 0<n) (ht : n/2≤3^m) (v : Vertex) (Δ₂ Δ₃ : ℤ) |
| (hΔ₂ : |Δ₂|≤2*n) (hΔ₃ : |Δ₃|≤2*n) (B : Finset (DiscreteTorus K)) |
| (hB : acceptedEnvironment (R+2) B v (v+![(n:ℤ),Δ₂,Δ₃])) (w : PairNoise m) : |
| ∃ p : SimpleGoodPath B (torusProjection K v) (torusProjection K (v+![(n:ℤ),Δ₂,Δ₃])), |
| ∀ x∈p.val.support, |
| x∈(nominalCover (nominalVertices m n v Δ₂ Δ₃ w)).image (torusProjection K) ∨ |
| shellAttachment R B ((nominalCover (nominalVertices m n v Δ₂ Δ₃ w)).image (torusProjection K)) x := by |
| let U := nominalVertices m n v Δ₂ Δ₃ w |
| have hi : U 0=v := nominal_initial m n v Δ₂ Δ₃ w |
| have hf : U (Fin.last n)=v+![(n:ℤ),Δ₂,Δ₃] := nominal_final m n hn v Δ₂ Δ₃ w |
| have hv : v∈nominalCover U := hi ▸ nominal_mem_cover U 0 |
| have hw : v+![(n:ℤ),Δ₂,Δ₃]∈nominalCover U := hf ▸ nominal_mem_cover U (Fin.last n) |
| have hwalk : withinReach nearestStep (↑(nominalCover U)) v (v+![(n:ℤ),Δ₂,Δ₃]) := by |
| simpa only [hi,hf] using nominalCover_reach U (nominal_speed m n hn ht v Δ₂ Δ₃ hΔ₂ hΔ₃ w) |
| obtain ⟨p,hp,hattach⟩ := periodic_good_detour hK R B |
| (small_star_of_no_large (by omega) B hB.1) (nominalCover U) hv hw hB.2 hwalk |
| exact ⟨⟨p,hp,fun x hx ↦ (hattach x hx).1⟩,fun x hx ↦ (hattach x hx).2⟩ |
|
|
| def detourSample {K m n : ℕ} [NeZero K] (hK : 2<K) (R : ℕ) |
| (hn : 0<n) (ht : n/2≤3^m) (v : Vertex) (Δ₂ Δ₃ : ℤ) |
| (hΔ₂ : |Δ₂|≤2*n) (hΔ₃ : |Δ₃|≤2*n) (B : Finset (DiscreteTorus K)) |
| (hB : acceptedEnvironment (R+2) B v (v+![(n:ℤ),Δ₂,Δ₃])) (w : PairNoise m) : |
| SimpleGoodPath B (torusProjection K v) (torusProjection K (v+![(n:ℤ),Δ₂,Δ₃])) := |
| Classical.choose (exists_nominal_detour hK R hn ht v Δ₂ Δ₃ hΔ₂ hΔ₃ B hB w) |
|
|
| lemma detourSample_attachment {K m n : ℕ} [NeZero K] (hK : 2<K) (R : ℕ) |
| (hn : 0<n) (ht : n/2≤3^m) (v : Vertex) (Δ₂ Δ₃ : ℤ) |
| (hΔ₂ : |Δ₂|≤2*n) (hΔ₃ : |Δ₃|≤2*n) (B : Finset (DiscreteTorus K)) |
| (hB : acceptedEnvironment (R+2) B v (v+![(n:ℤ),Δ₂,Δ₃])) (w : PairNoise m) : |
| ∀ x∈(detourSample hK R hn ht v Δ₂ Δ₃ hΔ₂ hΔ₃ B hB w).val.support, |
| x∈(nominalCover (nominalVertices m n v Δ₂ Δ₃ w)).image (torusProjection K) ∨ |
| shellAttachment R B ((nominalCover (nominalVertices m n v Δ₂ Δ₃ w)).image (torusProjection K)) x := |
| Classical.choose_spec (exists_nominal_detour hK R hn ht v Δ₂ Δ₃ hΔ₂ hΔ₃ B hB w) |
|
|
| def goodPathKernel {K m n : ℕ} [NeZero K] (hK : 2<K) (R : ℕ) |
| (hn : 0<n) (ht : n/2≤3^m) (v : Vertex) (Δ₂ Δ₃ : ℤ) |
| (hΔ₂ : |Δ₂|≤2*n) (hΔ₃ : |Δ₃|≤2*n) (B : Finset (DiscreteTorus K)) |
| (hB : acceptedEnvironment (R+2) B v (v+![(n:ℤ),Δ₂,Δ₃])) : |
| PMF (SimpleGoodPath B (torusProjection K v) (torusProjection K (v+![(n:ℤ),Δ₂,Δ₃]))) := |
| (pairLaw m).map (detourSample hK R hn ht v Δ₂ Δ₃ hΔ₂ hΔ₃ B hB) |
|
|
| lemma pmf_map_expectation {α β : Type*} (μ : PMF α) (f : α → β) (g : β → ℝ≥0∞) : |
| (∑' y, (μ.map f) y*g y)=∑' x, μ x*g (f x) := by |
| simp_rw [PMF.map_apply,← ENNReal.tsum_mul_right] |
| rw [ENNReal.tsum_comm] |
| apply tsum_congr |
| intro x |
| simp only [ite_mul,zero_mul] |
| simp |
|
|
| def pathNoiseTranspose (m : ℕ) : FourNoise m ≃ PairNoise m × PairNoise m where |
| toFun w := (firstPathNoise w,secondPathNoise w) |
| invFun w := ((w.1.1,w.2.1),(w.1.2,w.2.2)) |
| left_inv _ := rfl |
| right_inv _ := rfl |
|
|
| lemma fourLaw_transpose (m : ℕ) (w : FourNoise m) : |
| fourLaw m w=pairLaw m (firstPathNoise w)*pairLaw m (secondPathNoise w) := by |
| rcases w with ⟨⟨a,b⟩,⟨c,d⟩⟩ |
| simp only [fourLaw,pairLaw,firstPathNoise,secondPathNoise,independentPair_apply] |
| ring |
|
|
| lemma pair_expectation_transpose (m : ℕ) (f : PairNoise m → PairNoise m → ℝ≥0∞) : |
| (∑' x, pairLaw m x*∑' y, pairLaw m y*f x y)= |
| ∑' w, fourLaw m w*f (firstPathNoise w) (secondPathNoise w) := by |
| simp_rw [← ENNReal.tsum_mul_left,← mul_assoc] |
| rw [← ENNReal.tsum_prod] |
| have h := (pathNoiseTranspose m).tsum_eq (fun z ↦ pairLaw m z.1*pairLaw m z.2*f z.1 z.2) |
| calc |
| _ = ∑' w, pairLaw m (firstPathNoise w)*pairLaw m (secondPathNoise w)*f (firstPathNoise w) (secondPathNoise w) := h.symm |
| _ = _ := by simp_rw [fourLaw_transpose] |
|
|
| end HardSphere.Lattice |
|
|
| end |
|
|
| end OAI |
|
|
