Download data/lean/OAI/Geometry/HyperbolicGroups/ConditionalStar.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 21.1 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/HyperbolicGroups/ConditionalStar.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/HyperbolicGroups/ConditionalStar.lean
-
curl -L -o ConditionalStar.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/HyperbolicGroups/ConditionalStar.lean
21.1 kB
| import Mathlib | |
| import OAI.Geometry.HyperbolicGroups.MetricProduct | |
| namespace OAI | |
| section | |
| section | |
| noncomputable section | |
| open scoped Topology ContinuousMap | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| noncomputable section | |
| open scoped BigOperators ENNReal | |
| noncomputable section | |
| noncomputable section | |
| open Filter Topology | |
| noncomputable section | |
| noncomputable section | |
| open scoped BigOperators | |
| noncomputable section | |
| open scoped BigOperators | |
| open Filter Topology | |
| namespace HyperbolicObstruction | |
| /-- A conditional star: branches agree exactly on the named fields. | |
| The finite law placed on it below need not be uniform. -/ | |
| def ConditionalStar {F L Ξ© : Type*} [DecidableEq F] (label : Ξ© β F β L) | |
| (I : Finset F) (k : β) := | |
| {b : Fin (k + 1) β Ξ© // β j i, i β I β label (b j) i = label (b 0) i} | |
| namespace ConditionalStar | |
| variable {F L Ξ© : Type*} [DecidableEq F] {label : Ξ© β F β L} {I : Finset F} {k : β} | |
| instance [Fintype Ξ©] [DecidableEq L] : Fintype (ConditionalStar label I k) := | |
| inferInstanceAs (Fintype {branches : Fin (k + 1) β Ξ© // | |
| β branch field, field β I β label (branches branch) field = label (branches 0) field}) | |
| def branch (j : Fin (k + 1)) (b : ConditionalStar label I k) : Ξ© := b.val j | |
| lemma agree (b : ConditionalStar label I k) (j : Fin (k + 1)) (i : F) (hi : i β I) : | |
| label (branch j b) i = label (branch 0 b) i := b.property j i hi | |
| end ConditionalStar | |
| /-- Only combinatorial sampling assertions occur here, independent of the action | |
| that may be chosen after the random tables have been exposed. This is not a | |
| replacement for the random-table producer. -/ | |
| structure SamplingSequence (F : Type*) [DecidableEq F] (Admissible : Finset F β Prop) | |
| (L Ξ© : β β Type*) [β n, Fintype (L n)] [β n, Nonempty (L n)] | |
| [β n, DecidableEq (L n)] [β n, Fintype (Ξ© n)] [β n, Nonempty (Ξ© n)] | |
| (label : β n, Ξ© n β F β L n) where | |
| singleton : β e : F, Tendsto (fun n => | |
| ((FiniteLaw.uniform : FiniteLaw (Ξ© n)).map (fun a => label n a e)).totalVariation | |
| FiniteLaw.uniform) atTop (π 0) | |
| star : β (I : Finset F) (e : F), e β I β Admissible (insert e I) β β k : β, | |
| β Ξ· : β β β, Tendsto Ξ· atTop (π 0) β§ βαΆ n in atTop, | |
| β ΞΊ : FiniteLaw (ConditionalStar (label n) I k), | |
| (β j, (ΞΊ.map (ConditionalStar.branch j)).totalVariation FiniteLaw.uniform β€ Ξ· n) β§ | |
| (ΞΊ.map (fun b j => label n (ConditionalStar.branch j b) e)).totalVariation | |
| (FiniteLaw.uniform : FiniteLaw (Fin (k + 1) β L n)) β€ Ξ· n | |
| /-- Actual normalized orbit points along a symmetric finite generator list. -/ | |
| structure EnergyOrbit (L X : Type*) [Fintype L] [MetricSpace X] (M : β) where | |
| cat : CATZero X | |
| base : X | |
| isom : L β X βα΅’ X | |
| inverse : L β L | |
| symmetric : β i, isom (inverse i) = (isom i).symm | |
| minimum : β y : X, (β i, dist base (isom i base) ^ 2) β€ β i, dist y (isom i y) ^ 2 | |
| energy : (πΌ i, dist base (isom i base) ^ 2) = 1 | |
| bound : β i, dist base (isom i base) β€ M | |
| namespace EnergyOrbit | |
| variable {L X : Type*} [Fintype L] [MetricSpace X] {M : β} (O : EnergyOrbit L X M) | |
| abbrev Cone := TangentCone O.cat O.base | |
| abbrev cone : ConeData O.Cone := TangentCone.coneData O.cat O.base | |
| def vector (i : L) : O.Cone := TangentCone.log O.cat O.base (O.isom i O.base) | |
| lemma normSq_vector (i : L) : O.cone.normSq (O.vector i) = dist O.base (O.isom i O.base) ^ 2 := | |
| TangentCone.normSq_log O.cat O.base _ | |
| lemma norm_vector (i : L) : dist O.cone.vertex (O.vector i) = dist O.base (O.isom i O.base) := by | |
| have he := O.normSq_vector i | |
| exact (sq_eq_sqβ dist_nonneg dist_nonneg).mp he | |
| lemma barycenter (u : O.Cone) : (πΌ i, O.cone.pairing u (O.vector i)) β€ 0 := by | |
| rw [Fintype.expect_eq_sum_div_card] | |
| exact div_nonpos_of_nonpos_of_nonneg | |
| (energy_tangent_barycenter O.cat O.isom O.inverse O.symmetric O.base O.minimum u) | |
| (by positivity) | |
| lemma energy_vector : (πΌ i, O.cone.normSq (O.vector i)) = 1 := by | |
| simp_rw [O.normSq_vector] | |
| exact O.energy | |
| lemma barycenter_read (Ο : L β L) (u : O.Cone) : | |
| (πΌ i, O.cone.pairing u (O.vector (Ο i))) β€ 0 := by | |
| rw [Fintype.expect_eq_sum_div_card, Ο.sum_comp (fun i => O.cone.pairing u (O.vector i))] | |
| simpa only [Fintype.expect_eq_sum_div_card] using O.barycenter u | |
| lemma energy_read (Ο : L β L) : (πΌ i, O.cone.normSq (O.vector (Ο i))) = 1 := by | |
| rw [Fintype.expect_eq_sum_div_card, Ο.sum_comp (fun i => O.cone.normSq (O.vector i))] | |
| simpa only [Fintype.expect_eq_sum_div_card] using O.energy_vector | |
| end EnergyOrbit | |
| namespace SamplingSequence | |
| universe u v w | |
| variable {F : Type u} [DecidableEq F] {Admissible : Finset F β Prop} | |
| {L Ξ© : β β Type v} [β n, Fintype (L n)] [β n, Nonempty (L n)] | |
| [β n, DecidableEq (L n)] [β n, Fintype (Ξ© n)] [β n, Nonempty (Ξ© n)] | |
| {label : β n, Ξ© n β F β L n} (S : SamplingSequence F Admissible L Ξ© label) | |
| {X : β β Type w} [β n, MetricSpace (X n)] {M : β} | |
| (O : β n, EnergyOrbit (L n) (X n) M) | |
| include S | |
| /-- The conditional test applies to arbitrary bounded action-dependent tests, | |
| including tests using inverses of any field labels. -/ | |
| theorem conditional {I : Finset F} {e : F} (he : e β I) (hI : Admissible (insert e I)) | |
| (Ο : β n, L n β L n) (test : β n, Ξ© n β (O n).Cone) | |
| (depends : β n a b, (β i β I, label n a i = label n b i) β test n a = test n b) | |
| {B : β} (hM : 0 β€ M) (hB : 0 β€ B) | |
| (htest : β n a, dist (O n).cone.vertex (test n a) β€ B) : | |
| β Ξ΅ : β, 0 < Ξ΅ β βαΆ n in atTop, | |
| (πΌ a, (O n).cone.pairing (test n a) ((O n).vector (Ο n (label n a e)))) < Ξ΅ := by | |
| apply conditional_test_eventually | |
| intro k | |
| obtain β¨Ξ·, hΞ·, hΞΊβ© := S.star I e he hI k | |
| refine β¨Ξ·, hΞ·, ?_β© | |
| filter_upwards [hΞΊ] with n hn | |
| obtain β¨ΞΊ, hbranch, hleafβ© := hn | |
| have hh := (O n).cone.conditional_test (TangentCone.catZero (O n).cat (O n).base) | |
| (FiniteLaw.uniform : FiniteLaw (Ξ© n)) ΞΊ (fun i => (O n).vector (Ο n i)) | |
| ((O n).barycenter_read (Ο n)) ((O n).energy_read (Ο n)) | |
| (test n) (fun a => label n a e) k ConditionalStar.branch | |
| (fun j b => depends n _ _ (fun i hi => ConditionalStar.agree b j i hi)) hM hB | |
| (fun i => by rw [(O n).norm_vector]; exact (O n).bound _) | |
| (htest n) hbranch hleaf | |
| rwa [FiniteLaw.expect_uniform] at hh | |
| /-- Single-field convergence remains usable uniformly after the action has | |
| been chosen: the displacement functions only need the uniform letter bound. -/ | |
| theorem edge_energy (e : F) (Ο : β n, L n β L n) (hM : 0 β€ M) : | |
| Tendsto (fun n => πΌ a, dist (O n).base ((O n).isom (Ο n (label n a e)) (O n).base) ^ 2) | |
| atTop (π 1) := by | |
| let Ξ· (n : β) := ((FiniteLaw.uniform : FiniteLaw (Ξ© n)).map (fun a => label n a e)).totalVariation | |
| FiniteLaw.uniform | |
| have he : β n, |(πΌ a, dist (O n).base ((O n).isom (Ο n (label n a e)) (O n).base) ^ 2) - 1| β€ | |
| 2 * M ^ 2 * Ξ· n := by | |
| intro n | |
| have hb : β i, |dist (O n).base ((O n).isom (Ο n i) (O n).base) ^ 2| β€ M ^ 2 := by | |
| intro i | |
| rw [abs_of_nonneg (sq_nonneg _)] | |
| exact (sq_le_sqβ dist_nonneg hM).mpr ((O n).bound _) | |
| have hh := (((FiniteLaw.uniform : FiniteLaw (Ξ© n)).map (fun a => label n a e))).expect_sub_bound | |
| FiniteLaw.uniform (fun i => dist (O n).base ((O n).isom (Ο n i) (O n).base) ^ 2) hb | |
| simp only [FiniteLaw.expect_map, FiniteLaw.expect_uniform, Fintype.expect_eq_sum_div_card, | |
| Function.comp_def] at hh | |
| rw [(Ο n).sum_comp (fun i => dist (O n).base ((O n).isom i (O n).base) ^ 2)] at hh | |
| have hn := (O n).energy | |
| rw [Fintype.expect_eq_sum_div_card] at hn | |
| rw [hn] at hh | |
| simpa only [Fintype.expect_eq_sum_div_card] using hh | |
| have ht : Tendsto (fun n => 2 * M ^ 2 * Ξ· n) atTop (π 0) := by | |
| simpa using (S.singleton e).const_mul (2 * M ^ 2) | |
| have hz : Tendsto (fun n => (πΌ a, dist (O n).base ((O n).isom (Ο n (label n a e)) (O n).base) ^ 2) - 1) atTop (π 0) := by | |
| apply squeeze_zero_norm' _ ht | |
| filter_upwards [] with n | |
| simpa only [Real.norm_eq_abs] using he n | |
| have hh := hz.add_const 1 | |
| simpa only [sub_add_cancel, zero_add] using hh | |
| end SamplingSequence | |
| end HyperbolicObstruction | |
| noncomputable section | |
| open scoped BigOperators | |
| open Filter Topology | |
| namespace HyperbolicObstruction | |
| namespace EnergyOrbit | |
| /-- Six-letter relative counts provide the bound M=8 for the rescaled genuine | |
| geometric action; no bound on the action is assumed before sampling. -/ | |
| theorem exists_of_geometric {L G X : Type*} [Fintype L] [Nonempty L] [Group G] | |
| [Infinite G] [MetricSpace X] [Nonempty X] [ProperSpace X] | |
| (hX : CATZero X) (A : GeometricAction G X) (letter : L β G) (inv : L β L) | |
| (hinv : β i, letter (inv i) = (letter i)β»ΒΉ) | |
| (hgen : Subgroup.closure (Set.range letter) = β€) | |
| (Row : L β Type*) [β i, Fintype (Row i)] (ΞΊ : β i, FiniteLaw (Row i)) | |
| (row : β i, Row i β Fin 5 β L) | |
| (hrow : β i b, (List.ofFn (letter β row i b)).prod = (letter i)β»ΒΉ) | |
| (hmarg : β i j a, ((ΞΊ i).map (fun b => row i b j)).mass a β€ 2 / Fintype.card L) : | |
| β r : β, β hr : 0 < r, β O : EnergyOrbit L (MetricScale.Space r hr X) 8, | |
| β i, O.isom i = MetricScale.action A.act (letter i) := by | |
| obtain β¨r, hr, o, hen, hminβ© := IsometricAction.normalized_minimum A letter hgen | |
| refine β¨r, hr, β¨MetricScale.catZero hX, o, fun i => MetricScale.action A.act (letter i), | |
| inv, ?_, hmin, hen, ?_β©, fun _ => rflβ© | |
| Β· intro i | |
| rw [hinv, map_inv] | |
| rfl | |
| Β· intro i | |
| have hh := IsometricAction.six_letter_displacement_bound | |
| (MetricScale.action A.act) o letter hen (letter i) (ΞΊ i) (row i) (hrow i) (hmarg i) | |
| nlinarith [dist_nonneg (x := o) (y := MetricScale.action A.act (letter i) o)] | |
| end EnergyOrbit | |
| namespace IsometricAction | |
| variable {G X : Type*} [Group G] [MetricSpace X] | |
| lemma displacement_mul_dist (A : G β* (X βα΅’ X)) (o : X) (g k : G) : | |
| dist o (A (g * k) o) = dist (A gβ»ΒΉ o) (A k o) := by | |
| have hh := (A g).isometry.dist_eq (A gβ»ΒΉ o) (A k o) | |
| have hg : A g (A gβ»ΒΉ o) = o := by | |
| rw [β IsometryEquiv.mul_apply, β map_mul, mul_inv_cancel, map_one] | |
| rfl | |
| rw [hg, β IsometryEquiv.mul_apply, β map_mul] at hh | |
| exact hh | |
| end IsometricAction | |
| namespace OrbitWord | |
| variable {F L Ξ© G X : Type*} [Group G] | |
| def word (label : Ξ© β F β L) (Ο : F β L β L) (letter : L β G) (a : Ξ©) (w : List F) : G := | |
| (w.map (fun e => letter (Ο e (label a e)))).prod | |
| lemma nil (label : Ξ© β F β L) (Ο : F β L β L) (letter : L β G) (a : Ξ©) : | |
| word label Ο letter a [] = 1 := rfl | |
| lemma cons (label : Ξ© β F β L) (Ο : F β L β L) (letter : L β G) (a : Ξ©) (e : F) (w : List F) : | |
| word label Ο letter a (e :: w) = letter (Ο e (label a e)) * word label Ο letter a w := rfl | |
| lemma depends (label : Ξ© β F β L) (Ο : F β L β L) (letter : L β G) (a b : Ξ©) (w : List F) | |
| (he : β i β w, label a i = label b i) : word label Ο letter a w = word label Ο letter b w := by | |
| unfold word | |
| congr 1 | |
| apply List.map_congr_left | |
| intro i hi | |
| rw [he i hi] | |
| lemma bound [MetricSpace X] (A : G β* (X βα΅’ X)) (o : X) (label : Ξ© β F β L) | |
| (Ο : F β L β L) (letter : L β G) {M : β} | |
| (hb : β i, dist o (A (letter i) o) β€ M) (a : Ξ©) (w : List F) : | |
| dist o (A (word label Ο letter a w) o) β€ w.length * M := by | |
| induction w with | |
| | nil => simp [nil] | |
| | cons e w ih => | |
| rw [cons] | |
| have hh := (IsometricAction.displacement_mul_le A o (letter (Ο e (label a e))) _).trans (add_le_add (hb (Ο e (label a e))) ih) | |
| simpa only [List.length_cons, Nat.cast_add, Nat.cast_one, add_mul, one_mul, add_comm M] using hh | |
| end OrbitWord | |
| namespace SamplingSequence | |
| universe u v w z | |
| variable {F : Type u} [DecidableEq F] {Admissible : Finset F β Prop} | |
| {L Ξ© : β β Type v} [β n, Fintype (L n)] [β n, Nonempty (L n)] | |
| [β n, DecidableEq (L n)] [β n, Fintype (Ξ© n)] [β n, Nonempty (Ξ© n)] | |
| {label : β n, Ξ© n β F β L n} (S : SamplingSequence F Admissible L Ξ© label) | |
| {X : β β Type w} [β n, MetricSpace (X n)] {M : β} | |
| (O : β n, EnergyOrbit (L n) (X n) M) | |
| {G : β β Type z} [β n, Group (G n)] | |
| (A : β n, G n β* (X n βα΅’ X n)) (letter : β n, L n β G n) | |
| (hact : β n i, A n (letter n i) = (O n).isom i) | |
| include S hact | |
| /-- Path lower bounds are produced from the sampling assertions and the action, | |
| not postulated as a limiting configuration. The proof uses only finite sums and | |
| one-sided vanishing errors, so the spaces/actions can vary with n. -/ | |
| theorem word_lower (down : β I J, I β J β Admissible J β Admissible I) | |
| (Ο : β n, F β L n β L n) (hM : 0 β€ M) (w : List F) (hw : w.Nodup) | |
| (hadm : Admissible w.toFinset) : | |
| β Ξ΅ : β, 0 < Ξ΅ β βαΆ n in atTop, | |
| (w.length : β) - Ξ΅ β€ | |
| πΌ a, dist (O n).base (A n (OrbitWord.word (label n) (Ο n) (letter n) a w) (O n).base) ^ 2 := by | |
| induction w with | |
| | nil => | |
| intro Ξ΅ hΞ΅ | |
| filter_upwards [] with n | |
| simpa [OrbitWord.nil] using hΞ΅.le | |
| | cons e w ih => | |
| have hnot : e β w.toFinset := by simpa using (List.nodup_cons.mp hw).1 | |
| have hadm' : Admissible w.toFinset := down _ _ (by simp) hadm | |
| have hw' := (List.nodup_cons.mp hw).2 | |
| let test (n : β) (a : Ξ© n) : (O n).Cone := TangentCone.log (O n).cat (O n).base | |
| (A n (OrbitWord.word (label n) (Ο n) (letter n) a w) (O n).base) | |
| let Ο' (n : β) : L n β L n := (Ο n e).trans (O n).inverse | |
| have htest : β n a, dist (O n).cone.vertex (test n a) β€ w.length * M := by | |
| intro n a | |
| change dist (TangentCone.vertex (O n).cat (O n).base) (test n a) β€ _ | |
| rw [TangentCone.dist_vertex_log] | |
| exact OrbitWord.bound (A n) (O n).base (label n) (Ο n) (letter n) | |
| (fun i => by rw [hact]; exact (O n).bound i) a w | |
| have hc := S.conditional O hnot (by simpa using hadm) Ο' test | |
| (fun n a b hab => by | |
| dsimp only [test] | |
| rw [OrbitWord.depends (label n) (Ο n) (letter n) a b w | |
| (fun i hi => hab i (by simpa using hi))]) | |
| hM (mul_nonneg (by positivity) hM) htest | |
| have hedge := S.edge_energy O e Ο' hM | |
| have hineq (n : β) : | |
| (πΌ a, dist (O n).base (A n (OrbitWord.word (label n) (Ο n) (letter n) a w) (O n).base) ^ 2) + | |
| (πΌ a, dist (O n).base ((O n).isom (Ο' n (label n a e)) (O n).base) ^ 2) - | |
| 2 * (πΌ a, (O n).cone.pairing (test n a) ((O n).vector (Ο' n (label n a e)))) β€ | |
| πΌ a, dist (O n).base (A n (OrbitWord.word (label n) (Ο n) (letter n) a (e :: w)) (O n).base) ^ 2 := by | |
| rw [β Finset.expect_add_distrib, Finset.mul_expect, β Finset.expect_sub_distrib] | |
| apply Finset.expect_le_expect | |
| intro a _ | |
| have he : (O n).isom (Ο' n (label n a e)) = (A n (letter n (Ο n e (label n a e)))).symm := by | |
| simpa only [Ο', Equiv.trans_apply, hact] using (O n).symmetric (Ο n e (label n a e)) | |
| have hp := TangentCone.pairing_log_ge (O n).cat (O n).base | |
| (A n (OrbitWord.word (label n) (Ο n) (letter n) a w) (O n).base) | |
| ((O n).isom (Ο' n (label n a e)) (O n).base) | |
| have hd : dist (O n).base (A n (OrbitWord.word (label n) (Ο n) (letter n) a (e :: w)) (O n).base) = | |
| dist (A n (OrbitWord.word (label n) (Ο n) (letter n) a w) (O n).base) | |
| ((O n).isom (Ο' n (label n a e)) (O n).base) := by | |
| rw [OrbitWord.cons, IsometricAction.displacement_mul_dist, dist_comm, he, map_inv] | |
| rfl | |
| rw [hd] | |
| change _ - 2 * (O n).cone.pairing | |
| (TangentCone.log (O n).cat (O n).base _) (TangentCone.log (O n).cat (O n).base _) β€ _ | |
| linarith | |
| intro Ξ΅ hΞ΅ | |
| have h1 := ih hw' hadm' (Ξ΅ / 3) (by positivity) | |
| have h2 := hedge.eventually (lt_mem_nhds (show 1 - Ξ΅ / 3 < (1 : β) by linarith)) | |
| have h3 := hc (Ξ΅ / 6) (by positivity) | |
| filter_upwards [h1, h2, h3] with n hnβ hnβ hnβ | |
| have hh := hineq n | |
| simp only [List.length_cons, Nat.cast_add, Nat.cast_one] | |
| linarith | |
| end SamplingSequence | |
| end HyperbolicObstruction | |
| noncomputable section | |
| open scoped BigOperators | |
| open Filter Topology | |
| namespace HyperbolicObstruction | |
| namespace CATZero | |
| variable {X : Type*} [MetricSpace X] | |
| lemma isometry_segment (h : CATZero X) (e : X βα΅’ X) (x y : X) {t : β} | |
| (ht : t β Set.Icc (0 : β) 1) : | |
| e (segment h x y t) = segment h (e x) (e y) t := | |
| map_segment_of_dist h h e (fun a b => (e.isometry.dist_eq a b).le) x y | |
| (e.isometry.dist_eq x y) ht | |
| /-- Comparison at fixed fractions is taken before forming the ultralimit. -/ | |
| lemma fractional_log_comparison (h : CATZero X) (o x y : X) {a b : β} | |
| (ha : a β Set.Icc (0 : β) 1) (hb : b β Set.Icc (0 : β) 1) : | |
| a ^ 2 * dist o x ^ 2 + b ^ 2 * dist o y ^ 2 - | |
| 2 * a * b * (TangentCone.coneData h o).pairing | |
| (TangentCone.log h o x) (TangentCone.log h o y) β€ | |
| dist (segment h o x a) (segment h o y b) ^ 2 := by | |
| have hh := (sq_le_sqβ dist_nonneg dist_nonneg).mpr | |
| (TangentCone.dist_log_le h o (segment h o x a) (segment h o y b)) | |
| rw [TangentCone.log_radial h o x ha, TangentCone.log_radial h o y hb, | |
| (TangentCone.coneData h o).dist_sq, | |
| (TangentCone.coneData h o).normSq_scale ha.1, | |
| (TangentCone.coneData h o).normSq_scale hb.1, | |
| (TangentCone.coneData h o).pairing_scale ha.1 hb.1, | |
| TangentCone.normSq_log, TangentCone.normSq_log] at hh | |
| nlinarith only [hh] | |
| end CATZero | |
| namespace SamplingSequence | |
| universe u v w | |
| variable {F : Type u} [DecidableEq F] {Admissible : Finset F β Prop} | |
| {L Ξ© : β β Type v} [β n, Fintype (L n)] [β n, Nonempty (L n)] | |
| [β n, DecidableEq (L n)] [β n, Fintype (Ξ© n)] [β n, Nonempty (Ξ© n)] | |
| {label : β n, Ξ© n β F β L n} (S : SamplingSequence F Admissible L Ξ© label) | |
| {X : β β Type w} [β n, MetricSpace (X n)] {M : β} | |
| (O : β n, EnergyOrbit (L n) (X n) M) | |
| include S | |
| /-- Uniform fractional-distance comparison for any bounded point function of | |
| I, after translations depending on the whole match. -/ | |
| theorem fractional_error {I : Finset F} {e : F} (he : e β I) | |
| (hI : Admissible (insert e I)) (Ο : β n, L n β L n) | |
| (test : β n, Ξ© n β X n) | |
| (depends : β n a b, (β i β I, label n a i = label n b i) β test n a = test n b) | |
| {B : β} (hM : 0 β€ M) (hB : 0 β€ B) (htest : β n a, dist (O n).base (test n a) β€ B) | |
| (frame : β n, Ξ© n β X n βα΅’ X n) {a b : β} | |
| (ha : a β Set.Icc (0 : β) 1) (hb : b β Set.Icc (0 : β) 1) : | |
| β Ξ΅ : β, 0 < Ξ΅ β βαΆ n in atTop, | |
| a ^ 2 * (πΌ m, dist (frame n m (O n).base) (frame n m (test n m)) ^ 2) + | |
| b ^ 2 * (πΌ m, dist (frame n m (O n).base) | |
| (frame n m ((O n).isom (Ο n (label n m e)) (O n).base)) ^ 2) - Ξ΅ β€ | |
| πΌ m, dist | |
| (CATZero.segment (O n).cat (frame n m (O n).base) (frame n m (test n m)) a) | |
| (CATZero.segment (O n).cat (frame n m (O n).base) | |
| (frame n m ((O n).isom (Ο n (label n m e)) (O n).base)) b) ^ 2 := by | |
| let logTest (n : β) (m : Ξ© n) := TangentCone.log (O n).cat (O n).base (test n m) | |
| have hc := S.conditional O he hI Ο logTest | |
| (fun n m k hh => by simp only [logTest, depends n m k hh]) hM hB | |
| (fun n m => by | |
| change dist (TangentCone.vertex _ _) _ β€ B | |
| rw [TangentCone.dist_vertex_log] | |
| exact htest n m) | |
| intro Ξ΅ hΞ΅ | |
| filter_upwards [hc (Ξ΅ / 2) (by positivity)] with n hn | |
| have hi := Finset.expect_le_expect (s := Finset.univ) | |
| (fun (m : Ξ© n) _ => CATZero.fractional_log_comparison (O n).cat (O n).base | |
| (test n m) ((O n).isom (Ο n (label n m e)) (O n).base) ha hb) | |
| simp only [Finset.expect_sub_distrib, Finset.expect_add_distrib, β Finset.mul_expect] at hi | |
| simp only [(frame n _).isometry.dist_eq, β CATZero.isometry_segment (O n).cat (frame n _) _ _ ha, | |
| β CATZero.isometry_segment (O n).cat (frame n _) _ _ hb] | |
| have hab : 0 β€ 2 * a * b := mul_nonneg (mul_nonneg (by norm_num) ha.1) hb.1 | |
| have hab' : 2 * a * b β€ 2 := by nlinarith [mul_le_mul ha.2 hb.2 hb.1 (by norm_num : (0:β) β€ 1)] | |
| have he' := mul_le_mul_of_nonneg_left hn.le hab | |
| change 2 * a * b * (πΌ m, (O n).cone.pairing | |
| (TangentCone.log (O n).cat (O n).base (test n m)) | |
| (TangentCone.log (O n).cat (O n).base ((O n).isom (Ο n (label n m e)) (O n).base))) β€ _ at he' | |
| nlinarith | |
| end SamplingSequence | |
| end HyperbolicObstruction | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| section | |
| end | |
| end | |
| end OAI | |