| import OAI.Geometry.CylinderCovering.Singular.EdgeOneCover | |
| import OAI.Geometry.CylinderCovering.Singular.EdgeOneDifferential | |
| import OAI.Geometry.CylinderCovering.Singular.Orthogonal | |
| namespace OAI | |
| noncomputable section | |
| open Set MeasureTheory Filter Topology | |
| namespace CylinderCovering.SingularEdgeOneCover | |
| open RuledApproximation | |
| lemma labelMap_image {p c d q : ℝ} | |
| (hcap : ∀ b ∈ FlexibleSingular.labelDomain p c d q, b 1 ≤ 1) : | |
| SingularEdgeOne.labelMap '' FlexibleSingular.labelDomain p c d q = | |
| labelDomain p (4*c) d q := by | |
| ext b | |
| constructor | |
| · rintro ⟨a,ha,rfl⟩ | |
| exact (label_dictionary hcap a).mpr ha | |
| · intro hb | |
| refine ⟨vec2 (2*b 0) (b 1),?_,label_expand_contract b⟩ | |
| apply (label_dictionary hcap _).mp | |
| simpa only [label_expand_contract] using hb | |
| lemma cost_dictionary {p c d q : ℝ} (hd : 0 < d) | |
| (hcap : ∀ b ∈ FlexibleSingular.labelDomain p c d q, b 1 ≤ 1) : | |
| cost p (4*c) d q = FlexibleSingular.cost p c d q/4 := by | |
| have he := SingularEdgeOne.physical_cost_dictionary p c | |
| (FlexibleSingular.labelDomain_isCompact p c d q).measurableSet | |
| (fun b hb => hd.trans_le hb.1) | |
| rw [labelMap_image hcap] at he | |
| exact he | |
| lemma cost_dictionary_eventually {p : ℝ} {ρ q : ℝ → ℝ} | |
| (hadm : SingularCutoff.Admissible p ρ q) : | |
| ∀ᶠ k : ℝ in 𝓝[>] 0, | |
| cost p k (ρ (k/4)) (q (k/4)) = | |
| FlexibleSingular.cost p (k/4) (ρ (k/4)) (q (k/4))/4 := by | |
| filter_upwards [transport_zero_tendsto.eventually | |
| (FlexibleSingular.labelDomain_eq_upper_one hadm), | |
| transport_zero_tendsto.eventually hadm.1] with k hdom hpos | |
| have hcap : ∀ b ∈ FlexibleSingular.labelDomain p (k/4) (ρ (k/4)) (q (k/4)), | |
| b 1 ≤ 1 := by | |
| intro b hb | |
| rw [hdom] at hb | |
| exact hb.2.1 | |
| have h := cost_dictionary hpos.1 hcap | |
| simpa only [show 4*(k/4)=k by ring] using h | |
| lemma cost_quotient_tendsto {p : ℝ} {ρ q : ℝ → ℝ} | |
| (hp : 1 < p) (hp2 : p ≤ 2) (hadm : SingularCutoff.Admissible p ρ q) : | |
| Tendsto (fun k : ℝ => | |
| (cost p k (ρ (k/4)) (q (k/4))/height-1/8)/k^2) | |
| (𝓝[>] 0) (𝓝 (singularCoefficient p/32)) := by | |
| have h := ((FlexibleSingular.weighted_integral_tendsto hp hp2 hadm).comp | |
| transport_zero_tendsto).div_const 32 | |
| apply h.congr' | |
| filter_upwards [cost_dictionary_eventually hadm,self_mem_nhdsWithin] with k hk hk0 | |
| have hk0 : k ≠ 0 := ne_of_gt hk0 | |
| dsimp only [Function.comp_apply] | |
| rw [hk,height_eq] | |
| unfold FlexibleSingular.cost | |
| have hs : Real.sqrt 2 ≠ 0 := ne_of_gt (Real.sqrt_pos.mpr (by norm_num)) | |
| field_simp | |
| ring | |
| lemma cost_asymptotic {p : ℝ} {ρ q : ℝ → ℝ} | |
| (hp : 1 < p) (hp2 : p ≤ 2) (hadm : SingularCutoff.Admissible p ρ q) : | |
| Asymptotics.IsLittleO (𝓝[>] (0:ℝ)) | |
| (fun k => cost p k (ρ (k/4)) (q (k/4))/height- | |
| (1/8+singularCoefficient p/32*k^2)) (fun k => k^2) := by | |
| rw [Asymptotics.isLittleO_iff_tendsto'] | |
| · have h := (cost_quotient_tendsto hp hp2 hadm).sub_const (singularCoefficient p/32) | |
| simp only [sub_self] at h | |
| apply h.congr' | |
| filter_upwards [self_mem_nhdsWithin] with k hk | |
| have hk0 : k ≠ 0 := ne_of_gt hk | |
| field_simp | |
| ring | |
| · filter_upwards [self_mem_nhdsWithin] with k hk | |
| exact fun h => False.elim ((pow_ne_zero 2 (ne_of_gt hk)) h) | |
| lemma totalCost_small {p : ℝ} {ρ q : ℝ → ℝ} | |
| (hp : 1 < p) (hp2 : p ≤ 2) (hadm : SingularCutoff.Admissible p ρ q) | |
| (hcoef : singularCoefficient p < 0) : | |
| ∀ᶠ k : ℝ in 𝓝[>] 0, | |
| 2*cost p k (ρ (k/4)) (q (k/4))+4*height*(ρ (k/4))^2 < height/4 := by | |
| filter_upwards [cost_dictionary_eventually hadm, | |
| transport_zero_tendsto.eventually (FlexibleSingular.totalCost_small hp hp2 hadm hcoef)] | |
| with k hdict hsmall | |
| rw [hdict,height_eq] | |
| nlinarith only [hsmall] | |
| lemma finite_families_eventually {p : ℝ} {ρ q : ℝ → ℝ} | |
| (hp : 1 < p) (hp2 : p < 2) (hadm : SingularCutoff.Admissible p ρ q) : | |
| ∀ᶠ k : ℝ in 𝓝[>] 0, ∀ e : ℝ, 0 < e → | |
| HasFiniteCover Cylinder.parallelogram (lowerFamily p k (ρ (k/4)) (q (k/4))) | |
| (cost p k (ρ (k/4)) (q (k/4))+e) ∧ | |
| HasFiniteCover Cylinder.parallelogram (upperFamily p k (ρ (k/4)) (q (k/4))) | |
| (cost p k (ρ (k/4)) (q (k/4))+e) := by | |
| filter_upwards [cost_dictionary_eventually hadm, | |
| transport_zero_tendsto.eventually (FlexibleSingular.orthogonal_families_eventually hp hp2 hadm), | |
| transport_zero_tendsto.eventually (FlexibleSingular.labelDomain_eq_upper_one hadm), | |
| transport_zero_tendsto.eventually hadm.1] with k hdict hfam hdom hpos | |
| have hcap : ∀ b ∈ FlexibleSingular.labelDomain p (k/4) (ρ (k/4)) (q (k/4)), | |
| b 1 ≤ 1 := by | |
| intro b hb | |
| rw [hdom] at hb | |
| exact hb.2.1 | |
| intro e he | |
| obtain ⟨hlow,hupp⟩ := hfam (4*e) (by positivity) | |
| have hl := hlow.parallelogram_similarity 0 half_ne swap | |
| have hu := hupp.parallelogram_similarity 0 half_ne swap | |
| rw [← map_eq_similarity,map_image_lowerFamily hpos.1 hcap, | |
| show 4*(k/4)=k by ring] at hl | |
| rw [← map_eq_similarity,map_image_upperFamily hpos.1 hcap, | |
| show 4*(k/4)=k by ring] at hu | |
| constructor | |
| · convert hl using 1 | |
| rw [hdict] | |
| ring | |
| · convert hu using 1 | |
| rw [hdict] | |
| ring | |
| theorem cost_statement : CostStatement := by | |
| intro p ρ q hp hp' hadm | |
| have hs := Real.sq_sqrt (show (0:ℝ)≤51 by norm_num) | |
| have hn := Real.sqrt_nonneg (51:ℝ) | |
| have hp2 : p < 2 := by nlinarith | |
| have hcoef := (FlexibleSingular.flexible_singular p ρ q hp hp' hadm).1 | |
| refine ⟨cost_asymptotic hp hp2.le hadm,?_⟩ | |
| filter_upwards [totalCost_small hp hp2.le hadm hcoef, | |
| finite_families_eventually hp hp2 hadm] with k hsmall hfam | |
| exact ⟨hsmall,hfam⟩ | |
| theorem alternative_cost : AlternativeCostStatement := by | |
| intro p β hp hp' hβ hβp | |
| have hs := Real.sq_sqrt (show (0:ℝ)≤51 by norm_num) | |
| have hn := Real.sqrt_nonneg (51:ℝ) | |
| have hp2 : p < 2 := by nlinarith | |
| have hadm := SingularCutoff.edge_one_alternative_admissible hp2 hβ hβp | |
| have hm := cost_statement p (SingularCutoff.powerCutoff 4 β) | |
| (SingularCutoff.powerPadding 4 1 (5/2)) hp hp' hadm | |
| simpa only [SingularCutoff.powerCutoff,SingularCutoff.powerPadding,one_mul, | |
| show ∀ k : ℝ, 4*(k/4)=k from fun k => by ring] using hm | |
| end CylinderCovering.SingularEdgeOneCover | |
| end | |
| end OAI | |