| import Mathlib |
| import OAI.Geometry.Cannon.Flows.GoodCandidates |
| import OAI.Geometry.Cannon.Modulus.AnnularNet |
| import OAI.Geometry.Cannon.CirclePacking.Radius |
|
|
| namespace OAI |
|
|
| section |
| section |
| section |
| noncomputable section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| section |
| namespace CannonNode |
|
|
| open Set Metric |
|
|
| structure SourceNode {X : Type*} [MetricSpace X] (f : X → ℝ) (x₀ : X) |
| (ε ell c₀ B : ℝ) (kmin : ℕ) where |
| center : X |
| depth : ℕ |
| lowerDepth : kmin ≤ depth |
| a : ℝ |
| b : ℝ |
| apos : 0 < a |
| ab : a < b |
| bone : b < 1 |
| straddle : lower f center (c₀*radius ell depth) ≤ a ∧ |
| b ≤ upper f center (c₀*radius ell depth) |
| reserve : dist center x₀+2*B*radius ell depth ≤ ε |
|
|
| variable {X : Type*} [MetricSpace X] {f : X → ℝ} {x₀ : X} |
| {ε ell c₀ B : ℝ} {kmin : ℕ} |
|
|
| namespace SourceNode |
|
|
| def length (v : SourceNode f x₀ ε ell c₀ B kmin) : ℝ := v.b-v.a |
|
|
| lemma length_pos (v : SourceNode f x₀ ε ell c₀ B kmin) : 0 < v.length := sub_pos.mpr v.ab |
|
|
| def child (v : SourceNode f x₀ ε ell c₀ B kmin) (D : ℕ) (y : X) |
| (hB : 0 ≤ B) (hθ : radius ell D ≤ 1/2) |
| (hy : dist y v.center ≤ B*radius ell v.depth) |
| (ht : 0 < fraction v.a v.b (lower f y (c₀*radius ell (v.depth+D))) |
| (upper f y (c₀*radius ell (v.depth+D)))) : |
| SourceNode f x₀ ε ell c₀ B kmin where |
| center := y |
| depth := v.depth+D |
| lowerDepth := v.lowerDepth.trans (Nat.le_add_right _ _) |
| a := childLower v.a (lower f y (c₀*radius ell (v.depth+D))) |
| b := childUpper v.b (upper f y (c₀*radius ell (v.depth+D))) |
| apos := v.apos.trans_le (le_max_left _ _) |
| ab := (fraction_pos_iff v.ab).mp ht |
| bone := (min_le_left _ _).trans_lt v.bone |
| straddle := ⟨le_max_right _ _,min_le_right _ _⟩ |
| reserve := by |
| have hR := radius_pos ell v.depth |
| have htR := mul_le_mul_of_nonneg_right hθ hR.le |
| have hB' := mul_le_mul_of_nonneg_left htR (mul_nonneg (by norm_num : (0:ℝ) ≤ 2) hB) |
| have htri := dist_triangle y v.center x₀ |
| rw [radius_add] |
| nlinarith only [v.reserve,hy,htri,hB'] |
|
|
| lemma child_length (v : SourceNode f x₀ ε ell c₀ B kmin) (D : ℕ) (y : X) |
| (hB : 0 ≤ B) (hθ : radius ell D ≤ 1/2) |
| (hy : dist y v.center ≤ B*radius ell v.depth) |
| (ht : 0 < fraction v.a v.b (lower f y (c₀*radius ell (v.depth+D))) |
| (upper f y (c₀*radius ell (v.depth+D)))) : |
| (v.child D y hB hθ hy ht).length = v.length * |
| fraction v.a v.b (lower f y (c₀*radius ell (v.depth+D))) |
| (upper f y (c₀*radius ell (v.depth+D))) := by |
| exact positive_child_length v.ab ht |
|
|
| lemma center_mem (v : SourceNode f x₀ ε ell c₀ B kmin) (hB : 0 ≤ B) : |
| v.center ∈ closedBall x₀ ε := by |
| have hh : 0 ≤ 2*B*radius ell v.depth := mul_nonneg (mul_nonneg (by norm_num) hB) (radius_pos ell v.depth).le |
| exact mem_closedBall.mpr (by linarith only [v.reserve,hh]) |
|
|
| lemma root (k : ℕ) (hk : kmin ≤ k) (a b : ℝ) (ha : 0 < a) |
| (hab : a < b) (hb : b < 1) |
| (hs : lower f x₀ (c₀*radius ell k) ≤ a ∧ b ≤ upper f x₀ (c₀*radius ell k)) |
| (hroom : 2*B*radius ell k ≤ ε) : |
| Nonempty (SourceNode f x₀ ε ell c₀ B kmin) := |
| ⟨⟨x₀,k,hk,a,b,ha,hab,hb,hs,by simpa only [dist_self,zero_add] using hroom⟩⟩ |
|
|
| end SourceNode |
|
|
| end CannonNode |
|
|
| end |
|
|
| section |
|
|
| open Set Metric |
|
|
| namespace CannonMagnification |
|
|
| def Expansion {X : Type*} [MetricSpace X] (h : X ≃ₜ X) (x : X) |
| (r C L : ℝ) : Prop := |
| ∀ y z, |
| dist (h y) (h z) * max r (dist x y) * max r (dist x z) ≤ C*r*dist y z ∧ |
| r*dist y z ≤ L*dist (h y) (h z) * max r (dist x y) * max r (dist x z) |
|
|
| lemma expansion_ball_bounds {X : Type*} [MetricSpace X] (h : X ≃ₜ X) |
| (x : X) (r C L B : ℝ) (hr : 0 < r) (hL : 0 < L) (hB : 1 ≤ B) |
| (hexp : Expansion h x r C L) (y z : X) |
| (hy : dist y x ≤ B*r) (hz : dist z x ≤ B*r) : |
| dist (h y) (h z) ≤ C/r*dist y z ∧ |
| (1/(L*B^2))/r*dist y z ≤ dist (h y) (h z) := by |
| have hE : 0 ≤ dist (h y) (h z) := dist_nonneg |
| have hBr : r ≤ B*r := by nlinarith |
| have hby : max r (dist x y) ≤ B*r := max_le hBr (by simpa only [dist_comm] using hy) |
| have hbz : max r (dist x z) ≤ B*r := max_le hBr (by simpa only [dist_comm] using hz) |
| have hmy : 0 ≤ max r (dist x y) := hr.le.trans (le_max_left _ _) |
| have hmz : 0 ≤ max r (dist x z) := hr.le.trans (le_max_left _ _) |
| have h₁ : dist (h y) (h z)*r*r ≤ C*r*dist y z := by |
| exact (mul_le_mul (mul_le_mul_of_nonneg_left (le_max_left _ _) hE) |
| (le_max_left _ _) hr.le (mul_nonneg hE hmy)).trans (hexp y z).1 |
| have h₂ : r*dist y z ≤ L*dist (h y) (h z)*(B*r)*(B*r) := by |
| exact (hexp y z).2.trans (mul_le_mul (mul_le_mul_of_nonneg_left hby (mul_nonneg hL.le hE)) |
| hbz hmz (by positivity)) |
| constructor |
| · rw [div_mul_eq_mul_div] |
| apply (le_div_iff₀ hr).mpr |
| have hh : (dist (h y) (h z)*r)*r ≤ (C*dist y z)*r := by nlinarith [h₁] |
| exact (mul_le_mul_iff_left₀ hr).mp hh |
| · have hden : 0 < L*B^2*r := mul_pos (mul_pos hL (sq_pos_of_pos (zero_lt_one.trans_le hB))) hr |
| have hraw : dist y z ≤ dist (h y) (h z)*(L*B^2*r) := by |
| apply (mul_le_mul_iff_left₀ hr).mp |
| nlinarith [h₂] |
| have hdiv : dist y z/(L*B^2*r) ≤ dist (h y) (h z) := (div_le_iff₀ hden).mpr hraw |
| convert hdiv using 1; ring |
| |
| end CannonMagnification |
| |
| end |
| |
| section |
| |
| open Set Metric |
| |
| namespace CannonNode |
| |
| open Set Metric |
| |
| theorem node_level_hits {X : Type*} [MetricSpace X] [ProperSpace X] |
| (f : X → ℝ) (Ω : Set X) (K : ℝ → Set X) (x : X) (R c₀ L a b : ℝ) |
| (hR : 0 < R) (hc₀ : 0 < c₀) (hL : 1 ≤ L) |
| (hf : ContinuousOn f Ω) (hloc : closedBall x (L*c₀*R) ⊆ Ω) |
| (hnode : lower f x (c₀*R) ≤ a ∧ b ≤ upper f x (c₀*R)) |
| (hpaths : ∀ u v, u ∈ closedBall x (c₀*R) → v ∈ closedBall x (c₀*R) → |
| JoinedIn (ball x (L*c₀*R)) u v) |
| (hhit : ∀ t ∈ Ioo a b, ∀ u v, ∀ p : Path u v, Set.range p ⊆ Ω → |
| f u < t → t < f v → (K t ∩ Set.range p).Nonempty) : |
| ∀ t ∈ Ioo a b, ∃ y ∈ K t, dist y x ≤ L*c₀*R := by |
| have hsub : closedBall x (c₀*R) ⊆ closedBall x (L*c₀*R) := |
| closedBall_subset_closedBall (by nlinarith only [hL,mul_pos hc₀ hR]) |
| obtain ⟨⟨u,hu,huv⟩,⟨v,hv,hvv⟩⟩ := ball_extrema (mul_pos hc₀ hR).le (hf.mono (hsub.trans hloc)) |
| obtain ⟨p,hp⟩ := hpaths u v hu hv |
| have hpΩ : range p ⊆ Ω := by |
| rintro _ ⟨t,rfl⟩ |
| exact hloc (ball_subset_closedBall (hp t)) |
| intro t ht |
| have hu' : f u < t := by rw [huv]; exact hnode.1.trans_lt ht.1 |
| have hv' : t < f v := by rw [hvv]; exact ht.2.trans_le hnode.2 |
| obtain ⟨z,hz,⟨s,rfl⟩⟩ := hhit t ht u v p hpΩ hu' hv' |
| exact ⟨p s,hz,(mem_ball.mp (hp s)).le⟩ |
|
|
| lemma exists_node_interval {X : Type*} [MetricSpace X] [ProperSpace X] |
| (f : X → ℝ) (x : X) (r : ℝ) (hr : 0 ≤ r) |
| (hf : ContinuousOn f (closedBall x r)) |
| (hunit : ∀ y ∈ closedBall x r, f y ∈ Icc (0:ℝ) 1) |
| (hvar : ∃ y ∈ closedBall x r, ∃ z ∈ closedBall x r, f y ≠ f z) : |
| ∃ a b : ℝ, 0 < a ∧ a < b ∧ b < 1 ∧ lower f x r < a ∧ b < upper f x r := by |
| obtain ⟨⟨v,hv,hvv⟩,⟨w,hw,hww⟩⟩ := ball_extrema hr hf |
| have hlu : lower f x r < upper f x r := by |
| obtain ⟨y,hy,z,hz,hneq⟩ := hvar |
| have hylu := ball_range hf hy |
| have hzlu := ball_range hf hz |
| by_contra hn |
| have hh := le_of_not_gt hn |
| have hyz : f y=f z := by linarith only [hylu.1,hylu.2,hzlu.1,hzlu.2,hh] |
| exact hneq hyz |
| have hl : 0 ≤ lower f x r := by rw [← hvv]; exact (hunit v hv).1 |
| have hu : upper f x r ≤ 1 := by rw [← hww]; exact (hunit w hw).2 |
| refine ⟨(2*lower f x r+upper f x r)/3,(lower f x r+2*upper f x r)/3,?_,?_,?_,?_,?_⟩ <;> |
| linarith only [hlu,hl,hu] |
| |
| end CannonNode |
| |
| end |
| |
| namespace CannonNode |
| |
| open Set Metric Finset Filter Topology CannonPacking CannonAnnular CannonMagnification |
| |
| attribute [local instance] Classical.propDecidable |
| |
| def LiteralGood {X : Type*} [MetricSpace X] (f : X → ℝ) (Y : Finset X) |
| (c₀ r a b κ : ℝ) : Prop := |
| GoodCandidates (fun y : Y => lower f y (2*r)) (fun y : Y => upper f y (2*r)) |
| (fun y : Y => lower f y (c₀*r)) (fun y : Y => upper f y (c₀*r)) a b κ |
|
|
| def LiteralTransitions {X : Type*} [MetricSpace X] (f : X → ℝ) (Y : Finset X) |
| (c₀ r a b κ H L Qg Qb : ℝ) : Prop := |
| ∃ S : Finset Y, |
| (∀ y ∈ S, 0 < fraction a b (lower f y (c₀*r)) (upper f y (c₀*r))) ∧ |
| (∀ y ∈ S, ∀ z ∈ S, y ≠ z → H*r < dist (y:X) z) ∧ |
| ∃ p : S → ℝ, (∀ y, 0 < p y) ∧ (∑ y, p y = 1) ∧ |
| (∀ y, p y ≤ L*fraction a b (lower f (y.val:X) (c₀*r)) (upper f (y.val:X) (c₀*r))) ∧ |
| ∀ y, p y ≤ (if LiteralGood f Y c₀ r a b κ then Qg else Qb)* |
| (fraction a b (lower f (y.val:X) (c₀*r)) (upper f (y.val:X) (c₀*r)))^2 |
|
|
| lemma candidate_slack {X : Type*} [MetricSpace X] (Q : ℕ) (CP B ell : ℝ) |
| (hCP : 0 ≤ CP) (hB : 0 ≤ B) (D : ℕ) : |
| ∃ κ : ℝ, 0 < κ ∧ ∀ (Y : Finset X) (R r : ℝ), 0 < r → |
| (Y.card:ℝ) ≤ CP*((B+1)*R/r)^Q → R/r=Real.exp (ell*D) → |
| (Y.card:ℝ)*κ ≤ 1/8 := by |
| let C := CP*(B+1)^Q |
| have hC : 0 ≤ C := by dsimp [C]; positivity |
| let E := Real.exp (ell*D)^Q |
| have hE : 0 < E := pow_pos (Real.exp_pos _) _ |
| let κ := 1/(8*max C 1*E) |
| have hmax : 0 < max C 1 := zero_lt_one.trans_le (le_max_right _ _) |
| have hden : 0 < 8*max C 1*E := by positivity |
| refine ⟨κ,one_div_pos.mpr hden,?_⟩ |
| intro Y R r _hr hcard hratio |
| have hcard' : (Y.card:ℝ) ≤ C*E := by |
| convert hcard using 1 |
| rw [mul_div_assoc, hratio,mul_pow] |
| dsimp [C,E] |
| ring |
| have hh : (Y.card:ℝ) ≤ max C 1*E := hcard'.trans |
| (mul_le_mul_of_nonneg_right (le_max_left _ _) hE.le) |
| change (Y.card:ℝ)*(1/(8*max C 1*E)) ≤ 1/8 |
| rw [mul_one_div] |
| apply (div_le_iff₀ hden).mpr |
| nlinarith only [hh] |
|
|
| theorem eventually_scaled_subdivision {X : Type*} [MetricSpace X] [CompactSpace X] |
| [LocallyPathConnectedSpace X] (qdim : ℕ) (CP A B H c₀ C LE d₀ ell : ℝ) |
| (hpack : PolynomialPacking (X:=X) qdim CP) (hCP : 0 ≤ CP) |
| (hA : 1 ≤ A) (hAB : A+3 ≤ B) (hH : 0 < H) (hc₀ : 2 ≤ c₀) |
| (hC : 0 ≤ C) (hLE : 0 < LE) (hdc : d₀ ≤ 1/(9*LE)) (hell : 0 < ell) |
| (M : ℕ → ℝ) (hMnon : ∀ j, 0 ≤ M j) |
| (hM : ∀ lam : ℝ, 1 < lam → ∃ C : ℝ, 0 < C ∧ ∀ j, M j ≤ C*lam^j) |
| (δ : ℕ → Type*) [∀ j, Fintype (δ j)] (ξ : ∀ j, δ j → X) |
| (hξ : ∀ j i i', i ≠ i' → radius ell j ≤ dist (ξ j i) (ξ j i')) |
| (ω : ∀ j, δ j → ℝ) (hω : ∀ j, MacroscopicAdmissible (ξ j) (radius ell j) d₀ (ω j)) |
| (hωmass : ∀ j, (∑ i, (ω j i)^2) ≤ M j) |
| (h : X → ℕ → X ≃ₜ X) |
| (hexp : ∀ x k, Expansion (h x k) x (radius ell k) C LE) : |
| ∀ᶠ n : ℕ in atTop, 0 < n ∧ radius ell (160*(qdim+1)*n) < 1/4 ∧ |
| ∃ κ : ℝ, 0 < κ ∧ ∀ (x : X) (k : ℕ) (Y : Finset X) |
| (Ω : Set X) (f : X → ℝ) (K : ℝ → Set X) (a b : ℝ), |
| let R := radius ell k |
| let r := radius ell (k+160*(qdim+1)*n) |
| a < b → (B+1)*R ≤ 1 → max H 1*R ≤ 1 → 3*R ≤ 1 → |
| (∀ y ∈ Y, (A-1)*R ≤ dist y x ∧ dist y x ≤ (B+1)*R) → |
| (∀ y ∈ Y, ∀ z ∈ Y, y ≠ z → r ≤ dist y z) → |
| (∀ v, (A-1)*R ≤ dist v x → dist v x ≤ (B+1)*R → ∃ y ∈ Y, dist v y ≤ r) → |
| (∀ v, dist v x ≤ (B+2)*R → v ∈ Ω) → ContinuousOn f Ω → |
| (∀ v ∈ Ioo a b, IsPreconnected (K v)) → |
| (∀ v ∈ Ioo a b, ∃ y ∈ K v, dist y x ≤ A*R) → |
| (∀ v ∈ Ioo a b, 2*B*R < diam (K v)) → |
| (∀ v ∈ Ioo a b, ∀ y ∈ K v, y ∈ Ω → f y=v) → |
| LiteralTransitions f Y c₀ r a b κ H (Real.exp (-ell*n)) |
| (Real.exp (8*(qdim+1)*ell*n)) (Real.exp (-((80*(qdim+1):ℝ)*ell*n))) := by |
| have hB : 0 ≤ B := by linarith only [hA,hAB] |
| have hc : 0 < 1/(9*LE) := by positivity |
| have hs := uniform_literal_subdivision qdim CP A B H c₀ C (1/(9*LE)) d₀ ell |
| hpack hCP hA hAB hH hc₀ hC hc hdc hell M hMnon hM |
| have hsc := eventually_flow_scales qdim ell c₀ H (max (C+2) (max (1/(9*LE)) 1)) hell |
| filter_upwards [hs,hsc] with n hn hscale |
| obtain ⟨κ,hκ,hκcount⟩ := candidate_slack (X:=X) qdim CP B ell hCP hB (160*(qdim+1)*n) |
| refine ⟨hscale.1,hscale.2.1,κ,hκ,?_⟩ |
| intro x k Y Ω f K a b |
| dsimp only |
| let R := radius ell k |
| let r := radius ell (k+160*(qdim+1)*n) |
| let s := radius ell (k+2*n) |
| have hR : 0 < R := radius_pos _ _ |
| have hr : 0 < r := radius_pos _ _ |
| have hsp : 0 < s := radius_pos _ _ |
| intro hab hRone hCone hthree hY hYsep hYnet hΩ hf hK hinner hdiam hlevel |
| have hd : 2 ≤ 160*(qdim+1) := by omega |
| have hdr : 2*n ≤ 160*(qdim+1)*n := Nat.mul_le_mul_right n hd |
| have hrs : r ≤ s := radius_antitone hell.le (Nat.add_le_add_left hdr k) |
| have hsR : s ≤ R := radius_antitone hell.le (Nat.le_add_right k (2*n)) |
| have hrR : r ≤ R := hrs.trans hsR |
| have hSR : s ≤ R/4 := by |
| dsimp [s,R] |
| rw [radius_add] |
| nlinarith only [mul_le_mul_of_nonneg_right hscale.2.2.2.2.1 hR.le] |
| have hcR : c₀*r ≤ R := by |
| dsimp [r,R] |
| rw [radius_add] |
| nlinarith only [mul_le_mul_of_nonneg_right hscale.2.2.1 hR.le] |
| have hHR : 2*((H+3)*r) ≤ R := by |
| dsimp [r,R] |
| rw [radius_add] |
| nlinarith only [mul_le_mul_of_nonneg_right hscale.2.2.2.1 hR.le] |
| have hratioS : R/s=Real.exp (2*ell*n) := by |
| dsimp [R,s] |
| rw [radius_ratio] |
| congr 1 |
| push_cast |
| ring |
| have hratioR : R/r=Real.exp ((160*(qdim+1):ℝ)*ell*n) := by |
| dsimp [R,r] |
| rw [radius_ratio] |
| congr 1 |
| push_cast |
| ring |
| have hrr : r/s=radius ell ((160*(qdim+1)-2)*n) := by |
| dsimp [r,s] |
| rw [radius_sub_ratio ell k _ _ hdr, Nat.sub_mul] |
| have hκY : (Fintype.card Y:ℝ)*κ ≤ 1/8 := by |
| rw [Fintype.card_coe] |
| apply hκcount Y R r hr |
| · exact hpack x ((B+1)*R) r hr (hrR.trans (by nlinarith only [hB,hR])) hRone Y |
| (fun y hy => by simpa only [dist_comm] using (hY y hy).2) hYsep |
| · dsimp [R,r] |
| exact radius_ratio _ _ _ |
| obtain ⟨T,hT,hTsep,hTnet⟩ := annular_net x A B R s hsp |
| have htrans : max (C+2) (max (1/(9*LE)) 1)*(r/s) ≤ 1 := by |
| rw [hrr] |
| exact hscale.2.2.2.2.2 |
| have hmap (z : T) (v v' : X) (hv : dist v (z:X) ≤ 3*s) (hv' : dist v' (z:X) ≤ 3*s) : |
| dist (h z (k+2*n) v) (h z (k+2*n) v') ≤ C/s*dist v v' ∧ |
| (1/(9*LE))/s*dist v v' ≤ dist (h z (k+2*n) v) (h z (k+2*n) v') := by |
| have hh := expansion_ball_bounds (h z (k+2*n)) z s C LE 3 hsp hLE (by norm_num) |
| (hexp z (k+2*n)) v v' hv hv' |
| simpa only [show (3 : ℝ)^2 = 9 by norm_num, mul_comm LE 9] using hh |
| have htarget : ∀ i j, i ≠ j → r/s ≤ dist (ξ ((160*(qdim+1)-2)*n) i) (ξ ((160*(qdim+1)-2)*n) j) := by |
| rw [hrr] |
| exact hξ _ |
| have hweight : MacroscopicAdmissible (ξ ((160*(qdim+1)-2)*n)) (r/s) d₀ |
| (ω ((160*(qdim+1)-2)*n)) := by rw [hrr]; exact hω _ |
| exact hn (fun y : Y => (y:X)) (fun z : T => (z:X)) (ξ ((160*(qdim+1)-2)*n)) |
| (fun z : T => h z (k+2*n)) x Ω f K a b κ R r s hab hκ hκY hR hr hsp hrs hSR hcR hHR |
| hRone ((mul_le_mul_of_nonneg_left hrR (le_max_right H 1 |>.trans' zero_le_one)).trans hCone) |
| ((mul_le_mul_of_nonneg_left hsR (by norm_num : (0:ℝ) ≤ 3)).trans hthree) htrans hratioS hratioR |
| (fun y => (hY y y.property).2) |
| (fun y z hyz => hYsep y y.property z z.property (fun he => hyz (Subtype.ext he))) |
| (fun y z hyz => hTsep y y.property z z.property (fun he => hyz (Subtype.ext he))) |
| htarget (fun z => by simpa only [dist_comm] using (hT z z.property).2) |
| (fun v hl hu => by obtain ⟨y,hy,hd⟩ := hYnet v hl hu; exact ⟨⟨y,hy⟩,by simpa only [dist_comm] using hd⟩) |
| (fun v hl hu => by obtain ⟨z,hz,hd⟩ := hTnet v hl hu; exact ⟨⟨z,hz⟩,hd⟩) |
| hΩ hf hK hinner hdiam hlevel hmap (ω ((160*(qdim+1)-2)*n)) hweight (hωmass _) |
| |
| end CannonNode |
| |
| end |
| |
| section |
| |
| section |
| |
| open Set Filter Finset |
| |
| namespace CannonFlow |
| |
| structure FiniteFlow where |
| size : ℕ → ℕ |
| parent : (n : ℕ) → Fin (size (n+1)) → Fin (size n) |
| weight : (n : ℕ) → Fin (size n) → ℝ |
| nonneg : ∀ n v, 0 ≤ weight n v |
| root_mass : ∑ v, weight 0 v = 1 |
| conserves : ∀ n v, weight n v = ∑ w, if parent n w = v then weight (n+1) w else 0 |
| good : (n : ℕ) → Fin (size n) → Prop |
|
|
| namespace FiniteFlow |
|
|
| attribute [local instance] Classical.propDecidable |
|
|
| variable (T : FiniteFlow) |
|
|
| lemma conserve_expectation (n : ℕ) (f : Fin (T.size n) → ℝ) : |
| ∑ v, T.weight n v * f v = ∑ w, T.weight (n+1) w * f (T.parent n w) := by |
| classical |
| simp_rw [T.conserves n, sum_mul] |
| rw [sum_comm] |
| apply sum_congr rfl |
| intro w hw |
| simp only [ite_mul, zero_mul] |
| simp |
|
|
| lemma total_mass (n : ℕ) : ∑ v, T.weight n v = 1 := by |
| induction n with |
| | zero => exact T.root_mass |
| | succ n ih => |
| have h := T.conserve_expectation n (fun _ => 1) |
| simpa only [mul_one] using h.symm.trans (by simpa only [mul_one] using ih) |
|
|
| def badCount : (n : ℕ) → Fin (T.size n) → ℕ |
| | 0, _ => 0 |
| | n+1, v => badCount n (T.parent n v) + if T.good n (T.parent n v) then 0 else 1 |
|
|
| def expectedBad (n : ℕ) : ℝ := ∑ v, T.weight n v * (T.badCount n v : ℝ) |
|
|
| def badMass (n : ℕ) : ℝ := ∑ v, T.weight n v * if T.good n v then 0 else 1 |
|
|
| def goodMass (n : ℕ) : ℝ := ∑ v, T.weight n v * if T.good n v then 1 else 0 |
|
|
| lemma badMass_nonneg (n : ℕ) : 0 ≤ T.badMass n := by |
| classical |
| apply sum_nonneg |
| intro v hv |
| exact mul_nonneg (T.nonneg n v) (by split_ifs <;> norm_num) |
| |
| lemma good_add_bad (n : ℕ) : T.goodMass n + T.badMass n = 1 := by |
| classical |
| unfold goodMass badMass |
| rw [← sum_add_distrib] |
| convert T.total_mass n using 1 |
| apply sum_congr rfl |
| intro v hv |
| split_ifs <;> ring |
| |
| lemma expectedBad_succ (n : ℕ) : T.expectedBad (n+1) = T.expectedBad n + T.badMass n := by |
| classical |
| unfold expectedBad badMass |
| simp only [badCount, Nat.cast_add, Nat.cast_ite, Nat.cast_zero, Nat.cast_one, mul_add, sum_add_distrib] |
| exact congrArg₂ (· + ·) |
| (T.conserve_expectation n (fun v => (T.badCount n v : ℝ))).symm |
| (T.conserve_expectation n (fun v => if T.good n v then 0 else 1)).symm |
|
|
| lemma expectedBad_eq_sum (n : ℕ) : T.expectedBad n = ∑ k ∈ range n, T.badMass k := by |
| induction n with |
| | zero => simp [expectedBad, badCount] |
| | succ n ih => rw [T.expectedBad_succ, ih, sum_range_succ] |
|
|
| lemma expectedBad_bound {c E : ℝ} (_hc : 0 < c) |
| (henergy : ∀ n, ∑ v, T.weight n v * |
| Real.exp (c * ((11 / 20 : ℝ) * T.badCount n v - (1 / 20 : ℝ) * n)) ≤ E) |
| (n : ℕ) : c * ((11 / 20 : ℝ) * T.expectedBad n - (1 / 20 : ℝ) * n) + 1 ≤ E := by |
| have htan : ∑ v, T.weight n v * |
| (c * ((11 / 20 : ℝ) * T.badCount n v - (1 / 20 : ℝ) * n) + 1) ≤ E := by |
| apply le_trans _ (henergy n) |
| apply sum_le_sum |
| intro v hv |
| exact mul_le_mul_of_nonneg_left (Real.add_one_le_exp _) (T.nonneg n v) |
| have heq : (∑ v, T.weight n v * |
| (c * ((11 / 20 : ℝ) * T.badCount n v - (1 / 20 : ℝ) * n) + 1)) = |
| c * ((11 / 20 : ℝ) * T.expectedBad n - (1 / 20 : ℝ) * n) + 1 := by |
| calc |
| _ = ∑ v, ((c * (11 / 20 : ℝ)) * (T.weight n v * T.badCount n v) + |
| (1 - c * (1 / 20 : ℝ) * n) * T.weight n v) := by |
| apply sum_congr rfl |
| intro v hv |
| ring |
| _ = _ := by rw [sum_add_distrib, ← mul_sum, ← mul_sum, T.total_mass]; unfold expectedBad; ring |
| rwa [heq] at htan |
| |
| theorem arbitrarily_late_good_levels {c E : ℝ} (hc : 0 < c) |
| (henergy : ∀ n, ∑ v, T.weight n v * |
| Real.exp (c * ((11 / 20 : ℝ) * T.badCount n v - (1 / 20 : ℝ) * n)) ≤ E) : |
| ∀ N : ℕ, ∃ n ≥ N, (1 / 2 : ℝ) ≤ T.goodMass n := by |
| classical |
| intro N |
| by_contra hn |
| have hbad : ∀ n, N ≤ n → (1 / 2 : ℝ) ≤ T.badMass n := by |
| intro n hnN |
| have hg : T.goodMass n < 1 / 2 := lt_of_not_ge (fun h => hn ⟨n,hnN,h⟩) |
| linarith [T.good_add_bad n] |
| have hlarge : ∃ n : ℕ, N ≤ n ∧ E + c * (11 / 40 : ℝ) * N < c * (9 / 40 : ℝ) * n + 1 := by |
| obtain ⟨m,hm⟩ := exists_nat_gt ((E + c * (11 / 40 : ℝ) * N) / (c * (9 / 40 : ℝ))) |
| refine ⟨max m N,le_max_right _ _,?_⟩ |
| have hd : 0 < c * (9 / 40 : ℝ) := by positivity |
| have hh : E + c * (11 / 40 : ℝ) * N < c * (9 / 40 : ℝ) * m := by simpa [mul_comm] using (div_lt_iff₀ hd).mp hm |
| have hmn : (m : ℝ) ≤ max m N := by exact_mod_cast le_max_left m N |
| nlinarith |
| obtain ⟨n,hnN,hnE⟩ := hlarge |
| have hsum : ((n - N : ℕ) : ℝ) * (1 / 2 : ℝ) ≤ T.expectedBad n := by |
| rw [T.expectedBad_eq_sum] |
| have he := sum_le_sum (s := Ico N n) (fun k hk => hbad k (mem_Ico.mp hk).1) |
| have hs : ∑ k ∈ Ico N n, T.badMass k ≤ ∑ k ∈ range n, T.badMass k := |
| sum_le_sum_of_subset_of_nonneg (by intro k hk; exact mem_range.mpr (mem_Ico.mp hk).2) |
| (fun k _ _ => T.badMass_nonneg k) |
| simpa using he.trans hs |
| rw [Nat.cast_sub hnN] at hsum |
| have hb := T.expectedBad_bound hc henergy n |
| nlinarith |
|
|
| end FiniteFlow |
|
|
| lemma probabilities_of_capacity {ι : Type*} [Fintype ι] (cap : ι → ℝ) |
| (hcap : ∀ i, 0 ≤ cap i) (hmass : 1 ≤ ∑ i, cap i) : |
| ∃ p : ι → ℝ, (∀ i, 0 ≤ p i) ∧ (∑ i, p i = 1) ∧ ∀ i, p i ≤ cap i := by |
| let S := ∑ i, cap i |
| have hS : 0 < S := lt_of_lt_of_le (by norm_num) hmass |
| refine ⟨fun i => cap i / S, fun i => div_nonneg (hcap i) hS.le, ?_, ?_⟩ |
| · rw [← Finset.sum_div] |
| exact div_self hS.ne' |
| · intro i |
| exact (div_le_iff₀ hS).mpr (by nlinarith [hcap i]) |
|
|
| lemma probabilities_of_mixed_capacity {ι : Type*} [Fintype ι] |
| (t : ι → ℝ) {L Q : ℝ} (ht : ∀ i, 0 ≤ t i) (hL : 0 ≤ L) (hQ : 0 ≤ Q) |
| (hc : 1 ≤ ∑ i, min (L * t i) (Q * (t i)^2)) : |
| ∃ p : ι → ℝ, (∀ i, 0 ≤ p i) ∧ (∑ i, p i = 1) ∧ |
| (∀ i, p i ≤ L * t i) ∧ ∀ i, p i ≤ Q * (t i)^2 := by |
| obtain ⟨p,hp,hsum,hbound⟩ := probabilities_of_capacity |
| (fun i => min (L*t i) (Q*(t i)^2)) |
| (fun i => le_min (mul_nonneg hL (ht i)) (mul_nonneg hQ (sq_nonneg _))) hc |
| exact ⟨p,hp,hsum,fun i => (hbound i).trans (min_le_left _ _), |
| fun i => (hbound i).trans (min_le_right _ _)⟩ |
|
|
| namespace FiniteFlow |
|
|
| attribute [local instance] Classical.propDecidable |
|
|
| variable (T : FiniteFlow) |
|
|
| lemma weight_le_one (n : ℕ) (v : Fin (T.size n)) : T.weight n v ≤ 1 := by |
| rw [← T.total_mass n] |
| exact Finset.single_le_sum (fun w _ => T.nonneg n w) (Finset.mem_univ v) |
|
|
| lemma linear_transition_product |
| (p : (n : ℕ) → Fin (T.size (n+1)) → ℝ) |
| (Δ : (n : ℕ) → Fin (T.size n) → ℝ) {Δ₀ α : ℝ} |
| (hΔ₀ : 0 ≤ Δ₀) (hα : 0 ≤ α) (hroot : ∀ v, Δ 0 v = Δ₀) |
| (hp : ∀ n v, 0 ≤ p n v) |
| (hstep : ∀ n v, T.weight (n+1) v = p n v * T.weight n (T.parent n v)) |
| (hlin : ∀ n v, p n v * Δ n (T.parent n v) ≤ α * Δ (n+1) v) : |
| ∀ n v, Δ₀ * T.weight n v ≤ α^n * Δ n v := by |
| intro n |
| induction n with |
| | zero => |
| intro v |
| simpa [hroot] using mul_le_mul_of_nonneg_left (T.weight_le_one 0 v) hΔ₀ |
| | succ n ih => |
| intro v |
| calc |
| Δ₀ * T.weight (n+1) v = p n v * (Δ₀ * T.weight n (T.parent n v)) := by |
| rw [hstep]; ring |
| _ ≤ p n v * (α^n * Δ n (T.parent n v)) := |
| mul_le_mul_of_nonneg_left (ih _) (hp n v) |
| _ = α^n * (p n v * Δ n (T.parent n v)) := by ring |
| _ ≤ α^n * (α * Δ (n+1) v) := |
| mul_le_mul_of_nonneg_left (hlin n v) (pow_nonneg hα n) |
| _ = _ := by rw [pow_succ]; ring |
| |
| lemma badCount_exp_succ (c : ℝ) (n : ℕ) (v : Fin (T.size (n+1))) : |
| Real.exp (c * ((11/20:ℝ) * T.badCount (n+1) v - (1/20:ℝ) * (n+1))) = |
| Real.exp (c * ((11/20:ℝ) * T.badCount n (T.parent n v) - (1/20:ℝ)*n)) * |
| Real.exp (c * (if T.good n (T.parent n v) then -(1/20:ℝ) else 1/2)) := by |
| rw [← Real.exp_add] |
| congr 1 |
| simp only [badCount, Nat.cast_add, Nat.cast_ite, Nat.cast_zero, Nat.cast_one] |
| split_ifs <;> ring |
| |
| lemma quadratic_transition_product |
| (p : (n : ℕ) → Fin (T.size (n+1)) → ℝ) |
| (Δ : (n : ℕ) → Fin (T.size n) → ℝ) {Δ₀ c : ℝ} |
| (hroot : ∀ v, Δ 0 v = Δ₀) (hp : ∀ n v, 0 ≤ p n v) |
| (hstep : ∀ n v, T.weight (n+1) v = p n v * T.weight n (T.parent n v)) |
| (hq : ∀ n v, p n v * |
| Real.exp (c * (if T.good n (T.parent n v) then -(1/20:ℝ) else 1/2)) * |
| (Δ n (T.parent n v))^2 ≤ (Δ (n+1) v)^2) : |
| ∀ n v, Δ₀^2 * T.weight n v * |
| Real.exp (c * ((11/20:ℝ) * T.badCount n v - (1/20:ℝ) * n)) ≤ (Δ n v)^2 := by |
| intro n |
| induction n with |
| | zero => |
| intro v |
| simpa [badCount,hroot] using |
| mul_le_mul_of_nonneg_left (T.weight_le_one 0 v) (sq_nonneg Δ₀) |
| | succ n ih => |
| intro v |
| rw [hstep, Nat.cast_add, Nat.cast_one, T.badCount_exp_succ] |
| calc |
| _ = (p n v * Real.exp (c * (if T.good n (T.parent n v) then -(1/20:ℝ) else 1/2))) * |
| (Δ₀^2 * T.weight n (T.parent n v) * |
| Real.exp (c * ((11/20:ℝ) * T.badCount n (T.parent n v) - (1/20:ℝ) * n))) := by ring |
| _ ≤ (p n v * Real.exp (c * (if T.good n (T.parent n v) then -(1/20:ℝ) else 1/2))) * |
| (Δ n (T.parent n v))^2 := |
| mul_le_mul_of_nonneg_left (ih _) (mul_nonneg (hp n v) (Real.exp_pos _).le) |
| _ ≤ _ := hq n v |
|
|
| theorem good_levels_of_transitions |
| (p : (n : ℕ) → Fin (T.size (n+1)) → ℝ) |
| (Δ : (n : ℕ) → Fin (T.size n) → ℝ) {Δ₀ c E : ℝ} |
| (hΔ₀ : 0 < Δ₀) (hc : 0 < c) |
| (hroot : ∀ v, Δ 0 v = Δ₀) (hp : ∀ n v, 0 ≤ p n v) |
| (hstep : ∀ n v, T.weight (n+1) v = p n v * T.weight n (T.parent n v)) |
| (hq : ∀ n v, p n v * |
| Real.exp (c * (if T.good n (T.parent n v) then -(1/20:ℝ) else 1/2)) * |
| (Δ n (T.parent n v))^2 ≤ (Δ (n+1) v)^2) |
| (henergy : ∀ n, ∑ v, (Δ n v)^2 ≤ E) : |
| ∀ N : ℕ, ∃ n ≥ N, (1/2:ℝ) ≤ T.goodMass n := by |
| apply T.arbitrarily_late_good_levels hc (E := E / Δ₀^2) |
| intro n |
| apply (le_div_iff₀ (sq_pos_of_pos hΔ₀)).mpr |
| have h := (Finset.sum_le_sum fun v _ => |
| T.quadratic_transition_product p Δ hroot hp hstep hq n v).trans (henergy n) |
| convert h using 1 |
| rw [Finset.sum_mul] |
| apply Finset.sum_congr rfl |
| intro v hv |
| ring |
|
|
| end FiniteFlow |
|
|
| end CannonFlow |
|
|
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
|
|
| end OAI |
|
|
