| import OAI.Dynamics.SmoothObstruction.ProductCoordinates |
| import OAI.Dynamics.SmoothObstruction.GridCells |
| import OAI.Dynamics.SmoothObstruction.ShortScales |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace SmoothObstruction.ManifoldCoordinates |
| open Set MeasureTheory FiniteBins |
| open scoped Manifold ContDiff Matrix.Norms.L2Operator |
| variable {d : ℕ} {H : Type*} [TopologicalSpace H] |
| (I : ModelWithCorners ℝ (EuclideanSpace ℝ (Fin d)) H) |
| {M : Type*} [MetricSpace M] [ChartedSpace H M] [IsManifold I ∞ M] |
| [MeasurableSpace M] [BorelSpace M] |
| {ι : Type*} [Fintype ι] |
| open ChartDensity |
|
|
| /-- The actual full finite product partition is constructed from one original |
| gauge reference per active starting bin. Wall strips are charged to the ORIGINAL |
| measure. No endpoint or orbit chart code is included in the cell alphabet. The |
| recovery assertion is precisely the ideal exchange needed by both joins. -/ |
| theorem finite_product_partition_uniform (μ : Measure M) [IsProbabilityMeasure μ] |
| (S : Diffeomorph I I M M ∞) (a : ι → M) (K : ι → Set M) |
| (hK : ∀ i,IsCompact (K i)) (hKU : ∀ i,K i⊆(chartAt H (a i)).source) |
| (c : M → ι) (hc : ∀ x,x∈K (c x)) : |
| ∃ D : ℝ,1≤D ∧ ∀ (C : Type*) [Fintype C] [MeasurableSpace C] [MeasurableSingletonClass C] (P : M → C),Measurable P → ∀ (chart : C → ι), |
| (∀ x,chart (P x)=c x) → ∀ (G : Set M) (n : ℕ) (B R : ℝ),0≤B → |
| ∀ (A : ∀ x:G,BilateralGauge I S a c n B R x) (T : G → Finset (Fin d)) |
| (δ : ℝ),0<δ → ∀ N : ℕ,0<N → |
| let H₀ := Real.sqrt 2*Real.exp (2*B) |
| let m := ⌈H₀*D/(δ*N)+1⌉₊ |
| ∃ (L : M → C × (Fin d → Fin (2*m+1))) (W : Set M), |
| Measurable L ∧ MeasurableSet W ∧ μ.real W≤(d:ℝ)/N ∧ |
| (∀ x,(L x).1=P x) ∧ |
| (∀ x y,L x=L y → |
| ‖coordinates I (a (c x)) x-coordinates I (a (c x)) y‖≤ |
| Real.sqrt 2*((d:ℝ)+1)*(δ*N)) ∧ |
| (∀ (x y z : M) (hx : x∈G),L x=L y → x∉W → y∉W → P z=P x → |
| let ref : G := (reference P G (key P G ⟨x,hx⟩)).val |
| H₀*‖coordinates I (a (c x)) z-(coordinates I (a (c x)) x+ |
| (((A ref).forward I S a c).splitting (T ref)ᶜ).slow 0 |
| (coordinates I (a (c x)) y-coordinates I (a (c x)) x))‖≤δ/4 → |
| L z=L x) ∧ |
| Fintype.card (C × (Fin d → Fin (2*m+1)))=Fintype.card C*(2*m+1)^d := by |
| obtain ⟨D,hD,hbound⟩ := selected_coordinate_bound I a K hK hKU c hc |
| refine ⟨D,hD,?_⟩ |
| intro C _ _ _ P hP chart hchart G n B R hB A T δ hδ N hN H₀ m |
| let ref (Q : Active P G) : G := (reference P G Q).val |
| obtain ⟨E,hE,hEi,hmix⟩ := product_coordinates P G hB |
| (fun Q => (A (ref Q)).forward I S a c) (fun Q => (T (ref Q))ᶜ) |
| let φ (Q : C) (x : M) := coordinates I (a (chart Q)) x |
| have hb (x : M) : ‖φ (P x) x‖≤D := by simpa only [φ,hchart] using hbound x |
| obtain ⟨L,W,hL,hW,hWm,hLP,hdiam,hstable,hcard⟩ := ProductCells.exists_cells μ P hP φ |
| (fun Q => measurable_coordinates I (a (chart Q))) E (show 0≤D by linarith) |
| (show 0≤H₀ by dsimp [H₀]; positivity) (Real.sqrt_nonneg _) hδ hb hEi hE hN |
| refine ⟨L,W,hL,hW,hWm,hLP,?_,?_,hcard⟩ |
| · intro x y hxy |
| simpa only [φ,hchart] using hdiam x y hxy |
| · intro x y z hx hxy hxW hyW hz ref₀ herror |
| apply hstable x y z hxy hxW hyW hz |
| let Q : Active P G := key P G ⟨x,hx⟩ |
| let ideal := φ (P x) x+(((A (ref Q)).forward I S a c).splitting (T (ref Q))ᶜ).slow 0 |
| (φ (P x) y-φ (P x) x) |
| have herr : H₀*‖φ (P x) z-ideal‖≤δ/4 := by |
| simpa only [ideal,φ,hchart,ref,Q] using herror |
| have he (i : Fin d) : |((E (P x)).symm (φ (P x) z)) i-((E (P x)).symm ideal) i|≤δ/4 := by |
| calc |
| _ = ‖(((E (P x)).symm (φ (P x) z-ideal)) i)‖ := by rw [map_sub]; rfl |
| _ ≤ ‖(E (P x)).symm (φ (P x) z-ideal)‖ := PiLp.norm_apply_le _ _ |
| _ ≤ ‖(E (P x)).symm.toContinuousLinearMap‖*‖φ (P x) z-ideal‖ := |
| (E (P x)).symm.toContinuousLinearMap.le_opNorm _ |
| _ ≤ H₀*‖φ (P x) z-ideal‖ := mul_le_mul_of_nonneg_right (hEi _) (norm_nonneg _) |
| _ ≤ δ/4 := herr |
| intro i |
| have hh := hmix Q (φ (P x) x) (φ (P x) y) i |
| change ((E (P x)).symm ideal) i=((E (P x)).symm (φ (P x) x)) i ∨ |
| ((E (P x)).symm ideal) i=((E (P x)).symm (φ (P x) y)) i at hh |
| rcases hh with hh|hh |
| · exact Or.inl (by simpa only [hh] using he i) |
| · exact Or.inr (by simpa only [hh] using he i) |
| end SmoothObstruction.ManifoldCoordinates |
|
|
| end |
|
|
| section |
|
|
| open Filter Topology |
| open scoped Real |
|
|
| namespace SmoothObstruction.SwitchScales |
| open Filter Topology |
| open scoped Real |
| noncomputable def shortTime (b n : ℝ) : ℕ := ⌈b^(1/4:ℝ)*n⌉₊ |
| noncomputable def root (b : ℝ) : ℝ := b^(1/8:ℝ) |
| noncomputable def gap (b : ℝ) : ℝ := b^(1/2:ℝ) |
| noncomputable def shortSignal (b n : ℝ) : ℝ := b^(3/4:ℝ)*n |
|
|
| lemma ceil_bounds {b n : ℝ} (hn : 1≤n) (hfloor : n^(-1/10:ℝ)≤b) : |
| b^(1/4:ℝ)*n≤(shortTime b n : ℝ) ∧ (shortTime b n : ℝ)≤2*b^(1/4:ℝ)*n := by |
| have hl := ScaleHierarchy.lower_bound (p:=1/4) hn (by norm_num) hfloor |
| have hp : 1≤b^(1/4:ℝ)*n := by |
| apply le_trans _ hl |
| exact Real.one_le_rpow hn (by norm_num) |
| refine ⟨Nat.le_ceil _,?_⟩ |
| have hh := Nat.ceil_lt_add_one (show 0≤b^(1/4:ℝ)*n by linarith) |
| change (shortTime b n : ℝ)<b^(1/4:ℝ)*n+1 at hh |
| linarith |
|
|
| lemma gap_short_lower {b n : ℝ} (hb : 0<b) : |
| shortSignal b n≤gap b*(shortTime b n : ℝ) := by |
| have hh := mul_le_mul_of_nonneg_left (Nat.le_ceil (b^(1/4:ℝ)*n)) |
| (Real.rpow_nonneg hb.le (1/2:ℝ)) |
| have he : b^(1/2:ℝ)*(b^(1/4:ℝ)*n)=shortSignal b n := by |
| rw [←mul_assoc,←Real.rpow_add hb]; norm_num [shortSignal] |
| rwa [he] at hh |
|
|
| lemma short_eventually {ι : Type*} {l : Filter ι} {b n : ι → ℝ} |
| (hbpos : ∀ᶠ k in l,0<b k) (hb : Tendsto b l (𝓝 0)) |
| (hn : Tendsto n l atTop) (hfloor : ∀ᶠ k in l,n k^(-1/10:ℝ)≤b k) : |
| ∀ᶠ k in l,(shortTime (b k) (n k) : ℝ)≤n k ∧ 0<b k ∧ b k≤1 ∧ 1≤n k ∧ |
| (shortTime (b k) (n k) : ℝ)≤2*b k^(1/4:ℝ)*n k := by |
| have hr : Tendsto (fun k => b k^(1/4:ℝ)) l (𝓝 0) := by |
| simpa only [Real.zero_rpow (by norm_num : (1/4:ℝ)≠0),Function.comp_def] using |
| ((Real.continuous_rpow_const (show (0:ℝ)≤1/4 by norm_num)).tendsto 0).comp hb |
| filter_upwards [hbpos,hn.eventually (eventually_ge_atTop 1), hb.eventually_le_const (by norm_num : (0:ℝ)<1), hr.eventually_le_const (by norm_num : (0:ℝ)<1/2),hfloor] with k hp hn1 hb1 hr1 hf |
| have hL := (ceil_bounds hn1 hf).2 |
| refine ⟨hL.trans ?_,hp,hb1,hn1,hL⟩ |
| nlinarith [mul_le_mul_of_nonneg_right hr1 (show 0≤n k by linarith)] |
|
|
| /-- The genuine short-product noise with its ceiling time is swallowed by |
| one original spatial exponent, even after a full short-gap exponential cost. -/ |
| theorem short_noise_decay {ι : Type*} {l : Filter ι} {b n : ι → ℝ} |
| (hbpos : ∀ᶠ k in l,0<b k) (hb : Tendsto b l (𝓝 0)) |
| (hn : Tendsto n l atTop) (hfloor : ∀ᶠ k in l,n k^(-1/10:ℝ)≤b k) |
| {J C : ℝ} (hJ : 0≤J) (hC : 0≤C) : |
| Tendsto (fun k => n k*Real.exp (J*(shortTime (b k) (n k):ℝ)+C*b k*n k+ |
| shortSignal (b k) (n k)-root (b k)*n k)) l (𝓝 0) := by |
| have hz := ScaleHierarchy.polynomial_decay (p:=1/8) (q:=1/4) (c:=1) |
| (C:=2*J+C+1) (by norm_num) (by norm_num) (by norm_num) (by norm_num) |
| hbpos hb hn hfloor 1 |
| simp only [pow_one,one_mul] at hz |
| apply squeeze_zero' _ _ hz |
| · filter_upwards [hn.eventually (eventually_ge_atTop 0)] with k hk |
| exact mul_nonneg hk (Real.exp_pos _).le |
| · filter_upwards [short_eventually hbpos hb hn hfloor] with k hk |
| have hbq : b k≤b k^(1/4:ℝ) := by |
| simpa using Real.rpow_le_rpow_of_exponent_ge hk.2.1 hk.2.2.1 |
| (show (1/4:ℝ)≤1 by norm_num) |
| have hb3 : b k^(3/4:ℝ)≤b k^(1/4:ℝ) := |
| Real.rpow_le_rpow_of_exponent_ge hk.2.1 hk.2.2.1 (by norm_num) |
| apply mul_le_mul_of_nonneg_left (Real.exp_le_exp.mpr ?_) (by linarith [hk.2.2.2.1]) |
| have h₁ := mul_le_mul_of_nonneg_left hk.2.2.2.2 hJ |
| have h₂ := mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hbq hC) |
| (show 0≤n k by linarith [hk.2.2.2.1]) |
| have h₃ := mul_le_mul_of_nonneg_right hb3 (show 0≤n k by linarith [hk.2.2.2.1]) |
| dsimp [shortSignal,root] |
| nlinarith |
| |
| /-- All common-bin projector errors, including the true product difference |
| `L C C^(2L) h0`, are exponentially small at the authentic gap×time scale. -/ |
| theorem projector_budget {ι : Type*} {l : Filter ι} {b n : ι → ℝ} |
| (hbpos : ∀ᶠ k in l,0<b k) (hb : Tendsto b l (𝓝 0)) |
| (hn : Tendsto n l atTop) (hfloor : ∀ᶠ k in l,n k^(-1/10:ℝ)≤b k) |
| {C D A : ℝ} (hC : 1≤C) (hD : 0≤D) (hA : 0≤A) : |
| let L (k : ι) := shortTime (b k) (n k) |
| let K (k : ι) := D*b k*n k |
| let noise (k : ι) := (L k:ℝ)*C*C^(2*L k)*Real.exp (-root (b k)*n k) |
| let err (k : ι) := Real.exp (-2*gap (b k)*(L k:ℝ)+4*K k)+ |
| noise k*Real.exp (A*gap (b k)*(L k:ℝ)+2*K k) |
| ∀ᶠ k in l,3*err k≤Real.exp (-shortSignal (b k) (n k)) := by |
| intro L K noise err |
| have hlog : 0≤Real.log C := Real.log_nonneg hC |
| have hz₁ := ScaleHierarchy.polynomial_decay (p:=3/4) (q:=1) (c:=1) (C:=4*D) |
| (by norm_num) (by norm_num) (by norm_num) (by norm_num) hbpos hb hn hfloor 0 |
| simp only [pow_zero,one_mul,Real.rpow_one] at hz₁ |
| have hz₂ := (short_noise_decay hbpos hb hn hfloor |
| (J:=2*Real.log C+A) (C:=2*D) (by positivity) (by positivity)).const_mul C |
| simp only [mul_zero] at hz₂ |
| have hz : Tendsto (fun k => 3*(Real.exp (4*D*b k*n k-shortSignal (b k) (n k))+ |
| C*(n k*Real.exp ((2*Real.log C+A)*(L k:ℝ)+2*D*b k*n k+ |
| shortSignal (b k) (n k)-root (b k)*n k)))) l (𝓝 0) := by |
| simpa only [add_zero,mul_zero,shortSignal,L] using (hz₁.add hz₂).const_mul 3 |
| filter_upwards [short_eventually hbpos hb hn hfloor, |
| hz.eventually_le_const (by norm_num : (0:ℝ)<1)] with k hk hzbound |
| have hg : gap (b k)≤1 := Real.rpow_le_one hk.2.1.le hk.2.2.1 (by norm_num) |
| have hnp : 0≤n k := by linarith [hk.2.2.2.1] |
| have hL : 0≤(L k:ℝ) := Nat.cast_nonneg _ |
| have heC : C^(2*L k)=Real.exp (2*Real.log C*(L k:ℝ)) := by |
| rw [show 2*Real.log C*(L k:ℝ)=((2*L k:ℕ):ℝ)*Real.log C by push_cast; ring, |
| Real.exp_nat_mul,Real.exp_log (by linarith : 0<C)] |
| have hfirst : Real.exp (-2*gap (b k)*(L k:ℝ)+4*K k)* |
| Real.exp (shortSignal (b k) (n k))≤ |
| Real.exp (4*D*b k*n k-shortSignal (b k) (n k)) := by |
| rw [←Real.exp_add] |
| apply Real.exp_le_exp.mpr |
| have hh := gap_short_lower (n:=n k) hk.2.1 |
| dsimp only [K,L] |
| linarith |
| have hsecond : noise k*Real.exp (A*gap (b k)*(L k:ℝ)+2*K k)* |
| Real.exp (shortSignal (b k) (n k))≤ |
| C*(n k*Real.exp ((2*Real.log C+A)*(L k:ℝ)+2*D*b k*n k+ |
| shortSignal (b k) (n k)-root (b k)*n k)) := by |
| dsimp only [noise] |
| rw [heC] |
| have he : (L k:ℝ)*C*Real.exp (2*Real.log C*(L k:ℝ))*Real.exp (-root (b k)*n k)* |
| Real.exp (A*gap (b k)*(L k:ℝ)+2*K k)*Real.exp (shortSignal (b k) (n k))= |
| C*((L k:ℝ)*Real.exp (2*Real.log C*(L k:ℝ)-root (b k)*n k+ |
| (A*gap (b k)*(L k:ℝ)+2*K k)+shortSignal (b k) (n k))) := by |
| simp only [sub_eq_add_neg,neg_mul,Real.exp_add,Real.exp_neg] |
| ring |
| rw [he] |
| apply mul_le_mul_of_nonneg_left _ (by linarith : 0≤C) |
| apply mul_le_mul hk.1 (Real.exp_le_exp.mpr ?_) (Real.exp_pos _).le hnp |
| have hh := mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hg hA) hL |
| dsimp only [K] |
| nlinarith |
| have hbound : 3*err k*Real.exp (shortSignal (b k) (n k))≤1 := by |
| dsimp only [err] |
| have hh := mul_le_mul_of_nonneg_left (add_le_add hfirst hsecond) (by norm_num : (0:ℝ)≤3) |
| calc |
| _ = 3*(Real.exp (-2*gap (b k)*(L k:ℝ)+4*K k)*Real.exp (shortSignal (b k) (n k))+ |
| noise k*Real.exp (A*gap (b k)*(L k:ℝ)+2*K k)*Real.exp (shortSignal (b k) (n k))) := by ring |
| _ ≤ _ := hh |
| _ ≤ 1 := hzbound |
| have he : Real.exp (-shortSignal (b k) (n k))*Real.exp (shortSignal (b k) (n k))=1 := by |
| rw [←Real.exp_add,neg_add_cancel,Real.exp_zero] |
| exact (mul_le_mul_iff_left₀ (Real.exp_pos _)).mp (hbound.trans_eq he.symm) |
| end SmoothObstruction.SwitchScales |
| |
| end |
| |
| section |
| |
| namespace SmoothObstruction.SwitchScales |
| open Filter Topology |
| /-- A simultaneous usable envelope for all starting/endpoint bin estimates. |
| The short time is still the source ceiling, not an adjustable subsequence. -/ |
| theorem reference_budget {ι : Type*} {l : Filter ι} {b n : ι → ℝ} |
| (hbpos : ∀ᶠ k in l,0<b k) (hb : Tendsto b l (𝓝 0)) |
| (hn : Tendsto n l atTop) (hfloor : ∀ᶠ k in l,n k^(-1/10:ℝ)≤b k) |
| {C D A r : ℝ} (hC : 1≤C) (hD : 0≤D) (hA : 0≤A) (hr : 0<r) : |
| let L (k : ι) := shortTime (b k) (n k) |
| let K (k : ι) := D*b k*n k |
| let h (k : ι) := Real.exp (-root (b k)*n k) |
| let noise (k : ι) := (L k:ℝ)*C*C^(2*L k)*h k |
| let err (k : ι) := Real.exp (-2*gap (b k)*(L k:ℝ)+4*K k)+ |
| noise k*Real.exp (A*gap (b k)*(L k:ℝ)+2*K k) |
| ∀ᶠ k in l,(L k:ℝ)≤n k ∧ 1≤(L k:ℝ) ∧ |
| C^(L k)*h k≤r ∧ noise k<Real.exp (-2*K k)/2 ∧ |
| Real.exp (-2*gap (b k)*(L k:ℝ)+4*K k)≤1/2 ∧ err k≤1/2 ∧ |
| 3*err k≤Real.exp (-shortSignal (b k) (n k)) ∧ |
| Real.exp (-shortSignal (b k) (n k))≤1/2 := by |
| intro L K h noise err |
| have he := ScaleHierarchy.polynomial_decay (p:=3/4) (q:=1) (c:=1) (C:=0) |
| (by norm_num) (by norm_num) (by norm_num) (by norm_num) hbpos hb hn hfloor 0 |
| simp only [pow_zero,one_mul,zero_mul,zero_sub] at he |
| have he' : Tendsto (fun k => Real.exp (-shortSignal (b k) (n k))) l (𝓝 0) := by |
| simpa only [shortSignal,neg_mul] using he |
| filter_upwards [projector_budget hbpos hb hn hfloor hC hD hA, short_eventually hbpos hb hn hfloor,hfloor, he'.eventually_le_const (lt_min (by norm_num : (0:ℝ)<1/4) hr)] with k hbudget ht hf he |
| have hL : 1≤(L k:ℝ) := by |
| have hh := ScaleHierarchy.lower_bound (p:=1/4) ht.2.2.2.1 (by norm_num) hf |
| have hrp := Real.one_le_rpow ht.2.2.2.1 (by norm_num : (0:ℝ)≤1-(1/4:ℝ)/10) |
| exact (hrp.trans hh).trans (Nat.le_ceil _) |
| have hK : 0≤K k := mul_nonneg (mul_nonneg hD ht.2.1.le) (by linarith [ht.2.2.2.1]) |
| have hg : 0≤gap (b k) := Real.rpow_nonneg ht.2.1.le _ |
| have hnz : 0≤noise k := by dsimp only [noise,h]; positivity |
| have hLeft : Real.exp (-2*gap (b k)*(L k:ℝ)+4*K k)≤err k := by |
| exact le_add_of_nonneg_right (mul_nonneg hnz (Real.exp_pos _).le) |
| have hnoise : noise k≤err k := by |
| have hex : 1≤Real.exp (A*gap (b k)*(L k:ℝ)+2*K k) := Real.one_le_exp_iff.mpr (by positivity) |
| have hh := mul_le_mul_of_nonneg_left hex hnz |
| dsimp only [err]; nlinarith [Real.exp_pos (-2*gap (b k)*(L k:ℝ)+4*K k)] |
| have hne : noise k*Real.exp (2*K k)≤err k := by |
| have hex : Real.exp (2*K k)≤Real.exp (A*gap (b k)*(L k:ℝ)+2*K k) := Real.exp_le_exp.mpr (le_add_of_nonneg_left (mul_nonneg (mul_nonneg hA hg) (Nat.cast_nonneg _))) |
| have hh := mul_le_mul_of_nonneg_left hex hnz |
| dsimp only [err]; linarith [Real.exp_pos (-2*gap (b k)*(L k:ℝ)+4*K k)] |
| have herr : err k≤1/4 := by |
| have h := he.trans (min_le_left _ _) |
| have herrpos : 0≤err k := (Real.exp_pos _).le.trans hLeft |
| linarith |
| refine ⟨ht.1,hL,?_,?_,hLeft.trans (by linarith),by linarith,hbudget,he.trans (by linarith [min_le_left (1/4:ℝ) r])⟩ |
| · have hp : C^(L k)≤C^(2*L k) := pow_le_pow_right₀ hC (by omega) |
| have hc : 1≤(L k:ℝ)*C := one_le_mul_of_one_le_of_one_le hL hC |
| have hn : C^(L k)*h k≤noise k := by |
| dsimp only [noise] |
| calc |
| _ ≤ C^(2*L k)*h k := mul_le_mul_of_nonneg_right hp (Real.exp_pos _).le |
| _ ≤ ((L k:ℝ)*C)*C^(2*L k)*h k := by |
| have hh := mul_le_mul_of_nonneg_right hc (mul_nonneg (pow_nonneg (by linarith : 0≤C) (2*L k)) (show 0≤h k from (Real.exp_pos _).le)) |
| simpa only [one_mul,mul_assoc] using hh |
| have hre : Real.exp (-shortSignal (b k) (n k))≤r := he.trans (min_le_right _ _) |
| have herrpos : 0≤err k := (Real.exp_pos _).le.trans hLeft |
| exact hn.trans (hnoise.trans (by linarith)) |
| · have hmul := mul_lt_mul_of_pos_right (show noise k*Real.exp (2*K k)<1/2 by linarith) |
| (Real.exp_pos (-2*K k)) |
| have heq : Real.exp (2*K k)*Real.exp (-2*K k)=1 := by rw [←Real.exp_add]; simp |
| calc |
| _ = (noise k*Real.exp (2*K k))*Real.exp (-2*K k) := by rw [mul_assoc,heq,mul_one] |
| _ < _ := hmul |
| _ = _ := by ring |
| end SmoothObstruction.SwitchScales |
| |
| namespace SmoothObstruction.SwitchScales |
| open Filter Topology |
| /-- The finite-time noise is monotone in the literal chart constant. -/ |
| def refNoise (C : ℝ) (N : ℕ) (h : ℝ) : ℝ := (N:ℝ)*C*C^(2*N)*h |
| |
| noncomputable def refError (K A g : ℝ) (N : ℕ) (noise : ℝ) : ℝ := |
| Real.exp (-2*g*N+4*K)+noise*Real.exp (A*g*N+2*K) |
| |
| theorem refNoise_nonneg {C h : ℝ} (hC : 0≤C) (hh : 0≤h) (N : ℕ) : |
| 0≤refNoise C N h := by unfold refNoise; positivity |
| |
| theorem refNoise_mono {C D h : ℝ} {N : ℕ} (hC : 0≤C) (hCD : C≤D) (hh : 0≤h) : |
| refNoise C N h≤refNoise D N h := by |
| have hD : 0≤D := hC.trans hCD |
| apply mul_le_mul_of_nonneg_right _ hh |
| apply mul_le_mul (mul_le_mul_of_nonneg_left hCD (Nat.cast_nonneg N)) |
| (pow_le_pow_left₀ hC hCD (2*N)) (pow_nonneg hC _) (by positivity) |
| |
| theorem refNoise_add_le {C₁ C₂ C h : ℝ} {N : ℕ} |
| (h₁ : 0≤C₁) (h₂ : 0≤C₂) (hC : C₁+C₂≤C) (hh : 0≤h) : |
| refNoise C₁ N h+refNoise C₂ N h≤refNoise C N h := by |
| have hc₁ : C₁≤C := by linarith |
| have hc₂ : C₂≤C := by linarith |
| have hpow₁ := pow_le_pow_left₀ h₁ hc₁ (2*N) |
| have hpow₂ := pow_le_pow_left₀ h₂ hc₂ (2*N) |
| calc |
| _ ≤ (N:ℝ)*C₁*C^(2*N)*h+(N:ℝ)*C₂*C^(2*N)*h := by |
| exact add_le_add (mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hpow₁ (by positivity)) hh) |
| (mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hpow₂ (by positivity)) hh) |
| _ = (N:ℝ)*(C₁+C₂)*C^(2*N)*h := by ring |
| _ ≤ _ := by |
| apply mul_le_mul_of_nonneg_right _ hh |
| exact mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hC (Nat.cast_nonneg N)) (pow_nonneg (by linarith) _) |
| |
| theorem refError_mono {K₀ K A g noise₀ noise : ℝ} {N : ℕ} |
| (hK : K₀≤K) (hn : 0≤noise₀) (hnoise : noise₀≤noise) : |
| refError K₀ A g N noise₀≤refError K A g N noise := by |
| apply add_le_add (Real.exp_le_exp.mpr (by linarith)) |
| exact mul_le_mul hnoise (Real.exp_le_exp.mpr (by linarith)) (Real.exp_pos _).le |
| (hn.trans hnoise) |
| |
| theorem endpoint_refError_le {K₀ K A g u noise₀ noise : ℝ} {N : ℕ} |
| (hK : K₀≤K) (hu : u≤A*g) (hn : 0≤noise₀) (hnoise : noise₀≤noise) : |
| Real.exp (u*N+2*K₀)*(Real.exp ((-2*g-u)*N+2*K₀)+noise₀)≤refError K A g N noise := by |
| rw [mul_add,←Real.exp_add] |
| have he : u*(N:ℝ)+2*K₀+((-2*g-u)*N+2*K₀)=-2*g*N+4*K₀ := by ring |
| rw [he] |
| apply add_le_add (Real.exp_le_exp.mpr (by linarith)) |
| rw [mul_comm] |
| apply mul_le_mul hnoise _ (Real.exp_pos _).le (hn.trans hnoise) |
| apply Real.exp_le_exp.mpr |
| have hm := mul_le_mul_of_nonneg_right hu (Nat.cast_nonneg N) |
| linarith |
| |
| /-- All model-dependent reference constants are absorbed without changing b,n |
| or the source short-time, mesh and clean projector-error scales. -/ |
| theorem reference_constants_eventually {κ : Type*} {l : Filter κ} {b n : κ → ℝ} |
| (hbpos : ∀ᶠ k in l,0<b k) (hb : Tendsto b l (𝓝 0)) |
| (hn : Tendsto n l atTop) (hfloor : ∀ᶠ k in l,n k^(-1/10:ℝ)≤b k) |
| (d : ℕ) {Dg C₁ C₂ C₃ C₄ D D₃ D₄ r₁ r₂ r₃ r₄ : ℝ} |
| (hDg : 0≤Dg) (hC₁ : 1≤C₁) (hC₂ : 1≤C₂) (hC₃ : 1≤C₃) (hC₄ : 1≤C₄) |
| (hD : 1≤D) (hD₃ : 1≤D₃) (hD₄ : 1≤D₄) |
| (hr₁ : 0<r₁) (hr₂ : 0<r₂) (hr₃ : 0<r₃) (hr₄ : 0<r₄) : |
| let L (k : κ) := shortTime (b k) (n k) |
| let B (k : κ) := Dg*(b k*n k) |
| let h (k : κ) := Real.exp (-root (b k)*n k) |
| let g (k : κ) := gap (b k) |
| let ε (k : κ) := Real.exp (-shortSignal (b k) (n k)) |
| let err (k : κ) := refError (B k+Real.log D) (1+8*d) (g k) (L k) |
| (refNoise C₁ (L k) (h k)+refNoise C₂ (L k) (h k)) |
| ∀ᶠ k in l,(L k:ℝ)≤n k ∧ 1≤(L k:ℝ) ∧ 0<g k ∧ |
| C₁^(L k)*h k≤r₁ ∧ C₂^(L k)*h k≤r₂ ∧ C₃^(L k)*h k≤r₃ ∧ C₄^(L k)*h k≤r₄ ∧ |
| refNoise C₁ (L k) (h k)+refNoise C₂ (L k) (h k)<Real.exp (-2*(B k+Real.log D))/2 ∧ |
| Real.exp (-2*g k*(L k:ℝ)+4*(B k+Real.log D))≤1/2 ∧ |
| err k≤1/2 ∧ 3*err k≤ε k ∧ ε k≤1/2 ∧ |
| ∀ j : Fin (d+1),let γ := (1+8*(j.val:ℝ))*g k |
| (Real.exp ((γ-g k)*(L k:ℝ)+2*(B k+Real.log D₃))* |
| (Real.exp ((-γ-g k)*(L k:ℝ)+2*(B k+Real.log D₃))+refNoise C₃ (L k) (h k))≤ε k/3) ∧ |
| (Real.exp ((-γ-g k)*(L k:ℝ)+2*(B k+Real.log D₄))* |
| (Real.exp ((γ-g k)*(L k:ℝ)+2*(B k+Real.log D₄))+refNoise C₄ (L k) (h k))≤ε k/3) := by |
| intro L B h g ε err |
| let C := C₁+C₂+C₃+C₄+1 |
| let Dbar := Dg+Real.log D+Real.log D₃+Real.log D₄ |
| have hlD := Real.log_nonneg hD |
| have hlD₃ := Real.log_nonneg hD₃ |
| have hlD₄ := Real.log_nonneg hD₄ |
| have hDb : 0≤Dbar := by dsimp [Dbar]; positivity |
| have hC : 1≤C := by dsimp [C]; linarith |
| have hc₁ : C₁≤C := by dsimp [C]; linarith |
| have hc₂ : C₂≤C := by dsimp [C]; linarith |
| have hc₃ : C₃≤C := by dsimp [C]; linarith |
| have hc₄ : C₄≤C := by dsimp [C]; linarith |
| have hc12 : C₁+C₂≤C := by dsimp [C]; linarith |
| have hr : 0 < min (min r₁ r₂) (min r₃ r₄) := lt_min (lt_min hr₁ hr₂) (lt_min hr₃ hr₄) |
| have hbudget := reference_budget hbpos hb hn hfloor hC hDb (by positivity : 0≤(1+8*(d:ℝ))) hr |
| filter_upwards [hbudget,hbpos,hfloor,hn.eventually (eventually_ge_atTop (1:ℝ))] with k ht hbpos hf hn1 |
| let K := Dbar*b k*n k |
| let noise := refNoise C (L k) (h k) |
| let e := refError K (1+8*d) (g k) (L k) noise |
| have hbn : 1≤b k*n k := by |
| have hs := ScaleHierarchy.lower_bound (p:=1) hn1 (by norm_num) hf |
| have hpow := Real.one_le_rpow hn1 (by norm_num : (0:ℝ)≤1-(1:ℝ)/10) |
| simpa only [Real.rpow_one] using hpow.trans hs |
| have hK (D' : ℝ) (hD' : 0≤Real.log D') (hd : Dg+Real.log D'≤Dbar) : B k+Real.log D'≤K := by have hm := mul_le_mul_of_nonneg_right hd (by linarith : 0≤b k*n k) have hm' := mul_le_mul_of_nonneg_left hbn hD' dsimp only [B,K] |
| nlinarith only [hm,hm'] |
| have hKD := hK D hlD (by dsimp [Dbar]; linarith) |
| have hKD₃ := hK D₃ hlD₃ (by dsimp [Dbar]; linarith) |
| have hKD₄ := hK D₄ hlD₄ (by dsimp [Dbar]; linarith) |
| have hhp : 0≤h k := (Real.exp_pos _).le |
| have hn12 : refNoise C₁ (L k) (h k)+refNoise C₂ (L k) (h k)≤noise := |
| refNoise_add_le (by linarith) (by linarith) hc12 hhp |
| have hn3 : refNoise C₃ (L k) (h k)≤noise := refNoise_mono (by linarith) hc₃ hhp |
| have hn4 : refNoise C₄ (L k) (h k)≤noise := refNoise_mono (by linarith) hc₄ hhp |
| have he : err k≤e := refError_mono hKD (by apply add_nonneg <;> apply refNoise_nonneg <;> linarith) hn12 |
| have hτ (C' r' : ℝ) (hC' : 0≤C') (hc' : C'≤C) (hr' : min (min r₁ r₂) (min r₃ r₄)≤r') : |
| C'^(L k)*h k≤r' := |
| (mul_le_mul_of_nonneg_right (pow_le_pow_left₀ hC' hc' _) hhp).trans (ht.2.2.1.trans hr') have hg : 0<g k := Real.rpow_pos_of_pos hbpos _ refine ⟨ht.1,ht.2.1,hg,hτ C₁ r₁ (by linarith) hc₁ ((min_le_left _ _).trans (min_le_left _ _)), hτ C₂ r₂ (by linarith) hc₂ ((min_le_left _ _).trans (min_le_right _ _)), hτ C₃ r₃ (by linarith) hc₃ ((min_le_right _ _).trans (min_le_left _ _)), hτ C₄ r₄ (by linarith) hc₄ ((min_le_right _ _).trans (min_le_right _ _)),?_,?_,?_,?_,ht.2.2.2.2.2.2.2,?_⟩ · exact (hn12.trans_lt ht.2.2.2.1).trans_le (div_le_div_of_nonneg_right (Real.exp_le_exp.mpr (by linarith)) (by norm_num)) · exact (Real.exp_le_exp.mpr (by linarith : -2*g k*(L k:ℝ)+4*(B k+Real.log D)≤-2*g k*(L k:ℝ)+4*K)).trans ht.2.2.2.2.1 · exact he.trans ht.2.2.2.2.2.1 · exact (mul_le_mul_of_nonneg_left he (by norm_num)).trans ht.2.2.2.2.2.2.1 · intro j γ have hj : (j.val:ℝ)≤d := by exact_mod_cast (show j.val≤d by omega) have hγ₀ : 0≤γ := by dsimp only [γ]; positivity |
| have hγ : γ≤(1+8*(d:ℝ))*g k := by |
| apply mul_le_mul_of_nonneg_right _ hg.le |
| linarith |
| have hf := endpoint_refError_le (N:=L k) hKD₃ |
| (show γ-g k≤(1+8*(d:ℝ))*g k by linarith) (refNoise_nonneg (by linarith : 0≤C₃) hhp _) hn3 |
| have hb := endpoint_refError_le (N:=L k) hKD₄ |
| (show -γ-g k≤(1+8*(d:ℝ))*g k by linarith) (refNoise_nonneg (by linarith : 0≤C₄) hhp _) hn4 |
| have he3 : e≤ε k/3 := by have hh := ht.2.2.2.2.2.2.1; change 3*e≤ε k at hh; linarith |
| constructor |
| · convert hf.trans he3 using 1; congr 3; ring |
| · convert hb.trans he3 using 1; congr 3; ring |
| end SmoothObstruction.SwitchScales |
|
|
| namespace SmoothObstruction.ManifoldCoordinates |
| open Set Filter Topology Metric MeasureTheory FiniteBins ShortBin SwitchScales |
| open scoped Manifold ContDiff Matrix.Norms.L2Operator |
| variable {d : ℕ} {H : Type*} [TopologicalSpace H] |
| (I : ModelWithCorners ℝ (EuclideanSpace ℝ (Fin d)) H) |
| {M : Type*} [MetricSpace M] [ProperSpace M] [ChartedSpace H M] [IsManifold I ∞ M] |
| {ι : Type*} [Fintype ι] |
| local notation "E₀" => EuclideanSpace ℝ (Fin d) |
|
|
| /-- Authentic finite-bin references on every sufficiently large original scale. |
| The constants depend on the model and atlas, not the scale, alphabets, gauges, |
| or good set. The clean error is exp(-b^(3/4)n). -/ |
| theorem eventual_finite_references (hclosed : IsClosed (range I)) |
| (S : Diffeomorph I I M M ∞) (a : ι → M) (K : ι → Set M) |
| (hK : ∀ i,IsCompact (K i)) (hKU : ∀ i,K i⊆(chartAt H (a i)).source) |
| {κ : Type*} {l : Filter κ} {b : κ → ℝ} {n : κ → ℕ} |
| (hbpos : ∀ᶠ k in l,0<b k) (hb : Tendsto b l (𝓝 0)) |
| (hn : Tendsto (fun k => (n k:ℝ)) l atTop) |
| (hfloor : ∀ᶠ k in l,(n k:ℝ)^(-1/10:ℝ)≤b k) |
| (Dg R : ℝ) (hDg : 0≤Dg) : |
| ∀ᶠ k in l,∀ (C : Type*) (c : M → ι) (P : M → C) (G : Set M) |
| (A : ∀ x:G,BilateralGauge I S a c (n k) (Dg*(b k*n k)) R x), |
| (∀ y,y∈K (c y)) → (∀ x y,P x=P y → c x=c y) → |
| (∀ x∈G,I.IsInteriorPoint x) → |
| (∀ x y,P x=P y → ‖(extChartAt I (a (c y))) x-(extChartAt I (a (c y))) y‖≤ |
| Real.exp (-root (b k)*n k)) → |
| ∃ (γ : C → ℝ) (T : G → Finset (Fin d)) (ref : G → G) |
| (Wf Wb : C×C → Submodule ℝ E₀), |
| (ref = fun x => (reference P G (key P G x)).val) ∧ |
| (∀ q,|γ q|+|gap (b k)|≤(2+8*(d:ℝ))*gap (b k)) ∧ |
| (∀ x:G,P (ref x)=P x) ∧ |
| (∀ x y:G,P x=P y → (T x).card=(T y).card) ∧ |
| (∀ x y:G,P x=P y → ref x=ref y) ∧ |
| (∀ x:G,∀ i∈(T x)ᶜ,(A x).lam i≤γ (P x)-gap (b k)) ∧ |
| (∀ x:G,∀ i∈T x,γ (P x)+gap (b k)≤(A x).lam i) ∧ |
| (∀ x:G, |
| ‖((A (ref x)).forwardSpace I S a c 0 (T (ref x))ᶜ).starProjection- |
| ((A x).forwardSpace I S a c 0 (T x)ᶜ).starProjection‖≤Real.exp (-shortSignal (b k) (n k)) ∧ |
| ‖((A (ref x)).forwardSpace I S a c 0 (T (ref x))).starProjection- |
| ((A x).forwardSpace I S a c 0 (T x)).starProjection‖≤Real.exp (-shortSignal (b k) (n k))) ∧ |
| (∀ x:G, |
| Module.finrank ℝ (Wf (P x,P (S^[n k] x)))=(T x).card ∧ |
| Module.finrank ℝ (Wb (P x,P (S.symm^[n k] x)))=d-(T x).card ∧ |
| ‖((A x).forwardSpace I S a c (n k) (T x)).starProjection- |
| (Wf (P x,P (S^[n k] x))).starProjection‖≤1/2 ∧ |
| ‖((A x).backwardSpace I S a c (n k) (T x)ᶜ).starProjection- |
| (Wb (P x,P (S.symm^[n k] x))).starProjection‖≤1/2) := by |
| classical |
| obtain ⟨r₁,C₁,r₂,C₂,D,r₃,C₃,D₃,r₄,C₄,D₄,hr₁,hC₁,hr₂,hC₂,hD,hr₃,hC₃,hD₃,hr₄,hC₄,hD₄,hrefs⟩ := |
| finite_references_uniform I hclosed S a K hK hKU |
| have hbudget := reference_constants_eventually hbpos hb hn hfloor d hDg hC₁ hC₂ hC₃ hC₄ hD hD₃ hD₄ hr₁ hr₂ hr₃ hr₄ |
| filter_upwards [hbudget] with k hk |
| rcases hk with ⟨hN,hN1,hg,ht₁,ht₂,ht₃,ht₄,hnoise,hdec,herr,herr3,hεhalf,hend⟩ |
| intro C c P G A hcover hco hint hdiam |
| let N := shortTime (b k) (n k) |
| let g := gap (b k) |
| let h := Real.exp (-root (b k)*n k) |
| let B := Dg*(b k*n k) |
| let ε := Real.exp (-shortSignal (b k) (n k)) |
| have hN' : N≤n k := by exact_mod_cast hN |
| have hfsmall (j : Fin (d+1)) := (hend j).1 |
| have hbsmall (j : Fin (d+1)) := (hend j).2 |
| obtain ⟨j,Wf,Wb,hslow,hfast,hcard,hstart,hend'⟩ := hrefs C c P G (n k) N B R h g A |
| hcover hN' hco hint hdiam ht₁ ht₂ ht₃ ht₄ (Real.exp_pos _).le hg hdec |
| (by simpa only [refNoise,refError,←add_mul] using And.intro hnoise herr) |
| (fun j => by have hh := hfsmall j; change _≤ε/3 at hh; have he : ε≤1/2 := hεhalf; dsimp only [refNoise] at hh; linarith) |
| (fun j => by have hh := hbsmall j; change _≤ε/3 at hh; have he : ε≤1/2 := hεhalf; dsimp only [refNoise] at hh; linarith) |
| let γ (q : C) := (1+8*((j q).val:ℝ))*g |
| let T (x : G) := fastSet (A x).lam (γ (P x)) |
| let ref (x : G) : G := (reference P G (key P G x)).val |
| have hzero (x : G) (U : Finset (Fin d)) : |
| ((A x).forward I S a c).space U=(A x).forwardSpace I S a c 0 U := by |
| simp only [ShortBin.Gauge.space,BilateralGauge.forward,ShortBin.Gauge.ofFinite, |
| Nat.zero_min,BilateralGauge.forwardSpace] |
| refine ⟨γ,T,ref,Wf,Wb,rfl,?_,?_,hcard,?_,hslow,hfast,?_,?_⟩ |
| · intro q |
| have hγ : 0≤γ q := by dsimp only [γ]; positivity |
| rw [abs_of_nonneg hγ,abs_of_nonneg hg.le] |
| have hj : ((j q).val:ℝ)≤d := by exact_mod_cast (show (j q).val≤d by omega) |
| have hm := mul_le_mul_of_nonneg_right hj hg.le |
| dsimp only [γ]; nlinarith only [hm] |
| · intro x; exact (reference P G (key P G x)).property |
| · intro x y hxy |
| have he : key P G x=key P G y := Subtype.ext hxy |
| exact congrArg (fun q : Active P G => (reference P G q).val) he |
| · intro x |
| have hh := hstart x |
| simp only [hzero] at hh |
| have he : 3*(Real.exp (-2*g*(N:ℝ)+4*(B+Real.log D))+ |
| (((N:ℝ)*C₁*C₁^(2*N)+N*C₂*C₂^(2*N))*h)*Real.exp ((1+8*(d:ℝ))*g*N+2*(B+Real.log D)))≤ε := by |
| simpa only [refError,refNoise,←add_mul] using herr3 |
| constructor |
| · rw [norm_sub_rev]; exact hh.1.trans he |
| · rw [norm_sub_rev]; exact hh.2.trans he |
| · intro x |
| have hx := hend' x |
| refine ⟨hx.1,hx.2.1,?_,?_⟩ |
| · have hh := hfsmall (j (P x)); dsimp only [refNoise] at hh |
| have hb : 3*(Real.exp ((γ (P x)-g)*N+2*(B+Real.log D₃))* |
| (Real.exp ((-γ (P x)-g)*N+2*(B+Real.log D₃))+N*C₃*C₃^(2*N)*h))≤ε := by linarith |
| exact hx.2.2.1.trans (hb.trans hεhalf) |
| · have hh := hbsmall (j (P x)); dsimp only [refNoise] at hh |
| have hb : 3*(Real.exp ((-γ (P x)-g)*N+2*(B+Real.log D₄))* |
| (Real.exp ((γ (P x)-g)*N+2*(B+Real.log D₄))+N*C₄*C₄^(2*N)*h))≤ε := by linarith |
| exact hx.2.2.2.trans (hb.trans hεhalf) |
| end SmoothObstruction.ManifoldCoordinates |
|
|
| end |
|
|
| end OAI |
|
|
