| import OAI.GroupTheory.UniversalGroup.TreeGeometry |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| open Set Metric Topology BigOperators |
| open Set Metric Topology |
| open Set Topology |
| open Set Metric Topology |
| open scoped NNReal |
| open Set Metric Topology |
| open scoped NNReal ENNReal |
| open Set Metric Topology |
| open scoped TensorProduct |
|
|
| namespace UniversalFInfinity.Cellular |
|
|
| section |
| open Set Metric Topology |
| open scoped unitInterval |
| universe u v |
| variable {Y : Type u} {Z : Type v} [TopologicalSpace Y] [TopologicalSpace Z] |
|
|
| lemma square_filling_after {n : ℕ} (q : C(Y,Z)) (hq : KillsSpheres q (n+2)) |
| (a : C(Sphere n,C(I,C(I,Y)))) |
| (b c : C(Disk n,C(I,Y) × C(I,Y))) |
| (hs : ∀ x, pathEndpoint (a x) = b (boundary n x)) |
| (ht : ∀ x s, pathEndpoint (a x s) = |
| ((c (boundary n x)).1 s,(c (boundary n x)).2 s)) |
| (h0 : ∀ x, pathEndpoint ((b x).1) = ((c x).1 0,(c x).2 0)) |
| (h1 : ∀ x, pathEndpoint ((b x).2) = ((c x).1 1,(c x).2 1)) : |
| ∃ e : C(Disk n,C(I,C(I,Z))), |
| (∀ x s t, e (boundary n x) s t = q (a x s t)) ∧ |
| (∀ x t, e x 0 t = q ((b x).1 t)) ∧ |
| (∀ x t, e x 1 t = q ((b x).2 t)) ∧ |
| (∀ x s, e x s 0 = q ((c x).1 s)) ∧ |
| (∀ x s, e x s 1 = q ((c x).2 s)) := by |
| let A := cylinderBoundaryMap a b hs |
| let B : C(Disk (n+1),Y × Y) := |
| ⟨fun x => ((c (diskTail x)).1 (diskTime x),(c (diskTail x)).2 (diskTime x)),by |
| apply Continuous.prodMk |
| · exact continuous_eval.comp |
| ((continuous_fst.comp (c.continuous.comp continuous_diskTail)).prodMk continuous_diskTime) |
| · exact continuous_eval.comp |
| ((continuous_snd.comp (c.continuous.comp continuous_diskTail)).prodMk continuous_diskTime)⟩ |
| have hAB : ∀ x, pathEndpoint (A x) = B (boundary (n+1) x) := by |
| intro x |
| rcases sphere_split x with hx|hx|hx |
| · have hx' : x ∈ cylinderFace n (some false) := hx |
| rw [show A x = faceMap a b (some false) ⟨x,hx'⟩ from |
| cylinderBoundaryMap_face a b hs (some false) ⟨x,hx'⟩] |
| change pathEndpoint ((b (diskTail (boundary (n+1) x))).1) = |
| ((c (diskTail (boundary (n+1) x))).1 (diskTime (boundary (n+1) x)), |
| (c (diskTail (boundary (n+1) x))).2 (diskTime (boundary (n+1) x))) |
| rw [faceTime_eq_zero x hx]; exact h0 _ |
| · have hx' : x ∈ cylinderFace n (some true) := hx |
| rw [show A x = faceMap a b (some true) ⟨x,hx'⟩ from |
| cylinderBoundaryMap_face a b hs (some true) ⟨x,hx'⟩] |
| change pathEndpoint ((b (diskTail (boundary (n+1) x))).2) = |
| ((c (diskTail (boundary (n+1) x))).1 (diskTime (boundary (n+1) x)), |
| (c (diskTail (boundary (n+1) x))).2 (diskTime (boundary (n+1) x))) |
| rw [faceTime_eq_one x hx]; exact h1 _ |
| · have hx' : x ∈ cylinderFace n none := hx |
| rw [show A x = faceMap a b none ⟨x,hx'⟩ from |
| cylinderBoundaryMap_face a b hs none ⟨x,hx'⟩] |
| exact ht (faceSphere ⟨x,hx'⟩) (faceTime none ⟨x,hx'⟩) |
| obtain ⟨d,hd,hp⟩ := cylinder_filling_after q hq A B hAB |
| let e : C(Disk n,C(I,C(I,Z))) := |
| (d.comp ⟨fun p : Disk n × I => diskCons p.1 p.2,continuous_diskCons⟩).curry |
| refine ⟨e,?_,?_,?_,?_,?_⟩ |
| · intro x s t |
| let z : Sphere (n+1) := ⟨_,cons_mem_sphere_of_boundary x s⟩ |
| have hz : z ∈ cylinderFace n none := by |
| change (diskTail (diskCons (boundary n x) s)).1 ∈ sphere 0 1 |
| rw [diskTail_cons]; exact x.2 |
| change d (diskCons (boundary n x) s) t = q (a x s t) |
| rw [show diskCons (boundary n x) s = boundary (n+1) z from rfl,hd] |
| rw [show A z = faceMap a b none ⟨z,hz⟩ from |
| cylinderBoundaryMap_face a b hs none ⟨z,hz⟩] |
| change q (a (faceSphere ⟨z,hz⟩) (diskTime (diskCons (boundary n x) s)) t) = _ |
| rw [diskTime_cons]; congr 2 |
| · intro x t |
| let z : Sphere (n+1) := ⟨_,cons_zero_mem_sphere x⟩ |
| have hz : z ∈ cylinderFace n (some false) := by |
| change (diskCons x 0).1 0 = -1; norm_num [diskCons] |
| change d (diskCons x 0) t = q ((b x).1 t) |
| rw [show diskCons x 0 = boundary (n+1) z from rfl,hd] |
| rw [show A z = faceMap a b (some false) ⟨z,hz⟩ from |
| cylinderBoundaryMap_face a b hs (some false) ⟨z,hz⟩] |
| change q ((b (diskTail (diskCons x 0))).1 t) = _ |
| rw [diskTail_cons] |
| · intro x t |
| let z : Sphere (n+1) := ⟨_,cons_one_mem_sphere x⟩ |
| have hz : z ∈ cylinderFace n (some true) := by |
| change (diskCons x 1).1 0 = 1; norm_num [diskCons] |
| change d (diskCons x 1) t = q ((b x).2 t) |
| rw [show diskCons x 1 = boundary (n+1) z from rfl,hd] |
| rw [show A z = faceMap a b (some true) ⟨z,hz⟩ from |
| cylinderBoundaryMap_face a b hs (some true) ⟨z,hz⟩] |
| change q ((b (diskTail (diskCons x 1))).2 t) = _ |
| rw [diskTail_cons] |
| · intro x s |
| have h := congrArg Prod.fst (hp (diskCons x s)) |
| change d (diskCons x s) 0 = _ |
| simpa only [pathEndpoint,ContinuousMap.coe_mk,B,ContinuousMap.coe_mk, |
| diskTail_cons,diskTime_cons] using h |
| · intro x s |
| have h := congrArg Prod.snd (hp (diskCons x s)) |
| change d (diskCons x s) 1 = _ |
| simpa only [pathEndpoint,ContinuousMap.coe_mk,B,ContinuousMap.coe_mk, |
| diskTail_cons,diskTime_cons] using h |
| end |
| |
| section |
| open Set Metric Topology |
| open scoped unitInterval |
| universe u v w |
| variable {X : Type u} {Y : Type v} {Z : Type w} |
| variable [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] |
| |
| def postPath (q : C(Y,Z)) : C(C(I,Y),C(I,Z)) := |
| ⟨fun a => q.comp a,ContinuousMap.continuous_postcomp q⟩ |
| |
| structure SquareBoundary (X : Type u) (Y : Type v) [TopologicalSpace X] [TopologicalSpace Y] where |
| b : C(X,C(I,Y) × C(I,Y)) |
| c : C(X,C(I,Y) × C(I,Y)) |
| zero : ∀ x, pathEndpoint ((b x).1) = ((c x).1 0,(c x).2 0) |
| one : ∀ x, pathEndpoint ((b x).2) = ((c x).1 1,(c x).2 1) |
| |
| namespace SquareBoundary |
| |
| def post (D : SquareBoundary X Y) (q : C(Y,Z)) : SquareBoundary X Z where |
| b := ⟨fun x => (postPath q (D.b x).1,postPath q (D.b x).2), |
| ((postPath q).continuous.comp (continuous_fst.comp D.b.continuous)).prodMk |
| ((postPath q).continuous.comp (continuous_snd.comp D.b.continuous))⟩ |
| c := ⟨fun x => (postPath q (D.c x).1,postPath q (D.c x).2), |
| ((postPath q).continuous.comp (continuous_fst.comp D.c.continuous)).prodMk |
| ((postPath q).continuous.comp (continuous_snd.comp D.c.continuous))⟩ |
| zero x := Prod.ext (congrArg q (congrArg Prod.fst (D.zero x))) |
| (congrArg q (congrArg Prod.snd (D.zero x))) |
| one x := Prod.ext (congrArg q (congrArg Prod.fst (D.one x))) |
| (congrArg q (congrArg Prod.snd (D.one x))) |
| end SquareBoundary |
| |
| variable [T2Space X] {C : Set X} [CWComplex C] |
| |
| structure PartialSquare (D : SquareBoundary X Y) (n : ℕ) where |
| val : X → C(I,C(I,Y)) |
| continuousOn : ContinuousOn val (Skeleton C n) |
| left : ∀ x ∈ Skeleton C n, ∀ t, val x 0 t = (D.b x).1 t |
| right : ∀ x ∈ Skeleton C n, ∀ t, val x 1 t = (D.b x).2 t |
| bottom : ∀ x ∈ Skeleton C n, ∀ s, val x s 0 = (D.c x).1 s |
| top : ∀ x ∈ Skeleton C n, ∀ s, val x s 1 = (D.c x).2 s |
| |
| namespace PartialSquare |
| variable {D : SquareBoundary X Y} {n : ℕ} |
| |
| def onSphere (P : PartialSquare (C := C) D n) (i : RelCWComplex.cell C n) : |
| C(Sphere n,C(I,C(I,Y))) := |
| ⟨fun x => P.val (characteristic n i (boundary n x)), |
| P.continuousOn.comp_continuous ((characteristic n i).continuous.comp (continuous_boundary n)) |
| (sphere_mem_skeleton n i)⟩ |
| |
| lemma cell_extension_after (P : PartialSquare (C := C) D n) |
| (q : C(Y,Z)) (hq : KillsSpheres q (n+2)) (i : RelCWComplex.cell C n) : |
| ∃ e : C(Disk n,C(I,C(I,Z))), |
| (∀ x, e (boundary n x) = postPath (postPath q) (P.val (characteristic n i (boundary n x)))) ∧ |
| (∀ x t, e x 0 t = q ((D.b (characteristic n i x)).1 t)) ∧ |
| (∀ x t, e x 1 t = q ((D.b (characteristic n i x)).2 t)) ∧ |
| (∀ x s, e x s 0 = q ((D.c (characteristic n i x)).1 s)) ∧ |
| (∀ x s, e x s 1 = q ((D.c (characteristic n i x)).2 s)) := by |
| obtain ⟨e,he,h0,h1,h2,h3⟩ := square_filling_after q hq (P.onSphere i) |
| (D.b.comp (characteristic n i)) (D.c.comp (characteristic n i)) (by |
| intro x; apply Prod.ext <;> apply ContinuousMap.ext <;> intro t |
| · exact P.left _ (sphere_mem_skeleton n i x) t |
| · exact P.right _ (sphere_mem_skeleton n i x) t) (by |
| intro x s; exact Prod.ext (P.bottom _ (sphere_mem_skeleton n i x) s) |
| (P.top _ (sphere_mem_skeleton n i x) s)) |
| (fun x => D.zero (characteristic n i x)) (fun x => D.one (characteristic n i x)) |
| exact ⟨e,fun x => ContinuousMap.ext (fun s => ContinuousMap.ext (he x s)),h0,h1,h2,h3⟩ |
| |
| def next (P : PartialSquare (C := C) D n) |
| (q : C(Y,Z)) (hq : KillsSpheres q (n+2)) : PartialSquare (C := C) (D.post q) (n+1) := by |
| let e := fun i => (P.cell_extension_after q hq i).choose |
| have hb := fun i => (P.cell_extension_after q hq i).choose_spec.1 |
| have h0 := fun i => (P.cell_extension_after q hq i).choose_spec.2.1 |
| have h1 := fun i => (P.cell_extension_after q hq i).choose_spec.2.2.1 |
| have h2 := fun i => (P.cell_extension_after q hq i).choose_spec.2.2.2.1 |
| have h3 := fun i => (P.cell_extension_after q hq i).choose_spec.2.2.2.2 |
| let v : X → C(I,C(I,Z)) := fun x => postPath (postPath q) (P.val x) |
| have hv : ContinuousOn v (Skeleton C n) := |
| (postPath (postPath q)).continuous.comp_continuousOn P.continuousOn |
| refine ⟨attachValue v e,attachValue_continuous v hv e hb,?_,?_,?_,?_⟩ |
| all_goals |
| intro x hx t |
| have heq : Skeleton C (n+1) = Skeleton C n ∪ |
| ⋃ i : RelCWComplex.cell C n, CWComplex.closedCell n i := by |
| simpa only [Skeleton,Nat.cast_add,Nat.cast_one] using |
| (CWComplex.skeletonLT_union_iUnion_closedCell_eq_skeletonLT_succ (C := C) n).symm |
| rw [heq] at hx |
| rcases hx with hx|hx |
| · rw [attachValue_old v e hx] |
| first |
| | exact congrArg q (P.left x hx t) |
| | exact congrArg q (P.right x hx t) |
| | exact congrArg q (P.bottom x hx t) |
| | exact congrArg q (P.top x hx t) |
| · obtain ⟨i,y,hy,rfl⟩ := Set.mem_iUnion.mp hx |
| rw [show RelCWComplex.map n i y = characteristic n i ⟨y,hy⟩ from rfl, |
| attachValue_characteristic v e hb] |
| first |
| | exact h0 i ⟨y,hy⟩ t |
| | exact h1 i ⟨y,hy⟩ t |
| | exact h2 i ⟨y,hy⟩ t |
| | exact h3 i ⟨y,hy⟩ t |
| |
| def start (D : SquareBoundary X Y) : PartialSquare (C := C) D 0 where |
| val x := ContinuousMap.const _ (D.b x).1 |
| continuousOn := by |
| rw [Skeleton,Nat.cast_zero,CWComplex.skeletonLT_zero_eq_empty] |
| exact continuousOn_empty _ |
| left := by intro x hx; simp only [Skeleton,Nat.cast_zero,CWComplex.skeletonLT_zero_eq_empty,Set.mem_empty_iff_false] at hx |
| right := by intro x hx; simp only [Skeleton,Nat.cast_zero,CWComplex.skeletonLT_zero_eq_empty,Set.mem_empty_iff_false] at hx |
| bottom := by intro x hx; simp only [Skeleton,Nat.cast_zero,CWComplex.skeletonLT_zero_eq_empty,Set.mem_empty_iff_false] at hx |
| top := by intro x hx; simp only [Skeleton,Nat.cast_zero,CWComplex.skeletonLT_zero_eq_empty,Set.mem_empty_iff_false] at hx |
| |
| def toMap [CWComplex (Set.univ : Set X)] |
| (P : PartialSquare (C := (Set.univ : Set X)) D n) |
| (hd : Skeleton (Set.univ : Set X) n = Set.univ) : C(X,C(I,C(I,Y))) := |
| ⟨P.val,by |
| apply continuousOn_univ.mp |
| have h := P.continuousOn |
| rw [hd] at h |
| exact h⟩ |
| end PartialSquare |
| |
| end |
| |
| open Set Metric Topology |
| open scoped unitInterval |
| universe u v |
| variable {X : Type u} [TopologicalSpace X] [T2Space X] [CWComplex (Set.univ : Set X)] |
| variable (Y : ℕ → Type v) [∀ i,TopologicalSpace (Y i)] (q : ∀ i,C(Y i,Y (i+1))) |
| |
| def boundaryTower (D : SquareBoundary X (Y 0)) : ∀ i,SquareBoundary X (Y i) |
| | 0 => D |
| | i+1 => (boundaryTower D i).post (q i) |
| |
| variable (D : SquareBoundary X (Y 0)) (hq : ∀ i,KillsSpheres (q i) (i+2)) |
| |
| def squareTower : ∀ i,PartialSquare (C := (Set.univ : Set X)) (boundaryTower Y q D i) i |
| | 0 => PartialSquare.start D |
| | i+1 => (squareTower i).next (q i) (hq i) |
| |
| include hq in |
| |
| theorem exists_tower_square (d : ℕ) (hd : Skeleton (Set.univ : Set X) d = Set.univ) : |
| ∃ S : C(X,C(I,C(I,Y d))), |
| (∀ x t,S x 0 t = ((boundaryTower Y q D d).b x).1 t) ∧ |
| (∀ x t,S x 1 t = ((boundaryTower Y q D d).b x).2 t) ∧ |
| (∀ x s,S x s 0 = ((boundaryTower Y q D d).c x).1 s) ∧ |
| (∀ x s,S x s 1 = ((boundaryTower Y q D d).c x).2 s) := by |
| let P := squareTower Y q D hq d |
| refine ⟨P.toMap hd,?_,?_,?_,?_⟩ |
| · intro x t; exact P.left x (hd.symm ▸ Set.mem_univ x) t |
| · intro x t; exact P.right x (hd.symm ▸ Set.mem_univ x) t |
| · intro x s; exact P.bottom x (hd.symm ▸ Set.mem_univ x) s |
| · intro x s; exact P.top x (hd.symm ▸ Set.mem_univ x) s |
| end UniversalFInfinity.Cellular |
| |
| namespace UniversalFInfinity.SphereTopology |
| open Set Topology |
| open scoped unitInterval |
| universe u v w |
| variable {B : Type u} [TopologicalSpace B] {Y : Type v} [TopologicalSpace Y] |
| {Z : Type w} [TopologicalSpace Z] {n : ℕ} [Nonempty (Sphere n)] |
| |
| lemma parametric_extension (q : C(Y,Z)) (z : Z) (H : q.Homotopy (.const _ z)) |
| (a : C(B × Sphere n,Y)) : |
| ∃ F : C(B × Disk n,Z), ∀ b x,F (b,boundary n x) = q (a (b,x)) := by |
| let k : C(B × (I × Sphere n),B × Disk n) := |
| ⟨Prod.map id (cone n),continuous_fst.prodMk ((cone n).continuous.comp continuous_snd)⟩ |
| have hk : IsProperMap k := isProperMap_id.prodMap (cone n).continuous.isProperMap |
| have hsurj : Function.Surjective k := Function.Surjective.prodMap Function.surjective_id (cone_surjective n) |
| have hquot : IsQuotientMap k := hk.isClosedMap.isQuotientMap hk.continuous hsurj |
| let v : C(B × (I × Sphere n),Z) := |
| ⟨fun p => H.symm (p.2.1,a (p.1,p.2.2)),H.symm.continuous.comp |
| (continuous_snd.fst.prodMk (a.continuous.comp (continuous_fst.prodMk continuous_snd.snd)))⟩ |
| have hv : Function.FactorsThrough v k := by |
| intro p r hpr |
| have hb : p.1 = r.1 := congrArg (fun x : B × Disk n => x.1) hpr |
| have hc : cone n p.2 = cone n r.2 := congrArg (fun x : B × Disk n => x.2) hpr |
| have ht : p.2.1 = r.2.1 := Subtype.ext ((cone_norm p.2).symm.trans |
| ((congrArg (fun x : Disk n => ‖x.1‖) hc).trans (cone_norm r.2))) |
| by_cases hzero : (p.2.1:ℝ) = 0 |
| · have hp : p.2.1 = 0 := Subtype.ext hzero |
| have hr : r.2.1 = 0 := ht.symm.trans hp |
| change H.symm (p.2.1,a (p.1,p.2.2)) = H.symm (r.2.1,a (r.1,r.2.2)) |
| rw [hp,hr,H.symm.apply_zero,H.symm.apply_zero] |
| rfl |
| · have hs : p.2.2 = r.2.2 := by |
| apply Subtype.ext |
| have heq := congrArg (fun x : Disk n => x.1) hc |
| change (p.2.1:ℝ) • p.2.2.1 = (r.2.1:ℝ) • r.2.2.1 at heq |
| rw [←ht] at heq |
| exact (smul_right_injective _ hzero) heq |
| exact congrArg v (Prod.ext hb (Prod.ext ht hs)) |
| let F := hquot.lift v hv |
| refine ⟨F,?_⟩ |
| intro b x |
| have hh := ContinuousMap.congr_fun (hquot.lift_comp v hv) (b,(1,x)) |
| have hc : cone n (1,x) = boundary n x := by apply Subtype.ext; simp [cone,boundary] |
| change F (b,cone n (1,x)) = H.symm (1,a (b,x)) at hh |
| simpa only [hc,H.symm.apply_one,ContinuousMap.comp_apply] using hh |
| end UniversalFInfinity.SphereTopology |
| |
| namespace UniversalFInfinity.Cellular |
| |
| section |
| open Set Topology |
| open scoped unitInterval |
| universe u v |
| variable {B : Type u} [TopologicalSpace B] {Y : Type v} [TopologicalSpace Y] {n : ℕ} |
| variable (a : C(B,C(Sphere n,C(I,Y)))) (b : C(B,C(Disk n,Y × Y))) |
| variable (h : ∀ v x,pathEndpoint (a v x) = b v (boundary n x)) |
| |
| def familyCylinderFace (i : Option Bool) : Set (B × Sphere (n+1)) := |
| Prod.snd ⁻¹' cylinderFace n i |
|
|
| def familyFaceMap (i : Option Bool) : C(familyCylinderFace (B := B) (n := n) i,Y) := by |
| let π : C(familyCylinderFace (B := B) (n := n) i,B) := ⟨fun p => p.1.1,continuous_fst.comp continuous_subtype_val⟩ |
| let ρ : C(familyCylinderFace (B := B) (n := n) i,cylinderFace n i) := |
| ⟨fun p => ⟨p.1.2,p.2⟩,(continuous_snd.comp continuous_subtype_val).subtype_mk _⟩ |
| cases i with |
| | none => exact ⟨fun p => a (π p) (faceSphere (ρ p)) (faceTime none (ρ p)), |
| continuous_eval.comp ((continuous_eval.comp ((a.continuous.comp π.continuous).prodMk |
| (faceSphere.continuous.comp ρ.continuous))).prodMk ((faceTime none).continuous.comp ρ.continuous))⟩ |
| | some c => |
| cases c |
| · exact ⟨fun p => (b (π p) (faceTail (some false) (ρ p))).1, |
| continuous_fst.comp (continuous_eval.comp ((b.continuous.comp π.continuous).prodMk |
| ((faceTail (some false)).continuous.comp ρ.continuous)))⟩ |
| · exact ⟨fun p => (b (π p) (faceTail (some true) (ρ p))).2, |
| continuous_snd.comp (continuous_eval.comp ((b.continuous.comp π.continuous).prodMk |
| ((faceTail (some true)).continuous.comp ρ.continuous)))⟩ |
| lemma familyFaceMap_eq (i : Option Bool) (p : familyCylinderFace (B := B) (n := n) i) : |
| familyFaceMap a b i p = faceMap (a p.1.1) (b p.1.1) i ⟨p.1.2,p.2⟩ := by |
| cases i with |
| | none => rfl |
| | some c => cases c <;> rfl |
|
|
| include h in |
| lemma familyCylinder_continuous : Continuous (fun p : B × Sphere (n+1) => cylinderBoundaryMap (a p.1) (b p.1) (h p.1) p.2) := by |
| let S := familyCylinderFace (B := B) (n := n) |
| have hc : ∀ i j p (hi : p ∈ S i) (hj : p ∈ S j), familyFaceMap a b i ⟨p,hi⟩ = familyFaceMap a b j ⟨p,hj⟩ := by |
| intro i j p hi hj |
| rw [familyFaceMap_eq,familyFaceMap_eq] |
| exact faceMap_compat (a p.1) (b p.1) (h p.1) i j p.2 hi hj |
| have hcover : ⋃ i,S i = univ := by |
| apply Set.eq_univ_of_forall |
| intro p |
| have hp : p.2 ∈ ⋃ i,cylinderFace n i := by rw [cylinderFace_cover]; exact mem_univ _ |
| obtain ⟨i,hi⟩ := Set.mem_iUnion.mp hp |
| exact Set.mem_iUnion.mpr ⟨i,hi⟩ |
| have hclosed : ∀ i,IsClosed (S i) := fun i => (cylinderFace_closed n i).preimage continuous_snd |
| have he : Set.liftCover S (fun i => familyFaceMap a b i) hc hcover = |
| (fun p : B × Sphere (n+1) => cylinderBoundaryMap (a p.1) (b p.1) (h p.1) p.2) := by |
| funext p |
| have hp : p ∈ ⋃ i,S i := by rw [hcover]; exact mem_univ _ |
| obtain ⟨i,hi⟩ := Set.mem_iUnion.mp hp |
| rw [Set.liftCover_coe (S := S) (f := fun i => familyFaceMap a b i) (hf := hc) (hS := hcover) ⟨p,hi⟩, |
| familyFaceMap_eq] |
| exact (cylinderBoundaryMap_face (a p.1) (b p.1) (h p.1) i ⟨p.2,hi⟩).symm |
| rw [←he] |
| exact continuous_liftCover S _ hc hcover hclosed |
| end |
|
|
| section |
| open Set Metric Topology |
| open scoped unitInterval |
| universe u v w |
| variable {B : Type u} [TopologicalSpace B] {Y : Type v} [TopologicalSpace Y] |
| {Z : Type w} [TopologicalSpace Z] |
| lemma family_cylinder_filling {n : ℕ} (q : C(Y,Z)) (z : Z) (H : q.Homotopy (.const _ z)) |
| (a : C(B,C(Sphere n,C(I,Y)))) (b : C(B,C(Disk n,Y × Y))) |
| (h : ∀ v x,pathEndpoint (a v x) = b v (boundary n x)) : |
| ∃ e : C(B,C(Disk n,C(I,Z))), |
| (∀ v x t,e v (boundary n x) t = q (a v x t)) ∧ |
| ∀ v x,pathEndpoint (e v x) = (q (b v x).1,q (b v x).2) := by |
| let : Nonempty (Sphere (n+1)) := SphereTopology.sphere_nonempty n |
| let a' : C(B × Sphere (n+1),Y) := ⟨_,familyCylinder_continuous a b h⟩ |
| obtain ⟨F,hF⟩ := SphereTopology.parametric_extension q z H a' |
| change ∀ v x,F (v,boundary (n+1) x) = q (a' (v,x)) at hF |
| let e : C(B,C(Disk n,C(I,Z))) := |
| (F.comp ⟨fun p : (B × Disk n) × I => (p.1.1,diskCons p.1.2 p.2), |
| continuous_fst.fst.prodMk (continuous_diskCons.comp (continuous_fst.snd.prodMk continuous_snd))⟩).curry.curry |
| refine ⟨e,?_,?_⟩ |
| · intro v x t |
| let s : Sphere (n+1) := ⟨_,cons_mem_sphere_of_boundary x t⟩ |
| have hs : s ∈ cylinderFace n none := by |
| change (diskTail (diskCons (boundary n x) t)).1 ∈ sphere 0 1 |
| rw [diskTail_cons]; exact x.2 |
| change F (v,diskCons (boundary n x) t) = q (a v x t) |
| rw [show diskCons (boundary n x) t = boundary (n+1) s from rfl,hF] |
| change q (cylinderBoundaryMap (a v) (b v) (h v) s) = _ |
| rw [cylinderBoundaryMap_face (a v) (b v) (h v) none ⟨s,hs⟩] |
| change q (a v (faceSphere ⟨s,hs⟩) (diskTime (diskCons (boundary n x) t))) = q (a v x t) |
| rw [diskTime_cons]; congr 2 |
| · intro v x |
| apply Prod.ext |
| · let s : Sphere (n+1) := ⟨_,cons_zero_mem_sphere x⟩ |
| have hs : s ∈ cylinderFace n (some false) := by |
| change (diskCons x 0).1 0 = -1; norm_num [diskCons] |
| change F (v,diskCons x 0) = q (b v x).1 |
| rw [show diskCons x 0 = boundary (n+1) s from rfl,hF] |
| change q (cylinderBoundaryMap (a v) (b v) (h v) s) = _ |
| rw [cylinderBoundaryMap_face (a v) (b v) (h v) (some false) ⟨s,hs⟩] |
| change q (b v (diskTail (diskCons x 0))).1 = q (b v x).1 |
| rw [diskTail_cons] |
| · let s : Sphere (n+1) := ⟨_,cons_one_mem_sphere x⟩ |
| have hs : s ∈ cylinderFace n (some true) := by |
| change (diskCons x 1).1 0 = 1; norm_num [diskCons] |
| change F (v,diskCons x 1) = q (b v x).2 |
| rw [show diskCons x 1 = boundary (n+1) s from rfl,hF] |
| change q (cylinderBoundaryMap (a v) (b v) (h v) s) = _ |
| rw [cylinderBoundaryMap_face (a v) (b v) (h v) (some true) ⟨s,hs⟩] |
| change q (b v (diskTail (diskCons x 1))).2 = q (b v x).2 |
| rw [diskTail_cons] |
| end |
|
|
| section |
| open Set Metric Topology |
| open scoped unitInterval |
| universe u v w |
| variable {X : Type u} [TopologicalSpace X] {Y : Type v} [TopologicalSpace Y] |
| {Z : Type w} [TopologicalSpace Z] |
| lemma family_square_filling {n : ℕ} (q : C(Y,Z)) (z : Z) (H : q.Homotopy (.const _ z)) |
| (a : C(X,C(Sphere n,C(I,C(I,Y))))) |
| (b c : C(X,C(Disk n,C(I,Y) × C(I,Y)))) |
| (hs : ∀ v x,pathEndpoint (a v x) = b v (boundary n x)) |
| (ht : ∀ v x s,pathEndpoint (a v x s) = ((c v (boundary n x)).1 s,(c v (boundary n x)).2 s)) |
| (h0 : ∀ v x,pathEndpoint ((b v x).1) = ((c v x).1 0,(c v x).2 0)) |
| (h1 : ∀ v x,pathEndpoint ((b v x).2) = ((c v x).1 1,(c v x).2 1)) : |
| ∃ e : C(X,C(Disk n,C(I,C(I,Z)))), |
| (∀ v x s t,e v (boundary n x) s t = q (a v x s t)) ∧ |
| (∀ v x t,e v x 0 t = q ((b v x).1 t)) ∧ |
| (∀ v x t,e v x 1 t = q ((b v x).2 t)) ∧ |
| (∀ v x s,e v x s 0 = q ((c v x).1 s)) ∧ |
| (∀ v x s,e v x s 1 = q ((c v x).2 s)) := by |
| let A : C(X,C(Sphere (n+1),C(I,Y))) := ContinuousMap.curry ⟨_,familyCylinder_continuous a b hs⟩ |
| let B : C(X,C(Disk (n+1),Y × Y)) := ContinuousMap.curry |
| ⟨fun p => ((c p.1 (diskTail p.2)).1 (diskTime p.2),(c p.1 (diskTail p.2)).2 (diskTime p.2)),by |
| have hc : Continuous (fun p : X × Disk (n+1) => c p.1 (diskTail p.2)) := |
| continuous_eval.comp ((c.continuous.comp continuous_fst).prodMk (continuous_diskTail.comp continuous_snd)) |
| exact (continuous_eval.comp ((continuous_fst.comp hc).prodMk (continuous_diskTime.comp continuous_snd))).prodMk |
| (continuous_eval.comp ((continuous_snd.comp hc).prodMk (continuous_diskTime.comp continuous_snd)))⟩ |
| have hAB : ∀ v x,pathEndpoint (A v x) = B v (boundary (n+1) x) := by |
| intro v x |
| rcases sphere_split x with hx|hx|hx |
| · have hx' : x ∈ cylinderFace n (some false) := hx |
| rw [show A v x = faceMap (a v) (b v) (some false) ⟨x,hx'⟩ from |
| cylinderBoundaryMap_face (a v) (b v) (hs v) (some false) ⟨x,hx'⟩] |
| change pathEndpoint ((b v (diskTail (boundary (n+1) x))).1) = |
| ((c v (diskTail (boundary (n+1) x))).1 (diskTime (boundary (n+1) x)), |
| (c v (diskTail (boundary (n+1) x))).2 (diskTime (boundary (n+1) x))) |
| rw [faceTime_eq_zero x hx]; exact h0 v _ |
| · have hx' : x ∈ cylinderFace n (some true) := hx |
| rw [show A v x = faceMap (a v) (b v) (some true) ⟨x,hx'⟩ from |
| cylinderBoundaryMap_face (a v) (b v) (hs v) (some true) ⟨x,hx'⟩] |
| change pathEndpoint ((b v (diskTail (boundary (n+1) x))).2) = |
| ((c v (diskTail (boundary (n+1) x))).1 (diskTime (boundary (n+1) x)), |
| (c v (diskTail (boundary (n+1) x))).2 (diskTime (boundary (n+1) x))) |
| rw [faceTime_eq_one x hx]; exact h1 v _ |
| · have hx' : x ∈ cylinderFace n none := hx |
| rw [show A v x = faceMap (a v) (b v) none ⟨x,hx'⟩ from |
| cylinderBoundaryMap_face (a v) (b v) (hs v) none ⟨x,hx'⟩] |
| exact ht v (faceSphere ⟨x,hx'⟩) (faceTime none ⟨x,hx'⟩) |
| obtain ⟨d,hd,hp⟩ := family_cylinder_filling q z H A B hAB |
| let e : C(X,C(Disk n,C(I,C(I,Z)))) := |
| (ContinuousMap.mk (fun p : (X × Disk n) × I => d p.1.1 (diskCons p.1.2 p.2)) |
| (continuous_eval.comp ((d.continuous.comp continuous_fst.fst).prodMk |
| (continuous_diskCons.comp (continuous_fst.snd.prodMk continuous_snd))))).curry.curry |
| refine ⟨e,?_,?_,?_,?_,?_⟩ |
| · intro v x s t |
| let z' : Sphere (n+1) := ⟨_,cons_mem_sphere_of_boundary x s⟩ |
| have hz : z' ∈ cylinderFace n none := by |
| change (diskTail (diskCons (boundary n x) s)).1 ∈ sphere 0 1 |
| rw [diskTail_cons]; exact x.2 |
| change d v (diskCons (boundary n x) s) t = q (a v x s t) |
| rw [show diskCons (boundary n x) s = boundary (n+1) z' from rfl,hd] |
| rw [show A v z' = faceMap (a v) (b v) none ⟨z',hz⟩ from |
| cylinderBoundaryMap_face (a v) (b v) (hs v) none ⟨z',hz⟩] |
| change q (a v (faceSphere ⟨z',hz⟩) (diskTime (diskCons (boundary n x) s)) t) = _ |
| rw [diskTime_cons]; congr 2 |
| · intro v x t |
| let z' : Sphere (n+1) := ⟨_,cons_zero_mem_sphere x⟩ |
| have hz : z' ∈ cylinderFace n (some false) := by |
| change (diskCons x 0).1 0 = -1; norm_num [diskCons] |
| change d v (diskCons x 0) t = q ((b v x).1 t) |
| rw [show diskCons x 0 = boundary (n+1) z' from rfl,hd] |
| rw [show A v z' = faceMap (a v) (b v) (some false) ⟨z',hz⟩ from |
| cylinderBoundaryMap_face (a v) (b v) (hs v) (some false) ⟨z',hz⟩] |
| change q ((b v (diskTail (diskCons x 0))).1 t) = _ |
| rw [diskTail_cons] |
| · intro v x t |
| let z' : Sphere (n+1) := ⟨_,cons_one_mem_sphere x⟩ |
| have hz : z' ∈ cylinderFace n (some true) := by |
| change (diskCons x 1).1 0 = 1; norm_num [diskCons] |
| change d v (diskCons x 1) t = q ((b v x).2 t) |
| rw [show diskCons x 1 = boundary (n+1) z' from rfl,hd] |
| rw [show A v z' = faceMap (a v) (b v) (some true) ⟨z',hz⟩ from |
| cylinderBoundaryMap_face (a v) (b v) (hs v) (some true) ⟨z',hz⟩] |
| change q ((b v (diskTail (diskCons x 1))).2 t) = _ |
| rw [diskTail_cons] |
| · intro v x s |
| have h := congrArg Prod.fst (hp v (diskCons x s)) |
| change d v (diskCons x s) 0 = _ |
| simpa only [pathEndpoint,ContinuousMap.coe_mk,B,ContinuousMap.curry_apply, |
| diskTail_cons,diskTime_cons] using h |
| · intro v x s |
| have h := congrArg Prod.snd (hp v (diskCons x s)) |
| change d v (diskCons x s) 1 = _ |
| simpa only [pathEndpoint,ContinuousMap.coe_mk,B,ContinuousMap.curry_apply, |
| diskTail_cons,diskTime_cons] using h |
|
|
| lemma SquareBoundary.fill_after_nullhomotopy (D : SquareBoundary X Y) |
| (q : C(Y,Z)) (z : Z) (H : q.Homotopy (.const _ z)) : |
| ∃ Q : C(X,C(I,C(I,Z))), |
| (∀ x t,Q x 0 t = q ((D.b x).1 t)) ∧ |
| (∀ x t,Q x 1 t = q ((D.b x).2 t)) ∧ |
| (∀ x s,Q x s 0 = q ((D.c x).1 s)) ∧ |
| (∀ x s,Q x s 1 = q ((D.c x).2 s)) := by |
| let : IsEmpty (Sphere 0) := ⟨fun x => by |
| have hx : x.1 = 0 := Subsingleton.elim _ _ |
| have h := x.2 |
| change ‖x.1‖ = 1 at h |
| rw [hx,norm_zero] at h |
| exact zero_ne_one h⟩ |
| let a : C(X,C(Sphere 0,C(I,C(I,Y)))) := .const _ ⟨isEmptyElim,continuous_of_discreteTopology⟩ |
| let b : C(X,C(Disk 0,C(I,Y) × C(I,Y))) := ContinuousMap.curry (D.b.comp .fst) |
| let c : C(X,C(Disk 0,C(I,Y) × C(I,Y))) := ContinuousMap.curry (D.c.comp .fst) |
| obtain ⟨e,_,h0,h1,h2,h3⟩ := family_square_filling q z H a b c (fun _ x => isEmptyElim x) |
| (fun _ x => isEmptyElim x) (fun x _ => D.zero x) (fun x _ => D.one x) |
| let x0 : Disk 0 := ⟨0,by simp⟩ |
| exact ⟨⟨fun x => e x x0,(continuous_eval_const x0).comp e.continuous⟩, |
| fun x t => h0 x x0 t,fun x t => h1 x x0 t,fun x s => h2 x x0 s,fun x s => h3 x x0 s⟩ |
| end |
|
|
| open Set Topology |
| open scoped unitInterval |
| universe u v w |
| variable {X : Type u} [TopologicalSpace X] {Y : Type v} [TopologicalSpace Y] |
| {Z : Type w} [TopologicalSpace Z] |
| variable (a b : C(I × X,Y)) (A B : Y) |
| variable (h0 : ∀ x,a (0,x) = b (0,x)) (ha : ∀ x,a (1,x) = A) (hb : ∀ x,b (1,x) = B) |
|
|
| def contractionPath (a : C(I × X,Y)) (A : Y) (ha : ∀ x,a (1,x) = A) (x : X) : Path (a (0,x)) A := |
| { toFun t := a (t,x) |
| continuous_toFun := a.continuous.comp (continuous_id.prodMk continuous_const) |
| source' := rfl |
| target' := ha x } |
|
|
| def connectorTop (x : X) : Path A B := |
| (contractionPath a A ha x).symm.trans ((contractionPath b B hb x).cast (h0 x) rfl) |
|
|
| def connectorSquare (x0 : X) : SquareBoundary X Y where |
| b := (ContinuousMap.curry ((a.comp ⟨fun x => (0,x),continuous_const.prodMk continuous_id⟩).comp .fst)).prodMk |
| (.const _ (connectorTop a b A B h0 ha hb x0).toContinuousMap) |
| c := (ContinuousMap.curry (a.comp ⟨Prod.swap,continuous_swap⟩)).prodMk |
| (ContinuousMap.curry (b.comp ⟨Prod.swap,continuous_swap⟩)) |
| zero x := Prod.ext rfl (h0 x) |
| one x := Prod.ext ((connectorTop a b A B h0 ha hb x0).source.trans (ha x).symm) |
| ((connectorTop a b A B h0 ha hb x0).target.trans (hb x).symm) |
|
|
| include h0 ha hb in |
|
|
| lemma connector_after_nullhomotopy (x0 : X) (q : C(Y,Z)) (z : Z) |
| (H : q.Homotopy (.const _ z)) : |
| ∃ (P : Path A B) (Q : C(X,C(I,C(I,Z)))), |
| (∀ x t,Q x 0 t = q (a (0,x))) ∧ |
| (∀ x t,Q x 1 t = q (P t)) ∧ |
| (∀ x s,Q x s 0 = q (a (s,x))) ∧ |
| (∀ x s,Q x s 1 = q (b (s,x))) := by |
| obtain ⟨Q,hQ0,hQ1,hQ2,hQ3⟩ := (connectorSquare a b A B h0 ha hb x0).fill_after_nullhomotopy q z H |
| exact ⟨connectorTop a b A B h0 ha hb x0,Q,hQ0,hQ1,hQ2,hQ3⟩ |
| end UniversalFInfinity.Cellular |
|
|
| end |
|
|
| end OAI |
|
|
