Download data/lean/OAI/Geometry/HypersurfaceGerms/RootPages.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 25.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/HypersurfaceGerms/RootPages.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/HypersurfaceGerms/RootPages.lean
-
curl -L -o RootPages.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/HypersurfaceGerms/RootPages.lean
25.2 kB
| import Mathlib | |
| import OAI.Geometry.HypersurfaceGerms.InnerGeometry | |
| import OAI.Geometry.HypersurfaceGerms.Preparation | |
| import OAI.Geometry.HypersurfaceGerms.RelativeChains | |
| import OAI.Geometry.HypersurfaceGerms.RootBounds | |
| namespace OAI | |
| /-! Homeomorphic inner-root models and naturality of the root-to-base projection. -/ | |
| namespace AmbientMultiplicity.SourceInnerPage | |
| noncomputable section | |
| open Preparation InnerQuartic InnerGeometry Filter Topology | |
| abbrev Base := Fin 2 β β | |
| def sourceH (p : Base) : β := p 1*(p 0-(p 1)^2)*(p 0-2*(p 1)^2) | |
| lemma continuous_sourceH : Continuous sourceH := by unfold sourceH; fun_prop | |
| def low0 (p : Base) (j : Fin 4) : β := coeff0 p β¨j, by omegaβ© | |
| def low1 (p : Base) (j : Fin 4) : β := coeff1 p β¨j, by omegaβ© | |
| lemma low0_analytic : AnalyticAt β low0 0 := by | |
| apply AnalyticAt.pi | |
| intro j | |
| exact ((proj β¨j, by omegaβ©).analyticAt _).comp coeff0_spec.1 | |
| lemma low1_analytic : AnalyticAt β low1 0 := by | |
| apply AnalyticAt.pi | |
| intro j | |
| exact ((proj β¨j, by omegaβ©).analyticAt _).comp coeff1_spec.1 | |
| def R0 (s : β) (p : Base) (w : β) : β := rescaledQuartic low0 s p w | |
| def R1 (s : β) (p : Base) (w : β) : β := rescaledQuartic low1 s p w | |
| lemma R0_eq_source (s : β) (hs : s β 0) (p : Base) (w : β) : | |
| R0 s p w = (s : β)^4 * root0 p (w/(s : β)) := by | |
| have hs' : (s : β) β 0 := by exact_mod_cast hs | |
| simp only [R0, rescaledQuartic, low0, root0, eval_rootPoly, Fin.sum_univ_four] | |
| norm_num | |
| field_simp | |
| lemma R1_eq_source (s : β) (hs : s β 0) (p : Base) (w : β) : | |
| R1 s p w = (s : β)^4 * root1 p (w/(s : β)) := by | |
| have hs' : (s : β) β 0 := by exact_mod_cast hs | |
| simp only [R1, rescaledQuartic, low1, root1, eval_rootPoly, Fin.sum_univ_four] | |
| norm_num | |
| field_simp | |
| lemma common_base_cut : β baseRadius : β, 0 < baseRadius β§ | |
| ContinuousOn low0 (Metric.closedBall 0 baseRadius) β§ | |
| ContinuousOn low1 (Metric.closedBall 0 baseRadius) := by | |
| have hh : βαΆ p : Base in π 0, ContinuousAt low0 p β§ ContinuousAt low1 p := by | |
| filter_upwards [low0_analytic.eventually_analyticAt, low1_analytic.eventually_analyticAt] | |
| with p h0 h1 | |
| exact β¨h0.continuousAt, h1.continuousAtβ© | |
| obtain β¨r, hr, hsubβ© := Metric.mem_nhds_iff.mp hh | |
| refine β¨r/2, by positivity, ?_, ?_β© | |
| Β· intro p hp | |
| have hp' : p β Metric.ball 0 r := by | |
| rw [Metric.mem_ball] | |
| have := Metric.mem_closedBall.mp hp | |
| linarith | |
| exact (hsub hp').1.continuousWithinAt | |
| Β· intro p hp | |
| have hp' : p β Metric.ball 0 r := by | |
| rw [Metric.mem_ball] | |
| have := Metric.mem_closedBall.mp hp | |
| linarith | |
| exact (hsub hp').2.continuousWithinAt | |
| abbrev BasePage (baseRadius : β) (c : β) := | |
| {p : Base // βpβ β€ baseRadius β§ sourceH p = c} | |
| instance basePage_compact (baseRadius : β) (c : β) : CompactSpace (BasePage baseRadius c) := by | |
| apply isCompact_iff_compactSpace.mp | |
| change IsCompact {p : Base | βpβ β€ baseRadius β§ sourceH p = c} | |
| have he : {p : Base | βpβ β€ baseRadius β§ sourceH p = c} = | |
| Metric.closedBall 0 baseRadius β© sourceH β»ΒΉ' {c} := by | |
| ext p | |
| simp [Metric.mem_closedBall, dist_eq_norm] | |
| rw [he] | |
| exact (isCompact_closedBall _ _).inter_right | |
| (isClosed_singleton.preimage continuous_sourceH) | |
| abbrev Disk (radius : β) := β(Metric.closedBall (0 : β) radius) | |
| abbrev RootBase (baseRadius : β) (c : β) (radius : β) := BasePage baseRadius c Γ Disk radius | |
| def onRootBase (R : Base β β β β) (baseRadius : β) (c : β) (radius : β) : | |
| RootBase baseRadius c radius β β := fun g => R g.1.val g.2.val | |
| abbrev Model (R : Base β β β β) (baseRadius : β) (c : β) | |
| (radius M alpha beta : β) := | |
| {v : RootBase baseRadius c radius Γ (β Γ β) // | |
| v.2.1*v.2.2 = onRootBase R baseRadius c radius v.1 β§ | |
| βv.2.1β β€ M*radius^alpha β§ βv.2.2β β€ M*radius^beta} | |
| lemma y_bound_eq {radius alpha beta M : β} (hradius : 0 < radius) | |
| (hweights : alpha+beta = 4) : | |
| radius^((alpha-beta)/2)*(M*radius^2) = M*radius^alpha := by | |
| have he : (alpha-beta)/2 + (2 : β) = alpha := by linarith | |
| have hp := Real.rpow_add hradius ((alpha-beta)/2) 2 | |
| rw [he, Real.rpow_two] at hp | |
| calc | |
| _ = M*(radius^((alpha-beta)/2)*radius^2) := by ring | |
| _ = _ := by rw [β hp] | |
| lemma z_bound_eq {radius alpha beta M : β} (hradius : 0 < radius) | |
| (hweights : alpha+beta = 4) : | |
| (radius^((alpha-beta)/2))β»ΒΉ*(M*radius^2) = M*radius^beta := by | |
| rw [β Real.rpow_neg hradius.le] | |
| have he : -((alpha-beta)/2) + (2 : β) = beta := by linarith | |
| have hp := Real.rpow_add hradius (-((alpha-beta)/2)) 2 | |
| rw [he, Real.rpow_two] at hp | |
| calc | |
| _ = M*(radius^(-((alpha-beta)/2))*radius^2) := by ring | |
| _ = _ := by rw [β hp] | |
| def weightedModelHomeomorph (R : Base β β β β) (baseRadius : β) (c : β) | |
| (radius M alpha beta : β) (hradius : 0 < radius) (hweights : alpha+beta = 4) : | |
| WeightedConicBlock (onRootBase R baseRadius c radius) (M*radius^2) | |
| (radius^((alpha-beta)/2)) ββ Model R baseRadius c radius M alpha beta := | |
| Homeomorph.setCongr (by | |
| ext v | |
| simp only [y_bound_eq hradius hweights, z_bound_eq hradius hweights]) | |
| lemma continuous_onRootBase_rescaled {A : Base β Fin 4 β β} {baseRadius : β} | |
| (hA : ContinuousOn A (Metric.closedBall 0 baseRadius)) (c : β) (radius s : β) : | |
| Continuous (onRootBase (rescaledQuartic A s) baseRadius c radius) := by | |
| have hcA : Continuous (fun p : BasePage baseRadius c => A p.val) := | |
| hA.comp_continuous continuous_subtype_val (fun p => by | |
| simpa [Metric.mem_closedBall, dist_eq_norm] using p.property.1) | |
| have hc := continuous_rescaledQuartic (fun p : BasePage baseRadius c => A p.val) hcA | |
| have hk : Continuous (fun p : RootBase baseRadius c radius => (s, (p.1, p.2.val))) := | |
| continuous_const.prodMk (continuous_fst.prodMk continuous_snd.subtype_val) | |
| have hh := hc.comp hk | |
| exact hh | |
| lemma eventually_bound_on_base {A : Base β Fin 4 β β} {baseRadius : β} | |
| (hA : ContinuousOn A (Metric.closedBall 0 baseRadius)) | |
| (radius : β) (hradius : 0 < radius) : | |
| βαΆ s : β in π 0, β p : Base, βpβ β€ baseRadius β | |
| β w : β, βwβ β€ radius β βrescaledQuartic A s p wβ β€ 2*radius^4 := by | |
| have hcA : Continuous (fun p : β(Metric.closedBall (0 : Base) baseRadius) => A p.val) := | |
| hA.comp_continuous continuous_subtype_val (fun p => p.property) | |
| have hh := eventually_quartic_norm_le (fun p : β(Metric.closedBall (0 : Base) baseRadius) => A p.val) | |
| hcA radius hradius | |
| filter_upwards [hh] with s hs p hp w hw | |
| exact hs β¨p, by simpa [Metric.mem_closedBall, dist_eq_norm] using hpβ© w hw | |
| def modelCollapseHomotopyEquiv {A : Base β Fin 4 β β} {baseRadius : β} | |
| (hA : ContinuousOn A (Metric.closedBall 0 baseRadius)) | |
| (c : β) (radius M alpha beta s : β) (hradius : 0 < radius) (hM : 3 < M) | |
| (hweights : alpha+beta = 4) | |
| (hbound : β p : Base, βpβ β€ baseRadius β β w : β, βwβ β€ radius β | |
| βrescaledQuartic A s p wβ β€ 2*radius^4) : | |
| ContinuousMap.HomotopyEquiv (Model (rescaledQuartic A s) baseRadius c radius M alpha beta) | |
| (CircleCollapse (onRootBase (rescaledQuartic A s) baseRadius c radius)) := by | |
| let R := onRootBase (rescaledQuartic A s) baseRadius c radius | |
| have hb : β p : RootBase baseRadius c radius, Real.sqrt βR pβ β€ M*radius^2 := by | |
| intro p | |
| apply sqrt_quartic_bound hradius.le hM (norm_nonneg _) | |
| exact hbound p.1.val p.1.property.1 p.2.val (by | |
| have hd := Metric.mem_closedBall.mp p.2.property | |
| rwa [dist_zero_right] at hd) | |
| exact (weightedModelHomeomorph (rescaledQuartic A s) baseRadius c radius M alpha beta | |
| hradius hweights).symm.toHomotopyEquiv.trans | |
| (weightedBlockCollapseHomotopyEquiv R (M*radius^2) hb | |
| (continuous_onRootBase_rescaled hA c radius s) (radius^((alpha-beta)/2)) | |
| (Real.rpow_pos_of_pos hradius _)) | |
| theorem exact_inner_models : β baseRadius : β, 0 < baseRadius β§ | |
| β radius : β, 0 < radius β β M : β, 3 < M β β alpha beta : β, | |
| alpha+beta = 4 β βαΆ s : β in π 0, 0 < s β β c : β, | |
| Nonempty (ContinuousMap.HomotopyEquiv (Model (R0 s) baseRadius c radius M alpha beta) | |
| (CircleCollapse (onRootBase (R0 s) baseRadius c radius))) β§ | |
| Nonempty (ContinuousMap.HomotopyEquiv (Model (R1 s) baseRadius c radius M alpha beta) | |
| (CircleCollapse (onRootBase (R1 s) baseRadius c radius))) := by | |
| obtain β¨baseRadius, hb, h0, h1β© := common_base_cut | |
| refine β¨baseRadius, hb, ?_β© | |
| intro radius hr M hM alpha beta hweights | |
| filter_upwards [eventually_bound_on_base h0 radius hr, eventually_bound_on_base h1 radius hr] | |
| with s hs0 hs1 hpos c | |
| exact β¨β¨modelCollapseHomotopyEquiv h0 c radius M alpha beta s hr hM hweights hs0β©, | |
| β¨modelCollapseHomotopyEquiv h1 c radius M alpha beta s hr hM hweights hs1β©β© | |
| end | |
| noncomputable section | |
| open Preparation InnerQuartic InnerGeometry RootConfinement Filter Topology | |
| def pi0 (q : β Γ β) : Base := ![q.1^2 + q1 q.1 q.2, q.1] | |
| def pi1 (q : β Γ β) : Base := ![q.1, psi q.1 q.2] | |
| def d0 (q : β Γ β) : β := sourceH (pi0 q) | |
| def d1 (q : β Γ β) : β := sourceH (pi1 q) | |
| lemma continuous_pi0 : Continuous pi0 := by unfold pi0 q1; fun_prop | |
| lemma continuous_pi1 : Continuous pi1 := by unfold pi1 psi q2 q1; fun_prop | |
| lemma low0_zero : low0 0 = 0 := by | |
| funext j | |
| simp only [low0, coeff0_spec.2.1] | |
| change (graph0 0).coeff j = 0 | |
| rw [graph0_specialization, Polynomial.coeff_X_pow_mul', ite_eq_right (by omega)] | |
| lemma low1_zero : low1 0 = 0 := by | |
| funext j | |
| simp only [low1, coeff1_spec.2.1] | |
| change (graph1 0).coeff j = 0 | |
| rw [graph1_specialization, Polynomial.coeff_X_pow_mul', ite_eq_right (by omega)] | |
| lemma root0_eq_quartic (p : Base) (w : β) : | |
| root0 p w = w^4 + β j : Fin 4, low0 p j*w^(j:β) := by | |
| simp [root0, eval_rootPoly, low0] | |
| lemma root1_eq_quartic (p : Base) (w : β) : | |
| root1 p w = w^4 + β j : Fin 4, low1 p j*w^(j:β) := by | |
| simp [root1, eval_rootPoly, low1] | |
| lemma eventually_root_graph : βαΆ z : V 3 in π 0, | |
| (r0 z = 0 β z 0 = (z 1)^2+q1 (z 1) (z 2)) β§ | |
| (r1 z = 0 β z 1 = psi (z 0) (z 2)) := by | |
| have h0 : βαΆ z in π (0 : V 3), u0 z β 0 := | |
| u0_analytic.continuousAt.eventually_ne (by rw [u0_zero]; norm_num) | |
| have h1 : βαΆ z in π (0 : V 3), u1 z β 0 := | |
| u1_analytic.continuousAt.eventually_ne (by rw [u1_zero]; norm_num) | |
| filter_upwards [graph0_factor, graph1_factor, h0, h1] with z hz0 hz1 hn0 hn1 | |
| constructor | |
| Β· have hh : r0 z = 0 β z 0-(z 1)^2-q1 (z 1) (z 2) = 0 := by | |
| rw [hz0, mul_eq_zero, or_iff_left hn0] | |
| rw [hh] | |
| constructor <;> intro h <;> linear_combination h | |
| Β· have hh : r1 z = 0 β z 1-psi (z 0) (z 2) = 0 := by | |
| rw [hz1, mul_eq_zero, or_iff_left hn1] | |
| exact hh.trans sub_eq_zero | |
| def join (p : Base) (w : β) : V 3 := ![p 0,p 1,w] | |
| lemma join_small {p : Base} {w : β} {r : β} (hr : 0 < r) | |
| (hp : βpβ < r) (hw : βwβ < r) : βjoin p wβ < r := by | |
| apply (pi_norm_lt_iff hr).mpr | |
| intro j | |
| fin_cases j | |
| Β· exact (norm_le_pi_norm p 0).trans_lt hp | |
| Β· exact (norm_le_pi_norm p 1).trans_lt hp | |
| Β· exact hw | |
| lemma base3_join (p : Base) (w : β) : base3 (join p w) = p := by | |
| ext j | |
| fin_cases j <;> rfl | |
| theorem common_root_chart : β baseRadius rootRadius : β, | |
| 0 < baseRadius β§ 0 < rootRadius β§ | |
| ContinuousOn low0 (Metric.closedBall 0 baseRadius) β§ | |
| ContinuousOn low1 (Metric.closedBall 0 baseRadius) β§ | |
| (β p : Base, βpβ β€ baseRadius β β w : β, | |
| (root0 p w = 0 β βwβ < rootRadius) β§ | |
| (root1 p w = 0 β βwβ < rootRadius)) β§ | |
| (β p : Base, βpβ β€ baseRadius β β w : β, βwβ < rootRadius β | |
| (root0 p w = 0 β pi0 (p 1,w) = p) β§ | |
| (root1 p w = 0 β pi1 (p 0,w) = p)) := by | |
| obtain β¨r, hr, hsubβ© := Metric.mem_nhds_iff.mp eventually_root_graph | |
| have hΞ΅ : 0 < r/2 := by positivity | |
| have hall0 := eventually_all_roots_small low0 low0_analytic.continuousAt low0_zero (r/2) hΞ΅ | |
| have hall1 := eventually_all_roots_small low1 low1_analytic.continuousAt low1_zero (r/2) hΞ΅ | |
| have hcont : βαΆ p : Base in π 0, ContinuousAt low0 p β§ ContinuousAt low1 p := by | |
| filter_upwards [low0_analytic.eventually_analyticAt, low1_analytic.eventually_analyticAt] | |
| with p h0 h1 | |
| exact β¨h0.continuousAt,h1.continuousAtβ© | |
| obtain β¨b, hb, hballβ© := Metric.mem_nhds_iff.mp (hall0.and (hall1.and hcont)) | |
| refine β¨min b r / 2, r/2, by positivity, hΞ΅, ?_, ?_, ?_, ?_β© | |
| Β· intro p hp | |
| have hp' : p β Metric.ball (0 : Base) b := by | |
| rw [Metric.mem_ball, dist_zero_right] | |
| have hh := Metric.mem_closedBall.mp hp | |
| rw [dist_zero_right] at hh | |
| have hmin := min_le_left b r | |
| linarith | |
| exact (hball hp').2.2.1.continuousWithinAt | |
| Β· intro p hp | |
| have hp' : p β Metric.ball (0 : Base) b := by | |
| rw [Metric.mem_ball, dist_zero_right] | |
| have hh := Metric.mem_closedBall.mp hp | |
| rw [dist_zero_right] at hh | |
| have hmin := min_le_left b r | |
| linarith | |
| exact (hball hp').2.2.2.continuousWithinAt | |
| Β· intro p hp w | |
| have hp' : p β Metric.ball (0 : Base) b := by | |
| rw [Metric.mem_ball, dist_zero_right] | |
| have hmin := min_le_left b r | |
| linarith | |
| exact β¨fun hz => (hball hp').1 w (by rwa [β root0_eq_quartic]), | |
| fun hz => (hball hp').2.1 w (by rwa [β root1_eq_quartic])β© | |
| Β· intro p hp w hw | |
| have jp : join p w β Metric.ball 0 r := by | |
| rw [Metric.mem_ball, dist_zero_right] | |
| apply join_small hr | |
| Β· have hmin := min_le_right b r | |
| linarith | |
| Β· linarith | |
| obtain β¨h0,h1β© := hsub jp | |
| simp only [r0, r1, base3_join] at h0 h1 | |
| constructor | |
| Β· constructor | |
| Β· intro hz | |
| ext j | |
| fin_cases j | |
| Β· exact (h0.mp hz).symm | |
| Β· rfl | |
| Β· intro he | |
| apply h0.mpr | |
| exact (congrFun he 0).symm | |
| Β· constructor | |
| Β· intro hz | |
| ext j | |
| fin_cases j | |
| Β· rfl | |
| Β· exact (h1.mp hz).symm | |
| Β· intro he | |
| apply h1.mpr | |
| exact (congrFun he 1).symm | |
| abbrev RootPage (R : Base β β β β) (baseRadius : β) (c : β) (radius : β) := | |
| {g : RootBase baseRadius c radius // onRootBase R baseRadius c radius g = 0} | |
| abbrev GraphPage (pi : β Γ β β Base) (baseRadius : β) (c : β) (rootRadius : β) := | |
| {q : β Γ β // βpi qβ β€ baseRadius β§ βq.2β < rootRadius β§ sourceH (pi q) = c} | |
| section RootHomeomorph | |
| variable (pi : β Γ β β Base) (j : Fin 2) (root R : Base β β β β) | |
| variable (baseRadius rootRadius radius s : β) (c : β) | |
| variable (hs : 0 < s) (hsize : s*rootRadius β€ radius) | |
| variable (hscale : β p w, R p w = (s : β)^4*root p (w/(s : β))) | |
| variable (hconfine : β p : Base, βpβ β€ baseRadius β β w : β, | |
| root p w = 0 β βwβ < rootRadius) | |
| variable (hgraph : β p : Base, βpβ β€ baseRadius β β w : β, βwβ < rootRadius β | |
| (root p w = 0 β pi (p j,w) = p)) | |
| include hs hscale in | |
| lemma rootPage_unscaled_zero (g : RootPage R baseRadius c radius) : | |
| root g.val.1.val (g.val.2.val/(s : β)) = 0 := by | |
| have hz := g.property | |
| change R g.val.1.val g.val.2.val = 0 at hz | |
| rw [hscale] at hz | |
| have hs' : (s : β) β 0 := by exact_mod_cast hs.ne' | |
| exact (mul_eq_zero.mp hz).resolve_left (pow_ne_zero _ hs') | |
| include hs hscale hconfine in | |
| lemma rootPage_unscaled_small (g : RootPage R baseRadius c radius) : | |
| βg.val.2.val/(s : β)β < rootRadius := | |
| hconfine _ g.val.1.property.1 _ (rootPage_unscaled_zero root R _ _ _ _ hs hscale g) | |
| include hs hscale hconfine hgraph in | |
| lemma rootPage_graph_eq (g : RootPage R baseRadius c radius) : | |
| pi (g.val.1.val j,g.val.2.val/(s : β)) = g.val.1.val := | |
| (hgraph _ g.val.1.property.1 _ | |
| (rootPage_unscaled_small root R _ _ _ _ _ hs hscale hconfine g)).mp | |
| (rootPage_unscaled_zero root R _ _ _ _ hs hscale g) | |
| def rootToGraph (g : RootPage R baseRadius c radius) : | |
| GraphPage pi baseRadius c rootRadius := by | |
| let q : β Γ β := (g.val.1.val j,g.val.2.val/(s : β)) | |
| have he : pi q = g.val.1.val := | |
| rootPage_graph_eq pi j root R _ _ _ _ _ hs hscale hconfine hgraph g | |
| refine β¨q, ?_, ?_, ?_β© | |
| Β· rw [he]; exact g.val.1.property.1 | |
| Β· exact rootPage_unscaled_small root R _ _ _ _ _ hs hscale hconfine g | |
| Β· rw [he]; exact g.val.1.property.2 | |
| variable (hpi : β q : β Γ β, pi q j = q.1) | |
| def graphToRoot (q : GraphPage pi baseRadius c rootRadius) : | |
| RootPage R baseRadius c radius := by | |
| have hb : (s : β)*q.val.2 β Metric.closedBall 0 radius := by | |
| rw [Metric.mem_closedBall, dist_zero_right, norm_mul, Complex.norm_real, | |
| Real.norm_eq_abs, abs_of_pos hs] | |
| exact (mul_le_mul_of_nonneg_left q.property.2.1.le hs.le).trans hsize | |
| have hroot : root (pi q.val) q.val.2 = 0 := | |
| (hgraph _ q.property.1 _ q.property.2.1).mpr (by rw [hpi]) | |
| refine β¨(β¨pi q.val, q.property.1, q.property.2.2β©, | |
| β¨(s : β)*q.val.2, hbβ©), ?_β© | |
| change R (pi q.val) ((s : β)*q.val.2) = 0 | |
| have hs' : (s : β) β 0 := by exact_mod_cast hs.ne' | |
| rw [hscale, mul_div_cancel_leftβ _ hs', hroot, mul_zero] | |
| lemma graph_root_left_inverse : Function.LeftInverse | |
| (graphToRoot pi j root R baseRadius rootRadius radius s c hs hsize hscale hgraph hpi) | |
| (rootToGraph pi j root R baseRadius rootRadius radius s c hs hscale hconfine hgraph) := by | |
| intro g | |
| apply Subtype.ext | |
| apply Prod.ext | |
| Β· apply Subtype.ext | |
| exact rootPage_graph_eq pi j root R _ _ _ _ _ hs hscale hconfine hgraph g | |
| Β· apply Subtype.ext | |
| change (s : β)*(g.val.2.val/(s : β)) = g.val.2.val | |
| have hs' : (s : β) β 0 := by exact_mod_cast hs.ne' | |
| exact mul_div_cancelβ _ hs' | |
| lemma root_graph_right_inverse : Function.RightInverse | |
| (graphToRoot pi j root R baseRadius rootRadius radius s c hs hsize hscale hgraph hpi) | |
| (rootToGraph pi j root R baseRadius rootRadius radius s c hs hscale hconfine hgraph) := by | |
| intro q | |
| apply Subtype.ext | |
| apply Prod.ext | |
| Β· exact hpi q.val | |
| Β· change (s : β)*q.val.2/(s : β) = q.val.2 | |
| have hs' : (s : β) β 0 := by exact_mod_cast hs.ne' | |
| exact mul_div_cancel_leftβ _ hs' | |
| def rootGraphHomeomorph (hpi_cont : Continuous pi) : | |
| RootPage R baseRadius c radius ββ GraphPage pi baseRadius c rootRadius where | |
| toFun := rootToGraph pi j root R baseRadius rootRadius radius s c hs hscale hconfine hgraph | |
| invFun := graphToRoot pi j root R baseRadius rootRadius radius s c hs hsize hscale hgraph hpi | |
| left_inv := graph_root_left_inverse pi j root R _ _ _ _ _ hs hsize hscale hconfine hgraph hpi | |
| right_inv := root_graph_right_inverse pi j root R _ _ _ _ _ hs hsize hscale hconfine hgraph hpi | |
| continuous_toFun := by | |
| apply Continuous.subtype_mk | |
| change Continuous (fun g : RootPage R baseRadius c radius => | |
| (g.val.1.val j,g.val.2.val/(s : β))) | |
| have cp : Continuous (fun g : RootPage R baseRadius c radius => g.val.1.val) := | |
| continuous_subtype_val.fst.subtype_val | |
| have cw : Continuous (fun g : RootPage R baseRadius c radius => g.val.2.val) := | |
| continuous_subtype_val.snd.subtype_val | |
| exact ((continuous_apply j).comp cp).prodMk (cw.div_const (s : β)) | |
| continuous_invFun := by | |
| apply Continuous.subtype_mk | |
| apply Continuous.prodMk | |
| Β· apply Continuous.subtype_mk | |
| exact hpi_cont.comp continuous_subtype_val | |
| Β· apply Continuous.subtype_mk | |
| change Continuous (fun q : GraphPage pi baseRadius c rootRadius => (s : β)*q.val.2) | |
| fun_prop | |
| end RootHomeomorph | |
| theorem exact_root_pages : β baseRadius rootRadius : β, | |
| 0 < baseRadius β§ 0 < rootRadius β§ | |
| β radius : β, 0 < radius β βαΆ s : β in π 0, 0 < s β β c : β, | |
| Nonempty (RootPage (R0 s) baseRadius c radius ββ | |
| GraphPage pi0 baseRadius c rootRadius) β§ | |
| Nonempty (RootPage (R1 s) baseRadius c radius ββ | |
| GraphPage pi1 baseRadius c rootRadius) := by | |
| obtain β¨b, e, hb, he, _, _, hconf, hgraphβ© := common_root_chart | |
| refine β¨b, e, hb, he, ?_β© | |
| intro radius hradius | |
| have hc : ContinuousAt (fun s : β => s*e) 0 := by fun_prop | |
| have hsmall : βαΆ s : β in π 0, s*e < radius := | |
| hc.eventually (gt_mem_nhds (by simpa using hradius)) | |
| filter_upwards [hsmall] with s hsize hs c | |
| constructor | |
| Β· exact β¨rootGraphHomeomorph pi0 1 root0 (R0 s) b e radius s c hs hsize.le | |
| (R0_eq_source s hs.ne') (fun p hp w => (hconf p hp w).1) | |
| (fun p hp w hw => (hgraph p hp w hw).1) (fun _ => rfl) continuous_pi0β© | |
| Β· exact β¨rootGraphHomeomorph pi1 0 root1 (R1 s) b e radius s c hs hsize.le | |
| (R1_eq_source s hs.ne') (fun p hp w => (hconf p hp w).2) | |
| (fun p hp w hw => (hgraph p hp w hw).2) (fun _ => rfl) continuous_pi1β© | |
| end | |
| noncomputable section | |
| open InnerGeometry Preparation Filter Topology CategoryTheory | |
| def graphPageProjection (pi : β Γ β β Base) (hpi : Continuous pi) | |
| (baseRadius : β) (c : β) (rootRadius : β) : | |
| C(GraphPage pi baseRadius c rootRadius, BasePage baseRadius c) where | |
| toFun q := β¨pi q.val, q.property.1, q.property.2.2β© | |
| continuous_toFun := (hpi.comp continuous_subtype_val).subtype_mk _ | |
| def rootPageProjection (R : Base β β β β) | |
| (baseRadius : β) (c : β) (radius : β) : | |
| C(RootPage R baseRadius c radius, BasePage baseRadius c) where | |
| toFun g := g.val.1 | |
| continuous_toFun := continuous_fst.comp continuous_subtype_val | |
| section Naturality | |
| variable (pi : β Γ β β Base) (j : Fin 2) (root R : Base β β β β) | |
| variable (baseRadius rootRadius radius s : β) (c : β) | |
| variable (hs : 0 < s) (hsize : s*rootRadius β€ radius) | |
| variable (hscale : β p w, R p w = (s : β)^4*root p (w/(s : β))) | |
| variable (hconfine : β p : Base, βpβ β€ baseRadius β β w : β, | |
| root p w = 0 β βwβ < rootRadius) | |
| variable (hgraph : β p : Base, βpβ β€ baseRadius β β w : β, βwβ < rootRadius β | |
| (root p w = 0 β pi (p j,w) = p)) | |
| variable (hpi : β q : β Γ β, pi q j = q.1) (hcont : Continuous pi) | |
| lemma rootGraphHomeomorph_over_base : | |
| (graphPageProjection pi hcont baseRadius c rootRadius).comp | |
| (rootGraphHomeomorph pi j root R baseRadius rootRadius radius s c | |
| hs hsize hscale hconfine hgraph hpi hcont).toHomotopyEquiv.toFun = | |
| rootPageProjection R baseRadius c radius := by | |
| apply ContinuousMap.ext | |
| intro g | |
| apply Subtype.ext | |
| exact rootPage_graph_eq pi j root R _ _ _ _ _ hs hscale hconfine hgraph g | |
| lemma rootGraphHomeomorph_homology_over_base (n : β) : | |
| (integralHomologyFunctor n).map (TopCat.ofHom | |
| (rootGraphHomeomorph pi j root R baseRadius rootRadius radius s c | |
| hs hsize hscale hconfine hgraph hpi hcont).toHomotopyEquiv.toFun) β« | |
| (integralHomologyFunctor n).map (TopCat.ofHom | |
| (graphPageProjection pi hcont baseRadius c rootRadius)) = | |
| (integralHomologyFunctor n).map (TopCat.ofHom | |
| (rootPageProjection R baseRadius c radius)) := by | |
| rw [β Functor.map_comp] | |
| have he := rootGraphHomeomorph_over_base pi j root R baseRadius rootRadius radius s c | |
| hs hsize hscale hconfine hgraph hpi hcont | |
| exact congrArg ((integralHomologyFunctor n).map β TopCat.ofHom) he | |
| end Naturality | |
| def baseSection (baseRadius : β) (c : β) (radius : β) (hradius : 0 β€ radius) : | |
| C(BasePage baseRadius c, RootBase baseRadius c radius) where | |
| toFun p := (p, β¨0, by simpa using hradiusβ©) | |
| continuous_toFun := continuous_id.prodMk continuous_const | |
| def rootBaseHomotopyEquiv (baseRadius : β) (c : β) (radius : β) (hradius : 0 β€ radius) : | |
| ContinuousMap.HomotopyEquiv (RootBase baseRadius c radius) (BasePage baseRadius c) where | |
| toFun := β¨Prod.fst, continuous_fstβ© | |
| invFun := baseSection baseRadius c radius hradius | |
| left_inv := by | |
| refine β¨{ toFun := fun z => (z.2.1, β¨(z.1 : β) β’ z.2.2.val, ?_β©) | |
| continuous_toFun := ?_ | |
| map_zero_left := ?_ | |
| map_one_left := ?_ }β© | |
| Β· rw [Metric.mem_closedBall, dist_zero_right, norm_smul, Real.norm_eq_abs, | |
| abs_of_nonneg z.1.property.1] | |
| have hw := Metric.mem_closedBall.mp z.2.2.property | |
| rw [dist_zero_right] at hw | |
| exact (mul_le_of_le_one_left (norm_nonneg _) z.1.property.2).trans hw | |
| Β· apply Continuous.prodMk | |
| Β· exact continuous_snd.fst | |
| Β· apply Continuous.subtype_mk | |
| exact continuous_fst.subtype_val.smul continuous_snd.snd.subtype_val | |
| Β· intro g | |
| apply Prod.ext | |
| Β· rfl | |
| Β· apply Subtype.ext | |
| simp [baseSection] | |
| Β· intro g | |
| apply Prod.ext | |
| Β· rfl | |
| Β· apply Subtype.ext | |
| simp | |
| right_inv := by | |
| apply ContinuousMap.Homotopic.refl | |
| def rootBaseHomologyIso (baseRadius : β) (c : β) (radius : β) (hradius : 0 β€ radius) | |
| (n : β) : IntegralHomology n (RootBase baseRadius c radius) β | |
| IntegralHomology n (BasePage baseRadius c) := | |
| integralHomologyIso (rootBaseHomotopyEquiv baseRadius c radius hradius) n | |
| end | |
| end AmbientMultiplicity.SourceInnerPage | |
| end OAI | |