| 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 |
| namespace HardSphere.Lattice |
|
|
| lemma geometricEnvelope_ne_top (A R : ℕ) (b q : ℝ≥0∞) (hb : b≠⊤) (hq : q<1) |
| (z : ℤ×ℤ) : radiusEnvelope (geometricRadiusWeights A R b q) z≠⊤ := by |
| rw [geometricRadiusWeights_envelope] |
| apply ENNReal.add_ne_top.mpr |
| constructor |
| · split_ifs <;> simp_all |
| · apply ne_top_of_le_ne_top (b:=∑' m : ℕ, q^(m+1)) |
| · have he : (∑' m : ℕ, q^(m+1))=q*(∑' m : ℕ,q^m) := by |
| simp_rw [pow_succ',ENNReal.tsum_mul_left] |
| rw [he,ENNReal.tsum_geometric] |
| exact ENNReal.mul_ne_top (ne_of_lt (hq.trans (by norm_num))) |
| (ENNReal.inv_ne_top.mpr (ne_of_gt (tsub_pos_iff_lt.mpr hq))) |
| · exact ENNReal.tsum_le_tsum fun m ↦ by split_ifs <;> simp |
|
|
| def candidateConstant (a : ℕ) : ℕ := (2*(a+3)+1)^3*2^((2*a+1)^3)+(12*a+24) |
|
|
| def encounterConstant (R : ℕ) : ℕ := 343*(2*R+1)^3 |
|
|
| lemma candidateConstant_growth (a : ℕ) : |
| (2*(a+3)+1)^3*2^((2*a+1)^3)≤candidateConstant a := Nat.le_add_right _ _ |
|
|
| lemma candidateConstant_radius (a : ℕ) : 12*a+24≤candidateConstant a := Nat.le_add_left _ _ |
|
|
| lemma encounterConstant_detour (R : ℕ) : 52*(2*R+1)^3≤encounterConstant R := by |
| exact Nat.mul_le_mul_right _ (by norm_num) |
|
|
| theorem nominal_potential_bound {K m n : ℕ} [NeZero K] (R : ℕ) |
| (hn : 0<n) (hnK : 2*n≤K) (ht : n/2≤3^m) |
| (v : Vertex) (Δ₂ Δ₃ : ℤ) (hΔ₂ : |Δ₂|≤2*n) (hΔ₃ : |Δ₃|≤2*n) |
| (w : FourNoise m) (κ t : ℝ) (hκ : 0≤κ) (ht0 : 0≤t) |
| (hqt : (candidateConstant (R+2):ℝ)*t<1) : |
| let U := nominalVertices m n v Δ₂ Δ₃ (firstPathNoise w) |
| let U' := nominalVertices m n v Δ₂ Δ₃ (secondPathNoise w) |
| let Γ := (nominalCover U).image (torusProjection K) |
| let Γ' := (nominalCover U').image (torusProjection K) |
| let weights := geometricRadiusWeights (candidateConstant (R+2)) (4*(R+6)) |
| (ENNReal.ofReal ((encounterConstant R:ℝ)*κ)) |
| (ENNReal.ofReal ((candidateConstant (R+2):ℝ)*t)) |
| κ*((encounterSet (torusNear K R) Γ Γ').card:ℝ)+ |
| (∑ F∈candidateSets (torusRangeGraph K (R+2)), |
| if torusContact (R+2) F Γ ∧ torusContact (R+2) F Γ' then t^F.card else 0) ≤ |
| ∑ j∈Finset.range (n+1), radiusPotential weights (differenceAt m (min j (n-j)) w) := by |
| classical |
| dsimp only |
| let U := nominalVertices m n v Δ₂ Δ₃ (firstPathNoise w) |
| let U' := nominalVertices m n v Δ₂ Δ₃ (secondPathNoise w) |
| let Γ := (nominalCover U).image (torusProjection K) |
| let Γ' := (nominalCover U').image (torusProjection K) |
| let A := candidateConstant (R+2) |
| let C := encounterConstant R |
| let weights := geometricRadiusWeights A (4*(R+6)) (ENNReal.ofReal ((C:ℝ)*κ)) |
| (ENNReal.ofReal ((A:ℝ)*t)) |
| let z (i : Fin (n+1)) := differenceAt m (min i.val (n-i.val)) w |
| have hspeed := nominal_speed m n hn ht v Δ₂ Δ₃ hΔ₂ hΔ₃ (secondPathNoise w) |
| have hfirst := nominal_first m n v Δ₂ Δ₃ (firstPathNoise w) |
| have hfirst' := nominal_first m n v Δ₂ Δ₃ (secondPathNoise w) |
| have hnear (r : ℕ) (i : Fin (n+1)) : |
| torusNear K r (torusProjection K (U i)) (torusProjection K (U' i)) ↔ z i∈square r := |
| nominal_near_iff m r hnK ht v Δ₂ Δ₃ w i |
| have hN := nominal_encounter_bound R hnK U U' (v 0) hfirst hfirst' hspeed Γ Γ' |
| (fun _ hx ↦ nominalCover_projection U hx) (fun _ hx ↦ nominalCover_projection U' hx) |
| have hNen : ENNReal.ofReal (κ*((encounterSet (torusNear K R) Γ Γ').card:ℝ))≤ |
| ∑ i : Fin (n+1), if z i∈square (4*(R+6)) then ENNReal.ofReal ((C:ℝ)*κ) else 0 := by |
| calc |
| _ ≤ ENNReal.ofReal ((C:ℝ)*κ* |
| ((Finset.univ.filter (fun i ↦ torusNear K (4*(R+6)) |
| (torusProjection K (U i)) (torusProjection K (U' i)))).card:ℝ)) := by |
| apply ENNReal.ofReal_le_ofReal |
| have hN' : ((encounterSet (torusNear K R) Γ Γ').card:ℝ)≤ |
| (C:ℝ)*((Finset.univ.filter (fun i ↦ torusNear K (4*(R+6)) |
| (torusProjection K (U i)) (torusProjection K (U' i)))).card:ℝ) := by exact_mod_cast hN |
| nlinarith |
| _ = _ := by |
| rw [ENNReal.ofReal_mul (mul_nonneg (Nat.cast_nonneg _) hκ),ENNReal.ofReal_natCast] |
| simp_rw [← hnear] |
| rw [← Finset.sum_filter] |
| simp only [Finset.sum_const,nsmul_eq_mul] |
| rw [mul_comm] |
| have hF := contact_candidate_potential (R+2) hnK U U' (v 0) hfirst hfirst' hspeed Γ Γ' |
| (fun _ hx ↦ nominalCover_projection U hx) (fun _ hx ↦ nominalCover_projection U' hx) (ENNReal.ofReal t) |
| have hFen : ENNReal.ofReal (∑ F∈candidateSets (torusRangeGraph K (R+2)), |
| if torusContact (R+2) F Γ ∧ torusContact (R+2) F Γ' then t^F.card else 0)≤ |
| ∑ i : Fin (n+1), ∑' l : ℕ, if z i∈square (A*(l+1)) |
| then (ENNReal.ofReal ((A:ℝ)*t))^(l+1) else 0 := by |
| have hcast : ENNReal.ofReal (∑ F∈candidateSets (torusRangeGraph K (R+2)), |
| if torusContact (R+2) F Γ ∧ torusContact (R+2) F Γ' then t^F.card else 0)= |
| ∑ F∈candidateSets (torusRangeGraph K (R+2)), |
| if torusContact (R+2) F Γ ∧ torusContact (R+2) F Γ' then (ENNReal.ofReal t)^F.card else 0 := by |
| rw [ENNReal.ofReal_sum_of_nonneg (by intro F _; split_ifs <;> positivity)] |
| apply Finset.sum_congr rfl |
| intro F _ |
| split_ifs <;> simp [ENNReal.ofReal_pow ht0] |
| rw [hcast] |
| refine hF.trans (Finset.sum_le_sum fun i _ ↦ ENNReal.tsum_le_tsum fun l ↦ ?_) |
| by_cases h : torusNear K ((12*(R+2)+24)*(l+1)) (torusProjection K (U i)) (torusProjection K (U' i)) |
| · have hz : z i∈square (A*(l+1)) := (hnear _ i).mp |
| (torusNear_mono (Nat.mul_le_mul_right _ (candidateConstant_radius (R+2))) h) |
| rw [ite_eq_left h,ite_eq_left hz] |
| apply pow_le_pow_left' |
| rw [ENNReal.ofReal_mul (Nat.cast_nonneg _),ENNReal.ofReal_natCast] |
| apply mul_le_mul' _ le_rfl |
| exact_mod_cast candidateConstant_growth (R+2) |
| · rw [ite_eq_right h]; exact zero_le |
| have hfinite (i : Fin (n+1)) : radiusEnvelope weights (z i)≠⊤ := by |
| apply geometricEnvelope_ne_top _ _ _ _ ENNReal.ofReal_ne_top |
| exact (ENNReal.ofReal_lt_one).mpr hqt |
| have hbound := add_le_add hNen hFen |
| rw [← Finset.sum_add_distrib] at hbound |
| have hrw (i : Fin (n+1)) : |
| (if z i∈square (4*(R+6)) then ENNReal.ofReal ((C:ℝ)*κ) else 0)+ |
| (∑' l : ℕ, if z i∈square (A*(l+1)) then (ENNReal.ofReal ((A:ℝ)*t))^(l+1) else 0)= |
| ENNReal.ofReal (radiusPotential weights (z i)) := by |
| rw [radiusPotential,ENNReal.ofReal_toReal (hfinite i)] |
| exact (geometricRadiusWeights_envelope _ _ _ _ _).symm |
| simp_rw [hrw] at hbound |
| rw [← ENNReal.ofReal_sum_of_nonneg (fun i _ ↦ radiusPotential_nonneg weights (z i))] at hbound |
| rw [← ENNReal.ofReal_add (mul_nonneg hκ (Nat.cast_nonneg _)) |
| (Finset.sum_nonneg (by intro F _; split_ifs <;> positivity))] at hbound |
| have hreal := (ENNReal.ofReal_le_ofReal_iff (Finset.sum_nonneg |
| (fun i _ ↦ radiusPotential_nonneg weights (z i)))).mp hbound |
| dsimp only [z] at hreal |
| rw [Fin.sum_univ_eq_sum_range (fun j ↦ radiusPotential weights (differenceAt m (min j (n-j)) w)) (n+1)] at hreal |
| exact hreal |
|
|
| end HardSphere.Lattice |
|
|
| open scoped ENNReal |
| namespace HardSphere.Lattice |
| universe u |
| variable {V : Type u} [Fintype V] [DecidableEq V] |
| omit [Fintype V] in |
|
|
| lemma prod_one_add_ofReal_le_exp_sum {I : Type*} (Q : Finset I) (w : I → ℝ) |
| (hw : ∀ i ∈ Q, 0 ≤ w i) : |
| ∏ i ∈ Q, (1 + ENNReal.ofReal (w i)) ≤ |
| ENNReal.ofReal (Real.exp (∑ i ∈ Q, w i)) := by |
| classical |
| induction Q using Finset.induction_on with |
| | empty => simp |
| | @insert i Q hi ih => |
| rw [Finset.prod_insert hi, Finset.sum_insert hi, Real.exp_add, |
| ENNReal.ofReal_mul (Real.exp_pos _).le] |
| have hwi := hw i (Finset.mem_insert_self i Q) |
| have hQ : ∀ j ∈ Q, 0 ≤ w j := fun j hj ↦ hw j (Finset.mem_insert_of_mem hj) |
| apply mul_le_mul' _ (ih hQ) |
| rw [← ENNReal.ofReal_one, ← ENNReal.ofReal_add (by norm_num) hwi] |
| exact ENNReal.ofReal_le_ofReal (by simpa [add_comm] using Real.add_one_le_exp (w i)) |
|
|
| theorem badComponents_exponential_bound (G : SimpleGraph V) |
| (μ : PMF (Finset V)) (p β : ℝ) (hp : 0 ≤ p) |
| (hbad : JointBadLaw μ (ENNReal.ofReal p)) (P : Finset V → Prop) : |
| (∑' B, μ B * ENNReal.ofReal (Real.exp |
| (β * ∑ F∈badComponents G B, if P F then (F.card:ℝ) else 0))) ≤ |
| ENNReal.ofReal (Real.exp (∑ F∈candidateSets G, |
| if P F then (p * Real.exp β)^F.card else 0)) := by |
| let w : Finset V → ℝ≥0∞ := fun F ↦ if P F then |
| ENNReal.ofReal (Real.exp (β * (F.card:ℝ))) else 0 |
| have hpoint (B : Finset V) : |
| ENNReal.ofReal (Real.exp |
| (β * ∑ F∈badComponents G B, if P F then (F.card:ℝ) else 0)) ≤ |
| ∏ F∈badComponents G B, (1+w F) := by |
| rw [Finset.mul_sum, Real.exp_sum] |
| rw [ENNReal.ofReal_prod_of_nonneg (fun _ _ ↦ (Real.exp_pos _).le)] |
| apply Finset.prod_le_prod |
| intro F _ |
| by_cases h : P F |
| · simp only [ite_eq_left h,w] |
| exact le_add_self |
| · simp only [ite_eq_right h,w,mul_zero,Real.exp_zero,ENNReal.ofReal_one,add_zero] |
| exact le_rfl |
| calc |
| _ ≤ ∑' B, μ B * ∏ F∈badComponents G B, (1+w F) := by |
| exact ENNReal.tsum_le_tsum fun B ↦ mul_le_mul' le_rfl (hpoint B) |
| _ ≤ ∏ F∈candidateSets G, (1+(ENNReal.ofReal p)^F.card*w F) := |
| environment_product_bound μ _ hbad (badComponents G) |
| (badComponents_disjoint G) (fun B F hF ↦ badComponents_subset G B hF) |
| (candidateSets G) (badComponents_candidate G) w |
| _ = ∏ F∈candidateSets G, |
| (1+ENNReal.ofReal (if P F then (p*Real.exp β)^F.card else 0)) := by |
| apply Finset.prod_congr rfl |
| intro F _ |
| dsimp only [w] |
| by_cases h : P F |
| · simp only [ite_eq_left h] |
| rw [← ENNReal.ofReal_pow hp,← ENNReal.ofReal_mul (pow_nonneg hp _), |
| mul_comm β (F.card:ℝ),Real.exp_nat_mul,mul_pow] |
| · simp only [ite_eq_right h,mul_zero,ENNReal.ofReal_zero] |
| _ ≤ _ := prod_one_add_ofReal_le_exp_sum _ _ (by |
| intro F _ |
| split_ifs |
| · exact pow_nonneg (mul_nonneg hp (Real.exp_pos _).le) _ |
| · exact le_rfl) |
|
|
| end HardSphere.Lattice |
|
|
| end |
|
|
| end OAI |
|
|
